When canonicalize instances check if all fields are canonical. If a field is a non-canonical number…

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 "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 6783 matching lines @@
   arguments->Add(new LiteralNode(call_pos, Array::ZoneHandle()));
   // List existingArgumentNames.
   // Check if there exists a function with the same name.
   Function& function =
      Function::Handle(cls.LookupStaticFunction(function_name));
   if (function.IsNull()) {
     // TODO(srdjan): Store argument values into the argument list.
     arguments->Add(new LiteralNode(call_pos, Array::ZoneHandle()));
   } else {
     const int total_num_parameters = function.NumParameters();
-    Array& array = Array::ZoneHandle(Array::New(total_num_parameters));
-    array ^= array.Canonicalize();
+    Array& array =
+        Array::ZoneHandle(Array::New(total_num_parameters, Heap::kOld));
     // Skip receiver.
     for (int i = 0; i < total_num_parameters; i++) {
       array.SetAt(i, String::Handle(function.ParameterNameAt(i)));
     }
     arguments->Add(new LiteralNode(call_pos, array));
   }
   return MakeStaticCall(Symbols::NoSuchMethodError(),
                         PrivateCoreLibName(Symbols::ThrowNew()),
                         arguments);
 }
@@ skipping 1234 matching lines @@
 bool Parser::IsInstantiatorRequired() const {
   ASSERT(!current_function().IsNull());
   if (current_function().is_static() &&
       !current_function().IsInFactoryScope()) {
     return false;
   }
   return current_class().NumTypeParameters() > 0;
 }
 
 
+RawInstance* Parser::TryCanonicalize(const Instance& instance) {
+  if (instance.IsNull()) {
+    return instance.raw();
+  }
+  const char* error_str = NULL;
+  Instance& result =
+      Instance::Handle(instance.CheckAndCanonicalize(&error_str));
+  if (result.IsNull()) {
+    ErrorMsg("Invalid const object %s", error_str);

[hausner, 2013/06/11 23:29:24]

The error position is not necessarily the current token position. I would pass
in the token position as a parameter.

[srdjan, 2013/06/12 00:22:22]

Done.

+  }
+  return result.raw();
+}
+
+
 // If the field is already initialized, return no ast (NULL).
 // Otherwise, if the field is constant, initialize the field and return no ast.
 // If the field is not initialized and not const, return the ast for the getter.
 AstNode* Parser::RunStaticFieldInitializer(const Field& field) {
   ASSERT(field.is_static());
   const Instance& value = Instance::Handle(field.value());
   if (value.raw() == Object::transition_sentinel().raw()) {
     if (field.is_const()) {
       ErrorMsg("circular dependency while initializing static field '%s'",
                String::Handle(field.name()).ToCString());
@@ skipping 39 matching lines @@
           AppendErrorMsg(error, TokenPos(),
                          "error initializing const field '%s'",
                          String::Handle(field.name()).ToCString());
         } else {
           isolate()->long_jump_base()->Jump(1, error);
         }
       }
       ASSERT(const_value.IsNull() || const_value.IsInstance());
       Instance& instance = Instance::Handle();
       instance ^= const_value.raw();
-      if (!instance.IsNull()) {
-        instance ^= instance.Canonicalize();
-      }
+      instance = TryCanonicalize(instance);
       field.set_value(instance);
     } else {
       return new StaticGetterNode(TokenPos(),
                                   NULL,
                                   false,
                                   Class::ZoneHandle(field.owner()),
                                   String::ZoneHandle(field.name()));
     }
   }
   return NULL;
 }
 
 
 RawObject* Parser::EvaluateConstConstructorCall(
     const Class& type_class,
     const AbstractTypeArguments& type_arguments,
     const Function& constructor,
     ArgumentListNode* arguments) {
   const int kNumExtraArgs = 2;  // implicit rcvr and construction phase args.
   const int num_arguments = arguments->length() + kNumExtraArgs;
   const Array& arg_values = Array::Handle(Array::New(num_arguments));
   Instance& instance = Instance::Handle();
   ASSERT(!constructor.IsFactory());
-  instance = Instance::New(type_class, Heap::kOld);
+  instance ^= Instance::New(type_class, Heap::kOld);

[hausner, 2013/06/11 23:29:24]

Why ^= ?

[srdjan, 2013/06/12 00:22:22]

Weird ... removed.

   if (!type_arguments.IsNull()) {
     if (!type_arguments.IsInstantiated()) {
       ErrorMsg("type must be constant in const constructor");
     }
     instance.SetTypeArguments(
         AbstractTypeArguments::Handle(type_arguments.Canonicalize()));
   }
   arg_values.SetAt(0, instance);
   arg_values.SetAt(1, Smi::Handle(Smi::New(Function::kCtorPhaseAll)));
   for (int i = 0; i < arguments->length(); i++) {
@@ skipping 15 matching lines @@
       // not optimizable.
       current_function().set_is_optimizable(false);
       if (result.IsUnhandledException()) {
         return result.raw();
       } else {
         isolate()->long_jump_base()->Jump(1, Error::Cast(result));
         UNREACHABLE();
         return Object::null();
       }
   } else {
-    if (!instance.IsNull()) {
-      instance ^= instance.Canonicalize();
-    }
-    return instance.raw();
+    return TryCanonicalize(instance);
   }
 }
 
 
 // Do a lookup for the identifier in the block scope and the class scope
 // return true if the identifier is found, false otherwise.
 // If node is non NULL return an AST node corresponding to the identifier.
 bool Parser::ResolveIdentInLocalScope(intptr_t ident_pos,
                                       const String &ident,
                                       AstNode** node) {
@@ skipping 619 matching lines @@
         } else {
           ErrorMsg(elem->AsLiteralNode()->token_pos(),
                    "list literal element at index %d must be "
                    "a constant of type '%s'",
                    i,
                    String::Handle(element_type.UserVisibleName()).ToCString());
         }
       }
       const_list.SetAt(i, elem->AsLiteralNode()->literal());
     }
-    const_list ^= const_list.Canonicalize();
+    const_list ^= TryCanonicalize(const_list);
     const_list.MakeImmutable();
     return new LiteralNode(literal_pos, const_list);
   } else {
     // Factory call at runtime.
     const Class& factory_class =
         Class::Handle(LookupCoreClass(Symbols::List()));
     ASSERT(!factory_class.IsNull());
     const Function& factory_method = Function::ZoneHandle(
         factory_class.LookupFactory(
             PrivateCoreLibName(Symbols::ListLiteralFactory())));
@@ skipping 176 matching lines @@
         } else {
           ErrorMsg(arg->AsLiteralNode()->token_pos(),
                    "map literal value at index %d must be "
                    "a constant of type '%s'",
                    i >> 1,
                    String::Handle(value_type.UserVisibleName()).ToCString());
         }
       }
       key_value_array.SetAt(i, arg->AsLiteralNode()->literal());
     }
-    key_value_array ^= key_value_array.Canonicalize();
+    key_value_array ^= TryCanonicalize(key_value_array);
     key_value_array.MakeImmutable();
 
     // Construct the map object.
     const Class& immutable_map_class =
         Class::Handle(LookupCoreClass(Symbols::ImmutableMap()));
     ASSERT(!immutable_map_class.IsNull());
     // If the immutable map class extends other parameterized classes, we need
     // to adjust the type argument vector. This is currently not the case.
     ASSERT(immutable_map_class.NumTypeArguments() == 2);
     ArgumentListNode* constr_args = new ArgumentListNode(TokenPos());
@@ skipping 652 matching lines @@
 
     Object& result = Object::Handle(Compiler::ExecuteOnce(seq));
     if (result.IsError()) {
       // Propagate the compilation error.
       isolate()->long_jump_base()->Jump(1, Error::Cast(result));
       UNREACHABLE();
     }
     ASSERT(result.IsInstance());
     Instance& value = Instance::ZoneHandle();
     value ^= result.raw();
-    if (!value.IsNull()) {
-      value ^= value.Canonicalize();
-    }
+    value = TryCanonicalize(value);
     return value;
   }
 }
 
 
 void Parser::SkipFunctionLiteral() {
   if (IsIdentifier()) {
     if (LookaheadToken(1) != Token::kLPAREN) {
       SkipType(true);
     }
@@ skipping 273 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart