Optimize type checks of list and map literals.

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 6562 matching lines @@
 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();
 
-  Type& element_type = Type::Handle(Type::DynamicType());
+  Type& element_type = Type::ZoneHandle(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()) {
     ASSERT(type_arguments.Length() > 0);
     // List literals take a single type argument.
     element_type = type_arguments.TypeAt(0);
     if (type_arguments.Length() != 1) {
       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 list elements. Note: there may be an optional extra
   // comma after the last element.
   ArrayNode* list = new ArrayNode(token_index_, TypeArguments::ZoneHandle());
   if (!is_empty_literal) {
     const bool saved_mode = SetAllowFunctionLiterals(true);
+    const String& dst_name = String::ZoneHandle(
+        String::NewSymbol("list literal element"));
     while (CurrentToken() != Token::kRBRACK) {
-      list->AddElement(ParseExpr(is_const));
+      const intptr_t element_pos = token_index_;
+      AstNode* element = ParseExpr(is_const);
+      if (FLAG_enable_type_checks &&
+          !is_const &&
+          !element_type.IsDynamicType()) {
+        // The expression needs to be type checked at runtime.
+        // Eliminate the type check if it can be performed at compile time and
+        // if it succeeds.
+        if (!element_type.IsInstantiated() ||
+            !element->IsLiteralNode() ||
+            !element->AsLiteralNode()->literal().
+                IsAssignableTo(element_type, TypeArguments::Handle())) {
+          element = new AssignableNode(element_pos,
+                                       element,
+                                       element_type,
+                                       dst_name);
+        }
+      }
+      list->AddElement(element);
       if (CurrentToken() == Token::kCOMMA) {
         ConsumeToken();
       } else if (CurrentToken() != Token::kRBRACK) {
         ErrorMsg("comma or ']' expected");
       }
     }
     ExpectToken(Token::kRBRACK);
     SetAllowFunctionLiterals(saved_mode);
   }
 
@@ skipping 34 matching lines @@
     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();
     }
     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, literal_list_factory, factory_param);
   }
 }
 
 
 static void AddKeyValuePair(ArrayNode* pairs,
                             bool is_const,
                             AstNode* key,
@@ skipping 21 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 = Type::Handle(Type::DynamicType());
+  Type& value_type = Type::ZoneHandle(Type::DynamicType());
   TypeArguments& map_type_arguments =
       TypeArguments::ZoneHandle(type_arguments.raw());
   // 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()) {
     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
@@ skipping 22 matching lines @@
                "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 =
       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) {
       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");
     }
     ExpectToken(Token::kCOLON);
     const bool saved_mode = SetAllowFunctionLiterals(true);
+    const intptr_t value_pos = token_index_;
     AstNode* value = ParseExpr(is_const);
     SetAllowFunctionLiterals(saved_mode);
-
+    if (FLAG_enable_type_checks &&
+        !is_const &&
+        !value_type.IsDynamicType()) {
+      // The expression needs to be type checked at runtime.
+      // Eliminate the type check if it can be performed at compile time and
+      // if it succeeds.
+      if (!value_type.IsInstantiated() ||
+          !value->IsLiteralNode() ||
+          !value->AsLiteralNode()->literal().
+              IsAssignableTo(value_type, TypeArguments::Handle())) {
+        value = new AssignableNode(value_pos,
+                                   value,
+                                   value_type,
+                                   dst_name);
+      }
+    }
     AddKeyValuePair(kv_pairs, is_const, key, value);
 
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
     } else if (CurrentToken() != Token::kRBRACE) {
       ErrorMsg("comma or '}' expected");
     }
   }
   ASSERT(kv_pairs->length() % 2 == 0);
   ExpectToken(Token::kRBRACE);
@@ skipping 61 matching lines @@
     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(
-        new LiteralNode(literal_pos, Smi::ZoneHandle(Smi::New(literal_pos))));
-    factory_param->Add(
-        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) {
@@ skipping 659 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart