Pass isolates explicitly.

runtime/vm/flow_graph_builder.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/flow_graph_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/class_finalizer.h"
@@ skipping 28 matching lines @@
             "Trace type check elimination at compile time.");
 DEFINE_FLAG(bool, warn_on_javascript_compatibility, false,
             "Warn on incompatibilities between vm and dart2js.");
 
 DECLARE_FLAG(bool, enable_debugger);
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(int, optimization_counter_threshold);
 DECLARE_FLAG(bool, silent_warnings);
 DECLARE_FLAG(bool, warning_as_error);
 
+// Quick access to the locally defined isolate() method.
+#define I (isolate())
 
 // TODO(srdjan): Allow compiler to add constants as they are encountered in
 // the compilation.
 const double kCommonDoubleConstants[] =
     {-1.0, -0.5, -0.1, 0.0, 0.1, 0.5, 1.0, 2.0, 4.0, 5.0,
      10.0, 20.0, 30.0, 64.0, 255.0, NAN,
      // From dart:math
      2.718281828459045, 2.302585092994046, 0.6931471805599453,
      1.4426950408889634, 0.4342944819032518, 3.1415926535897932,
      0.7071067811865476, 1.4142135623730951};
@@ skipping 680 matching lines @@
 Definition* EffectGraphVisitor::BuildStoreLocal(const LocalVariable& local,
                                                 Value* value) {
   if (local.is_captured()) {
     LocalVariable* tmp_var = EnterTempLocalScope(value);
     intptr_t delta =
         owner()->context_level() - local.owner()->context_level();
     ASSERT(delta >= 0);
     Value* context = Bind(new CurrentContextInstr());
     while (delta-- > 0) {
       context = Bind(new LoadFieldInstr(
-          context, Context::parent_offset(), Type::ZoneHandle(),
+          context, Context::parent_offset(), Type::ZoneHandle(I, Type::null()),
           Scanner::kNoSourcePos));
     }
     Value* tmp_val = Bind(new LoadLocalInstr(*tmp_var));
     StoreInstanceFieldInstr* store =
         new StoreInstanceFieldInstr(Context::variable_offset(local.index()),
                                     context,
                                     tmp_val,
                                     kEmitStoreBarrier,
                                     Scanner::kNoSourcePos);
     Do(store);
     return ExitTempLocalScope(tmp_var);
   } else {
     return new StoreLocalInstr(local, value);
   }
 }
 
 
 Definition* EffectGraphVisitor::BuildLoadLocal(const LocalVariable& local) {
   if (local.IsConst()) {
     return new ConstantInstr(*local.ConstValue());
   } else if (local.is_captured()) {
     intptr_t delta =
         owner()->context_level() - local.owner()->context_level();
     ASSERT(delta >= 0);
     Value* context = Bind(new CurrentContextInstr());
     while (delta-- > 0) {
       context = Bind(new LoadFieldInstr(
-          context, Context::parent_offset(), Type::ZoneHandle(),
+          context, Context::parent_offset(), Type::ZoneHandle(I, Type::null()),
           Scanner::kNoSourcePos));
     }
     return new LoadFieldInstr(context,
                               Context::variable_offset(local.index()),
                               local.type(),
                               Scanner::kNoSourcePos);
   } else {
     return new LoadLocalInstr(local);
   }
 }
@@ skipping 226 matching lines @@
         (!function.is_static() &&
         ((function.kind() == RawFunction::kImplicitGetter) ||
          (function.kind() == RawFunction::kImplicitStaticFinalGetter)));
     // Implicit getters do not need a type check at return, unless they compute
     // the initial value of a static field.
     // The body of a constructor cannot modify the type of the
     // constructed instance, which is passed in as an implicit parameter.
     // However, factories may create an instance of the wrong type.
     if (!is_implicit_dynamic_getter && !function.IsConstructor()) {
       const AbstractType& dst_type =
-          AbstractType::ZoneHandle(function.result_type());
+          AbstractType::ZoneHandle(I, function.result_type());
       return_value = BuildAssignableValue(node->value()->token_pos(),
                                           return_value,
                                           dst_type,
                                           Symbols::FunctionResult());
     }
   }
 
   intptr_t current_context_level = owner()->context_level();
   ASSERT(current_context_level >= 0);
   if (owner()->parsed_function()->saved_entry_context_var() != NULL) {
@@ skipping 22 matching lines @@
 
 
 void ValueGraphVisitor::VisitTypeNode(TypeNode* node) {
   const AbstractType& type = node->type();
   // Type may be malbounded, but not malformed.
   ASSERT(type.IsFinalized() && !type.IsMalformed());
   if (type.IsInstantiated()) {
     ReturnDefinition(new ConstantInstr(type));
   } else {
     const Class& instantiator_class = Class::ZoneHandle(
-        owner()->parsed_function()->function().Owner());
+        I, owner()->parsed_function()->function().Owner());
     Value* instantiator_value = BuildInstantiatorTypeArguments(
         node->token_pos(), instantiator_class, NULL);
     ReturnDefinition(new InstantiateTypeInstr(
         node->token_pos(), type, instantiator_class, instantiator_value));
   }
 }
 
 
 // Returns true if the type check can be skipped, for example, if the
 // destination type is dynamic or if the compile type of the value is a subtype
@@ skipping 116 matching lines @@
 
   ValueGraphVisitor for_right_value(owner());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   PushArgumentInstr* push_right = PushArgument(for_right_value.value());
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   arguments->Add(push_left);
   arguments->Add(push_right);
-  const String& name = String::ZoneHandle(Symbols::New(node->TokenName()));
+  const String& name = String::ZoneHandle(I, Symbols::New(node->TokenName()));
   const intptr_t kNumArgsChecked = 2;
   InstanceCallInstr* call = new InstanceCallInstr(node->token_pos(),
                                                   name,
                                                   node->kind(),
                                                   arguments,
                                                   Object::null_array(),
                                                   kNumArgsChecked,
                                                   owner()->ic_data_array());
   ReturnDefinition(call);
 }
@@ skipping 46 matching lines @@
   }
   EffectGraphVisitor::VisitBinaryOpNode(node);
 }
 
 
 static const String& BinaryOpAndMaskName(BinaryOpNode* node) {
   if (node->kind() == Token::kSHL) {
     return Library::PrivateCoreLibName(Symbols::_leftShiftWithMask32());
   }
   UNIMPLEMENTED();
-  return String::ZoneHandle();
+  return String::ZoneHandle(Isolate::Current(), String::null());
 }
 
 
 // <Expression> :: BinaryOp { kind:  Token::Kind
 //                            left:  <Expression>
 //                            right: <Expression>
 //                            mask32: constant }
 void EffectGraphVisitor::VisitBinaryOpWithMask32Node(
     BinaryOpWithMask32Node* node) {
   ASSERT((node->kind() != Token::kAND) && (node->kind() != Token::kOR));
   ValueGraphVisitor for_left_value(owner());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   PushArgumentInstr* push_left = PushArgument(for_left_value.value());
 
   ValueGraphVisitor for_right_value(owner());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   PushArgumentInstr* push_right = PushArgument(for_right_value.value());
 
   Value* mask_value = Bind(new ConstantInstr(
-      Integer::ZoneHandle(Integer::New(node->mask32(), Heap::kOld))));
+      Integer::ZoneHandle(I, Integer::New(node->mask32(), Heap::kOld))));
   PushArgumentInstr* push_mask = PushArgument(mask_value);
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(3);
   arguments->Add(push_left);
   arguments->Add(push_right);
   // Call to special method 'BinaryOpAndMaskName(node)'.
   arguments->Add(push_mask);
   const intptr_t kNumArgsChecked = 2;
   InstanceCallInstr* call = new InstanceCallInstr(node->token_pos(),
                                                   BinaryOpAndMaskName(node),
                                                   Token::kILLEGAL,
                                                   arguments,
                                                   Object::null_array(),
                                                   kNumArgsChecked,
                                                   owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::BuildTypecheckPushArguments(
     intptr_t token_pos,
     PushArgumentInstr** push_instantiator_result,
     PushArgumentInstr** push_instantiator_type_arguments_result) {
   const Class& instantiator_class = Class::Handle(
-      owner()->parsed_function()->function().Owner());
+      I, owner()->parsed_function()->function().Owner());
   // Since called only when type tested against is not instantiated.
   ASSERT(instantiator_class.NumTypeParameters() > 0);
   Value* instantiator_type_arguments = NULL;
   Value* instantiator = BuildInstantiator(instantiator_class);
   if (instantiator == NULL) {
     // No instantiator when inside factory.
     *push_instantiator_result = PushArgument(BuildNullValue());
     instantiator_type_arguments =
         BuildInstantiatorTypeArguments(token_pos, instantiator_class, NULL);
   } else {
     instantiator = Bind(BuildStoreExprTemp(instantiator));
     *push_instantiator_result = PushArgument(instantiator);
     Value* loaded = Bind(BuildLoadExprTemp());
     instantiator_type_arguments =
         BuildInstantiatorTypeArguments(token_pos, instantiator_class, loaded);
   }
   *push_instantiator_type_arguments_result =
       PushArgument(instantiator_type_arguments);
 }
 
 
 
 void EffectGraphVisitor::BuildTypecheckArguments(
     intptr_t token_pos,
     Value** instantiator_result,
     Value** instantiator_type_arguments_result) {
   Value* instantiator = NULL;
   Value* instantiator_type_arguments = NULL;
   const Class& instantiator_class = Class::Handle(
-      owner()->parsed_function()->function().Owner());
+      I, owner()->parsed_function()->function().Owner());
   // Since called only when type tested against is not instantiated.
   ASSERT(instantiator_class.NumTypeParameters() > 0);
   instantiator = BuildInstantiator(instantiator_class);
   if (instantiator == NULL) {
     // No instantiator when inside factory.
     instantiator = BuildNullValue();
     instantiator_type_arguments =
         BuildInstantiatorTypeArguments(token_pos, instantiator_class, NULL);
   } else {
     // Preserve instantiator.
     instantiator = Bind(BuildStoreExprTemp(instantiator));
     Value* loaded = Bind(BuildLoadExprTemp());
     instantiator_type_arguments =
         BuildInstantiatorTypeArguments(token_pos, instantiator_class, loaded);
   }
   *instantiator_result = instantiator;
   *instantiator_type_arguments_result = instantiator_type_arguments;
 }
 
 
 Value* EffectGraphVisitor::BuildNullValue() {
-  return Bind(new ConstantInstr(Object::ZoneHandle()));
+  return Bind(new ConstantInstr(Object::ZoneHandle(I, Object::null())));
 }
 
 
 // Used for testing incoming arguments.
 AssertAssignableInstr* EffectGraphVisitor::BuildAssertAssignable(
     intptr_t token_pos,
     Value* value,
     const AbstractType& dst_type,
     const String& dst_name) {
   // Build the type check computation.
@@ skipping 60 matching lines @@
   }
 }
 
 
 void EffectGraphVisitor::BuildTypeTest(ComparisonNode* node) {
   ASSERT(Token::IsTypeTestOperator(node->kind()));
   const AbstractType& type = node->right()->AsTypeNode()->type();
   ASSERT(type.IsFinalized() && !type.IsMalformedOrMalbounded());
   const bool negate_result = (node->kind() == Token::kISNOT);
   // All objects are instances of type T if Object type is a subtype of type T.
-  const Type& object_type = Type::Handle(Type::ObjectType());
+  const Type& object_type = Type::Handle(I, Type::ObjectType());
   if (type.IsInstantiated() && object_type.IsSubtypeOf(type, NULL)) {
     // Must evaluate left side.
     EffectGraphVisitor for_left_value(owner());
     node->left()->Visit(&for_left_value);
     Append(for_left_value);
     ReturnDefinition(new ConstantInstr(Bool::Get(!negate_result)));
     return;
   }
 
   // Check for javascript compatibility.
@@ skipping 48 matching lines @@
 
   // Check for javascript compatibility.
   if (FLAG_warn_on_javascript_compatibility) {
     owner()->WarnOnJSIntegralNumTypeTest(node->left(), type);
   }
 
   ValueGraphVisitor for_value(owner());
   node->left()->Visit(&for_value);
   Append(for_value);
   const String& dst_name = String::ZoneHandle(
-      Symbols::New(Exceptions::kCastErrorDstName));
+      I, Symbols::New(Exceptions::kCastErrorDstName));
   if (CanSkipTypeCheck(node->token_pos(),
                        for_value.value(),
                        type,
                        dst_name)) {
     ReturnValue(for_value.value());
     return;
   }
   PushArgumentInstr* push_left = PushArgument(for_value.value());
   PushArgumentInstr* push_instantiator = NULL;
   PushArgumentInstr* push_type_args = NULL;
@@ skipping 126 matching lines @@
 
   ValueGraphVisitor for_right_value(owner());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   PushArgumentInstr* push_right = PushArgument(for_right_value.value());
   arguments->Add(push_right);
 
   ASSERT(Token::IsRelationalOperator(node->kind()));
   InstanceCallInstr* comp =
       new InstanceCallInstr(node->token_pos(),
-                            String::ZoneHandle(Symbols::New(node->TokenName())),
+                            String::ZoneHandle(
+                                I, Symbols::New(node->TokenName())),
                             node->kind(),
                             arguments,
                             Object::null_array(),
                             2,
                             owner()->ic_data_array());
   ReturnDefinition(comp);
 }
 
 
 void EffectGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
@@ skipping 14 matching lines @@
 
   ValueGraphVisitor for_value(owner());
   node->operand()->Visit(&for_value);
   Append(for_value);
   PushArgumentInstr* push_value = PushArgument(for_value.value());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(1);
   arguments->Add(push_value);
   InstanceCallInstr* call =
       new InstanceCallInstr(node->token_pos(),
-                            String::ZoneHandle(Symbols::New(node->TokenName())),
+                            String::ZoneHandle(
+                                I, Symbols::New(node->TokenName())),
                             node->kind(),
                             arguments,
                             Object::null_array(),
                             1,
                             owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
@@ skipping 380 matching lines @@
 LocalVariable* EffectGraphVisitor::EnterTempLocalScope(Value* value) {
   Do(new PushTempInstr(value));
   owner()->AllocateTemp();
 
   ASSERT(value->definition()->temp_index() == (owner()->temp_count() - 1));
   intptr_t index = GetCurrentTempLocalIndex();
   char name[64];
   OS::SNPrint(name, 64, ":tmp_local%" Pd, index);
   LocalVariable*  var =
       new LocalVariable(0,
-                        String::ZoneHandle(Symbols::New(name)),
+                        String::ZoneHandle(I, Symbols::New(name)),
                         *value->Type()->ToAbstractType());
   var->set_index(index);
   return var;
 }
 
 
 Definition* EffectGraphVisitor::ExitTempLocalScope(LocalVariable* var) {
     Value* tmp = Bind(new LoadLocalInstr(*var));
     owner()->DeallocateTemps(1);
     ASSERT(GetCurrentTempLocalIndex() == var->index());
@@ skipping 53 matching lines @@
     owner()->DeallocateTemps(num_temps);
     ReturnDefinition(new DropTempsInstr(num_temps, result_value));
   } else {
     ReturnValue(result_value);
   }
 }
 
 
 void EffectGraphVisitor::VisitArrayNode(ArrayNode* node) {
   const TypeArguments& type_args =
-      TypeArguments::ZoneHandle(node->type().arguments());
+      TypeArguments::ZoneHandle(I, node->type().arguments());
   Value* element_type = BuildInstantiatedTypeArguments(node->token_pos(),
                                                        type_args);
   Value* num_elements =
-      Bind(new ConstantInstr(Smi::ZoneHandle(Smi::New(node->length()))));
+      Bind(new ConstantInstr(Smi::ZoneHandle(I, Smi::New(node->length()))));
   CreateArrayInstr* create = new CreateArrayInstr(node->token_pos(),
                                                   element_type,
                                                   num_elements);
   Value* array_val = Bind(create);
 
   { LocalVariable* tmp_var = EnterTempLocalScope(array_val);
     const intptr_t class_id = kArrayCid;
     const intptr_t deopt_id = Isolate::kNoDeoptId;
     for (int i = 0; i < node->length(); ++i) {
       Value* array = Bind(new LoadLocalInstr(*tmp_var));
-      Value* index = Bind(new ConstantInstr(Smi::ZoneHandle(Smi::New(i))));
+      Value* index = Bind(new ConstantInstr(Smi::ZoneHandle(I, Smi::New(i))));
       ValueGraphVisitor for_value(owner());
       node->ElementAt(i)->Visit(&for_value);
       Append(for_value);
       // No store barrier needed for constants.
       const StoreBarrierType emit_store_barrier =
           for_value.value()->BindsToConstant()
               ? kNoStoreBarrier
               : kEmitStoreBarrier;
       const intptr_t index_scale = Instance::ElementSizeFor(class_id);
       StoreIndexedInstr* store = new StoreIndexedInstr(
@@ skipping 15 matching lines @@
       new StringInterpolateInstr(for_argument.value(), node->token_pos());
   ReturnDefinition(instr);
 }
 
 
 void EffectGraphVisitor::VisitClosureNode(ClosureNode* node) {
   const Function& function = node->function();
 
   if (function.IsImplicitStaticClosureFunction()) {
     const Instance& closure =
-        Instance::ZoneHandle(function.ImplicitStaticClosure());
+        Instance::ZoneHandle(I, function.ImplicitStaticClosure());
     ReturnDefinition(new ConstantInstr(closure));
     return;
   }
   const bool is_implicit = function.IsImplicitInstanceClosureFunction();
   ASSERT(is_implicit || function.IsNonImplicitClosureFunction());
   // The context scope may have already been set by the non-optimizing
   // compiler.  If it was not, set it here.
   if (function.context_scope() == ContextScope::null()) {
     ASSERT(!is_implicit);
     const ContextScope& context_scope = ContextScope::ZoneHandle(
-        node->scope()->PreserveOuterScope(owner()->context_level()));
+        I, node->scope()->PreserveOuterScope(owner()->context_level()));
     ASSERT(!function.HasCode());
     ASSERT(function.context_scope() == ContextScope::null());
     function.set_context_scope(context_scope);
     const Class& cls = Class::Handle(
-        owner()->parsed_function()->function().Owner());
+        I, owner()->parsed_function()->function().Owner());
     // The closure is now properly setup, add it to the lookup table.
     // It is possible that the compiler creates more than one function
     // object for the same closure, e.g. when inlining nodes from
     // finally clauses. If we already have a function object for the
     // same closure, do not add a second one. We compare the origin
     // class, token position, and parent function to detect duplicates.
     // Note that we can have two different closure object for the same
     // source text represntation of the closure: one with a non-closurized
     // parent, and one with a closurized parent function.
 
     const Function& found_func = Function::Handle(
-        cls.LookupClosureFunction(function.token_pos()));
+        I, cls.LookupClosureFunction(function.token_pos()));
 
     if (found_func.IsNull() ||
         (found_func.token_pos() != function.token_pos()) ||
         (found_func.script() != function.script()) ||
         (found_func.parent_function() != function.parent_function())) {
       cls.AddClosureFunction(function);
     }
   }
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(1);
   ASSERT(function.context_scope() != ContextScope::null());
 
   // The function type of a closure may have type arguments. In that case,
   // pass the type arguments of the instantiator.
-  const Class& cls = Class::ZoneHandle(function.signature_class());
+  const Class& cls = Class::ZoneHandle(I, function.signature_class());
   ASSERT(!cls.IsNull());
   const bool requires_type_arguments = cls.NumTypeArguments() > 0;
   Value* type_arguments = NULL;
   if (requires_type_arguments) {
     ASSERT(cls.type_arguments_field_offset() ==
            Closure::type_arguments_offset());
     ASSERT(cls.instance_size() == Closure::InstanceSize());
     const Class& instantiator_class = Class::Handle(
-        owner()->parsed_function()->function().Owner());
+        I, owner()->parsed_function()->function().Owner());
     type_arguments = BuildInstantiatorTypeArguments(node->token_pos(),
                                                     instantiator_class,
                                                     NULL);
     arguments->Add(PushArgument(type_arguments));
   }
   AllocateObjectInstr* alloc = new AllocateObjectInstr(node->token_pos(),
                                                        cls,
                                                        arguments);
   alloc->set_closure_function(function);
 
   Value* closure_val = Bind(alloc);
   { LocalVariable* closure_tmp_var = EnterTempLocalScope(closure_val);
     // Store function.
     Value* closure_tmp_val = Bind(new LoadLocalInstr(*closure_tmp_var));
     Value* func_val =
-        Bind(new ConstantInstr(Function::ZoneHandle(function.raw())));
+        Bind(new ConstantInstr(Function::ZoneHandle(I, function.raw())));
     Do(new StoreInstanceFieldInstr(Closure::function_offset(),
                                    closure_tmp_val,
                                    func_val,
                                    kEmitStoreBarrier,
                                    node->token_pos()));
     if (is_implicit) {
       // Create new context containing the receiver.
       const intptr_t kNumContextVariables = 1;  // The receiver.
       Value* allocated_context =
           Bind(new AllocateContextInstr(node->token_pos(),
@@ skipping 136 matching lines @@
       new ZoneGrowableArray<PushArgumentInstr*>(node->arguments()->length());
   Value* closure_val = Bind(new LoadLocalInstr(*tmp_var));
   PushArgumentInstr* push_closure = PushArgument(closure_val);
   arguments->Add(push_closure);
   BuildPushArguments(*node->arguments(), arguments);
 
   // Save context around the call.
   ASSERT(owner()->parsed_function()->saved_current_context_var() != NULL);
   BuildSaveContext(*owner()->parsed_function()->saved_current_context_var());
   closure_val = Bind(new LoadLocalInstr(*tmp_var));
-  LoadFieldInstr* context_load = new LoadFieldInstr(closure_val,
-                                                    Closure::context_offset(),
-                                                    AbstractType::ZoneHandle(),
-                                                    node->token_pos());
+  LoadFieldInstr* context_load = new LoadFieldInstr(
+      closure_val,
+      Closure::context_offset(),
+      AbstractType::ZoneHandle(I, AbstractType::null()),
+      node->token_pos());
   context_load->set_is_immutable(true);
   Value* context_val = Bind(context_load);
   AddInstruction(new StoreContextInstr(context_val));
   closure_val = Bind(new LoadLocalInstr(*tmp_var));
-  LoadFieldInstr* function_load =
-      new LoadFieldInstr(closure_val,
-                         Closure::function_offset(),
-                         AbstractType::ZoneHandle(),
-                         node->token_pos());
+  LoadFieldInstr* function_load = new LoadFieldInstr(
+      closure_val,
+      Closure::function_offset(),
+      AbstractType::ZoneHandle(I, AbstractType::null()),
+      node->token_pos());
   function_load->set_is_immutable(true);
   Value* function_val = Bind(function_load);
   Definition* closure_call =
       new ClosureCallInstr(function_val, node, arguments);
   if (result_needed) {
     Value* result = Bind(closure_call);
     Do(new StoreLocalInstr(*tmp_var, result));
     // Restore context from temp.
     BuildRestoreContext(
         *owner()->parsed_function()->saved_current_context_var());
@@ skipping 19 matching lines @@
 
 
 void EffectGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
   Value* context = Bind(new CurrentContextInstr());
   Value* clone = Bind(new CloneContextInstr(node->token_pos(), context));
   AddInstruction(new StoreContextInstr(clone));
 }
 
 
 Value* EffectGraphVisitor::BuildObjectAllocation(ConstructorCallNode* node) {
-  const Class& cls = Class::ZoneHandle(node->constructor().Owner());
+  const Class& cls = Class::ZoneHandle(I, node->constructor().Owner());
   const bool cls_is_parameterized = cls.NumTypeArguments() > 0;
 
   ZoneGrowableArray<PushArgumentInstr*>* allocate_arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(cls_is_parameterized ? 1 : 0);
   if (cls_is_parameterized) {
     Value* type_args = BuildInstantiatedTypeArguments(node->token_pos(),
                                                       node->type_arguments());
     allocate_arguments->Add(PushArgument(type_args));
   }
 
   Definition* allocation = new AllocateObjectInstr(
       node->token_pos(),
-      Class::ZoneHandle(node->constructor().Owner()),
+      Class::ZoneHandle(I, node->constructor().Owner()),
       allocate_arguments);
 
   return Bind(allocation);
 }
 
 
 void EffectGraphVisitor::BuildConstructorCall(
     ConstructorCallNode* node,
     PushArgumentInstr* push_alloc_value) {
   Value* ctor_arg = Bind(
-      new ConstantInstr(Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll))));
+      new ConstantInstr(Smi::ZoneHandle(I, Smi::New(Function::kCtorPhaseAll))));
   PushArgumentInstr* push_ctor_arg = PushArgument(ctor_arg);
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   arguments->Add(push_alloc_value);
   arguments->Add(push_ctor_arg);
 
   BuildPushArguments(*node->arguments(), arguments);
   Do(new StaticCallInstr(node->token_pos(),
                          node->constructor(),
@@ skipping 63 matching lines @@
   // No need to preserve allocated value (simpler than in ValueGraphVisitor).
   Value* allocated_value = BuildObjectAllocation(node);
   PushArgumentInstr* push_allocated_value = PushArgument(allocated_value);
   BuildConstructorCall(node, push_allocated_value);
 }
 
 
 Value* EffectGraphVisitor::BuildInstantiator(const Class& instantiator_class) {
   ASSERT(instantiator_class.NumTypeParameters() > 0);
   Function& outer_function =
-      Function::Handle(owner()->parsed_function()->function().raw());
+      Function::Handle(I, owner()->parsed_function()->function().raw());
   while (outer_function.IsLocalFunction()) {
     outer_function = outer_function.parent_function();
   }
   if (outer_function.IsFactory()) {
     return NULL;
   }
 
   LocalVariable* instantiator = owner()->parsed_function()->instantiator();
   ASSERT(instantiator != NULL);
   Value* result = Bind(BuildLoadLocal(*instantiator));
   return result;
 }
 
 
 // 'expression_temp_var' may not be used inside this method if 'instantiator'
 // is not NULL.
 Value* EffectGraphVisitor::BuildInstantiatorTypeArguments(
     intptr_t token_pos,
     const Class& instantiator_class,
     Value* instantiator) {
   if (instantiator_class.NumTypeParameters() == 0) {
     // The type arguments are compile time constants.
-    TypeArguments& type_arguments = TypeArguments::ZoneHandle();
+    TypeArguments& type_arguments =
+        TypeArguments::ZoneHandle(I, TypeArguments::null());
     // Type is temporary. Only its type arguments are preserved.
     Type& type = Type::Handle(
+        I,
         Type::New(instantiator_class, type_arguments, token_pos, Heap::kNew));
     type ^= ClassFinalizer::FinalizeType(
         instantiator_class, type, ClassFinalizer::kFinalize);
     ASSERT(!type.IsMalformedOrMalbounded());
     type_arguments = type.arguments();
     type_arguments = type_arguments.Canonicalize();
     return Bind(new ConstantInstr(type_arguments));
   }
   Function& outer_function =
-      Function::Handle(owner()->parsed_function()->function().raw());
+      Function::Handle(I, owner()->parsed_function()->function().raw());
   while (outer_function.IsLocalFunction()) {
     outer_function = outer_function.parent_function();
   }
   if (outer_function.IsFactory()) {
     // No instantiator for factories.
     ASSERT(instantiator == NULL);
     LocalVariable* instantiator_var =
         owner()->parsed_function()->instantiator();
     ASSERT(instantiator_var != NULL);
     return Bind(BuildLoadLocal(*instantiator_var));
   }
   if (instantiator == NULL) {
     instantiator = BuildInstantiator(instantiator_class);
   }
   // The instantiator is the receiver of the caller, which is not a factory.
   // The receiver cannot be null; extract its TypeArguments object.
   // Note that in the factory case, the instantiator is the first parameter
   // of the factory, i.e. already a TypeArguments object.
   intptr_t type_arguments_field_offset =
       instantiator_class.type_arguments_field_offset();
   ASSERT(type_arguments_field_offset != Class::kNoTypeArguments);
 
   return Bind(new LoadFieldInstr(
       instantiator,
       type_arguments_field_offset,
-      Type::ZoneHandle(),  // Not an instance, no type.
+      Type::ZoneHandle(I, Type::null()),  // Not an instance, no type.
       Scanner::kNoSourcePos));
 }
 
 
 Value* EffectGraphVisitor::BuildInstantiatedTypeArguments(
     intptr_t token_pos,
     const TypeArguments& type_arguments) {
   if (type_arguments.IsNull() || type_arguments.IsInstantiated()) {
     return Bind(new ConstantInstr(type_arguments));
   }
   // The type arguments are uninstantiated.
   const Class& instantiator_class = Class::ZoneHandle(
-      owner()->parsed_function()->function().Owner());
+      I, owner()->parsed_function()->function().Owner());
   Value* instantiator_value =
       BuildInstantiatorTypeArguments(token_pos, instantiator_class, NULL);
   const bool use_instantiator_type_args =
       type_arguments.IsUninstantiatedIdentity() ||
       type_arguments.CanShareInstantiatorTypeArguments(instantiator_class);
   if (use_instantiator_type_args) {
     return instantiator_value;
   } else {
     return Bind(new InstantiateTypeArgumentsInstr(token_pos,
                                                   type_arguments,
@@ skipping 29 matching lines @@
 
 void EffectGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
   ValueGraphVisitor for_receiver(owner());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(1);
   arguments->Add(push_receiver);
   const String& name =
-      String::ZoneHandle(Field::GetterSymbol(node->field_name()));
+      String::ZoneHandle(I, Field::GetterSymbol(node->field_name()));
   InstanceCallInstr* call = new InstanceCallInstr(
       node->token_pos(),
       name,
       Token::kGET,
       arguments, Object::null_array(),
       1,
       owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
@@ skipping 19 matching lines @@
   }
   arguments->Add(PushArgument(value));
 }
 
 
 void EffectGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   BuildInstanceSetterArguments(node, arguments, kResultNotNeeded);
   const String& name =
-      String::ZoneHandle(Field::SetterSymbol(node->field_name()));
+      String::ZoneHandle(I, Field::SetterSymbol(node->field_name()));
   InstanceCallInstr* call = new InstanceCallInstr(node->token_pos(),
                                                   name,
                                                   Token::kSET,
                                                   arguments,
                                                   Object::null_array(),
                                                   2,  // Checked arg count.
                                                   owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void ValueGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   BuildInstanceSetterArguments(node, arguments, kResultNeeded);
   const String& name =
-      String::ZoneHandle(Field::SetterSymbol(node->field_name()));
+      String::ZoneHandle(I, Field::SetterSymbol(node->field_name()));
   Do(new InstanceCallInstr(node->token_pos(),
                            name,
                            Token::kSET,
                            arguments,
                            Object::null_array(),
                            2,  // Checked argument count.
                            owner()->ic_data_array()));
   ReturnDefinition(BuildLoadExprTemp());
 }
 
 
 void EffectGraphVisitor::VisitStaticGetterNode(StaticGetterNode* node) {
   const String& getter_name =
-      String::ZoneHandle(Field::GetterSymbol(node->field_name()));
+      String::ZoneHandle(I, Field::GetterSymbol(node->field_name()));
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>();
-  Function& getter_function = Function::ZoneHandle();
+  Function& getter_function = Function::ZoneHandle(I, Function::null());
   if (node->is_super_getter()) {
     // Statically resolved instance getter, i.e. "super getter".
     ASSERT(node->receiver() != NULL);
     getter_function = Resolver::ResolveDynamicAnyArgs(node->cls(), getter_name);
     if (getter_function.IsNull()) {
       // Resolve and call noSuchMethod.
       ArgumentListNode* arguments = new ArgumentListNode(node->token_pos());
       arguments->Add(node->receiver());
       StaticCallInstr* call =
           BuildStaticNoSuchMethodCall(node->cls(),
@@ skipping 48 matching lines @@
                                               Object::null_array(),  // No names
                                               arguments,
                                               owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::BuildStaticSetter(StaticSetterNode* node,
                                            bool result_is_needed) {
   const String& setter_name =
-      String::ZoneHandle(Field::SetterSymbol(node->field_name()));
+      String::ZoneHandle(I, Field::SetterSymbol(node->field_name()));
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(1);
   // A super setter is an instance setter whose setter function is
   // resolved at compile time (in the caller instance getter's super class).
   // Unlike a static getter, a super getter has a receiver parameter.
   const bool is_super_setter = (node->receiver() != NULL);
   Function& setter_function =
-      Function::ZoneHandle(is_super_setter
+      Function::ZoneHandle(I, is_super_setter
           ? Resolver::ResolveDynamicAnyArgs(node->cls(), setter_name)
           : node->cls().LookupStaticFunction(setter_name));
   StaticCallInstr* call;
   if (setter_function.IsNull()) {
     if (is_super_setter) {
       ASSERT(node->receiver() != NULL);
       // Resolve and call noSuchMethod.
       ArgumentListNode* arguments = new ArgumentListNode(node->token_pos());
       arguments->Add(node->receiver());
       arguments->Add(node->value());
@@ skipping 113 matching lines @@
       case MethodRecognizer::kStringBaseLength:
       case MethodRecognizer::kStringBaseIsEmpty: {
         Value* receiver = Bind(BuildLoadThisVar(node->scope()));
         // Treat length loads as mutable (i.e. affected by side effects) to
         // avoid hoisting them since we can't hoist the preceding class-check.
         // This is because of externalization of strings that affects their
         // class-id.
         LoadFieldInstr* load = new LoadFieldInstr(
             receiver,
             String::length_offset(),
-            Type::ZoneHandle(Type::SmiType()),
+            Type::ZoneHandle(I, Type::SmiType()),
             node->token_pos());
         load->set_result_cid(kSmiCid);
         load->set_recognized_kind(MethodRecognizer::kStringBaseLength);
         if (kind == MethodRecognizer::kStringBaseLength) {
           return ReturnDefinition(load);
         }
         ASSERT(kind == MethodRecognizer::kStringBaseIsEmpty);
-        Value* zero_val = Bind(new ConstantInstr(Smi::ZoneHandle(Smi::New(0))));
+        Value* zero_val = Bind(new ConstantInstr(
+            Smi::ZoneHandle(I, Smi::New(0))));
         Value* load_val = Bind(load);
         StrictCompareInstr* compare =
             new StrictCompareInstr(node->token_pos(),
                                    Token::kEQ_STRICT,
                                    load_val,
                                    zero_val,
                                    false);  // No number check.
         return ReturnDefinition(compare);
       }
       case MethodRecognizer::kGrowableArrayLength:
       case MethodRecognizer::kObjectArrayLength:
       case MethodRecognizer::kImmutableArrayLength:
       case MethodRecognizer::kTypedDataLength: {
         Value* receiver = Bind(BuildLoadThisVar(node->scope()));
         LoadFieldInstr* load = new LoadFieldInstr(
             receiver,
             OffsetForLengthGetter(kind),
-            Type::ZoneHandle(Type::SmiType()),
+            Type::ZoneHandle(I, Type::SmiType()),
             node->token_pos());
         load->set_is_immutable(kind != MethodRecognizer::kGrowableArrayLength);
         load->set_result_cid(kSmiCid);
         load->set_recognized_kind(kind);
         return ReturnDefinition(load);
       }
       case MethodRecognizer::kObjectCid:
       case MethodRecognizer::kTypedListBaseCid: {
         Value* receiver = Bind(BuildLoadThisVar(node->scope()));
         LoadClassIdInstr* load = new LoadClassIdInstr(receiver);
         return ReturnDefinition(load);
       }
       case MethodRecognizer::kGrowableArrayCapacity: {
         Value* receiver = Bind(BuildLoadThisVar(node->scope()));
         LoadFieldInstr* data_load = new LoadFieldInstr(
             receiver,
             Array::data_offset(),
-            Type::ZoneHandle(Type::DynamicType()),
+            Type::ZoneHandle(I, Type::DynamicType()),
             node->token_pos());
         data_load->set_result_cid(kArrayCid);
         Value* data = Bind(data_load);
         LoadFieldInstr* length_load = new LoadFieldInstr(
             data,
             Array::length_offset(),
-            Type::ZoneHandle(Type::SmiType()),
+            Type::ZoneHandle(I, Type::SmiType()),
             node->token_pos());
         length_load->set_result_cid(kSmiCid);
         length_load->set_recognized_kind(MethodRecognizer::kObjectArrayLength);
         return ReturnDefinition(length_load);
       }
       default:
         break;
     }
   }
   InlineBailout("EffectGraphVisitor::VisitNativeBodyNode");
@@ skipping 50 matching lines @@
 
 
 void EffectGraphVisitor::VisitLoadInstanceFieldNode(
     LoadInstanceFieldNode* node) {
   ValueGraphVisitor for_instance(owner());
   node->instance()->Visit(&for_instance);
   Append(for_instance);
   LoadFieldInstr* load = new LoadFieldInstr(
       for_instance.value(),
       &node->field(),
-      AbstractType::ZoneHandle(node->field().type()),
+      AbstractType::ZoneHandle(I, node->field().type()),
       node->token_pos());
   if (node->field().guarded_cid() != kIllegalCid) {
     if (!node->field().is_nullable() ||
         (node->field().guarded_cid() == kNullCid)) {
       load->set_result_cid(node->field().guarded_cid());
     }
     FlowGraph::AddToGuardedFields(owner()->guarded_fields(), &node->field());
   }
   ReturnDefinition(load);
 }
 
 
 void EffectGraphVisitor::VisitStoreInstanceFieldNode(
     StoreInstanceFieldNode* node) {
   ValueGraphVisitor for_instance(owner());
   node->instance()->Visit(&for_instance);
   Append(for_instance);
   ValueGraphVisitor for_value(owner());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
-    const AbstractType& type = AbstractType::ZoneHandle(node->field().type());
-    const String& dst_name = String::ZoneHandle(node->field().name());
+    const AbstractType& type =
+        AbstractType::ZoneHandle(I, node->field().type());
+    const String& dst_name = String::ZoneHandle(I, node->field().name());
     store_value = BuildAssignableValue(node->value()->token_pos(),
                                        store_value,
                                        type,
                                        dst_name);
   }
 
   store_value = Bind(BuildStoreExprTemp(store_value));
   GuardFieldInstr* guard =
-      new GuardFieldInstr(store_value,
-                          node->field(),
-                          Isolate::Current()->GetNextDeoptId());
+      new GuardFieldInstr(store_value, node->field(), I->GetNextDeoptId());
   AddInstruction(guard);
 
   store_value = Bind(BuildLoadExprTemp());
   StoreInstanceFieldInstr* store =
       new StoreInstanceFieldInstr(node->field(),
                                   for_instance.value(),
                                   store_value,
                                   kEmitStoreBarrier,
                                   node->token_pos());
   store->set_is_initialization(true);  // Maybe initializing store.
   ReturnDefinition(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadStaticFieldNode(LoadStaticFieldNode* node) {
   if (node->field().is_const()) {
     ASSERT(node->field().value() != Object::sentinel().raw());
     ASSERT(node->field().value() != Object::transition_sentinel().raw());
     Definition* result =
-        new ConstantInstr(Instance::ZoneHandle(node->field().value()));
+        new ConstantInstr(Instance::ZoneHandle(I, node->field().value()));
     return ReturnDefinition(result);
   }
   Value* field_value = Bind(new ConstantInstr(node->field()));
   LoadStaticFieldInstr* load = new LoadStaticFieldInstr(field_value);
   ReturnDefinition(load);
 }
 
 
 Definition* EffectGraphVisitor::BuildStoreStaticField(
   StoreStaticFieldNode* node, bool result_is_needed) {
@@ skipping 26 matching lines @@
 void ValueGraphVisitor::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
   ReturnDefinition(BuildStoreStaticField(node, kResultNeeded));
 }
 
 
 void EffectGraphVisitor::VisitLoadIndexedNode(LoadIndexedNode* node) {
   Function* super_function = NULL;
   if (node->IsSuperLoad()) {
     // Resolve the load indexed operator in the super class.
     super_function = &Function::ZoneHandle(
-          Resolver::ResolveDynamicAnyArgs(node->super_class(),
-                                          Symbols::IndexToken()));
+          I, Resolver::ResolveDynamicAnyArgs(node->super_class(),
+                                             Symbols::IndexToken()));
     if (super_function->IsNull()) {
       // Could not resolve super operator. Generate call noSuchMethod() of the
       // super class instead.
       ArgumentListNode* arguments = new ArgumentListNode(node->token_pos());
       arguments->Add(node->array());
       arguments->Add(node->index_expr());
       StaticCallInstr* call =
           BuildStaticNoSuchMethodCall(node->super_class(),
                                       node->array(),
                                       Symbols::IndexToken(),
@@ skipping 39 matching lines @@
 }
 
 
 Definition* EffectGraphVisitor::BuildStoreIndexedValues(
     StoreIndexedNode* node,
     bool result_is_needed) {
   Function* super_function = NULL;
   if (node->IsSuperStore()) {
     // Resolve the store indexed operator in the super class.
     super_function = &Function::ZoneHandle(
-        Resolver::ResolveDynamicAnyArgs(node->super_class(),
-                                        Symbols::AssignIndexToken()));
+        I, Resolver::ResolveDynamicAnyArgs(node->super_class(),
+                                           Symbols::AssignIndexToken()));
     if (super_function->IsNull()) {
       // Could not resolve super operator. Generate call noSuchMethod() of the
       // super class instead.
       ArgumentListNode* arguments = new ArgumentListNode(node->token_pos());
       arguments->Add(node->array());
       arguments->Add(node->index_expr());
       arguments->Add(node->value());
       StaticCallInstr* call = BuildStaticNoSuchMethodCall(
           node->super_class(),
           node->array(),
@@ skipping 46 matching lines @@
     if (result_is_needed) {
       Do(store);
       return BuildLoadExprTemp();
     } else {
       return store;
     }
   } else {
     // Generate dynamic call to operator []=.
     const intptr_t checked_argument_count = 3;
     const String& name =
-        String::ZoneHandle(Symbols::New(Token::Str(Token::kASSIGN_INDEX)));
+        String::ZoneHandle(I, Symbols::New(Token::Str(Token::kASSIGN_INDEX)));
     InstanceCallInstr* store =
         new InstanceCallInstr(node->token_pos(),
                               name,
                               Token::kASSIGN_INDEX,
                               arguments,
                               Object::null_array(),
                               checked_argument_count,
                               owner()->ic_data_array());
     if (result_is_needed) {
       Do(store);
@@ skipping 21 matching lines @@
 }
 
 
 void EffectGraphVisitor::UnchainContexts(intptr_t n) {
   if (n > 0) {
     Value* context = Bind(new CurrentContextInstr());
     while (n-- > 0) {
       context = Bind(
           new LoadFieldInstr(context,
                              Context::parent_offset(),
-                             Type::ZoneHandle(),  // Not an instance, no type.
+                             // Not an instance, no type.
+                             Type::ZoneHandle(I, Type::null()),
                              Scanner::kNoSourcePos));
     }
     AddInstruction(new StoreContextInstr(context));
   }
 }
 
 
 // <Statement> ::= Sequence { scope: LocalScope
 //                            nodes: <Statement>*
 //                            label: SourceLabel }
@@ skipping 18 matching lines @@
       // if this function allocates context variables, but none of its enclosing
       // functions do, the context on entry is not linked as parent of the
       // allocated context but saved on entry and restored on exit as to prevent
       // memory leaks.
       // In this case, the parser pre-allocates a variable to save the context.
       Value* tmp_val = Bind(new LoadLocalInstr(*tmp_var));
       Value* parent_context = NULL;
       if (MustSaveRestoreContext(node)) {
         BuildSaveContext(
             *owner()->parsed_function()->saved_entry_context_var());
-        parent_context = Bind(new ConstantInstr(Object::ZoneHandle()));
+        parent_context = Bind(
+            new ConstantInstr(Object::ZoneHandle(I, Object::null())));
       } else {
         parent_context = Bind(new CurrentContextInstr());
       }
       Do(new StoreInstanceFieldInstr(Context::parent_offset(),
                                      tmp_val,
                                      parent_context,
                                      kEmitStoreBarrier,
                                      Scanner::kNoSourcePos));
       AddInstruction(
           new StoreContextInstr(Bind(ExitTempLocalScope(tmp_var))));
     }
 
     // If this node_sequence is the body of the function being compiled, copy
     // the captured parameters from the frame into the context.
     if (node == owner()->parsed_function()->node_sequence()) {
       ASSERT(scope->context_level() == 1);
       const Function& function = owner()->parsed_function()->function();
       const int num_params = function.NumParameters();
       int param_frame_index = (num_params == function.num_fixed_parameters()) ?
           (kParamEndSlotFromFp + num_params) : kFirstLocalSlotFromFp;
       for (int pos = 0; pos < num_params; param_frame_index--, pos++) {
         const LocalVariable& parameter = *scope->VariableAt(pos);
         ASSERT(parameter.owner() == scope);
         if (parameter.is_captured()) {
           // Create a temporary local describing the original position.
           const String& temp_name = Symbols::TempParam();
           LocalVariable* temp_local = new LocalVariable(
               0,  // Token index.
               temp_name,
-              Type::ZoneHandle(Type::DynamicType()));  // Type.
+              Type::ZoneHandle(I, Type::DynamicType()));  // Type.
           temp_local->set_index(param_frame_index);
 
           // Copy parameter from local frame to current context.
           Value* load = Bind(BuildLoadLocal(*temp_local));
           Do(BuildStoreLocal(parameter, load));
           // Write NULL to the source location to detect buggy accesses and
           // allow GC of passed value if it gets overwritten by a new value in
           // the function.
-          Value* null_constant =
-              Bind(new ConstantInstr(Object::ZoneHandle()));
+          Value* null_constant = Bind(new ConstantInstr(
+              Object::ZoneHandle(I, Object::null())));
           Do(BuildStoreLocal(*temp_local, null_constant));
         }
       }
     }
   } else if (MustSaveRestoreContext(node)) {
     // Even when the current scope has no context variables, we may
     // still need to save the current context if, for example, there
     // are loop scopes below this which will allocate a context
     // object.
     BuildSaveContext(
         *owner()->parsed_function()->saved_entry_context_var());
     AddInstruction(
         new StoreContextInstr(Bind(new ConstantInstr(Object::ZoneHandle(
-            Isolate::Current()->object_store()->empty_context())))));
+            I, I->object_store()->empty_context())))));
   }
 
   // This check may be deleted if the generated code is leaf.
   // Native functions don't need a stack check at entry.
   const Function& function = owner()->parsed_function()->function();
   if ((node == owner()->parsed_function()->node_sequence()) &&
       !function.is_native()) {
     // Always allocate CheckOverflowInstr so that deopt-ids match regardless
     // if we inline or not.
     if (!function.IsImplicitGetterFunction() &&
@@ skipping 170 matching lines @@
       for_finally.PushArgument(exception);
       Value* stacktrace = for_finally.Bind(
           for_finally.BuildLoadLocal(catch_block->stacktrace_var()));
       for_finally.PushArgument(stacktrace);
       for_finally.AddInstruction(
           new ReThrowInstr(catch_block->token_pos(), catch_handler_index));
       for_finally.CloseFragment();
     }
     ASSERT(!for_finally.is_open());
 
-    const Array& types = Array::ZoneHandle(Array::New(1, Heap::kOld));
-    types.SetAt(0, Type::Handle(Type::DynamicType()));
+    const Array& types = Array::ZoneHandle(I, Array::New(1, Heap::kOld));
+    types.SetAt(0, Type::Handle(I, Type::DynamicType()));
     CatchBlockEntryInstr* finally_entry =
         new CatchBlockEntryInstr(owner()->AllocateBlockId(),
                                  original_handler_index,
                                  types,
                                  catch_handler_index,
                                  catch_block->exception_var(),
                                  catch_block->stacktrace_var(),
                                  catch_block->needs_stacktrace());
     owner()->AddCatchEntry(finally_entry);
     AppendFragment(finally_entry, for_finally);
@@ skipping 22 matching lines @@
   if (save_last_arg) {
     temp = owner()->parsed_function()->EnsureExpressionTemp();
   }
   ArgumentListNode* args =
       Parser::BuildNoSuchMethodArguments(args_pos,
                                          method_name,
                                          *method_arguments,
                                          temp,
                                          is_super_invocation);
   const Function& no_such_method_func = Function::ZoneHandle(
+      I,
       Resolver::ResolveDynamicAnyArgs(target_class, Symbols::NoSuchMethod()));
   // We are guaranteed to find noSuchMethod of class Object.
   ASSERT(!no_such_method_func.IsNull());
   ZoneGrowableArray<PushArgumentInstr*>* push_arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   BuildPushArguments(*args, push_arguments);
   return new StaticCallInstr(args_pos,
                              no_such_method_func,
                              Object::null_array(),
                              push_arguments,
                              owner()->ic_data_array());
 }
 
 
 StaticCallInstr* EffectGraphVisitor::BuildThrowNoSuchMethodError(
     intptr_t token_pos,
     const Class& function_class,
     const String& function_name,
     ArgumentListNode* function_arguments,
     int invocation_type) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>();
   // 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(
+      I,
       Type::New(function_class,
-                TypeArguments::Handle(),
+                TypeArguments::Handle(I, TypeArguments::null()),
                 token_pos,
                 Heap::kOld));
   type ^= ClassFinalizer::FinalizeType(
       function_class, type, ClassFinalizer::kCanonicalize);
   Value* receiver_value = Bind(new ConstantInstr(type));
   arguments->Add(PushArgument(receiver_value));
   // String memberName.
-  const String& member_name = String::ZoneHandle(Symbols::New(function_name));
+  const String& member_name =
+      String::ZoneHandle(I, Symbols::New(function_name));
   Value* member_name_value = Bind(new ConstantInstr(member_name));
   arguments->Add(PushArgument(member_name_value));
   // Smi invocation_type.
   Value* invocation_type_value = Bind(new ConstantInstr(
-      Smi::ZoneHandle(Smi::New(invocation_type))));
+      Smi::ZoneHandle(I, Smi::New(invocation_type))));
   arguments->Add(PushArgument(invocation_type_value));
   // List arguments.
   if (function_arguments == NULL) {
-    Value* arguments_value = Bind(new ConstantInstr(Array::ZoneHandle()));
+    Value* arguments_value = Bind(
+        new ConstantInstr(Array::ZoneHandle(I, Array::null())));
     arguments->Add(PushArgument(arguments_value));
   } else {
     ValueGraphVisitor array_val(owner());
     ArrayNode* array =
-        new ArrayNode(token_pos, Type::ZoneHandle(Type::ArrayType()),
+        new ArrayNode(token_pos, Type::ZoneHandle(I, Type::ArrayType()),
                       function_arguments->nodes());
     array->Visit(&array_val);
     Append(array_val);
     arguments->Add(PushArgument(array_val.value()));
   }
   // List argumentNames.
   ConstantInstr* cinstr = new ConstantInstr(
-      (function_arguments == NULL) ? Array::ZoneHandle()
+      (function_arguments == NULL) ? Array::ZoneHandle(I, Array::null())
                                    : function_arguments->names());
   Value* argument_names_value = Bind(cinstr);
   arguments->Add(PushArgument(argument_names_value));
 
   // List existingArgumentNames.
   Value* existing_argument_names_value =
-      Bind(new ConstantInstr(Array::ZoneHandle()));
+      Bind(new ConstantInstr(Array::ZoneHandle(I, Array::null())));
   arguments->Add(PushArgument(existing_argument_names_value));
   // Resolve and call NoSuchMethodError._throwNew.
-  const Library& core_lib = Library::Handle(Library::CoreLibrary());
+  const Library& core_lib = Library::Handle(I, Library::CoreLibrary());
   const Class& cls = Class::Handle(
-      core_lib.LookupClass(Symbols::NoSuchMethodError()));
+      I, core_lib.LookupClass(Symbols::NoSuchMethodError()));
   ASSERT(!cls.IsNull());
   const Function& func = Function::ZoneHandle(
+      I,
       Resolver::ResolveStatic(cls,
                               Library::PrivateCoreLibName(Symbols::ThrowNew()),
                               arguments->length(),
                               Object::null_array()));
   ASSERT(!func.IsNull());
   return new StaticCallInstr(token_pos,
                              func,
                              Object::null_array(),  // No names.
                              arguments,
                              owner()->ic_data_array());
@@ skipping 23 matching lines @@
   BuildThrowNode(node);
   CloseFragment();
 }
 
 
 // A throw cannot be part of an expression, however, the parser may replace
 // certain expression nodes with a throw. In that case generate a literal null
 // so that the fragment is not closed in the middle of an expression.
 void ValueGraphVisitor::VisitThrowNode(ThrowNode* node) {
   BuildThrowNode(node);
-  ReturnDefinition(new ConstantInstr(Instance::ZoneHandle()));
+  ReturnDefinition(new ConstantInstr(
+      Instance::ZoneHandle(I, Instance::null())));
 }
 
 
 void EffectGraphVisitor::VisitInlinedFinallyNode(InlinedFinallyNode* node) {
   InlineBailout("EffectGraphVisitor::VisitInlinedFinallyNode (exception)");
   const intptr_t try_index = owner()->try_index();
   if (try_index >= 0) {
     // We are about to generate code for an inlined finally block. Exceptions
     // thrown in this block of code should be treated as though they are
     // thrown not from the current try block but the outer try block if any.
@@ skipping 66 matching lines @@
 }
 
 
 void FlowGraphBuilder::Warning(intptr_t token_pos,
                                const char* format, ...) const {
   if (FLAG_silent_warnings) return;
   const Function& function = parsed_function_->function();
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
-      LanguageError::NewFormattedV(Error::Handle(),  // No previous error.
-                                   Script::Handle(function.script()),
-                                   token_pos, LanguageError::kWarning,
-                                   Heap::kNew, format, args));
+      I,
+      LanguageError::NewFormattedV(
+          Error::Handle(I, Error::null()),  // No previous error.
+          Script::Handle(I, function.script()),
+          token_pos, LanguageError::kWarning,
+          Heap::kNew, format, args));
   va_end(args);
   if (FLAG_warning_as_error) {
-    Isolate::Current()->long_jump_base()->Jump(1, error);
+    I->long_jump_base()->Jump(1, error);
     UNREACHABLE();
   } else {
     OS::Print("%s", error.ToErrorCString());
   }
 }
 
 
 void FlowGraphBuilder::Bailout(const char* reason) const {
   const Function& function = parsed_function_->function();
   const Error& error = Error::Handle(
-      LanguageError::NewFormatted(Error::Handle(),  // No previous error.
-                                  Script::Handle(function.script()),
-                                  function.token_pos(),
-                                  LanguageError::kBailout,
-                                  Heap::kNew,
-                                  "FlowGraphBuilder Bailout: %s %s",
-                                  String::Handle(function.name()).ToCString(),
-                                  reason));
-  Isolate::Current()->long_jump_base()->Jump(1, error);
+      I,
+      LanguageError::NewFormatted(
+          Error::Handle(I, Error::null()),  // No previous error.
+          Script::Handle(I, function.script()),
+          function.token_pos(),
+          LanguageError::kBailout,
+          Heap::kNew,
+          "FlowGraphBuilder Bailout: %s %s",
+          String::Handle(I, function.name()).ToCString(),
+          reason));
+  I->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 }  // namespace dart