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 47 matching lines @@
                  "the key type of a map literal is implicitly 'String'");
       }
       Warning(type_pos,
               "a map literal takes one type argument specifying "
               "the value type");
       value_type = map_type_arguments.TypeAt(1);
     } else {
       TypeArguments& type_array = TypeArguments::Handle(TypeArguments::New(2));
       type_array.SetTypeAt(0, Type::Handle(Type::StringInterface()));
       type_array.SetTypeAt(1, value_type);
-      map_type_arguments = type_array.raw();
+      map_type_arguments = type_array.Canonicalize();

[regis, 2011/12/05 23:16:35]

Is this necessary? You canonicalize below as well.

[srdjan, 2011/12/06 17:24:15]

Removed, doing it later

     }
     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));

[srdjan, 2011/12/06 17:24:15]

Canonicalizing it here,

 
   // 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 72 matching lines @@
     ASSERT(!immutable_map_class.IsNull());
     ArgumentListNode* constr_args = new ArgumentListNode(token_index_);
     constr_args->Add(new LiteralNode(literal_pos, key_value_array));
     const String& constr_name =
         String::Handle(String::NewSymbol(kImmutableMapConstructorName));
     const Function& map_constr = Function::ZoneHandle(
         immutable_map_class.LookupConstructor(constr_name));
     ASSERT(!map_constr.IsNull());
     const Instance& const_instance = Instance::ZoneHandle(
         EvaluateConstConstructorCall(immutable_map_class,
                                      map_type_arguments,

[regis, 2011/12/05 23:16:35]

Why not canonicalize here as well?

[srdjan, 2011/12/06 17:24:15]

Done it above

                                      map_constr,
                                      constr_args));
     if (const_instance.IsUnhandledException()) {
       return CreateEvalConstConstructorThrow(literal_pos, const_instance);
     } else {
       return new LiteralNode(literal_pos, const_instance);
     }
   } else {
     // Factory call at runtime.
     String& literal_factory_class_name = String::Handle(
         String::NewSymbol(kLiteralFactoryClassName));
     const Class& literal_factory_class =
         Class::Handle(LookupCoreClass(literal_factory_class_name));
     ASSERT(!literal_factory_class.IsNull());
     const String& literal_map_factory_name =
         String::Handle(String::NewSymbol(kLiteralFactoryMapFromLiteralName));
     const Function& literal_map_factory = Function::ZoneHandle(
         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);
+    AbstractTypeArguments& canonical_map_type_arguments =
+        AbstractTypeArguments::ZoneHandle(map_type_arguments.Canonicalize());

[srdjan, 2011/12/06 17:24:15]

Reverted this.

+    return new ConstructorCallNode(literal_pos,
+                                   canonical_map_type_arguments,
+                                   literal_map_factory,
+                                   factory_param);
   }
 }
 
 
 AstNode* Parser::ParseCompoundLiteral() {
   bool is_const = false;
   if (CurrentToken() == Token::kCONST) {
     is_const = true;
     ConsumeToken();
   }
@@ skipping 195 matching lines @@
 
   // 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,

[regis, 2011/12/05 23:16:35]

ditto

[srdjan, 2011/12/06 17:24:15]

Done by moving canonicalization before if (is_const)

                                      constructor,
                                      arguments));
     if (const_instance.IsUnhandledException()) {
       new_object = CreateEvalConstConstructorThrow(new_pos, const_instance);
     } else {
       new_object = new LiteralNode(new_pos, const_instance);
     }
   } else {
     CheckFunctionIsCallable(new_pos, constructor);
     CheckConstructorCallTypeArguments(new_pos, constructor, type_arguments);
     if (!type_arguments.IsNull() &&
         !type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureReceiver();
     }
+    AbstractTypeArguments& canonical_type_arguments =
+        AbstractTypeArguments::ZoneHandle(type_arguments.Canonicalize());
     new_object = new ConstructorCallNode(
-        new_pos, type_arguments, constructor, arguments);
+        new_pos, canonical_type_arguments, constructor, arguments);
   }
   return new_object;
 }
 
 
 // A string literal consists of the concatenation of the next n tokens
 // that satisfy the EBNF grammar:
 // literal = kSTRING {{ interpol }+ kSTRING }
 // interpol = kINTERPOL_VAR | (kINTERPOL_START expression kINTERPOL_END)
 // In other words, the scanner breaks down interpolated strings so that
@@ skipping 422 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart