Eliminate type checks that can successfully be performed at compile time.

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 7134 matching lines @@
   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) {
       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.
-        Error& malformed_error = Error::Handle();
-        if (!element_type.IsInstantiated() ||
-            !element->IsLiteralNode() ||
-            (!element->AsLiteralNode()->literal().IsNull() &&
-             !element->AsLiteralNode()->literal().IsInstanceOf(
-                 element_type,
-                 TypeArguments::Handle(),
-                 &malformed_error))) {
-          element = new AssignableNode(element_pos,
-                                       element,
-                                       element_type,
-                                       dst_name);
-        }
+        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 151 matching lines @@
       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.
-      Error& malformed_error = Error::Handle();
-      if (!value_type.IsInstantiated() ||
-          !value->IsLiteralNode() ||
-          (!value->AsLiteralNode()->literal().IsNull() &&
-           !value->AsLiteralNode()->literal().IsInstanceOf(
-               value_type, TypeArguments::Handle(), &malformed_error))) {
-        value = new AssignableNode(value_pos,
-                                   value,
-                                   value_type,
-                                   dst_name);
-      }
+      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);
@@ skipping 913 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart