Add Zone-based handle allocation interface and reduce use of Isolate-based interfaces.

runtime/vm/parser.cc

Index: runtime/vm/parser.cc
===================================================================
--- runtime/vm/parser.cc	(revision 43075)
+++ runtime/vm/parser.cc	(working copy)
@@ -62,8 +62,9 @@
                     "Enable checked mode.");
 
 
-// Quick access to the locally defined isolate() method.
-#define I (isolate())
+// Quick access to the current isolate and zone.
+#define I (thread()->isolate())

[siva, 2015/01/23 19:29:27]

Is I still used?

[koda, 2015/01/23 21:09:42]

Yes in ~15 places, mostly to access the object_store.

+#define Z (zone())
 
 
 #if defined(DEBUG)
@@ -132,7 +133,7 @@
 LocalVariable* ParsedFunction::EnsureExpressionTemp() {
   if (!has_expression_temp_var()) {
     LocalVariable* temp =
-        new (I) LocalVariable(function_.token_pos(),
+        new (Z) LocalVariable(function_.token_pos(),
                               Symbols::ExprTemp(),
                               Type::ZoneHandle(Type::DynamicType()));
     ASSERT(temp != NULL);
@@ -145,10 +146,10 @@
 
 void ParsedFunction::EnsureFinallyReturnTemp() {
   if (!has_finally_return_temp_var()) {
-    LocalVariable* temp = new(I) LocalVariable(
+    LocalVariable* temp = new(Z) LocalVariable(
         function_.token_pos(),
-        String::ZoneHandle(I, Symbols::New(":finally_ret_val")),
-        Type::ZoneHandle(I, Type::DynamicType()));
+        String::ZoneHandle(Z, Symbols::New(":finally_ret_val")),
+        Type::ZoneHandle(Z, Type::DynamicType()));
     ASSERT(temp != NULL);
     temp->set_is_final();
     set_finally_return_temp_var(temp);
@@ -180,7 +181,7 @@
       return;
     }
   }
-  deferred_prefixes_->Add(&LibraryPrefix::ZoneHandle(I, prefix.raw()));
+  deferred_prefixes_->Add(&LibraryPrefix::ZoneHandle(Z, prefix.raw()));
 }
 
 
@@ -308,9 +309,9 @@
 
 // For parsing a compilation unit.
 Parser::Parser(const Script& script, const Library& library, intptr_t token_pos)
-    : isolate_(Isolate::Current()),
-      script_(Script::Handle(isolate_, script.raw())),
-      tokens_iterator_(TokenStream::Handle(isolate_, script.tokens()),
+    : thread_(Thread::Current()),
+      script_(Script::Handle(zone(), script.raw())),
+      tokens_iterator_(TokenStream::Handle(zone(), script.tokens()),
                        token_pos),
       token_kind_(Token::kILLEGAL),
       current_block_(NULL),
@@ -319,10 +320,10 @@
       current_member_(NULL),
       allow_function_literals_(true),
       parsed_function_(NULL),
-      innermost_function_(Function::Handle(isolate_)),
-      literal_token_(LiteralToken::Handle(isolate_)),
-      current_class_(Class::Handle(isolate_)),
-      library_(Library::Handle(isolate_, library.raw())),
+      innermost_function_(Function::Handle(zone())),
+      literal_token_(LiteralToken::Handle(zone())),
+      current_class_(Class::Handle(zone())),
+      library_(Library::Handle(zone(), library.raw())),
       try_blocks_list_(NULL),
       last_used_try_index_(0),
       unregister_pending_function_(false),
@@ -336,9 +337,9 @@
 Parser::Parser(const Script& script,
                ParsedFunction* parsed_function,
                intptr_t token_position)
-    : isolate_(Isolate::Current()),
-      script_(Script::Handle(isolate_, script.raw())),
-      tokens_iterator_(TokenStream::Handle(isolate_, script.tokens()),
+    : thread_(Thread::Current()),
+      script_(Script::Handle(zone(), script.raw())),
+      tokens_iterator_(TokenStream::Handle(zone(), script.tokens()),
                        token_position),
       token_kind_(Token::kILLEGAL),
       current_block_(NULL),
@@ -347,13 +348,13 @@
       current_member_(NULL),
       allow_function_literals_(true),
       parsed_function_(parsed_function),
-      innermost_function_(Function::Handle(isolate_,
+      innermost_function_(Function::Handle(zone(),
                                            parsed_function->function().raw())),
-      literal_token_(LiteralToken::Handle(isolate_)),
-      current_class_(Class::Handle(isolate_,
+      literal_token_(LiteralToken::Handle(zone())),
+      current_class_(Class::Handle(zone(),
                                    parsed_function->function().Owner())),
-      library_(Library::Handle(isolate_, Class::Handle(
-          isolate_,
+      library_(Library::Handle(zone(), Class::Handle(
+          zone(),
           parsed_function->function().origin()).library())),
       try_blocks_list_(NULL),
       last_used_try_index_(0),
@@ -392,7 +393,7 @@
 void Parser::SetScript(const Script& script, intptr_t token_pos) {
   script_ = script.raw();
   tokens_iterator_.SetStream(
-      TokenStream::Handle(I, script.tokens()), token_pos);
+      TokenStream::Handle(Z, script.tokens()), token_pos);
   token_kind_ = Token::kILLEGAL;
 }
 
@@ -463,7 +464,7 @@
 
 String* Parser::CurrentLiteral() const {
   String& result =
-      String::ZoneHandle(I, tokens_iterator_.CurrentLiteral());
+      String::ZoneHandle(Z, tokens_iterator_.CurrentLiteral());
   return &result;
 }
 
@@ -480,7 +481,7 @@
   ASSERT(literal_token_.kind() == Token::kINTEGER);
   RawInteger* ri = Integer::RawCast(literal_token_.value());
   if (FLAG_throw_on_javascript_int_overflow) {
-    const Integer& i = Integer::Handle(I, ri);
+    const Integer& i = Integer::Handle(Z, ri);
     if (i.CheckJavascriptIntegerOverflow()) {
       ReportError(TokenPos(),
                   "Integer literal does not fit in a Javascript integer: %s.",
@@ -789,15 +790,17 @@
 
 RawObject* Parser::ParseFunctionParameters(const Function& func) {
   ASSERT(!func.IsNull());
-  Isolate* isolate = Isolate::Current();
-  StackZone zone(isolate);
+  Thread* thread = Thread::Current();
+  Isolate* isolate = thread->isolate();
+  StackZone stack_zone(isolate);
+  Zone* zone = stack_zone.GetZone();
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
-    const Script& script = Script::Handle(isolate, func.script());
-    const Class& owner = Class::Handle(isolate, func.Owner());
+    const Script& script = Script::Handle(zone, func.script());
+    const Class& owner = Class::Handle(zone, func.Owner());
     ASSERT(!owner.IsNull());
     ParsedFunction* parsed_function = new ParsedFunction(
-        isolate, Function::ZoneHandle(isolate, func.raw()));
+        thread, Function::ZoneHandle(zone, func.raw()));
     Parser parser(script, parsed_function, func.token_pos());
     parser.SkipFunctionPreamble();
     ParamList params;
@@ -834,16 +837,17 @@
 
 
 void Parser::ParseFunction(ParsedFunction* parsed_function) {
-  Isolate* isolate = Isolate::Current();
+  Isolate* isolate = parsed_function->isolate();
+  Zone* zone = parsed_function->zone();
   TimerScope timer(FLAG_compiler_stats, &CompilerStats::parser_timer);
   CompilerStats::num_functions_compiled++;
   ASSERT(isolate->long_jump_base()->IsSafeToJump());
   ASSERT(parsed_function != NULL);
   const Function& func = parsed_function->function();
-  const Script& script = Script::Handle(isolate, func.script());
+  const Script& script = Script::Handle(zone, func.script());
   Parser parser(script, parsed_function, func.token_pos());
   SequenceNode* node_sequence = NULL;
-  Array& default_parameter_values = Array::ZoneHandle(isolate, Array::null());
+  Array& default_parameter_values = Array::ZoneHandle(zone, Array::null());
   switch (func.kind()) {
     case RawFunction::kRegularFunction:
     case RawFunction::kClosureFunction:
@@ -925,16 +929,18 @@
 
 
 RawObject* Parser::ParseMetadata(const Class& cls, intptr_t token_pos) {
-  Isolate* isolate = Isolate::Current();
-  StackZone zone(isolate);
+  Thread* thread = Thread::Current();
+  Isolate* isolate = thread->isolate();
+  StackZone stack_zone(isolate);
+  Zone* zone = stack_zone.GetZone();
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
-    const Script& script = Script::Handle(isolate, cls.script());
+    const Script& script = Script::Handle(zone, cls.script());
     // Parsing metadata can involve following paths in the parser that are
     // normally used for expressions and assume current_function is non-null,
     // so we create a fake function to use as the current_function rather than
     // scattering special cases throughout the parser.
-    const Function& fake_function = Function::ZoneHandle(Function::New(
+    const Function& fake_function = Function::ZoneHandle(zone, Function::New(
         Symbols::At(),
         RawFunction::kRegularFunction,
         true,  // is_static
@@ -946,7 +952,7 @@
         token_pos));
     fake_function.set_is_debuggable(false);
     ParsedFunction* parsed_function =
-        new ParsedFunction(isolate, fake_function);
+        new ParsedFunction(thread, fake_function);
     Parser parser(script, parsed_function, token_pos);
     parser.set_current_class(cls);
 
@@ -953,7 +959,7 @@
     RawObject* metadata = parser.EvaluateMetadata();
     return metadata;
   } else {
-    Error& error = Error::Handle(isolate);
+    Error& error = Error::Handle(zone);
     error = isolate->object_store()->sticky_error();
     isolate->object_store()->clear_sticky_error();
     return error.raw();
@@ -966,7 +972,7 @@
 RawArray* Parser::EvaluateMetadata() {
   CheckToken(Token::kAT, "Metadata character '@' expected");
   GrowableObjectArray& meta_values =
-      GrowableObjectArray::Handle(I, GrowableObjectArray::New());
+      GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
   while (CurrentToken() == Token::kAT) {
     ConsumeToken();
     intptr_t expr_pos = TokenPos();
@@ -974,7 +980,7 @@
       ExpectIdentifier("identifier expected");
     }
     // Reject expressions with deferred library prefix eagerly.
-    Object& obj = Object::Handle(I,
+    Object& obj = Object::Handle(Z,
                                  library_.LookupLocalObject(*CurrentLiteral()));
     if (!obj.IsNull() && obj.IsLibraryPrefix()) {
       if (LibraryPrefix::Cast(obj).is_deferred_load()) {
@@ -992,7 +998,7 @@
     } else {
       // Can be x, C.x, or L.C.x.
       expr = ParsePrimary();  // Consumes x, C or L.C.
-      Class& cls = Class::Handle(I);
+      Class& cls = Class::Handle(Z);
       if (expr->IsPrimaryNode()) {
         PrimaryNode* primary_node = expr->AsPrimaryNode();
         if (primary_node->primary().IsClass()) {
@@ -1015,7 +1021,7 @@
         ConsumeToken();
         const intptr_t ident_pos = TokenPos();
         String* ident = ExpectIdentifier("identifier expected");
-        const Field& field = Field::Handle(I, cls.LookupStaticField(*ident));
+        const Field& field = Field::Handle(Z, cls.LookupStaticField(*ident));
         if (field.IsNull()) {
           ReportError(ident_pos,
                       "Class '%s' has no field '%s'",
@@ -1048,7 +1054,7 @@
   OpenFunctionBlock(parsed_function()->function());
   intptr_t expr_pos = TokenPos();
   AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
-  ReturnNode* ret = new(I) ReturnNode(expr_pos, expr);
+  ReturnNode* ret = new(Z) ReturnNode(expr_pos, expr);
   current_block_->statements->Add(ret);
   return CloseBlock();
 }
@@ -1057,17 +1063,19 @@
 ParsedFunction* Parser::ParseStaticFieldInitializer(const Field& field) {
   ASSERT(field.is_static());
   ASSERT(field.value() == Object::transition_sentinel().raw());
-  Isolate* isolate = Isolate::Current();
+  Thread* thread = Thread::Current();
+  // TODO(koda): Should there be a StackZone here?
+  Zone* zone = thread->zone();
 
-  const Class& script_cls = Class::Handle(isolate, field.origin());
-  const Script& script = Script::Handle(isolate, script_cls.script());
+  const Class& script_cls = Class::Handle(zone, field.origin());
+  const Script& script = Script::Handle(zone, script_cls.script());
 
-  const String& field_name = String::Handle(isolate, field.name());
-  String& init_name = String::Handle(isolate,
+  const String& field_name = String::Handle(zone, field.name());
+  String& init_name = String::Handle(zone,
       String::Concat(Symbols::InitPrefix(), field_name));
   init_name = Symbols::New(init_name);
 
-  const Function& initializer = Function::ZoneHandle(isolate,
+  const Function& initializer = Function::ZoneHandle(zone,
       Function::New(init_name,
                     RawFunction::kRegularFunction,
                     true,   // static
@@ -1077,7 +1085,7 @@
                     false,  // !native
                     Class::Handle(field.owner()),
                     field.token_pos()));
-  initializer.set_result_type(AbstractType::Handle(isolate, field.type()));
+  initializer.set_result_type(AbstractType::Handle(zone, field.type()));
   // Static initializer functions are hidden from the user.
   // Since they are only executed once, we avoid optimizing
   // and inlining them. After the field is initialized, the
@@ -1087,7 +1095,7 @@
   initializer.SetIsOptimizable(false);
   initializer.set_is_inlinable(false);
 
-  ParsedFunction* parsed_function = new ParsedFunction(isolate, initializer);
+  ParsedFunction* parsed_function = new ParsedFunction(thread, initializer);
   Parser parser(script, parsed_function, field.token_pos());
 
   SequenceNode* body = parser.ParseStaticInitializer();
@@ -1110,8 +1118,9 @@
 
 RawObject* Parser::ParseFunctionFromSource(const Class& owning_class,
                                            const String& source) {
-  Isolate* isolate = Isolate::Current();
-  StackZone zone(isolate);
+  Thread* thread = Thread::Current();
+  Isolate* isolate = thread->isolate();
+  StackZone stack_zone(isolate);
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     const String& uri = String::Handle(Symbols::New("dynamically-added"));
@@ -1132,7 +1141,7 @@
     const Function& func =
         Function::ZoneHandle(Function::RawCast(members.functions().At(0)));
     func.set_eval_script(script);
-    ParsedFunction* parsed_function = new ParsedFunction(isolate, func);
+    ParsedFunction* parsed_function = new ParsedFunction(thread, func);
     Parser::ParseFunction(parsed_function);
     return func.raw();
   } else {
@@ -1150,7 +1159,7 @@
   ParamList params;
   ASSERT(func.num_fixed_parameters() == 0);  // static.
   ASSERT(!func.HasOptionalParameters());
-  ASSERT(AbstractType::Handle(I, func.result_type()).IsResolved());
+  ASSERT(AbstractType::Handle(Z, func.result_type()).IsResolved());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
@@ -1158,9 +1167,9 @@
 
   intptr_t ident_pos = TokenPos();
   const String& field_name = *ExpectIdentifier("field name expected");
-  const Class& field_class = Class::Handle(I, func.Owner());
+  const Class& field_class = Class::Handle(Z, func.Owner());
   const Field& field =
-      Field::ZoneHandle(I, field_class.LookupStaticField(field_name));
+      Field::ZoneHandle(Z, field_class.LookupStaticField(field_name));
 
   // Static final fields must have an initializer.
   ExpectToken(Token::kASSIGN);
@@ -1185,7 +1194,7 @@
     // The runtime function will detect circular dependencies in expressions
     // and handle errors while evaluating the expression.
     current_block_->statements->Add(
-        new (I) InitStaticFieldNode(ident_pos, field));
+        new (Z) InitStaticFieldNode(ident_pos, field));
     ReturnNode* return_node =
         new ReturnNode(ident_pos,
                        new LoadStaticFieldNode(ident_pos, field));
@@ -1208,7 +1217,7 @@
   params.AddReceiver(ReceiverType(current_class()), ident_pos);
   ASSERT(func.num_fixed_parameters() == 1);  // receiver.
   ASSERT(!func.HasOptionalParameters());
-  ASSERT(AbstractType::Handle(I, func.result_type()).IsResolved());
+  ASSERT(AbstractType::Handle(Z, func.result_type()).IsResolved());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
@@ -1217,12 +1226,12 @@
   // Receiver is local 0.
   LocalVariable* receiver = current_block_->scope->VariableAt(0);
   LoadLocalNode* load_receiver = new LoadLocalNode(ident_pos, receiver);
-  String& field_name = String::Handle(I, func.name());
+  String& field_name = String::Handle(Z, func.name());
   field_name = Field::NameFromGetter(field_name);
 
-  const Class& field_class = Class::Handle(I, func.Owner());
+  const Class& field_class = Class::Handle(Z, func.Owner());
   const Field& field =
-      Field::ZoneHandle(I, field_class.LookupInstanceField(field_name));
+      Field::ZoneHandle(Z, field_class.LookupInstanceField(field_name));
   ASSERT(!field.IsNull());
 
   LoadInstanceFieldNode* load_field =
@@ -1244,10 +1253,10 @@
   // 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(I, func.Owner());
+  const Class& field_class = Class::ZoneHandle(Z, func.Owner());
   const Field& field =
-      Field::ZoneHandle(I, field_class.LookupInstanceField(field_name));
-  const AbstractType& field_type = AbstractType::ZoneHandle(I, field.type());
+      Field::ZoneHandle(Z, field_class.LookupInstanceField(field_name));
+  const AbstractType& field_type = AbstractType::ZoneHandle(Z, field.type());
 
   ParamList params;
   ASSERT(current_class().raw() == func.Owner());
@@ -1257,7 +1266,7 @@
                            &field_type);
   ASSERT(func.num_fixed_parameters() == 2);  // receiver, value.
   ASSERT(!func.HasOptionalParameters());
-  ASSERT(AbstractType::Handle(I, func.result_type()).IsVoidType());
+  ASSERT(AbstractType::Handle(Z, func.result_type()).IsVoidType());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
@@ -1298,7 +1307,7 @@
 
   ClosureNode* closure = new ClosureNode(
       ident_pos,
-      Function::ZoneHandle(I, func.extracted_method_closure()),
+      Function::ZoneHandle(Z, func.extracted_method_closure()),
       load_receiver,
       NULL);
 
@@ -1321,8 +1330,8 @@
     ParamDesc p;
     char name[64];
     OS::SNPrint(name, 64, ":p%" Pd, i);
-    p.name = &String::ZoneHandle(I, Symbols::New(name));
-    p.type = &Type::ZoneHandle(I, Type::DynamicType());
+    p.name = &String::ZoneHandle(Z, Symbols::New(name));
+    p.type = &Type::ZoneHandle(Z, Type::DynamicType());
     params.parameters->Add(p);
     params.num_fixed_parameters++;
   }
@@ -1332,8 +1341,8 @@
   for (; i < desc.Count(); ++i) {
     ParamDesc p;
     intptr_t index = i - desc.PositionalCount();
-    p.name = &String::ZoneHandle(I, desc.NameAt(index));
-    p.type = &Type::ZoneHandle(I, Type::DynamicType());
+    p.name = &String::ZoneHandle(Z, desc.NameAt(index));
+    p.type = &Type::ZoneHandle(Z, Type::DynamicType());
     p.default_value = &Object::null_object();
     params.parameters->Add(p);
     params.num_optional_parameters++;
@@ -1357,7 +1366,7 @@
   ASSERT(func.token_pos() == 0);
   ASSERT(current_class().raw() == func.Owner());
 
-  ArgumentsDescriptor desc(Array::Handle(I, func.saved_args_desc()));
+  ArgumentsDescriptor desc(Array::Handle(Z, func.saved_args_desc()));
   ASSERT(desc.Count() > 0);
 
   // Set up scope for this function.
@@ -1372,27 +1381,27 @@
 
   if (desc.NamedCount() > 0) {
     const Array& arg_names =
-        Array::ZoneHandle(I, Array::New(desc.NamedCount()));
+        Array::ZoneHandle(Z, Array::New(desc.NamedCount()));
     for (intptr_t i = 0; i < arg_names.Length(); ++i) {
-      arg_names.SetAt(i, String::Handle(I, desc.NameAt(i)));
+      arg_names.SetAt(i, String::Handle(Z, desc.NameAt(i)));
     }
     func_args->set_names(arg_names);
   }
 
-  const String& func_name = String::ZoneHandle(I, func.name());
+  const String& func_name = String::ZoneHandle(Z, func.name());
   ArgumentListNode* arguments = BuildNoSuchMethodArguments(
       token_pos, func_name, *func_args, NULL, false);
   const intptr_t kNumArguments = 2;  // Receiver, InvocationMirror.
   ArgumentsDescriptor args_desc(
-      Array::Handle(I, ArgumentsDescriptor::New(kNumArguments)));
-  Function& no_such_method = Function::ZoneHandle(I,
-      Resolver::ResolveDynamicForReceiverClass(Class::Handle(I, func.Owner()),
+      Array::Handle(Z, ArgumentsDescriptor::New(kNumArguments)));
+  Function& no_such_method = Function::ZoneHandle(Z,
+      Resolver::ResolveDynamicForReceiverClass(Class::Handle(Z, func.Owner()),
                                                Symbols::NoSuchMethod(),
                                                args_desc));
   if (no_such_method.IsNull()) {
     // If noSuchMethod(i) is not found, call Object:noSuchMethod.
     no_such_method ^= Resolver::ResolveDynamicForReceiverClass(
-        Class::Handle(I, I->object_store()->object_class()),
+        Class::Handle(Z, I->object_store()->object_class()),
         Symbols::NoSuchMethod(),
         args_desc);
   }
@@ -1414,7 +1423,7 @@
   ASSERT(func.token_pos() == 0);
   ASSERT(current_class().raw() == func.Owner());
 
-  const Array& args_desc = Array::Handle(I, func.saved_args_desc());
+  const Array& args_desc = Array::Handle(Z, func.saved_args_desc());
   ArgumentsDescriptor desc(args_desc);
   ASSERT(desc.Count() > 0);
 
@@ -1426,16 +1435,16 @@
   ArgumentListNode* no_args = new ArgumentListNode(token_pos);
   LoadLocalNode* receiver = new LoadLocalNode(token_pos, scope->VariableAt(0));
 
-  const String& name = String::Handle(I, func.name());
-  const String& getter_name = String::ZoneHandle(I,
-      Symbols::New(String::Handle(I, Field::GetterName(name))));
-  InstanceCallNode* getter_call = new(I) InstanceCallNode(
+  const String& name = String::Handle(Z, func.name());
+  const String& getter_name = String::ZoneHandle(Z,
+      Symbols::New(String::Handle(Z, Field::GetterName(name))));
+  InstanceCallNode* getter_call = new(Z) InstanceCallNode(
       token_pos, receiver, getter_name, no_args);
 
   // Pass arguments 1..n to the closure call.
-  ArgumentListNode* args = new(I) ArgumentListNode(token_pos);
+  ArgumentListNode* args = new(Z) ArgumentListNode(token_pos);
   const Array& names = Array::Handle(
-      I, Array::New(desc.NamedCount(), Heap::kOld));
+      Z, Array::New(desc.NamedCount(), Heap::kOld));
   // Positional parameters.
   intptr_t i = 1;
   for (; i < desc.PositionalCount(); ++i) {
@@ -1443,13 +1452,13 @@
   }
   // Named parameters.
   for (; i < desc.Count(); i++) {
-    args->Add(new(I) LoadLocalNode(token_pos, scope->VariableAt(i)));
+    args->Add(new(Z) LoadLocalNode(token_pos, scope->VariableAt(i)));
     intptr_t index = i - desc.PositionalCount();
-    names.SetAt(index, String::Handle(I, desc.NameAt(index)));
+    names.SetAt(index, String::Handle(Z, desc.NameAt(index)));
   }
   args->set_names(names);
 
-  const Class& owner = Class::Handle(I, func.Owner());
+  const Class& owner = Class::Handle(Z, func.Owner());
   ASSERT(!owner.IsNull());
   AstNode* result = NULL;
   if (owner.IsSignatureClass() && name.Equals(Symbols::Call())) {
@@ -1529,7 +1538,7 @@
   bool this_seen = false;
 
   if (evaluate_metadata && (CurrentToken() == Token::kAT)) {
-    parameter.metadata = &Array::ZoneHandle(I, EvaluateMetadata());
+    parameter.metadata = &Array::ZoneHandle(Z, EvaluateMetadata());
   } else {
     SkipMetadata();
   }
@@ -1543,7 +1552,7 @@
     // 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(I, Type::DynamicType());
+    parameter.type = &Type::ZoneHandle(Z, Type::DynamicType());
   }
   if (CurrentToken() == Token::kTHIS) {
     ConsumeToken();
@@ -1556,7 +1565,7 @@
     // 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(I, Type::VoidType());
+    parameter.type = &Type::ZoneHandle(Z, Type::VoidType());
   }
   if (parameter.type == NULL) {
     // At this point, we must see an identifier for the type or the
@@ -1577,13 +1586,13 @@
       // 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(I,
+      parameter.type = &AbstractType::ZoneHandle(Z,
           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(I, Type::DynamicType());
+      parameter.type = &Type::ZoneHandle(Z, Type::DynamicType());
     }
   }
   if (!this_seen && (CurrentToken() == Token::kTHIS)) {
@@ -1623,7 +1632,7 @@
     if (!var_seen && !parameter.is_final) {
       // The parsed parameter type is actually the function result type.
       const AbstractType& result_type =
-          AbstractType::Handle(I, parameter.type->raw());
+          AbstractType::Handle(Z, parameter.type->raw());
 
       // Finish parsing the function type parameter.
       ParamList func_params;
@@ -1632,13 +1641,13 @@
       func_params.AddFinalParameter(
           TokenPos(),
           &Symbols::ClosureParameter(),
-          &Type::ZoneHandle(I, Type::DynamicType()));
+          &Type::ZoneHandle(Z, 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(I,
+      const Function& signature_function = Function::Handle(Z,
           Function::New(*parameter.name,
                         RawFunction::kSignatureFunction,
                         /* is_static = */ false,
@@ -1651,12 +1660,12 @@
       signature_function.set_result_type(result_type);
       signature_function.set_is_debuggable(false);
       AddFormalParamsToFunction(&func_params, signature_function);
-      const String& signature = String::Handle(I,
+      const String& signature = String::Handle(Z,
                                                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(I,
+      Class& signature_class = Class::ZoneHandle(Z,
           library_.LookupLocalClass(signature));
       if (signature_class.IsNull()) {
         signature_class = Class::NewSignatureClass(signature,
@@ -1674,7 +1683,7 @@
       }
       ASSERT(signature_function.signature_class() == signature_class.raw());
       Type& signature_type =
-          Type::ZoneHandle(I, signature_class.SignatureType());
+          Type::ZoneHandle(Z, signature_class.SignatureType());
       if (!is_top_level_ && !signature_type.IsFinalized()) {
         signature_type ^= ClassFinalizer::FinalizeType(
             signature_class, signature_type, ClassFinalizer::kCanonicalize);
@@ -1814,12 +1823,12 @@
                                       ArgumentListNode* arguments,
                                       bool resolve_getter,
                                       bool* is_no_such_method) {
-  const Class& super_class = Class::Handle(I, current_class().SuperClass());
+  const Class& super_class = Class::Handle(Z, current_class().SuperClass());
   if (super_class.IsNull()) {
     ReportError(token_pos, "class '%s' does not have a superclass",
-                String::Handle(I, current_class().Name()).ToCString());
+                String::Handle(Z, current_class().Name()).ToCString());
   }
-  Function& super_func = Function::Handle(I,
+  Function& super_func = Function::Handle(Z,
       Resolver::ResolveDynamicAnyArgs(super_class, name));
   if (!super_func.IsNull() &&
       !super_func.AreValidArguments(arguments->length(),
@@ -1827,7 +1836,7 @@
                                     NULL)) {
     super_func = Function::null();
   } else if (super_func.IsNull() && resolve_getter) {
-    const String& getter_name = String::ZoneHandle(I, Field::GetterName(name));
+    const String& getter_name = String::ZoneHandle(Z, Field::GetterName(name));
     super_func = Resolver::ResolveDynamicAnyArgs(super_class, getter_name);
     ASSERT(super_func.IsNull() ||
            (super_func.kind() != RawFunction::kImplicitStaticFinalGetter));
@@ -1926,7 +1935,7 @@
 
   const bool kResolveGetter = true;
   bool is_no_such_method = false;
-  const Function& super_function = Function::ZoneHandle(I,
+  const Function& super_function = Function::ZoneHandle(Z,
       GetSuperFunction(supercall_pos,
                        function_name,
                        arguments,
@@ -1935,7 +1944,7 @@
   if (super_function.IsGetterFunction() ||
       super_function.IsImplicitGetterFunction()) {
     const Class& super_class =
-        Class::ZoneHandle(I, current_class().SuperClass());
+        Class::ZoneHandle(Z, current_class().SuperClass());
     AstNode* closure = new StaticGetterNode(supercall_pos,
                                             LoadReceiver(supercall_pos),
                                             /* is_super_getter */ true,
@@ -1970,13 +1979,13 @@
       (op == Token::kBIT_NOT)) {
     // Resolve the operator function in the superclass.
     const String& operator_function_name =
-        String::ZoneHandle(I, Symbols::New(Token::Str(op)));
+        String::ZoneHandle(Z, 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(I,
+    const Function& super_operator = Function::ZoneHandle(Z,
         GetSuperFunction(super_pos,
                          operator_function_name,
                          op_arguments,
@@ -2005,7 +2014,7 @@
     ExpectToken(Token::kRBRACK);
     AstNode* receiver = LoadReceiver(operator_pos);
     const Class& super_class =
-        Class::ZoneHandle(I, current_class().SuperClass());
+        Class::ZoneHandle(Z, current_class().SuperClass());
     ASSERT(!super_class.IsNull());
     super_op =
         new LoadIndexedNode(operator_pos, receiver, index_expr, super_class);
@@ -2031,10 +2040,10 @@
 
     // Resolve the operator function in the superclass.
     const String& operator_function_name =
-        String::ZoneHandle(I, Symbols::New(Token::Str(op)));
+        String::ZoneHandle(Z, Symbols::New(Token::Str(op)));
     const bool kResolveGetter = false;
     bool is_no_such_method = false;
-    const Function& super_operator = Function::ZoneHandle(I,
+    const Function& super_operator = Function::ZoneHandle(Z,
         GetSuperFunction(operator_pos,
                          operator_function_name,
                          op_arguments,
@@ -2057,13 +2066,13 @@
                                                intptr_t token_pos,
                                                AstNode* receiver) {
   Function& implicit_closure_function =
-      Function::ZoneHandle(I, func.ImplicitClosureFunction());
+      Function::ZoneHandle(Z, 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(I,
+      const Class& signature_class = Class::Handle(Z,
           implicit_closure_function.signature_class());
       if (signature_class.NumTypeParameters() > 0) {
         CaptureInstantiator();
@@ -2077,21 +2086,21 @@
 AstNode* Parser::ParseSuperFieldAccess(const String& field_name,
                                        intptr_t field_pos) {
   TRACE_PARSER("ParseSuperFieldAccess");
-  const Class& super_class = Class::ZoneHandle(I, current_class().SuperClass());
+  const Class& super_class = Class::ZoneHandle(Z, current_class().SuperClass());
   if (super_class.IsNull()) {
     ReportError("class '%s' does not have a superclass",
-                String::Handle(I, current_class().Name()).ToCString());
+                String::Handle(Z, current_class().Name()).ToCString());
   }
   AstNode* implicit_argument = LoadReceiver(field_pos);
 
   const String& getter_name =
-      String::ZoneHandle(I, Field::GetterName(field_name));
-  const Function& super_getter = Function::ZoneHandle(I,
+      String::ZoneHandle(Z, Field::GetterName(field_name));
+  const Function& super_getter = Function::ZoneHandle(Z,
       Resolver::ResolveDynamicAnyArgs(super_class, getter_name));
   if (super_getter.IsNull()) {
     const String& setter_name =
-        String::ZoneHandle(I, Field::SetterName(field_name));
-    const Function& super_setter = Function::ZoneHandle(I,
+        String::ZoneHandle(Z, Field::SetterName(field_name));
+    const Function& super_setter = Function::ZoneHandle(Z,
         Resolver::ResolveDynamicAnyArgs(super_class, setter_name));
     if (super_setter.IsNull()) {
       // Check if this is an access to an implicit closure using 'super'.
@@ -2098,7 +2107,7 @@
       // 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(I,
+      const Function& super_function = Function::ZoneHandle(Z,
           Resolver::ResolveDynamicAnyArgs(super_class, field_name));
       if (!super_function.IsNull()) {
         // In case CreateAssignmentNode is called later on this
@@ -2120,16 +2129,16 @@
                                           intptr_t supercall_pos,
                                           LocalVariable* receiver,
                                           ArgumentListNode* forwarding_args) {
-  const Class& super_class = Class::Handle(I, cls.SuperClass());
+  const Class& super_class = Class::Handle(Z, cls.SuperClass());
   // Omit the implicit super() if there is no super class (i.e.
   // we're not compiling class Object), or if the super class is an
   // artificially generated "wrapper class" that has no constructor.
   if (super_class.IsNull() ||
       (super_class.num_native_fields() > 0 &&
-       Class::Handle(I, super_class.SuperClass()).IsObjectClass())) {
+       Class::Handle(Z, super_class.SuperClass()).IsObjectClass())) {
     return;
   }
-  String& super_ctor_name = String::Handle(I, super_class.Name());
+  String& super_ctor_name = String::Handle(Z, super_class.Name());
   super_ctor_name = String::Concat(super_ctor_name, Symbols::Dot());
 
   ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
@@ -2139,7 +2148,7 @@
   // Implicit construction phase parameter is second argument.
   AstNode* phase_parameter =
       new LiteralNode(supercall_pos,
-                      Smi::ZoneHandle(I, Smi::New(Function::kCtorPhaseAll)));
+                      Smi::ZoneHandle(Z, Smi::New(Function::kCtorPhaseAll)));
   arguments->Add(phase_parameter);
 
   // If this is a super call in a forwarding constructor, add the user-
@@ -2149,8 +2158,8 @@
     for (int i = 0; i < forwarding_args->length(); i++) {
       arguments->Add(forwarding_args->NodeAt(i));
     }
-    String& ctor_name = String::Handle(I, current_function().name());
-    String& class_name = String::Handle(I, cls.Name());
+    String& ctor_name = String::Handle(Z, current_function().name());
+    String& class_name = String::Handle(Z, 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.
@@ -2160,24 +2169,24 @@
   }
 
   // Resolve super constructor function and check arguments.
-  const Function& super_ctor = Function::ZoneHandle(I,
+  const Function& super_ctor = Function::ZoneHandle(Z,
       super_class.LookupConstructor(super_ctor_name));
   if (super_ctor.IsNull()) {
       ReportError(supercall_pos,
                   "unresolved implicit call to super constructor '%s()'",
-                  String::Handle(I, super_class.Name()).ToCString());
+                  String::Handle(Z, super_class.Name()).ToCString());
   }
   if (current_function().is_const() && !super_ctor.is_const()) {
     ReportError(supercall_pos, "implicit call to non-const super constructor");
   }
 
-  String& error_message = String::Handle(I);
+  String& error_message = String::Handle(Z);
   if (!super_ctor.AreValidArguments(arguments->length(),
                                     arguments->names(),
                                     &error_message)) {
     ReportError(supercall_pos,
                 "invalid arguments passed to super constructor '%s()': %s",
-                String::Handle(I, super_class.Name()).ToCString(),
+                String::Handle(Z, super_class.Name()).ToCString(),
                 error_message.ToCString());
   }
   current_block_->statements->Add(
@@ -2191,9 +2200,9 @@
   ASSERT(CurrentToken() == Token::kSUPER);
   const intptr_t supercall_pos = TokenPos();
   ConsumeToken();
-  const Class& super_class = Class::Handle(I, cls.SuperClass());
+  const Class& super_class = Class::Handle(Z, cls.SuperClass());
   ASSERT(!super_class.IsNull());
-  String& ctor_name = String::Handle(I, super_class.Name());
+  String& ctor_name = String::Handle(Z, super_class.Name());
   ctor_name = String::Concat(ctor_name, Symbols::Dot());
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
@@ -2212,7 +2221,7 @@
   // super initializer.
   AstNode* phase_parameter =
       new LiteralNode(supercall_pos,
-                      Smi::ZoneHandle(I, Smi::New(Function::kCtorPhaseAll)));
+                      Smi::ZoneHandle(Z, Smi::New(Function::kCtorPhaseAll)));
   arguments->Add(phase_parameter);
   // 'this' parameter must not be accessible to the other super call arguments.
   receiver->set_invisible(true);
@@ -2220,7 +2229,7 @@
   receiver->set_invisible(false);
 
   // Resolve the constructor.
-  const Function& super_ctor = Function::ZoneHandle(I,
+  const Function& super_ctor = Function::ZoneHandle(Z,
       super_class.LookupConstructor(ctor_name));
   if (super_ctor.IsNull()) {
     ReportError(supercall_pos,
@@ -2230,7 +2239,7 @@
   if (current_function().is_const() && !super_ctor.is_const()) {
     ReportError(supercall_pos, "super constructor must be const");
   }
-  String& error_message = String::Handle(I);
+  String& error_message = String::Handle(Z);
   if (!super_ctor.AreValidArguments(arguments->length(),
                                     arguments->names(),
                                     &error_message)) {
@@ -2268,18 +2277,18 @@
     ReportError(field_pos,
                 "initializer expression must be compile time constant.");
   }
-  Field& field = Field::ZoneHandle(I, cls.LookupInstanceField(field_name));
+  Field& field = Field::ZoneHandle(Z, cls.LookupInstanceField(field_name));
   if (field.IsNull()) {
     ReportError(field_pos, "unresolved reference to instance field '%s'",
                 field_name.ToCString());
   }
   EnsureExpressionTemp();
-  AstNode* instance = new(I) LoadLocalNode(field_pos, receiver);
+  AstNode* instance = new(Z) LoadLocalNode(field_pos, receiver);
   AstNode* initializer = CheckDuplicateFieldInit(field_pos,
       initialized_fields, instance, &field, init_expr);
   if (initializer == NULL) {
     initializer =
-        new(I) StoreInstanceFieldNode(field_pos, instance, field, init_expr);
+        new(Z) StoreInstanceFieldNode(field_pos, instance, field, init_expr);
   }
   return initializer;
 }
@@ -2286,8 +2295,8 @@
 
 
 void Parser::CheckFieldsInitialized(const Class& cls) {
-  const Array& fields = Array::Handle(I, cls.fields());
-  Field& field = Field::Handle(I);
+  const Array& fields = Array::Handle(Z, cls.fields());
+  Field& field = Field::Handle(Z);
   SequenceNode* initializers = current_block_->statements;
   for (int field_num = 0; field_num < fields.Length(); field_num++) {
     field ^= fields.At(field_num);
@@ -2310,7 +2319,7 @@
 
     if (found) continue;
 
-    field.RecordStore(Object::Handle(I));
+    field.RecordStore(Object::Handle(Z));
   }
 }
 
@@ -2320,14 +2329,14 @@
   // from a different class. We need to save and restore current
   // class, library, and token stream (script).
   ASSERT(current_class().raw() != field.origin());
-  const Class& saved_class = Class::Handle(I, current_class().raw());
-  const Library& saved_library = Library::Handle(I, library().raw());
-  const Script& saved_script = Script::Handle(I, script().raw());
+  const Class& saved_class = Class::Handle(Z, current_class().raw());
+  const Library& saved_library = Library::Handle(Z, library().raw());
+  const Script& saved_script = Script::Handle(Z, script().raw());
   const intptr_t saved_token_pos = TokenPos();
 
-  set_current_class(Class::Handle(I, field.origin()));
-  set_library(Library::Handle(I, current_class().library()));
-  SetScript(Script::Handle(I, current_class().script()),
+  set_current_class(Class::Handle(Z, field.origin()));
+  set_library(Library::Handle(Z, current_class().library()));
+  SetScript(Script::Handle(Z, current_class().script()),
             field.token_pos());
 
   ASSERT(IsIdentifier());
@@ -2356,13 +2365,13 @@
                  LocalVariable* receiver,
                  GrowableArray<Field*>* initialized_fields) {
   TRACE_PARSER("ParseInitializedInstanceFields");
-  const Array& fields = Array::Handle(I, cls.fields());
-  Field& f = Field::Handle(I);
+  const Array& fields = Array::Handle(Z, cls.fields());
+  Field& f = Field::Handle(Z);
   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(I);
+      Field& field = Field::ZoneHandle(Z);
       field ^= fields.At(i);
       if (field.is_final()) {
         // Final fields with initializer expression may not be initialized
@@ -2443,7 +2452,7 @@
       //     List argumentNames,
       //     List existingArgumentNames);
 
-      ArgumentListNode* nsm_args = new(I) ArgumentListNode(init_pos);
+      ArgumentListNode* nsm_args = new(Z) ArgumentListNode(init_pos);
       // Object receiver.
       nsm_args->Add(instance);
 
@@ -2450,32 +2459,32 @@
       // String memberName.
       String& setter_name = String::ZoneHandle(field->name());
       setter_name = Field::SetterSymbol(setter_name);
-      nsm_args->Add(new(I) LiteralNode(init_pos, setter_name));
+      nsm_args->Add(new(Z) LiteralNode(init_pos, setter_name));
 
       // Smi invocation_type.
       const int invocation_type =
           InvocationMirror::EncodeType(InvocationMirror::kDynamic,
                                        InvocationMirror::kSetter);
-      nsm_args->Add(new(I) LiteralNode(
-          init_pos, Smi::ZoneHandle(I, Smi::New(invocation_type))));
+      nsm_args->Add(new(Z) LiteralNode(
+          init_pos, Smi::ZoneHandle(Z, Smi::New(invocation_type))));
 
       // List arguments.
       GrowableArray<AstNode*> setter_args;
       setter_args.Add(init_value);
-      ArrayNode* setter_args_array = new(I) ArrayNode(
+      ArrayNode* setter_args_array = new(Z) ArrayNode(
           init_pos,
-          Type::ZoneHandle(I, Type::ArrayType()),
+          Type::ZoneHandle(Z, Type::ArrayType()),
           setter_args);
       nsm_args->Add(setter_args_array);
 
       // List argumentNames.
       // The missing implicit setter of the field has no argument names.
-      nsm_args->Add(new(I) LiteralNode(init_pos, Array::ZoneHandle(I)));
+      nsm_args->Add(new(Z) LiteralNode(init_pos, Array::ZoneHandle(Z)));
 
       // List existingArgumentNames.
       // There is no setter for the final field, thus there are
       // no existing names.
-      nsm_args->Add(new(I) LiteralNode(init_pos, Array::ZoneHandle(I)));
+      nsm_args->Add(new(Z) LiteralNode(init_pos, Array::ZoneHandle(Z)));
 
       AstNode* nsm_call =
           MakeStaticCall(Symbols::NoSuchMethodError(),
@@ -2482,7 +2491,7 @@
           Library::PrivateCoreLibName(Symbols::ThrowNew()),
           nsm_args);
 
-      LetNode* let = new(I) LetNode(init_pos);
+      LetNode* let = new(Z) LetNode(init_pos);
       let->AddNode(init_value);
       let->AddNode(nsm_call);
       result = let;
@@ -2498,7 +2507,7 @@
     if (initialized_field->raw() == field->raw()) {
       ReportError(init_pos,
                   "duplicate initializer for field %s",
-                  String::Handle(I, field->name()).ToCString());
+                  String::Handle(Z, field->name()).ToCString());
     }
   }
   initialized_fields->Add(field);
@@ -2543,7 +2552,7 @@
   ASSERT(CurrentToken() == Token::kTHIS);
   const intptr_t call_pos = TokenPos();
   ConsumeToken();
-  String& ctor_name = String::Handle(I, cls.Name());
+  String& ctor_name = String::Handle(Z, cls.Name());
 
   ctor_name = String::Concat(ctor_name, Symbols::Dot());
   if (CurrentToken() == Token::kPERIOD) {
@@ -2566,12 +2575,12 @@
   ParseActualParameters(arguments, kAllowConst);
   receiver->set_invisible(false);
   // Resolve the constructor.
-  const Function& redirect_ctor = Function::ZoneHandle(I,
+  const Function& redirect_ctor = Function::ZoneHandle(Z,
       cls.LookupConstructor(ctor_name));
   if (redirect_ctor.IsNull()) {
     ReportError(call_pos, "constructor '%s' not found", ctor_name.ToCString());
   }
-  String& error_message = String::Handle(I);
+  String& error_message = String::Handle(Z);
   if (!redirect_ctor.AreValidArguments(arguments->length(),
                                        arguments->names(),
                                        &error_message)) {
@@ -2598,7 +2607,7 @@
   LocalVariable* phase_parameter =
       new LocalVariable(Scanner::kNoSourcePos,
                         Symbols::PhaseParameter(),
-                        Type::ZoneHandle(I, Type::SmiType()));
+                        Type::ZoneHandle(Z, Type::SmiType()));
   current_block_->scope->InsertParameterAt(1, phase_parameter);
 
   // Parse expressions of instance fields that have an explicit
@@ -2628,7 +2637,7 @@
     // TODO(hausner): Remove this limitation if the language spec indeed
     // allows optional parameters.
     if (func.HasOptionalParameters()) {
-      const Class& super_class = Class::Handle(I, current_class().SuperClass());
+      const Class& super_class = Class::Handle(Z, current_class().SuperClass());
       ReportError(ctor_pos,
                   "cannot generate an implicit mixin application constructor "
                   "forwarding to a super class constructor with optional "
@@ -2636,7 +2645,7 @@
                   "to class '%s' that redirects to the constructor with "
                   "optional parameters and invoke it via super from a "
                   "constructor of the class extending the mixin application",
-                  String::Handle(I, super_class.Name()).ToCString());
+                  String::Handle(Z, super_class.Name()).ToCString());
     }
 
     // Prepare user-defined arguments to be forwarded to super call.
@@ -2645,8 +2654,8 @@
     for (int i = 2; i < func.NumParameters(); i++) {
       LocalVariable* param = new LocalVariable(
           Scanner::kNoSourcePos,
-          String::ZoneHandle(I, func.ParameterNameAt(i)),
-          Type::ZoneHandle(I, Type::DynamicType()));
+          String::ZoneHandle(Z, func.ParameterNameAt(i)),
+          Type::ZoneHandle(Z, Type::DynamicType()));
       current_block_->scope->InsertParameterAt(i, param);
       forwarding_args->Add(new LoadLocalNode(Scanner::kNoSourcePos, param));
     }
@@ -2667,12 +2676,12 @@
 
 void Parser::CheckRecursiveInvocation() {
   const GrowableObjectArray& pending_functions =
-      GrowableObjectArray::Handle(I,
+      GrowableObjectArray::Handle(Z,
           I->object_store()->pending_functions());
   for (int i = 0; i < pending_functions.Length(); i++) {
     if (pending_functions.At(i) == current_function().raw()) {
       const String& fname =
-          String::Handle(I, current_function().UserVisibleName());
+          String::Handle(Z, current_function().UserVisibleName());
       ReportError("circular dependency for function %s", fname.ToCString());
     }
   }
@@ -2691,7 +2700,7 @@
   ASSERT(!func.IsFactory());
   ASSERT(!func.is_static());
   ASSERT(!func.IsLocalFunction());
-  const Class& cls = Class::Handle(I, func.Owner());
+  const Class& cls = Class::Handle(Z, func.Owner());
   ASSERT(!cls.IsNull());
 
   CheckRecursiveInvocation();
@@ -2720,7 +2729,7 @@
   params.AddFinalParameter(
       TokenPos(),
       &Symbols::PhaseParameter(),
-      &Type::ZoneHandle(I, Type::SmiType()));
+      &Type::ZoneHandle(Z, Type::SmiType()));
 
   if (func.is_const()) {
     params.SetImplicitlyFinal();
@@ -2728,7 +2737,7 @@
   ParseFormalParameterList(allow_explicit_default_values, false, &params);
 
   SetupDefaultsForOptionalParams(&params, default_parameter_values);
-  ASSERT(AbstractType::Handle(I, func.result_type()).IsResolved());
+  ASSERT(AbstractType::Handle(Z, func.result_type()).IsResolved());
   ASSERT(func.NumParameters() == params.parameters->length());
 
   // Now populate function scope with the formal parameters.
@@ -2768,7 +2777,7 @@
       if (param.is_field_initializer) {
         const String& field_name = *param.name;
         Field& field =
-            Field::ZoneHandle(I, cls.LookupInstanceField(field_name));
+            Field::ZoneHandle(Z, cls.LookupInstanceField(field_name));
         if (field.IsNull()) {
           ReportError(param.name_pos,
                       "unresolved reference to instance field '%s'",
@@ -2782,7 +2791,7 @@
 
         if (!param.has_explicit_type) {
           const AbstractType& field_type =
-              AbstractType::ZoneHandle(I, field.type());
+              AbstractType::ZoneHandle(Z, field.type());
           param.type = &field_type;
           // Parameter type was already set to dynamic when parsing the class
           // declaration: fix it.
@@ -2805,7 +2814,7 @@
                                     &field,
                                     value);
         if (initializer == NULL) {
-          initializer = new(I) StoreInstanceFieldNode(
+          initializer = new(Z) StoreInstanceFieldNode(
               param.name_pos, instance, field, value);
         }
         current_block_->statements->Add(initializer);
@@ -2832,13 +2841,13 @@
     AstNode* phase_check = new BinaryOpNode(
         Scanner::kNoSourcePos, Token::kBIT_AND, phase_value,
         new LiteralNode(Scanner::kNoSourcePos,
-            Smi::ZoneHandle(I, Smi::New(Function::kCtorPhaseInit))));
+            Smi::ZoneHandle(Z, Smi::New(Function::kCtorPhaseInit))));
     AstNode* comparison =
         new ComparisonNode(Scanner::kNoSourcePos,
                            Token::kNE_STRICT,
                            phase_check,
                            new LiteralNode(TokenPos(),
-                                           Smi::ZoneHandle(I, Smi::New(0))));
+                                           Smi::ZoneHandle(Z, Smi::New(0))));
     AstNode* guarded_init_statements =
         new IfNode(Scanner::kNoSourcePos,
                    comparison,
@@ -2901,14 +2910,14 @@
     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(I, Smi::New(Function::kCtorPhaseInit))));
+        body_pos, Smi::ZoneHandle(Z, 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(I) LiteralNode(
-        body_pos, Smi::ZoneHandle(I, Smi::New(Function::kCtorPhaseBody)));
+    AstNode* phase_parameter = new(Z) LiteralNode(
+        body_pos, Smi::ZoneHandle(Z, 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++) {
@@ -2998,7 +3007,7 @@
                                 Array* default_parameter_values) {
   TRACE_PARSER("ParseFunc");
   Function& saved_innermost_function =
-      Function::Handle(I, innermost_function().raw());
+      Function::Handle(Z, innermost_function().raw());
   innermost_function_ = func.raw();
 
   // Save current try index. Try index starts at zero for each function.
@@ -3010,7 +3019,7 @@
   // temporaries are added.
   LocalVariable* saved_saved_try_ctx = parsed_function()->saved_try_ctx();
   const String& saved_async_saved_try_ctx_name =
-      String::Handle(I, parsed_function()->async_saved_try_ctx_name());
+      String::Handle(Z, parsed_function()->async_saved_try_ctx_name());
   parsed_function()->reset_saved_try_ctx_vars();
   LocalScope* saved_async_temp_scope = async_temp_scope_;
 
@@ -3033,7 +3042,7 @@
     params.AddFinalParameter(
         TokenPos(),
         &Symbols::ClosureParameter(),
-        &Type::ZoneHandle(I, Type::DynamicType()));
+        &Type::ZoneHandle(Z, Type::DynamicType()));
   } else if (!func.is_static()) {
     // Static functions do not have a receiver.
     ASSERT(current_class().raw() == func.Owner());
@@ -3044,7 +3053,7 @@
     params.AddFinalParameter(
         TokenPos(),
         &Symbols::TypeArgumentsParameter(),
-        &Type::ZoneHandle(I, Type::DynamicType()));
+        &Type::ZoneHandle(Z, Type::DynamicType()));
   }
   ASSERT((CurrentToken() == Token::kLPAREN) ||
          func.IsGetterFunction() ||
@@ -3060,7 +3069,7 @@
     // * A continuation error.
     //
     // If the error!=null we rethrow the error at the next await.
-    const Type& dynamic_type = Type::ZoneHandle(I, Type::DynamicType());
+    const Type& dynamic_type = Type::ZoneHandle(Z, Type::DynamicType());
     ParamDesc result_param;
     result_param.name = &Symbols::AsyncOperationParam();
     result_param.default_value = &Object::null_instance();
@@ -3075,7 +3084,7 @@
     params.has_optional_positional_parameters = true;
     SetupDefaultsForOptionalParams(&params, default_parameter_values);
     AddFormalParamsToScope(&params, current_block_->scope);
-    ASSERT(AbstractType::Handle(I, func.result_type()).IsResolved());
+    ASSERT(AbstractType::Handle(Z, func.result_type()).IsResolved());
     ASSERT(func.NumParameters() == params.parameters->length());
     if (!Function::Handle(func.parent_function()).IsGetterFunction()) {
       // Parse and discard any formal parameters. They are accessed as
@@ -3094,7 +3103,7 @@
       AddFormalParamsToFunction(&params, func);
     }
     SetupDefaultsForOptionalParams(&params, default_parameter_values);
-    ASSERT(AbstractType::Handle(I, func.result_type()).IsResolved());
+    ASSERT(AbstractType::Handle(Z, func.result_type()).IsResolved());
     ASSERT(func.NumParameters() == params.parameters->length());
 
     // Check whether the function has any field initializer formal parameters,
@@ -3130,7 +3139,7 @@
 
   OpenBlock();  // Open a nested scope for the outermost function block.
 
-  Function& async_closure = Function::ZoneHandle(I);
+  Function& async_closure = Function::ZoneHandle(Z);
   if (func.IsAsyncFunction() && !func.is_async_closure()) {
     // The code of an async function is synthesized. Disable debugging.
     func.set_is_debuggable(false);
@@ -3146,8 +3155,8 @@
   intptr_t end_token_pos = 0;
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
-    if (String::Handle(I, func.name()).Equals(Symbols::EqualOperator())) {
-      const Class& owner = Class::Handle(I, func.Owner());
+    if (String::Handle(Z, func.name()).Equals(Symbols::EqualOperator())) {
+      const Class& owner = Class::Handle(Z, func.Owner());
       if (!owner.IsObjectClass()) {
         AddEqualityNullCheck();
       }
@@ -3157,9 +3166,9 @@
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
-    if (String::Handle(I, func.name()).Equals(
+    if (String::Handle(Z, func.name()).Equals(
         Symbols::EqualOperator())) {
-      const Class& owner = Class::Handle(I, func.Owner());
+      const Class& owner = Class::Handle(Z, func.Owner());
       if (!owner.IsObjectClass()) {
         AddEqualityNullCheck();
       }
@@ -3170,9 +3179,9 @@
     current_block_->statements->Add(new ReturnNode(expr_pos, expr));
     end_token_pos = TokenPos();
   } else if (IsLiteral("native")) {
-    if (String::Handle(I, func.name()).Equals(
+    if (String::Handle(Z, func.name()).Equals(
         Symbols::EqualOperator())) {
-      const Class& owner = Class::Handle(I, func.Owner());
+      const Class& owner = Class::Handle(Z, func.Owner());
       if (!owner.IsObjectClass()) {
         AddEqualityNullCheck();
       }
@@ -3182,7 +3191,7 @@
     ExpectSemicolon();
   } else if (func.is_external()) {
     // Body of an external method contains a single throw.
-    const String& function_name = String::ZoneHandle(I, func.name());
+    const String& function_name = String::ZoneHandle(Z, func.name());
     current_block_->statements->Add(
         ThrowNoSuchMethodError(TokenPos(),
                                Class::Handle(func.Owner()),
@@ -3224,7 +3233,7 @@
       new LoadLocalNode(Scanner::kNoSourcePos,
                         current_block_->scope->parent()->VariableAt(1));
   LiteralNode* null_operand =
-      new LiteralNode(Scanner::kNoSourcePos, Instance::ZoneHandle(I));
+      new LiteralNode(Scanner::kNoSourcePos, Instance::ZoneHandle(Z));
   ComparisonNode* check_arg =
       new ComparisonNode(Scanner::kNoSourcePos,
                          Token::kEQ_STRICT,
@@ -3312,7 +3321,7 @@
   // in the library scope and return in the common case where ident is
   // not a library prefix.
   LibraryPrefix& prefix =
-      LibraryPrefix::Handle(I, library_.LookupLocalLibraryPrefix(ident));
+      LibraryPrefix::Handle(Z, library_.LookupLocalLibraryPrefix(ident));
   if (prefix.IsNull()) {
     return LibraryPrefix::null();
   }
@@ -3379,7 +3388,7 @@
     method->params.AddFinalParameter(
         formal_param_pos,
         &Symbols::TypeArgumentsParameter(),
-        &Type::ZoneHandle(I, Type::DynamicType()));
+        &Type::ZoneHandle(Z, Type::DynamicType()));
   }
   // Constructors have an implicit parameter for the construction phase.
   if (method->IsConstructor()) {
@@ -3386,7 +3395,7 @@
     method->params.AddFinalParameter(
         TokenPos(),
         &Symbols::PhaseParameter(),
-        &Type::ZoneHandle(I, Type::SmiType()));
+        &Type::ZoneHandle(Z, Type::SmiType()));
   }
   if (are_implicitly_final) {
     method->params.SetImplicitlyFinal();
@@ -3417,13 +3426,13 @@
     if (method->IsGetter()) {
       expected_num_parameters = (method->has_static) ? 0 : 1;
       method->dict_name = method->name;
-      method->name = &String::ZoneHandle(I, Field::GetterSymbol(*method->name));
+      method->name = &String::ZoneHandle(Z, Field::GetterSymbol(*method->name));
     } else {
       ASSERT(method->IsSetter());
       expected_num_parameters = (method->has_static) ? 1 : 2;
-      method->dict_name = &String::ZoneHandle(I,
+      method->dict_name = &String::ZoneHandle(Z,
           String::Concat(*method->name, Symbols::Equals()));
-      method->name = &String::ZoneHandle(I, Field::SetterSymbol(*method->name));
+      method->name = &String::ZoneHandle(Z, Field::SetterSymbol(*method->name));
     }
     if ((method->params.num_fixed_parameters != expected_num_parameters) ||
         (method->params.num_optional_parameters != 0)) {
@@ -3433,8 +3442,8 @@
   }
 
   // Parse redirecting factory constructor.
-  Type& redirection_type = Type::Handle(I);
-  String& redirection_identifier = String::Handle(I);
+  Type& redirection_type = Type::Handle(Z);
+  String& redirection_identifier = String::Handle(Z);
   bool is_redirecting = false;
   if (method->IsFactory() && (CurrentToken() == Token::kASSIGN)) {
     // Default parameter values are disallowed in redirecting factories.
@@ -3454,7 +3463,7 @@
     const bool consume_unresolved_prefix =
         (LookaheadToken(3) == Token::kLT) ||
         (LookaheadToken(3) == Token::kPERIOD);
-    const AbstractType& type = AbstractType::Handle(I,
+    const AbstractType& type = AbstractType::Handle(Z,
         ParseType(ClassFinalizer::kResolveTypeParameters,
                   false,  // Deferred types not allowed.
                   consume_unresolved_prefix));
@@ -3461,12 +3470,12 @@
     if (!type.IsMalformed() && type.IsTypeParameter()) {
       // Replace the type with a malformed type and compile a throw when called.
       redirection_type = ClassFinalizer::NewFinalizedMalformedType(
-          Error::Handle(I),  // No previous error.
+          Error::Handle(Z),  // No previous error.
           script_,
           type_pos,
           "factory '%s' may not redirect to type parameter '%s'",
           method->name->ToCString(),
-          String::Handle(I, type.UserVisibleName()).ToCString());
+          String::Handle(Z, type.UserVisibleName()).ToCString());
     } else {
       // We handle malformed and malbounded redirection type at run time.
       redirection_type ^= type.raw();
@@ -3499,7 +3508,7 @@
       }
       ConsumeToken();  // Colon.
       ExpectToken(Token::kTHIS);
-      String& redir_name = String::ZoneHandle(I,
+      String& redir_name = String::ZoneHandle(Z,
           String::Concat(members->class_name(), Symbols::Dot()));
       if (CurrentToken() == Token::kPERIOD) {
         ConsumeToken();
@@ -3637,7 +3646,7 @@
   } else {
     function_kind = RawFunction::kRegularFunction;
   }
-  Function& func = Function::Handle(I,
+  Function& func = Function::Handle(Z,
       Function::New(*method->name,
                     function_kind,
                     method->has_static,
@@ -3699,10 +3708,10 @@
   if (!field->has_static && field->has_const) {
     ReportError(field->name_pos, "instance field may not be 'const'");
   }
-  Function& getter = Function::Handle(I);
-  Function& setter = Function::Handle(I);
-  Field& class_field = Field::ZoneHandle(I);
-  Instance& init_value = Instance::Handle(I);
+  Function& getter = Function::Handle(Z);
+  Function& setter = Function::Handle(Z);
+  Field& class_field = Field::ZoneHandle(Z);
+  Instance& init_value = Instance::Handle(Z);
   while (true) {
     bool has_initializer = CurrentToken() == Token::kASSIGN;
     bool has_simple_literal = false;
@@ -3764,7 +3773,7 @@
     if (field->has_static && has_initializer) {
       class_field.set_value(init_value);
       if (!has_simple_literal) {
-        String& getter_name = String::Handle(I,
+        String& getter_name = String::Handle(Z,
                                              Field::GetterSymbol(*field->name));
         getter = Function::New(getter_name,
                                RawFunction::kImplicitStaticFinalGetter,
@@ -3786,7 +3795,7 @@
 
     // For instance fields, we create implicit getter and setter methods.
     if (!field->has_static) {
-      String& getter_name = String::Handle(I,
+      String& getter_name = String::Handle(Z,
                                            Field::GetterSymbol(*field->name));
       getter = Function::New(getter_name, RawFunction::kImplicitGetter,
                              field->has_static,
@@ -3805,7 +3814,7 @@
       members->AddFunction(getter);
       if (!field->has_final) {
         // Build a setter accessor for non-const fields.
-        String& setter_name = String::Handle(I,
+        String& setter_name = String::Handle(Z,
                                              Field::SetterSymbol(*field->name));
         setter = Function::New(setter_name, RawFunction::kImplicitSetter,
                                field->has_static,
@@ -3821,7 +3830,7 @@
         params.AddFinalParameter(TokenPos(),
                                  &Symbols::Value(),
                                  field->type);
-        setter.set_result_type(Type::Handle(I, Type::VoidType()));
+        setter.set_result_type(Type::Handle(Z, Type::VoidType()));
         setter.set_is_debuggable(false);
         if (library_.is_dart_scheme() && library_.IsPrivate(*field->name)) {
           setter.set_is_visible(false);
@@ -3925,7 +3934,7 @@
     ConsumeToken();
     member.has_var = true;
     // The member type is the 'dynamic' type.
-    member.type = &Type::ZoneHandle(I, Type::DynamicType());
+    member.type = &Type::ZoneHandle(Z, Type::DynamicType());
   } else if (CurrentToken() == Token::kFACTORY) {
     ConsumeToken();
     if (member.has_static) {
@@ -3942,7 +3951,7 @@
     }
     ConsumeToken();
     ASSERT(member.type == NULL);
-    member.type = &Type::ZoneHandle(I, Type::VoidType());
+    member.type = &Type::ZoneHandle(Z, 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) {
@@ -3962,7 +3971,7 @@
         // 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(I,
+        member.type = &AbstractType::ZoneHandle(Z,
             ParseType(ClassFinalizer::kResolveTypeParameters));
       }
     }
@@ -3989,16 +3998,16 @@
     }
     // Do not bypass class resolution by using current_class() directly, since
     // it may be a patch class.
-    const Object& result_type_class = Object::Handle(I,
-        UnresolvedClass::New(LibraryPrefix::Handle(I),
+    const Object& result_type_class = Object::Handle(Z,
+        UnresolvedClass::New(LibraryPrefix::Handle(Z),
                              *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(I, Type::New(
+    member.type = &Type::ZoneHandle(Z, Type::New(
         result_type_class,
-        TypeArguments::Handle(I, current_class().type_parameters()),
+        TypeArguments::Handle(Z, current_class().type_parameters()),
         member.name_pos));
 
     // We must be dealing with a constructor or named constructor.
@@ -4037,7 +4046,7 @@
     // 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(I, Type::DynamicType());
+      member.type = &Type::ZoneHandle(Z, Type::DynamicType());
     }
   } else if ((CurrentToken() == Token::kOPERATOR) && !member.has_var &&
              (LookaheadToken(1) != Token::kLPAREN) &&
@@ -4056,7 +4065,7 @@
     member.kind = RawFunction::kRegularFunction;
     member.name_pos = this->TokenPos();
     member.name =
-        &String::ZoneHandle(I, Symbols::New(Token::Str(member.operator_token)));
+        &String::ZoneHandle(Z, Symbols::New(Token::Str(member.operator_token)));
     ConsumeToken();
   } else if (IsIdentifier()) {
     member.name = CurrentLiteral();
@@ -4070,7 +4079,7 @@
   if (CurrentToken() == Token::kLPAREN || member.IsGetter()) {
     // Constructor or method.
     if (member.type == NULL) {
-      member.type = &Type::ZoneHandle(I, Type::DynamicType());
+      member.type = &Type::ZoneHandle(Z, Type::DynamicType());
     }
     ASSERT(member.IsFactory() == member.has_factory);
     ParseMethodOrConstructor(members, &member);
@@ -4084,7 +4093,7 @@
     }
     if (member.type == NULL) {
       if (member.has_final) {
-        member.type = &Type::ZoneHandle(I, Type::DynamicType());
+        member.type = &Type::ZoneHandle(Z, Type::DynamicType());
       } else {
         ReportError("missing 'var', 'final', 'const' or type"
                     " in field declaration");
@@ -4130,11 +4139,11 @@
   }
   ExpectToken(Token::kRBRACE);
 
-  Object& obj = Object::Handle(I, library_.LookupLocalObject(*enum_name));
+  Object& obj = Object::Handle(Z, library_.LookupLocalObject(*enum_name));
   if (!obj.IsNull()) {
     ReportError(enum_pos, "'%s' is already defined", enum_name->ToCString());
   }
-  Class& cls = Class::Handle(I);
+  Class& cls = Class::Handle(Z);
   cls = Class::New(*enum_name, script_, enum_pos);
   cls.set_library(library_);
   library_.AddClass(cls);
@@ -4143,7 +4152,7 @@
   if (metadata_pos >= 0) {
     library_.AddClassMetadata(cls, toplevel_class, metadata_pos);
   }
-  cls.set_super_type(Type::Handle(I, Type::ObjectType()));
+  cls.set_super_type(Type::Handle(Z, Type::ObjectType()));
   pending_classes.Add(cls, Heap::kOld);
 }
 
@@ -4169,9 +4178,9 @@
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing class '%s'\n", class_name.ToCString());
   }
-  Class& cls = Class::Handle(I);
-  TypeArguments& orig_type_parameters = TypeArguments::Handle(I);
-  Object& obj = Object::Handle(I, library_.LookupLocalObject(class_name));
+  Class& cls = Class::Handle(Z);
+  TypeArguments& orig_type_parameters = TypeArguments::Handle(Z);
+  Object& obj = Object::Handle(Z, library_.LookupLocalObject(class_name));
   if (obj.IsNull()) {
     if (is_patch) {
       ReportError(classname_pos, "missing class '%s' cannot be patched",
@@ -4215,7 +4224,7 @@
   if (is_patch) {
     // Check that the new type parameters are identical to the original ones.
     const TypeArguments& new_type_parameters =
-        TypeArguments::Handle(I, cls.type_parameters());
+        TypeArguments::Handle(Z, cls.type_parameters());
     const int new_type_params_count =
         new_type_parameters.IsNull() ? 0 : new_type_parameters.Length();
     const int orig_type_params_count =
@@ -4225,12 +4234,12 @@
                   "class '%s' must be patched with identical type parameters",
                   class_name.ToCString());
     }
-    TypeParameter& new_type_param = TypeParameter::Handle(I);
-    TypeParameter& orig_type_param = TypeParameter::Handle(I);
-    String& new_name = String::Handle(I);
-    String& orig_name = String::Handle(I);
-    AbstractType& new_bound = AbstractType::Handle(I);
-    AbstractType& orig_bound = AbstractType::Handle(I);
+    TypeParameter& new_type_param = TypeParameter::Handle(Z);
+    TypeParameter& orig_type_param = TypeParameter::Handle(Z);
+    String& new_name = String::Handle(Z);
+    String& orig_name = String::Handle(Z);
+    AbstractType& new_bound = AbstractType::Handle(Z);
+    AbstractType& orig_bound = AbstractType::Handle(Z);
     for (int i = 0; i < new_type_params_count; i++) {
       new_type_param ^= new_type_parameters.TypeAt(i);
       orig_type_param ^= orig_type_parameters.TypeAt(i);
@@ -4273,13 +4282,13 @@
                 class_name.ToCString());
   }
 
-  AbstractType& super_type = Type::Handle(I);
+  AbstractType& super_type = Type::Handle(Z);
   if ((CurrentToken() == Token::kEXTENDS) || is_mixin_declaration) {
     ConsumeToken();  // extends or =
     const intptr_t type_pos = TokenPos();
     super_type = ParseType(ClassFinalizer::kResolveTypeParameters);
     if (super_type.IsMalformedOrMalbounded()) {
-      ReportError(Error::Handle(I, super_type.error()));
+      ReportError(Error::Handle(Z, super_type.error()));
     }
     if (super_type.IsDynamicType()) {
       // Unlikely here, since super type is not resolved yet.
@@ -4291,7 +4300,7 @@
       ReportError(type_pos,
                   "class '%s' may not extend type parameter '%s'",
                   class_name.ToCString(),
-                  String::Handle(I,
+                  String::Handle(Z,
                                  super_type.UserVisibleName()).ToCString());
     }
     // The class finalizer will check whether the super type is malbounded.
@@ -4344,7 +4353,7 @@
   CompilerStats::num_classes_compiled++;
   set_current_class(cls);
   is_top_level_ = true;
-  String& class_name = String::Handle(I, cls.Name());
+  String& class_name = String::Handle(Z, cls.Name());
   const intptr_t class_pos = TokenPos();
   ClassDesc members(cls, class_name, false, class_pos);
   while (CurrentToken() != Token::kLBRACE) {
@@ -4367,7 +4376,7 @@
   cls.AddFields(members.fields());
 
   // Creating a new array for functions marks the class as parsed.
-  const Array& array = Array::Handle(I, Array::MakeArray(members.functions()));
+  const Array& array = Array::Handle(Z, Array::MakeArray(members.functions()));
   cls.SetFunctions(array);
 
   // Add an implicit constructor if no explicit constructor is present.
@@ -4378,11 +4387,11 @@
 
   if (cls.is_patch()) {
     // Apply the changes to the patched class looked up above.
-    Object& obj = Object::Handle(I, library_.LookupLocalObject(class_name));
+    Object& obj = Object::Handle(Z, library_.LookupLocalObject(class_name));
     // The patched class must not be finalized yet.
     const Class& orig_class = Class::Cast(obj);
     ASSERT(!orig_class.is_finalized());
-    Error& error = Error::Handle(I);
+    Error& error = Error::Handle(Z);
     if (!orig_class.ApplyPatch(cls, &error)) {
       Report::LongJumpF(error, script_, class_pos, "applying patch failed");
     }
@@ -4394,12 +4403,12 @@
   TRACE_PARSER("ParseEnumDefinition");
   CompilerStats::num_classes_compiled++;
 
-  const String& enum_name = String::Handle(I, cls.Name());
+  const String& enum_name = String::Handle(Z, cls.Name());
   ClassDesc enum_members(cls, enum_name, false, cls.token_pos());
 
   // Add instance field 'final int index'.
-  Field& index_field = Field::ZoneHandle(I);
-  const Type& int_type = Type::Handle(I, Type::IntType());
+  Field& index_field = Field::ZoneHandle(Z);
+  const Type& int_type = Type::Handle(Z, Type::IntType());
   const Type& dynamic_type = Type::Handle(Type::DynamicType());
   index_field = Field::New(Symbols::Index(),
                            false,  // Not static.
@@ -4413,8 +4422,8 @@
 
   // Add implicit getter for index field.
   const String& getter_name =
-      String::Handle(I, Field::GetterSymbol(Symbols::Index()));
-  Function& getter = Function::Handle(I);
+      String::Handle(Z, Field::GetterSymbol(Symbols::Index()));
+  Function& getter = Function::Handle(Z);
   getter = Function::New(getter_name,
                          RawFunction::kImplicitGetter,
                          /* is_static = */ false,
@@ -4431,7 +4440,7 @@
   AddFormalParamsToFunction(&params, getter);
   enum_members.AddFunction(getter);
 
-  GrowableObjectArray& enum_names = GrowableObjectArray::Handle(I,
+  GrowableObjectArray& enum_names = GrowableObjectArray::Handle(Z,
       GrowableObjectArray::New(8, Heap::kOld));
   const String& name_prefix =
       String::Handle(String::Concat(enum_name, Symbols::Dot()));
@@ -4441,8 +4450,8 @@
 
   ConsumeToken();  // Enum type name.
   ExpectToken(Token::kLBRACE);
-  Field& enum_value = Field::Handle(I);
-  String& enum_value_name = String::Handle(I);
+  Field& enum_value = Field::Handle(Z);
+  String& enum_value_name = String::Handle(Z);
   intptr_t i = 0;
   GrowableArray<String*> declared_names(8);
 
@@ -4485,7 +4494,7 @@
     enum_members.AddField(enum_value);
     // Initialize the field with the ordinal value. It will be patched
     // later with the enum constant instance.
-    const Smi& ordinal_value = Smi::Handle(I, Smi::New(i));
+    const Smi& ordinal_value = Smi::Handle(Z, Smi::New(i));
     enum_value.set_value(ordinal_value);
     enum_value.RecordStore(ordinal_value);
     i++;
@@ -4506,11 +4515,11 @@
   ExpectToken(Token::kRBRACE);
 
   const Class& helper_class =
-      Class::Handle(I, Library::LookupCoreClass(Symbols::_EnumHelper()));
+      Class::Handle(Z, Library::LookupCoreClass(Symbols::_EnumHelper()));
   ASSERT(!helper_class.IsNull());
 
   // Add static field 'const List values'.
-  Field& values_field = Field::ZoneHandle(I);
+  Field& values_field = Field::ZoneHandle(Z);
   values_field = Field::New(Symbols::Values(),
                             /* is_static = */ true,
                             /* is_final = */ true,
@@ -4518,18 +4527,18 @@
                             /* is_synthetic = */ false,
                             cls,
                             cls.token_pos());
-  values_field.set_type(Type::Handle(I, Type::ArrayType()));
+  values_field.set_type(Type::Handle(Z, Type::ArrayType()));
   enum_members.AddField(values_field);
 
   // Allocate the immutable array containing the enumeration values.
   // The actual enum instance values will be patched in later.
-  const Array& values_array = Array::Handle(I, Array::New(i, Heap::kOld));
+  const Array& values_array = Array::Handle(Z, Array::New(i, Heap::kOld));
   values_field.set_value(values_array);
   values_field.RecordStore(values_array);
 
   // Create a static field that contains the list of enumeration names.
   // Clone the _enum_names field from the helper class.
-  Field& names_field = Field::Handle(I,
+  Field& names_field = Field::Handle(Z,
       helper_class.LookupStaticField(Symbols::_EnumNames()));
   ASSERT(!names_field.IsNull());
   names_field = names_field.Clone(cls);
@@ -4539,7 +4548,7 @@
   names_field.RecordStore(names_array);
 
   // Clone the toString() function from the helper class.
-  Function& to_string_func = Function::Handle(I,
+  Function& to_string_func = Function::Handle(Z,
       helper_class.LookupDynamicFunctionAllowPrivate(Symbols::toString()));
   ASSERT(!to_string_func.IsNull());
   to_string_func = to_string_func.Clone(cls);
@@ -4547,7 +4556,7 @@
 
   cls.AddFields(enum_members.fields());
   const Array& functions =
-      Array::Handle(I, Array::MakeArray(enum_members.functions()));
+      Array::Handle(Z, Array::MakeArray(enum_members.functions()));
   cls.SetFunctions(functions);
 }
 
@@ -4555,13 +4564,13 @@
 // 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(I, cls.Name());
+  String& ctor_name = String::ZoneHandle(Z, 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(I,
+  Function& ctor = Function::Handle(Z,
       Function::New(ctor_name,
                     RawFunction::kConstructor,
                     /* is_static = */ false,
@@ -4584,7 +4593,7 @@
   // Add implicit parameter for construction phase.
   params.AddFinalParameter(cls.token_pos(),
                            &Symbols::PhaseParameter(),
-                           &Type::ZoneHandle(I, Type::SmiType()));
+                           &Type::ZoneHandle(Z, Type::SmiType()));
 
   AddFormalParamsToFunction(&params, ctor);
   // The body of the constructor cannot modify the type of the constructed
@@ -4636,13 +4645,13 @@
     OS::Print("toplevel parsing mixin application alias class '%s'\n",
               class_name.ToCString());
   }
-  const Object& obj = Object::Handle(I, library_.LookupLocalObject(class_name));
+  const Object& obj = Object::Handle(Z, library_.LookupLocalObject(class_name));
   if (!obj.IsNull()) {
     ReportError(classname_pos, "'%s' is already defined",
                 class_name.ToCString());
   }
   const Class& mixin_application =
-      Class::Handle(I, Class::New(class_name, script_, classname_pos));
+      Class::Handle(Z, Class::New(class_name, script_, classname_pos));
   mixin_application.set_is_mixin_app_alias();
   library_.AddClass(mixin_application);
   set_current_class(mixin_application);
@@ -4657,13 +4666,13 @@
 
   const intptr_t type_pos = TokenPos();
   AbstractType& type =
-      AbstractType::Handle(I,
+      AbstractType::Handle(Z,
                            ParseType(ClassFinalizer::kResolveTypeParameters));
   if (type.IsTypeParameter()) {
     ReportError(type_pos,
                 "class '%s' may not extend type parameter '%s'",
                 class_name.ToCString(),
-                String::Handle(I, type.UserVisibleName()).ToCString());
+                String::Handle(Z, type.UserVisibleName()).ToCString());
   }
 
   CheckToken(Token::kWITH, "mixin application 'with Type' expected");
@@ -4741,7 +4750,7 @@
   }
 
   // Parse the result type of the function type.
-  AbstractType& result_type = Type::Handle(I, Type::DynamicType());
+  AbstractType& result_type = Type::Handle(Z, Type::DynamicType());
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
@@ -4758,7 +4767,7 @@
   // Lookup alias name and report an error if it is already defined in
   // the library scope.
   const Object& obj =
-      Object::Handle(I, library_.LookupLocalObject(*alias_name));
+      Object::Handle(Z, library_.LookupLocalObject(*alias_name));
   if (!obj.IsNull()) {
     ReportError(alias_name_pos,
                 "'%s' is already defined", alias_name->ToCString());
@@ -4768,9 +4777,9 @@
   // signature function after it has been parsed. The type parameters, in order
   // to be properly finalized, need to be associated to this signature class as
   // they are parsed.
-  const Class& function_type_alias = Class::Handle(I,
+  const Class& function_type_alias = Class::Handle(Z,
       Class::NewSignatureClass(*alias_name,
-                               Function::Handle(I),
+                               Function::Handle(Z),
                                script_,
                                alias_name_pos));
   library_.AddClass(function_type_alias);
@@ -4792,13 +4801,13 @@
   func_params.AddFinalParameter(
       TokenPos(),
       &Symbols::ClosureParameter(),
-      &Type::ZoneHandle(I, Type::DynamicType()));
+      &Type::ZoneHandle(Z, 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(I,
+  Function& signature_function = Function::Handle(Z,
       Function::New(*alias_name,
                     RawFunction::kSignatureFunction,
                     /* is_static = */ false,
@@ -4815,7 +4824,7 @@
   // Patch the signature function in the signature class.
   function_type_alias.PatchSignatureFunction(signature_function);
 
-  const String& signature = String::Handle(I,
+  const String& signature = String::Handle(Z,
                                            signature_function.Signature());
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing function type alias '%s'\n",
@@ -4825,7 +4834,7 @@
   // 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(I, library_.LookupLocalClass(signature));
+      Class::ZoneHandle(Z, library_.LookupLocalClass(signature));
   if (signature_class.IsNull()) {
     signature_class = Class::NewSignatureClass(signature,
                                                signature_function,
@@ -4929,12 +4938,12 @@
   TRACE_PARSER("ParseTypeParameters");
   if (CurrentToken() == Token::kLT) {
     const GrowableObjectArray& type_parameters_array =
-        GrowableObjectArray::Handle(I, GrowableObjectArray::New());
+        GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
     intptr_t index = 0;
-    TypeParameter& type_parameter = TypeParameter::Handle(I);
-    TypeParameter& existing_type_parameter = TypeParameter::Handle(I);
-    String& existing_type_parameter_name = String::Handle(I);
-    AbstractType& type_parameter_bound = Type::Handle(I);
+    TypeParameter& type_parameter = TypeParameter::Handle(Z);
+    TypeParameter& existing_type_parameter = TypeParameter::Handle(Z);
+    String& existing_type_parameter_name = String::Handle(Z);
+    AbstractType& type_parameter_bound = Type::Handle(Z);
     do {
       ConsumeToken();
       const intptr_t metadata_pos = SkipMetadata();
@@ -4978,7 +4987,7 @@
       ReportError("right angle bracket expected");
     }
     const TypeArguments& type_parameters =
-        TypeArguments::Handle(I,
+        TypeArguments::Handle(Z,
                               NewTypeArguments(type_parameters_array));
     cls.set_type_parameters(type_parameters);
     // Try to resolve the upper bounds, which will at least resolve the
@@ -5001,8 +5010,8 @@
   TRACE_PARSER("ParseTypeArguments");
   if (CurrentToken() == Token::kLT) {
     const GrowableObjectArray& types =
-        GrowableObjectArray::Handle(I, GrowableObjectArray::New());
-    AbstractType& type = AbstractType::Handle(I);
+        GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
+    AbstractType& type = AbstractType::Handle(Z);
     do {
       ConsumeToken();
       type = ParseType(finalization);
@@ -5031,10 +5040,10 @@
   TRACE_PARSER("ParseInterfaceList");
   ASSERT(CurrentToken() == Token::kIMPLEMENTS);
   const GrowableObjectArray& all_interfaces =
-      GrowableObjectArray::Handle(I, GrowableObjectArray::New());
-  AbstractType& interface = AbstractType::Handle(I);
+      GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
+  AbstractType& interface = AbstractType::Handle(Z);
   // First get all the interfaces already implemented by class.
-  Array& cls_interfaces = Array::Handle(I, cls.interfaces());
+  Array& cls_interfaces = Array::Handle(Z, cls.interfaces());
   for (intptr_t i = 0; i < cls_interfaces.Length(); i++) {
     interface ^= cls_interfaces.At(i);
     all_interfaces.Add(interface);
@@ -5047,7 +5056,7 @@
     if (interface.IsTypeParameter()) {
       ReportError(interface_pos,
                   "type parameter '%s' may not be used in interface list",
-                  String::Handle(I, interface.UserVisibleName()).ToCString());
+                  String::Handle(Z, interface.UserVisibleName()).ToCString());
     }
     all_interfaces.Add(interface);
   } while (CurrentToken() == Token::kCOMMA);
@@ -5060,8 +5069,8 @@
   TRACE_PARSER("ParseMixins");
   ASSERT(CurrentToken() == Token::kWITH);
   const GrowableObjectArray& mixin_types =
-      GrowableObjectArray::Handle(I, GrowableObjectArray::New());
-  AbstractType& mixin_type = AbstractType::Handle(I);
+      GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
+  AbstractType& mixin_type = AbstractType::Handle(Z);
   do {
     ConsumeToken();
     mixin_type = ParseType(ClassFinalizer::kResolveTypeParameters);
@@ -5073,12 +5082,12 @@
     if (mixin_type.IsTypeParameter()) {
       ReportError(mixin_type.token_pos(),
                   "mixin type '%s' may not be a type parameter",
-                  String::Handle(I, mixin_type.UserVisibleName()).ToCString());
+                  String::Handle(Z, mixin_type.UserVisibleName()).ToCString());
     }
     mixin_types.Add(mixin_type);
   } while (CurrentToken() == Token::kCOMMA);
   return MixinAppType::New(super_type,
-      Array::Handle(I, Array::MakeArray(mixin_types)));
+      Array::Handle(Z, Array::MakeArray(mixin_types)));
 }
 
 
@@ -5090,10 +5099,10 @@
   const bool is_final = is_const || (CurrentToken() == Token::kFINAL);
   const bool is_static = true;
   const bool is_synthetic = false;
-  const AbstractType& type = AbstractType::ZoneHandle(I,
+  const AbstractType& type = AbstractType::ZoneHandle(Z,
       ParseConstFinalVarOrType(ClassFinalizer::kResolveTypeParameters));
-  Field& field = Field::Handle(I);
-  Function& getter = Function::Handle(I);
+  Field& field = Field::Handle(Z);
+  Function& getter = Function::Handle(Z);
   while (true) {
     const intptr_t name_pos = TokenPos();
     String& var_name = *ExpectIdentifier("variable name expected");
@@ -5106,7 +5115,7 @@
     // or final field implies a setter which throws a NoSuchMethodError,
     // thus we need to check for conflicts with existing setters and
     // getters.
-    String& accessor_name = String::Handle(I,
+    String& accessor_name = String::Handle(Z,
                                            Field::GetterName(var_name));
     if (library_.LookupLocalObject(accessor_name) != Object::null()) {
       ReportError(name_pos, "getter for '%s' is already defined",
@@ -5121,7 +5130,7 @@
     field = Field::New(var_name, is_static, is_final, is_const, is_synthetic,
                        current_class(), name_pos);
     field.set_type(type);
-    field.set_value(Instance::Handle(I, Instance::null()));
+    field.set_value(Instance::Handle(Z, Instance::null()));
     top_level->fields.Add(field);
     library_.AddObject(field, var_name);
     if (metadata_pos >= 0) {
@@ -5129,7 +5138,7 @@
     }
     if (CurrentToken() == Token::kASSIGN) {
       ConsumeToken();
-      Instance& field_value = Instance::Handle(I,
+      Instance& field_value = Instance::Handle(Z,
                                                Object::sentinel().raw());
       bool has_simple_literal = false;
       if (LookaheadToken(1) == Token::kSEMICOLON) {
@@ -5139,7 +5148,7 @@
       field.set_value(field_value);
       if (!has_simple_literal) {
         // Create a static final getter.
-        String& getter_name = String::Handle(I,
+        String& getter_name = String::Handle(Z,
                                              Field::GetterSymbol(var_name));
         getter = Function::New(getter_name,
                                RawFunction::kImplicitStaticFinalGetter,
@@ -5189,7 +5198,7 @@
                                    intptr_t metadata_pos) {
   TRACE_PARSER("ParseTopLevelFunction");
   const intptr_t decl_begin_pos = TokenPos();
-  AbstractType& result_type = Type::Handle(I, Type::DynamicType());
+  AbstractType& result_type = Type::Handle(Z, Type::DynamicType());
   const bool is_static = true;
   bool is_external = false;
   bool is_patch = false;
@@ -5223,7 +5232,7 @@
     ReportError(name_pos, "missing '%s' cannot be patched",
                 func_name.ToCString());
   }
-  String& accessor_name = String::Handle(I,
+  String& accessor_name = String::Handle(Z,
                                          Field::GetterName(func_name));
   if (library_.LookupLocalObject(accessor_name) != Object::null()) {
     ReportError(name_pos, "'%s' is already defined as getter",
@@ -5264,7 +5273,7 @@
   } else {
     ReportError("function block expected");
   }
-  Function& func = Function::Handle(I,
+  Function& func = Function::Handle(Z,
       Function::New(func_name,
                     RawFunction::kRegularFunction,
                     is_static,
@@ -5303,7 +5312,7 @@
   const bool is_static = true;
   bool is_external = false;
   bool is_patch = false;
-  AbstractType& result_type = AbstractType::Handle(I);
+  AbstractType& result_type = AbstractType::Handle(Z);
   if (is_patch_source() &&
       (CurrentToken() == Token::kIDENT) &&
       CurrentLiteral()->Equals("patch")) {
@@ -5342,7 +5351,7 @@
     const bool allow_explicit_default_values = true;
     ParseFormalParameterList(allow_explicit_default_values, false, &params);
   }
-  String& accessor_name = String::ZoneHandle(I);
+  String& accessor_name = String::ZoneHandle(Z);
   int expected_num_parameters = -1;
   if (is_getter) {
     expected_num_parameters = 0;
@@ -5406,7 +5415,7 @@
   } else {
     ReportError("function block expected");
   }
-  Function& func = Function::Handle(I,
+  Function& func = Function::Handle(Z,
       Function::New(accessor_name,
                     is_getter ? RawFunction::kGetterFunction :
                                 RawFunction::kSetterFunction,
@@ -5463,7 +5472,7 @@
   if (Dart_IsError(result)) {
     // In case of an error we append an explanatory error message to the
     // error obtained from the library tag handler.
-    Error& prev_error = Error::Handle(I);
+    Error& prev_error = Error::Handle(Z);
     prev_error ^= Api::UnwrapHandle(result);
     Report::LongJumpF(prev_error, script_, token_pos, "library handler failed");
   }
@@ -5529,7 +5538,7 @@
     ConsumeToken();
     CheckToken(Token::kAS, "'as' expected");
   }
-  String& prefix = String::Handle(I);
+  String& prefix = String::Handle(Z);
   intptr_t prefix_pos = 0;
   if (is_import && (CurrentToken() == Token::kAS)) {
     ConsumeToken();
@@ -5537,13 +5546,13 @@
     prefix = ExpectIdentifier("prefix identifier expected")->raw();
   }
 
-  Array& show_names = Array::Handle(I);
-  Array& hide_names = Array::Handle(I);
+  Array& show_names = Array::Handle(Z);
+  Array& hide_names = Array::Handle(Z);
   if (is_deferred_import || IsLiteral("show") || IsLiteral("hide")) {
     GrowableObjectArray& show_list =
-        GrowableObjectArray::Handle(I, GrowableObjectArray::New());
+        GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
     GrowableObjectArray& hide_list =
-        GrowableObjectArray::Handle(I, GrowableObjectArray::New());
+        GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
     // Libraries imported through deferred import automatically hide
     // the name 'loadLibrary'.
     if (is_deferred_import) {
@@ -5574,7 +5583,7 @@
       CallLibraryTagHandler(Dart_kCanonicalizeUrl, import_pos, url));
 
   // Create a new library if it does not exist yet.
-  Library& library = Library::Handle(I, Library::LookupLibrary(canon_url));
+  Library& library = Library::Handle(Z, Library::LookupLibrary(canon_url));
   if (library.IsNull()) {
     library = Library::New(canon_url);
     library.Register();
@@ -5588,7 +5597,7 @@
     CallLibraryTagHandler(Dart_kImportTag, import_pos, canon_url);
   }
 
-  Namespace& ns = Namespace::Handle(I,
+  Namespace& ns = Namespace::Handle(Z,
       Namespace::New(library, show_names, hide_names));
   if (metadata_pos >= 0) {
     ns.AddMetadata(metadata_pos, current_class());
@@ -5597,7 +5606,7 @@
   if (is_import) {
     // Ensure that private dart:_ libraries are only imported into dart:
     // libraries.
-    const String& lib_url = String::Handle(I, library_.url());
+    const String& lib_url = String::Handle(Z, library_.url());
     if (canon_url.StartsWith(Symbols::DartSchemePrivate()) &&
         !lib_url.StartsWith(Symbols::DartScheme())) {
       ReportError(import_pos, "private library is not accessible");
@@ -5606,7 +5615,7 @@
       ASSERT(!is_deferred_import);
       library_.AddImport(ns);
     } else {
-      LibraryPrefix& library_prefix = LibraryPrefix::Handle(I);
+      LibraryPrefix& library_prefix = LibraryPrefix::Handle(Z);
       library_prefix = library_.LookupLocalLibraryPrefix(prefix);
       if (!library_prefix.IsNull()) {
         // Check that prefix names of deferred import clauses are
@@ -5685,9 +5694,9 @@
   // Core lib has not been explicitly imported, so we implicitly
   // import it here.
   if (!library_.ImportsCorelib()) {
-    Library& core_lib = Library::Handle(I, Library::CoreLibrary());
+    Library& core_lib = Library::Handle(Z, Library::CoreLibrary());
     ASSERT(!core_lib.IsNull());
-    const Namespace& core_ns = Namespace::Handle(I,
+    const Namespace& core_ns = Namespace::Handle(Z,
         Namespace::New(core_lib, Object::null_array(), Object::null_array()));
     library_.AddImport(core_ns);
   }
@@ -5726,11 +5735,11 @@
   // has been completed.
   ObjectStore* object_store = I->object_store();
   const GrowableObjectArray& pending_classes =
-      GrowableObjectArray::Handle(I, object_store->pending_classes());
+      GrowableObjectArray::Handle(Z, object_store->pending_classes());
   SetPosition(0);
   is_top_level_ = true;
   TopLevel top_level;
-  Class& toplevel_class = Class::Handle(I,
+  Class& toplevel_class = Class::Handle(Z,
       Class::New(Symbols::TopLevel(), script_, TokenPos()));
   toplevel_class.set_library(library_);
 
@@ -5741,7 +5750,7 @@
     ParsePartHeader();
   }
 
-  const Class& cls = Class::Handle(I);
+  const Class& cls = Class::Handle(Z);
   while (true) {
     set_current_class(cls);  // No current class.
     intptr_t metadata_pos = SkipMetadata();
@@ -5777,7 +5786,7 @@
   if ((top_level.fields.Length() > 0) || (top_level.functions.Length() > 0)) {
     toplevel_class.AddFields(top_level.fields);
 
-    const Array& array = Array::Handle(I,
+    const Array& array = Array::Handle(Z,
                                        Array::MakeArray(top_level.functions));
     toplevel_class.SetFunctions(array);
 
@@ -5788,10 +5797,10 @@
 
 
 void Parser::ChainNewBlock(LocalScope* outer_scope) {
-  Block* block = new(I) Block(
+  Block* block = new(Z) Block(
       current_block_,
       outer_scope,
-      new(I) SequenceNode(TokenPos(), outer_scope));
+      new(Z) SequenceNode(TokenPos(), outer_scope));
   current_block_ = block;
 }
 
@@ -5799,7 +5808,7 @@
 void Parser::OpenBlock() {
   ASSERT(current_block_ != NULL);
   LocalScope* outer_scope = current_block_->scope;
-  ChainNewBlock(new(I) LocalScope(
+  ChainNewBlock(new(Z) LocalScope(
       outer_scope, outer_scope->function_level(), outer_scope->loop_level()));
 }
 
@@ -5807,7 +5816,7 @@
 void Parser::OpenLoopBlock() {
   ASSERT(current_block_ != NULL);
   LocalScope* outer_scope = current_block_->scope;
-  ChainNewBlock(new(I) LocalScope(
+  ChainNewBlock(new(Z) LocalScope(
       outer_scope,
       outer_scope->function_level(),
       outer_scope->loop_level() + 1));
@@ -5819,20 +5828,20 @@
   if (current_block_ == NULL) {
     if (!func.IsLocalFunction()) {
       // We are compiling a non-nested function.
-      outer_scope = new(I) LocalScope(NULL, 0, 0);
+      outer_scope = new(Z) LocalScope(NULL, 0, 0);
     } else {
       // We are compiling the function of an invoked closure.
       // Restore the outer scope containing all captured variables.
       const ContextScope& context_scope =
-          ContextScope::Handle(I, func.context_scope());
+          ContextScope::Handle(Z, func.context_scope());
       ASSERT(!context_scope.IsNull());
-      outer_scope = new(I) LocalScope(
+      outer_scope = new(Z) LocalScope(
           LocalScope::RestoreOuterScope(context_scope), 0, 0);
     }
   } else {
     // We are parsing a nested function while compiling the enclosing function.
     outer_scope =
-        new(I) LocalScope(current_block_->scope,
+        new(Z) LocalScope(current_block_->scope,
                                   current_block_->scope->function_level() + 1,
                                   0);
   }
@@ -5855,7 +5864,7 @@
   OpenBlock();
   OpenBlock();
   const AbstractType& dynamic_type =
-      AbstractType::ZoneHandle(I, Type::DynamicType());
+      AbstractType::ZoneHandle(Z, Type::DynamicType());
   CatchParamDesc exception_param;
   CatchParamDesc stack_trace_param;
   exception_param.token_pos = Scanner::kNoSourcePos;
@@ -5877,10 +5886,10 @@
     // Generate code to load the exception object (:exception_var) into
     // the exception variable specified in this block.
     ASSERT(exception_var != NULL);
-    current_block_->statements->Add(new(I) StoreLocalNode(
+    current_block_->statements->Add(new(Z) StoreLocalNode(
         Scanner::kNoSourcePos,
         exception_param.var,
-        new(I) LoadLocalNode(Scanner::kNoSourcePos, exception_var)));
+        new(Z) LoadLocalNode(Scanner::kNoSourcePos, exception_var)));
   }
   LocalVariable* stack_trace_var =
       current_block_->scope->LookupVariable(Symbols::StackTraceVar(), false);
@@ -5888,15 +5897,15 @@
     // A stack trace variable is specified in this block, so generate code
     // to load the stack trace object (:stack_trace_var) into the stack
     // trace variable specified in this block.
-    ArgumentListNode* no_args = new(I) ArgumentListNode(Scanner::kNoSourcePos);
+    ArgumentListNode* no_args = new(Z) ArgumentListNode(Scanner::kNoSourcePos);
     ASSERT(stack_trace_var != NULL);
-    current_block_->statements->Add(new(I) StoreLocalNode(
+    current_block_->statements->Add(new(Z) StoreLocalNode(
         Scanner::kNoSourcePos,
         stack_trace_param.var,
-        new(I) LoadLocalNode(Scanner::kNoSourcePos, stack_trace_var)));
-    current_block_->statements->Add(new(I) InstanceCallNode(
+        new(Z) LoadLocalNode(Scanner::kNoSourcePos, stack_trace_var)));
+    current_block_->statements->Add(new(Z) InstanceCallNode(
         Scanner::kNoSourcePos,
-        new(I) LoadLocalNode(Scanner::kNoSourcePos, stack_trace_param.var),
+        new(Z) LoadLocalNode(Scanner::kNoSourcePos, stack_trace_param.var),
         Library::PrivateCoreLibName(Symbols::_setupFullStackTrace()),
         no_args));
   }
@@ -5926,17 +5935,17 @@
       Symbols::AsyncCompleter(), false);
   ASSERT(async_completer != NULL);
   ArgumentListNode* completer_args =
-      new (I) ArgumentListNode(Scanner::kNoSourcePos);
+      new (Z) ArgumentListNode(Scanner::kNoSourcePos);
   completer_args->Add(
-      new (I) LoadLocalNode(Scanner::kNoSourcePos, exception_param.var));
+      new (Z) LoadLocalNode(Scanner::kNoSourcePos, exception_param.var));
   completer_args->Add(
-      new (I) LoadLocalNode(Scanner::kNoSourcePos, stack_trace_param.var));
-  current_block_->statements->Add(new (I) InstanceCallNode(
+      new (Z) LoadLocalNode(Scanner::kNoSourcePos, stack_trace_param.var));
+  current_block_->statements->Add(new (Z) InstanceCallNode(
       Scanner::kNoSourcePos,
-      new (I) LoadLocalNode(Scanner::kNoSourcePos, async_completer),
+      new (Z) LoadLocalNode(Scanner::kNoSourcePos, async_completer),
       Symbols::CompleterCompleteError(),
       completer_args));
-  ReturnNode* return_node = new (I) ReturnNode(Scanner::kNoSourcePos);
+  ReturnNode* return_node = new (Z) ReturnNode(Scanner::kNoSourcePos);
   // Behavior like a continuation return, i.e,. don't call a completer.
   return_node->set_return_type(ReturnNode::kContinuation);
   current_block_->statements->Add(return_node);
@@ -5945,7 +5954,7 @@
   SequenceNode* catch_handler_list = CloseBlock();
 
   const GrowableObjectArray& handler_types =
-      GrowableObjectArray::Handle(I, GrowableObjectArray::New());
+      GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
   handler_types.SetLength(0);
   handler_types.Add(*exception_param.type);
 
@@ -5952,16 +5961,16 @@
   TryBlocks* inner_try_block = PopTryBlock();
   const intptr_t try_index = inner_try_block->try_index();
 
-  CatchClauseNode* catch_clause = new (I) CatchClauseNode(
+  CatchClauseNode* catch_clause = new (Z) CatchClauseNode(
       Scanner::kNoSourcePos,
       catch_handler_list,
-      Array::ZoneHandle(I, Array::MakeArray(handler_types)),
+      Array::ZoneHandle(Z, Array::MakeArray(handler_types)),
       context_var,
       exception_var,
       stack_trace_var,
       CatchClauseNode::kInvalidTryIndex,
       true);
-  AstNode* try_catch_node = new (I) TryCatchNode(
+  AstNode* try_catch_node = new (Z) TryCatchNode(
       Scanner::kNoSourcePos,
       try_block,
       context_var,
@@ -5978,28 +5987,28 @@
   LocalVariable* context_var =
       current_block_->scope->LocalLookupVariable(Symbols::SavedTryContextVar());
   if (context_var == NULL) {
-    context_var = new(I) LocalVariable(
+    context_var = new(Z) LocalVariable(
         TokenPos(),
         Symbols::SavedTryContextVar(),
-        Type::ZoneHandle(I, Type::DynamicType()));
+        Type::ZoneHandle(Z, Type::DynamicType()));
     current_block_->scope->AddVariable(context_var);
   }
   LocalVariable* exception_var =
       current_block_->scope->LocalLookupVariable(Symbols::ExceptionVar());
   if (exception_var == NULL) {
-    exception_var = new(I) LocalVariable(
+    exception_var = new(Z) LocalVariable(
         TokenPos(),
         Symbols::ExceptionVar(),
-        Type::ZoneHandle(I, Type::DynamicType()));
+        Type::ZoneHandle(Z, 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(I) LocalVariable(
+    stack_trace_var = new(Z) LocalVariable(
         TokenPos(),
         Symbols::StackTraceVar(),
-        Type::ZoneHandle(I, Type::DynamicType()));
+        Type::ZoneHandle(Z, Type::DynamicType()));
     current_block_->scope->AddVariable(stack_trace_var);
   }
 
@@ -6017,7 +6026,7 @@
 RawFunction* Parser::OpenAsyncFunction(intptr_t async_func_pos) {
   TRACE_PARSER("OpenAsyncFunction");
   AddAsyncClosureVariables();
-  Function& closure = Function::Handle(I);
+  Function& closure = Function::Handle(Z);
   bool is_new_closure = false;
 
   // Check whether a function for the asynchronous function body of
@@ -6024,7 +6033,7 @@
   // this async function has already been created by a previous
   // compilation of this function.
   const Function& found_func = Function::Handle(
-      I, current_class().LookupClosureFunction(async_func_pos));
+      Z, current_class().LookupClosureFunction(async_func_pos));
   if (!found_func.IsNull() &&
       (found_func.token_pos() == async_func_pos) &&
       (found_func.script() == innermost_function().script()) &&
@@ -6034,11 +6043,11 @@
   } else {
     // Create the closure containing the body of this async function.
     const String& async_func_name =
-        String::Handle(I, innermost_function().name());
-    String& closure_name = String::Handle(I,
+        String::Handle(Z, innermost_function().name());
+    String& closure_name = String::Handle(Z,
         String::NewFormatted("<%s_async_body>", async_func_name.ToCString()));
     closure = Function::NewClosureFunction(
-        String::Handle(I, Symbols::New(closure_name)),
+        String::Handle(Z, Symbols::New(closure_name)),
         innermost_function(),
         async_func_pos);
     closure.set_is_async_closure(true);
@@ -6047,7 +6056,7 @@
   }
   // Create the parameter list for the async body closure.
   ParamList closure_params;
-  const Type& dynamic_type = Type::ZoneHandle(I, Type::DynamicType());
+  const Type& dynamic_type = Type::ZoneHandle(Z, Type::DynamicType());
   closure_params.AddFinalParameter(
       async_func_pos, &Symbols::ClosureParameter(), &dynamic_type);
   ParamDesc result_param;
@@ -6068,8 +6077,8 @@
     AddFormalParamsToFunction(&closure_params, closure);
 
     // Create and set the signature class of the closure.
-    const String& sig = String::Handle(I, closure.Signature());
-    Class& sig_cls = Class::Handle(I, library_.LookupLocalClass(sig));
+    const String& sig = String::Handle(Z, closure.Signature());
+    Class& sig_cls = Class::Handle(Z, library_.LookupLocalClass(sig));
     if (sig_cls.IsNull()) {
       sig_cls =
           Class::NewSignatureClass(sig, closure, script_, closure.token_pos());
@@ -6076,12 +6085,12 @@
       library_.AddClass(sig_cls);
     }
     closure.set_signature_class(sig_cls);
-    const Type& sig_type = Type::Handle(I, sig_cls.SignatureType());
+    const Type& sig_type = Type::Handle(Z, sig_cls.SignatureType());
     if (!sig_type.IsFinalized()) {
       ClassFinalizer::FinalizeType(
           sig_cls, sig_type, ClassFinalizer::kCanonicalize);
     }
-    ASSERT(AbstractType::Handle(I, closure.result_type()).IsResolved());
+    ASSERT(AbstractType::Handle(Z, closure.result_type()).IsResolved());
     ASSERT(closure.NumParameters() == closure_params.parameters->length());
   }
   OpenFunctionBlock(closure);
@@ -6098,23 +6107,23 @@
   //   var :await_ctx_var;
   //   var :async_op;
   //   var :async_completer;
-  const Type& dynamic_type = Type::ZoneHandle(I, Type::DynamicType());
-  LocalVariable* await_jump_var = new (I) LocalVariable(
+  const Type& dynamic_type = Type::ZoneHandle(Z, Type::DynamicType());
+  LocalVariable* await_jump_var = new (Z) LocalVariable(
       Scanner::kNoSourcePos, Symbols::AwaitJumpVar(), dynamic_type);
   current_block_->scope->AddVariable(await_jump_var);
   current_block_->scope->CaptureVariable(Symbols::AwaitJumpVar());
   await_jump_var->set_is_captured();
-  LocalVariable* await_ctx_var = new (I) LocalVariable(
+  LocalVariable* await_ctx_var = new (Z) LocalVariable(
       Scanner::kNoSourcePos, Symbols::AwaitContextVar(), dynamic_type);
   current_block_->scope->AddVariable(await_ctx_var);
   current_block_->scope->CaptureVariable(Symbols::AwaitContextVar());
   await_ctx_var->set_is_captured();
-  LocalVariable* async_op_var = new (I) LocalVariable(
+  LocalVariable* async_op_var = new (Z) LocalVariable(
       Scanner::kNoSourcePos, Symbols::AsyncOperation(), dynamic_type);
   current_block_->scope->AddVariable(async_op_var);
   current_block_->scope->CaptureVariable(Symbols::AsyncOperation());
   async_op_var->set_is_captured();
-  LocalVariable* async_completer = new (I) LocalVariable(
+  LocalVariable* async_completer = new (Z) LocalVariable(
       Scanner::kNoSourcePos, Symbols::AsyncCompleter(), dynamic_type);
   current_block_->scope->AddVariable(async_completer);
   current_block_->scope->CaptureVariable(Symbols::AsyncCompleter());
@@ -6135,13 +6144,13 @@
 }
 
 
-static inline String& BuildAsyncSavedTryContextName(Isolate* isolate,
+static inline String& BuildAsyncSavedTryContextName(Zone* zone,
                                                     int16_t id) {
   const char* async_saved_prefix = ":async_saved_try_ctx_var_";
   // Can be a regular handle since we only use it to build an actual symbol.
-  const String& cnt_str = String::Handle(
+  const String& cnt_str = String::Handle(zone,
       String::NewFormatted("%s%d", async_saved_prefix, id));
-  return String::ZoneHandle(isolate, Symbols::New(cnt_str));
+  return String::ZoneHandle(zone, Symbols::New(cnt_str));
 }
 
 
@@ -6165,15 +6174,15 @@
   // been captured in the corresponding scope as the body has been parsed within
   // a nested block (contained in the async funtion's block).
   const Class& future =
-      Class::ZoneHandle(I, I->object_store()->future_class());
+      Class::ZoneHandle(Z, I->object_store()->future_class());
   ASSERT(!future.IsNull());
-  const Function& constructor = Function::ZoneHandle(I,
+  const Function& constructor = Function::ZoneHandle(Z,
       future.LookupFunction(Symbols::FutureMicrotask()));
   ASSERT(!constructor.IsNull());
   const Class& completer =
-      Class::ZoneHandle(I, I->object_store()->completer_class());
+      Class::ZoneHandle(Z, I->object_store()->completer_class());
   ASSERT(!completer.IsNull());
-  const Function& completer_constructor = Function::ZoneHandle(I,
+  const Function& completer_constructor = Function::ZoneHandle(Z,
       completer.LookupFunction(Symbols::CompleterConstructor()));
   ASSERT(!completer_constructor.IsNull());
 
@@ -6183,13 +6192,13 @@
   // Add to AST:
   //   :async_completer = new Completer();
   ArgumentListNode* empty_args =
-      new (I) ArgumentListNode(Scanner::kNoSourcePos);
-  ConstructorCallNode* completer_constructor_node = new (I) ConstructorCallNode(
+      new (Z) ArgumentListNode(Scanner::kNoSourcePos);
+  ConstructorCallNode* completer_constructor_node = new (Z) ConstructorCallNode(
       Scanner::kNoSourcePos,
-      TypeArguments::ZoneHandle(I),
+      TypeArguments::ZoneHandle(Z),
       completer_constructor,
       empty_args);
-  StoreLocalNode* store_completer = new (I) StoreLocalNode(
+  StoreLocalNode* store_completer = new (Z) StoreLocalNode(
       Scanner::kNoSourcePos,
       async_completer,
       completer_constructor_node);
@@ -6199,17 +6208,17 @@
   LocalVariable* jump_var = current_block_->scope->LookupVariable(
         Symbols::AwaitJumpVar(), false);
   LiteralNode* init_value =
-    new(I) LiteralNode(Scanner::kNoSourcePos, Smi::ZoneHandle(Smi::New(-1)));
+    new(Z) LiteralNode(Scanner::kNoSourcePos, Smi::ZoneHandle(Smi::New(-1)));
   current_block_->statements->Add(
-      new (I) StoreLocalNode(Scanner::kNoSourcePos, jump_var, init_value));
+      new (Z) StoreLocalNode(Scanner::kNoSourcePos, jump_var, init_value));
 
   // Add to AST:
   //   :async_op = <closure>;  (containing the original body)
   LocalVariable* async_op_var = current_block_->scope->LookupVariable(
       Symbols::AsyncOperation(), false);
-  ClosureNode* cn = new(I) ClosureNode(
+  ClosureNode* cn = new(Z) ClosureNode(
       Scanner::kNoSourcePos, closure, NULL, closure_body->scope());
-  StoreLocalNode* store_async_op = new (I) StoreLocalNode(
+  StoreLocalNode* store_async_op = new (Z) StoreLocalNode(
       Scanner::kNoSourcePos,
       async_op_var,
       cn);
@@ -6217,21 +6226,21 @@
 
   // Add to AST:
   //   new Future(:async_op);
-  ArgumentListNode* arguments = new (I) ArgumentListNode(Scanner::kNoSourcePos);
-  arguments->Add(new (I) LoadLocalNode(
+  ArgumentListNode* arguments = new (Z) ArgumentListNode(Scanner::kNoSourcePos);
+  arguments->Add(new (Z) LoadLocalNode(
       Scanner::kNoSourcePos, async_op_var));
-  ConstructorCallNode* future_node = new (I) ConstructorCallNode(
-      Scanner::kNoSourcePos, TypeArguments::ZoneHandle(I), constructor,
+  ConstructorCallNode* future_node = new (Z) ConstructorCallNode(
+      Scanner::kNoSourcePos, TypeArguments::ZoneHandle(Z), constructor,
       arguments);
   current_block_->statements->Add(future_node);
 
   // Add to AST:
   //   return :async_completer.future;
-  ReturnNode* return_node = new (I) ReturnNode(
+  ReturnNode* return_node = new (Z) ReturnNode(
       Scanner::kNoSourcePos,
-      new (I) InstanceGetterNode(
+      new (Z) InstanceGetterNode(
           Scanner::kNoSourcePos,
-          new (I) LoadLocalNode(
+          new (Z) LoadLocalNode(
               Scanner::kNoSourcePos,
               async_completer),
           Symbols::CompleterFuture()));
@@ -6317,7 +6326,7 @@
     ParamDesc& param_desc = (*params->parameters)[i];
     ASSERT(!is_top_level_ || param_desc.type->IsResolved());
     const String* name = param_desc.name;
-    LocalVariable* parameter = new(I) LocalVariable(
+    LocalVariable* parameter = new(Z) LocalVariable(
         param_desc.name_pos, *name, *param_desc.type);
     if (!scope->InsertParameterAt(i, parameter)) {
       ReportError(param_desc.name_pos,
@@ -6340,8 +6349,8 @@
                                       const Function& func) {
   ASSERT(func.is_native());
   TRACE_PARSER("ParseNativeFunctionBlock");
-  const Class& cls = Class::Handle(I, func.Owner());
-  const Library& library = Library::Handle(I, cls.library());
+  const Class& cls = Class::Handle(Z, func.Owner());
+  const Library& library = Library::Handle(Z, cls.library());
   ASSERT(func.NumParameters() == params->parameters->length());
 
   // Parse the function name out.
@@ -6363,11 +6372,11 @@
   // 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(I) ReturnNode(
+  current_block_->statements->Add(new(Z) ReturnNode(
       TokenPos(),
-      new(I) NativeBodyNode(
+      new(Z) NativeBodyNode(
           TokenPos(),
-          Function::ZoneHandle(I, func.raw()),
+          Function::ZoneHandle(Z, func.raw()),
           native_name,
           native_function,
           current_block_->scope,
@@ -6417,7 +6426,7 @@
   if (receiver == NULL) {
     ReportError(token_pos, "illegal implicit access to receiver 'this'");
   }
-  return new(I) LoadLocalNode(TokenPos(), receiver);
+  return new(Z) LoadLocalNode(TokenPos(), receiver);
 }
 
 
@@ -6424,7 +6433,7 @@
 AstNode* Parser::CallGetter(intptr_t token_pos,
                             AstNode* object,
                             const String& name) {
-  return new(I) InstanceGetterNode(token_pos, object, name);
+  return new(Z) InstanceGetterNode(token_pos, object, name);
 }
 
 
@@ -6437,7 +6446,7 @@
   ASSERT(IsIdentifier());
   const intptr_t ident_pos = TokenPos();
   const String& ident = *CurrentLiteral();
-  LocalVariable* variable = new(I) LocalVariable(
+  LocalVariable* variable = new(Z) LocalVariable(
       ident_pos, ident, type);
   ConsumeToken();  // Variable identifier.
   AstNode* initialization = NULL;
@@ -6447,7 +6456,7 @@
     ConsumeToken();
     AstNode* expr = ParseAwaitableExpr(
         is_const, kConsumeCascades, await_preamble);
-    initialization = new(I) StoreLocalNode(
+    initialization = new(Z) StoreLocalNode(
         assign_pos, variable, expr);
     if (is_const) {
       ASSERT(expr->IsLiteralNode());
@@ -6458,9 +6467,9 @@
                 "missing initialization of 'final' or 'const' variable");
   } else {
     // Initialize variable with null.
-    AstNode* null_expr = new(I) LiteralNode(
-        ident_pos, Instance::ZoneHandle(I));
-    initialization = new(I) StoreLocalNode(
+    AstNode* null_expr = new(Z) LiteralNode(
+        ident_pos, Instance::ZoneHandle(Z));
+    initialization = new(Z) StoreLocalNode(
         ident_pos, variable, null_expr);
   }
 
@@ -6552,7 +6561,7 @@
   SkipMetadata();
   bool is_final = (CurrentToken() == Token::kFINAL);
   bool is_const = (CurrentToken() == Token::kCONST);
-  const AbstractType& type = AbstractType::ZoneHandle(I,
+  const AbstractType& type = AbstractType::ZoneHandle(Z,
       ParseConstFinalVarOrType(FLAG_enable_type_checks ?
           ClassFinalizer::kCanonicalize : ClassFinalizer::kIgnore));
   if (!IsIdentifier()) {
@@ -6592,7 +6601,7 @@
 
 AstNode* Parser::ParseFunctionStatement(bool is_literal) {
   TRACE_PARSER("ParseFunctionStatement");
-  AbstractType& result_type = AbstractType::Handle(I);
+  AbstractType& result_type = AbstractType::Handle(Z);
   const String* variable_name = NULL;
   const String* function_name = NULL;
 
@@ -6636,7 +6645,7 @@
   // 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(I);
+  Function& function = Function::ZoneHandle(Z);
   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
@@ -6659,7 +6668,7 @@
   // passed as a function argument, or returned as a function result.
 
   LocalVariable* function_variable = NULL;
-  Type& function_type = Type::ZoneHandle(I);
+  Type& function_type = Type::ZoneHandle(Z);
   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
@@ -6666,15 +6675,15 @@
     // 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(I,
-        Type::Handle(I, Type::Function()).type_class());
+    const Class& unknown_signature_class = Class::Handle(Z,
+        Type::Handle(Z, Type::Function()).type_class());
     function_type = Type::New(unknown_signature_class,
-                              TypeArguments::Handle(I), function_pos);
+                              TypeArguments::Handle(Z), function_pos);
     function_type.SetIsFinalized();  // No finalization needed.
 
     // Add the function variable to the scope before parsing the function in
     // order to allow self reference from inside the function.
-    function_variable = new(I) LocalVariable(function_pos,
+    function_variable = new(Z) LocalVariable(function_pos,
                                              *variable_name,
                                              function_type);
     function_variable->set_is_final();
@@ -6698,7 +6707,7 @@
   }
 
   // Parse the local function.
-  Array& default_parameter_values = Array::Handle(I);
+  Array& default_parameter_values = Array::Handle(Z);
   SequenceNode* statements = Parser::ParseFunc(function,
                                                &default_parameter_values);
 
@@ -6705,8 +6714,8 @@
   // 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(I, function.Signature());
-  Class& signature_class = Class::ZoneHandle(I);
+  const String& signature = String::Handle(Z, function.Signature());
+  Class& signature_class = Class::ZoneHandle(Z);
   if (!is_new_closure) {
     signature_class = function.signature_class();
   }
@@ -6741,9 +6750,9 @@
 
   // Since the signature type is cached by the signature class, it may have
   // been finalized already.
-  Type& signature_type = Type::Handle(I,
+  Type& signature_type = Type::Handle(Z,
                                       signature_class.SignatureType());
-  TypeArguments& signature_type_arguments = TypeArguments::Handle(I,
+  TypeArguments& signature_type_arguments = TypeArguments::Handle(Z,
       signature_type.arguments());
 
   if (!signature_type.IsFinalized()) {
@@ -6799,7 +6808,7 @@
   // variables are not relevant for the compilation of the enclosing function.
   // This pruning is done by omitting to hook the local scope in its parent
   // scope in the constructor of LocalScope.
-  AstNode* closure = new(I) ClosureNode(
+  AstNode* closure = new(Z) ClosureNode(
       function_pos, function, NULL, statements->scope());
 
   if (function_variable == NULL) {
@@ -6806,7 +6815,7 @@
     ASSERT(is_literal);
     return closure;
   } else {
-    AstNode* initialization = new(I) StoreLocalNode(
+    AstNode* initialization = new(Z) StoreLocalNode(
         function_pos, function_variable, closure);
     return initialization;
   }
@@ -7215,7 +7224,7 @@
     ConsumeToken();
     false_branch = ParseNestedStatement(parsing_loop_body, NULL);
   }
-  AstNode* if_node = new(I) IfNode(
+  AstNode* if_node = new(Z) IfNode(
       if_pos, cond_expr, true_branch, false_branch);
   if (label != NULL) {
     current_block_->statements->Add(if_node);
@@ -7287,9 +7296,9 @@
     }
   }
   if (first_value.IsInteger()) {
-    return Type::Handle(I, Type::IntType()).type_class();
+    return Type::Handle(Z, Type::IntType()).type_class();
   } else if (first_value.IsString()) {
-    return Type::Handle(I, Type::StringType()).type_class();
+    return Type::Handle(Z, Type::StringType()).type_class();
   }
   return first_value.clazz();
 }
@@ -7302,7 +7311,7 @@
   bool default_seen = false;
   const intptr_t case_pos = TokenPos();
   // The case expressions node sequence does not own the enclosing scope.
-  SequenceNode* case_expressions = new(I) SequenceNode(case_pos, NULL);
+  SequenceNode* case_expressions = new(Z) SequenceNode(case_pos, NULL);
   while (CurrentToken() == Token::kCASE || CurrentToken() == Token::kDEFAULT) {
     if (CurrentToken() == Token::kCASE) {
       if (default_seen) {
@@ -7314,9 +7323,9 @@
       ASSERT(expr->IsLiteralNode());
       case_expr_values->Add(expr->AsLiteralNode());
 
-      AstNode* switch_expr_load = new(I) LoadLocalNode(
+      AstNode* switch_expr_load = new(Z) LoadLocalNode(
           case_pos, switch_expr_value);
-      AstNode* case_comparison = new(I) ComparisonNode(
+      AstNode* case_comparison = new(Z) ComparisonNode(
           expr_pos, Token::kEQ, expr, switch_expr_load);
       case_expressions->Add(case_comparison);
     } else {
@@ -7350,9 +7359,9 @@
       // 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(I) ArgumentListNode(TokenPos());
-        arguments->Add(new(I) LiteralNode(
-            TokenPos(), Integer::ZoneHandle(I, Integer::New(TokenPos()))));
+        ArgumentListNode* arguments = new(Z) ArgumentListNode(TokenPos());
+        arguments->Add(new(Z) LiteralNode(
+            TokenPos(), Integer::ZoneHandle(Z, Integer::New(TokenPos()))));
         current_block_->statements->Add(
             MakeStaticCall(Symbols::FallThroughError(),
                            Library::PrivateCoreLibName(Symbols::ThrowNew()),
@@ -7368,7 +7377,7 @@
     }
   }
   SequenceNode* statements = CloseBlock();
-  return new(I) CaseNode(case_pos, case_label,
+  return new(Z) CaseNode(case_pos, case_label,
       case_expressions, default_seen, switch_expr_value, statements);
 }
 
@@ -7394,15 +7403,15 @@
   // 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(I,
-       Type::New(Class::Handle(I, Object::dynamic_class()),
-                 TypeArguments::Handle(I),
+  const Type& temp_var_type = Type::ZoneHandle(Z,
+       Type::New(Class::Handle(Z, Object::dynamic_class()),
+                 TypeArguments::Handle(Z),
                  expr_pos));
   temp_var_type.SetIsFinalized();
-  LocalVariable* temp_variable = new(I) LocalVariable(
+  LocalVariable* temp_variable = new(Z) LocalVariable(
       expr_pos,  Symbols::SwitchExpr(), temp_var_type);
   current_block_->scope->AddVariable(temp_variable);
-  AstNode* save_switch_expr = new(I) StoreLocalNode(
+  AstNode* save_switch_expr = new(Z) StoreLocalNode(
       expr_pos, temp_variable, switch_expr);
   current_block_->statements->Add(save_switch_expr);
 
@@ -7421,7 +7430,7 @@
       case_label = current_block_->scope->LocalLookupLabel(*label_name);
       if (case_label == NULL) {
         // Label does not exist yet. Add it to scope of switch statement.
-        case_label = new(I) SourceLabel(
+        case_label = new(Z) SourceLabel(
             label_pos, *label_name, SourceLabel::kCase);
         current_block_->scope->AddLabel(case_label);
       } else if (case_label->kind() == SourceLabel::kForward) {
@@ -7457,7 +7466,7 @@
   // variable holding the switch expression to match the type of the
   // case clause constants.
   temp_var_type.set_type_class(
-      Class::Handle(I, CheckCaseExpressions(case_expr_values)));
+      Class::Handle(Z, CheckCaseExpressions(case_expr_values)));
 
   // Check for unresolved label references.
   SourceLabel* unresolved_label =
@@ -7469,7 +7478,7 @@
 
   SequenceNode* switch_body = CloseBlock();
   ExpectToken(Token::kRBRACE);
-  return new(I) SwitchNode(switch_pos, label, switch_body);
+  return new(Z) SwitchNode(switch_pos, label, switch_body);
 }
 
 
@@ -7486,7 +7495,7 @@
   ExpectToken(Token::kRPAREN);
   const bool parsing_loop_body =  true;
   SequenceNode* while_body = ParseNestedStatement(parsing_loop_body, label);
-  WhileNode* while_node = new (I) WhileNode(while_pos,
+  WhileNode* while_node = new (Z) WhileNode(while_pos,
                                             label,
                                             cond_expr,
                                             await_preamble,
@@ -7515,7 +7524,7 @@
   }
   ExpectToken(Token::kRPAREN);
   ExpectSemicolon();
-  return new(I) DoWhileNode(do_pos, label, cond_expr, dowhile_body);
+  return new(Z) DoWhileNode(do_pos, label, cond_expr, dowhile_body);
 }
 
 
@@ -7534,7 +7543,7 @@
     ReportError("Loop variable cannot be 'const'");
   }
   bool new_loop_var = false;
-  AbstractType& loop_var_type =  AbstractType::ZoneHandle(I);
+  AbstractType& loop_var_type =  AbstractType::ZoneHandle(Z);
   if (LookaheadToken(1) != Token::kIN) {
     // Declaration of a new loop variable.
     // Delay creation of the local variable until we know its actual
@@ -7559,36 +7568,36 @@
   // Build creation of implicit StreamIterator.
   // var :for-in-iter = new StreamIterator(stream_expr).
   const Class& stream_iterator_cls =
-      Class::ZoneHandle(I, I->object_store()->stream_iterator_class());
+      Class::ZoneHandle(Z, I->object_store()->stream_iterator_class());
   ASSERT(!stream_iterator_cls.IsNull());
   const Function& iterator_ctor =
-      Function::ZoneHandle(I, stream_iterator_cls.LookupFunction(
+      Function::ZoneHandle(Z, stream_iterator_cls.LookupFunction(
           Symbols::StreamIteratorConstructor()));
   ASSERT(!iterator_ctor.IsNull());
-  ArgumentListNode* ctor_args = new (I) ArgumentListNode(Scanner::kNoSourcePos);
+  ArgumentListNode* ctor_args = new (Z) ArgumentListNode(Scanner::kNoSourcePos);
   ctor_args->Add(stream_expr);
   ConstructorCallNode* ctor_call =
-      new (I) ConstructorCallNode(Scanner::kNoSourcePos,
-                              TypeArguments::ZoneHandle(I),
+      new (Z) ConstructorCallNode(Scanner::kNoSourcePos,
+                              TypeArguments::ZoneHandle(Z),
                               iterator_ctor,
                               ctor_args);
-  const AbstractType& iterator_type = Type::ZoneHandle(I, Type::DynamicType());
-  LocalVariable* iterator_var = new(I) LocalVariable(
+  const AbstractType& iterator_type = Type::ZoneHandle(Z, Type::DynamicType());
+  LocalVariable* iterator_var = new(Z) LocalVariable(
       stream_pos, Symbols::ForInIter(), iterator_type);
   current_block_->scope->AddVariable(iterator_var);
   AstNode* iterator_init =
-      new(I) StoreLocalNode(stream_pos, iterator_var, ctor_call);
+      new(Z) StoreLocalNode(stream_pos, iterator_var, ctor_call);
   current_block_->statements->Add(iterator_init);
 
   // Build while loop condition.
   // while (await :for-in-iter.moveNext())
-  ArgumentListNode* no_args = new(I) ArgumentListNode(stream_pos);
-  AstNode* iterator_moveNext = new(I) InstanceCallNode(
+  ArgumentListNode* no_args = new(Z) ArgumentListNode(stream_pos);
+  AstNode* iterator_moveNext = new(Z) InstanceCallNode(
       stream_pos,
-      new(I) LoadLocalNode(stream_pos, iterator_var),
+      new(Z) LoadLocalNode(stream_pos, iterator_var),
                            Symbols::MoveNext(),
                            no_args);
-  AstNode* await_moveNext = new (I) AwaitNode(stream_pos, iterator_moveNext);
+  AstNode* await_moveNext = new (Z) AwaitNode(stream_pos, iterator_moveNext);
   OpenBlock();
   AwaitTransformer at(current_block_->statements,
                       parsed_function(),
@@ -7606,9 +7615,9 @@
   current_block_->scope->AddLabel(label);
   const intptr_t loop_var_assignment_pos = TokenPos();
 
-  AstNode* iterator_current = new(I) InstanceGetterNode(
+  AstNode* iterator_current = new(Z) InstanceGetterNode(
       loop_var_assignment_pos,
-      new(I) LoadLocalNode(loop_var_assignment_pos, iterator_var),
+      new(Z) LoadLocalNode(loop_var_assignment_pos, iterator_var),
       Symbols::Current());
 
   // Generate assignment of next iterator value to loop variable.
@@ -7619,7 +7628,7 @@
     // Note that the variable token position needs to be inside the
     // loop block, so it gets put in the loop context level.
     LocalVariable* loop_var =
-        new(I) LocalVariable(loop_var_assignment_pos,
+        new(Z) LocalVariable(loop_var_assignment_pos,
                              *loop_var_name,
                              loop_var_type);;
     if (loop_var_is_final) {
@@ -7626,7 +7635,7 @@
       loop_var->set_is_final();
     }
     current_block_->scope->AddVariable(loop_var);
-    loop_var_assignment = new(I) StoreLocalNode(
+    loop_var_assignment = new(Z) StoreLocalNode(
         loop_var_assignment_pos, loop_var, iterator_current);
   } else {
     AstNode* loop_var_primary =
@@ -7653,7 +7662,7 @@
   }
   SequenceNode* for_loop_statement = CloseBlock();
 
-  WhileNode* while_node = new (I) WhileNode(await_for_pos,
+  WhileNode* while_node = new (Z) WhileNode(await_for_pos,
                                             label,
                                             transformed_await,
                                             await_preamble,
@@ -7674,7 +7683,7 @@
   const String* loop_var_name = NULL;
   intptr_t loop_var_pos = 0;
   bool new_loop_var = false;
-  AbstractType& loop_var_type =  AbstractType::ZoneHandle(I);
+  AbstractType& loop_var_type =  AbstractType::ZoneHandle(Z);
   if (LookaheadToken(1) == Token::kIN) {
     loop_var_pos = TokenPos();
     loop_var_name = ExpectIdentifier("variable name expected");
@@ -7702,23 +7711,23 @@
   // 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(I, Type::DynamicType());
-  LocalVariable* iterator_var = new(I) LocalVariable(
+  const AbstractType& iterator_type = Type::ZoneHandle(Z, Type::DynamicType());
+  LocalVariable* iterator_var = new(Z) LocalVariable(
       collection_pos, Symbols::ForInIter(), iterator_type);
   current_block_->scope->AddVariable(iterator_var);
 
   // Generate initialization of iterator variable.
-  ArgumentListNode* no_args = new(I) ArgumentListNode(collection_pos);
-  AstNode* get_iterator = new(I) InstanceGetterNode(
+  ArgumentListNode* no_args = new(Z) ArgumentListNode(collection_pos);
+  AstNode* get_iterator = new(Z) InstanceGetterNode(
       collection_pos, collection_expr, Symbols::GetIterator());
   AstNode* iterator_init =
-      new(I) StoreLocalNode(collection_pos, iterator_var, get_iterator);
+      new(Z) StoreLocalNode(collection_pos, iterator_var, get_iterator);
   current_block_->statements->Add(iterator_init);
 
   // Generate while loop condition.
-  AstNode* iterator_moveNext = new(I) InstanceCallNode(
+  AstNode* iterator_moveNext = new(Z) InstanceCallNode(
       collection_pos,
-      new(I) LoadLocalNode(collection_pos, iterator_var),
+      new(Z) LoadLocalNode(collection_pos, iterator_var),
       Symbols::MoveNext(),
       no_args);
 
@@ -7730,9 +7739,9 @@
   current_block_->scope->AddLabel(label);
   const intptr_t loop_var_assignment_pos = TokenPos();
 
-  AstNode* iterator_current = new(I) InstanceGetterNode(
+  AstNode* iterator_current = new(Z) InstanceGetterNode(
       loop_var_assignment_pos,
-      new(I) LoadLocalNode(loop_var_assignment_pos, iterator_var),
+      new(Z) LoadLocalNode(loop_var_assignment_pos, iterator_var),
       Symbols::Current());
 
   // Generate assignment of next iterator value to loop variable.
@@ -7741,7 +7750,7 @@
     // The for loop variable is new for each iteration.
     // Create a variable and add it to the loop body scope.
     LocalVariable* loop_var =
-       new(I) LocalVariable(loop_var_assignment_pos,
+       new(Z) LocalVariable(loop_var_assignment_pos,
                             *loop_var_name,
                             loop_var_type);;
     if (loop_var_is_final) {
@@ -7748,7 +7757,7 @@
       loop_var->set_is_final();
     }
     current_block_->scope->AddVariable(loop_var);
-    loop_var_assignment = new(I) StoreLocalNode(
+    loop_var_assignment = new(Z) StoreLocalNode(
         loop_var_assignment_pos, loop_var, iterator_current);
   } else {
     AstNode* loop_var_primary =
@@ -7776,7 +7785,7 @@
 
   SequenceNode* for_loop_statement = CloseBlock();
 
-  AstNode* while_statement = new(I) WhileNode(
+  AstNode* while_statement = new(Z) WhileNode(
       forin_pos, label, iterator_moveNext, NULL, for_loop_statement);
   current_block_->statements->Add(while_statement);
 
@@ -7830,8 +7839,8 @@
   for (int i = 0; i < init_scope->num_variables(); i++) {
     if (init_scope->VariableAt(i)->is_captured() &&
         (init_scope->VariableAt(i)->owner() == init_scope)) {
-      SequenceNode* incr_sequence = new(I) SequenceNode(incr_pos, NULL);
-      incr_sequence->Add(new(I) CloneContextNode(for_pos));
+      SequenceNode* incr_sequence = new(Z) SequenceNode(incr_pos, NULL);
+      incr_sequence->Add(new(Z) CloneContextNode(for_pos));
       if (increment != NULL) {
         incr_sequence->Add(increment);
       }
@@ -7839,7 +7848,7 @@
       break;
     }
   }
-  AstNode* for_node = new(I) ForNode(
+  AstNode* for_node = new(Z) ForNode(
       for_pos,
       label,
       NodeAsSequenceNode(init_pos, initializer, NULL),
@@ -7856,24 +7865,24 @@
 AstNode* Parser::MakeStaticCall(const String& cls_name,
                                 const String& func_name,
                                 ArgumentListNode* arguments) {
-  const Class& cls = Class::Handle(I, Library::LookupCoreClass(cls_name));
+  const Class& cls = Class::Handle(Z, Library::LookupCoreClass(cls_name));
   ASSERT(!cls.IsNull());
-  const Function& func = Function::ZoneHandle(I,
+  const Function& func = Function::ZoneHandle(Z,
       Resolver::ResolveStatic(cls,
                               func_name,
                               arguments->length(),
                               arguments->names()));
   ASSERT(!func.IsNull());
-  return new(I) StaticCallNode(arguments->token_pos(), func, arguments);
+  return new(Z) StaticCallNode(arguments->token_pos(), func, arguments);
 }
 
 
 AstNode* Parser::MakeAssertCall(intptr_t begin, intptr_t end) {
-  ArgumentListNode* arguments = new(I) ArgumentListNode(begin);
-  arguments->Add(new(I) LiteralNode(begin,
-      Integer::ZoneHandle(I, Integer::New(begin))));
-  arguments->Add(new(I) LiteralNode(end,
-      Integer::ZoneHandle(I, Integer::New(end))));
+  ArgumentListNode* arguments = new(Z) ArgumentListNode(begin);
+  arguments->Add(new(Z) LiteralNode(begin,
+      Integer::ZoneHandle(Z, Integer::New(begin))));
+  arguments->Add(new(Z) LiteralNode(end,
+      Integer::ZoneHandle(Z, Integer::New(end))));
   return MakeStaticCall(Symbols::AssertionError(),
                         Library::PrivateCoreLibName(Symbols::ThrowNew()),
                         arguments);
@@ -7888,7 +7897,7 @@
     const intptr_t pos = condition->token_pos();
     condition = BuildClosureCall(pos,
                                  condition,
-                                 new(I) ArgumentListNode(pos));
+                                 new(Z) ArgumentListNode(pos));
   } else if (condition->IsConditionalExprNode()) {
     ConditionalExprNode* cond_expr = condition->AsConditionalExprNode();
     cond_expr->set_true_expr(InsertClosureCallNodes(cond_expr->true_expr()));
@@ -7912,9 +7921,9 @@
   const intptr_t condition_end = TokenPos();
   ExpectToken(Token::kRPAREN);
   condition = InsertClosureCallNodes(condition);
-  condition = new(I) UnaryOpNode(condition_pos, Token::kNOT, condition);
+  condition = new(Z) UnaryOpNode(condition_pos, Token::kNOT, condition);
   AstNode* assert_throw = MakeAssertCall(condition_pos, condition_end);
-  return new(I) IfNode(
+  return new(Z) IfNode(
       condition_pos,
       condition,
       NodeAsSequenceNode(condition_pos, assert_throw, NULL),
@@ -7927,7 +7936,7 @@
                                    CatchParamDesc* stack_trace_param,
                                    LocalScope* scope) {
   if (exception_param->name != NULL) {
-    LocalVariable* var = new(I) LocalVariable(
+    LocalVariable* var = new(Z) LocalVariable(
         exception_param->token_pos,
         *exception_param->name,
         *exception_param->type);
@@ -7937,7 +7946,7 @@
     exception_param->var = var;
   }
   if (stack_trace_param->name != NULL) {
-    LocalVariable* var = new(I) LocalVariable(
+    LocalVariable* var = new(Z) LocalVariable(
         stack_trace_param->token_pos,
         *stack_trace_param->name,
         *stack_trace_param->type);
@@ -7981,7 +7990,7 @@
 
 void Parser::PushTryBlock(Block* try_block) {
   intptr_t try_index = AllocateTryIndex();
-  TryBlocks* block = new(I) TryBlocks(
+  TryBlocks* block = new(Z) TryBlocks(
       try_block, try_blocks_list_, try_index);
   try_blocks_list_ = block;
 }
@@ -8059,10 +8068,10 @@
     CatchParamDesc stack_trace_param;
     if (IsLiteral("on")) {
       ConsumeToken();
-      exception_param.type = &AbstractType::ZoneHandle(I,
+      exception_param.type = &AbstractType::ZoneHandle(Z,
           ParseType(ClassFinalizer::kCanonicalize));
     } else {
-      exception_param.type = &AbstractType::ZoneHandle(I, Type::DynamicType());
+      exception_param.type = &AbstractType::ZoneHandle(Z, Type::DynamicType());
     }
     if (CurrentToken() == Token::kCATCH) {
       ConsumeToken();  // Consume the 'catch'.
@@ -8073,7 +8082,7 @@
         ConsumeToken();
         // TODO(hausner): Make implicit type be StackTrace, not dynamic.
         stack_trace_param.type =
-            &AbstractType::ZoneHandle(I, Type::DynamicType());
+            &AbstractType::ZoneHandle(Z, Type::DynamicType());
         stack_trace_param.token_pos = TokenPos();
         stack_trace_param.name = ExpectIdentifier("identifier expected");
       }
@@ -8093,8 +8102,8 @@
       // Generate code to load the exception object (:exception_var) into
       // the exception variable specified in this block.
       ASSERT(exception_var != NULL);
-      current_block_->statements->Add(new(I) StoreLocalNode(
-          catch_pos, exception_param.var, new(I) LoadLocalNode(
+      current_block_->statements->Add(new(Z) StoreLocalNode(
+          catch_pos, exception_param.var, new(Z) LoadLocalNode(
               catch_pos, exception_var)));
     }
     if (stack_trace_param.var != NULL) {
@@ -8102,14 +8111,14 @@
       // to load the stack trace object (:stack_trace_var) into the stack
       // trace variable specified in this block.
       *needs_stack_trace = true;
-      ArgumentListNode* no_args = new(I) ArgumentListNode(catch_pos);
+      ArgumentListNode* no_args = new(Z) ArgumentListNode(catch_pos);
       ASSERT(stack_trace_var != NULL);
-      current_block_->statements->Add(new(I) StoreLocalNode(
-          catch_pos, stack_trace_param.var, new(I) LoadLocalNode(
+      current_block_->statements->Add(new(Z) StoreLocalNode(
+          catch_pos, stack_trace_param.var, new(Z) LoadLocalNode(
               catch_pos, stack_trace_var)));
-      current_block_->statements->Add(new(I) InstanceCallNode(
+      current_block_->statements->Add(new(Z) InstanceCallNode(
           catch_pos,
-          new(I) LoadLocalNode(catch_pos, stack_trace_param.var),
+          new(Z) LoadLocalNode(catch_pos, stack_trace_param.var),
           Library::PrivateCoreLibName(Symbols::_setupFullStackTrace()),
           no_args));
     }
@@ -8149,10 +8158,10 @@
       // In the first case, unconditionally execute the catch body.  In the
       // second case, unconditionally throw.
       generic_catch_seen = true;
-      type_tests.Add(new(I) LiteralNode(catch_pos, Bool::True()));
+      type_tests.Add(new(Z) LiteralNode(catch_pos, Bool::True()));
       if (is_bad_type) {
         // Replace the body with one that throws.
-        SequenceNode* block = new(I) SequenceNode(catch_pos, NULL);
+        SequenceNode* block = new(Z) SequenceNode(catch_pos, NULL);
         block->Add(ThrowTypeError(catch_pos, *exception_param.type));
         catch_blocks.Last() = block;
       }
@@ -8168,14 +8177,14 @@
         // Make sure that the instantiator is captured.
         CaptureInstantiator();
       }
-      TypeNode* exception_type = new(I) TypeNode(
+      TypeNode* exception_type = new(Z) TypeNode(
           catch_pos, *exception_param.type);
-      AstNode* exception_value = new(I) LoadLocalNode(
+      AstNode* exception_value = new(Z) LoadLocalNode(
           catch_pos, exception_var);
       if (!exception_type->type().IsInstantiated()) {
         EnsureExpressionTemp();
       }
-      type_tests.Add(new(I) ComparisonNode(
+      type_tests.Add(new(Z) ComparisonNode(
           catch_pos, Token::kIS, exception_value, exception_type));
 
       // Do not add uninstantiated types (e.g. type parameter T or generic
@@ -8203,11 +8212,11 @@
     // There isn't a generic catch clause so create a clause body that
     // rethrows the exception.  This includes the case that there were no
     // catch clauses.
-    current = new(I) SequenceNode(handler_pos, NULL);
-    current->Add(new(I) ThrowNode(
+    current = new(Z) SequenceNode(handler_pos, NULL);
+    current->Add(new(Z) ThrowNode(
         handler_pos,
-        new(I) LoadLocalNode(handler_pos, exception_var),
-        new(I) LoadLocalNode(handler_pos, stack_trace_var)));
+        new(Z) LoadLocalNode(handler_pos, exception_var),
+        new(Z) LoadLocalNode(handler_pos, stack_trace_var)));
   } else if (type_tests.Last()->IsLiteralNode()) {
     ASSERT(type_tests.Last()->AsLiteralNode()->literal().raw() ==
            Bool::True().raw());
@@ -8246,7 +8255,7 @@
       }
     }
 
-    current_block_->statements->Add(new(I) IfNode(
+    current_block_->statements->Add(new(Z) IfNode(
         type_test->token_pos(), type_test, catch_block, current));
     current = CloseBlock();
   }
@@ -8256,11 +8265,11 @@
 
 void Parser::SetupSavedTryContext(LocalVariable* saved_try_context) {
   const String& async_saved_try_ctx_name =
-      BuildAsyncSavedTryContextName(I, last_used_try_index_ - 1);
-  LocalVariable* async_saved_try_ctx = new (I) LocalVariable(
+      BuildAsyncSavedTryContextName(Z, last_used_try_index_ - 1);
+  LocalVariable* async_saved_try_ctx = new (Z) LocalVariable(
       Scanner::kNoSourcePos,
       async_saved_try_ctx_name,
-      Type::ZoneHandle(I, Type::DynamicType()));
+      Type::ZoneHandle(Z, Type::DynamicType()));
   async_temp_scope_->AddVariable(async_saved_try_ctx);
   async_saved_try_ctx->set_is_captured();
   async_saved_try_ctx = current_block_->scope->LookupVariable(
@@ -8267,8 +8276,8 @@
       async_saved_try_ctx_name, false);
   ASSERT(async_saved_try_ctx != NULL);
   ASSERT(saved_try_context != NULL);
-  current_block_->statements->Add(new (I) StoreLocalNode(
-      Scanner::kNoSourcePos, async_saved_try_ctx, new (I) LoadLocalNode(
+  current_block_->statements->Add(new (Z) StoreLocalNode(
+      Scanner::kNoSourcePos, async_saved_try_ctx, new (Z) LoadLocalNode(
           Scanner::kNoSourcePos, saved_try_context)));
   parsed_function()->set_saved_try_ctx(saved_try_context);
   parsed_function()->set_async_saved_try_ctx_name(async_saved_try_ctx_name);
@@ -8289,15 +8298,15 @@
       Symbols::SavedTryContextVar(), false);
   ASSERT((saved_try_ctx != NULL) && !saved_try_ctx->is_captured());
   const String& async_saved_try_ctx_name =
-      BuildAsyncSavedTryContextName(I, try_index);
+      BuildAsyncSavedTryContextName(Z, try_index);
   LocalVariable* async_saved_try_ctx =
       target->scope()->LookupVariable(async_saved_try_ctx_name, false);
   ASSERT(async_saved_try_ctx != NULL);
   ASSERT(async_saved_try_ctx->is_captured());
-  target->Add(new (I) StoreLocalNode(
+  target->Add(new (Z) StoreLocalNode(
       Scanner::kNoSourcePos,
       saved_try_ctx,
-      new (I) LoadLocalNode(Scanner::kNoSourcePos, async_saved_try_ctx)));
+      new (Z) LoadLocalNode(Scanner::kNoSourcePos, async_saved_try_ctx)));
 
   parsed_function()->set_saved_try_ctx(saved_try_ctx);
   parsed_function()->set_async_saved_try_ctx_name(async_saved_try_ctx_name);
@@ -8323,28 +8332,28 @@
   LocalVariable* context_var =
       current_block_->scope->LocalLookupVariable(Symbols::SavedTryContextVar());
   if (context_var == NULL) {
-    context_var = new(I) LocalVariable(
+    context_var = new(Z) LocalVariable(
         TokenPos(),
         Symbols::SavedTryContextVar(),
-        Type::ZoneHandle(I, Type::DynamicType()));
+        Type::ZoneHandle(Z, Type::DynamicType()));
     current_block_->scope->AddVariable(context_var);
   }
   LocalVariable* exception_var =
       current_block_->scope->LocalLookupVariable(Symbols::ExceptionVar());
   if (exception_var == NULL) {
-    exception_var = new(I) LocalVariable(
+    exception_var = new(Z) LocalVariable(
         TokenPos(),
         Symbols::ExceptionVar(),
-        Type::ZoneHandle(I, Type::DynamicType()));
+        Type::ZoneHandle(Z, 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(I) LocalVariable(
+    stack_trace_var = new(Z) LocalVariable(
         TokenPos(),
         Symbols::StackTraceVar(),
-        Type::ZoneHandle(I, Type::DynamicType()));
+        Type::ZoneHandle(Z, Type::DynamicType()));
     current_block_->scope->AddVariable(stack_trace_var);
   }
 
@@ -8381,7 +8390,7 @@
   try_blocks_list_->enter_catch();
   const intptr_t handler_pos = TokenPos();
   const GrowableObjectArray& handler_types =
-      GrowableObjectArray::Handle(I, GrowableObjectArray::New());
+      GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
   bool needs_stack_trace = false;
   SequenceNode* catch_handler_list =
       ParseCatchClauses(handler_pos, exception_var, stack_trace_var,
@@ -8405,7 +8414,7 @@
         inner_try_block->GetNodeToInlineFinally(node_index);
     while (node_to_inline != NULL) {
       finally_block = ParseFinallyBlock();
-      InlinedFinallyNode* node = new(I) InlinedFinallyNode(finally_pos,
+      InlinedFinallyNode* node = new(Z) InlinedFinallyNode(finally_pos,
                                                            finally_block,
                                                            context_var,
                                                            outer_try_index);
@@ -8417,10 +8426,10 @@
     finally_block = ParseFinallyBlock();
   }
 
-  CatchClauseNode* catch_clause = new(I) CatchClauseNode(
+  CatchClauseNode* catch_clause = new(Z) CatchClauseNode(
       handler_pos,
       catch_handler_list,
-      Array::ZoneHandle(I, Array::MakeArray(handler_types)),
+      Array::ZoneHandle(Z, Array::MakeArray(handler_types)),
       context_var,
       exception_var,
       stack_trace_var,
@@ -8431,7 +8440,7 @@
   // 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.
-  AstNode* try_catch_node = new(I) TryCatchNode(
+  AstNode* try_catch_node = new(Z) TryCatchNode(
       try_pos, try_block, context_var, catch_clause, finally_block, try_index);
 
   if (try_label != NULL) {
@@ -8474,7 +8483,7 @@
       LocalScope* switch_scope = current_block_->scope->LookupSwitchScope();
       if (switch_scope != NULL) {
         // We found a switch scope. Enter a forward reference to the label.
-        target = new(I) SourceLabel(
+        target = new(Z) SourceLabel(
             TokenPos(), target_name, SourceLabel::kForward);
         switch_scope->AddLabel(target);
       }
@@ -8504,7 +8513,7 @@
     ReportError(jump_pos, "'%s' target must be in same function context",
                 Token::Str(jump_kind));
   }
-  return new(I) JumpNode(jump_pos, jump_kind, target);
+  return new(Z) JumpNode(jump_pos, jump_kind, target);
 }
 
 
@@ -8548,9 +8557,9 @@
                     "return of a value not allowed in constructors");
       }
       AstNode* expr = ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
-      statement = new(I) ReturnNode(statement_pos, expr);
+      statement = new(Z) ReturnNode(statement_pos, expr);
     } else {
-      statement = new(I) ReturnNode(statement_pos);
+      statement = new(Z) ReturnNode(statement_pos);
     }
     AddNodeForFinallyInlining(statement);
     ExpectSemicolon();
@@ -8607,10 +8616,10 @@
     LocalVariable* trace_var =
         scope->LocalLookupVariable(Symbols::StackTraceVar());
     ASSERT(trace_var != NULL);
-    statement = new(I) ThrowNode(
+    statement = new(Z) ThrowNode(
         statement_pos,
-        new(I) LoadLocalNode(statement_pos, excp_var),
-        new(I) LoadLocalNode(statement_pos, trace_var));
+        new(Z) LoadLocalNode(statement_pos, excp_var),
+        new(Z) LoadLocalNode(statement_pos, trace_var));
   } else {
     statement = ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
     ExpectSemicolon();
@@ -8766,20 +8775,20 @@
 
 
 AstNode* Parser::ThrowTypeError(intptr_t type_pos, const AbstractType& type) {
-  ArgumentListNode* arguments = new(I) ArgumentListNode(type_pos);
+  ArgumentListNode* arguments = new(Z) ArgumentListNode(type_pos);
   // Location argument.
-  arguments->Add(new(I) LiteralNode(
-      type_pos, Integer::ZoneHandle(I, Integer::New(type_pos))));
+  arguments->Add(new(Z) LiteralNode(
+      type_pos, Integer::ZoneHandle(Z, Integer::New(type_pos))));
   // Src value argument.
-  arguments->Add(new(I) LiteralNode(type_pos, Instance::ZoneHandle(I)));
+  arguments->Add(new(Z) LiteralNode(type_pos, Instance::ZoneHandle(Z)));
   // Dst type name argument.
-  arguments->Add(new(I) LiteralNode(type_pos, Symbols::Malformed()));
+  arguments->Add(new(Z) LiteralNode(type_pos, Symbols::Malformed()));
   // Dst name argument.
-  arguments->Add(new(I) LiteralNode(type_pos, Symbols::Empty()));
+  arguments->Add(new(Z) LiteralNode(type_pos, Symbols::Empty()));
   // Malformed type error or malbounded type error.
-  const Error& error = Error::Handle(I, type.error());
+  const Error& error = Error::Handle(Z, type.error());
   ASSERT(!error.IsNull());
-  arguments->Add(new(I) LiteralNode(type_pos, String::ZoneHandle(I,
+  arguments->Add(new(Z) LiteralNode(type_pos, String::ZoneHandle(Z,
       Symbols::New(error.ToErrorCString()))));
   return MakeStaticCall(Symbols::TypeError(),
                         Library::PrivateCoreLibName(Symbols::ThrowNew()),
@@ -8794,7 +8803,7 @@
                                         InvocationMirror::Call im_call,
                                         InvocationMirror::Type im_type,
                                         const Function* func) {
-  ArgumentListNode* arguments = new(I) ArgumentListNode(call_pos);
+  ArgumentListNode* arguments = new(Z) ArgumentListNode(call_pos);
   // Object receiver.
   // If the function is external and dynamic, pass the actual receiver,
   // otherwise, pass a class literal of the unresolved method's owner.
@@ -8802,15 +8811,15 @@
       func->is_external() && !func->is_static()) {
     arguments->Add(LoadReceiver(func->token_pos()));
   } else {
-    Type& type = Type::ZoneHandle(I,
-        Type::New(cls, TypeArguments::Handle(I), call_pos, Heap::kOld));
+    Type& type = Type::ZoneHandle(Z,
+        Type::New(cls, TypeArguments::Handle(Z), call_pos, Heap::kOld));
     type ^= ClassFinalizer::FinalizeType(
         current_class(), type, ClassFinalizer::kCanonicalize);
-    arguments->Add(new(I) LiteralNode(call_pos, type));
+    arguments->Add(new(Z) LiteralNode(call_pos, type));
   }
   // String memberName.
-  arguments->Add(new(I) LiteralNode(
-      call_pos, String::ZoneHandle(I, Symbols::New(function_name))));
+  arguments->Add(new(Z) LiteralNode(
+      call_pos, String::ZoneHandle(Z, Symbols::New(function_name))));
   // Smi invocation_type.
   if (cls.IsTopLevel()) {
     ASSERT(im_call == InvocationMirror::kStatic ||
@@ -8817,23 +8826,23 @@
            im_call == InvocationMirror::kTopLevel);
     im_call = InvocationMirror::kTopLevel;
   }
-  arguments->Add(new(I) LiteralNode(call_pos, Smi::ZoneHandle(I,
+  arguments->Add(new(Z) LiteralNode(call_pos, Smi::ZoneHandle(Z,
       Smi::New(InvocationMirror::EncodeType(im_call, im_type)))));
   // List arguments.
   if (function_arguments == NULL) {
-    arguments->Add(new(I) LiteralNode(call_pos, Array::ZoneHandle(I)));
+    arguments->Add(new(Z) LiteralNode(call_pos, Array::ZoneHandle(Z)));
   } else {
-    ArrayNode* array = new(I) ArrayNode(
+    ArrayNode* array = new(Z) ArrayNode(
         call_pos,
-        Type::ZoneHandle(I, Type::ArrayType()),
+        Type::ZoneHandle(Z, Type::ArrayType()),
         function_arguments->nodes());
     arguments->Add(array);
   }
   // List argumentNames.
   if (function_arguments == NULL) {
-    arguments->Add(new(I) LiteralNode(call_pos, Array::ZoneHandle(I)));
+    arguments->Add(new(Z) LiteralNode(call_pos, Array::ZoneHandle(Z)));
   } else {
-    arguments->Add(new(I) LiteralNode(call_pos, function_arguments->names()));
+    arguments->Add(new(Z) LiteralNode(call_pos, function_arguments->names()));
   }
 
   // List existingArgumentNames.
@@ -8841,13 +8850,13 @@
   // 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(I);
+  Function& function = Function::Handle(Z);
   if (func != NULL) {
     function = func->raw();
   } else {
     function = cls.LookupStaticFunction(function_name);
   }
-  Array& array = Array::ZoneHandle(I);
+  Array& array = Array::ZoneHandle(Z);
   // An unpatched external function is treated as an unresolved function.
   if (!function.IsNull() && !function.is_external()) {
     // The constructor for NoSuchMethodError takes a list of existing
@@ -8863,9 +8872,9 @@
     // between dart2js and VM. Update the constructor to accept a string
     // describing the formal parameters of an incompatible call target.
     array = Array::New(1, Heap::kOld);
-    array.SetAt(0, String::Handle(I, function.UserVisibleFormalParameters()));
+    array.SetAt(0, String::Handle(Z, function.UserVisibleFormalParameters()));
   }
-  arguments->Add(new(I) LiteralNode(call_pos, array));
+  arguments->Add(new(Z) LiteralNode(call_pos, array));
 
   return MakeStaticCall(Symbols::NoSuchMethodError(),
                         Library::PrivateCoreLibName(Symbols::ThrowNew()),
@@ -8897,7 +8906,7 @@
           op_kind = Token::kISNOT;
         }
         const intptr_t type_pos = TokenPos();
-        const AbstractType& type = AbstractType::ZoneHandle(I,
+        const AbstractType& type = AbstractType::ZoneHandle(Z,
             ParseType(ClassFinalizer::kCanonicalize));
         if (!type.IsInstantiated() &&
             (current_block_->scope->function_level() > 0)) {
@@ -8904,7 +8913,7 @@
           // Make sure that the instantiator is captured.
           CaptureInstantiator();
         }
-        right_operand = new(I) TypeNode(type_pos, type);
+        right_operand = new(Z) 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) ||
@@ -8914,7 +8923,7 @@
           // a type cast even if the tested value is null.
           // We need to evaluate the left operand for potential
           // side effects.
-          LetNode* let = new(I) LetNode(left_operand->token_pos());
+          LetNode* let = new(Z) LetNode(left_operand->token_pos());
           let->AddNode(left_operand);
           let->AddNode(ThrowTypeError(type_pos, type));
           left_operand = let;
@@ -8931,7 +8940,7 @@
             EnsureExpressionTemp();
           }
         }
-        left_operand = new(I) ComparisonNode(
+        left_operand = new(Z) ComparisonNode(
             op_pos, op_kind, left_operand, right_operand);
         break;  // Equality and relational operators cannot be chained.
       } else {
@@ -8956,7 +8965,7 @@
   }
   if (CurrentToken() == Token::kCOMMA) {
     // Collect comma-separated expressions in a non scope owning sequence node.
-    SequenceNode* list = new(I) SequenceNode(TokenPos(), NULL);
+    SequenceNode* list = new(Z) SequenceNode(TokenPos(), NULL);
     list->Add(expressions);
     while (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
@@ -8984,10 +8993,10 @@
                                                const char* s) {
   char name[64];
   OS::SNPrint(name, 64, ":%s%" Pd, s, token_pos);
-  LocalVariable* temp = new(I) LocalVariable(
+  LocalVariable* temp = new(Z) LocalVariable(
       token_pos,
-      String::ZoneHandle(I, Symbols::New(name)),
-      Type::ZoneHandle(I, Type::DynamicType()));
+      String::ZoneHandle(Z, Symbols::New(name)),
+      Type::ZoneHandle(Z, Type::DynamicType()));
   temp->set_is_final();
   current_block_->scope->AddVariable(temp);
   return temp;
@@ -9007,9 +9016,9 @@
       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(I,
+        const Double& dbl_obj = Double::ZoneHandle(Z,
             Double::NewCanonical((left_double / right_double)));
-        return new(I) LiteralNode(op_pos, dbl_obj);
+        return new(Z) LiteralNode(op_pos, dbl_obj);
       }
     }
   }
@@ -9032,7 +9041,7 @@
             (lhs->AsBinaryOpNode()->kind() == Token::kSHL)) {
           // Merge SHL and BIT_AND into one "SHL with mask" node.
           BinaryOpNode* old = lhs->AsBinaryOpNode();
-          BinaryOpWithMask32Node* binop = new(I) BinaryOpWithMask32Node(
+          BinaryOpWithMask32Node* binop = new(Z) BinaryOpWithMask32Node(
               old->token_pos(), old->kind(), old->left(), old->right(), val);
           return binop;
         }
@@ -9039,7 +9048,7 @@
       }
     }
   }
-  return new(I) BinaryOpNode(op_pos, binary_op, lhs, rhs);
+  return new(Z) BinaryOpNode(op_pos, binary_op, lhs, rhs);
 }
 
 
@@ -9052,27 +9061,27 @@
     case Token::kASSIGN:
       return rhs;
     case Token::kASSIGN_ADD:
-      return new(I) BinaryOpNode(op_pos, Token::kADD, lhs, rhs);
+      return new(Z) BinaryOpNode(op_pos, Token::kADD, lhs, rhs);
     case Token::kASSIGN_SUB:
-      return new(I) BinaryOpNode(op_pos, Token::kSUB, lhs, rhs);
+      return new(Z) BinaryOpNode(op_pos, Token::kSUB, lhs, rhs);
     case Token::kASSIGN_MUL:
-      return new(I) BinaryOpNode(op_pos, Token::kMUL, lhs, rhs);
+      return new(Z) BinaryOpNode(op_pos, Token::kMUL, lhs, rhs);
     case Token::kASSIGN_TRUNCDIV:
-      return new(I) BinaryOpNode(op_pos, Token::kTRUNCDIV, lhs, rhs);
+      return new(Z) BinaryOpNode(op_pos, Token::kTRUNCDIV, lhs, rhs);
     case Token::kASSIGN_DIV:
-      return new(I) BinaryOpNode(op_pos, Token::kDIV, lhs, rhs);
+      return new(Z) BinaryOpNode(op_pos, Token::kDIV, lhs, rhs);
     case Token::kASSIGN_MOD:
-      return new(I) BinaryOpNode(op_pos, Token::kMOD, lhs, rhs);
+      return new(Z) BinaryOpNode(op_pos, Token::kMOD, lhs, rhs);
     case Token::kASSIGN_SHR:
-      return new(I) BinaryOpNode(op_pos, Token::kSHR, lhs, rhs);
+      return new(Z) BinaryOpNode(op_pos, Token::kSHR, lhs, rhs);
     case Token::kASSIGN_SHL:
-      return new(I) BinaryOpNode(op_pos, Token::kSHL, lhs, rhs);
+      return new(Z) BinaryOpNode(op_pos, Token::kSHL, lhs, rhs);
     case Token::kASSIGN_OR:
-      return new(I) BinaryOpNode(op_pos, Token::kBIT_OR, lhs, rhs);
+      return new(Z) BinaryOpNode(op_pos, Token::kBIT_OR, lhs, rhs);
     case Token::kASSIGN_AND:
-      return new(I) BinaryOpNode(op_pos, Token::kBIT_AND, lhs, rhs);
+      return new(Z) BinaryOpNode(op_pos, Token::kBIT_AND, lhs, rhs);
     case Token::kASSIGN_XOR:
-      return new(I) BinaryOpNode(op_pos, Token::kBIT_XOR, lhs, rhs);
+      return new(Z) BinaryOpNode(op_pos, Token::kBIT_XOR, lhs, rhs);
     default:
       ReportError(op_pos,
                   "internal error: ExpandAssignableOp '%s' unimplemented",
@@ -9092,7 +9101,7 @@
   if (expr->EvalConstExpr() == NULL) {
     ReportError(expr_pos, "expression is not a valid compile-time constant");
   }
-  return new(I) LiteralNode(
+  return new(Z) LiteralNode(
       expr_pos, EvaluateConstExpr(expr_pos, expr));
 }
 
@@ -9100,7 +9109,7 @@
 LetNode* Parser::PrepareCompoundAssignmentNodes(AstNode** expr) {
   AstNode* node = *expr;
   intptr_t token_pos = node->token_pos();
-  LetNode* result = new(I) LetNode(token_pos);
+  LetNode* result = new(Z) LetNode(token_pos);
   if (node->IsLoadIndexedNode()) {
     LoadIndexedNode* load_indexed = node->AsLoadIndexedNode();
     AstNode* array = load_indexed->array();
@@ -9107,14 +9116,14 @@
     AstNode* index = load_indexed->index_expr();
     if (!IsSimpleLocalOrLiteralNode(load_indexed->array())) {
       LocalVariable* t0 = result->AddInitializer(load_indexed->array());
-      array = new(I) LoadLocalNode(token_pos, t0);
+      array = new(Z) LoadLocalNode(token_pos, t0);
     }
     if (!IsSimpleLocalOrLiteralNode(load_indexed->index_expr())) {
       LocalVariable* t1 = result->AddInitializer(
           load_indexed->index_expr());
-      index = new(I) LoadLocalNode(token_pos, t1);
+      index = new(Z) LoadLocalNode(token_pos, t1);
     }
-    *expr = new(I) LoadIndexedNode(token_pos,
+    *expr = new(Z) LoadIndexedNode(token_pos,
                                    array,
                                    index,
                                    load_indexed->super_class());
@@ -9125,9 +9134,9 @@
     AstNode* receiver = getter->receiver();
     if (!IsSimpleLocalOrLiteralNode(getter->receiver())) {
       LocalVariable* t0 = result->AddInitializer(getter->receiver());
-      receiver = new(I) LoadLocalNode(token_pos, t0);
+      receiver = new(Z) LoadLocalNode(token_pos, t0);
     }
-    *expr = new(I) InstanceGetterNode(
+    *expr = new(Z) InstanceGetterNode(
         token_pos, receiver, getter->field_name());
     return result;
   }
@@ -9163,13 +9172,13 @@
                                       intptr_t left_pos) {
   AstNode* result = original->MakeAssignmentNode(rhs);
   if (result == NULL) {
-    String& name = String::ZoneHandle(I);
+    String& name = String::ZoneHandle(Z);
     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(I,
+      target_cls = &Class::Handle(Z,
           original->AsLoadStaticFieldNode()->field().owner());
     } else if ((left_ident != NULL) &&
                (original->IsLiteralNode() ||
@@ -9182,7 +9191,7 @@
     result = ThrowNoSuchMethodError(
         original->token_pos(),
         *target_cls,
-        String::Handle(I, Field::SetterName(name)),
+        String::Handle(Z, Field::SetterName(name)),
         NULL,  // No arguments.
         InvocationMirror::kStatic,
         original->IsLoadLocalNode() ?
@@ -9202,12 +9211,12 @@
 
 AstNode* Parser::ParseCascades(AstNode* expr) {
   intptr_t cascade_pos = TokenPos();
-  LetNode* cascade = new(I) LetNode(cascade_pos);
+  LetNode* cascade = new(Z) LetNode(cascade_pos);
   LocalVariable* cascade_receiver_var = cascade->AddInitializer(expr);
   while (CurrentToken() == Token::kCASCADE) {
     cascade_pos = TokenPos();
     LoadLocalNode* load_cascade_receiver =
-        new(I) LoadLocalNode(cascade_pos, cascade_receiver_var);
+        new(Z) LoadLocalNode(cascade_pos, cascade_receiver_var);
     if (Token::IsIdentifier(LookaheadToken(1))) {
       // Replace .. with . for ParseSelectors().
       token_kind_ = Token::kPERIOD;
@@ -9252,20 +9261,20 @@
   }
   // 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(I) LoadLocalNode(cascade_pos, cascade_receiver_var));
+  cascade->AddNode(new(Z) LoadLocalNode(cascade_pos, cascade_receiver_var));
   return cascade;
 }
 
 
 // Convert loading of a static const field into a literal node.
-static AstNode* LiteralIfStaticConst(Isolate* iso, AstNode* expr) {
+static AstNode* LiteralIfStaticConst(Zone* zone, 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(iso) LiteralNode(expr->token_pos(),
-                             Instance::ZoneHandle(iso, field.value()));
+      return new(zone) LiteralNode(expr->token_pos(),
+                                   Instance::ZoneHandle(zone, field.value()));
     }
   }
   return expr;
@@ -9316,7 +9325,7 @@
       ReportError("expression expected after throw");
     }
     AstNode* expr = ParseExpr(require_compiletime_const, consume_cascades);
-    return new(I) ThrowNode(expr_pos, expr, NULL);
+    return new(Z) ThrowNode(expr_pos, expr, NULL);
   }
   AstNode* expr = ParseConditionalExpr();
   if (!Token::IsAssignmentOperator(CurrentToken())) {
@@ -9326,7 +9335,7 @@
     if (require_compiletime_const) {
       expr = FoldConstExpr(expr_pos, expr);
     } else {
-      expr = LiteralIfStaticConst(I, expr);
+      expr = LiteralIfStaticConst(Z, expr);
     }
     return expr;
   }
@@ -9354,7 +9363,7 @@
     let_expr->AddNode(assign_expr);
     return let_expr;
   } else {
-    AstNode* assigned_value = LiteralIfStaticConst(I, right_expr);
+    AstNode* assigned_value = LiteralIfStaticConst(Z, right_expr);
     AstNode* assign_expr =
         CreateAssignmentNode(expr, assigned_value, expr_ident, expr_pos);
     ASSERT(assign_expr != NULL);
@@ -9384,7 +9393,7 @@
     AstNode* expr1 = ParseExpr(kAllowConst, kNoCascades);
     ExpectToken(Token::kCOLON);
     AstNode* expr2 = ParseExpr(kAllowConst, kNoCascades);
-    expr = new(I) ConditionalExprNode(expr_pos, expr, expr1, expr2);
+    expr = new(Z) ConditionalExprNode(expr_pos, expr, expr1, expr2);
   }
   return expr;
 }
@@ -9398,7 +9407,7 @@
     TRACE_PARSER("ParseAwaitExpr");
     ConsumeToken();
     parsed_function()->record_await();
-    expr = new (I) AwaitNode(TokenPos(), ParseUnaryExpr());
+    expr = new (Z) AwaitNode(TokenPos(), ParseUnaryExpr());
   } else if (IsPrefixOperator(CurrentToken())) {
     Token::Kind unary_op = CurrentToken();
     if (unary_op == Token::kSUB) {
@@ -9425,11 +9434,11 @@
     LetNode* let_expr = PrepareCompoundAssignmentNodes(&expr);
     Token::Kind binary_op =
         (incr_op == Token::kINCR) ? Token::kADD : Token::kSUB;
-    BinaryOpNode* add = new(I) BinaryOpNode(
+    BinaryOpNode* add = new(Z) BinaryOpNode(
         op_pos,
         binary_op,
         expr,
-        new(I) LiteralNode(op_pos, Smi::ZoneHandle(I, Smi::New(1))));
+        new(Z) LiteralNode(op_pos, Smi::ZoneHandle(Z, Smi::New(1))));
     AstNode* store = CreateAssignmentNode(expr, add, expr_ident, expr_pos);
     ASSERT(store != NULL);
     let_expr->AddNode(store);
@@ -9449,15 +9458,15 @@
   const bool saved_mode = SetAllowFunctionLiterals(true);
   ArgumentListNode* arguments;
   if (implicit_arguments == NULL) {
-    arguments = new(I) ArgumentListNode(TokenPos());
+    arguments = new(Z) ArgumentListNode(TokenPos());
   } else {
     arguments = implicit_arguments;
   }
-  const GrowableObjectArray& names = GrowableObjectArray::Handle(I,
+  const GrowableObjectArray& names = GrowableObjectArray::Handle(Z,
       GrowableObjectArray::New(Heap::kOld));
   bool named_argument_seen = false;
   if (LookaheadToken(1) != Token::kRPAREN) {
-    String& arg_name = String::Handle(I);
+    String& arg_name = String::Handle(Z);
     do {
       ASSERT((CurrentToken() == Token::kLPAREN) ||
              (CurrentToken() == Token::kCOMMA));
@@ -9488,7 +9497,7 @@
   ExpectToken(Token::kRPAREN);
   SetAllowFunctionLiterals(saved_mode);
   if (named_argument_seen) {
-    arguments->set_names(Array::Handle(I, Array::MakeArray(names)));
+    arguments->set_names(Array::Handle(Z, Array::MakeArray(names)));
   }
   return arguments;
 }
@@ -9502,7 +9511,7 @@
   ASSERT(CurrentToken() == Token::kLPAREN);
   ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
   const int num_arguments = arguments->length();
-  const Function& func = Function::ZoneHandle(I,
+  const Function& func = Function::ZoneHandle(Z,
       Resolver::ResolveStatic(cls,
                               func_name,
                               num_arguments,
@@ -9511,12 +9520,12 @@
     // 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(I, cls.LookupStaticField(func_name));
-    Function& func = Function::ZoneHandle(I);
+    const Field& field = Field::ZoneHandle(Z, cls.LookupStaticField(func_name));
+    Function& func = Function::ZoneHandle(Z);
     if (field.IsNull()) {
       // No field, check if we have an explicit getter function.
       const String& getter_name =
-          String::ZoneHandle(I, Field::GetterName(func_name));
+          String::ZoneHandle(Z, Field::GetterName(func_name));
       const int kNumArguments = 0;  // no arguments.
       func = Resolver::ResolveStatic(cls,
                                      getter_name,
@@ -9524,11 +9533,11 @@
                                      Object::empty_array());
       if (!func.IsNull()) {
         ASSERT(func.kind() != RawFunction::kImplicitStaticFinalGetter);
-        closure = new(I) StaticGetterNode(
+        closure = new(Z) StaticGetterNode(
             call_pos,
             NULL,
             false,
-            Class::ZoneHandle(I, cls.raw()),
+            Class::ZoneHandle(Z, cls.raw()),
             func_name);
         return BuildClosureCall(call_pos, closure, arguments);
       }
@@ -9553,13 +9562,13 @@
     // source.
     if (!FLAG_warn_on_javascript_compatibility || is_patch_source()) {
       ASSERT(num_arguments == 2);
-      return new(I) ComparisonNode(ident_pos,
+      return new(Z) ComparisonNode(ident_pos,
                                    Token::kEQ_STRICT,
                                    arguments->NodeAt(0),
                                    arguments->NodeAt(1));
     }
   }
-  return new(I) StaticCallNode(call_pos, func, arguments);
+  return new(Z) StaticCallNode(call_pos, func, arguments);
 }
 
 
@@ -9568,7 +9577,7 @@
   const intptr_t call_pos = TokenPos();
   CheckToken(Token::kLPAREN);
   ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
-  return new(I) InstanceCallNode(call_pos, receiver, func_name, arguments);
+  return new(Z) InstanceCallNode(call_pos, receiver, func_name, arguments);
 }
 
 
@@ -9593,18 +9602,18 @@
   }
   // The field is initialized.
   ASSERT(field.is_static());
-  const Class& field_owner = Class::ZoneHandle(I, field.owner());
-  const String& field_name = String::ZoneHandle(I, field.name());
-  const String& getter_name = String::Handle(I, Field::GetterName(field_name));
-  const Function& getter = Function::Handle(I,
+  const Class& field_owner = Class::ZoneHandle(Z, field.owner());
+  const String& field_name = String::ZoneHandle(Z, field.name());
+  const String& getter_name = String::Handle(Z, Field::GetterName(field_name));
+  const Function& getter = Function::Handle(Z,
       field_owner.LookupStaticFunction(getter_name));
   // Never load field directly if there is a getter (deterministic AST).
   if (getter.IsNull() || field.is_const()) {
-    return new(I) LoadStaticFieldNode(
-        ident_pos, Field::ZoneHandle(I, field.raw()));
+    return new(Z) LoadStaticFieldNode(
+        ident_pos, Field::ZoneHandle(Z, field.raw()));
   } else {
     ASSERT(getter.kind() == RawFunction::kImplicitStaticFinalGetter);
-    return new(I) StaticGetterNode(ident_pos,
+    return new(Z) StaticGetterNode(ident_pos,
                                    NULL,  // Receiver.
                                    false,  // is_super_getter.
                                    field_owner,
@@ -9619,12 +9628,12 @@
                                         bool consume_cascades) {
   TRACE_PARSER("ParseStaticFieldAccess");
   AstNode* access = NULL;
-  const Field& field = Field::ZoneHandle(I, cls.LookupStaticField(field_name));
-  Function& func = Function::ZoneHandle(I);
+  const Field& field = Field::ZoneHandle(Z, cls.LookupStaticField(field_name));
+  Function& func = Function::ZoneHandle(Z);
   if (field.IsNull()) {
     // No field, check if we have an explicit getter function.
     const String& getter_name =
-        String::ZoneHandle(I, Field::GetterName(field_name));
+        String::ZoneHandle(Z, Field::GetterName(field_name));
     const int kNumArguments = 0;  // no arguments.
     func = Resolver::ResolveStatic(cls,
                                    getter_name,
@@ -9642,16 +9651,16 @@
         // Create a getter call, which may later be turned into
         // a setter call, or else the backend will generate
         // a throw NoSuchMethodError().
-        access = new(I) StaticGetterNode(ident_pos,
+        access = new(Z) StaticGetterNode(ident_pos,
                                          NULL,
                                          false,
-                                         Class::ZoneHandle(I, cls.raw()),
+                                         Class::ZoneHandle(Z, cls.raw()),
                                          field_name);
       }
     } else {
       ASSERT(func.kind() != RawFunction::kImplicitStaticFinalGetter);
-      access = new(I) StaticGetterNode(
-          ident_pos, NULL, false, Class::ZoneHandle(I, cls.raw()), field_name);
+      access = new(Z) StaticGetterNode(
+          ident_pos, NULL, false, Class::ZoneHandle(Z, cls.raw()), field_name);
     }
   } else {
     access = GenerateStaticFieldLookup(field, ident_pos);
@@ -9676,11 +9685,11 @@
     String& name = String::CheckedZoneHandle(primary->primary().raw());
     if (current_function().is_static() ||
         current_function().IsInFactoryScope()) {
-      StaticGetterNode* getter = new(I) StaticGetterNode(
+      StaticGetterNode* getter = new(Z) StaticGetterNode(
           primary->token_pos(),
           NULL,  // No receiver.
           false,  // Not a super getter.
-          Class::ZoneHandle(I, current_class().raw()),
+          Class::ZoneHandle(Z, current_class().raw()),
           name);
       getter->set_is_deferred(primary->is_deferred_reference());
       return getter;
@@ -9697,7 +9706,7 @@
   ASSERT(primary->primary().IsFunction());
   const Function& func =
       Function::CheckedZoneHandle(primary->primary().raw());
-  const String& funcname = String::ZoneHandle(I, func.name());
+  const String& funcname = String::ZoneHandle(Z, func.name());
   if (func.is_static()) {
     // Static function access.
     ClosureNode* closure =
@@ -9733,7 +9742,7 @@
           left = LoadClosure(primary_node);
         } else if (primary_node->primary().IsTypeParameter()) {
           if (current_function().is_static()) {
-            const String& name = String::ZoneHandle(I,
+            const String& name = String::ZoneHandle(Z,
                 TypeParameter::Cast(primary_node->primary()).name());
             ReportError(primary_pos,
                         "cannot access type parameter '%s' "
@@ -9744,13 +9753,13 @@
             // Make sure that the instantiator is captured.
             CaptureInstantiator();
           }
-          TypeParameter& type_parameter = TypeParameter::ZoneHandle(I);
+          TypeParameter& type_parameter = TypeParameter::ZoneHandle(Z);
           type_parameter ^= ClassFinalizer::FinalizeType(
               current_class(),
               TypeParameter::Cast(primary_node->primary()),
               ClassFinalizer::kCanonicalize);
           ASSERT(!type_parameter.IsMalformed());
-          left = new(I) TypeNode(primary->token_pos(), type_parameter);
+          left = new(Z) TypeNode(primary->token_pos(), type_parameter);
         } else {
           // Super field access handled in ParseSuperFieldAccess(),
           // super calls handled in ParseSuperCall().
@@ -9772,7 +9781,7 @@
         }
       } else {
         // Field access.
-        Class& cls = Class::Handle(I);
+        Class& cls = Class::Handle(Z);
         if (left->IsPrimaryNode()) {
           PrimaryNode* primary_node = left->AsPrimaryNode();
           if (primary_node->primary().IsClass()) {
@@ -9809,17 +9818,17 @@
           array = LoadClosure(primary_node);
         } else if (primary_node->primary().IsClass()) {
           const Class& type_class = Class::Cast(primary_node->primary());
-          AbstractType& type = Type::ZoneHandle(I,
-              Type::New(type_class, TypeArguments::Handle(I),
+          AbstractType& type = Type::ZoneHandle(Z,
+              Type::New(type_class, TypeArguments::Handle(Z),
                         primary_pos, Heap::kOld));
           type ^= ClassFinalizer::FinalizeType(
               current_class(), type, ClassFinalizer::kCanonicalize);
           // Type may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
-          array = new(I) TypeNode(primary_pos, type);
+          array = new(Z) TypeNode(primary_pos, type);
         } else if (primary_node->primary().IsTypeParameter()) {
           if (current_function().is_static()) {
-            const String& name = String::ZoneHandle(I,
+            const String& name = String::ZoneHandle(Z,
                 TypeParameter::Cast(primary_node->primary()).name());
             ReportError(primary_pos,
                         "cannot access type parameter '%s' "
@@ -9830,19 +9839,19 @@
             // Make sure that the instantiator is captured.
             CaptureInstantiator();
           }
-          TypeParameter& type_parameter = TypeParameter::ZoneHandle(I);
+          TypeParameter& type_parameter = TypeParameter::ZoneHandle(Z);
           type_parameter ^= ClassFinalizer::FinalizeType(
               current_class(),
               TypeParameter::Cast(primary_node->primary()),
               ClassFinalizer::kCanonicalize);
           ASSERT(!type_parameter.IsMalformed());
-          array = new(I) TypeNode(primary_pos, type_parameter);
+          array = new(Z) TypeNode(primary_pos, type_parameter);
         } else {
           UNREACHABLE();  // Internal parser error.
         }
       }
-      selector =  new(I) LoadIndexedNode(
-          bracket_pos, array, index, Class::ZoneHandle(I));
+      selector =  new(Z) LoadIndexedNode(
+          bracket_pos, array, index, Class::ZoneHandle(Z));
     } else if (CurrentToken() == Token::kLPAREN) {
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary_node = left->AsPrimaryNode();
@@ -9849,10 +9858,10 @@
         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(I, func.name());
+          const String& func_name = String::ZoneHandle(Z, func.name());
           if (func.is_static()) {
             // Parse static function call.
-            Class& cls = Class::Handle(I, func.Owner());
+            Class& cls = Class::Handle(Z, func.Owner());
             selector = ParseStaticCall(cls, func_name, primary_pos);
           } else {
             // Dynamic function call on implicit "this" parameter.
@@ -9884,7 +9893,7 @@
             selector = ParseInstanceCall(LoadReceiver(primary_pos), name);
           }
         } else if (primary_node->primary().IsTypeParameter()) {
-          const String& name = String::ZoneHandle(I,
+          const String& name = String::ZoneHandle(Z,
               TypeParameter::Cast(primary_node->primary()).name());
           if (current_function().is_static()) {
             // Treat as this.T(), because T is in scope.
@@ -9898,13 +9907,13 @@
           }
         } else if (primary_node->primary().IsClass()) {
           const Class& type_class = Class::Cast(primary_node->primary());
-          AbstractType& type = Type::ZoneHandle(I, Type::New(
-              type_class, TypeArguments::Handle(I), primary_pos));
+          AbstractType& type = Type::ZoneHandle(Z, Type::New(
+              type_class, TypeArguments::Handle(Z), primary_pos));
           type ^= ClassFinalizer::FinalizeType(
               current_class(), type, ClassFinalizer::kCanonicalize);
           // Type may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
-          selector = new(I) TypeNode(primary_pos, type);
+          selector = new(Z) TypeNode(primary_pos, type);
         } else {
           UNREACHABLE();  // Internal parser error.
         }
@@ -9924,16 +9933,16 @@
           left = LoadClosure(primary_node);
         } else if (primary_node->primary().IsClass()) {
           const Class& type_class = Class::Cast(primary_node->primary());
-          AbstractType& type = Type::ZoneHandle(I, Type::New(
-              type_class, TypeArguments::Handle(I), primary_pos));
+          AbstractType& type = Type::ZoneHandle(Z, Type::New(
+              type_class, TypeArguments::Handle(Z), primary_pos));
           type = ClassFinalizer::FinalizeType(
               current_class(), type, ClassFinalizer::kCanonicalize);
           // Type may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
-          left = new(I) TypeNode(primary_pos, type);
+          left = new(Z) TypeNode(primary_pos, type);
         } else if (primary_node->primary().IsTypeParameter()) {
           if (current_function().is_static()) {
-            const String& name = String::ZoneHandle(I,
+            const String& name = String::ZoneHandle(Z,
                 TypeParameter::Cast(primary_node->primary()).name());
             ReportError(primary_pos,
                         "cannot access type parameter '%s' "
@@ -9944,13 +9953,13 @@
             // Make sure that the instantiator is captured.
             CaptureInstantiator();
           }
-          TypeParameter& type_parameter = TypeParameter::ZoneHandle(I);
+          TypeParameter& type_parameter = TypeParameter::ZoneHandle(Z);
           type_parameter ^= ClassFinalizer::FinalizeType(
               current_class(),
               TypeParameter::Cast(primary_node->primary()),
               ClassFinalizer::kCanonicalize);
           ASSERT(!type_parameter.IsMalformed());
-          left = new(I) TypeNode(primary_pos, type_parameter);
+          left = new(Z) 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.
@@ -9987,17 +9996,17 @@
     LocalVariable* temp = let_expr->AddInitializer(expr);
     Token::Kind binary_op =
         (incr_op == Token::kINCR) ? Token::kADD : Token::kSUB;
-    BinaryOpNode* add = new(I) BinaryOpNode(
+    BinaryOpNode* add = new(Z) BinaryOpNode(
         expr_pos,
         binary_op,
-        new(I) LoadLocalNode(expr_pos, temp),
-        new(I) LiteralNode(expr_pos, Smi::ZoneHandle(I, Smi::New(1))));
+        new(Z) LoadLocalNode(expr_pos, temp),
+        new(Z) LiteralNode(expr_pos, Smi::ZoneHandle(Z, 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(I) LoadLocalNode(expr_pos, temp));
+    let_expr->AddNode(new(Z) LoadLocalNode(expr_pos, temp));
     return let_expr;
   }
   return expr;
@@ -10022,14 +10031,14 @@
   // Resolve class.
   if (!type->HasResolvedTypeClass()) {
     const UnresolvedClass& unresolved_class =
-        UnresolvedClass::Handle(I, type->unresolved_class());
+        UnresolvedClass::Handle(Z, type->unresolved_class());
     const String& unresolved_class_name =
-        String::Handle(I, unresolved_class.ident());
-    Class& resolved_type_class = Class::Handle(I);
+        String::Handle(Z, unresolved_class.ident());
+    Class& resolved_type_class = Class::Handle(Z);
     if (unresolved_class.library_prefix() == LibraryPrefix::null()) {
       if (!scope_class.IsNull()) {
         // First check if the type is a type parameter of the given scope class.
-        const TypeParameter& type_parameter = TypeParameter::Handle(I,
+        const TypeParameter& type_parameter = TypeParameter::Handle(Z,
             scope_class.LookupTypeParameter(unresolved_class_name));
         if (!type_parameter.IsNull()) {
           // A type parameter is considered to be a malformed type when
@@ -10037,23 +10046,23 @@
           if (ParsingStaticMember()) {
             ASSERT(scope_class.raw() == current_class().raw());
             *type = ClassFinalizer::NewFinalizedMalformedType(
-                Error::Handle(I),  // No previous error.
+                Error::Handle(Z),  // No previous error.
                 script_,
                 type->token_pos(),
                 "type parameter '%s' cannot be referenced "
                 "from static member",
-                String::Handle(I, type_parameter.name()).ToCString());
+                String::Handle(Z, type_parameter.name()).ToCString());
             return;
           }
           // A type parameter cannot be parameterized, so make the type
           // malformed if type arguments have previously been parsed.
-          if (!TypeArguments::Handle(I, type->arguments()).IsNull()) {
+          if (!TypeArguments::Handle(Z, type->arguments()).IsNull()) {
             *type = ClassFinalizer::NewFinalizedMalformedType(
-                Error::Handle(I),  // No previous error.
+                Error::Handle(Z),  // No previous error.
                 script_,
                 type_parameter.token_pos(),
                 "type parameter '%s' cannot be parameterized",
-                String::Handle(I, type_parameter.name()).ToCString());
+                String::Handle(Z, type_parameter.name()).ToCString());
             return;
           }
           *type = type_parameter.raw();
@@ -10069,7 +10078,7 @@
       }
     } else {
       LibraryPrefix& lib_prefix =
-          LibraryPrefix::Handle(I, unresolved_class.library_prefix());
+          LibraryPrefix::Handle(Z, unresolved_class.library_prefix());
       // Resolve class name in the scope of the library prefix.
       resolved_type_class =
           ResolveClassInPrefixScope(lib_prefix, unresolved_class_name);
@@ -10081,21 +10090,21 @@
       parameterized_type.set_type_class(resolved_type_class);
     } else if (finalization >= ClassFinalizer::kCanonicalize) {
       ClassFinalizer::FinalizeMalformedType(
-          Error::Handle(I),  // No previous error.
+          Error::Handle(Z),  // No previous error.
           script_,
           parameterized_type,
           "type '%s' is not loaded",
-          String::Handle(I, parameterized_type.UserVisibleName()).ToCString());
+          String::Handle(Z, parameterized_type.UserVisibleName()).ToCString());
       return;
     }
   }
   // Resolve type arguments, if any.
-  const TypeArguments& arguments = TypeArguments::Handle(I, type->arguments());
-      TypeArguments::Handle(I, type->arguments());
+  const TypeArguments& arguments = TypeArguments::Handle(Z, type->arguments());
+      TypeArguments::Handle(Z, type->arguments());
   if (!arguments.IsNull()) {
     const intptr_t num_arguments = arguments.Length();
     for (intptr_t i = 0; i < num_arguments; i++) {
-      AbstractType& type_argument = AbstractType::Handle(I,
+      AbstractType& type_argument = AbstractType::Handle(Z,
                                                          arguments.TypeAt(i));
       ResolveTypeFromClass(scope_class, finalization, &type_argument);
       arguments.SetTypeAt(i, type_argument);
@@ -10140,11 +10149,11 @@
 const AbstractType* Parser::ReceiverType(const Class& cls) {
   ASSERT(!cls.IsNull());
   const TypeArguments& type_arguments = TypeArguments::Handle(
-      I,
+      Z,
       (cls.NumTypeParameters() > 0) ?
           cls.type_parameters() : TypeArguments::null());
   AbstractType& type = AbstractType::ZoneHandle(
-      I, Type::New(cls, type_arguments, cls.token_pos()));
+      Z, Type::New(cls, type_arguments, cls.token_pos()));
   if (cls.is_type_finalized()) {
     type ^= ClassFinalizer::FinalizeType(
         cls, type, ClassFinalizer::kCanonicalizeWellFormed);
@@ -10171,7 +10180,7 @@
   }
   const char* error_str = NULL;
   Instance& result =
-      Instance::Handle(I, instance.CheckAndCanonicalize(&error_str));
+      Instance::Handle(Z, instance.CheckAndCanonicalize(&error_str));
   if (result.IsNull()) {
     ReportError(token_pos, "Invalid const object %s", error_str);
   }
@@ -10185,12 +10194,12 @@
 AstNode* Parser::RunStaticFieldInitializer(const Field& field,
                                            intptr_t field_ref_pos) {
   ASSERT(field.is_static());
-  const Class& field_owner = Class::ZoneHandle(I, field.owner());
-  const String& field_name = String::ZoneHandle(I, field.name());
-  const String& getter_name = String::Handle(I, Field::GetterName(field_name));
-  const Function& getter = Function::Handle(I,
+  const Class& field_owner = Class::ZoneHandle(Z, field.owner());
+  const String& field_name = String::ZoneHandle(Z, field.name());
+  const String& getter_name = String::Handle(Z, Field::GetterName(field_name));
+  const Function& getter = Function::Handle(Z,
       field_owner.LookupStaticFunction(getter_name));
-  const Instance& value = Instance::Handle(I, field.value());
+  const Instance& value = Instance::Handle(Z, field.value());
   if (value.raw() == Object::transition_sentinel().raw()) {
     if (field.is_const()) {
       ReportError("circular dependency while initializing static field '%s'",
@@ -10197,7 +10206,7 @@
                   field_name.ToCString());
     } else {
       // The implicit static getter will throw the exception if necessary.
-      return new(I) StaticGetterNode(
+      return new(Z) StaticGetterNode(
           field_ref_pos, NULL, false, field_owner, field_name);
     }
   } else if (value.raw() == Object::sentinel().raw()) {
@@ -10207,7 +10216,7 @@
     if (field.is_const()) {
       field.set_value(Object::transition_sentinel());
       const int kNumArguments = 0;  // no arguments.
-      const Function& func = Function::Handle(I,
+      const Function& func = Function::Handle(Z,
           Resolver::ResolveStatic(field_owner,
                                   getter_name,
                                   kNumArguments,
@@ -10214,7 +10223,7 @@
                                   Object::empty_array()));
       ASSERT(!func.IsNull());
       ASSERT(func.kind() == RawFunction::kImplicitStaticFinalGetter);
-      Object& const_value = Object::Handle(I);
+      Object& const_value = Object::Handle(Z);
       {
         PAUSETIMERSCOPE(I, time_compilation);
         const_value = DartEntry::InvokeFunction(func, Object::empty_array());
@@ -10229,7 +10238,7 @@
           field.set_value(Object::null_instance());
           // It is a compile-time error if evaluation of a compile-time constant
           // would raise an exception.
-          const String& field_name = String::Handle(I, field.name());
+          const String& field_name = String::Handle(Z, field.name());
           ReportErrors(error,
                        script_, field_ref_pos,
                        "error initializing const field '%s'",
@@ -10240,13 +10249,13 @@
         UNREACHABLE();
       }
       ASSERT(const_value.IsNull() || const_value.IsInstance());
-      Instance& instance = Instance::Handle(I);
+      Instance& instance = Instance::Handle(Z);
       instance ^= const_value.raw();
       instance = TryCanonicalize(instance, field_ref_pos);
       field.set_value(instance);
       return NULL;   // Constant
     } else {
-      return new(I) StaticGetterNode(
+      return new(Z) StaticGetterNode(
           field_ref_pos, NULL, false, field_owner, field_name);
     }
   }
@@ -10255,7 +10264,7 @@
     return NULL;
   }
   ASSERT(getter.kind() == RawFunction::kImplicitGetter);
-  return new(I) StaticGetterNode(
+  return new(Z) StaticGetterNode(
       field_ref_pos, NULL, false, field_owner, field_name);
 }
 
@@ -10269,8 +10278,8 @@
   // Constructors have 2 extra arguments: rcvr and construction phase.
   const int kNumExtraArgs = constructor.IsFactory() ? 1 : 2;
   const int num_arguments = arguments->length() + kNumExtraArgs;
-  const Array& arg_values = Array::Handle(I, Array::New(num_arguments));
-  Instance& instance = Instance::Handle(I);
+  const Array& arg_values = Array::Handle(Z, Array::New(num_arguments));
+  Instance& instance = Instance::Handle(Z);
   if (!constructor.IsFactory()) {
     instance = Instance::New(type_class, Heap::kOld);
     if (!type_arguments.IsNull()) {
@@ -10278,10 +10287,10 @@
         ReportError("type must be constant in const constructor");
       }
       instance.SetTypeArguments(
-          TypeArguments::Handle(I, type_arguments.Canonicalize()));
+          TypeArguments::Handle(Z, type_arguments.Canonicalize()));
     }
     arg_values.SetAt(0, instance);
-    arg_values.SetAt(1, Smi::Handle(I, Smi::New(Function::kCtorPhaseAll)));
+    arg_values.SetAt(1, Smi::Handle(Z, Smi::New(Function::kCtorPhaseAll)));
   } else {
     // Prepend type_arguments to list of arguments to factory.
     ASSERT(type_arguments.IsZoneHandle());
@@ -10293,9 +10302,9 @@
     ASSERT(arg->IsLiteralNode());
     arg_values.SetAt((i + kNumExtraArgs), arg->AsLiteralNode()->literal());
   }
-  const Array& args_descriptor = Array::Handle(I,
+  const Array& args_descriptor = Array::Handle(Z,
       ArgumentsDescriptor::New(num_arguments, arguments->names()));
-  Object& result = Object::Handle(I);
+  Object& result = Object::Handle(Z);
   {
     PAUSETIMERSCOPE(I, time_compilation);
     result = DartEntry::InvokeFunction(
@@ -10337,7 +10346,7 @@
   }
   if (local != NULL) {
     if (node != NULL) {
-      *node = new(I) LoadLocalNode(ident_pos, local);
+      *node = new(Z) LoadLocalNode(ident_pos, local);
     }
     return true;
   }
@@ -10345,14 +10354,14 @@
   // Try to find the identifier in the class scope of the current class.
   // If the current class is the result of a mixin application, we must
   // use the class scope of the class from which the function originates.
-  Class& cls = Class::Handle(I);
+  Class& cls = Class::Handle(Z);
   if (!current_class().IsMixinApplication()) {
     cls = current_class().raw();
   } else {
     cls = parsed_function()->function().origin();
   }
-  Function& func = Function::Handle(I, Function::null());
-  Field& field = Field::Handle(I, Field::null());
+  Function& func = Function::Handle(Z, Function::null());
+  Field& field = Field::Handle(Z, Field::null());
 
   // First check if a field exists.
   field = cls.LookupField(ident);
@@ -10375,8 +10384,8 @@
       func.IsStaticFunction() ||
       func.is_abstract())) {
     if (node != NULL) {
-      *node = new(I) PrimaryNode(
-          ident_pos, Function::ZoneHandle(I, func.raw()));
+      *node = new(Z) PrimaryNode(
+          ident_pos, Function::ZoneHandle(Z, func.raw()));
     }
     return true;
   }
@@ -10388,13 +10397,13 @@
     if (func.IsDynamicFunction() || func.is_abstract()) {
       if (node != NULL) {
         CheckInstanceFieldAccess(ident_pos, ident);
-        ASSERT(AbstractType::Handle(I, func.result_type()).IsResolved());
+        ASSERT(AbstractType::Handle(Z, func.result_type()).IsResolved());
         *node = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
       }
       return true;
     } else if (func.IsStaticFunction()) {
       if (node != NULL) {
-        ASSERT(AbstractType::Handle(I, func.result_type()).IsResolved());
+        ASSERT(AbstractType::Handle(Z, func.result_type()).IsResolved());
         // The static getter may later be changed into a dynamically
         // resolved instance setter if no static setter can
         // be found.
@@ -10404,10 +10413,10 @@
             (LookupReceiver(current_block_->scope, kTestOnly) != NULL)) {
           receiver = LoadReceiver(ident_pos);
         }
-        *node = new(I) StaticGetterNode(ident_pos,
+        *node = new(Z) StaticGetterNode(ident_pos,
                                         receiver,
                                         false,
-                                        Class::ZoneHandle(I, cls.raw()),
+                                        Class::ZoneHandle(Z, cls.raw()),
                                         ident);
       }
       return true;
@@ -10422,7 +10431,7 @@
         // 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(I, func.result_type()).IsResolved());
+        ASSERT(AbstractType::Handle(Z, func.result_type()).IsResolved());
         *node = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
       }
       return true;
@@ -10432,11 +10441,11 @@
         // 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(I) StaticGetterNode(
+        *node = new(Z) StaticGetterNode(
             ident_pos,
             NULL,
             false,
-            Class::ZoneHandle(I, cls.raw()),
+            Class::ZoneHandle(Z, cls.raw()),
             ident);
       }
       return true;
@@ -10453,7 +10462,7 @@
 
 RawClass* Parser::ResolveClassInCurrentLibraryScope(const String& name) {
   HANDLESCOPE(I);
-  const Object& obj = Object::Handle(I, library_.ResolveName(name));
+  const Object& obj = Object::Handle(Z, library_.ResolveName(name));
   if (obj.IsClass()) {
     return Class::Cast(obj).raw();
   }
@@ -10468,10 +10477,10 @@
                                                    const String& ident) {
   TRACE_PARSER("ResolveIdentInCurrentLibraryScope");
   HANDLESCOPE(I);
-  const Object& obj = Object::Handle(I, library_.ResolveName(ident));
+  const Object& obj = Object::Handle(Z, library_.ResolveName(ident));
   if (obj.IsClass()) {
     const Class& cls = Class::Cast(obj);
-    return new(I) PrimaryNode(ident_pos, Class::ZoneHandle(I, cls.raw()));
+    return new(Z) PrimaryNode(ident_pos, Class::ZoneHandle(Z, cls.raw()));
   } else if (obj.IsField()) {
     const Field& field = Field::Cast(obj);
     ASSERT(field.is_static());
@@ -10480,20 +10489,20 @@
     const Function& func = Function::Cast(obj);
     ASSERT(func.is_static());
     if (func.IsGetterFunction() || func.IsSetterFunction()) {
-      return new(I) StaticGetterNode(ident_pos,
+      return new(Z) StaticGetterNode(ident_pos,
                                      /* receiver */ NULL,
                                      /* is_super_getter */ false,
-                                     Class::ZoneHandle(I, func.Owner()),
+                                     Class::ZoneHandle(Z, func.Owner()),
                                      ident);
 
     } else {
-      return new(I) PrimaryNode(ident_pos, Function::ZoneHandle(I, func.raw()));
+      return new(Z) PrimaryNode(ident_pos, Function::ZoneHandle(Z, func.raw()));
     }
   } else {
     ASSERT(obj.IsNull() || obj.IsLibraryPrefix());
   }
   // Lexically unresolved primary identifiers are referenced by their name.
-  return new(I) PrimaryNode(ident_pos, ident);
+  return new(Z) PrimaryNode(ident_pos, ident);
 }
 
 
@@ -10500,7 +10509,7 @@
 RawClass* Parser::ResolveClassInPrefixScope(const LibraryPrefix& prefix,
                                             const String& name) {
   HANDLESCOPE(I);
-  const Object& obj = Object::Handle(I, prefix.LookupObject(name));
+  const Object& obj = Object::Handle(Z, prefix.LookupObject(name));
   if (obj.IsClass()) {
     return Class::Cast(obj).raw();
   }
@@ -10525,7 +10534,7 @@
     // name, so we need to explicitly reject private names here.
     return NULL;
   }
-  Object& obj = Object::Handle(I);
+  Object& obj = Object::Handle(Z);
   if (prefix.is_loaded()) {
     obj = prefix.LookupObject(ident);
   } else {
@@ -10543,7 +10552,7 @@
   } else if (obj.IsClass()) {
     const Class& cls = Class::Cast(obj);
     PrimaryNode* primary =
-        new(I) PrimaryNode(ident_pos, Class::ZoneHandle(I, cls.raw()));
+        new(Z) PrimaryNode(ident_pos, Class::ZoneHandle(Z, cls.raw()));
     primary->set_is_deferred(is_deferred);
     return primary;
   } else if (obj.IsField()) {
@@ -10563,17 +10572,17 @@
     const Function& func = Function::Cast(obj);
     ASSERT(func.is_static());
     if (func.IsGetterFunction() || func.IsSetterFunction()) {
-      StaticGetterNode* getter = new(I) StaticGetterNode(
+      StaticGetterNode* getter = new(Z) StaticGetterNode(
           ident_pos,
           /* receiver */ NULL,
           /* is_super_getter */ false,
-          Class::ZoneHandle(I, func.Owner()),
+          Class::ZoneHandle(Z, func.Owner()),
           ident);
       getter->set_is_deferred(is_deferred);
       return getter;
     } else {
-      PrimaryNode* primary = new(I) PrimaryNode(
-           ident_pos, Function::ZoneHandle(I, func.raw()));
+      PrimaryNode* primary = new(Z) PrimaryNode(
+           ident_pos, Function::ZoneHandle(Z, func.raw()));
       primary->set_is_deferred(is_deferred);
       return primary;
     }
@@ -10600,7 +10609,7 @@
   if (resolved == NULL) {
     // Check whether the identifier is a type parameter.
     if (!current_class().IsNull()) {
-      TypeParameter& type_parameter = TypeParameter::ZoneHandle(I,
+      TypeParameter& type_parameter = TypeParameter::ZoneHandle(Z,
           current_class().LookupTypeParameter(ident));
       if (!type_parameter.IsNull()) {
         if (current_block_->scope->function_level() > 0) {
@@ -10610,7 +10619,7 @@
         type_parameter ^= ClassFinalizer::FinalizeType(
             current_class(), type_parameter, ClassFinalizer::kCanonicalize);
         ASSERT(!type_parameter.IsMalformed());
-        return new(I) TypeNode(ident_pos, type_parameter);
+        return new(Z) TypeNode(ident_pos, type_parameter);
       }
     }
     // Not found in the local scope, and the name is not a type parameter.
@@ -10648,13 +10657,13 @@
       }
     } else if (primary->primary().IsClass()) {
       const Class& type_class = Class::Cast(primary->primary());
-      AbstractType& type = Type::ZoneHandle(I,
-          Type::New(type_class, TypeArguments::Handle(I), primary_pos));
+      AbstractType& type = Type::ZoneHandle(Z,
+          Type::New(type_class, TypeArguments::Handle(Z), primary_pos));
       type ^= ClassFinalizer::FinalizeType(
           current_class(), type, ClassFinalizer::kCanonicalize);
       // Type may be malbounded, but not malformed.
       ASSERT(!type.IsMalformed());
-      resolved = new(I) TypeNode(primary_pos, type);
+      resolved = new(Z) TypeNode(primary_pos, type);
     }
   }
   return resolved;
@@ -10670,8 +10679,8 @@
   TRACE_PARSER("ParseType");
   CheckToken(Token::kIDENT, "type name expected");
   intptr_t ident_pos = TokenPos();
-  LibraryPrefix& prefix = LibraryPrefix::Handle(I);
-  String& type_name = String::Handle(I);;
+  LibraryPrefix& prefix = LibraryPrefix::Handle(Z);
+  String& type_name = String::Handle(Z);;
 
   if (finalization == ClassFinalizer::kIgnore) {
     if (!is_top_level_ && (current_block_ != NULL)) {
@@ -10701,7 +10710,7 @@
       }
       ConsumeToken();  // Period token.
       ASSERT(IsIdentifier());
-      String& qualified_name = String::Handle(I, type_name.raw());
+      String& qualified_name = String::Handle(Z, type_name.raw());
       qualified_name = String::Concat(qualified_name, Symbols::Dot());
       qualified_name = String::Concat(qualified_name, *CurrentLiteral());
       ConsumeToken();
@@ -10708,7 +10717,7 @@
       // The type is malformed. Skip over its type arguments.
       ParseTypeArguments(ClassFinalizer::kIgnore);
       return ClassFinalizer::NewFinalizedMalformedType(
-          Error::Handle(I),  // No previous error.
+          Error::Handle(Z),  // No previous error.
           script_,
           ident_pos,
           "qualified name '%s' does not refer to a type",
@@ -10723,7 +10732,7 @@
       // The type is malformed. Skip over its type arguments.
       ParseTypeArguments(ClassFinalizer::kIgnore);
       return ClassFinalizer::NewFinalizedMalformedType(
-          Error::Handle(I),  // No previous error.
+          Error::Handle(Z),  // No previous error.
           script_,
           ident_pos,
           "using '%s' in this context is invalid",
@@ -10732,26 +10741,26 @@
     if (!prefix.IsNull() && prefix.is_deferred_load() && !allow_deferred_type) {
       ParseTypeArguments(ClassFinalizer::kIgnore);
       return ClassFinalizer::NewFinalizedMalformedType(
-          Error::Handle(I),  // No previous error.
+          Error::Handle(Z),  // No previous error.
           script_,
           ident_pos,
           "using deferred type '%s.%s' is invalid",
-          String::Handle(I, prefix.name()).ToCString(),
+          String::Handle(Z, prefix.name()).ToCString(),
           type_name.ToCString());
     }
   }
-  Object& type_class = Object::Handle(I);
+  Object& type_class = Object::Handle(Z);
   // Leave type_class as null if type finalization mode is kIgnore.
   if (finalization != ClassFinalizer::kIgnore) {
     type_class = UnresolvedClass::New(prefix, type_name, ident_pos);
   }
   TypeArguments& type_arguments = TypeArguments::Handle(
-      I, ParseTypeArguments(finalization));
+      Z, ParseTypeArguments(finalization));
   if (finalization == ClassFinalizer::kIgnore) {
     return Type::DynamicType();
   }
   AbstractType& type = AbstractType::Handle(
-      I, Type::New(type_class, type_arguments, ident_pos));
+      Z, Type::New(type_class, type_arguments, ident_pos));
   if (finalization >= ClassFinalizer::kResolveTypeParameters) {
     ResolveTypeFromClass(current_class(), finalization, &type);
     if (finalization >= ClassFinalizer::kCanonicalize) {
@@ -10766,7 +10775,7 @@
     intptr_t pos, const Function& constructor,
     const TypeArguments& type_arguments) {
   if (!type_arguments.IsNull()) {
-    const Class& constructor_class = Class::Handle(I, constructor.Owner());
+    const Class& constructor_class = Class::Handle(Z, constructor.Owner());
     ASSERT(!constructor_class.IsNull());
     ASSERT(constructor_class.is_finalized());
     ASSERT(type_arguments.IsCanonical());
@@ -10793,9 +10802,9 @@
   bool is_empty_literal = CurrentToken() == Token::kINDEX;
   ConsumeToken();
 
-  AbstractType& element_type = Type::ZoneHandle(I, Type::DynamicType());
+  AbstractType& element_type = Type::ZoneHandle(Z, Type::DynamicType());
   TypeArguments& list_type_arguments =
-      TypeArguments::ZoneHandle(I, type_arguments.raw());
+      TypeArguments::ZoneHandle(Z, 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()) {
@@ -10823,8 +10832,8 @@
     }
   }
   ASSERT(list_type_arguments.IsNull() || (list_type_arguments.Length() == 1));
-  const Class& array_class = Class::Handle(I, I->object_store()->array_class());
-  Type& type = Type::ZoneHandle(I,
+  const Class& array_class = Class::Handle(Z, I->object_store()->array_class());
+  Type& type = Type::ZoneHandle(Z,
       Type::New(array_class, list_type_arguments, type_pos));
   type ^= ClassFinalizer::FinalizeType(
       current_class(), type, ClassFinalizer::kCanonicalize);
@@ -10839,7 +10848,7 @@
       if (FLAG_enable_type_checks &&
           !is_const &&
           !element_type.IsDynamicType()) {
-        element = new(I) AssignableNode(element_pos,
+        element = new(Z) AssignableNode(element_pos,
                                         element,
                                         element_type,
                                         Symbols::ListLiteralElement());
@@ -10858,10 +10867,10 @@
   if (is_const) {
     // Allocate and initialize the const list at compile time.
     Array& const_list =
-        Array::ZoneHandle(I, Array::New(element_list.length(), Heap::kOld));
+        Array::ZoneHandle(Z, Array::New(element_list.length(), Heap::kOld));
     const_list.SetTypeArguments(
-        TypeArguments::Handle(I, list_type_arguments.Canonicalize()));
-    Error& malformed_error = Error::Handle(I);
+        TypeArguments::Handle(Z, list_type_arguments.Canonicalize()));
+    Error& malformed_error = Error::Handle(Z);
     for (int i = 0; i < element_list.length(); i++) {
       AstNode* elem = element_list[i];
       // Arguments have been evaluated to a literal value already.
@@ -10872,7 +10881,7 @@
           (!elem->AsLiteralNode()->literal().IsNull() &&
            !elem->AsLiteralNode()->literal().IsInstanceOf(
                element_type,
-               TypeArguments::Handle(I),
+               TypeArguments::Handle(Z),
                &malformed_error))) {
         // If the failure is due to a malformed type error, display it instead.
         if (!malformed_error.IsNull()) {
@@ -10882,7 +10891,7 @@
                       "list literal element at index %d must be "
                       "a constant of type '%s'",
                       i,
-                      String::Handle(I,
+                      String::Handle(Z,
                           element_type.UserVisibleName()).ToCString());
         }
       }
@@ -10890,13 +10899,13 @@
     }
     const_list.MakeImmutable();
     const_list ^= TryCanonicalize(const_list, literal_pos);
-    return new(I) LiteralNode(literal_pos, const_list);
+    return new(Z) LiteralNode(literal_pos, const_list);
   } else {
     // Factory call at runtime.
     const Class& factory_class =
-        Class::Handle(I, Library::LookupCoreClass(Symbols::List()));
+        Class::Handle(Z, Library::LookupCoreClass(Symbols::List()));
     ASSERT(!factory_class.IsNull());
-    const Function& factory_method = Function::ZoneHandle(I,
+    const Function& factory_method = Function::ZoneHandle(Z,
         factory_class.LookupFactory(
             Library::PrivateCoreLibName(Symbols::ListLiteralFactory())));
     ASSERT(!factory_method.IsNull());
@@ -10907,12 +10916,12 @@
       CaptureInstantiator();
     }
     TypeArguments& factory_type_args =
-        TypeArguments::ZoneHandle(I, list_type_arguments.raw());
+        TypeArguments::ZoneHandle(Z, 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(I, Type::New(
+      Type& factory_type = Type::Handle(Z, Type::New(
           factory_class, factory_type_args, type_pos, Heap::kNew));
       factory_type ^= ClassFinalizer::FinalizeType(
           current_class(), factory_type, ClassFinalizer::kFinalize);
@@ -10920,14 +10929,14 @@
       ASSERT(factory_type_args.Length() == factory_class.NumTypeArguments());
     }
     factory_type_args = factory_type_args.Canonicalize();
-    ArgumentListNode* factory_param = new(I) ArgumentListNode(
+    ArgumentListNode* factory_param = new(Z) ArgumentListNode(
         literal_pos);
     if (element_list.length() == 0) {
       LiteralNode* empty_array_literal =
-          new(I) LiteralNode(TokenPos(), Object::empty_array());
+          new(Z) LiteralNode(TokenPos(), Object::empty_array());
       factory_param->Add(empty_array_literal);
     } else {
-      ArrayNode* list = new(I) ArrayNode(TokenPos(), type, element_list);
+      ArrayNode* list = new(Z) ArrayNode(TokenPos(), type, element_list);
       factory_param->Add(list);
     }
     return CreateConstructorCallNode(literal_pos,
@@ -10946,7 +10955,7 @@
   if (!type_arguments.IsNull() && !type_arguments.IsInstantiated()) {
     EnsureExpressionTemp();
   }
-  return new(I) ConstructorCallNode(
+  return new(Z) ConstructorCallNode(
       token_pos, type_arguments, constructor, arguments);
 }
 
@@ -10985,10 +10994,10 @@
   const intptr_t literal_pos = TokenPos();
   ConsumeToken();
 
-  AbstractType& key_type = Type::ZoneHandle(I, Type::DynamicType());
-  AbstractType& value_type = Type::ZoneHandle(I, Type::DynamicType());
+  AbstractType& key_type = Type::ZoneHandle(Z, Type::DynamicType());
+  AbstractType& value_type = Type::ZoneHandle(Z, Type::DynamicType());
   TypeArguments& map_type_arguments =
-      TypeArguments::ZoneHandle(I, type_arguments.raw());
+      TypeArguments::ZoneHandle(Z, 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.
@@ -11032,7 +11041,7 @@
     if (FLAG_enable_type_checks &&
         !is_const &&
         !key_type.IsDynamicType()) {
-      key = new(I) AssignableNode(
+      key = new(Z) AssignableNode(
           key_pos, key, key_type, Symbols::ListLiteralElement());
     }
     if (is_const) {
@@ -11055,7 +11064,7 @@
     if (FLAG_enable_type_checks &&
         !is_const &&
         !value_type.IsDynamicType()) {
-      value = new(I) AssignableNode(
+      value = new(Z) AssignableNode(
           value_pos, value, value_type, Symbols::ListLiteralElement());
     }
     AddKeyValuePair(&kv_pairs_list, is_const, key, value);
@@ -11076,9 +11085,9 @@
 
     // First, create the canonicalized key-value pair array.
     Array& key_value_array =
-        Array::ZoneHandle(I, Array::New(kv_pairs_list.length(), Heap::kOld));
-    AbstractType& arg_type = Type::Handle(I);
-    Error& malformed_error = Error::Handle(I);
+        Array::ZoneHandle(Z, Array::New(kv_pairs_list.length(), Heap::kOld));
+    AbstractType& arg_type = Type::Handle(Z);
+    Error& malformed_error = Error::Handle(Z);
     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.
@@ -11107,7 +11116,7 @@
                         "a constant of type '%s'",
                         ((i % 2) == 0) ? "key" : "value",
                         i >> 1,
-                        String::Handle(I,
+                        String::Handle(Z,
                                        arg_type.UserVisibleName()).ToCString());
           }
         }
@@ -11118,19 +11127,19 @@
     key_value_array ^= TryCanonicalize(key_value_array, TokenPos());
 
     // Construct the map object.
-    const Class& immutable_map_class = Class::Handle(I,
+    const Class& immutable_map_class = Class::Handle(Z,
         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(I) ArgumentListNode(TokenPos());
-    constr_args->Add(new(I) LiteralNode(literal_pos, key_value_array));
+    ArgumentListNode* constr_args = new(Z) ArgumentListNode(TokenPos());
+    constr_args->Add(new(Z) LiteralNode(literal_pos, key_value_array));
     const Function& map_constr =
-        Function::ZoneHandle(I, immutable_map_class.LookupConstructor(
+        Function::ZoneHandle(Z, immutable_map_class.LookupConstructor(
             Library::PrivateCoreLibName(Symbols::ImmutableMapConstructor())));
     ASSERT(!map_constr.IsNull());
-    const Object& constructor_result = Object::Handle(I,
+    const Object& constructor_result = Object::Handle(Z,
         EvaluateConstConstructorCall(immutable_map_class,
                                      map_type_arguments,
                                      map_constr,
@@ -11141,15 +11150,15 @@
                    "error executing const Map constructor");
     } else {
       const Instance& const_instance = Instance::Cast(constructor_result);
-      return new(I) LiteralNode(
-          literal_pos, Instance::ZoneHandle(I, const_instance.raw()));
+      return new(Z) LiteralNode(
+          literal_pos, Instance::ZoneHandle(Z, const_instance.raw()));
     }
   } else {
     // Factory call at runtime.
     const Class& factory_class =
-        Class::Handle(I, Library::LookupCoreClass(Symbols::Map()));
+        Class::Handle(Z, Library::LookupCoreClass(Symbols::Map()));
     ASSERT(!factory_class.IsNull());
-    const Function& factory_method = Function::ZoneHandle(I,
+    const Function& factory_method = Function::ZoneHandle(Z,
         factory_class.LookupFactory(
             Library::PrivateCoreLibName(Symbols::MapLiteralFactory())));
     ASSERT(!factory_method.IsNull());
@@ -11160,12 +11169,12 @@
       CaptureInstantiator();
     }
     TypeArguments& factory_type_args =
-        TypeArguments::ZoneHandle(I, map_type_arguments.raw());
+        TypeArguments::ZoneHandle(Z, 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(I, Type::New(
+      Type& factory_type = Type::Handle(Z, Type::New(
           factory_class, factory_type_args, type_pos, Heap::kNew));
       factory_type ^= ClassFinalizer::FinalizeType(
           current_class(), factory_type, ClassFinalizer::kFinalize);
@@ -11173,12 +11182,12 @@
       ASSERT(factory_type_args.Length() == factory_class.NumTypeArguments());
     }
     factory_type_args = factory_type_args.Canonicalize();
-    ArgumentListNode* factory_param = new(I) ArgumentListNode(literal_pos);
+    ArgumentListNode* factory_param = new(Z) 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(I) ArrayNode(
+    ArrayNode* kv_pairs = new(Z) ArrayNode(
         TokenPos(),
-        Type::ZoneHandle(I, Type::ArrayType()),
+        Type::ZoneHandle(Z, Type::ArrayType()),
         kv_pairs_list);
     factory_param->Add(kv_pairs);
     return CreateConstructorCallNode(literal_pos,
@@ -11199,7 +11208,7 @@
     ConsumeToken();
   }
   const intptr_t type_pos = TokenPos();
-  TypeArguments& type_arguments = TypeArguments::Handle(I,
+  TypeArguments& type_arguments = TypeArguments::Handle(Z,
       ParseTypeArguments(ClassFinalizer::kCanonicalize));
   // Malformed type arguments are mapped to dynamic, so we will not encounter
   // them here.
@@ -11222,7 +11231,7 @@
   ASSERT(CurrentToken() == Token::kHASH);
   ConsumeToken();
   intptr_t symbol_pos = TokenPos();
-  String& symbol = String::Handle(I);
+  String& symbol = String::Handle(Z);
   if (IsIdentifier()) {
     symbol = CurrentLiteral()->raw();
     ConsumeToken();
@@ -11242,15 +11251,15 @@
   // Call Symbol class constructor to create a symbol instance.
   const Class& symbol_class = Class::Handle(I->object_store()->symbol_class());
   ASSERT(!symbol_class.IsNull());
-  ArgumentListNode* constr_args = new(I) ArgumentListNode(symbol_pos);
-  constr_args->Add(new(I) LiteralNode(
-      symbol_pos, String::ZoneHandle(I, Symbols::New(symbol))));
-  const Function& constr = Function::ZoneHandle(I,
+  ArgumentListNode* constr_args = new(Z) ArgumentListNode(symbol_pos);
+  constr_args->Add(new(Z) LiteralNode(
+      symbol_pos, String::ZoneHandle(Z, Symbols::New(symbol))));
+  const Function& constr = Function::ZoneHandle(Z,
       symbol_class.LookupConstructor(Symbols::SymbolCtor()));
   ASSERT(!constr.IsNull());
-  const Object& result = Object::Handle(I,
+  const Object& result = Object::Handle(Z,
       EvaluateConstConstructorCall(symbol_class,
-                                   TypeArguments::Handle(I),
+                                   TypeArguments::Handle(Z),
                                    constr,
                                    constr_args));
   if (result.IsUnhandledException()) {
@@ -11259,8 +11268,8 @@
                  "error executing const Symbol constructor");
   }
   const Instance& instance = Instance::Cast(result);
-  return new(I) LiteralNode(symbol_pos,
-                            Instance::ZoneHandle(I, instance.raw()));
+  return new(Z) LiteralNode(symbol_pos,
+                            Instance::ZoneHandle(Z, instance.raw()));
 }
 
 
@@ -11292,7 +11301,7 @@
   const bool allow_deferred_type = !is_const;
   const bool consume_unresolved_prefix = (LookaheadToken(3) == Token::kLT) ||
                                          (LookaheadToken(3) == Token::kPERIOD);
-  AbstractType& type = AbstractType::Handle(I,
+  AbstractType& type = AbstractType::Handle(Z,
       ParseType(ClassFinalizer::kCanonicalizeWellFormed,
                 allow_deferred_type,
                 consume_unresolved_prefix));
@@ -11301,20 +11310,20 @@
   if (!type.IsMalformed() && (type.IsTypeParameter() || type.IsDynamicType())) {
     // Replace the type with a malformed type.
     type = ClassFinalizer::NewFinalizedMalformedType(
-        Error::Handle(I),  // No previous error.
+        Error::Handle(Z),  // No previous error.
         script_,
         type_pos,
         "%s'%s' cannot be instantiated",
         type.IsTypeParameter() ? "type parameter " : "",
         type.IsTypeParameter() ?
-            String::Handle(I, type.UserVisibleName()).ToCString() :
+            String::Handle(Z, type.UserVisibleName()).ToCString() :
             "dynamic");
   }
   // Attempting to instantiate an enum type is a compile-time error.
-  Class& type_class = Class::Handle(I, type.type_class());
+  Class& type_class = Class::Handle(Z, type.type_class());
   if (type_class.is_enum_class()) {
     ReportError(new_pos, "enum type '%s' can not be instantiated",
-                String::Handle(I, type_class.Name()).ToCString());
+                String::Handle(Z, type_class.Name()).ToCString());
   }
 
   // The grammar allows for an optional ('.' identifier)? after the type, which
@@ -11336,7 +11345,7 @@
   // malbounded type or report a compile-time error if the constructor is const.
   if (type.IsMalformedOrMalbounded()) {
     if (is_const) {
-      const Error& error = Error::Handle(I, type.error());
+      const Error& error = Error::Handle(Z, type.error());
       ReportError(error);
     }
     return ThrowTypeError(type_pos, type);
@@ -11343,9 +11352,9 @@
   }
 
   // Resolve the type and optional identifier to a constructor or factory.
-  String& type_class_name = String::Handle(I, type_class.Name());
+  String& type_class_name = String::Handle(Z, type_class.Name());
   TypeArguments& type_arguments =
-      TypeArguments::ZoneHandle(I, type.arguments());
+      TypeArguments::ZoneHandle(Z, type.arguments());
 
   // A constructor has an implicit 'this' parameter (instance to construct)
   // and a factory has an implicit 'this' parameter (type_arguments).
@@ -11354,12 +11363,12 @@
 
   // An additional type check of the result of a redirecting factory may be
   // required.
-  AbstractType& type_bound = AbstractType::ZoneHandle(I);
+  AbstractType& type_bound = AbstractType::ZoneHandle(Z);
 
   // Make sure that an appropriate constructor exists.
   String& constructor_name =
       BuildConstructorName(type_class_name, named_constructor);
-  Function& constructor = Function::ZoneHandle(I,
+  Function& constructor = Function::ZoneHandle(Z,
       type_class.LookupConstructor(constructor_name));
   if (constructor.IsNull()) {
     constructor = type_class.LookupFactory(constructor_name);
@@ -11370,13 +11379,13 @@
       // compile-time error if the constructor is const.
       if (is_const) {
         type = ClassFinalizer::NewFinalizedMalformedType(
-            Error::Handle(I),  // No previous error.
+            Error::Handle(Z),  // No previous error.
             script_,
             call_pos,
             "class '%s' has no constructor or factory named '%s'",
-            String::Handle(I, type_class.Name()).ToCString(),
+            String::Handle(Z, type_class.Name()).ToCString(),
             external_constructor_name.ToCString());
-        ReportError(Error::Handle(I, type.error()));
+        ReportError(Error::Handle(Z, type.error()));
       }
       return ThrowNoSuchMethodError(call_pos,
                                     type_class,
@@ -11387,12 +11396,12 @@
                                     NULL);  // No existing function.
     } else if (constructor.IsRedirectingFactory()) {
       ClassFinalizer::ResolveRedirectingFactory(type_class, constructor);
-      Type& redirect_type = Type::Handle(I, constructor.RedirectionType());
+      Type& redirect_type = Type::Handle(Z, constructor.RedirectionType());
       if (!redirect_type.IsMalformedOrMalbounded() &&
           !redirect_type.IsInstantiated()) {
         // The type arguments of the redirection type are instantiated from the
         // type arguments of the parsed type of the 'new' or 'const' expression.
-        Error& error = Error::Handle(I);
+        Error& error = Error::Handle(Z);
         redirect_type ^= redirect_type.InstantiateFrom(type_arguments, &error);
         if (!error.IsNull()) {
           redirect_type = ClassFinalizer::NewFinalizedMalformedType(
@@ -11400,12 +11409,12 @@
               script_,
               call_pos,
               "redirecting factory type '%s' cannot be instantiated",
-              String::Handle(I, redirect_type.UserVisibleName()).ToCString());
+              String::Handle(Z, redirect_type.UserVisibleName()).ToCString());
         }
       }
       if (redirect_type.IsMalformedOrMalbounded()) {
         if (is_const) {
-          ReportError(Error::Handle(I, redirect_type.error()));
+          ReportError(Error::Handle(Z, redirect_type.error()));
         }
         return ThrowTypeError(redirect_type.token_pos(), redirect_type);
       }
@@ -11432,15 +11441,15 @@
   ASSERT(!constructor.IsNull());
   if (type_class.is_abstract() && !constructor.IsFactory()) {
     // Evaluate arguments before throwing.
-    LetNode* result = new(I) LetNode(call_pos);
+    LetNode* result = new(Z) LetNode(call_pos);
     for (intptr_t i = 0; i < arguments->length(); ++i) {
       result->AddNode(arguments->NodeAt(i));
     }
-    ArgumentListNode* error_arguments = new(I) ArgumentListNode(type_pos);
-    error_arguments->Add(new(I) LiteralNode(
-        TokenPos(), Integer::ZoneHandle(I, Integer::New(type_pos))));
-    error_arguments->Add(new(I) LiteralNode(
-        TokenPos(), String::ZoneHandle(I, type_class_name.raw())));
+    ArgumentListNode* error_arguments = new(Z) ArgumentListNode(type_pos);
+    error_arguments->Add(new(Z) LiteralNode(
+        TokenPos(), Integer::ZoneHandle(Z, Integer::New(type_pos))));
+    error_arguments->Add(new(Z) LiteralNode(
+        TokenPos(), String::ZoneHandle(Z, type_class_name.raw())));
     result->AddNode(
         MakeStaticCall(Symbols::AbstractClassInstantiationError(),
                        Library::PrivateCoreLibName(Symbols::ThrowNew()),
@@ -11447,7 +11456,7 @@
                        error_arguments));
     return result;
   }
-  String& error_message = String::Handle(I);
+  String& error_message = String::Handle(Z);
   if (!constructor.AreValidArguments(arguments_length,
                                      arguments->names(),
                                      &error_message)) {
@@ -11458,7 +11467,7 @@
                   "invalid arguments passed to constructor '%s' "
                   "for class '%s': %s",
                   external_constructor_name.ToCString(),
-                  String::Handle(I, type_class.Name()).ToCString(),
+                  String::Handle(Z, type_class.Name()).ToCString(),
                   error_message.ToCString());
     }
     return ThrowNoSuchMethodError(call_pos,
@@ -11474,7 +11483,7 @@
   // compile-time error if the constructor is const.
   if (type.IsMalformedOrMalbounded()) {
     if (is_const) {
-      ReportError(Error::Handle(I, type.error()));
+      ReportError(Error::Handle(Z, type.error()));
     }
     return ThrowTypeError(type_pos, type);
   }
@@ -11489,7 +11498,7 @@
                   "const object creation",
                   external_constructor_name.ToCString());
     }
-    const Object& constructor_result = Object::Handle(I,
+    const Object& constructor_result = Object::Handle(Z,
         EvaluateConstConstructorCall(type_class,
                                      type_arguments,
                                      constructor,
@@ -11503,16 +11512,16 @@
     } 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(I);
+      Instance& const_instance = Instance::Handle(Z);
       const_instance ^= constructor_result.raw();
-      new_object = new(I) LiteralNode(
-          new_pos, Instance::ZoneHandle(I, const_instance.raw()));
+      new_object = new(Z) LiteralNode(
+          new_pos, Instance::ZoneHandle(Z, const_instance.raw()));
       if (!type_bound.IsNull()) {
         ASSERT(!type_bound.IsMalformed());
-        Error& malformed_error = Error::Handle(I);
+        Error& malformed_error = Error::Handle(Z);
         ASSERT(!is_top_level_);  // We cannot check unresolved types.
         if (!const_instance.IsInstanceOf(type_bound,
-                                         TypeArguments::Handle(I),
+                                         TypeArguments::Handle(Z),
                                          &malformed_error)) {
           type_bound = ClassFinalizer::NewFinalizedMalformedType(
               malformed_error,
@@ -11519,7 +11528,7 @@
               script_,
               new_pos,
               "const factory result is not an instance of '%s'",
-              String::Handle(I, type_bound.UserVisibleName()).ToCString());
+              String::Handle(Z, type_bound.UserVisibleName()).ToCString());
           new_object = ThrowTypeError(new_pos, type_bound);
         }
         type_bound = AbstractType::null();
@@ -11539,7 +11548,7 @@
         new_pos, type_arguments, constructor, arguments);
   }
   if (!type_bound.IsNull()) {
-    new_object = new(I) AssignableNode(
+    new_object = new(Z) AssignableNode(
          new_pos, new_object, type_bound, Symbols::FactoryResult());
   }
   return new_object;
@@ -11548,14 +11557,14 @@
 
 String& Parser::Interpolate(const GrowableArray<AstNode*>& values) {
   const Class& cls = Class::Handle(
-      I, Library::LookupCoreClass(Symbols::StringBase()));
+      Z, Library::LookupCoreClass(Symbols::StringBase()));
   ASSERT(!cls.IsNull());
-  const Function& func = Function::Handle(I, cls.LookupStaticFunction(
+  const Function& func = Function::Handle(Z, cls.LookupStaticFunction(
       Library::PrivateCoreLibName(Symbols::Interpolate())));
   ASSERT(!func.IsNull());
 
   // Build the array of literal values to interpolate.
-  const Array& value_arr = Array::Handle(I, Array::New(values.length()));
+  const Array& value_arr = Array::Handle(Z, Array::New(values.length()));
   for (int i = 0; i < values.length(); i++) {
     ASSERT(values[i]->IsLiteralNode());
     value_arr.SetAt(i, values[i]->AsLiteralNode()->literal());
@@ -11562,11 +11571,11 @@
   }
 
   // Build argument array to pass to the interpolation function.
-  const Array& interpolate_arg = Array::Handle(I, Array::New(1));
+  const Array& interpolate_arg = Array::Handle(Z, Array::New(1));
   interpolate_arg.SetAt(0, value_arr);
 
   // Call interpolation function.
-  Object& result = Object::Handle(I);
+  Object& result = Object::Handle(Z);
   {
     PAUSETIMERSCOPE(I, time_compilation);
     result = DartEntry::InvokeFunction(func, interpolate_arg);
@@ -11574,7 +11583,7 @@
   if (result.IsUnhandledException()) {
     ReportError("%s", Error::Cast(result).ToErrorCString());
   }
-  String& concatenated = String::ZoneHandle(I);
+  String& concatenated = String::ZoneHandle(Z);
   concatenated ^= result.raw();
   concatenated = Symbols::New(concatenated);
   return concatenated;
@@ -11597,7 +11606,7 @@
       (l1_token != Token::kINTERPOL_VAR) &&
       (l1_token != Token::kINTERPOL_START)) {
     // Common case: no interpolation.
-    primary = new(I) LiteralNode(literal_start, *CurrentLiteral());
+    primary = new(Z) LiteralNode(literal_start, *CurrentLiteral());
     ConsumeToken();
     return primary;
   }
@@ -11609,7 +11618,7 @@
     if (CurrentLiteral()->Length() > 0) {
       // Only add non-empty string sections to the values list
       // that will be concatenated.
-      values_list.Add(new(I) LiteralNode(TokenPos(), *CurrentLiteral()));
+      values_list.Add(new(Z) LiteralNode(TokenPos(), *CurrentLiteral()));
     }
     ConsumeToken();
     while ((CurrentToken() == Token::kINTERPOL_VAR) ||
@@ -11643,7 +11652,7 @@
             const_expr->IsBool() ||
             const_expr->IsNull())) {
           // Change expr into a literal.
-          expr = new(I) LiteralNode(expr_pos,
+          expr = new(Z) LiteralNode(expr_pos,
                                     EvaluateConstExpr(expr_pos, expr));
         } else {
           is_compiletime_const = false;
@@ -11654,25 +11663,25 @@
   }
   if (is_compiletime_const) {
     if (has_interpolation) {
-      primary = new(I) LiteralNode(literal_start, Interpolate(values_list));
+      primary = new(Z) LiteralNode(literal_start, Interpolate(values_list));
     } else {
-      const Array& strings = Array::Handle(I, Array::New(values_list.length()));
+      const Array& strings = Array::Handle(Z, 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(I,
+      String& lit = String::ZoneHandle(Z,
                                        String::ConcatAll(strings, Heap::kOld));
       lit = Symbols::New(lit);
-      primary = new(I) LiteralNode(literal_start, lit);
+      primary = new(Z) LiteralNode(literal_start, lit);
     }
   } else {
-    ArrayNode* values = new(I) ArrayNode(
+    ArrayNode* values = new(Z) ArrayNode(
         TokenPos(),
-        Type::ZoneHandle(I, Type::ArrayType()),
+        Type::ZoneHandle(Z, Type::ArrayType()),
         values_list);
-    primary = new(I) StringInterpolateNode(TokenPos(), values);
+    primary = new(Z) StringInterpolateNode(TokenPos(), values);
   }
   return primary;
 }
@@ -11691,7 +11700,7 @@
     CloseBlock();
   } else if (IsIdentifier()) {
     intptr_t qual_ident_pos = TokenPos();
-    const LibraryPrefix& prefix = LibraryPrefix::ZoneHandle(I, ParsePrefix());
+    const LibraryPrefix& prefix = LibraryPrefix::ZoneHandle(Z, ParsePrefix());
     String& ident = *CurrentLiteral();
     ConsumeToken();
     if (prefix.IsNull()) {
@@ -11698,10 +11707,10 @@
       if (!ResolveIdentInLocalScope(qual_ident_pos, ident, &primary)) {
         // Check whether the identifier is a type parameter.
         if (!current_class().IsNull()) {
-          TypeParameter& type_param = TypeParameter::ZoneHandle(I,
+          TypeParameter& type_param = TypeParameter::ZoneHandle(Z,
               current_class().LookupTypeParameter(ident));
           if (!type_param.IsNull()) {
-            return new(I) PrimaryNode(qual_ident_pos, type_param);
+            return new(Z) PrimaryNode(qual_ident_pos, type_param);
           }
         }
         // This is a non-local unqualified identifier so resolve the
@@ -11727,7 +11736,7 @@
           // let ParseSelectors() handle the loadLibrary call.
           SetPosition(qual_ident_pos);
           ConsumeToken();  // Prefix name.
-          primary = new(I) LiteralNode(qual_ident_pos, prefix);
+          primary = new(Z) LiteralNode(qual_ident_pos, prefix);
         } else {
           // TODO(hausner): Ideally we should generate the NoSuchMethodError
           // later, when we know more about how the unresolved name is used.
@@ -11739,7 +11748,7 @@
           // 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(I, prefix.name());
+          String& qualified_name = String::ZoneHandle(Z, prefix.name());
           qualified_name = String::Concat(qualified_name, Symbols::Dot());
           qualified_name = String::Concat(qualified_name, ident);
           qualified_name = Symbols::New(qualified_name);
@@ -11762,20 +11771,20 @@
     if (local == NULL) {
       ReportError("receiver 'this' is not in scope");
     }
-    primary = new(I) LoadLocalNode(TokenPos(), local);
+    primary = new(Z) LoadLocalNode(TokenPos(), local);
     ConsumeToken();
   } else if (token == Token::kINTEGER) {
-    const Integer& literal = Integer::ZoneHandle(I, CurrentIntegerLiteral());
-    primary = new(I) LiteralNode(TokenPos(), literal);
+    const Integer& literal = Integer::ZoneHandle(Z, CurrentIntegerLiteral());
+    primary = new(Z) LiteralNode(TokenPos(), literal);
     ConsumeToken();
   } else if (token == Token::kTRUE) {
-    primary = new(I) LiteralNode(TokenPos(), Bool::True());
+    primary = new(Z) LiteralNode(TokenPos(), Bool::True());
     ConsumeToken();
   } else if (token == Token::kFALSE) {
-    primary = new(I) LiteralNode(TokenPos(), Bool::False());
+    primary = new(Z) LiteralNode(TokenPos(), Bool::False());
     ConsumeToken();
   } else if (token == Token::kNULL) {
-    primary = new(I) LiteralNode(TokenPos(), Instance::ZoneHandle(I));
+    primary = new(Z) LiteralNode(TokenPos(), Instance::ZoneHandle(Z));
     ConsumeToken();
   } else if (token == Token::kLPAREN) {
     ConsumeToken();
@@ -11784,11 +11793,11 @@
     SetAllowFunctionLiterals(saved_mode);
     ExpectToken(Token::kRPAREN);
   } else if (token == Token::kDOUBLE) {
-    Double& double_value = Double::ZoneHandle(I, CurrentDoubleLiteral());
+    Double& double_value = Double::ZoneHandle(Z, CurrentDoubleLiteral());
     if (double_value.IsNull()) {
       ReportError("invalid double literal");
     }
-    primary = new(I) LiteralNode(TokenPos(), double_value);
+    primary = new(Z) LiteralNode(TokenPos(), double_value);
     ConsumeToken();
   } else if (token == Token::kSTRING) {
     primary = ParseStringLiteral(true);
@@ -11818,13 +11827,13 @@
     }
     if (current_class().SuperClass() == Class::null()) {
       ReportError("class '%s' does not have a superclass",
-                  String::Handle(I, current_class().Name()).ToCString());
+                  String::Handle(Z, current_class().Name()).ToCString());
     }
     if (current_class().IsMixinApplication()) {
-      const Type& mixin_type = Type::Handle(I, current_class().mixin());
+      const Type& mixin_type = Type::Handle(Z, current_class().mixin());
       if (mixin_type.type_class() == current_function().origin()) {
         ReportError("method of mixin class '%s' may not refer to 'super'",
-                    String::Handle(I, Class::Handle(I,
+                    String::Handle(Z, Class::Handle(Z,
                         current_function().origin()).Name()).ToCString());
       }
     }
@@ -11844,7 +11853,7 @@
         (CurrentToken() == Token::kNE)) {
       primary = ParseSuperOperator();
     } else {
-      primary = new(I) PrimaryNode(super_pos, Symbols::Super());
+      primary = new(Z) PrimaryNode(super_pos, Symbols::Super());
     }
   } else {
     UnexpectedToken();
@@ -11868,17 +11877,17 @@
     ASSERT(field.is_const());
     ASSERT(field.value() != Object::sentinel().raw());
     ASSERT(field.value() != Object::transition_sentinel().raw());
-    return Instance::ZoneHandle(I, field.value());
+    return Instance::ZoneHandle(Z, field.value());
   } else {
     ASSERT(expr->EvalConstExpr() != NULL);
-    ReturnNode* ret = new(I) ReturnNode(expr->token_pos(), expr);
+    ReturnNode* ret = new(Z) ReturnNode(expr->token_pos(), expr);
     // Compile time constant expressions cannot reference anything from a
     // local scope.
-    LocalScope* empty_scope = new(I) LocalScope(NULL, 0, 0);
-    SequenceNode* seq = new(I) SequenceNode(expr->token_pos(), empty_scope);
+    LocalScope* empty_scope = new(Z) LocalScope(NULL, 0, 0);
+    SequenceNode* seq = new(Z) SequenceNode(expr->token_pos(), empty_scope);
     seq->Add(ret);
 
-    Object& result = Object::Handle(I, Compiler::ExecuteOnce(seq));
+    Object& result = Object::Handle(Z, Compiler::ExecuteOnce(seq));
     if (result.IsError()) {
       ReportErrors(Error::Cast(result),
                    script_, expr_pos,
@@ -11885,7 +11894,7 @@
                    "error evaluating constant expression");
     }
     ASSERT(result.IsInstance());
-    Instance& value = Instance::ZoneHandle(I);
+    Instance& value = Instance::ZoneHandle(Z);
     value ^= result.raw();
     value = TryCanonicalize(value, TokenPos());
     return value;