Make creation of list literal more resilient to changes in the underlying

runtime/vm/parser.cc

 // Copyright (c) 2012, 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 1340 matching lines @@
     const String& function_name,
     const ArgumentListNode& function_args) {
   const intptr_t args_pos = function_args.token_pos();
   // Build arguments to the call to the static
   // InvocationMirror._allocateInvocationMirror method.
   ArgumentListNode* arguments = new ArgumentListNode(args_pos);
   // The first argument is the original function name.
   arguments->Add(new LiteralNode(args_pos, function_name));
   // The second argument is an array containing the original function arguments.
   ArrayNode* args_array = new ArrayNode(
-      args_pos, Type::ZoneHandle(Type::ListInterface()));
+      args_pos, Type::ZoneHandle(Type::ArrayType()));
   for (intptr_t i = 1; i < function_args.length(); i++) {
     args_array->AddElement(function_args.NodeAt(i));
   }
   arguments->Add(args_array);
   // Lookup the static InvocationMirror._allocateInvocationMirror method.
   const Class& mirror_class = Class::Handle(
       LookupCoreClass(String::Handle(Symbols::InvocationMirror())));
   ASSERT(!mirror_class.IsNull());
   const String& allocation_function_name =
       String::Handle(Symbols::AllocateInvocationMirror());
@@ skipping 7328 matching lines @@
                "a list literal takes one type argument specifying "
                "the element type");
     }
     if (is_const && !element_type.IsInstantiated()) {
       ErrorMsg(type_pos,
                "the type argument of a constant list literal cannot include "
                "a type variable");
     }
   }
   ASSERT(type_arguments.IsNull() || (type_arguments.Length() == 1));
-  const Class& list_class = Class::Handle(
-      Type::Handle(Type::ListInterface()).type_class());
+  const Class& array_class = Class::Handle(
+      Type::Handle(Type::ArrayType()).type_class());

[siva, 2012/11/16 02:24:50]

Why not just do
const Class& array_class = Class::Handle(
  Isolate::Current()->object_store()->array_class());

or if you had the helper method it would be
const Class& array_class = Class::Handle(Class::ListClass());

[regis, 2012/11/20 19:37:33]

The ListClass helper would be the wrong one here, since we want the class of
Array, not of List. I changed the code according to your first suggestion (in a
follow-up cl).

   Type& type = Type::ZoneHandle(
-      Type::New(list_class, type_arguments, type_pos));
+      Type::New(array_class, type_arguments, type_pos));
   type ^= ClassFinalizer::FinalizeType(
       current_class(), type, ClassFinalizer::kCanonicalize);
   ArrayNode* list = new ArrayNode(TokenPos(), type);
 
   // Parse the list elements. Note: there may be an optional extra
   // comma after the last element.
   if (!is_empty_literal) {
     const bool saved_mode = SetAllowFunctionLiterals(true);
     const String& dst_name = String::ZoneHandle(Symbols::ListLiteralElement());
     while (CurrentToken() != Token::kRBRACK) {
@@ skipping 45 matching lines @@
                    String::Handle(element_type.UserVisibleName()).ToCString());
         }
       }
       const_list.SetAt(i, elem->AsLiteralNode()->literal());
     }
     const_list ^= const_list.Canonicalize();
     const_list.MakeImmutable();
     return new LiteralNode(literal_pos, const_list);
   } else {
     // Factory call at runtime.
-    String& list_class_name = String::Handle(Symbols::ListImplementation());
-    const Class& list_class = Class::Handle(LookupCoreClass(list_class_name));
-    ASSERT(!list_class.IsNull());
-    const String& list_literal_factory_name =
+    // TODO(regis): Once _ListImpl is removed, use Symbols::List() instead of
+    // Symbols::ListImplementation() on the following line.
+    String& factory_class_name = String::Handle(Symbols::ListImplementation());
+    const Class& factory_class =
+        Class::Handle(LookupCoreClass(factory_class_name));
+    ASSERT(!factory_class.IsNull());
+    const String& factory_method_name =
         String::Handle(Symbols::ListLiteralFactory());
-    const Function& list_literal_factory = Function::ZoneHandle(
-        list_class.LookupFactory(list_literal_factory_name));
-    ASSERT(!list_literal_factory.IsNull());
+    const Function& factory_method = Function::ZoneHandle(
+        factory_class.LookupFactory(factory_method_name));
+    ASSERT(!factory_method.IsNull());
     if (!type_arguments.IsNull() &&
         !type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureInstantiator();
     }
+    AbstractTypeArguments& factory_type_args =
+        AbstractTypeArguments::ZoneHandle(type_arguments.raw());
+    // If the factory class extends other parameterized classes, adjust the
+    // type argument vector.
+    if (!factory_type_args.IsNull() && (factory_class.NumTypeArguments() > 1)) {
+      ASSERT(factory_type_args.Length() == 1);
+      Type& factory_type = Type::Handle(Type::New(
+          factory_class, factory_type_args, type_pos, Heap::kNew));
+      factory_type ^= ClassFinalizer::FinalizeType(
+          current_class(), factory_type, ClassFinalizer::kFinalize);
+      factory_type_args = factory_type.arguments();
+      ASSERT(factory_type_args.Length() == factory_class.NumTypeArguments());
+    }
+    factory_type_args = factory_type_args.Canonicalize();
     ArgumentListNode* factory_param = new ArgumentListNode(literal_pos);
     factory_param->Add(list);
-    AbstractTypeArguments& canonical_type_arguments =
-        AbstractTypeArguments::ZoneHandle(type_arguments.Canonicalize());
     return CreateConstructorCallNode(literal_pos,
-                                     canonical_type_arguments,
-                                     list_literal_factory,
+                                     factory_type_args,
+                                     factory_method,
                                      factory_param);
   }
 }
 
 
 ConstructorCallNode* Parser::CreateConstructorCallNode(
     intptr_t token_pos,
     const AbstractTypeArguments& type_arguments,
     const Function& constructor,
     ArgumentListNode* arguments) {
@@ skipping 80 matching lines @@
       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();
 
   // The kv_pair array is temporary and of element type dynamic. It is passed
   // to the factory to initialize a properly typed map.
-  ArrayNode* kv_pairs =
-      new ArrayNode(TokenPos(), Type::ZoneHandle(Type::ListInterface()));
+  ArrayNode* kv_pairs = new ArrayNode(
+      TokenPos(), Type::ZoneHandle(Type::ArrayType()));
 
   // Parse the map entries. Note: there may be an optional extra
   // comma after the last entry.
   const String& dst_name = String::ZoneHandle(Symbols::ListLiteralElement());
   while (CurrentToken() != Token::kRBRACE) {
     AstNode* key = NULL;
     if (CurrentToken() == Token::kSTRING) {
       key = ParseStringLiteral();
     }
     if (key == NULL) {
@@ skipping 59 matching lines @@
     }
     key_value_array ^= key_value_array.Canonicalize();
     key_value_array.MakeImmutable();
 
     // Construct the map object.
     const String& immutable_map_class_name =
         String::Handle(Symbols::ImmutableMap());
     const Class& immutable_map_class =
         Class::Handle(LookupCoreClass(immutable_map_class_name));
     ASSERT(!immutable_map_class.IsNull());
+    // If the immutable map class extends other parameterized classes, we need
+    // to adjust the type argument vector. This is currently not the case.
+    ASSERT(immutable_map_class.NumTypeArguments() == 2);
     ArgumentListNode* constr_args = new ArgumentListNode(TokenPos());
     constr_args->Add(new LiteralNode(literal_pos, key_value_array));
     const String& constr_name =
         String::Handle(Symbols::ImmutableMapConstructor());
     const Function& map_constr = Function::ZoneHandle(
         immutable_map_class.LookupConstructor(constr_name));
     ASSERT(!map_constr.IsNull());
     const Object& constructor_result = Object::Handle(
         EvaluateConstConstructorCall(immutable_map_class,
                                      map_type_arguments,
                                      map_constr,
                                      constr_args));
     if (constructor_result.IsUnhandledException()) {
       return GenerateRethrow(literal_pos, constructor_result);
     } else {
       const Instance& const_instance = Instance::Cast(constructor_result);
       return new LiteralNode(literal_pos,
                              Instance::ZoneHandle(const_instance.raw()));
     }
   } else {
     // Factory call at runtime.
-    String& map_class_name = String::Handle(Symbols::MapImplementation());
-    const Class& map_class = Class::Handle(LookupCoreClass(map_class_name));
-    ASSERT(!map_class.IsNull());
-    const String& map_literal_factory_name =
+    String& factory_class_name = String::Handle(Symbols::MapImplementation());
+    const Class& factory_class =
+        Class::Handle(LookupCoreClass(factory_class_name));
+    ASSERT(!factory_class.IsNull());
+    const String& factory_method_name =
         String::Handle(Symbols::MapLiteralFactory());
-    const Function& map_literal_factory = Function::ZoneHandle(
-        map_class.LookupFactory(map_literal_factory_name));
-    ASSERT(!map_literal_factory.IsNull());
+    const Function& factory_method = Function::ZoneHandle(
+        factory_class.LookupFactory(factory_method_name));
+    ASSERT(!factory_method.IsNull());
     if (!map_type_arguments.IsNull() &&
         !map_type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureInstantiator();
     }
+    AbstractTypeArguments& factory_type_args =
+        AbstractTypeArguments::ZoneHandle(map_type_arguments.raw());
+    // If the factory class extends other parameterized classes, adjust the
+    // type argument vector.
+    if (!factory_type_args.IsNull() && (factory_class.NumTypeArguments() > 2)) {
+      ASSERT(factory_type_args.Length() == 2);
+      Type& factory_type = Type::Handle(Type::New(
+          factory_class, factory_type_args, type_pos, Heap::kNew));
+      factory_type ^= ClassFinalizer::FinalizeType(
+          current_class(), factory_type, ClassFinalizer::kFinalize);
+      factory_type_args = factory_type.arguments();
+      ASSERT(factory_type_args.Length() == factory_class.NumTypeArguments());
+    }
+    factory_type_args = factory_type_args.Canonicalize();
     ArgumentListNode* factory_param = new ArgumentListNode(literal_pos);
     factory_param->Add(kv_pairs);
     return CreateConstructorCallNode(literal_pos,
-                                     map_type_arguments,
-                                     map_literal_factory,
+                                     factory_type_args,
+                                     factory_method,
                                      factory_param);
   }
 }
 
 
 AstNode* Parser::ParseCompoundLiteral() {
   TRACE_PARSER("ParseCompoundLiteral");
   bool is_const = false;
   if (CurrentToken() == Token::kCONST) {
     is_const = true;
@@ skipping 431 matching lines @@
   if ((l1_token != Token::kSTRING) &&
       (l1_token != Token::kINTERPOL_VAR) &&
       (l1_token != Token::kINTERPOL_START)) {
     // Common case: no interpolation.
     primary = new LiteralNode(literal_start, *CurrentLiteral());
     ConsumeToken();
     return primary;
   }
   // String interpolation needed.
   bool is_compiletime_const = true;
-  ArrayNode* values = new ArrayNode(TokenPos(),
-                                    Type::ZoneHandle(Type::ListInterface()));
+  ArrayNode* values = new ArrayNode(
+      TokenPos(), Type::ZoneHandle(Type::ArrayType()));
   while (CurrentToken() == Token::kSTRING) {
     values->AddElement(new LiteralNode(TokenPos(), *CurrentLiteral()));
     ConsumeToken();
     while ((CurrentToken() == Token::kINTERPOL_VAR) ||
         (CurrentToken() == Token::kINTERPOL_START)) {
       AstNode* expr = NULL;
       const intptr_t expr_pos = TokenPos();
       if (CurrentToken() == Token::kINTERPOL_VAR) {
         expr = ResolveIdent(TokenPos(), *CurrentLiteral(), true);
         ConsumeToken();
@@ skipping 57 matching lines @@
   OS::SNPrint(name, 64, "%s_%"Pd"",
               Symbols::Name(Symbols::kSavedArgDescVarPrefix),
               owner_function.token_pos());
   const String& saved_args_desc_name = String::ZoneHandle(Symbols::New(name));
   LocalVariable* saved_args_desc_var = LookupLocalScope(saved_args_desc_name);
   if (saved_args_desc_var == NULL) {
     ASSERT(owner_scope != NULL);
     saved_args_desc_var =
         new LocalVariable(owner_function.token_pos(),
                           saved_args_desc_name,
-                          Type::ZoneHandle(Type::ListInterface()));
+                          Type::ZoneHandle(Type::ArrayType()));
     saved_args_desc_var->set_is_final();
     // The saved arguments descriptor variable must be added just after the
     // formal parameters. This simplifies the 2-step saving of a captured
     // arguments descriptor.
     // At this time, the owner scope should only contain formal parameters.
     ASSERT(owner_scope->num_variables() == owner_function.NumParameters());
     bool success = owner_scope->AddVariable(saved_args_desc_var);
     ASSERT(success);
     // Capture the saved argument descriptor variable if necessary.
     LocalVariable* local = LookupLocalScope(saved_args_desc_name);
@@ skipping 449 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart