Propagate type of list literal from parser to ast, graph, and optimizer.

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 1236 matching lines @@
     const String& function_name,
     const ArgumentListNode& function_args) {
   ASSERT(function_args.length() >= 1);  // The receiver is the first argument.
   const intptr_t args_pos = function_args.token_pos();
   ArgumentListNode* arguments = new ArgumentListNode(args_pos);
   arguments->Add(function_args.NodeAt(0));
   // The second argument is the original function name.
   // TODO(regis): This will change once mirrors are supported.
   arguments->Add(new LiteralNode(args_pos, function_name));
   // The third argument is an array containing the original function arguments.
-  ArrayNode* args_array = new ArrayNode(args_pos, TypeArguments::ZoneHandle());
+  ArrayNode* args_array = new ArrayNode(
+      args_pos, Type::ZoneHandle(Type::ListInterface()));
   for (intptr_t i = 1; i < function_args.length(); i++) {
     args_array->AddElement(function_args.NodeAt(i));
   }
   arguments->Add(args_array);
   return arguments;
 }
 
 
 AstNode* Parser::ParseSuperCall(const String& function_name) {
   TRACE_PARSER("ParseSuperCall");
@@ skipping 6785 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());
+  Type& type = Type::ZoneHandle(
+      Type::New(list_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.
-  ArrayNode* list = new ArrayNode(TokenPos(), type_arguments);
   if (!is_empty_literal) {
     const bool saved_mode = SetAllowFunctionLiterals(true);
     const String& dst_name = String::ZoneHandle(Symbols::ListLiteralElement());
     while (CurrentToken() != Token::kRBRACK) {
       const intptr_t element_pos = TokenPos();
       AstNode* element = ParseExpr(is_const, kConsumeCascades);
       if (FLAG_enable_type_checks &&
           !is_const &&
           !element_type.IsDynamicType()) {
         element = new AssignableNode(element_pos,
@@ skipping 160 matching lines @@
     }
     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.
   // 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(), TypeArguments::ZoneHandle());
+      new ArrayNode(TokenPos(), Type::ZoneHandle(Type::ListInterface()));
+
+  // 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) {
       ErrorMsg("map entry key must be string literal");
     } else if (is_const && !key->IsLiteralNode()) {
       ErrorMsg("map entry key must be compile time constant string");
@@ skipping 437 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(), TypeArguments::ZoneHandle());
+  ArrayNode* values = new ArrayNode(TokenPos(),
+                                    Type::ZoneHandle(Type::ListInterface()));
   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 505 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart