Canonicalize types.

runtime/vm/parser.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 860 matching lines @@
       if (signature_class.IsNull()) {
         signature_class = Class::NewSignatureClass(signature,
                                                    signature_function,
                                                    script_);
         // Record the function signature class in the current library.
         library_.AddClass(signature_class);
       } else {
         signature_function.set_signature_class(signature_class);
       }
       ASSERT(signature_function.signature_class() == signature_class.raw());
-      // The type of the parameter is now the signature type.
-      parameter.type = &Type::ZoneHandle(signature_class.SignatureType());
-      if (!is_top_level_ && !parameter.type->IsFinalized()) {
-        const String& errmsg = String::Handle(
-            ClassFinalizer::FinalizeTypeWhileParsing(*parameter.type));
+      Type& signature_type = Type::ZoneHandle(signature_class.SignatureType());
+      if (!is_top_level_ && !signature_type.IsFinalized()) {
+        String& errmsg = String::Handle();
+        signature_type =
+            ClassFinalizer::FinalizeAndCanonicalizeType(signature_type,
+                                                        &errmsg);
         if (!errmsg.IsNull()) {
           ErrorMsg(errmsg.ToCString());
         }
       }
+      // The type of the parameter is now the signature type.
+      parameter.type = &signature_type;
     }
   }
 
   if (CurrentToken() == Token::kASSIGN) {
     if (!params->has_named_optional_parameters ||
         !allow_explicit_default_value) {
       ErrorMsg("parameter must not specify a default value");
     }
     ConsumeToken();
     params->num_optional_parameters++;
@@ skipping 2537 matching lines @@
   // Make sure that the instantiator is captured.
   if ((signature_class.NumTypeParameters() > 0) &&
       (current_block_->scope->function_level() > 0)) {
     CaptureReceiver();
   }
 
   if (variable_name != NULL) {
     // Patch the function type now that the signature is known.
     // We need to create a new type for proper finalization, since the existing
     // type is already marked as finalized.
-    const Type& signature_type = Type::Handle(signature_class.SignatureType());
+    Type& signature_type = Type::Handle(signature_class.SignatureType());
     const TypeArguments& signature_type_arguments = TypeArguments::Handle(
         signature_type.arguments());
 
     // Since the signature type is cached by the signature class, it may have
     // been finalized already.
     if (!signature_type.IsFinalized()) {
-      const String& errmsg = String::Handle(
-          ClassFinalizer::FinalizeTypeWhileParsing(signature_type));
+      String& errmsg = String::Handle();
+      signature_type =
+          ClassFinalizer::FinalizeAndCanonicalizeType(signature_type, &errmsg);
       if (!errmsg.IsNull()) {
         ErrorMsg(errmsg.ToCString());
       }
       // The call to ClassFinalizer::FinalizeTypeWhileParsing may have extended
       // the vector of type arguments.
       ASSERT(signature_type_arguments.IsNull() ||
              (signature_type_arguments.Length() ==
               signature_class.NumTypeArguments()));
       // The signature_class should not have changed.
       ASSERT(signature_type.type_class() == signature_class.raw());
@@ skipping 2653 matching lines @@
                    String::Handle(type_parameter.Name()).ToCString());
         }
         return type_parameter.raw();
       }
     }
     // Try to resolve the type class.
     type_class = LookupTypeClass(type_name, type_resolution);
   }
   TypeArguments& type_arguments =
       TypeArguments::Handle(ParseTypeArguments(type_resolution));
-  const Type& type = Type::Handle(
+  Type& type = Type::Handle(
       Type::NewParameterizedType(type_class, type_arguments));
   if (type_resolution == kMustResolve) {
     ASSERT(type_class.IsClass());  // Must be resolved.
-    const String& errmsg = String::Handle(
-        ClassFinalizer::FinalizeTypeWhileParsing(type));
+    String& errmsg = String::Handle();
+    type = ClassFinalizer::FinalizeAndCanonicalizeType(type, &errmsg);
     if (!errmsg.IsNull()) {
       ErrorMsg(errmsg.ToCString());
     }
   }
   return type.raw();
 }
 
 
 // Parse "[" [ expr { "," expr } ["," ] "]".
 // Note: if the array literal is empty and the brackets have no whitespace
@@ skipping 305 matching lines @@
     CheckTypeParameterReference(type_name.ident_pos, *type_name.ident);
     ErrorMsg(type_pos, "type parameter '%s' cannot be instantiated",
              String::Handle(type_parameter.Name()).ToCString());
   }
   type_class ^= LookupTypeClass(type_name, kMustResolve);
   type_class_name = type_class.Name();
   // Type arguments are not allowed after the optional constructor name.
   if (named_constructor == NULL) {
     type_arguments = ParseTypeArguments(kMustResolve);
     type = Type::NewParameterizedType(type_class, type_arguments);
-    const String& errmsg = String::Handle(
-        ClassFinalizer::FinalizeTypeWhileParsing(type));
+    String& errmsg = String::Handle();
+    type = ClassFinalizer::FinalizeAndCanonicalizeType(type, &errmsg);
     if (!errmsg.IsNull()) {
       ErrorMsg(errmsg.ToCString());
     }
     // The type argument vector may have been expanded with the type arguments
     // of the super type when finalizing the type.
     type_arguments = type.arguments();
   }
   if ((named_constructor == NULL) && (CurrentToken() == Token::kPERIOD)) {
     ConsumeToken();
     named_constructor = ExpectIdentifier("name of constructor expected");
@@ skipping 546 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart