Implement type checking of list literals (issue 220).

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"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
 #include "vm/growable_array.h"
 #include "vm/longjump.h"
 #include "vm/native_entry.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/resolver.h"
 #include "vm/scopes.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, enable_asserts, false, "Enable assert statements.");
 DEFINE_FLAG(bool, enable_type_checks, false, "Enable type checks.");
 DEFINE_FLAG(bool, trace_parser, false, "Trace parser operations.");
 DEFINE_FLAG(bool, warning_as_error, false, "Treat warnings as errors.");
 DEFINE_FLAG(bool, silent_warnings, false, "Silence warnings.");
-DECLARE_FLAG(bool, expose_core_impl);
 
 // All references to Dart names are listed here.
 static const char* kAssertionErrorName = "AssertionError";
 static const char* kFallThroughErrorName = "FallThroughError";
 static const char* kThrowNewName = "_throwNew";
-static const char* kGrowableObjectArrayFromArrayName =
-    "GrowableObjectArray._usingArray";
-static const char* kGrowableObjectArrayName = "GrowableObjectArray";
-static const char* kLiteralMapFactoryName = "_LiteralMapFactory";
-static const char* kLiteralMapFactoryFromLiteralName = "Map.fromLiteral";
+static const char* kLiteralFactoryClassName = "_LiteralFactory";
+static const char* kLiteralFactoryListFromLiteralName = "List.fromLiteral";
+static const char* kLiteralFactoryMapFromLiteralName = "Map.fromLiteral";
 static const char* kImmutableMapName = "ImmutableMap";
 static const char* kImmutableMapConstructorName = "ImmutableMap.";
 static const char* kStringClassName = "StringBase";
 static const char* kInterpolateName = "_interpolate";
 static const char* kThisName = "this";
 static const char* kPhaseParameterName = ":phase";
 static const char* kGetIteratorName = "iterator";
 
 #if defined(DEBUG)
 
@@ skipping 4379 matching lines @@
 static RawClass* LookupImplClass(const String& class_name) {
   return Library::Handle(Library::CoreImplLibrary()).LookupClass(class_name);
 }
 
 
 // Lookup class in the corelib which also contains various VM
 // helper methods and classes. Allow look up of private classes.
 static RawClass* LookupCoreClass(const String& class_name) {
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   String& name = String::Handle(class_name.raw());
-  if ((class_name.CharAt(0) == Scanner::kPrivateIdentifierStart) &&
-      !FLAG_expose_core_impl) {
+  if (class_name.CharAt(0) == Scanner::kPrivateIdentifierStart) {
     // Private identifiers are mangled on a per script basis.
     name = String::Concat(name, String::Handle(core_lib.private_key()));
     name = String::NewSymbol(name);
   }
   return core_lib.LookupClass(name);
 }
 
 
 RawClass* Parser::LookupClass(const String& class_name) {
   return library_.LookupClass(class_name);
@@ skipping 2126 matching lines @@
     // Do not report the expected vs. actual number of type arguments, because
     // the type argument vector is flattened and raw types are allowed.
     if (type_arguments.Length() != signature_class.NumTypeArguments()) {
       ErrorMsg(pos, "wrong number of type arguments passed to constructor");
     }
   }
 }
 
 
 // Parse "[" [ expr { "," expr } ["," ] "]".
-// Note: if the array literal is empty and the brackets have no whitespace
+// Note: if the list literal is empty and the brackets have no whitespace
 // between them, the scanner recognizes the opening and closing bracket
 // as one token of type Token::kINDEX.
-AstNode* Parser::ParseArrayLiteral(intptr_t type_pos,
-                                   bool is_const,
-                                   const TypeArguments& type_arguments) {
+AstNode* Parser::ParseListLiteral(intptr_t type_pos,
+                                  bool is_const,
+                                  const TypeArguments& type_arguments) {
+  TRACE_PARSER("ParseListLiteral");
+  ASSERT(type_pos >= 0);
   ASSERT(CurrentToken() == Token::kLBRACK || CurrentToken() == Token::kINDEX);
   const intptr_t literal_pos = token_index_;
   bool is_empty_literal = CurrentToken() == Token::kINDEX;
   ConsumeToken();
 
-  // If no type arguments are provided, leave them as null, which is equivalent
-  // to using Array<Dynamic>. See issue 4966724.
+  Type& element_type = Type::Handle(Type::DynamicType());
+  // If no type argument vector is provided, leave it as null, which is
+  // equivalent to using Dynamic as the type argument for the element type.
   if (!type_arguments.IsNull()) {
-    // For now, only check the number of type arguments. See issue 4975876.
+    ASSERT(type_arguments.Length() > 0);
+    // List literals take a single type argument.
+    element_type = type_arguments.TypeAt(0);
     if (type_arguments.Length() != 1) {
-      ASSERT(type_pos >= 0);
-      ErrorMsg(type_pos, "wrong number of type arguments for Array literal");
+      ErrorMsg(type_pos,
+               "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));
 
-  // Parse the array elements. Note: there may be an optional extra
+  // Parse the list elements. Note: there may be an optional extra
   // comma after the last element.
-  ArrayNode* array = new ArrayNode(token_index_, type_arguments);
+  ArrayNode* list = new ArrayNode(token_index_, TypeArguments::ZoneHandle());
   if (!is_empty_literal) {
     const bool saved_mode = SetAllowFunctionLiterals(true);
     while (CurrentToken() != Token::kRBRACK) {
-      array->AddElement(ParseExpr(is_const));
+      list->AddElement(ParseExpr(is_const));
       if (CurrentToken() == Token::kCOMMA) {
         ConsumeToken();
       } else if (CurrentToken() != Token::kRBRACK) {
         ErrorMsg("comma or ']' expected");
       }
     }
     ExpectToken(Token::kRBRACK);
     SetAllowFunctionLiterals(saved_mode);
   }
 
   if (is_const) {
-    // Allocate and initialize the array at compile time.
-    Array& lit_array =
-        Array::ZoneHandle(Array::New(array->length(), Heap::kOld));
-    if (!type_arguments.IsNull()) {
-      // TODO(regis): Where should we check the constraints on type parameters?
-      if (!type_arguments.IsInstantiated()) {
-        ErrorMsg("type must be constant in const constructor");
-      }
-      lit_array.SetTypeArguments(type_arguments);
-    }
+    // Allocate and initialize the const list at compile time.
+    Array& const_list =
+        Array::ZoneHandle(Array::New(list->length(), Heap::kOld));
+    const_list.SetTypeArguments(type_arguments);
 
-    for (int i = 0; i < array->length(); i++) {
-      AstNode* elem = array->ElementAt(i);
+    for (int i = 0; i < list->length(); i++) {
+      AstNode* elem = list->ElementAt(i);
       // Arguments have been evaluated to a literal value already.
       ASSERT(elem->IsLiteralNode());
-      lit_array.SetAt(i, elem->AsLiteralNode()->literal());
+      if (!element_type.IsDynamicType() &&
+          !elem->AsLiteralNode()->literal().Is(element_type)) {
+        ErrorMsg(elem->AsLiteralNode()->token_index(),
+                 "list literal element at index %d must be "
+                 "a constant of type '%s'",
+                 i,
+                 String::Handle(element_type.Name()).ToCString());
+      }
+      const_list.SetAt(i, elem->AsLiteralNode()->literal());
     }
-    lit_array ^= lit_array.Canonicalize();
-    lit_array.MakeImmutable();
-    return new LiteralNode(literal_pos, lit_array);
+    const_list ^= const_list.Canonicalize();
+    const_list.MakeImmutable();
+    return new LiteralNode(literal_pos, const_list);
   } 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_list_factory_name =
+        String::Handle(String::NewSymbol(kLiteralFactoryListFromLiteralName));
+    const Function& literal_list_factory = Function::ZoneHandle(
+        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();
     }
-
-    // Make a new growable array from the fixed array.
-    String& growable_object_array_class_name = String::Handle(
-        String::NewSymbol(kGrowableObjectArrayName));
-    const Class& growable_array_class = Class::Handle(
-        LookupImplClass(growable_object_array_class_name));
-    String& ctor_name =
-        String::Handle(String::NewSymbol(kGrowableObjectArrayFromArrayName));
-    Function& array_ctor = Function::ZoneHandle(
-        growable_array_class.LookupConstructor(ctor_name));
-    ASSERT(!array_ctor.IsNull());
-    ArgumentListNode* ctor_args = new ArgumentListNode(literal_pos);
-    ctor_args->Add(array);
-    CheckConstructorCallTypeArguments(literal_pos, array_ctor, type_arguments);
+    ArgumentListNode* factory_param = new ArgumentListNode(literal_pos);
+    factory_param->Add(
+        new LiteralNode(literal_pos, Smi::ZoneHandle(Smi::New(literal_pos))));
+    factory_param->Add(
+        new LiteralNode(literal_pos, String::ZoneHandle(element_type.Name())));
+    factory_param->Add(list);
     return new ConstructorCallNode(
-        literal_pos, type_arguments, array_ctor, ctor_args);
+        literal_pos, 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 18 matching lines @@
 
 AstNode* Parser::ParseMapLiteral(intptr_t type_pos,
                                  bool is_const,
                                  const TypeArguments& type_arguments) {
   TRACE_PARSER("ParseMapLiteral");
   ASSERT(type_pos >= 0);
   ASSERT(CurrentToken() == Token::kLBRACE);
   const intptr_t literal_pos = token_index_;
   ConsumeToken();
 
-  Type& value_type_argument = Type::Handle(Type::DynamicType());
+  Type& value_type = Type::Handle(Type::DynamicType());
   TypeArguments& map_type_arguments =
       TypeArguments::ZoneHandle(type_arguments.raw());
-  // If no type argument is provided, leave it as null, which is equivalent
-  // to using Dynamic as the type argument for the value type.
+  // If no type argument vector is provided, leave it as null, which is
+  // equivalent to using Dynamic as the type argument for the value type.
   if (!map_type_arguments.IsNull()) {
-    // Map literals only take one type argument.
-    value_type_argument = map_type_arguments.TypeAt(0);
+    ASSERT(map_type_arguments.Length() > 0);
+    // Map literals take a single type argument.
+    value_type = map_type_arguments.TypeAt(0);
     if (map_type_arguments.Length() > 1) {
       // We temporarily accept two type arguments, as long as the first one is
       // type String.
       if (map_type_arguments.Length() != 2) {
         ErrorMsg(type_pos,
                  "a map literal takes one type argument specifying "
                  "the value type");
       }
-      if (!value_type_argument.IsStringInterface()) {
+      if (!value_type.IsStringInterface()) {
         ErrorMsg(type_pos,
                  "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_argument = map_type_arguments.TypeAt(1);
+      value_type = map_type_arguments.TypeAt(1);
     } else {
       TypeArray& type_array = TypeArray::Handle(TypeArray::New(2));
       type_array.SetTypeAt(0, Type::Handle(Type::StringInterface()));
-      type_array.SetTypeAt(1, value_type_argument);
+      type_array.SetTypeAt(1, value_type);
       map_type_arguments = type_array.raw();
     }
-    if (is_const && !value_type_argument.IsInstantiated()) {
+    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));
 
   // Parse the map entries. Note: there may be an optional extra
   // comma after the last entry.
   ArrayNode* kv_pairs =
@@ skipping 30 matching lines @@
     // The resulting immutable map object is returned as a literal.
 
     // First, create the canonicalized key-value pair array.
     Array& key_value_array =
         Array::ZoneHandle(Array::New(kv_pairs->length(), Heap::kOld));
     for (int i = 0; i < kv_pairs->length(); i++) {
       AstNode* arg = kv_pairs->ElementAt(i);
       // Arguments have been evaluated to a literal value already.
       ASSERT(arg->IsLiteralNode());
       if (((i % 2) == 1) &&  // Check values only, not keys.
-          !value_type_argument.IsDynamicType() &&
-          !arg->AsLiteralNode()->literal().Is(value_type_argument)) {
+          !value_type.IsDynamicType() &&
+          !arg->AsLiteralNode()->literal().Is(value_type)) {
         ErrorMsg(arg->AsLiteralNode()->token_index(),
-                 "map literal entry value must be a constant of type '%s'",
-                 String::Handle(value_type_argument.Name()).ToCString());
+                 "map literal value at index %d must be "
+                 "a constant of type '%s'",
+                 i >> 1,
+                 String::Handle(value_type.Name()).ToCString());
       }
       key_value_array.SetAt(i, arg->AsLiteralNode()->literal());
     }
     key_value_array ^= key_value_array.Canonicalize();
     key_value_array.MakeImmutable();
 
     // Construct the map object.
     const String& immutable_map_class_name =
         String::Handle(String::NewSymbol(kImmutableMapName));
     const Class& immutable_map_class =
@@ skipping 11 matching lines @@
                                      map_type_arguments,
                                      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_map_factory_class_name = String::Handle(
-        String::NewSymbol(kLiteralMapFactoryName));
-    const Class& literal_map_factory_class =
-        Class::Handle(LookupCoreClass(literal_map_factory_class_name));
-    ASSERT(!literal_map_factory_class.IsNull());
+    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(kLiteralMapFactoryFromLiteralName));
+        String::Handle(String::NewSymbol(kLiteralFactoryMapFromLiteralName));
     const Function& literal_map_factory = Function::ZoneHandle(
-        literal_map_factory_class.LookupFactory(literal_map_factory_name));
+        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(
         new LiteralNode(literal_pos, Smi::ZoneHandle(Smi::New(literal_pos))));
     factory_param->Add(
-        new LiteralNode(literal_pos,
-                        String::ZoneHandle(value_type_argument.Name())));
+        new LiteralNode(literal_pos, String::ZoneHandle(value_type.Name())));
     factory_param->Add(kv_pairs);
     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();
   }
   const intptr_t type_pos = token_index_;
   TypeArguments& type_arguments =
       TypeArguments::ZoneHandle(ParseTypeArguments(kMustResolve));
   AstNode* primary = NULL;
   if ((CurrentToken() == Token::kLBRACK) ||
       (CurrentToken() == Token::kINDEX)) {
-    primary = ParseArrayLiteral(type_pos, is_const, type_arguments);
+    primary = ParseListLiteral(type_pos, is_const, type_arguments);
   } else if (CurrentToken() == Token::kLBRACE) {
     primary = ParseMapLiteral(type_pos, is_const, type_arguments);
   } else {
     ErrorMsg("unexpected token %s", Token::Str(CurrentToken()));
   }
   return primary;
 }
 
 
 static const String& BuildConstructorName(const String& type_class_name,
@@ skipping 424 matching lines @@
   }
   if (CurrentToken() == Token::kLBRACE) {
     SkipBlock();
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
     SkipExpr();
   }
 }
 
 
-void Parser::SkipArrayLiteral() {
+void Parser::SkipListLiteral() {
   if (CurrentToken() == Token::kINDEX) {
-    // Empty array literal.
+    // Empty list literal.
     ConsumeToken();
     return;
   }
   ExpectToken(Token::kLBRACK);
   while (CurrentToken() != Token::kRBRACK) {
     SkipNestedExpr();
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
     }
   }
@@ skipping 26 matching lines @@
   ExpectToken(Token::kRPAREN);
 }
 
 
 void Parser::SkipCompoundLiteral() {
   if (CurrentToken() == Token::kLT) {
     SkipTypeArguments();
   }
   if ((CurrentToken() == Token::kLBRACK) ||
       (CurrentToken() == Token::kINDEX)) {
-    SkipArrayLiteral();
+    SkipListLiteral();
   } else if (CurrentToken() == Token::kLBRACE) {
     SkipMapLiteral();
   }
 }
 
 
 void Parser::SkipNewOperator() {
   ConsumeToken();  // Skip new or const keyword.
   if (CurrentToken() == Token::kIDENT) {
     SkipType(false);
@@ skipping 145 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart