- Add isolate to ZoneHandle allocation in parser.

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 "platform/utils.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 391 matching lines @@
 
 Token::Kind Parser::LookaheadToken(int num_tokens) {
   CompilerStats::num_tokens_lookahead++;
   CompilerStats::num_token_checks++;
   return tokens_iterator_.LookaheadTokenKind(num_tokens);
 }
 
 
 String* Parser::CurrentLiteral() const {
   String& result =
-      String::ZoneHandle(isolate_, tokens_iterator_.CurrentLiteral());
+      String::ZoneHandle(I, tokens_iterator_.CurrentLiteral());
   return &result;
 }
 
 
 RawDouble* Parser::CurrentDoubleLiteral() const {
   literal_token_ ^= tokens_iterator_.CurrentToken();
   ASSERT(literal_token_.kind() == Token::kDOUBLE);
   return Double::RawCast(literal_token_.value());
 }
 
@@ skipping 321 matching lines @@
 RawObject* Parser::ParseFunctionParameters(const Function& func) {
   ASSERT(!func.IsNull());
   Isolate* isolate = Isolate::Current();
   StackZone zone(isolate);
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     const Script& script = Script::Handle(isolate, func.script());
     const Class& owner = Class::Handle(isolate, func.Owner());
     ASSERT(!owner.IsNull());
     ParsedFunction* parsed_function = new ParsedFunction(
-        Function::ZoneHandle(func.raw()));
+        Function::ZoneHandle(isolate, func.raw()));
     Parser parser(script, parsed_function, func.token_pos());
     parser.SkipFunctionPreamble();
     ParamList params;
     parser.ParseFormalParameterList(true, true, &params);
     ParamDesc* param = params.parameters->data();
     const int param_cnt = params.num_fixed_parameters +
                           params.num_optional_parameters;
     const Array& param_descriptor =
         Array::Handle(Array::New(param_cnt * kParameterEntrySize));
     for (int i = 0, j = 0; i < param_cnt; i++, j += kParameterEntrySize) {
@@ skipping 222 matching lines @@
   ASSERT(AbstractType::Handle(isolate(), func.result_type()).IsResolved());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   intptr_t ident_pos = TokenPos();
   const String& field_name = *ExpectIdentifier("field name expected");
   const Class& field_class = Class::Handle(isolate(), func.Owner());
   const Field& field =
-      Field::ZoneHandle(field_class.LookupStaticField(field_name));
+      Field::ZoneHandle(I, field_class.LookupStaticField(field_name));
 
   // Static final fields must have an initializer.
   ExpectToken(Token::kASSIGN);
 
   const intptr_t expr_pos = TokenPos();
   if (field.is_const()) {
     // We don't want to use ParseConstExpr() here because we don't want
     // the constant folding code to create, compile and execute a code
     // fragment to evaluate the expression. Instead, we just make sure
     // the static const field initializer is a constant expression and
@@ skipping 25 matching lines @@
         new LoadStaticFieldNode(ident_pos, field),
         new LiteralNode(ident_pos, Object::transition_sentinel()));
     // Set field to null prior to throwing exception, so that subsequent
     // accesses to the field do not throw again, since initializers should only
     // be executed once.
     SequenceNode* report_circular = new SequenceNode(ident_pos, NULL);
     report_circular->Add(
         new StoreStaticFieldNode(
             ident_pos,
             field,
-            new LiteralNode(ident_pos, Instance::ZoneHandle())));
+            new LiteralNode(ident_pos, Instance::ZoneHandle(I))));
     // Call CyclicInitializationError._throwNew(field_name).
     ArgumentListNode* error_arguments = new ArgumentListNode(ident_pos);
     error_arguments->Add(new LiteralNode(ident_pos, field_name));
     report_circular->Add(
         MakeStaticCall(Symbols::CyclicInitializationError(),
                        Library::PrivateCoreLibName(Symbols::ThrowNew()),
                        error_arguments));
     AstNode* circular_check =
         new IfNode(ident_pos, compare_circular, report_circular, NULL);
     current_block_->statements->Add(circular_check);
 
     // Generate code checking for uninitialized field.
     AstNode* compare_uninitialized = new ComparisonNode(
         ident_pos,
         Token::kEQ_STRICT,
         new LoadStaticFieldNode(ident_pos, field),
         new LiteralNode(ident_pos, Object::sentinel()));
     SequenceNode* initialize_field = new SequenceNode(ident_pos, NULL);
     initialize_field->Add(
         new StoreStaticFieldNode(
             ident_pos,
             field,
             new LiteralNode(ident_pos, Object::transition_sentinel())));
     const String& init_name = String::Handle(isolate(), Symbols::New(
         String::Handle(isolate(), String::Concat(
             Symbols::InitPrefix(), String::Handle(isolate(), field.name())))));
-    const Function& init_function = Function::ZoneHandle(
+    const Function& init_function = Function::ZoneHandle(I,
         field_class.LookupStaticFunction(init_name));
     ASSERT(!init_function.IsNull());
     ArgumentListNode* arguments = new ArgumentListNode(expr_pos);
     StaticCallNode* init_call =
         new StaticCallNode(expr_pos, init_function, arguments);
     initialize_field->Add(init_call);
 
     AstNode* uninitialized_check =
         new IfNode(ident_pos, compare_uninitialized, initialize_field, NULL);
     current_block_->statements->Add(uninitialized_check);
@@ skipping 24 matching lines @@
   ExpectIdentifier("identifier expected");
   ExpectToken(Token::kASSIGN);
   intptr_t token_pos = TokenPos();
 
   // Synthesize a try-catch block to wrap the initializer expression.
   LocalVariable* context_var =
       current_block_->scope->LocalLookupVariable(Symbols::SavedTryContextVar());
   if (context_var == NULL) {
     context_var = new LocalVariable(token_pos,
                                     Symbols::SavedTryContextVar(),
-                                    Type::ZoneHandle(Type::DynamicType()));
+                                    Type::ZoneHandle(I, Type::DynamicType()));
     current_block_->scope->AddVariable(context_var);
   }
   LocalVariable* catch_excp_var =
       current_block_->scope->LocalLookupVariable(Symbols::ExceptionVar());
   if (catch_excp_var == NULL) {
-    catch_excp_var = new LocalVariable(token_pos,
-                                       Symbols::ExceptionVar(),
-                                       Type::ZoneHandle(Type::DynamicType()));
+    catch_excp_var = new LocalVariable(
+        token_pos,
+        Symbols::ExceptionVar(),
+        Type::ZoneHandle(I, Type::DynamicType()));
     current_block_->scope->AddVariable(catch_excp_var);
   }
   LocalVariable* catch_trace_var =
       current_block_->scope->LocalLookupVariable(Symbols::StackTraceVar());
   if (catch_trace_var == NULL) {
-    catch_trace_var = new LocalVariable(token_pos,
-                                        Symbols::StackTraceVar(),
-                                        Type::ZoneHandle(Type::DynamicType()));
+    catch_trace_var = new LocalVariable(
+        token_pos,
+        Symbols::StackTraceVar(),
+        Type::ZoneHandle(I, Type::DynamicType()));
     current_block_->scope->AddVariable(catch_trace_var);
   }
 
   OpenBlock();  // Start try block.
   AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
-  const Field& field = Field::ZoneHandle(func.saved_static_field());
+  const Field& field = Field::ZoneHandle(I, func.saved_static_field());
   ASSERT(!field.is_const());
   StoreStaticFieldNode* store = new StoreStaticFieldNode(field.token_pos(),
                                                          field,
                                                          expr);
   current_block_->statements->Add(store);
   SequenceNode* try_block = CloseBlock();  // End try block.
 
   OpenBlock();  // Start catch handler list.
   OpenBlock();  // Start catch clause.
   AstNode* compare_transition_sentinel = new ComparisonNode(
       token_pos,
       Token::kEQ_STRICT,
       new LoadStaticFieldNode(ident_pos, field),
       new LiteralNode(field.token_pos(), Object::transition_sentinel()));
 
   SequenceNode* store_null = new SequenceNode(token_pos, NULL);
   store_null->Add(new StoreStaticFieldNode(
       field.token_pos(),
       field,
-      new LiteralNode(token_pos, Instance::ZoneHandle())));
+      new LiteralNode(token_pos, Instance::ZoneHandle(I))));
   AstNode* transition_sentinel_check =
       new IfNode(token_pos, compare_transition_sentinel, store_null, NULL);
   current_block_->statements->Add(transition_sentinel_check);
 
   current_block_->statements->Add(
       new ThrowNode(token_pos,
                     new LoadLocalNode(token_pos, catch_excp_var),
                     new LoadLocalNode(token_pos, catch_trace_var)));
   SequenceNode* catch_clause = CloseBlock();  // End catch clause.
 
   current_block_->statements->Add(catch_clause);
   SequenceNode* catch_handler_list = CloseBlock();  // End catch handler list.
   CatchClauseNode* catch_block =
       new CatchClauseNode(token_pos,
                           catch_handler_list,
-                          Array::ZoneHandle(Object::empty_array().raw()),
+                          Array::ZoneHandle(I, Object::empty_array().raw()),
                           context_var,
                           catch_excp_var,
                           catch_trace_var,
                           CatchClauseNode::kInvalidTryIndex,
                           false);  // No stack trace needed.
 
   AstNode* try_catch_node = new TryCatchNode(token_pos,
                                              try_block,
                                              context_var,
                                              catch_block,
@@ skipping 23 matching lines @@
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   // Receiver is local 0.
   LocalVariable* receiver = current_block_->scope->VariableAt(0);
   LoadLocalNode* load_receiver = new LoadLocalNode(ident_pos, receiver);
   ASSERT(IsIdentifier());
   const String& field_name = *CurrentLiteral();
   const Class& field_class = Class::Handle(isolate(), func.Owner());
   const Field& field =
-      Field::ZoneHandle(field_class.LookupInstanceField(field_name));
+      Field::ZoneHandle(I, field_class.LookupInstanceField(field_name));
 
   LoadInstanceFieldNode* load_field =
       new LoadInstanceFieldNode(ident_pos, load_receiver, field);
 
   ReturnNode* return_node =
       new ReturnNode(Scanner::kNoSourcePos, load_field);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 // Create AstNodes for an implicit instance setter method:
 //   LoadLocalNode 0 ('this')
 //   LoadLocalNode 1 ('value')
 //   SetInstanceField (field_name);
 //   ReturnNode (void);
 SequenceNode* Parser::ParseInstanceSetter(const Function& func) {
   TRACE_PARSER("ParseInstanceSetter");
   // func.token_pos() points to the name of the field.
   const intptr_t ident_pos = func.token_pos();
   const String& field_name = *CurrentLiteral();
-  const Class& field_class = Class::ZoneHandle(func.Owner());
+  const Class& field_class = Class::ZoneHandle(I, func.Owner());
   const Field& field =
-      Field::ZoneHandle(field_class.LookupInstanceField(field_name));
-  const AbstractType& field_type = AbstractType::ZoneHandle(field.type());
+      Field::ZoneHandle(I, field_class.LookupInstanceField(field_name));
+  const AbstractType& field_type = AbstractType::ZoneHandle(I, field.type());
 
   ParamList params;
   ASSERT(current_class().raw() == func.Owner());
   params.AddReceiver(ReceiverType(current_class()), ident_pos);
   params.AddFinalParameter(ident_pos,
                            &Symbols::Value(),
                            &field_type);
   ASSERT(func.num_fixed_parameters() == 2);  // receiver, value.
   ASSERT(!func.HasOptionalParameters());
   ASSERT(AbstractType::Handle(isolate(), func.result_type()).IsVoidType());
@@ skipping 30 matching lines @@
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   // Receiver is local 0.
   LocalVariable* receiver = current_block_->scope->VariableAt(0);
   LoadLocalNode* load_receiver = new LoadLocalNode(ident_pos, receiver);
 
   ClosureNode* closure = new ClosureNode(
       ident_pos,
-      Function::ZoneHandle(func.extracted_method_closure()),
+      Function::ZoneHandle(I, func.extracted_method_closure()),
       load_receiver,
       NULL);
 
   ReturnNode* return_node = new ReturnNode(Scanner::kNoSourcePos, closure);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 void Parser::BuildDispatcherScope(const Function& func,
                                   const ArgumentsDescriptor& desc,
                                   Array* default_values) {
   ParamList params;
   // Receiver first.
   intptr_t token_pos = func.token_pos();
   params.AddReceiver(ReceiverType(current_class()), token_pos);
   // Remaining positional parameters.
   intptr_t i = 1;
   for (; i < desc.PositionalCount(); ++i) {
     ParamDesc p;
     char name[64];
     OS::SNPrint(name, 64, ":p%" Pd, i);
-    p.name = &String::ZoneHandle(Symbols::New(name));
-    p.type = &Type::ZoneHandle(Type::DynamicType());
+    p.name = &String::ZoneHandle(I, Symbols::New(name));
+    p.type = &Type::ZoneHandle(I, Type::DynamicType());
     params.parameters->Add(p);
     params.num_fixed_parameters++;
   }
   ASSERT(desc.PositionalCount() == params.num_fixed_parameters);
 
   // Named parameters.
   for (; i < desc.Count(); ++i) {
     ParamDesc p;
     intptr_t index = i - desc.PositionalCount();
-    p.name = &String::ZoneHandle(desc.NameAt(index));
-    p.type = &Type::ZoneHandle(Type::DynamicType());
+    p.name = &String::ZoneHandle(I, desc.NameAt(index));
+    p.type = &Type::ZoneHandle(I, Type::DynamicType());
     p.default_value = &Object::ZoneHandle();
     params.parameters->Add(p);
     params.num_optional_parameters++;
     params.has_optional_named_parameters = true;
   }
   ASSERT(desc.NamedCount() == params.num_optional_parameters);
 
   SetupDefaultsForOptionalParams(&params, default_values);
 
   // Build local scope for function and populate with the formal parameters.
@@ skipping 17 matching lines @@
   BuildDispatcherScope(func, desc, default_values);
 
   // Receiver is local 0.
   LocalScope* scope = current_block_->scope;
   ArgumentListNode* func_args = new ArgumentListNode(token_pos);
   for (intptr_t i = 0; i < desc.Count(); ++i) {
     func_args->Add(new LoadLocalNode(token_pos, scope->VariableAt(i)));
   }
 
   if (desc.NamedCount() > 0) {
-    const Array& arg_names = Array::ZoneHandle(Array::New(desc.NamedCount()));
+    const Array& arg_names =
+        Array::ZoneHandle(I, Array::New(desc.NamedCount()));
     for (intptr_t i = 0; i < arg_names.Length(); ++i) {
       arg_names.SetAt(i, String::Handle(isolate(), desc.NameAt(i)));
     }
     func_args->set_names(arg_names);
   }
 
-  const String& func_name = String::ZoneHandle(func.name());
+  const String& func_name = String::ZoneHandle(I, func.name());
   ArgumentListNode* arguments = BuildNoSuchMethodArguments(
       token_pos, func_name, *func_args, NULL, false);
-  const Function& no_such_method = Function::ZoneHandle(
+  const Function& no_such_method = Function::ZoneHandle(I,
       Resolver::ResolveDynamicAnyArgs(Class::Handle(
           isolate(), func.Owner()), Symbols::NoSuchMethod()));
   StaticCallNode* call =
       new StaticCallNode(token_pos, no_such_method, arguments);
 
   ReturnNode* return_node = new ReturnNode(token_pos, call);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
@@ skipping 13 matching lines @@
 
   // Set up scope for this function.
   BuildDispatcherScope(func, desc, default_values);
 
   // Receiver is local 0.
   LocalScope* scope = current_block_->scope;
   ArgumentListNode* no_args = new ArgumentListNode(token_pos);
   LoadLocalNode* receiver = new LoadLocalNode(token_pos, scope->VariableAt(0));
 
   const String& name = String::Handle(isolate(), func.name());
-  const String& getter_name = String::ZoneHandle(
+  const String& getter_name = String::ZoneHandle(I,
       Symbols::New(String::Handle(isolate(), Field::GetterName(name))));
   InstanceCallNode* getter_call = new(isolate()) InstanceCallNode(
       token_pos, receiver, getter_name, no_args);
 
   // Pass arguments 1..n to the closure call.
   ArgumentListNode* args = new ArgumentListNode(token_pos);
   const Array& names = Array::Handle(
       isolate(), Array::New(desc.NamedCount(), Heap::kOld));
   // Positional parameters.
   intptr_t i = 1;
@@ skipping 82 matching lines @@
 
 void Parser::ParseFormalParameter(bool allow_explicit_default_value,
                                   bool evaluate_metadata,
                                   ParamList* params) {
   TRACE_PARSER("ParseFormalParameter");
   ParamDesc parameter;
   bool var_seen = false;
   bool this_seen = false;
 
   if (evaluate_metadata && (CurrentToken() == Token::kAT)) {
-    parameter.metadata = &Array::ZoneHandle(EvaluateMetadata());
+    parameter.metadata = &Array::ZoneHandle(I, EvaluateMetadata());
   } else {
     SkipMetadata();
   }
 
   if (CurrentToken() == Token::kFINAL) {
     ConsumeToken();
     parameter.is_final = true;
   } else if (CurrentToken() == Token::kVAR) {
     ConsumeToken();
     var_seen = true;
     // The parameter type is the 'dynamic' type.
     // If this is an initializing formal, its type will be set to the type of
     // the respective field when the constructor is fully parsed.
-    parameter.type = &Type::ZoneHandle(Type::DynamicType());
+    parameter.type = &Type::ZoneHandle(I, Type::DynamicType());
   }
   if (CurrentToken() == Token::kTHIS) {
     ConsumeToken();
     ExpectToken(Token::kPERIOD);
     this_seen = true;
     parameter.is_field_initializer = true;
   }
   if ((parameter.type == NULL) && (CurrentToken() == Token::kVOID)) {
     ConsumeToken();
     // This must later be changed to a closure type if we recognize
     // a closure/function type parameter. We check this at the end
     // of ParseFormalParameter.
-    parameter.type = &Type::ZoneHandle(Type::VoidType());
+    parameter.type = &Type::ZoneHandle(I, Type::VoidType());
   }
   if (parameter.type == NULL) {
     // At this point, we must see an identifier for the type or the
     // function parameter.
     if (!IsIdentifier()) {
       ErrorMsg("parameter name or type expected");
     }
     // We have not seen a parameter type yet, so we check if the next
     // identifier could represent a type before parsing it.
     Token::Kind follower = LookaheadToken(1);
     // We have an identifier followed by a 'follower' token.
     // We either parse a type or assume that no type is specified.
     if ((follower == Token::kLT) ||  // Parameterized type.
         (follower == Token::kPERIOD) ||  // Qualified class name of type.
         Token::IsIdentifier(follower) ||  // Parameter name following a type.
         (follower == Token::kTHIS)) {  // Field parameter following a type.
       // The types of formal parameters are never ignored, even in unchecked
       // mode, because they are part of the function type of closurized
       // functions appearing in type tests with typedefs.
       parameter.has_explicit_type = true;
-      parameter.type = &AbstractType::ZoneHandle(
+      parameter.type = &AbstractType::ZoneHandle(I,
           ParseType(is_top_level_ ? ClassFinalizer::kResolveTypeParameters :
                                     ClassFinalizer::kCanonicalize));
     } else {
       // If this is an initializing formal, its type will be set to the type of
       // the respective field when the constructor is fully parsed.
-      parameter.type = &Type::ZoneHandle(Type::DynamicType());
+      parameter.type = &Type::ZoneHandle(I, Type::DynamicType());
     }
   }
   if (!this_seen && (CurrentToken() == Token::kTHIS)) {
     ConsumeToken();
     ExpectToken(Token::kPERIOD);
     this_seen = true;
     parameter.is_field_initializer = true;
   }
 
   // At this point, we must see an identifier for the parameter name.
@@ skipping 28 matching lines @@
       const AbstractType& result_type =
           AbstractType::Handle(isolate(), parameter.type->raw());
 
       // Finish parsing the function type parameter.
       ParamList func_params;
 
       // Add implicit closure object parameter.
       func_params.AddFinalParameter(
           TokenPos(),
           &Symbols::ClosureParameter(),
-          &Type::ZoneHandle(Type::DynamicType()));
+          &Type::ZoneHandle(I, Type::DynamicType()));
 
       const bool no_explicit_default_values = false;
       ParseFormalParameterList(no_explicit_default_values, false, &func_params);
 
       // The field 'is_static' has no meaning for signature functions.
       const Function& signature_function = Function::Handle(isolate(),
           Function::New(*parameter.name,
                         RawFunction::kSignatureFunction,
                         /* is_static = */ false,
                         /* is_const = */ false,
                         /* is_abstract = */ false,
                         /* is_external = */ false,
                         /* is_native = */ false,
                         current_class(),
                         parameter.name_pos));
       signature_function.set_result_type(result_type);
       AddFormalParamsToFunction(&func_params, signature_function);
       const String& signature = String::Handle(isolate(),
                                                signature_function.Signature());
       // Lookup the signature class, i.e. the class whose name is the signature.
       // We only lookup in the current library, but not in its imports, and only
       // create a new canonical signature class if it does not exist yet.
-      Class& signature_class = Class::ZoneHandle(
+      Class& signature_class = Class::ZoneHandle(I,
           library_.LookupLocalClass(signature));
       if (signature_class.IsNull()) {
         signature_class = Class::NewSignatureClass(signature,
                                                    signature_function,
                                                    script_,
                                                    parameter.name_pos);
         // Record the function signature class in the current library, unless
         // we are currently skipping a formal parameter list, in which case
         // the signature class could remain unfinalized.
         if (!params->skipped) {
           library_.AddClass(signature_class);
         }
       } else {
         signature_function.set_signature_class(signature_class);
       }
       ASSERT(signature_function.signature_class() == signature_class.raw());
-      Type& signature_type = Type::ZoneHandle(signature_class.SignatureType());
+      Type& signature_type =
+          Type::ZoneHandle(I, signature_class.SignatureType());
       if (!is_top_level_ && !signature_type.IsFinalized()) {
         signature_type ^= ClassFinalizer::FinalizeType(
             signature_class, signature_type, ClassFinalizer::kCanonicalize);
       }
       // A signature type itself cannot be malformed or malbounded, only its
       // signature function's result type or parameter types may be.
       ASSERT(!signature_type.IsMalformed());
       ASSERT(!signature_type.IsMalbounded());
       // The type of the parameter is now the signature type.
       parameter.type = &signature_type;
@@ skipping 132 matching lines @@
              String::Handle(isolate(), current_class().Name()).ToCString());
   }
   Function& super_func = Function::Handle(isolate(),
       Resolver::ResolveDynamicAnyArgs(super_class, name));
   if (!super_func.IsNull() &&
       !super_func.AreValidArguments(arguments->length(),
                                     arguments->names(),
                                     NULL)) {
     super_func = Function::null();
   } else if (super_func.IsNull() && resolve_getter) {
-    const String& getter_name = String::ZoneHandle(Field::GetterName(name));
+    const String& getter_name = String::ZoneHandle(I, Field::GetterName(name));
     super_func = Resolver::ResolveDynamicAnyArgs(super_class, getter_name);
     ASSERT(super_func.IsNull() ||
            (super_func.kind() != RawFunction::kImplicitStaticFinalGetter));
   }
   if (super_func.IsNull()) {
     super_func =
         Resolver::ResolveDynamicAnyArgs(super_class, Symbols::NoSuchMethod());
     ASSERT(!super_func.IsNull());
     *is_no_such_method = true;
   } else {
@@ skipping 78 matching lines @@
   const intptr_t supercall_pos = TokenPos();
 
   // 'this' parameter is the first argument to super call.
   ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
   AstNode* receiver = LoadReceiver(supercall_pos);
   arguments->Add(receiver);
   ParseActualParameters(arguments, kAllowConst);
 
   const bool kResolveGetter = true;
   bool is_no_such_method = false;
-  const Function& super_function = Function::ZoneHandle(
+  const Function& super_function = Function::ZoneHandle(I,
       GetSuperFunction(supercall_pos,
                        function_name,
                        arguments,
                        kResolveGetter,
                        &is_no_such_method));
   if (super_function.IsGetterFunction() ||
       super_function.IsImplicitGetterFunction()) {
-    const Class& super_class = Class::ZoneHandle(current_class().SuperClass());
+    const Class& super_class =
+        Class::ZoneHandle(I, current_class().SuperClass());
     AstNode* closure = new StaticGetterNode(supercall_pos,
                                             LoadReceiver(supercall_pos),
                                             /* is_super_getter */ true,
                                             super_class,
                                             function_name);
     // 'this' is not passed as parameter to the closure.
     ArgumentListNode* closure_arguments = new ArgumentListNode(supercall_pos);
     for (int i = 1; i < arguments->length(); i++) {
       closure_arguments->Add(arguments->NodeAt(i));
     }
@@ skipping 14 matching lines @@
 
 
 AstNode* Parser::BuildUnarySuperOperator(Token::Kind op, PrimaryNode* super) {
   ASSERT(super->IsSuper());
   AstNode* super_op = NULL;
   const intptr_t super_pos = super->token_pos();
   if ((op == Token::kNEGATE) ||
       (op == Token::kBIT_NOT)) {
     // Resolve the operator function in the superclass.
     const String& operator_function_name =
-        String::ZoneHandle(Symbols::New(Token::Str(op)));
+        String::ZoneHandle(I, Symbols::New(Token::Str(op)));
     ArgumentListNode* op_arguments = new ArgumentListNode(super_pos);
     AstNode* receiver = LoadReceiver(super_pos);
     op_arguments->Add(receiver);
     const bool kResolveGetter = false;
     bool is_no_such_method = false;
-    const Function& super_operator = Function::ZoneHandle(
+    const Function& super_operator = Function::ZoneHandle(I,
         GetSuperFunction(super_pos,
                          operator_function_name,
                          op_arguments,
                          kResolveGetter,
                          &is_no_such_method));
     if (is_no_such_method) {
       op_arguments = BuildNoSuchMethodArguments(
           super_pos, operator_function_name, *op_arguments, NULL, true);
     }
     super_op = new StaticCallNode(super_pos, super_operator, op_arguments);
   } else {
     ErrorMsg(super_pos, "illegal super operator call");
   }
   return super_op;
 }
 
 
 AstNode* Parser::ParseSuperOperator() {
   TRACE_PARSER("ParseSuperOperator");
   AstNode* super_op = NULL;
   const intptr_t operator_pos = TokenPos();
 
   if (CurrentToken() == Token::kLBRACK) {
     ConsumeToken();
     AstNode* index_expr = ParseExpr(kAllowConst, kConsumeCascades);
     ExpectToken(Token::kRBRACK);
     AstNode* receiver = LoadReceiver(operator_pos);
-    const Class& super_class = Class::ZoneHandle(current_class().SuperClass());
+    const Class& super_class =
+        Class::ZoneHandle(I, current_class().SuperClass());
     ASSERT(!super_class.IsNull());
     super_op =
         new LoadIndexedNode(operator_pos, receiver, index_expr, super_class);
   } else {
     ASSERT(Token::CanBeOverloaded(CurrentToken()) ||
            (CurrentToken() == Token::kNE));
     Token::Kind op = CurrentToken();
     ConsumeToken();
 
     bool negate_result = false;
     if (op == Token::kNE) {
       op = Token::kEQ;
       negate_result = true;
     }
 
     ASSERT(Token::Precedence(op) >= Token::Precedence(Token::kEQ));
     AstNode* other_operand = ParseBinaryExpr(Token::Precedence(op) + 1);
 
     ArgumentListNode* op_arguments = new ArgumentListNode(operator_pos);
     AstNode* receiver = LoadReceiver(operator_pos);
     op_arguments->Add(receiver);
     op_arguments->Add(other_operand);
 
     // Resolve the operator function in the superclass.
     const String& operator_function_name =
-        String::ZoneHandle(Symbols::New(Token::Str(op)));
+        String::ZoneHandle(I, Symbols::New(Token::Str(op)));
     const bool kResolveGetter = false;
     bool is_no_such_method = false;
-    const Function& super_operator = Function::ZoneHandle(
+    const Function& super_operator = Function::ZoneHandle(I,
         GetSuperFunction(operator_pos,
                          operator_function_name,
                          op_arguments,
                          kResolveGetter,
                          &is_no_such_method));
     if (is_no_such_method) {
       op_arguments = BuildNoSuchMethodArguments(
           operator_pos, operator_function_name, *op_arguments, NULL, true);
     }
     super_op = new StaticCallNode(operator_pos, super_operator, op_arguments);
     if (negate_result) {
       super_op = new UnaryOpNode(operator_pos, Token::kNOT, super_op);
     }
   }
   return super_op;
 }
 
 
 ClosureNode* Parser::CreateImplicitClosureNode(const Function& func,
                                                intptr_t token_pos,
                                                AstNode* receiver) {
   Function& implicit_closure_function =
-      Function::ZoneHandle(func.ImplicitClosureFunction());
+      Function::ZoneHandle(I, func.ImplicitClosureFunction());
   if (receiver != NULL) {
     // If we create an implicit instance closure from inside a closure of a
     // parameterized class, make sure that the receiver is captured as
     // instantiator.
     if (current_block_->scope->function_level() > 0) {
       const Class& signature_class = Class::Handle(isolate(),
           implicit_closure_function.signature_class());
       if (signature_class.NumTypeParameters() > 0) {
         CaptureInstantiator();
       }
     }
   }
   return new ClosureNode(token_pos, implicit_closure_function, receiver, NULL);
 }
 
 
 AstNode* Parser::ParseSuperFieldAccess(const String& field_name,
                                        intptr_t field_pos) {
   TRACE_PARSER("ParseSuperFieldAccess");
-  const Class& super_class = Class::ZoneHandle(current_class().SuperClass());
+  const Class& super_class = Class::ZoneHandle(I, current_class().SuperClass());
   if (super_class.IsNull()) {
     ErrorMsg("class '%s' does not have a superclass",
              String::Handle(isolate(), current_class().Name()).ToCString());
   }
   AstNode* implicit_argument = LoadReceiver(field_pos);
 
   const String& getter_name =
-      String::ZoneHandle(Field::GetterName(field_name));
-  const Function& super_getter = Function::ZoneHandle(
+      String::ZoneHandle(I, Field::GetterName(field_name));
+  const Function& super_getter = Function::ZoneHandle(I,
       Resolver::ResolveDynamicAnyArgs(super_class, getter_name));
   if (super_getter.IsNull()) {
     const String& setter_name =
-        String::ZoneHandle(Field::SetterName(field_name));
-    const Function& super_setter = Function::ZoneHandle(
+        String::ZoneHandle(I, Field::SetterName(field_name));
+    const Function& super_setter = Function::ZoneHandle(I,
         Resolver::ResolveDynamicAnyArgs(super_class, setter_name));
     if (super_setter.IsNull()) {
       // Check if this is an access to an implicit closure using 'super'.
       // If a function exists of the specified field_name then try
       // accessing it as a getter, at runtime we will handle this by
       // creating an implicit closure of the function and returning it.
-      const Function& super_function = Function::ZoneHandle(
+      const Function& super_function = Function::ZoneHandle(I,
           Resolver::ResolveDynamicAnyArgs(super_class, field_name));
       if (!super_function.IsNull()) {
         // In case CreateAssignmentNode is called later on this
         // CreateImplicitClosureNode, it will be replaced by a StaticSetterNode.
         return CreateImplicitClosureNode(super_function,
                                          field_pos,
                                          implicit_argument);
       }
       // No function or field exists of the specified field_name.
       // Emit a StaticGetterNode anyway, so that noSuchMethod gets called.
@@ skipping 20 matching lines @@
   String& super_ctor_name = String::Handle(isolate(), super_class.Name());
   super_ctor_name = String::Concat(super_ctor_name, Symbols::Dot());
 
   ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
   // Implicit 'this' parameter is the first argument.
   AstNode* implicit_argument = new LoadLocalNode(supercall_pos, receiver);
   arguments->Add(implicit_argument);
   // Implicit construction phase parameter is second argument.
   AstNode* phase_parameter =
       new LiteralNode(supercall_pos,
-                      Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll)));
+                      Smi::ZoneHandle(I, Smi::New(Function::kCtorPhaseAll)));
   arguments->Add(phase_parameter);
 
   // If this is a super call in a forwarding constructor, add the user-
   // defined arguments to the super call and adjust the the super
   // constructor name to the respective named constructor if necessary.
   if (forwarding_args != NULL) {
     for (int i = 0; i < forwarding_args->length(); i++) {
       arguments->Add(forwarding_args->NodeAt(i));
     }
     String& ctor_name = String::Handle(isolate(), current_function().name());
     String& class_name = String::Handle(isolate(), cls.Name());
     if (ctor_name.Length() > class_name.Length() + 1) {
       // Generating a forwarding call to a named constructor 'C.n'.
       // Add the constructor name 'n' to the super constructor.
       ctor_name = String::SubString(ctor_name, class_name.Length() + 1);
       super_ctor_name = String::Concat(super_ctor_name, ctor_name);
     }
   }
 
   // Resolve super constructor function and check arguments.
-  const Function& super_ctor = Function::ZoneHandle(
+  const Function& super_ctor = Function::ZoneHandle(I,
       super_class.LookupConstructor(super_ctor_name));
   if (super_ctor.IsNull()) {
       ErrorMsg(supercall_pos,
                "unresolved implicit call to super constructor '%s()'",
                String::Handle(isolate(), super_class.Name()).ToCString());
   }
   if (current_function().is_const() && !super_ctor.is_const()) {
     ErrorMsg(supercall_pos, "implicit call to non-const super constructor");
   }
 
@@ skipping 31 matching lines @@
   ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
   // 'this' parameter is the first argument to super class constructor.
   AstNode* implicit_argument = new LoadLocalNode(supercall_pos, receiver);
   arguments->Add(implicit_argument);
   // Second implicit parameter is the construction phase. We optimistically
   // assume that we can execute both the super initializer and the super
   // constructor body. We may later change this to only execute the
   // super initializer.
   AstNode* phase_parameter =
       new LiteralNode(supercall_pos,
-                      Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll)));
+                      Smi::ZoneHandle(I, Smi::New(Function::kCtorPhaseAll)));
   arguments->Add(phase_parameter);
   // 'this' parameter must not be accessible to the other super call arguments.
   receiver->set_invisible(true);
   ParseActualParameters(arguments, kAllowConst);
   receiver->set_invisible(false);
 
   // Resolve the constructor.
-  const Function& super_ctor = Function::ZoneHandle(
+  const Function& super_ctor = Function::ZoneHandle(I,
       super_class.LookupConstructor(ctor_name));
   if (super_ctor.IsNull()) {
     ErrorMsg(supercall_pos,
              "super class constructor '%s' not found",
              ctor_name.ToCString());
   }
   if (current_function().is_const() && !super_ctor.is_const()) {
     ErrorMsg(supercall_pos, "super constructor must be const");
   }
   String& error_message = String::Handle(isolate());
@@ skipping 27 matching lines @@
   AstNode* init_expr = ParseConditionalExpr();
   if (CurrentToken() == Token::kCASCADE) {
     init_expr = ParseCascades(init_expr);
   }
   receiver->set_invisible(false);
   SetAllowFunctionLiterals(saved_mode);
   if (current_function().is_const() && !init_expr->IsPotentiallyConst()) {
     ErrorMsg(field_pos,
              "initializer expression must be compile time constant.");
   }
-  Field& field = Field::ZoneHandle(cls.LookupInstanceField(field_name));
+  Field& field = Field::ZoneHandle(I, cls.LookupInstanceField(field_name));
   if (field.IsNull()) {
     ErrorMsg(field_pos, "unresolved reference to instance field '%s'",
              field_name.ToCString());
   }
   CheckDuplicateFieldInit(field_pos, initialized_fields, &field);
   AstNode* instance = new LoadLocalNode(field_pos, receiver);
   EnsureExpressionTemp();
   return new StoreInstanceFieldNode(field_pos, instance, field, init_expr);
 }
 
@@ skipping 68 matching lines @@
 void Parser::ParseInitializedInstanceFields(const Class& cls,
                  LocalVariable* receiver,
                  GrowableArray<Field*>* initialized_fields) {
   TRACE_PARSER("ParseInitializedInstanceFields");
   const Array& fields = Array::Handle(isolate(), cls.fields());
   Field& f = Field::Handle(isolate());
   const intptr_t saved_pos = TokenPos();
   for (int i = 0; i < fields.Length(); i++) {
     f ^= fields.At(i);
     if (!f.is_static() && f.has_initializer()) {
-      Field& field = Field::ZoneHandle();
+      Field& field = Field::ZoneHandle(I);
       field ^= fields.At(i);
       if (field.is_final()) {
         // Final fields with initializer expression may not be initialized
         // again by constructors. Remember that this field is already
         // initialized.
         initialized_fields->Add(&field);
       }
       AstNode* init_expr = NULL;
       if (current_class().raw() != field.origin()) {
         init_expr = ParseExternalInitializedField(field);
@@ skipping 97 matching lines @@
   arguments->Add(implicit_argument);
   // Construction phase parameter is second argument.
   LocalVariable* phase_param = LookupPhaseParameter();
   ASSERT(phase_param != NULL);
   AstNode* phase_argument = new LoadLocalNode(call_pos, phase_param);
   arguments->Add(phase_argument);
   receiver->set_invisible(true);
   ParseActualParameters(arguments, kAllowConst);
   receiver->set_invisible(false);
   // Resolve the constructor.
-  const Function& redirect_ctor = Function::ZoneHandle(
+  const Function& redirect_ctor = Function::ZoneHandle(I,
       cls.LookupConstructor(ctor_name));
   if (redirect_ctor.IsNull()) {
     ErrorMsg(call_pos, "constructor '%s' not found", ctor_name.ToCString());
   }
   String& error_message = String::Handle(isolate());
   if (!redirect_ctor.AreValidArguments(arguments->length(),
                                        arguments->names(),
                                        &error_message)) {
     ErrorMsg(call_pos,
              "invalid arguments passed to constructor '%s': %s",
@@ skipping 11 matching lines @@
   const intptr_t ctor_pos = TokenPos();
   OpenFunctionBlock(func);
 
   LocalVariable* receiver = new LocalVariable(
       Scanner::kNoSourcePos, Symbols::This(), *ReceiverType(current_class()));
   current_block_->scope->InsertParameterAt(0, receiver);
 
   LocalVariable* phase_parameter =
       new LocalVariable(Scanner::kNoSourcePos,
                         Symbols::PhaseParameter(),
-                        Type::ZoneHandle(Type::SmiType()));
+                        Type::ZoneHandle(I, Type::SmiType()));
   current_block_->scope->InsertParameterAt(1, phase_parameter);
 
   // Parse expressions of instance fields that have an explicit
   // initializer expression.
   // The receiver must not be visible to field initializer expressions.
   receiver->set_invisible(true);
   GrowableArray<Field*> initialized_fields;
   ParseInitializedInstanceFields(
       current_class(), receiver, &initialized_fields);
   receiver->set_invisible(false);
@@ skipping 19 matching lines @@
       ErrorMsg(ctor_pos,
                "forwarding constructors must not have optional parameters");
     }
 
     // Prepare user-defined arguments to be forwarded to super call.
     // The first user-defined argument is at position 2.
     forwarding_args = new ArgumentListNode(Scanner::kNoSourcePos);
     for (int i = 2; i < func.NumParameters(); i++) {
       LocalVariable* param = new LocalVariable(
           Scanner::kNoSourcePos,
-          String::ZoneHandle(func.ParameterNameAt(i)),
-          Type::ZoneHandle(Type::DynamicType()));
+          String::ZoneHandle(I, func.ParameterNameAt(i)),
+          Type::ZoneHandle(I, Type::DynamicType()));
       current_block_->scope->InsertParameterAt(i, param);
       forwarding_args->Add(new LoadLocalNode(Scanner::kNoSourcePos, param));
     }
   }
 
   GenerateSuperConstructorCall(current_class(),
                                Scanner::kNoSourcePos,
                                receiver,
                                forwarding_args);
   CheckFieldsInitialized(current_class());
@@ skipping 53 matching lines @@
 
   // Add implicit receiver parameter which is passed the allocated
   // but uninitialized instance to construct.
   ASSERT(current_class().raw() == func.Owner());
   params.AddReceiver(ReceiverType(current_class()), func.token_pos());
 
   // Add implicit parameter for construction phase.
   params.AddFinalParameter(
       TokenPos(),
       &Symbols::PhaseParameter(),
-      &Type::ZoneHandle(Type::SmiType()));
+      &Type::ZoneHandle(I, Type::SmiType()));
 
   if (func.is_const()) {
     params.SetImplicitlyFinal();
   }
   ParseFormalParameterList(allow_explicit_default_values, false, &params);
 
   SetupDefaultsForOptionalParams(&params, default_parameter_values);
   ASSERT(AbstractType::Handle(isolate(), func.result_type()).IsResolved());
   ASSERT(func.NumParameters() == params.parameters->length());
 
@@ skipping 26 matching lines @@
   }
 
   // Turn formal field parameters into field initializers.
   if (params.has_field_initializer) {
     // First two parameters are implicit receiver and phase.
     ASSERT(params.parameters->length() >= 2);
     for (int i = 2; i < params.parameters->length(); i++) {
       ParamDesc& param = (*params.parameters)[i];
       if (param.is_field_initializer) {
         const String& field_name = *param.name;
-        Field& field = Field::ZoneHandle(cls.LookupInstanceField(field_name));
+        Field& field =
+            Field::ZoneHandle(I, cls.LookupInstanceField(field_name));
         if (field.IsNull()) {
           ErrorMsg(param.name_pos,
                    "unresolved reference to instance field '%s'",
                    field_name.ToCString());
         }
         if (is_redirecting_constructor) {
           ErrorMsg(param.name_pos,
                    "redirecting constructors may not have "
                    "initializing formal parameters");
         }
         CheckDuplicateFieldInit(param.name_pos, &initialized_fields, &field);
 
         if (!param.has_explicit_type) {
           const AbstractType& field_type =
-              AbstractType::ZoneHandle(field.type());
+              AbstractType::ZoneHandle(I, field.type());
           param.type = &field_type;
           // Parameter type was already set to dynamic when parsing the class
           // declaration: fix it.
           func.SetParameterTypeAt(i, field_type);
         }
 
         AstNode* instance = new LoadLocalNode(param.name_pos, receiver);
         // Initializing formals cannot be used in the explicit initializer
         // list, nor can they be used in the constructor body.
         // Thus, they are set to be invisible when added to the scope.
@@ skipping 21 matching lines @@
     // the target which executes the corresponding phase.
     current_block_->statements->Add(init_statements);
   } else if (init_statements->length() > 0) {
     // Generate guard around the initializer code.
     LocalVariable* phase_param = LookupPhaseParameter();
     AstNode* phase_value = new
         LoadLocalNode(Scanner::kNoSourcePos, phase_param);
     AstNode* phase_check = new BinaryOpNode(
         Scanner::kNoSourcePos, Token::kBIT_AND, phase_value,
         new LiteralNode(Scanner::kNoSourcePos,
-                        Smi::ZoneHandle(Smi::New(Function::kCtorPhaseInit))));
+            Smi::ZoneHandle(I, Smi::New(Function::kCtorPhaseInit))));
     AstNode* comparison =
         new ComparisonNode(Scanner::kNoSourcePos,
                            Token::kNE_STRICT,
                            phase_check,
                            new LiteralNode(TokenPos(),
-                                           Smi::ZoneHandle(Smi::New(0))));
+                                           Smi::ZoneHandle(I, Smi::New(0))));
     AstNode* guarded_init_statements =
         new IfNode(Scanner::kNoSourcePos,
                    comparison,
                    init_statements,
                    NULL);
     current_block_->statements->Add(guarded_init_statements);
   }
 
   // Parsing of initializers done. Now we parse the constructor body
   // and add the implicit super call to the super constructor's body
@@ skipping 41 matching lines @@
     }
   }
   OpenBlock();  // Block to collect constructor body nodes.
   intptr_t body_pos = TokenPos();
 
   // Insert the implicit super call to the super constructor body.
   if (super_call != NULL) {
     ArgumentListNode* initializer_args = super_call->arguments();
     const Function& super_ctor = super_call->function();
     // Patch the initializer call so it only executes the super initializer.
-    initializer_args->SetNodeAt(1,
-        new LiteralNode(body_pos,
-                        Smi::ZoneHandle(Smi::New(Function::kCtorPhaseInit))));
+    initializer_args->SetNodeAt(1, new LiteralNode(
+        body_pos, Smi::ZoneHandle(I, Smi::New(Function::kCtorPhaseInit))));
 
     ArgumentListNode* super_call_args = new ArgumentListNode(body_pos);
     // First argument is the receiver.
     super_call_args->Add(new LoadLocalNode(body_pos, receiver));
     // Second argument is the construction phase argument.
-    AstNode* phase_parameter =
-        new LiteralNode(body_pos,
-                        Smi::ZoneHandle(Smi::New(Function::kCtorPhaseBody)));
+    AstNode* phase_parameter = new(I) LiteralNode(
+        body_pos, Smi::ZoneHandle(I, Smi::New(Function::kCtorPhaseBody)));
     super_call_args->Add(phase_parameter);
     super_call_args->set_names(initializer_args->names());
     for (int i = 2; i < initializer_args->length(); i++) {
       AstNode* arg = initializer_args->NodeAt(i);
       if (arg->IsLiteralNode()) {
         LiteralNode* lit = arg->AsLiteralNode();
         super_call_args->Add(new LiteralNode(body_pos, lit->literal()));
       } else {
         ASSERT(arg->IsLoadLocalNode() || arg->IsStoreLocalNode());
         if (arg->IsLoadLocalNode()) {
@@ skipping 85 matching lines @@
 
   ParamList params;
   // An instance closure function may capture and access the receiver, but via
   // the context and not via the first formal parameter.
   if (func.IsClosureFunction()) {
     // The first parameter of a closure function is the closure object.
     ASSERT(!func.is_const());  // Closure functions cannot be const.
     params.AddFinalParameter(
         TokenPos(),
         &Symbols::ClosureParameter(),
-        &Type::ZoneHandle(Type::DynamicType()));
+        &Type::ZoneHandle(I, Type::DynamicType()));
   } else if (!func.is_static()) {
     // Static functions do not have a receiver.
     ASSERT(current_class().raw() == func.Owner());
     params.AddReceiver(ReceiverType(current_class()), func.token_pos());
   } else if (func.IsFactory()) {
     // The first parameter of a factory is the TypeArguments vector of
     // the type of the instance to be allocated.
     params.AddFinalParameter(
         TokenPos(),
         &Symbols::TypeArgumentsParameter(),
-        &Type::ZoneHandle(Type::DynamicType()));
+        &Type::ZoneHandle(I, Type::DynamicType()));
   }
   ASSERT((CurrentToken() == Token::kLPAREN) || func.IsGetterFunction());
   const bool allow_explicit_default_values = true;
   if (func.IsGetterFunction()) {
     // Populate function scope with the formal parameters. Since in this case
     // we are compiling a getter this will at most populate the receiver.
     AddFormalParamsToScope(&params, current_block_->scope);
   } else {
     ParseFormalParameterList(allow_explicit_default_values, false, &params);
 
@@ skipping 68 matching lines @@
       const Class& owner = Class::Handle(isolate(), func.Owner());
       if (!owner.IsObjectClass()) {
         AddEqualityNullCheck();
       }
     }
     ParseNativeFunctionBlock(&params, func);
     end_token_pos = TokenPos();
     ExpectSemicolon();
   } else if (func.is_external()) {
     // Body of an external method contains a single throw.
-    const String& function_name = String::ZoneHandle(func.name());
+    const String& function_name = String::ZoneHandle(I, func.name());
     // TODO(regis): For an instance function, pass the receiver to
     // NoSuchMethodError.
     current_block_->statements->Add(
         ThrowNoSuchMethodError(TokenPos(),
                                current_class(),
                                function_name,
                                NULL,   // No arguments.
                                func.is_static() ?
                                    InvocationMirror::kStatic :
                                    InvocationMirror::kDynamic,
@@ skipping 13 matching lines @@
   last_used_try_index_ = saved_try_index;
   return CloseBlock();
 }
 
 
 void Parser::AddEqualityNullCheck() {
   AstNode* argument =
       new LoadLocalNode(Scanner::kNoSourcePos,
                         current_block_->scope->parent()->VariableAt(1));
   LiteralNode* null_operand =
-      new LiteralNode(Scanner::kNoSourcePos, Instance::ZoneHandle());
+      new LiteralNode(Scanner::kNoSourcePos, Instance::ZoneHandle(I));
   ComparisonNode* check_arg =
       new ComparisonNode(Scanner::kNoSourcePos,
                          Token::kEQ_STRICT,
                          argument,
                          null_operand);
   ComparisonNode* result =
       new ComparisonNode(Scanner::kNoSourcePos,
                          Token::kEQ_STRICT,
                          LoadReceiver(Scanner::kNoSourcePos),
                          null_operand);
@@ skipping 61 matching lines @@
   qual_ident->ident_pos = TokenPos();
   qual_ident->ident = CurrentLiteral();
   qual_ident->lib_prefix = NULL;
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     // An identifier cannot be resolved in a local scope when top level parsing.
     if (is_top_level_ ||
         !ResolveIdentInLocalScope(qual_ident->ident_pos,
                                   *(qual_ident->ident),
                                   NULL)) {
-      LibraryPrefix& lib_prefix = LibraryPrefix::ZoneHandle();
+      LibraryPrefix& lib_prefix = LibraryPrefix::ZoneHandle(I);
       if (!current_class().IsMixinApplication()) {
         lib_prefix = current_class().LookupLibraryPrefix(*(qual_ident->ident));
       } else {
         // TODO(hausner): Should we resolve the prefix via the library scope
         // rather than via the class?
         Class& cls = Class::Handle(isolate(),
                                    parsed_function()->function().origin());
         lib_prefix = cls.LookupLibraryPrefix(*(qual_ident->ident));
       }
       if (!lib_prefix.IsNull()) {
@@ skipping 49 matching lines @@
   method->params.Clear();
   // Static functions do not have a receiver.
   // The first parameter of a factory is the TypeArguments vector of
   // the type of the instance to be allocated.
   if (!method->has_static || method->IsConstructor()) {
     method->params.AddReceiver(ReceiverType(current_class()), formal_param_pos);
   } else if (method->IsFactory()) {
     method->params.AddFinalParameter(
         formal_param_pos,
         &Symbols::TypeArgumentsParameter(),
-        &Type::ZoneHandle(Type::DynamicType()));
+        &Type::ZoneHandle(I, Type::DynamicType()));
   }
   // Constructors have an implicit parameter for the construction phase.
   if (method->IsConstructor()) {
     method->params.AddFinalParameter(
         TokenPos(),
         &Symbols::PhaseParameter(),
-        &Type::ZoneHandle(Type::SmiType()));
+        &Type::ZoneHandle(I, Type::SmiType()));
   }
   if (are_implicitly_final) {
     method->params.SetImplicitlyFinal();
   }
   if (!method->IsGetter()) {
     ParseFormalParameterList(allow_explicit_default_values,
                              false,
                              &method->params);
   }
 
@@ skipping 10 matching lines @@
     CheckOperatorArity(*method);
   }
 
   // Mangle the name for getter and setter functions and check function
   // arity.
   if (method->IsGetter() || method->IsSetter()) {
     int expected_num_parameters = 0;
     if (method->IsGetter()) {
       expected_num_parameters = (method->has_static) ? 0 : 1;
       method->dict_name = method->name;
-      method->name = &String::ZoneHandle(Field::GetterSymbol(*method->name));
+      method->name = &String::ZoneHandle(I, Field::GetterSymbol(*method->name));
     } else {
       ASSERT(method->IsSetter());
       expected_num_parameters = (method->has_static) ? 1 : 2;
-      method->dict_name =
-          &String::ZoneHandle(String::Concat(*method->name, Symbols::Equals()));
-      method->name = &String::ZoneHandle(Field::SetterSymbol(*method->name));
+      method->dict_name = &String::ZoneHandle(I,
+          String::Concat(*method->name, Symbols::Equals()));
+      method->name = &String::ZoneHandle(I, Field::SetterSymbol(*method->name));
     }
     if ((method->params.num_fixed_parameters != expected_num_parameters) ||
         (method->params.num_optional_parameters != 0)) {
       ErrorMsg(method->name_pos, "illegal %s parameters",
                method->IsGetter() ? "getter" : "setter");
     }
   }
 
   // Parse redirecting factory constructor.
   Type& redirection_type = Type::Handle(isolate());
@@ skipping 40 matching lines @@
       // Redirected constructor: either this(...) or this.xxx(...).
       is_redirecting = true;
       if (method->params.has_field_initializer) {
         // Constructors that redirect to another constructor must not
         // initialize any fields using field initializer parameters.
         ErrorMsg(formal_param_pos, "Redirecting constructor "
                  "may not use field initializer parameters");
       }
       ConsumeToken();  // Colon.
       ExpectToken(Token::kTHIS);
-      String& redir_name = String::ZoneHandle(
+      String& redir_name = String::ZoneHandle(I,
           String::Concat(members->class_name(), Symbols::Dot()));
       if (CurrentToken() == Token::kPERIOD) {
         ConsumeToken();
         redir_name = String::Concat(redir_name,
             *ExpectIdentifier("constructor name expected"));
       }
       method->redirect_name = &redir_name;
       CheckToken(Token::kLPAREN);
       SkipToMatchingParenthesis();
     } else {
@@ skipping 165 matching lines @@
     ErrorMsg("keyword 'external' not allowed in field declaration");
   }
   if (field->has_factory) {
     ErrorMsg("keyword 'factory' not allowed in field declaration");
   }
   if (!field->has_static && field->has_const) {
     ErrorMsg(field->name_pos, "instance field may not be 'const'");
   }
   Function& getter = Function::Handle(isolate());
   Function& setter = Function::Handle(isolate());
-  Field& class_field = Field::ZoneHandle();
+  Field& class_field = Field::ZoneHandle(I);
   Instance& init_value = Instance::Handle(isolate());
   while (true) {
     bool has_initializer = CurrentToken() == Token::kASSIGN;
     bool has_simple_literal = false;
     if (has_initializer) {
       ConsumeToken();
       init_value = Object::sentinel().raw();
       // For static fields, the initialization expression will be parsed
       // through the kImplicitStaticFinalGetter method invocation/compilation.
       // For instance fields, the expression is parsed when a constructor
@@ skipping 50 matching lines @@
                                /* is_abstract = */ false,
                                /* is_external = */ false,
                                /* is_native = */ false,
                                current_class(),
                                field->name_pos);
         getter.set_result_type(*field->type);
         members->AddFunction(getter);
 
         // Create initializer function for non-const fields.
         if (!class_field.is_const()) {
-          const Function& init_function = Function::ZoneHandle(
+          const Function& init_function = Function::ZoneHandle(I,
               Function::NewStaticInitializer(class_field));
           members->AddFunction(init_function);
         }
       }
     }
 
     // For instance fields, we create implicit getter and setter methods.
     if (!field->has_static) {
       String& getter_name = String::Handle(isolate(),
                                            Field::GetterSymbol(*field->name));
@@ skipping 122 matching lines @@
   if (CurrentToken() == Token::kVAR) {
     if (member.has_const) {
       ErrorMsg("identifier expected after 'const'");
     }
     if (member.has_final) {
       ErrorMsg("identifier expected after 'final'");
     }
     ConsumeToken();
     member.has_var = true;
     // The member type is the 'dynamic' type.
-    member.type = &Type::ZoneHandle(Type::DynamicType());
+    member.type = &Type::ZoneHandle(I, Type::DynamicType());
   } else if (CurrentToken() == Token::kFACTORY) {
     ConsumeToken();
     if (member.has_static) {
       ErrorMsg("factory method cannot be explicitly marked static");
     }
     member.has_factory = true;
     member.has_static = true;
     // The result type depends on the name of the factory method.
   }
   // Optionally parse a type.
   if (CurrentToken() == Token::kVOID) {
     if (member.has_var || member.has_factory) {
       ErrorMsg("void not expected");
     }
     ConsumeToken();
     ASSERT(member.type == NULL);
-    member.type = &Type::ZoneHandle(Type::VoidType());
+    member.type = &Type::ZoneHandle(I, Type::VoidType());
   } else if (CurrentToken() == Token::kIDENT) {
     // This is either a type name or the name of a method/constructor/field.
     if ((member.type == NULL) && !member.has_factory) {
       // We have not seen a member type yet, so we check if the next
       // identifier could represent a type before parsing it.
       Token::Kind follower = LookaheadToken(1);
       // We have an identifier followed by a 'follower' token.
       // We either parse a type or assume that no type is specified.
       if ((follower == Token::kLT) ||  // Parameterized type.
           (follower == Token::kGET) ||  // Getter following a type.
           (follower == Token::kSET) ||  // Setter following a type.
           (follower == Token::kOPERATOR) ||  // Operator following a type.
           (Token::IsIdentifier(follower)) ||  // Member name following a type.
           ((follower == Token::kPERIOD) &&    // Qualified class name of type,
            (LookaheadToken(3) != Token::kLPAREN))) {  // but not a named constr.
         ASSERT(is_top_level_);
         // The declared type of fields is never ignored, even in unchecked mode,
         // because getters and setters could be closurized at some time (not
         // supported yet).
-        member.type = &AbstractType::ZoneHandle(
+        member.type = &AbstractType::ZoneHandle(I,
             ParseType(ClassFinalizer::kResolveTypeParameters));
       }
     }
   }
 
   // Optionally parse a (possibly named) constructor name or factory.
   if (IsIdentifier() &&
       (CurrentLiteral()->Equals(members->class_name()) || member.has_factory)) {
     member.name_pos = TokenPos();
     member.name = CurrentLiteral();  // Unqualified identifier.
@@ skipping 13 matching lines @@
     }
     // Do not bypass class resolution by using current_class() directly, since
     // it may be a patch class.
     const Object& result_type_class = Object::Handle(isolate(),
         UnresolvedClass::New(LibraryPrefix::Handle(isolate()),
                              *member.name,
                              member.name_pos));
     // The type arguments of the result type are the type parameters of the
     // current class. Note that in the case of a patch class, they are copied
     // from the class being patched.
-    member.type = &Type::ZoneHandle(Type::New(
+    member.type = &Type::ZoneHandle(I, Type::New(
         result_type_class,
         TypeArguments::Handle(isolate(), current_class().type_parameters()),
         member.name_pos));
 
     // We must be dealing with a constructor or named constructor.
     member.kind = RawFunction::kConstructor;
     *member.name = String::Concat(*member.name, Symbols::Dot());
     if (CurrentToken() == Token::kPERIOD) {
       // Named constructor.
       ConsumeToken();
@@ skipping 20 matching lines @@
              (LookaheadToken(1) != Token::kCOMMA)  &&
              (LookaheadToken(1) != Token::kSEMICOLON))  {
     ConsumeToken();
     member.kind = RawFunction::kSetterFunction;
     member.name_pos = this->TokenPos();
     member.name = ExpectIdentifier("identifier expected");
     CheckToken(Token::kLPAREN);
     // The grammar allows a return type, so member.type is not always NULL here.
     // If no return type is specified, the return type of the setter is dynamic.
     if (member.type == NULL) {
-      member.type = &Type::ZoneHandle(Type::DynamicType());
+      member.type = &Type::ZoneHandle(I, Type::DynamicType());
     }
   } else if ((CurrentToken() == Token::kOPERATOR) && !member.has_var &&
              (LookaheadToken(1) != Token::kLPAREN) &&
              (LookaheadToken(1) != Token::kASSIGN) &&
              (LookaheadToken(1) != Token::kCOMMA)  &&
              (LookaheadToken(1) != Token::kSEMICOLON)) {
     ConsumeToken();
     if (!Token::CanBeOverloaded(CurrentToken())) {
       ErrorMsg("invalid operator overloading");
     }
     if (member.has_static) {
       ErrorMsg("operator overloading functions cannot be static");
     }
     member.operator_token = CurrentToken();
     member.has_operator = true;
     member.kind = RawFunction::kRegularFunction;
     member.name_pos = this->TokenPos();
     member.name =
-        &String::ZoneHandle(Symbols::New(Token::Str(member.operator_token)));
+        &String::ZoneHandle(I, Symbols::New(Token::Str(member.operator_token)));
     ConsumeToken();
   } else if (IsIdentifier()) {
     member.name = CurrentLiteral();
     member.name_pos = TokenPos();
     ConsumeToken();
   } else {
     ErrorMsg("identifier expected");
   }
 
   ASSERT(member.name != NULL);
   if (CurrentToken() == Token::kLPAREN || member.IsGetter()) {
     // Constructor or method.
     if (member.type == NULL) {
-      member.type = &Type::ZoneHandle(Type::DynamicType());
+      member.type = &Type::ZoneHandle(I, Type::DynamicType());
     }
     ASSERT(member.IsFactory() == member.has_factory);
     ParseMethodOrConstructor(members, &member);
   } else if (CurrentToken() ==  Token::kSEMICOLON ||
              CurrentToken() == Token::kCOMMA ||
              CurrentToken() == Token::kASSIGN) {
     // Field definition.
     if (member.has_const) {
       // const fields are implicitly final.
       member.has_final = true;
     }
     if (member.type == NULL) {
       if (member.has_final) {
-        member.type = &Type::ZoneHandle(Type::DynamicType());
+        member.type = &Type::ZoneHandle(I, Type::DynamicType());
       } else {
         ErrorMsg("missing 'var', 'final', 'const' or type"
                  " in field declaration");
       }
     }
     ParseFieldDefinition(members, &member);
   } else {
     UnexpectedToken();
   }
   current_member_ = NULL;
@@ skipping 232 matching lines @@
     if (!orig_class.ApplyPatch(cls, &error)) {
       AppendErrorMsg(error, class_pos, "applying patch failed");
     }
   }
 }
 
 
 // Add an implicit constructor to the given class.
 void Parser::AddImplicitConstructor(const Class& cls) {
   // The implicit constructor is unnamed, has no explicit parameter.
-  String& ctor_name = String::ZoneHandle(cls.Name());
+  String& ctor_name = String::ZoneHandle(I, cls.Name());
   ctor_name = String::Concat(ctor_name, Symbols::Dot());
   ctor_name = Symbols::New(ctor_name);
   // To indicate that this is an implicit constructor, we set the
   // token position and end token position of the function
   // to the token position of the class.
   Function& ctor = Function::Handle(isolate(),
       Function::New(ctor_name,
                     RawFunction::kConstructor,
                     /* is_static = */ false,
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     /* is_external = */ false,
                     /* is_native = */ false,
                     cls,
                     cls.token_pos()));
   ctor.set_end_token_pos(ctor.token_pos());
   if (library_.is_dart_scheme() && library_.IsPrivate(ctor_name)) {
     ctor.set_is_visible(false);
   }
 
   ParamList params;
   // Add implicit 'this' parameter.
   const AbstractType* receiver_type = ReceiverType(cls);
   params.AddReceiver(receiver_type, cls.token_pos());
   // Add implicit parameter for construction phase.
   params.AddFinalParameter(cls.token_pos(),
                            &Symbols::PhaseParameter(),
-                           &Type::ZoneHandle(Type::SmiType()));
+                           &Type::ZoneHandle(I, Type::SmiType()));
 
   AddFormalParamsToFunction(&params, ctor);
   // The body of the constructor cannot modify the type of the constructed
   // instance, which is passed in as the receiver.
   ctor.set_result_type(*receiver_type);
   cls.AddFunction(ctor);
 }
 
 
 // Check for cycles in constructor redirection.
@@ skipping 188 matching lines @@
                          &result_type);
   }
   // Parse the formal parameters of the function type.
   CheckToken(Token::kLPAREN, "formal parameter list expected");
   ParamList func_params;
 
   // Add implicit closure object parameter.
   func_params.AddFinalParameter(
       TokenPos(),
       &Symbols::ClosureParameter(),
-      &Type::ZoneHandle(Type::DynamicType()));
+      &Type::ZoneHandle(I, Type::DynamicType()));
 
   const bool no_explicit_default_values = false;
   ParseFormalParameterList(no_explicit_default_values, false, &func_params);
   ExpectSemicolon();
   // The field 'is_static' has no meaning for signature functions.
   Function& signature_function = Function::Handle(isolate(),
       Function::New(*alias_name,
                     RawFunction::kSignatureFunction,
                     /* is_static = */ false,
                     /* is_const = */ false,
@@ skipping 10 matching lines @@
 
   const String& signature = String::Handle(isolate(),
                                            signature_function.Signature());
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing function type alias '%s'\n",
               signature.ToCString());
   }
   // Lookup the signature class, i.e. the class whose name is the signature.
   // We only lookup in the current library, but not in its imports, and only
   // create a new canonical signature class if it does not exist yet.
-  Class& signature_class = Class::ZoneHandle(
+  Class& signature_class = Class::ZoneHandle(I,
       library_.LookupLocalClass(signature));
   if (signature_class.IsNull()) {
     signature_class = Class::NewSignatureClass(signature,
                                                signature_function,
                                                script_,
                                                alias_name_pos);
     // Record the function signature class in the current library.
     library_.AddClass(signature_class);
   } else {
     // Forget the just created signature function and use the existing one.
@@ skipping 246 matching lines @@
 }
 
 
 void Parser::ParseTopLevelVariable(TopLevel* top_level,
                                    intptr_t metadata_pos) {
   TRACE_PARSER("ParseTopLevelVariable");
   const bool is_const = (CurrentToken() == Token::kCONST);
   // Const fields are implicitly final.
   const bool is_final = is_const || (CurrentToken() == Token::kFINAL);
   const bool is_static = true;
-  const AbstractType& type = AbstractType::ZoneHandle(ParseConstFinalVarOrType(
-      ClassFinalizer::kResolveTypeParameters));
+  const AbstractType& type = AbstractType::ZoneHandle(I,
+      ParseConstFinalVarOrType(ClassFinalizer::kResolveTypeParameters));
   Field& field = Field::Handle(isolate());
   Function& getter = Function::Handle(isolate());
   while (true) {
     const intptr_t name_pos = TokenPos();
     String& var_name = *ExpectIdentifier("variable name expected");
 
     if (library_.LookupLocalObject(var_name) != Object::null()) {
       ErrorMsg(name_pos, "'%s' is already defined", var_name.ToCString());
     }
 
@@ skipping 43 matching lines @@
                                /* is_abstract = */ false,
                                /* is_external = */ false,
                                /* is_native = */ false,
                                current_class(),
                                name_pos);
         getter.set_result_type(type);
         top_level->functions.Add(getter);
 
         // Create initializer function.
         if (!field.is_const()) {
-          const Function& init_function = Function::ZoneHandle(
+          const Function& init_function = Function::ZoneHandle(I,
               Function::NewStaticInitializer(field));
           top_level->functions.Add(init_function);
         }
       }
     } else if (is_final) {
       ErrorMsg(name_pos, "missing initializer for final or const variable");
     }
 
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
@@ skipping 148 matching lines @@
   const intptr_t name_pos = TokenPos();
   const String* field_name = ExpectIdentifier("accessor name expected");
 
   const intptr_t accessor_pos = TokenPos();
   ParamList params;
 
   if (!is_getter) {
     const bool allow_explicit_default_values = true;
     ParseFormalParameterList(allow_explicit_default_values, false, &params);
   }
-  String& accessor_name = String::ZoneHandle();
+  String& accessor_name = String::ZoneHandle(I);
   int expected_num_parameters = -1;
   if (is_getter) {
     expected_num_parameters = 0;
     accessor_name = Field::GetterSymbol(*field_name);
   } else {
     expected_num_parameters = 1;
     accessor_name = Field::SetterSymbol(*field_name);
   }
   if ((params.num_fixed_parameters != expected_num_parameters) ||
       (params.num_optional_parameters != 0)) {
@@ skipping 589 matching lines @@
              native_name.ToCString(), func.NumParameters());
   }
   func.SetIsNativeAutoSetupScope(auto_setup_scope);
 
   // Now add the NativeBodyNode and return statement.
   Dart_NativeEntryResolver resolver = library.native_entry_resolver();
   bool is_bootstrap_native = Bootstrap::IsBootstapResolver(resolver);
   current_block_->statements->Add(new(isolate()) ReturnNode(
       TokenPos(), new(isolate()) NativeBodyNode(
           TokenPos(),
-          Function::ZoneHandle(func.raw()),
+          Function::ZoneHandle(I, func.raw()),
           native_name,
           native_function,
           current_block_->scope,
           is_bootstrap_native)));
 }
 
 
 LocalVariable* Parser::LookupReceiver(LocalScope* from_scope, bool test_only) {
   ASSERT(!current_function().is_static());
   return from_scope->LookupVariable(Symbols::This(), test_only);
@@ skipping 81 matching lines @@
     if (is_const) {
       ASSERT(expr->IsLiteralNode());
       variable->SetConstValue(expr->AsLiteralNode()->literal());
     }
   } else if (is_final || is_const) {
     ErrorMsg(ident_pos,
     "missing initialization of 'final' or 'const' variable");
   } else {
     // Initialize variable with null.
     AstNode* null_expr = new(isolate()) LiteralNode(
-        ident_pos, Instance::ZoneHandle());
+        ident_pos, Instance::ZoneHandle(I));
     initialization = new(isolate()) StoreLocalNode(
         ident_pos, variable, null_expr);
   }
 
   ASSERT(current_block_ != NULL);
   const intptr_t previous_pos =
   current_block_->scope->PreviousReferencePos(ident);
   if (previous_pos >= 0) {
     ASSERT(!script_.IsNull());
     if (previous_pos > ident_pos) {
@@ skipping 72 matching lines @@
 
 
 // Returns ast nodes of the variable initialization. Variables without an
 // explicit initializer are initialized to null. If several variables are
 // declared, the individual initializers are collected in a sequence node.
 AstNode* Parser::ParseVariableDeclarationList() {
   TRACE_PARSER("ParseVariableDeclarationList");
   SkipMetadata();
   bool is_final = (CurrentToken() == Token::kFINAL);
   bool is_const = (CurrentToken() == Token::kCONST);
-  const AbstractType& type = AbstractType::ZoneHandle(ParseConstFinalVarOrType(
-      FLAG_enable_type_checks ? ClassFinalizer::kCanonicalize :
-                                ClassFinalizer::kIgnore));
+  const AbstractType& type = AbstractType::ZoneHandle(I,
+      ParseConstFinalVarOrType(FLAG_enable_type_checks ?
+          ClassFinalizer::kCanonicalize : ClassFinalizer::kIgnore));
   if (!IsIdentifier()) {
     ErrorMsg("identifier expected");
   }
 
   AstNode* initializers = ParseVariableDeclaration(type, is_final, is_const);
   ASSERT(initializers != NULL);
   while (CurrentToken() == Token::kCOMMA) {
     ConsumeToken();
     if (!IsIdentifier()) {
       ErrorMsg("identifier expected after comma");
@@ skipping 49 matching lines @@
                line_number);
     }
   }
   CheckToken(Token::kLPAREN);
 
   // Check whether we have parsed this closure function before, in a previous
   // compilation. If so, reuse the function object, else create a new one
   // and register it in the current class.
   // Note that we cannot share the same closure function between the closurized
   // and non-closurized versions of the same parent function.
-  Function& function = Function::ZoneHandle();
+  Function& function = Function::ZoneHandle(I);
   bool is_new_closure = false;
   // TODO(hausner): There could be two different closures at the given
   // function_pos, one enclosed in a closurized function and one enclosed in the
   // non-closurized version of this same function.
   function = current_class().LookupClosureFunction(function_pos);
   if (function.IsNull() || (function.token_pos() != function_pos) ||
       (function.parent_function() != innermost_function().raw())) {
     // The function will be registered in the lookup table by the
     // EffectGraphVisitor::VisitClosureNode when the newly allocated closure
     // function has been properly setup.
     is_new_closure = true;
     function = Function::NewClosureFunction(*function_name,
                                             innermost_function(),
                                             function_pos);
     function.set_result_type(result_type);
   }
 
   // The function type needs to be finalized at compile time, since the closure
   // may be type checked at run time when assigned to a function variable,
   // passed as a function argument, or returned as a function result.
 
   LocalVariable* function_variable = NULL;
-  Type& function_type = Type::ZoneHandle();
+  Type& function_type = Type::ZoneHandle(I);
   if (variable_name != NULL) {
     // Since the function type depends on the signature of the closure function,
     // it cannot be determined before the formal parameter list of the closure
     // function is parsed. Therefore, we set the function type to a new
     // parameterized type to be patched after the actual type is known.
     // We temporarily use the class of the Function interface.
     const Class& unknown_signature_class = Class::Handle(isolate(),
         Type::Handle(isolate(), Type::Function()).type_class());
     function_type = Type::New(unknown_signature_class,
                               TypeArguments::Handle(isolate()), function_pos);
@@ skipping 25 matching lines @@
 
   // Parse the local function.
   Array& default_parameter_values = Array::Handle(isolate());
   SequenceNode* statements = Parser::ParseFunc(function,
                                                &default_parameter_values);
 
   // Now that the local function has formal parameters, lookup the signature
   // class in the current library (but not in its imports) and only create a new
   // canonical signature class if it does not exist yet.
   const String& signature = String::Handle(isolate(), function.Signature());
-  Class& signature_class = Class::ZoneHandle();
+  Class& signature_class = Class::ZoneHandle(I);
   if (!is_new_closure) {
     signature_class = function.signature_class();
   }
   if (signature_class.IsNull()) {
     signature_class = library_.LookupLocalClass(signature);
   }
   if (signature_class.IsNull()) {
     // If we don't have a signature class yet, this must be a closure we
     // have not parsed before.
     ASSERT(is_new_closure);
@@ skipping 599 matching lines @@
       // End of switch statement.
       break;
     }
     if ((next_token == Token::kCASE) || (next_token == Token::kDEFAULT)) {
       // End of this case clause. If there is a possible fall-through to
       // the next case clause, throw an implicit FallThroughError.
       if (!abrupt_completing_seen) {
         ArgumentListNode* arguments = new(isolate()) ArgumentListNode(
             TokenPos());
         arguments->Add(new(isolate()) LiteralNode(
-            TokenPos(), Integer::ZoneHandle(Integer::New(TokenPos()))));
+            TokenPos(), Integer::ZoneHandle(I, Integer::New(TokenPos()))));
         current_block_->statements->Add(
             MakeStaticCall(Symbols::FallThroughError(),
                            Library::PrivateCoreLibName(Symbols::ThrowNew()),
                            arguments));
       }
       break;
     }
     // The next statement still belongs to this case.
     AstNode* statement = ParseStatement();
     if (statement != NULL) {
@@ skipping 20 matching lines @@
   ExpectToken(Token::kRPAREN);
   ExpectToken(Token::kLBRACE);
   OpenBlock();
   current_block_->scope->AddLabel(label);
 
   // Store switch expression in temporary local variable. The type of the
   // variable is set to dynamic. It will later be patched to match the
   // type of the case clause expressions. Therefore, we have to allocate
   // a new type representing dynamic and can't reuse the canonical
   // type object for dynamic.
-  const Type& temp_var_type = Type::ZoneHandle(isolate(),
+  const Type& temp_var_type = Type::ZoneHandle(I,
        Type::New(Class::Handle(isolate(), Object::dynamic_class()),
                  TypeArguments::Handle(isolate()),
                  expr_pos));
   temp_var_type.SetIsFinalized();
   LocalVariable* temp_variable = new(isolate()) LocalVariable(
       expr_pos,  Symbols::SwitchExpr(), temp_var_type);
   current_block_->scope->AddVariable(temp_variable);
   AstNode* save_switch_expr = new(isolate()) StoreLocalNode(
       expr_pos, temp_variable, switch_expr);
   current_block_->statements->Add(save_switch_expr);
@@ skipping 106 matching lines @@
   }
   const String* loop_var_name = NULL;
   LocalVariable* loop_var = NULL;
   intptr_t loop_var_pos = 0;
   if (LookaheadToken(1) == Token::kIN) {
     loop_var_pos = TokenPos();
     loop_var_name = ExpectIdentifier("variable name expected");
   } else {
     // The case without a type is handled above, so require a type here.
     const AbstractType& type =
-        AbstractType::ZoneHandle(ParseConstFinalVarOrType(
+        AbstractType::ZoneHandle(I, ParseConstFinalVarOrType(
             FLAG_enable_type_checks ? ClassFinalizer::kCanonicalize :
                                       ClassFinalizer::kIgnore));
     loop_var_pos = TokenPos();
     loop_var_name = ExpectIdentifier("variable name expected");
     loop_var = new(isolate()) LocalVariable(loop_var_pos, *loop_var_name, type);
     if (is_final) {
       loop_var->set_is_final();
     }
   }
   ExpectToken(Token::kIN);
   const intptr_t collection_pos = TokenPos();
   AstNode* collection_expr = ParseExpr(kAllowConst, kConsumeCascades);
   ExpectToken(Token::kRPAREN);
 
   OpenBlock();  // Implicit block around while loop.
 
   // Generate implicit iterator variable and add to scope.
   // We could set the type of the implicit iterator variable to Iterator<T>
   // where T is the type of the for loop variable. However, the type error
   // would refer to the compiler generated iterator and could confuse the user.
   // It is better to leave the iterator untyped and postpone the type error
   // until the loop variable is assigned to.
-  const AbstractType& iterator_type = Type::ZoneHandle(Type::DynamicType());
+  const AbstractType& iterator_type = Type::ZoneHandle(I, Type::DynamicType());
   LocalVariable* iterator_var = new(isolate()) LocalVariable(
       collection_pos, Symbols::ForInIter(), iterator_type);
   current_block_->scope->AddVariable(iterator_var);
 
   // Generate initialization of iterator variable.
   ArgumentListNode* no_args = new(isolate()) ArgumentListNode(collection_pos);
   AstNode* get_iterator = new(isolate()) InstanceGetterNode(
       collection_pos, collection_expr, Symbols::GetIterator());
   AstNode* iterator_init =
       new(isolate()) StoreLocalNode(collection_pos, iterator_var, get_iterator);
@@ skipping 122 matching lines @@
 }
 
 
 // Calling VM-internal helpers, uses implementation core library.
 AstNode* Parser::MakeStaticCall(const String& cls_name,
                                 const String& func_name,
                                 ArgumentListNode* arguments) {
   const Class& cls = Class::Handle(isolate(),
                                    Library::LookupCoreClass(cls_name));
   ASSERT(!cls.IsNull());
-  const Function& func = Function::ZoneHandle(
+  const Function& func = Function::ZoneHandle(I,
       Resolver::ResolveStatic(cls,
                               func_name,
                               arguments->length(),
                               arguments->names()));
   ASSERT(!func.IsNull());
   return new(isolate()) StaticCallNode(arguments->token_pos(), func, arguments);
 }
 
 
 AstNode* Parser::MakeAssertCall(intptr_t begin, intptr_t end) {
   ArgumentListNode* arguments = new(isolate()) ArgumentListNode(begin);
   arguments->Add(new(isolate()) LiteralNode(begin,
-      Integer::ZoneHandle(Integer::New(begin))));
+      Integer::ZoneHandle(I, Integer::New(begin))));
   arguments->Add(new(isolate()) LiteralNode(end,
-      Integer::ZoneHandle(Integer::New(end))));
+      Integer::ZoneHandle(I, Integer::New(end))));
   return MakeStaticCall(Symbols::AssertionError(),
                         Library::PrivateCoreLibName(Symbols::ThrowNew()),
                         arguments);
 }
 
 
 AstNode* Parser::InsertClosureCallNodes(AstNode* condition) {
   if (condition->IsClosureNode() ||
       (condition->IsStoreLocalNode() &&
        condition->AsStoreLocalNode()->value()->IsClosureNode())) {
@@ skipping 164 matching lines @@
   GrowableArray<SequenceNode*> catch_blocks;
   while ((CurrentToken() == Token::kCATCH) || IsLiteral("on")) {
     // Open a block that contains the if or an unconditional body.  It's
     // closed in the loop that builds the if-then-else nest.
     OpenBlock();
     const intptr_t catch_pos = TokenPos();
     CatchParamDesc exception_param;
     CatchParamDesc stack_trace_param;
     if (IsLiteral("on")) {
       ConsumeToken();
-      exception_param.type = &AbstractType::ZoneHandle(
+      exception_param.type = &AbstractType::ZoneHandle(I,
           ParseType(ClassFinalizer::kCanonicalize));
     } else {
-      exception_param.type = &AbstractType::ZoneHandle(Type::DynamicType());
+      exception_param.type = &AbstractType::ZoneHandle(I, Type::DynamicType());
     }
     if (CurrentToken() == Token::kCATCH) {
       ConsumeToken();  // Consume the 'catch'.
       ExpectToken(Token::kLPAREN);
       exception_param.token_pos = TokenPos();
       exception_param.name = ExpectIdentifier("identifier expected");
       if (CurrentToken() == Token::kCOMMA) {
         ConsumeToken();
         // TODO(hausner): Make implicit type be StackTrace, not dynamic.
         stack_trace_param.type =
-            &AbstractType::ZoneHandle(Type::DynamicType());
+            &AbstractType::ZoneHandle(I, Type::DynamicType());
         stack_trace_param.token_pos = TokenPos();
         stack_trace_param.name = ExpectIdentifier("identifier expected");
       }
       ExpectToken(Token::kRPAREN);
     }
 
     // Create a block containing the catch clause parameters and the
     // following code:
     // 1) Store exception object and stack trace object into user-defined
     //    variables (as needed).
@@ skipping 140 matching lines @@
   //                      was thrown.
   // :exception_var and :stack_trace_var get set with the exception object
   // and the stack trace object when an exception is thrown.  These three
   // implicit variables can never be captured.
   LocalVariable* context_var =
       current_block_->scope->LocalLookupVariable(Symbols::SavedTryContextVar());
   if (context_var == NULL) {
     context_var = new(isolate()) LocalVariable(
         TokenPos(),
         Symbols::SavedTryContextVar(),
-        Type::ZoneHandle(Type::DynamicType()));
+        Type::ZoneHandle(I, Type::DynamicType()));
     current_block_->scope->AddVariable(context_var);
   }
   LocalVariable* exception_var =
       current_block_->scope->LocalLookupVariable(Symbols::ExceptionVar());
   if (exception_var == NULL) {
     exception_var = new(isolate()) LocalVariable(
         TokenPos(),
         Symbols::ExceptionVar(),
-        Type::ZoneHandle(Type::DynamicType()));
+        Type::ZoneHandle(I, Type::DynamicType()));
     current_block_->scope->AddVariable(exception_var);
   }
   LocalVariable* stack_trace_var =
       current_block_->scope->LocalLookupVariable(Symbols::StackTraceVar());
   if (stack_trace_var == NULL) {
     stack_trace_var = new(isolate()) LocalVariable(
         TokenPos(),
         Symbols::StackTraceVar(),
-        Type::ZoneHandle(Type::DynamicType()));
+        Type::ZoneHandle(I, Type::DynamicType()));
     current_block_->scope->AddVariable(stack_trace_var);
   }
 
   const intptr_t try_pos = TokenPos();
   ConsumeToken();  // Consume the 'try'.
 
   SourceLabel* try_label = NULL;
   if (label_name != NULL) {
     try_label = SourceLabel::New(try_pos, label_name, SourceLabel::kStatement);
     OpenBlock();
@@ skipping 49 matching lines @@
       node_index += 1;
       node_to_inline = inner_try_block->GetNodeToInlineFinally(node_index);
       tokens_iterator_.SetCurrentPosition(finally_pos);
     }
     finally_block = ParseFinallyBlock();
   }
 
   CatchClauseNode* catch_clause = new(isolate()) CatchClauseNode(
       handler_pos,
       catch_handler_list,
-      Array::ZoneHandle(Array::MakeArray(handler_types)),
+      Array::ZoneHandle(I, Array::MakeArray(handler_types)),
       context_var,
       exception_var,
       stack_trace_var,
       (finally_block != NULL) ?
           AllocateTryIndex() : CatchClauseNode::kInvalidTryIndex,
       needs_stack_trace);
 
   // Now create the try/catch ast node and return it. If there is a label
   // on the try/catch, close the block that's embedding the try statement
   // and attach the label to it.
@@ skipping 351 matching lines @@
     return sequence;
   }
   return node->AsSequenceNode();
 }
 
 
 AstNode* Parser::ThrowTypeError(intptr_t type_pos, const AbstractType& type) {
   ArgumentListNode* arguments = new(isolate()) ArgumentListNode(type_pos);
   // Location argument.
   arguments->Add(new(isolate()) LiteralNode(
-      type_pos, Integer::ZoneHandle(Integer::New(type_pos))));
+      type_pos, Integer::ZoneHandle(I, Integer::New(type_pos))));
   // Src value argument.
-  arguments->Add(new(isolate()) LiteralNode(type_pos, Instance::ZoneHandle()));
+  arguments->Add(new(isolate()) LiteralNode(type_pos, Instance::ZoneHandle(I)));
   // Dst type name argument.
   arguments->Add(new(isolate()) LiteralNode(type_pos, Symbols::Malformed()));
   // Dst name argument.
   arguments->Add(new(isolate()) LiteralNode(type_pos, Symbols::Empty()));
   // Malformed type error or malbounded type error.
   const Error& error = Error::Handle(isolate(), type.error());
   ASSERT(!error.IsNull());
-  arguments->Add(new(isolate()) LiteralNode(type_pos, String::ZoneHandle(
+  arguments->Add(new(isolate()) LiteralNode(type_pos, String::ZoneHandle(I,
       Symbols::New(error.ToErrorCString()))));
   return MakeStaticCall(Symbols::TypeError(),
                         Library::PrivateCoreLibName(Symbols::ThrowNew()),
                         arguments);
 }
 
 
 AstNode* Parser::ThrowNoSuchMethodError(intptr_t call_pos,
                                         const Class& cls,
                                         const String& function_name,
                                         ArgumentListNode* function_arguments,
                                         InvocationMirror::Call im_call,
                                         InvocationMirror::Type im_type,
                                         Function* func) {
   ArgumentListNode* arguments = new(isolate()) ArgumentListNode(call_pos);
   // Object receiver.
   // TODO(regis): For now, we pass a class literal of the unresolved
   // method's owner, but this is not specified and will probably change.
-  Type& type = Type::ZoneHandle(
+  Type& type = Type::ZoneHandle(I,
       Type::New(cls, TypeArguments::Handle(isolate()), call_pos, Heap::kOld));
   type ^= ClassFinalizer::FinalizeType(
       current_class(), type, ClassFinalizer::kCanonicalize);
   arguments->Add(new(isolate()) LiteralNode(call_pos, type));
   // String memberName.
   arguments->Add(new(isolate()) LiteralNode(
-      call_pos, String::ZoneHandle(Symbols::New(function_name))));
+      call_pos, String::ZoneHandle(I, Symbols::New(function_name))));
   // Smi invocation_type.
   if (cls.IsTopLevel()) {
     ASSERT(im_call == InvocationMirror::kStatic ||
            im_call == InvocationMirror::kTopLevel);
     im_call = InvocationMirror::kTopLevel;
   }
-  arguments->Add(new(isolate()) LiteralNode(call_pos, Smi::ZoneHandle(
+  arguments->Add(new(isolate()) LiteralNode(call_pos, Smi::ZoneHandle(I,
       Smi::New(InvocationMirror::EncodeType(im_call, im_type)))));
   // List arguments.
   if (function_arguments == NULL) {
-    arguments->Add(new(isolate()) LiteralNode(call_pos, Array::ZoneHandle()));
+    arguments->Add(new(isolate()) LiteralNode(call_pos, Array::ZoneHandle(I)));
   } else {
     ArrayNode* array = new(isolate()) ArrayNode(
         call_pos,
-        Type::ZoneHandle(Type::ArrayType()),
+        Type::ZoneHandle(I, Type::ArrayType()),
         function_arguments->nodes());
     arguments->Add(array);
   }
   // List argumentNames.
   if (function_arguments == NULL) {
-    arguments->Add(new(isolate()) LiteralNode(call_pos, Array::ZoneHandle()));
+    arguments->Add(new(isolate()) LiteralNode(call_pos, Array::ZoneHandle(I)));
   } else {
     arguments->Add(new(isolate()) LiteralNode(
         call_pos, function_arguments->names()));
   }
 
   // List existingArgumentNames.
   // Check if there exists a function with the same name unless caller
   // has done the lookup already. If there is a function with the same
   // name but incompatible parameters, inform the NoSuchMethodError what the
   // expected parameters are.
   Function& function = Function::Handle(isolate());
   if (func != NULL) {
     function = func->raw();
   } else {
     function = cls.LookupStaticFunction(function_name);
   }
-  Array& array = Array::ZoneHandle();
+  Array& array = Array::ZoneHandle(I);
   if (!function.IsNull()) {
     // The constructor for NoSuchMethodError takes a list of existing
     // parameter names to produce a descriptive error message explaining
     // the parameter mismatch. The problem is that the array of names
     // does not describe which parameters are optional positional or
     // named, which can lead to confusing error messages.
     // Since the NoSuchMethodError class only uses the list to produce
     // a string describing the expected parameters, we construct a more
     // descriptive string here and pass it as the only element of the
     // "existingArgumentNames" array of the NoSuchMethodError constructor.
@@ skipping 29 matching lines @@
       AstNode* right_operand = NULL;
       if ((op_kind != Token::kIS) && (op_kind != Token::kAS)) {
         right_operand = ParseBinaryExpr(current_preced + 1);
       } else {
         // For 'is' and 'as' we expect the right operand to be a type.
         if ((op_kind == Token::kIS) && (CurrentToken() == Token::kNOT)) {
           ConsumeToken();
           op_kind = Token::kISNOT;
         }
         const intptr_t type_pos = TokenPos();
-        const AbstractType& type = AbstractType::ZoneHandle(
+        const AbstractType& type = AbstractType::ZoneHandle(I,
             ParseType(ClassFinalizer::kCanonicalize));
         if (!type.IsInstantiated() &&
             (current_block_->scope->function_level() > 0)) {
           // Make sure that the instantiator is captured.
           CaptureInstantiator();
         }
         right_operand = new(isolate()) TypeNode(type_pos, type);
         // In production mode, the type may be malformed.
         // In checked mode, the type may be malformed or malbounded.
         if (((op_kind == Token::kIS) || (op_kind == Token::kISNOT) ||
@@ skipping 57 matching lines @@
   parsed_function()->EnsureExpressionTemp();
 }
 
 
 void Parser::EnsureSavedCurrentContext() {
   // Used later by the flow_graph_builder to save current context.
   if (!parsed_function()->has_saved_current_context_var()) {
     LocalVariable* temp = new(isolate()) LocalVariable(
         current_function().token_pos(),
         Symbols::SavedCurrentContextVar(),
-        Type::ZoneHandle(Type::DynamicType()));
+        Type::ZoneHandle(I, Type::DynamicType()));
     ASSERT(temp != NULL);
     parsed_function()->set_saved_current_context_var(temp);
   }
 }
 
 
 LocalVariable* Parser::CreateTempConstVariable(intptr_t token_pos,
                                                const char* s) {
   char name[64];
   OS::SNPrint(name, 64, ":%s%" Pd, s, token_pos);
   LocalVariable* temp = new(isolate()) LocalVariable(
       token_pos,
-      String::ZoneHandle(Symbols::New(name)),
-      Type::ZoneHandle(Type::DynamicType()));
+      String::ZoneHandle(I, Symbols::New(name)),
+      Type::ZoneHandle(I, Type::DynamicType()));
   temp->set_is_final();
   current_block_->scope->AddVariable(temp);
   return temp;
 }
 
 
 // TODO(srdjan): Implement other optimizations.
 AstNode* Parser::OptimizeBinaryOpNode(intptr_t op_pos,
                                       Token::Kind binary_op,
                                       AstNode* lhs,
                                       AstNode* rhs) {
   LiteralNode* lhs_literal = lhs->AsLiteralNode();
   LiteralNode* rhs_literal = rhs->AsLiteralNode();
   if ((lhs_literal != NULL) && (rhs_literal != NULL)) {
     if (lhs_literal->literal().IsDouble() &&
         rhs_literal->literal().IsDouble()) {
       double left_double = Double::Cast(lhs_literal->literal()).value();
       double right_double = Double::Cast(rhs_literal->literal()).value();
       if (binary_op == Token::kDIV) {
-        const Double& dbl_obj = Double::ZoneHandle(
+        const Double& dbl_obj = Double::ZoneHandle(I,
             Double::NewCanonical((left_double / right_double)));
         return new(isolate()) LiteralNode(op_pos, dbl_obj);
       }
     }
   }
   if ((binary_op == Token::kAND) || (binary_op == Token::kOR)) {
     EnsureExpressionTemp();
   }
   if (binary_op == Token::kBIT_AND) {
     // Normalize so that rhs is a literal if any is.
@@ skipping 135 matching lines @@
   return Token::IsIdentifier(token) || (token == Token::kRBRACK);
 }
 
 
 AstNode* Parser::CreateAssignmentNode(AstNode* original,
                                       AstNode* rhs,
                                       const String* left_ident,
                                       intptr_t left_pos) {
   AstNode* result = original->MakeAssignmentNode(rhs);
   if (result == NULL) {
-    String& name = String::ZoneHandle();
+    String& name = String::ZoneHandle(I);
     const Class* target_cls = &current_class();
     if (original->IsTypeNode()) {
       name = Symbols::New(original->AsTypeNode()->TypeName());
     } else if (original->IsLoadStaticFieldNode()) {
       name = original->AsLoadStaticFieldNode()->field().name();
       target_cls = &Class::Handle(isolate(),
           original->AsLoadStaticFieldNode()->field().owner());
     } else if ((left_ident != NULL) &&
                (original->IsLiteralNode() ||
                 original->IsLoadLocalNode())) {
@@ skipping 75 matching lines @@
   }
   // The result is an expression with the (side effects of the) cascade
   // sequence followed by the (value of the) receiver temp variable load.
   cascade->AddNode(new(isolate()) LoadLocalNode(
       cascade_pos, cascade_receiver_var));
   return cascade;
 }
 
 
 // Convert loading of a static const field into a literal node.
-static AstNode* LiteralIfStaticConst(AstNode* expr) {
+static AstNode* LiteralIfStaticConst(Isolate* iso, AstNode* expr) {
   if (expr->IsLoadStaticFieldNode()) {
     const Field& field = expr->AsLoadStaticFieldNode()->field();
     if (field.is_const()) {
       ASSERT(field.value() != Object::sentinel().raw());
       ASSERT(field.value() != Object::transition_sentinel().raw());
-      return new LiteralNode(expr->token_pos(),
-                             Instance::ZoneHandle(field.value()));
+      return new(iso) LiteralNode(expr->token_pos(),
+                             Instance::ZoneHandle(iso, field.value()));
     }
   }
   return expr;
 }
 
 
 AstNode* Parser::ParseExpr(bool require_compiletime_const,
                            bool consume_cascades) {
   TRACE_PARSER("ParseExpr");
   String* expr_ident =
       Token::IsIdentifier(CurrentToken()) ? CurrentLiteral() : NULL;
   const intptr_t expr_pos = TokenPos();
 
   if (CurrentToken() == Token::kTHROW) {
     ConsumeToken();
     if (CurrentToken() == Token::kSEMICOLON) {
       ErrorMsg("expression expected after throw");
     }
     AstNode* expr = ParseExpr(require_compiletime_const, consume_cascades);
     return new(isolate()) ThrowNode(expr_pos, expr, NULL);
   }
   AstNode* expr = ParseConditionalExpr();
   if (!Token::IsAssignmentOperator(CurrentToken())) {
     if ((CurrentToken() == Token::kCASCADE) && consume_cascades) {
       return ParseCascades(expr);
     }
     if (require_compiletime_const) {
       expr = FoldConstExpr(expr_pos, expr);
     } else {
-      expr = LiteralIfStaticConst(expr);
+      expr = LiteralIfStaticConst(I, expr);
     }
     return expr;
   }
   // Assignment expressions.
   if (!IsLegalAssignableSyntax(expr, TokenPos())) {
     ErrorMsg(expr_pos, "expression is not assignable");
   }
   const Token::Kind assignment_op = CurrentToken();
   const intptr_t assignment_pos = TokenPos();
   ConsumeToken();
   const intptr_t right_expr_pos = TokenPos();
   if (require_compiletime_const && (assignment_op != Token::kASSIGN)) {
     ErrorMsg(right_expr_pos, "expression is not a valid compile-time constant");
   }
   AstNode* right_expr = ParseExpr(require_compiletime_const, consume_cascades);
   if (assignment_op != Token::kASSIGN) {
     // Compound assignment: store inputs with side effects into temp. locals.
     LetNode* let_expr = PrepareCompoundAssignmentNodes(&expr);
     AstNode* assigned_value =
         ExpandAssignableOp(assignment_pos, assignment_op, expr, right_expr);
     AstNode* assign_expr =
         CreateAssignmentNode(expr, assigned_value, expr_ident, expr_pos);
     ASSERT(assign_expr != NULL);
     let_expr->AddNode(assign_expr);
     return let_expr;
   } else {
-    AstNode* assigned_value = LiteralIfStaticConst(right_expr);
+    AstNode* assigned_value = LiteralIfStaticConst(I, right_expr);
     AstNode* assign_expr =
         CreateAssignmentNode(expr, assigned_value, expr_ident, expr_pos);
     ASSERT(assign_expr != NULL);
     return assign_expr;
   }
 }
 
 
 LiteralNode* Parser::ParseConstExpr() {
   TRACE_PARSER("ParseConstExpr");
@@ skipping 49 matching lines @@
       ErrorMsg(expr_pos, "expression is not assignable");
     }
     // Is prefix.
     LetNode* let_expr = PrepareCompoundAssignmentNodes(&expr);
     Token::Kind binary_op =
         (incr_op == Token::kINCR) ? Token::kADD : Token::kSUB;
     BinaryOpNode* add = new(isolate()) BinaryOpNode(
         op_pos,
         binary_op,
         expr,
-        new(isolate()) LiteralNode(op_pos, Smi::ZoneHandle(Smi::New(1))));
+        new(isolate()) LiteralNode(op_pos, Smi::ZoneHandle(I, Smi::New(1))));
     AstNode* store = CreateAssignmentNode(expr, add, expr_ident, expr_pos);
     ASSERT(store != NULL);
     let_expr->AddNode(store);
     expr = let_expr;
   } else {
     expr = ParsePostfixExpr();
   }
   return expr;
 }
 
@@ skipping 52 matching lines @@
 
 
 AstNode* Parser::ParseStaticCall(const Class& cls,
                                  const String& func_name,
                                  intptr_t ident_pos) {
   TRACE_PARSER("ParseStaticCall");
   const intptr_t call_pos = TokenPos();
   ASSERT(CurrentToken() == Token::kLPAREN);
   ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
   const int num_arguments = arguments->length();
-  const Function& func = Function::ZoneHandle(
+  const Function& func = Function::ZoneHandle(I,
       Resolver::ResolveStatic(cls,
                               func_name,
                               num_arguments,
                               arguments->names()));
   if (func.IsNull()) {
     // Check if there is a static field of the same name, it could be a closure
     // and so we try and invoke the closure.
     AstNode* closure = NULL;
-    const Field& field = Field::ZoneHandle(cls.LookupStaticField(func_name));
-    Function& func = Function::ZoneHandle();
+    const Field& field = Field::ZoneHandle(I, cls.LookupStaticField(func_name));
+    Function& func = Function::ZoneHandle(I);
     if (field.IsNull()) {
       // No field, check if we have an explicit getter function.
       const String& getter_name =
-          String::ZoneHandle(Field::GetterName(func_name));
+          String::ZoneHandle(I, Field::GetterName(func_name));
       const int kNumArguments = 0;  // no arguments.
       func = Resolver::ResolveStatic(cls,
                                      getter_name,
                                      kNumArguments,
                                      Object::empty_array());
       if (!func.IsNull()) {
         ASSERT(func.kind() != RawFunction::kImplicitStaticFinalGetter);
-        closure = new(isolate()) StaticGetterNode(call_pos,
-                                                  NULL,
-                                                  false,
-                                                  Class::ZoneHandle(cls.raw()),
-                                                  func_name);
+        closure = new(isolate()) StaticGetterNode(
+            call_pos,
+            NULL,
+            false,
+            Class::ZoneHandle(I, cls.raw()),
+            func_name);
         return BuildClosureCall(call_pos, closure, arguments);
       }
     } else {
       closure = GenerateStaticFieldLookup(field, call_pos);
       return BuildClosureCall(call_pos, closure, arguments);
     }
     // Could not resolve static method: throw a NoSuchMethodError.
     return ThrowNoSuchMethodError(ident_pos,
                                   cls,
                                   func_name,
@@ skipping 40 matching lines @@
   // If the static field has an initializer, initialize the field at compile
   // time, which is only possible if the field is const.
   AstNode* initializing_getter = RunStaticFieldInitializer(field, ident_pos);
   if (initializing_getter != NULL) {
     // The field is not yet initialized and could not be initialized at compile
     // time. The getter will initialize the field.
     return initializing_getter;
   }
   // The field is initialized.
   ASSERT(field.is_static());
-  const Class& field_owner = Class::ZoneHandle(field.owner());
-  const String& field_name = String::ZoneHandle(field.name());
+  const Class& field_owner = Class::ZoneHandle(I, field.owner());
+  const String& field_name = String::ZoneHandle(I, field.name());
   const String& getter_name = String::Handle(isolate(),
       Field::GetterName(field_name));
   const Function& getter = Function::Handle(isolate(),
       field_owner.LookupStaticFunction(getter_name));
   // Never load field directly if there is a getter (deterministic AST).
   if (getter.IsNull() || field.is_const()) {
     return new(isolate()) LoadStaticFieldNode(
-        ident_pos, Field::ZoneHandle(field.raw()));
+        ident_pos, Field::ZoneHandle(I, field.raw()));
   } else {
     ASSERT(getter.kind() == RawFunction::kImplicitStaticFinalGetter);
     return new(isolate()) StaticGetterNode(ident_pos,
                                            NULL,  // Receiver.
                                            false,  // is_super_getter.
                                            field_owner,
                                            field_name);
   }
 }
 
 
 AstNode* Parser::ParseStaticFieldAccess(const Class& cls,
                                         const String& field_name,
                                         intptr_t ident_pos,
                                         bool consume_cascades) {
   TRACE_PARSER("ParseStaticFieldAccess");
   AstNode* access = NULL;
-  const Field& field = Field::ZoneHandle(cls.LookupStaticField(field_name));
-  Function& func = Function::ZoneHandle();
+  const Field& field = Field::ZoneHandle(I, cls.LookupStaticField(field_name));
+  Function& func = Function::ZoneHandle(I);
   if (field.IsNull()) {
     // No field, check if we have an explicit getter function.
     const String& getter_name =
-        String::ZoneHandle(Field::GetterName(field_name));
+        String::ZoneHandle(I, Field::GetterName(field_name));
     const int kNumArguments = 0;  // no arguments.
     func = Resolver::ResolveStatic(cls,
                                    getter_name,
                                    kNumArguments,
                                    Object::empty_array());
     if (func.IsNull()) {
       // We might be referring to an implicit closure, check to see if
       // there is a function of the same name.
       func = cls.LookupStaticFunction(field_name);
       if (!func.IsNull()) {
         access = CreateImplicitClosureNode(func, ident_pos, NULL);
       } else {
         // No function to closurize found found.
         // This field access may turn out to be a call to the setter.
         // Create a getter call, which may later be turned into
         // a setter call, or else the backend will generate
         // a throw NoSuchMethodError().
-        access = new(isolate()) StaticGetterNode(
-            ident_pos, NULL, false, Class::ZoneHandle(cls.raw()), field_name);
+        access = new(I) StaticGetterNode(ident_pos,
+                                         NULL,
+                                         false,
+                                         Class::ZoneHandle(I, cls.raw()),
+                                         field_name);
       }
     } else {
       ASSERT(func.kind() != RawFunction::kImplicitStaticFinalGetter);
       access = new(isolate()) StaticGetterNode(
-          ident_pos, NULL, false, Class::ZoneHandle(cls.raw()), field_name);
+          ident_pos, NULL, false, Class::ZoneHandle(I, cls.raw()), field_name);
     }
   } else {
     access = GenerateStaticFieldLookup(field, ident_pos);
   }
   return access;
 }
 
 
 AstNode* Parser::LoadFieldIfUnresolved(AstNode* node) {
   if (!node->IsPrimaryNode()) {
@@ skipping 15 matching lines @@
                "unresolved identifier '%s' is not a compile-time constant",
                name.ToCString());
     }
     if (current_function().is_static() ||
         current_function().IsInFactoryScope()) {
       StaticGetterNode* getter =
           new(isolate()) StaticGetterNode(
               primary->token_pos(),
               NULL,  // No receiver.
               false,  // Not a super getter.
-              Class::ZoneHandle(current_class().raw()),
+              Class::ZoneHandle(I, current_class().raw()),
               name);
       getter->set_is_deferred(primary->is_deferred_reference());
       return getter;
     } else {
       AstNode* receiver = LoadReceiver(primary->token_pos());
       return CallGetter(node->token_pos(), receiver, name);
     }
   }
   return primary;
 }
 
 
 AstNode* Parser::LoadClosure(PrimaryNode* primary) {
   ASSERT(primary->primary().IsFunction());
   const Function& func =
       Function::CheckedZoneHandle(primary->primary().raw());
-  const String& funcname = String::ZoneHandle(func.name());
+  const String& funcname = String::ZoneHandle(I, func.name());
   if (func.is_static()) {
     // Static function access.
     ClosureNode* closure =
         CreateImplicitClosureNode(func, primary->token_pos(), NULL);
     closure->set_is_deferred(primary->is_deferred_reference());
     return closure;
   } else {
     // Instance function access.
     if (parsing_metadata_) {
       ErrorMsg(primary->token_pos(),
@@ skipping 20 matching lines @@
     AstNode* selector = NULL;
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary_node = left->AsPrimaryNode();
         const intptr_t primary_pos = primary_node->token_pos();
         if (primary_node->primary().IsFunction()) {
           left = LoadClosure(primary_node);
         } else if (primary_node->primary().IsTypeParameter()) {
           if (current_function().is_static()) {
-            const String& name = String::ZoneHandle(
+            const String& name = String::ZoneHandle(I,
                 TypeParameter::Cast(primary_node->primary()).name());
             ErrorMsg(primary_pos,
                      "cannot access type parameter '%s' from static function",
                      name.ToCString());
           }
           if (current_block_->scope->function_level() > 0) {
             // Make sure that the instantiator is captured.
             CaptureInstantiator();
           }
-          TypeParameter& type_parameter = TypeParameter::ZoneHandle();
+          TypeParameter& type_parameter = TypeParameter::ZoneHandle(I);
           type_parameter ^= ClassFinalizer::FinalizeType(
               current_class(),
               TypeParameter::Cast(primary_node->primary()),
               ClassFinalizer::kCanonicalize);
           ASSERT(!type_parameter.IsMalformed());
           left = new(isolate()) TypeNode(primary->token_pos(), type_parameter);
         } else {
           // Super field access handled in ParseSuperFieldAccess(),
           // super calls handled in ParseSuperCall().
           ASSERT(!primary_node->IsSuper());
@@ skipping 44 matching lines @@
       SetAllowFunctionLiterals(saved_mode);
       ExpectToken(Token::kRBRACK);
       AstNode* array = left;
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary_node = left->AsPrimaryNode();
         const intptr_t primary_pos = primary_node->token_pos();
         if (primary_node->primary().IsFunction()) {
           array = LoadClosure(primary_node);
         } else if (primary_node->primary().IsClass()) {
           const Class& type_class = Class::Cast(primary_node->primary());
-          AbstractType& type = Type::ZoneHandle(
+          AbstractType& type = Type::ZoneHandle(I,
               Type::New(type_class, TypeArguments::Handle(isolate()),
                         primary_pos, Heap::kOld));
           type ^= ClassFinalizer::FinalizeType(
               current_class(), type, ClassFinalizer::kCanonicalize);
           // Type may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
           array = new(isolate()) TypeNode(primary_pos, type);
         } else if (primary_node->primary().IsTypeParameter()) {
           if (current_function().is_static()) {
-            const String& name = String::ZoneHandle(
+            const String& name = String::ZoneHandle(I,
                 TypeParameter::Cast(primary_node->primary()).name());
             ErrorMsg(primary_pos,
                      "cannot access type parameter '%s' from static function",
                      name.ToCString());
           }
           if (current_block_->scope->function_level() > 0) {
             // Make sure that the instantiator is captured.
             CaptureInstantiator();
           }
-          TypeParameter& type_parameter = TypeParameter::ZoneHandle();
+          TypeParameter& type_parameter = TypeParameter::ZoneHandle(I);
           type_parameter ^= ClassFinalizer::FinalizeType(
               current_class(),
               TypeParameter::Cast(primary_node->primary()),
               ClassFinalizer::kCanonicalize);
           ASSERT(!type_parameter.IsMalformed());
           array = new(isolate()) TypeNode(primary_pos, type_parameter);
         } else {
           UNREACHABLE();  // Internal parser error.
         }
       }
       selector =  new(isolate()) LoadIndexedNode(
-          bracket_pos, array, index, Class::ZoneHandle());
+          bracket_pos, array, index, Class::ZoneHandle(I));
     } else if (CurrentToken() == Token::kLPAREN) {
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary_node = left->AsPrimaryNode();
         const intptr_t primary_pos = primary_node->token_pos();
         if (primary_node->primary().IsFunction()) {
           const Function& func = Function::Cast(primary_node->primary());
-          const String& func_name = String::ZoneHandle(func.name());
+          const String& func_name = String::ZoneHandle(I, func.name());
           if (func.is_static()) {
             // Parse static function call.
             Class& cls = Class::Handle(isolate(), func.Owner());
             selector = ParseStaticCall(cls, func_name, primary_pos);
           } else {
             // Dynamic function call on implicit "this" parameter.
             if (current_function().is_static()) {
               ErrorMsg(primary_pos,
                        "cannot access instance method '%s' "
                        "from static function",
@@ skipping 14 matching lines @@
                                               name,
                                               NULL,  // No arguments.
                                               InvocationMirror::kStatic,
                                               InvocationMirror::kMethod,
                                               NULL);  // No existing function.
           } else {
             // Treat as call to unresolved (instance) method.
             selector = ParseInstanceCall(LoadReceiver(primary_pos), name);
           }
         } else if (primary_node->primary().IsTypeParameter()) {
-          const String& name = String::ZoneHandle(
+          const String& name = String::ZoneHandle(I,
               TypeParameter::Cast(primary_node->primary()).name());
           if (current_function().is_static()) {
             // Treat as this.T(), because T is in scope.
             ErrorMsg(primary_pos,
                      "cannot access type parameter '%s' from static function",
                      name.ToCString());
           } else {
             // Treat as call to unresolved (instance) method.
             selector = ParseInstanceCall(LoadReceiver(primary_pos), name);
           }
         } else if (primary_node->primary().IsClass()) {
           const Class& type_class = Class::Cast(primary_node->primary());
-          AbstractType& type = Type::ZoneHandle(Type::New(
+          AbstractType& type = Type::ZoneHandle(I, Type::New(
               type_class, TypeArguments::Handle(isolate()), primary_pos));
           type ^= ClassFinalizer::FinalizeType(
               current_class(), type, ClassFinalizer::kCanonicalize);
           // Type may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
           selector = new(isolate()) TypeNode(primary_pos, type);
         } else {
           UNREACHABLE();  // Internal parser error.
         }
       } else {
@@ skipping 13 matching lines @@
       // No (more) selectors to parse.
       left = LoadFieldIfUnresolved(left);
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary_node = left->AsPrimaryNode();
         const intptr_t primary_pos = primary->token_pos();
         if (primary_node->primary().IsFunction()) {
           // Treat as implicit closure.
           left = LoadClosure(primary_node);
         } else if (primary_node->primary().IsClass()) {
           const Class& type_class = Class::Cast(primary_node->primary());
-          AbstractType& type = Type::ZoneHandle(Type::New(
+          AbstractType& type = Type::ZoneHandle(I, Type::New(
               type_class, TypeArguments::Handle(isolate()), primary_pos));
           type = ClassFinalizer::FinalizeType(
               current_class(), type, ClassFinalizer::kCanonicalize);
           // Type may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
           left = new(isolate()) TypeNode(primary_pos, type);
         } else if (primary_node->primary().IsTypeParameter()) {
           if (current_function().is_static()) {
-            const String& name = String::ZoneHandle(
+            const String& name = String::ZoneHandle(I,
                 TypeParameter::Cast(primary_node->primary()).name());
             ErrorMsg(primary_pos,
                      "cannot access type parameter '%s' from static function",
                      name.ToCString());
           }
           if (current_block_->scope->function_level() > 0) {
             // Make sure that the instantiator is captured.
             CaptureInstantiator();
           }
-          TypeParameter& type_parameter = TypeParameter::ZoneHandle();
+          TypeParameter& type_parameter = TypeParameter::ZoneHandle(I);
           type_parameter ^= ClassFinalizer::FinalizeType(
               current_class(),
               TypeParameter::Cast(primary_node->primary()),
               ClassFinalizer::kCanonicalize);
           ASSERT(!type_parameter.IsMalformed());
           left = new(isolate()) TypeNode(primary_pos, type_parameter);
         } else if (primary_node->IsSuper()) {
           // Return "super" to handle unary super operator calls,
           // or to report illegal use of "super" otherwise.
           left = primary_node;
@@ skipping 26 matching lines @@
     ConsumeToken();
     // Not prefix.
     LetNode* let_expr = PrepareCompoundAssignmentNodes(&expr);
     LocalVariable* temp = let_expr->AddInitializer(expr);
     Token::Kind binary_op =
         (incr_op == Token::kINCR) ? Token::kADD : Token::kSUB;
     BinaryOpNode* add = new(isolate()) BinaryOpNode(
         expr_pos,
         binary_op,
         new(isolate()) LoadLocalNode(expr_pos, temp),
-        new(isolate()) LiteralNode(expr_pos, Smi::ZoneHandle(Smi::New(1))));
+        new(isolate()) LiteralNode(expr_pos, Smi::ZoneHandle(I, Smi::New(1))));
     AstNode* store = CreateAssignmentNode(expr, add, expr_ident, expr_pos);
     ASSERT(store != NULL);
     // The result is a pair of the (side effects of the) store followed by
     // the (value of the) initial value temp variable load.
     let_expr->AddNode(store);
     let_expr->AddNode(new(isolate()) LoadLocalNode(expr_pos, temp));
     return let_expr;
   }
   return expr;
 }
@@ skipping 181 matching lines @@
   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,
                                            intptr_t field_ref_pos) {
   ASSERT(field.is_static());
-  const Class& field_owner = Class::ZoneHandle(isolate(), field.owner());
-  const String& field_name = String::ZoneHandle(isolate(), field.name());
+  const Class& field_owner = Class::ZoneHandle(I, field.owner());
+  const String& field_name = String::ZoneHandle(I, field.name());
   const String& getter_name = String::Handle(isolate(),
                                              Field::GetterName(field_name));
   const Function& getter = Function::Handle(
       isolate(), field_owner.LookupStaticFunction(getter_name));
   const Instance& value = Instance::Handle(isolate(), field.value());
   if (value.raw() == Object::transition_sentinel().raw()) {
     if (field.is_const()) {
       ErrorMsg("circular dependency while initializing static field '%s'",
                field_name.ToCString());
     } else {
@@ skipping 173 matching lines @@
   }
 
   // Check if an instance/static function exists.
   func = cls.LookupFunction(ident);
   if (!func.IsNull() &&
       (func.IsDynamicFunction() ||
       func.IsStaticFunction() ||
       func.is_abstract())) {
     if (node != NULL) {
       *node = new(isolate()) PrimaryNode(
-          ident_pos, Function::ZoneHandle(isolate(), func.raw()));
+          ident_pos, Function::ZoneHandle(I, func.raw()));
     }
     return true;
   }
 
   // Now check if a getter/setter method exists for it in which case
   // it is still a field.
   func = cls.LookupGetterFunction(ident);
   if (!func.IsNull()) {
     if (func.IsDynamicFunction() || func.is_abstract()) {
       if (node != NULL) {
@@ skipping 17 matching lines @@
                    "'%s' is not a compile-time constant",
                    ident.ToCString());
         }
         if (!current_function().is_static() &&
             (LookupReceiver(current_block_->scope, kTestOnly) != NULL)) {
           receiver = LoadReceiver(ident_pos);
         }
         *node = new(isolate()) StaticGetterNode(ident_pos,
                                      receiver,
                                      false,
-                                     Class::ZoneHandle(isolate(), cls.raw()),
+                                     Class::ZoneHandle(I, cls.raw()),
                                      ident);
       }
       return true;
     }
   }
   func = cls.LookupSetterFunction(ident);
   if (!func.IsNull()) {
     if (func.IsDynamicFunction() || func.is_abstract()) {
       if (node != NULL) {
         // We create a getter node even though a getter doesn't exist as
         // it could be followed by an assignment which will convert it to
         // a setter node. If there is no assignment we will get an error
         // when we try to invoke the getter.
         CheckInstanceFieldAccess(ident_pos, ident);
         ASSERT(AbstractType::Handle(isolate(),
                                     func.result_type()).IsResolved());
         *node = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
       }
       return true;
     } else if (func.IsStaticFunction()) {
       if (node != NULL) {
         // We create a getter node even though a getter doesn't exist as
         // it could be followed by an assignment which will convert it to
         // a setter node. If there is no assignment we will get an error
         // when we try to invoke the getter.
         *node = new(isolate()) StaticGetterNode(
             ident_pos,
             NULL,
             false,
-            Class::ZoneHandle(isolate(), cls.raw()),
+            Class::ZoneHandle(I, cls.raw()),
             ident);
       }
       return true;
     }
   }
 
   // Nothing found in scope of current class.
   if (node != NULL) {
     *node = NULL;
   }
@@ skipping 14 matching lines @@
 // Resolve an identifier by checking the global scope of the current
 // library. If not found in the current library, then look in the scopes
 // of all libraries that are imported without a library prefix.
 AstNode* Parser::ResolveIdentInCurrentLibraryScope(intptr_t ident_pos,
                                                    const String& ident) {
   TRACE_PARSER("ResolveIdentInCurrentLibraryScope");
   HANDLESCOPE(isolate());
   const Object& obj = Object::Handle(isolate(), library_.ResolveName(ident));
   if (obj.IsClass()) {
     const Class& cls = Class::Cast(obj);
-    return new(isolate()) PrimaryNode(ident_pos, Class::ZoneHandle(cls.raw()));
+    return new(isolate()) PrimaryNode(
+        ident_pos, Class::ZoneHandle(I, cls.raw()));
   } else if (obj.IsField()) {
     const Field& field = Field::Cast(obj);
     ASSERT(field.is_static());
     return GenerateStaticFieldLookup(field, ident_pos);
   } else if (obj.IsFunction()) {
     const Function& func = Function::Cast(obj);
     ASSERT(func.is_static());
     if (func.IsGetterFunction() || func.IsSetterFunction()) {
       return new(isolate()) StaticGetterNode(ident_pos,
                                              /* receiver */ NULL,
                                              /* is_super_getter */ false,
-                                             Class::ZoneHandle(func.Owner()),
+                                             Class::ZoneHandle(I, func.Owner()),
                                              ident);
 
     } else {
       return new(isolate()) PrimaryNode(ident_pos,
-                                        Function::ZoneHandle(func.raw()));
+                                        Function::ZoneHandle(I, func.raw()));
     }
   } else {
     ASSERT(obj.IsNull() || obj.IsLibraryPrefix());
   }
   // Lexically unresolved primary identifiers are referenced by their name.
   return new(isolate()) PrimaryNode(ident_pos, ident);
 }
 
 
 RawClass* Parser::ResolveClassInPrefixScope(const LibraryPrefix& prefix,
@@ skipping 26 matching lines @@
       parsed_function()->AddDeferredPrefix(prefix);
     }
   }
   const bool is_deferred = prefix.is_deferred_load();
   if (obj.IsNull()) {
     // Unresolved prefixed primary identifier.
     return NULL;
   } else if (obj.IsClass()) {
     const Class& cls = Class::Cast(obj);
     PrimaryNode* primary =
-        new(isolate()) PrimaryNode(ident_pos, Class::ZoneHandle(cls.raw()));
+        new(isolate()) PrimaryNode(ident_pos, Class::ZoneHandle(I, cls.raw()));
     primary->set_is_deferred(is_deferred);
     return primary;
   } else if (obj.IsField()) {
     const Field& field = Field::Cast(obj);
     ASSERT(field.is_static());
     AstNode* get_field = GenerateStaticFieldLookup(field, ident_pos);
     ASSERT(get_field != NULL);
     ASSERT(get_field->IsLoadStaticFieldNode() ||
            get_field->IsStaticGetterNode());
     if (get_field->IsLoadStaticFieldNode()) {
       get_field->AsLoadStaticFieldNode()->set_is_deferred(is_deferred);
     } else if (get_field->IsStaticGetterNode()) {
       get_field->AsStaticGetterNode()->set_is_deferred(is_deferred);
     }
     return get_field;
   } else if (obj.IsFunction()) {
     const Function& func = Function::Cast(obj);
     ASSERT(func.is_static());
     if (func.IsGetterFunction() || func.IsSetterFunction()) {
       StaticGetterNode* getter =
           new(isolate()) StaticGetterNode(ident_pos,
                                /* receiver */ NULL,
                                /* is_super_getter */ false,
-                               Class::ZoneHandle(isolate(), func.Owner()),
+                               Class::ZoneHandle(I, func.Owner()),
                                ident);
       getter->set_is_deferred(is_deferred);
       return getter;
     } else {
       PrimaryNode* primary = new(isolate()) PrimaryNode(
-           ident_pos, Function::ZoneHandle(isolate(), func.raw()));
+           ident_pos, Function::ZoneHandle(I, func.raw()));
       primary->set_is_deferred(is_deferred);
       return primary;
     }
   }
   // All possible object types are handled above.
   UNREACHABLE();
   return NULL;
 }
 
 
 // Resolve identifier. Issue an error message if
 // the ident refers to a method and allow_closure_names is false.
 // If the name cannot be resolved, turn it into an instance field access
 // if we're compiling an instance method, or generate
 // throw NoSuchMethodError if we're compiling a static method.
 AstNode* Parser::ResolveIdent(intptr_t ident_pos,
                               const String& ident,
                               bool allow_closure_names) {
   TRACE_PARSER("ResolveIdent");
   // First try to find the variable in the local scope (block scope or
   // class scope).
   AstNode* resolved = NULL;
   ResolveIdentInLocalScope(ident_pos, ident, &resolved);
   if (resolved == NULL) {
     // Check whether the identifier is a type parameter.
     if (!current_class().IsNull()) {
-      TypeParameter& type_parameter = TypeParameter::ZoneHandle(
+      TypeParameter& type_parameter = TypeParameter::ZoneHandle(I,
           current_class().LookupTypeParameter(ident));
       if (!type_parameter.IsNull()) {
         if (current_block_->scope->function_level() > 0) {
           // Make sure that the instantiator is captured.
           CaptureInstantiator();
         }
         type_parameter ^= ClassFinalizer::FinalizeType(
             current_class(), type_parameter, ClassFinalizer::kCanonicalize);
         ASSERT(!type_parameter.IsMalformed());
         return new(isolate()) TypeNode(ident_pos, type_parameter);
@@ skipping 27 matching lines @@
       }
     } else if (primary->primary().IsFunction()) {
       if (allow_closure_names) {
         resolved = LoadClosure(primary);
       } else {
         ErrorMsg(ident_pos, "illegal reference to method '%s'",
                  ident.ToCString());
       }
     } else if (primary->primary().IsClass()) {
       const Class& type_class = Class::Cast(primary->primary());
-      AbstractType& type = Type::ZoneHandle(
+      AbstractType& type = Type::ZoneHandle(I,
           Type::New(type_class, TypeArguments::Handle(isolate()), primary_pos));
       type ^= ClassFinalizer::FinalizeType(
           current_class(), type, ClassFinalizer::kCanonicalize);
       // Type may be malbounded, but not malformed.
       ASSERT(!type.IsMalformed());
       resolved = new(isolate()) TypeNode(primary_pos, type);
     }
   }
   return resolved;
 }
@@ skipping 95 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 = TokenPos();
   bool is_empty_literal = CurrentToken() == Token::kINDEX;
   ConsumeToken();
 
-  AbstractType& element_type = Type::ZoneHandle(Type::DynamicType());
+  AbstractType& element_type = Type::ZoneHandle(I, Type::DynamicType());
   TypeArguments& list_type_arguments =
-      TypeArguments::ZoneHandle(type_arguments.raw());
+      TypeArguments::ZoneHandle(I, 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 element type.
   if (!list_type_arguments.IsNull()) {
     ASSERT(list_type_arguments.Length() > 0);
     // List literals take a single type argument.
     if (list_type_arguments.Length() == 1) {
       element_type = list_type_arguments.TypeAt(0);
       ASSERT(!element_type.IsMalformed());  // Would be mapped to dynamic.
       ASSERT(!element_type.IsMalbounded());  // No declared bound in List.
       if (element_type.IsDynamicType()) {
         list_type_arguments = TypeArguments::null();
       } else if (is_const && !element_type.IsInstantiated()) {
         ErrorMsg(type_pos,
                  "the type argument of a constant list literal cannot include "
                  "a type variable");
       }
     } else {
       if (FLAG_error_on_bad_type) {
         ErrorMsg(type_pos,
                  "a list literal takes one type argument specifying "
                  "the element type");
       }
       // Ignore type arguments.
       list_type_arguments = TypeArguments::null();
     }
   }
   ASSERT(list_type_arguments.IsNull() || (list_type_arguments.Length() == 1));
   const Class& array_class = Class::Handle(isolate(),
       isolate()->object_store()->array_class());
-  Type& type = Type::ZoneHandle(
+  Type& type = Type::ZoneHandle(I,
       Type::New(array_class, list_type_arguments, type_pos));
   type ^= ClassFinalizer::FinalizeType(
       current_class(), type, ClassFinalizer::kCanonicalize);
   GrowableArray<AstNode*> element_list;
   // Parse the list elements. Note: there may be an optional extra
   // comma after the last element.
   if (!is_empty_literal) {
     const bool saved_mode = SetAllowFunctionLiterals(true);
     while (CurrentToken() != Token::kRBRACK) {
       const intptr_t element_pos = TokenPos();
@@ skipping 13 matching lines @@
         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(element_list.length(), Heap::kOld));
+        Array::ZoneHandle(I, Array::New(element_list.length(), Heap::kOld));
     const_list.SetTypeArguments(
         TypeArguments::Handle(isolate(), list_type_arguments.Canonicalize()));
     Error& malformed_error = Error::Handle(isolate());
     for (int i = 0; i < element_list.length(); i++) {
       AstNode* elem = element_list[i];
       // Arguments have been evaluated to a literal value already.
       ASSERT(elem->IsLiteralNode());
       ASSERT(!is_top_level_);  // We cannot check unresolved types.
       if (FLAG_enable_type_checks &&
           !element_type.IsDynamicType() &&
@@ skipping 17 matching lines @@
       const_list.SetAt(i, elem->AsLiteralNode()->literal());
     }
     const_list ^= TryCanonicalize(const_list, literal_pos);
     const_list.MakeImmutable();
     return new(isolate()) LiteralNode(literal_pos, const_list);
   } else {
     // Factory call at runtime.
     const Class& factory_class =
         Class::Handle(isolate(), Library::LookupCoreClass(Symbols::List()));
     ASSERT(!factory_class.IsNull());
-    const Function& factory_method = Function::ZoneHandle(
+    const Function& factory_method = Function::ZoneHandle(I,
         factory_class.LookupFactory(
             Library::PrivateCoreLibName(Symbols::ListLiteralFactory())));
     ASSERT(!factory_method.IsNull());
     if (!list_type_arguments.IsNull() &&
         !list_type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureInstantiator();
     }
     TypeArguments& factory_type_args =
-        TypeArguments::ZoneHandle(list_type_arguments.raw());
+        TypeArguments::ZoneHandle(I, list_type_arguments.raw());
     // If the factory class extends other parameterized classes, adjust the
     // type argument vector.
     if (!factory_type_args.IsNull() && (factory_class.NumTypeArguments() > 1)) {
       ASSERT(factory_type_args.Length() == 1);
       Type& factory_type = Type::Handle(isolate(), Type::New(
           factory_class, factory_type_args, type_pos, Heap::kNew));
       factory_type ^= ClassFinalizer::FinalizeType(
           current_class(), factory_type, ClassFinalizer::kFinalize);
       factory_type_args = factory_type.arguments();
       ASSERT(factory_type_args.Length() == factory_class.NumTypeArguments());
     }
     factory_type_args = factory_type_args.Canonicalize();
     ArgumentListNode* factory_param = new(isolate()) ArgumentListNode(
         literal_pos);
     if (element_list.length() == 0) {
       // TODO(srdjan): Use Object::empty_array once issue 9871 has been fixed.
-      Array& empty_array = Array::ZoneHandle(Object::empty_array().raw());
+      Array& empty_array = Array::ZoneHandle(I, Object::empty_array().raw());
       LiteralNode* empty_array_literal =
           new(isolate()) LiteralNode(TokenPos(), empty_array);
       factory_param->Add(empty_array_literal);
     } else {
       ArrayNode* list = new(isolate()) ArrayNode(
           TokenPos(), type, element_list);
       factory_param->Add(list);
     }
     return CreateConstructorCallNode(literal_pos,
                                      factory_type_args,
@@ skipping 43 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 = TokenPos();
   ConsumeToken();
 
-  AbstractType& key_type = Type::ZoneHandle(Type::DynamicType());
-  AbstractType& value_type = Type::ZoneHandle(Type::DynamicType());
+  AbstractType& key_type = Type::ZoneHandle(I, Type::DynamicType());
+  AbstractType& value_type = Type::ZoneHandle(I, Type::DynamicType());
   TypeArguments& map_type_arguments =
-      TypeArguments::ZoneHandle(type_arguments.raw());
+      TypeArguments::ZoneHandle(I, 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 both key and value
   // types.
   if (!map_type_arguments.IsNull()) {
     ASSERT(map_type_arguments.Length() > 0);
     // Map literals take two type arguments.
     if (map_type_arguments.Length() == 2) {
       key_type = map_type_arguments.TypeAt(0);
       value_type = map_type_arguments.TypeAt(1);
       // Malformed type arguments are mapped to dynamic.
@@ skipping 66 matching lines @@
   ASSERT(kv_pairs_list.length() % 2 == 0);
   ExpectToken(Token::kRBRACE);
 
   if (is_const) {
     // Create the key-value pair array, canonicalize it and then create
     // 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_list.length(), Heap::kOld));
+        Array::ZoneHandle(I, Array::New(kv_pairs_list.length(), Heap::kOld));
     AbstractType& arg_type = Type::Handle(isolate());
     Error& malformed_error = Error::Handle(isolate());
     for (int i = 0; i < kv_pairs_list.length(); i++) {
       AstNode* arg = kv_pairs_list[i];
       // Arguments have been evaluated to a literal value already.
       ASSERT(arg->IsLiteralNode());
       ASSERT(!is_top_level_);  // We cannot check unresolved types.
       if (FLAG_enable_type_checks) {
         if ((i % 2) == 0) {
           // Check key type.
@@ skipping 30 matching lines @@
     // Construct the map object.
     const Class& immutable_map_class = Class::Handle(isolate(),
         Library::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(isolate()) ArgumentListNode(TokenPos());
     constr_args->Add(new(isolate()) LiteralNode(literal_pos, key_value_array));
     const Function& map_constr =
-        Function::ZoneHandle(immutable_map_class.LookupConstructor(
+        Function::ZoneHandle(I, immutable_map_class.LookupConstructor(
             Library::PrivateCoreLibName(Symbols::ImmutableMapConstructor())));
     ASSERT(!map_constr.IsNull());
     const Object& constructor_result = Object::Handle(isolate(),
         EvaluateConstConstructorCall(immutable_map_class,
                                      map_type_arguments,
                                      map_constr,
                                      constr_args));
     if (constructor_result.IsUnhandledException()) {
       AppendErrorMsg(Error::Cast(constructor_result),
                      literal_pos,
                      "error executing const Map constructor");
     } else {
       const Instance& const_instance = Instance::Cast(constructor_result);
       return new(isolate()) LiteralNode(
-          literal_pos, Instance::ZoneHandle(const_instance.raw()));
+          literal_pos, Instance::ZoneHandle(I, const_instance.raw()));
     }
   } else {
     // Factory call at runtime.
     const Class& factory_class =
         Class::Handle(isolate(), Library::LookupCoreClass(Symbols::Map()));
     ASSERT(!factory_class.IsNull());
-    const Function& factory_method = Function::ZoneHandle(
+    const Function& factory_method = Function::ZoneHandle(I,
         factory_class.LookupFactory(
             Library::PrivateCoreLibName(Symbols::MapLiteralFactory())));
     ASSERT(!factory_method.IsNull());
     if (!map_type_arguments.IsNull() &&
         !map_type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureInstantiator();
     }
     TypeArguments& factory_type_args =
-        TypeArguments::ZoneHandle(map_type_arguments.raw());
+        TypeArguments::ZoneHandle(I, map_type_arguments.raw());
     // If the factory class extends other parameterized classes, adjust the
     // type argument vector.
     if (!factory_type_args.IsNull() && (factory_class.NumTypeArguments() > 2)) {
       ASSERT(factory_type_args.Length() == 2);
       Type& factory_type = Type::Handle(isolate(), Type::New(
           factory_class, factory_type_args, type_pos, Heap::kNew));
       factory_type ^= ClassFinalizer::FinalizeType(
           current_class(), factory_type, ClassFinalizer::kFinalize);
       factory_type_args = factory_type.arguments();
       ASSERT(factory_type_args.Length() == factory_class.NumTypeArguments());
     }
     factory_type_args = factory_type_args.Canonicalize();
     ArgumentListNode* factory_param =
         new(isolate()) ArgumentListNode(literal_pos);
     // The kv_pair array is temporary and of element type dynamic. It is passed
     // to the factory to initialize a properly typed map.
     ArrayNode* kv_pairs = new(isolate()) ArrayNode(
         TokenPos(),
-        Type::ZoneHandle(Type::ArrayType()),
+        Type::ZoneHandle(I, Type::ArrayType()),
         kv_pairs_list);
     factory_param->Add(kv_pairs);
     return CreateConstructorCallNode(literal_pos,
                                      factory_type_args,
                                      factory_method,
                                      factory_param);
   }
   UNREACHABLE();
   return NULL;
 }
@@ skipping 47 matching lines @@
     ErrorMsg("illegal symbol literal");
   }
   // Lookup class Symbol from internal library and call the
   // constructor to create a symbol instance.
   const Library& lib = Library::Handle(isolate(), Library::InternalLibrary());
   const Class& symbol_class = Class::Handle(isolate(),
                                             lib.LookupClass(Symbols::Symbol()));
   ASSERT(!symbol_class.IsNull());
   ArgumentListNode* constr_args = new(isolate()) ArgumentListNode(symbol_pos);
   constr_args->Add(new(isolate()) LiteralNode(
-      symbol_pos, String::ZoneHandle(Symbols::New(symbol))));
-  const Function& constr = Function::ZoneHandle(
+      symbol_pos, String::ZoneHandle(I, Symbols::New(symbol))));
+  const Function& constr = Function::ZoneHandle(I,
       symbol_class.LookupConstructor(Symbols::SymbolCtor()));
   ASSERT(!constr.IsNull());
   const Object& result = Object::Handle(isolate(),
       EvaluateConstConstructorCall(symbol_class,
                                    TypeArguments::Handle(isolate()),
                                    constr,
                                    constr_args));
   if (result.IsUnhandledException()) {
     AppendErrorMsg(Error::Cast(result),
                    symbol_pos,
                    "error executing const Symbol constructor");
   }
   const Instance& instance = Instance::Cast(result);
   return new(isolate()) LiteralNode(symbol_pos,
-                                    Instance::ZoneHandle(instance.raw()));
+                                    Instance::ZoneHandle(I, instance.raw()));
 }
 
 
 static String& BuildConstructorName(const String& type_class_name,
                                     const String* named_constructor) {
   // By convention, the static function implementing a named constructor 'C'
   // for class 'A' is labeled 'A.C', and the static function implementing the
   // unnamed constructor for class 'A' is labeled 'A.'.
   // This convention prevents users from explicitly calling constructors.
   String& constructor_name =
@@ skipping 55 matching lines @@
       const Error& error = Error::Handle(isolate(), type.error());
       ErrorMsg(error);
     }
     return ThrowTypeError(type_pos, type);
   }
 
   // Resolve the type and optional identifier to a constructor or factory.
   Class& type_class = Class::Handle(isolate(), type.type_class());
   String& type_class_name = String::Handle(isolate(), type_class.Name());
   TypeArguments& type_arguments =
-      TypeArguments::ZoneHandle(type.arguments());
+      TypeArguments::ZoneHandle(I, type.arguments());
 
   // A constructor has an implicit 'this' parameter (instance to construct)
   // and a factory has an implicit 'this' parameter (type_arguments).
   // A constructor has a second implicit 'phase' parameter.
   intptr_t arguments_length = arguments->length() + 2;
 
   // An additional type check of the result of a redirecting factory may be
   // required.
-  AbstractType& type_bound = AbstractType::ZoneHandle();
+  AbstractType& type_bound = AbstractType::ZoneHandle(I);
 
   // Make sure that an appropriate constructor exists.
   String& constructor_name =
       BuildConstructorName(type_class_name, named_constructor);
-  Function& constructor = Function::ZoneHandle(
+  Function& constructor = Function::ZoneHandle(I,
       type_class.LookupConstructor(constructor_name));
   if (constructor.IsNull()) {
     constructor = type_class.LookupFactory(constructor_name);
     if (constructor.IsNull()) {
       const String& external_constructor_name =
           (named_constructor ? constructor_name : type_class_name);
       // Replace the type with a malformed type and compile a throw or report a
       // compile-time error if the constructor is const.
       if (is_const) {
         type = ClassFinalizer::NewFinalizedMalformedType(
@@ skipping 61 matching lines @@
   ASSERT(!constructor.IsNull());
   if (type_class.is_abstract() && !constructor.IsFactory()) {
     // Evaluate arguments before throwing.
     LetNode* result = new(isolate()) LetNode(call_pos);
     for (intptr_t i = 0; i < arguments->length(); ++i) {
       result->AddNode(arguments->NodeAt(i));
     }
     ArgumentListNode* error_arguments =
         new(isolate()) ArgumentListNode(type_pos);
     error_arguments->Add(new(isolate()) LiteralNode(
-        TokenPos(), Integer::ZoneHandle(Integer::New(type_pos))));
+        TokenPos(), Integer::ZoneHandle(I, Integer::New(type_pos))));
     error_arguments->Add(new(isolate()) LiteralNode(
-        TokenPos(), String::ZoneHandle(type_class_name.raw())));
+        TokenPos(), String::ZoneHandle(I, type_class_name.raw())));
     result->AddNode(
         MakeStaticCall(Symbols::AbstractClassInstantiationError(),
                        Library::PrivateCoreLibName(Symbols::ThrowNew()),
                        error_arguments));
     return result;
   }
   String& error_message = String::Handle(isolate());
   if (!constructor.AreValidArguments(arguments_length,
                                      arguments->names(),
                                      &error_message)) {
@@ skipping 44 matching lines @@
       // It's a compile-time error if invocation of a const constructor
       // call fails.
       AppendErrorMsg(Error::Cast(constructor_result),
                      new_pos,
                      "error while evaluating const constructor");
     } else {
       // Const constructors can return null in the case where a const native
       // factory returns a null value. Thus we cannot use a Instance::Cast here.
       Instance& const_instance = Instance::Handle(isolate());
       const_instance ^= constructor_result.raw();
-      new_object = new(isolate()) LiteralNode(new_pos,
-                                   Instance::ZoneHandle(const_instance.raw()));
+      new_object = new(isolate()) LiteralNode(
+          new_pos, Instance::ZoneHandle(I, const_instance.raw()));
       if (!type_bound.IsNull()) {
         ASSERT(!type_bound.IsMalformed());
         Error& malformed_error = Error::Handle(isolate());
         ASSERT(!is_top_level_);  // We cannot check unresolved types.
         if (!const_instance.IsInstanceOf(type_bound,
                                          TypeArguments::Handle(isolate()),
                                          &malformed_error)) {
           type_bound = ClassFinalizer::NewFinalizedMalformedType(
               malformed_error,
               script_,
@@ skipping 49 matching lines @@
 
   // Call interpolation function.
   Object& result = Object::Handle(isolate());
   {
     PAUSETIMERSCOPE(isolate(), time_compilation);
     result = DartEntry::InvokeFunction(func, interpolate_arg);
   }
   if (result.IsUnhandledException()) {
     ErrorMsg("%s", Error::Cast(result).ToErrorCString());
   }
-  String& concatenated = String::ZoneHandle(isolate());
+  String& concatenated = String::ZoneHandle(I);
   concatenated ^= result.raw();
   concatenated = Symbols::New(concatenated);
   return concatenated;
 }
 
 
 // A string literal consists of the concatenation of the next n tokens
 // that satisfy the EBNF grammar:
 // literal = kSTRING {{ interpol } kSTRING }
 // interpol = kINTERPOL_VAR | (kINTERPOL_START expression kINTERPOL_END)
@@ skipping 70 matching lines @@
       primary = new(isolate()) LiteralNode(
           literal_start, Interpolate(values_list));
     } else {
       const Array& strings = Array::Handle(isolate(),
                                            Array::New(values_list.length()));
       for (int i = 0; i < values_list.length(); i++) {
         const Instance& part = values_list[i]->AsLiteralNode()->literal();
         ASSERT(part.IsString());
         strings.SetAt(i, String::Cast(part));
       }
-      String& lit = String::ZoneHandle(String::ConcatAll(strings, Heap::kOld));
+      String& lit = String::ZoneHandle(I,
+                                       String::ConcatAll(strings, Heap::kOld));
       lit = Symbols::New(lit);
       primary = new(isolate()) LiteralNode(literal_start, lit);
     }
   } else {
     ArrayNode* values = new(isolate()) ArrayNode(
         TokenPos(),
-        Type::ZoneHandle(Type::ArrayType()),
+        Type::ZoneHandle(I, Type::ArrayType()),
         values_list);
     primary = new(isolate()) StringInterpolateNode(TokenPos(), values);
   }
   return primary;
 }
 
 
 AstNode* Parser::ParsePrimary() {
   TRACE_PARSER("ParsePrimary");
   ASSERT(!is_top_level_);
   AstNode* primary = NULL;
   if (IsFunctionLiteral()) {
     // The name of a literal function is visible from inside the function, but
     // must not collide with names in the scope declaring the literal.
     OpenBlock();
     primary = ParseFunctionStatement(true);
     CloseBlock();
   } else if (IsIdentifier()) {
     QualIdent qual_ident;
     intptr_t qual_ident_pos = TokenPos();
     ParseQualIdent(&qual_ident);
     if (qual_ident.lib_prefix == NULL) {
       if (!ResolveIdentInLocalScope(qual_ident.ident_pos,
                                     *qual_ident.ident,
                                     &primary)) {
         // Check whether the identifier is a type parameter.
         if (!current_class().IsNull()) {
-          TypeParameter& type_param = TypeParameter::ZoneHandle(
+          TypeParameter& type_param = TypeParameter::ZoneHandle(I,
               current_class().LookupTypeParameter(*(qual_ident.ident)));
           if (!type_param.IsNull()) {
             return new(isolate()) PrimaryNode(qual_ident.ident_pos, type_param);
           }
         }
         // This is a non-local unqualified identifier so resolve the
         // identifier locally in the main app library and all libraries
         // imported by it.
         primary = ResolveIdentInCurrentLibraryScope(qual_ident.ident_pos,
                                                     *qual_ident.ident);
@@ skipping 24 matching lines @@
           // later, when we know more about how the unresolved name is used.
           // For example, we don't know yet whether the unresolved name
           // refers to a getter or a setter. However, it is more awkward
           // to distinuish four NoSuchMethodError cases all over the place
           // in the parser. The four cases are: prefixed vs non-prefixed
           // name, static vs dynamic context in which the unresolved name
           // is used. We cheat a little here by looking at the next token
           // to determine whether we have an unresolved method call or
           // field access.
           String& qualified_name =
-              String::ZoneHandle(qual_ident.lib_prefix->name());
+              String::ZoneHandle(I, qual_ident.lib_prefix->name());
           qualified_name = String::Concat(qualified_name, Symbols::Dot());
           qualified_name = String::Concat(qualified_name, *qual_ident.ident);
           qualified_name = Symbols::New(qualified_name);
           InvocationMirror::Type call_type =
               CurrentToken() == Token::kLPAREN ?
                   InvocationMirror::kMethod : InvocationMirror::kGetter;
           primary = ThrowNoSuchMethodError(qual_ident_pos,
                                            current_class(),
                                            qualified_name,
                                            NULL,  // No arguments.
                                            InvocationMirror::kTopLevel,
                                            call_type,
                                            NULL);  // No existing function.
         }
       }
     }
     ASSERT(primary != NULL);
   } else if (CurrentToken() == Token::kTHIS) {
     LocalVariable* local = LookupLocalScope(Symbols::This());
     if (local == NULL) {
       ErrorMsg("receiver 'this' is not in scope");
     }
     primary = new(isolate()) LoadLocalNode(TokenPos(), local);
     ConsumeToken();
   } else if (CurrentToken() == Token::kINTEGER) {
-    const Integer& literal = Integer::ZoneHandle(CurrentIntegerLiteral());
+    const Integer& literal = Integer::ZoneHandle(I, CurrentIntegerLiteral());
     primary = new(isolate()) LiteralNode(TokenPos(), literal);
     ConsumeToken();
   } else if (CurrentToken() == Token::kTRUE) {
     primary = new(isolate()) LiteralNode(TokenPos(), Bool::True());
     ConsumeToken();
   } else if (CurrentToken() == Token::kFALSE) {
     primary = new(isolate()) LiteralNode(TokenPos(), Bool::False());
     ConsumeToken();
   } else if (CurrentToken() == Token::kNULL) {
-    primary = new(isolate()) LiteralNode(TokenPos(), Instance::ZoneHandle());
+    primary = new(isolate()) LiteralNode(TokenPos(), Instance::ZoneHandle(I));
     ConsumeToken();
   } else if (CurrentToken() == Token::kLPAREN) {
     ConsumeToken();
     const bool saved_mode = SetAllowFunctionLiterals(true);
     primary = ParseExpr(kAllowConst, kConsumeCascades);
     SetAllowFunctionLiterals(saved_mode);
     ExpectToken(Token::kRPAREN);
   } else if (CurrentToken() == Token::kDOUBLE) {
-    Double& double_value = Double::ZoneHandle(CurrentDoubleLiteral());
+    Double& double_value = Double::ZoneHandle(I, CurrentDoubleLiteral());
     if (double_value.IsNull()) {
       ErrorMsg("invalid double literal");
     }
     primary = new(isolate()) LiteralNode(TokenPos(), double_value);
     ConsumeToken();
   } else if (CurrentToken() == Token::kSTRING) {
     primary = ParseStringLiteral(true);
   } else if (CurrentToken() == Token::kNEW) {
     ConsumeToken();
     primary = ParseNewOperator(Token::kNEW);
@@ skipping 66 matching lines @@
   } else if (expr->IsLoadLocalNode() &&
       expr->AsLoadLocalNode()->local().IsConst()) {
     return *expr->AsLoadLocalNode()->local().ConstValue();
   } else if (expr->IsLoadStaticFieldNode()) {
     const Field& field = expr->AsLoadStaticFieldNode()->field();
     // We already checked that this field is const and has been
     // initialized.
     ASSERT(field.is_const());
     ASSERT(field.value() != Object::sentinel().raw());
     ASSERT(field.value() != Object::transition_sentinel().raw());
-    return Instance::ZoneHandle(field.value());
+    return Instance::ZoneHandle(I, field.value());
   } else {
     ASSERT(expr->EvalConstExpr() != NULL);
     ReturnNode* ret = new(isolate()) ReturnNode(expr->token_pos(), expr);
     // Compile time constant expressions cannot reference anything from a
     // local scope.
     LocalScope* empty_scope = new(isolate()) LocalScope(NULL, 0, 0);
     SequenceNode* seq = new(isolate()) SequenceNode(expr->token_pos(),
                                                     empty_scope);
     seq->Add(ret);
 
     Object& result = Object::Handle(isolate(), Compiler::ExecuteOnce(seq));
     if (result.IsError()) {
       AppendErrorMsg(Error::Cast(result),
                      expr_pos,
                      "error evaluating constant expression");
     }
     ASSERT(result.IsInstance());
-    Instance& value = Instance::ZoneHandle();
+    Instance& value = Instance::ZoneHandle(I);
     value ^= result.raw();
     value = TryCanonicalize(value, TokenPos());
     return value;
   }
 }
 
 
 void Parser::SkipFunctionLiteral() {
   if (IsIdentifier()) {
     if (LookaheadToken(1) != Token::kLPAREN) {
@@ skipping 319 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart