Fix build breakage.

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 6622 matching lines @@
   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);
 
     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 (!element_type.IsDynamicType() &&
-          !elem->AsLiteralNode()->literal().Is(element_type)) {
+      if (FLAG_enable_type_checks &&
+          !element_type.IsDynamicType() &&
+          !elem->AsLiteralNode()->literal().
+              IsAssignableTo(element_type, TypeArguments::Handle())) {
         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());
     }
     const_list ^= const_list.Canonicalize();
     const_list.MakeImmutable();
@@ skipping 136 matching lines @@
     // the immutable map object with it. This all happens at compile time.
     // 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.
+      if (FLAG_enable_type_checks &&
+          ((i % 2) == 1) &&  // Check values only, not keys.
           !value_type.IsDynamicType() &&
-          !arg->AsLiteralNode()->literal().Is(value_type)) {
+          !arg->AsLiteralNode()->literal().
+              IsAssignableTo(value_type, TypeArguments::Handle())) {
         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());
       }
       key_value_array.SetAt(i, arg->AsLiteralNode()->literal());
     }
     key_value_array ^= key_value_array.Canonicalize();
     key_value_array.MakeImmutable();
@@ skipping 716 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart