Canonicalize TypeArguments.

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 68 matching lines @@
   Array& a = Array::Handle(Array::New(objs.length(), Heap::kOld));
   for (int i = 0; i < objs.length(); i++) {
     a.SetAt(i, *objs[i]);
   }
   return a.raw();
 }
 
 
 static RawTypeArguments* NewTypeArguments(
     const GrowableArray<AbstractType*>& objs) {
-  TypeArguments& a = TypeArguments::Handle(TypeArguments::New(objs.length()));
+  const TypeArguments& a =
+      TypeArguments::Handle(TypeArguments::New(objs.length()));
   for (int i = 0; i < objs.length(); i++) {
     a.SetTypeAt(i, *objs[i]);
   }
+  // Cannot canonicalize TypeArgument yet as its types may not have been
+  // finalized yet.
   return a.raw();
 }
 
 
 static ThrowNode* CreateEvalConstConstructorThrow(intptr_t token_pos,
                                                   const Instance& instance) {
   UnhandledException& excp = UnhandledException::Handle();
   excp ^= instance.raw();
   const Instance& exception = Instance::ZoneHandle(excp.exception());
   const Instance& stack_trace = Instance::ZoneHandle(excp.stacktrace());
@@ skipping 6628 matching lines @@
         literal_factory_class.LookupFactory(literal_list_factory_name));
     ASSERT(!literal_list_factory.IsNull());
     if (!type_arguments.IsNull() &&
         !type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureReceiver();
     }
     ArgumentListNode* factory_param = new ArgumentListNode(literal_pos);
     factory_param->Add(list);
-    return new ConstructorCallNode(
-        literal_pos, type_arguments, literal_list_factory, factory_param);
+    AbstractTypeArguments& canonical_type_arguments =
+        AbstractTypeArguments::ZoneHandle(type_arguments.Canonicalize());
+    return new ConstructorCallNode(literal_pos,
+                                   canonical_type_arguments,
+                                   literal_list_factory,
+                                   factory_param);
   }
 }
 
 
 static void AddKeyValuePair(ArrayNode* pairs,
                             bool is_const,
                             AstNode* key,
                             AstNode* value) {
   if (is_const) {
     ASSERT(key->IsLiteralNode());
@@ skipping 56 matching lines @@
       type_array.SetTypeAt(1, value_type);
       map_type_arguments = type_array.raw();
     }
     if (is_const && !value_type.IsInstantiated()) {
       ErrorMsg(type_pos,
                "the type argument of a constant map literal cannot include "
                "a type variable");
     }
   }
   ASSERT(map_type_arguments.IsNull() || (map_type_arguments.Length() == 2));
+  map_type_arguments ^= map_type_arguments.Canonicalize();
 
   // Parse the map entries. Note: there may be an optional extra
   // comma after the last entry.
   ArrayNode* kv_pairs =
       new ArrayNode(token_index_, TypeArguments::ZoneHandle());
   const String& dst_name = String::ZoneHandle(
       String::NewSymbol("list literal element"));
   while (CurrentToken() != Token::kRBRACE) {
     AstNode* key = NULL;
     if (CurrentToken() == Token::kSTRING) {
@@ skipping 100 matching lines @@
         literal_factory_class.LookupFactory(literal_map_factory_name));
     ASSERT(!literal_map_factory.IsNull());
     if (!map_type_arguments.IsNull() &&
         !map_type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureReceiver();
     }
     ArgumentListNode* factory_param = new ArgumentListNode(literal_pos);
     factory_param->Add(kv_pairs);
-    return new ConstructorCallNode(
-        literal_pos, map_type_arguments, literal_map_factory, factory_param);
+    return new ConstructorCallNode(literal_pos,
+                                   map_type_arguments,
+                                   literal_map_factory,
+                                   factory_param);
   }
 }
 
 
 AstNode* Parser::ParseCompoundLiteral() {
   bool is_const = false;
   if (CurrentToken() == Token::kCONST) {
     is_const = true;
     ConsumeToken();
   }
@@ skipping 186 matching lines @@
     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();
   }
 
+  type_arguments ^= type_arguments.Canonicalize();
   // Make the constructor call.
   AstNode* new_object = NULL;
   if (is_const) {
     if (!constructor.is_const()) {
       ErrorMsg("'const' requires const constructor: '%s'",
           String::Handle(constructor.name()).ToCString());
     }
     const Instance& const_instance = Instance::ZoneHandle(
         EvaluateConstConstructorCall(type_class,
                                      type_arguments,
@@ skipping 450 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart