Fix type check to perform a subtype test at top level instead of an

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 7069 matching lines @@
       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().
-                IsAssignableTo(element_type,
-                               TypeArguments::Handle(),
-                               &malformed_error)) {
+            (!element->AsLiteralNode()->literal().IsNull() &&
+             !element->AsLiteralNode()->literal().IsInstanceOf(
+                 element_type,
+                 TypeArguments::Handle(),
+                 &malformed_error))) {
           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);
   }
 
   if (is_const) {
     // 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);
     Error& malformed_error = Error::Handle();
     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());
       if (FLAG_enable_type_checks &&
           !element_type.IsDynamicType() &&
-          !elem->AsLiteralNode()->literal().IsAssignableTo(
-              element_type, TypeArguments::Handle(), &malformed_error)) {
+          (!elem->AsLiteralNode()->literal().IsNull() &&
+           !elem->AsLiteralNode()->literal().IsInstanceOf(
+               element_type, TypeArguments::Handle(), &malformed_error))) {
         // If the failure is due to a malformed type error, display it instead.
         if (!malformed_error.IsNull()) {
           ErrorMsg(malformed_error);
         } else {
           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());
         }
@@ skipping 130 matching lines @@
     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().IsAssignableTo(
-              value_type, TypeArguments::Handle(), &malformed_error)) {
+          (!value->AsLiteralNode()->literal().IsNull() &&
+           !value->AsLiteralNode()->literal().IsInstanceOf(
+               value_type, TypeArguments::Handle(), &malformed_error))) {
         value = new AssignableNode(value_pos,
                                    value,
                                    value_type,
                                    dst_name);
       }
     }
     AddKeyValuePair(kv_pairs, is_const, key, value);
 
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
@@ skipping 13 matching lines @@
     Array& key_value_array =
         Array::ZoneHandle(Array::New(kv_pairs->length(), Heap::kOld));
     Error& malformed_error = Error::Handle();
     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 (FLAG_enable_type_checks &&
           ((i % 2) == 1) &&  // Check values only, not keys.
           !value_type.IsDynamicType() &&
-          !arg->AsLiteralNode()->literal().IsAssignableTo(
-              value_type, TypeArguments::Handle(), &malformed_error)) {
+          (!arg->AsLiteralNode()->literal().IsNull() &&
+           !arg->AsLiteralNode()->literal().IsInstanceOf(
+               value_type, TypeArguments::Handle(), &malformed_error))) {
         // If the failure is due to a malformed type error, display it instead.
         if (!malformed_error.IsNull()) {
           ErrorMsg(malformed_error);
         } else {
           ErrorMsg(arg->AsLiteralNode()->token_index(),
                    "map literal value at index %d must be "
                    "a constant of type '%s'",
                    i >> 1,
                    String::Handle(value_type.Name()).ToCString());
         }
@@ skipping 881 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart