- Use isolate where it is appropriate.

runtime/vm/parser.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/parser.h"
 
 #include "lib/invocation_mirror.h"
 #include "platform/utils.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 287 matching lines @@
       is_top_level_(false),
       parsing_metadata_(false),
       current_member_(NULL),
       allow_function_literals_(true),
       parsed_function_(parsed_function),
       innermost_function_(Function::Handle(isolate_,
                                            parsed_function->function().raw())),
       literal_token_(LiteralToken::Handle(isolate_)),
       current_class_(Class::Handle(isolate_,
                                    parsed_function->function().Owner())),
-      library_(Library::Handle(Class::Handle(
+      library_(Library::Handle(isolate_, Class::Handle(

[Cutch, 2014/05/27 10:00:02]

Should this use isolate() instead of isolate_?

[Ivan Posva, 2014/05/27 10:15:53]

This is in the constructor, so I use isolate_ like the other places above.

           isolate_,
           parsed_function->function().origin()).library())),
       try_blocks_list_(NULL),
       last_used_try_index_(0),
       unregister_pending_function_(false) {
   ASSERT(tokens_iterator_.IsValid());
   ASSERT(!current_function().IsNull());
   if (FLAG_enable_type_checks) {
     EnsureExpressionTemp();
   }
 }
 
 
 Parser::~Parser() {
   if (unregister_pending_function_) {
     const GrowableObjectArray& pending_functions =
         GrowableObjectArray::Handle(
             isolate()->object_store()->pending_functions());
     ASSERT(pending_functions.Length() > 0);
     ASSERT(pending_functions.At(pending_functions.Length()-1) ==
         current_function().raw());
     pending_functions.RemoveLast();
   }
 }
 
 
 void Parser::SetScript(const Script& script, intptr_t token_pos) {
   script_ = script.raw();
-  tokens_iterator_.SetStream(TokenStream::Handle(script.tokens()), token_pos);
+  tokens_iterator_.SetStream(
+      TokenStream::Handle(isolate(), script.tokens()), token_pos);
   token_kind_ = Token::kILLEGAL;
 }
 
 
 bool Parser::SetAllowFunctionLiterals(bool value) {
   bool current_value = allow_function_literals_;
   allow_function_literals_ = value;
   return current_value;
 }
 
@@ skipping 70 matching lines @@
   ASSERT(literal_token_.kind() == Token::kDOUBLE);
   return Double::RawCast(literal_token_.value());
 }
 
 
 RawInteger* Parser::CurrentIntegerLiteral() const {
   literal_token_ ^= tokens_iterator_.CurrentToken();
   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(ri);
+    const Integer& i = Integer::Handle(isolate(), ri);
     if (i.CheckJavascriptIntegerOverflow()) {
       ErrorMsg(TokenPos(),
           "Integer literal does not fit in a Javascript integer: %s.",
           i.ToCString());
     }
   }
   return ri;
 }
 
 
@@ skipping 436 matching lines @@
 
   parsed_function->set_default_parameter_values(default_parameter_values);
 }
 
 
 RawObject* Parser::ParseMetadata(const Class& cls, intptr_t token_pos) {
   Isolate* isolate = Isolate::Current();
   StackZone zone(isolate);
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
-    const Script& script = Script::Handle(cls.script());
-    const Library& lib = Library::Handle(cls.library());
+    const Script& script = Script::Handle(isolate, cls.script());

[Cutch, 2014/05/27 10:00:02]

You can use: isolate() right?

[Ivan Posva, 2014/05/27 10:15:53]

No, as this is a static method.

+    const Library& lib = Library::Handle(isolate, cls.library());
     Parser parser(script, lib, token_pos);
     parser.set_current_class(cls);
     parser.set_parsing_metadata(true);
 
     RawObject* metadata = parser.EvaluateMetadata();
     return metadata;
   } else {
-    Error& error = Error::Handle();
+    Error& error = Error::Handle(isolate);
     error = isolate->object_store()->sticky_error();
     isolate->object_store()->clear_sticky_error();
     return error.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 
 RawArray* Parser::EvaluateMetadata() {
   CheckToken(Token::kAT, "Metadata character '@' expected");
   GrowableObjectArray& meta_values =
-      GrowableObjectArray::Handle(GrowableObjectArray::New());
+      GrowableObjectArray::Handle(isolate(), GrowableObjectArray::New());
   while (CurrentToken() == Token::kAT) {
     ConsumeToken();
     intptr_t expr_pos = TokenPos();
     if (!IsIdentifier()) {
       ExpectIdentifier("identifier expected");
     }
     // Reject expressions with deferred library prefix eagerly.
-    Object& obj = Object::Handle(library_.LookupLocalObject(*CurrentLiteral()));
+    Object& obj = Object::Handle(isolate(),
+                                 library_.LookupLocalObject(*CurrentLiteral()));
     if (!obj.IsNull() && obj.IsLibraryPrefix()) {
       if (LibraryPrefix::Cast(obj).is_deferred_load()) {
         ErrorMsg("Metadata must be compile-time constant");
       }
     }
     AstNode* expr = NULL;
     if ((LookaheadToken(1) == Token::kLPAREN) ||
         ((LookaheadToken(1) == Token::kPERIOD) &&
             (LookaheadToken(3) == Token::kLPAREN)) ||
         ((LookaheadToken(1) == Token::kPERIOD) &&
             (LookaheadToken(3) == Token::kPERIOD) &&
             (LookaheadToken(5) == Token::kLPAREN))) {
       expr = ParseNewOperator(Token::kCONST);
     } else {
       // Can be x, C.x, or L.C.x.
       expr = ParsePrimary();  // Consumes x, C or L.C.
-      Class& cls = Class::Handle();
+      Class& cls = Class::Handle(isolate());
       if (expr->IsPrimaryNode()) {
         PrimaryNode* primary_node = expr->AsPrimaryNode();
         if (primary_node->primary().IsClass()) {
           // If the primary node referred to a class we are loading a
           // qualified static field.
           cls ^= primary_node->primary().raw();
         } else {
           ErrorMsg(expr_pos, "Metadata expressions must refer to a const field "
                              "or constructor");
         }
       }
       if (CurrentToken() == Token::kPERIOD) {
         // C.x or L.C.X.
         if (cls.IsNull()) {
           ErrorMsg(expr_pos, "Metadata expressions must refer to a const field "
                              "or constructor");
         }
         ConsumeToken();
         const intptr_t ident_pos = TokenPos();
         String* ident = ExpectIdentifier("identifier expected");
-        const Field& field = Field::Handle(cls.LookupStaticField(*ident));
+        const Field& field = Field::Handle(isolate(),
+                                           cls.LookupStaticField(*ident));
         if (field.IsNull()) {
           ErrorMsg(ident_pos,
                    "Class '%s' has no field '%s'",
                    cls.ToCString(),
                    ident->ToCString());
         }
         if (!field.is_const()) {
           ErrorMsg(ident_pos,
                    "Field '%s' of class '%s' is not const",
                    ident->ToCString(),
@@ skipping 10 matching lines @@
   }
   return Array::MakeArray(meta_values);
 }
 
 
 SequenceNode* Parser::ParseStaticFinalGetter(const Function& func) {
   TRACE_PARSER("ParseStaticFinalGetter");
   ParamList params;
   ASSERT(func.num_fixed_parameters() == 0);  // static.
   ASSERT(!func.HasOptionalParameters());
-  ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
+  ASSERT(AbstractType::Handle(isolate(), func.result_type()).IsResolved());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   intptr_t ident_pos = TokenPos();
   const String& field_name = *ExpectIdentifier("field name expected");
-  const Class& field_class = Class::Handle(func.Owner());
+  const Class& field_class = Class::Handle(isolate(), func.Owner());
   const Field& field =
       Field::ZoneHandle(field_class.LookupStaticField(field_name));
 
   // Static final fields must have an initializer.
   ExpectToken(Token::kASSIGN);
 
   const intptr_t expr_pos = TokenPos();
   if (field.is_const()) {
     // We don't want to use ParseConstExpr() here because we don't want
     // the constant folding code to create, compile and execute a code
@@ skipping 51 matching lines @@
         ident_pos,
         Token::kEQ_STRICT,
         new LoadStaticFieldNode(ident_pos, field),
         new LiteralNode(ident_pos, Object::sentinel()));
     SequenceNode* initialize_field = new SequenceNode(ident_pos, NULL);
     initialize_field->Add(
         new StoreStaticFieldNode(
             ident_pos,
             field,
             new LiteralNode(ident_pos, Object::transition_sentinel())));
-    const String& init_name = String::Handle(
-        Symbols::New(String::Handle(String::Concat(
-            Symbols::InitPrefix(), String::Handle(field.name())))));
+    const String& init_name = String::Handle(isolate(), Symbols::New(
+        String::Handle(isolate(), String::Concat(
+            Symbols::InitPrefix(), String::Handle(isolate(), field.name())))));
     const Function& init_function = Function::ZoneHandle(
         field_class.LookupStaticFunction(init_name));
     ASSERT(!init_function.IsNull());
     ArgumentListNode* arguments = new ArgumentListNode(expr_pos);
     StaticCallNode* init_call =
         new StaticCallNode(expr_pos, init_function, arguments);
     initialize_field->Add(init_call);
 
     AstNode* uninitialized_check =
         new IfNode(ident_pos, compare_uninitialized, initialize_field, NULL);
     current_block_->statements->Add(uninitialized_check);
 
     // Generate code returning the field value.
     ReturnNode* return_node =
         new ReturnNode(ident_pos,
                        new LoadStaticFieldNode(ident_pos, field));
     current_block_->statements->Add(return_node);
   }
   return CloseBlock();
 }
 
 
 SequenceNode* Parser::ParseStaticInitializer(const Function& func) {
   TRACE_PARSER("ParseStaticInitializer");
   ParamList params;
   ASSERT(func.num_fixed_parameters() == 0);  // static.
   ASSERT(!func.HasOptionalParameters());
-  ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
+  ASSERT(AbstractType::Handle(isolate(), func.result_type()).IsResolved());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   // Move forward to the start of the initializer expression.
   intptr_t ident_pos = TokenPos();
   ExpectIdentifier("identifier expected");
   ExpectToken(Token::kASSIGN);
   intptr_t token_pos = TokenPos();
@@ skipping 86 matching lines @@
 //   ReturnNode (field's value);
 SequenceNode* Parser::ParseInstanceGetter(const Function& func) {
   TRACE_PARSER("ParseInstanceGetter");
   ParamList params;
   // func.token_pos() points to the name of the field.
   const intptr_t ident_pos = func.token_pos();
   ASSERT(current_class().raw() == func.Owner());
   params.AddReceiver(ReceiverType(current_class()), ident_pos);
   ASSERT(func.num_fixed_parameters() == 1);  // receiver.
   ASSERT(!func.HasOptionalParameters());
-  ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
+  ASSERT(AbstractType::Handle(isolate(), func.result_type()).IsResolved());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   // Receiver is local 0.
   LocalVariable* receiver = current_block_->scope->VariableAt(0);
   LoadLocalNode* load_receiver = new LoadLocalNode(ident_pos, receiver);
   ASSERT(IsIdentifier());
   const String& field_name = *CurrentLiteral();
-  const Class& field_class = Class::Handle(func.Owner());
+  const Class& field_class = Class::Handle(isolate(), func.Owner());
   const Field& field =
       Field::ZoneHandle(field_class.LookupInstanceField(field_name));
 
   LoadInstanceFieldNode* load_field =
       new LoadInstanceFieldNode(ident_pos, load_receiver, field);
 
   ReturnNode* return_node =
       new ReturnNode(Scanner::kNoSourcePos, load_field);
   current_block_->statements->Add(return_node);
   return CloseBlock();
@@ skipping 16 matching lines @@
   const AbstractType& field_type = AbstractType::ZoneHandle(field.type());
 
   ParamList params;
   ASSERT(current_class().raw() == func.Owner());
   params.AddReceiver(ReceiverType(current_class()), ident_pos);
   params.AddFinalParameter(ident_pos,
                            &Symbols::Value(),
                            &field_type);
   ASSERT(func.num_fixed_parameters() == 2);  // receiver, value.
   ASSERT(!func.HasOptionalParameters());
-  ASSERT(AbstractType::Handle(func.result_type()).IsVoidType());
+  ASSERT(AbstractType::Handle(isolate(), func.result_type()).IsVoidType());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   LoadLocalNode* receiver =
       new LoadLocalNode(ident_pos, current_block_->scope->VariableAt(0));
   LoadLocalNode* value =
       new LoadLocalNode(ident_pos, current_block_->scope->VariableAt(1));
 
@@ skipping 79 matching lines @@
 
 SequenceNode* Parser::ParseNoSuchMethodDispatcher(const Function& func,
                                                   Array* default_values) {
   TRACE_PARSER("ParseNoSuchMethodDispatcher");
 
   ASSERT(func.IsNoSuchMethodDispatcher());
   intptr_t token_pos = func.token_pos();
   ASSERT(func.token_pos() == 0);
   ASSERT(current_class().raw() == func.Owner());
 
-  ArgumentsDescriptor desc(Array::Handle(func.saved_args_desc()));
+  ArgumentsDescriptor desc(Array::Handle(isolate(), func.saved_args_desc()));
   ASSERT(desc.Count() > 0);
 
   // Set up scope for this function.
   BuildDispatcherScope(func, desc, default_values);
 
   // Receiver is local 0.
   LocalScope* scope = current_block_->scope;
   ArgumentListNode* func_args = new ArgumentListNode(token_pos);
   for (intptr_t i = 0; i < desc.Count(); ++i) {
     func_args->Add(new LoadLocalNode(token_pos, scope->VariableAt(i)));
   }
 
   if (desc.NamedCount() > 0) {
     const Array& arg_names = Array::ZoneHandle(Array::New(desc.NamedCount()));
     for (intptr_t i = 0; i < arg_names.Length(); ++i) {
-      arg_names.SetAt(i, String::Handle(desc.NameAt(i)));
+      arg_names.SetAt(i, String::Handle(isolate(), desc.NameAt(i)));
     }
     func_args->set_names(arg_names);
   }
 
   const String& func_name = String::ZoneHandle(func.name());
   ArgumentListNode* arguments = BuildNoSuchMethodArguments(
       token_pos, func_name, *func_args, NULL, false);
   const Function& no_such_method = Function::ZoneHandle(
-      Resolver::ResolveDynamicAnyArgs(Class::Handle(func.Owner()),
-                                      Symbols::NoSuchMethod()));
+      Resolver::ResolveDynamicAnyArgs(Class::Handle(
+          isolate(), func.Owner()), Symbols::NoSuchMethod()));
   StaticCallNode* call =
       new StaticCallNode(token_pos, no_such_method, arguments);
 
   ReturnNode* return_node = new ReturnNode(token_pos, call);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 SequenceNode* Parser::ParseInvokeFieldDispatcher(const Function& func,
                                                  Array* default_values) {
   TRACE_PARSER("ParseInvokeFieldDispatcher");
 
   ASSERT(func.IsInvokeFieldDispatcher());
   intptr_t token_pos = func.token_pos();
   ASSERT(func.token_pos() == 0);
   ASSERT(current_class().raw() == func.Owner());
 
-  const Array& args_desc = Array::Handle(func.saved_args_desc());
+  const Array& args_desc = Array::Handle(isolate(), func.saved_args_desc());
   ArgumentsDescriptor desc(args_desc);
   ASSERT(desc.Count() > 0);
 
   // Set up scope for this function.
   BuildDispatcherScope(func, desc, default_values);
 
   // Receiver is local 0.
   LocalScope* scope = current_block_->scope;
   ArgumentListNode* no_args = new ArgumentListNode(token_pos);
   LoadLocalNode* receiver = new LoadLocalNode(token_pos, scope->VariableAt(0));
 
-  const String& name = String::Handle(func.name());
-  const String& getter_name =
-      String::ZoneHandle(Symbols::New(String::Handle(Field::GetterName(name))));
-  InstanceCallNode* getter_call = new InstanceCallNode(token_pos,
-                                                       receiver,
-                                                       getter_name,
-                                                       no_args);
+  const String& name = String::Handle(isolate(), func.name());
+  const String& getter_name = String::ZoneHandle(

[srdjan, 2014/05/27 10:00:53]

pass isolate to ZoneHandle as well

[Ivan Posva, 2014/05/27 10:15:53]

This change only dealt with Handle, even though there are some sprinkled
ZoneHandles adjusted. Different CL.

+      Symbols::New(String::Handle(isolate(), Field::GetterName(name))));
+  InstanceCallNode* getter_call = new(isolate()) InstanceCallNode(
+      token_pos, receiver, getter_name, no_args);
 
   // Pass arguments 1..n to the closure call.
   ArgumentListNode* args = new ArgumentListNode(token_pos);
-  const Array& names = Array::Handle(Array::New(desc.NamedCount(), Heap::kOld));
+  const Array& names = Array::Handle(
+      isolate(), Array::New(desc.NamedCount(), Heap::kOld));
   // Positional parameters.
   intptr_t i = 1;
   for (; i < desc.PositionalCount(); ++i) {
     args->Add(new LoadLocalNode(token_pos, scope->VariableAt(i)));
   }
   // Named parameters.
   for (; i < desc.Count(); i++) {
     args->Add(new LoadLocalNode(token_pos, scope->VariableAt(i)));
     intptr_t index = i - desc.PositionalCount();
-    names.SetAt(index, String::Handle(desc.NameAt(index)));
+    names.SetAt(index, String::Handle(isolate(), desc.NameAt(index)));
   }
   args->set_names(names);
 
-  const Class& owner = Class::Handle(func.Owner());
+  const Class& owner = Class::Handle(isolate(), func.Owner());
   ASSERT(!owner.IsNull());
   AstNode* result = NULL;
   if (owner.IsSignatureClass() && name.Equals(Symbols::Call())) {
     EnsureSavedCurrentContext();
     result = new ClosureCallNode(token_pos, getter_call, args);
   } else {
     result = BuildClosureCall(token_pos, getter_call, args);
   }
 
   ReturnNode* return_node = new ReturnNode(token_pos, result);
@@ skipping 154 matching lines @@
     }
   }
 
   if (CurrentToken() == Token::kLPAREN) {
     // This parameter is probably a closure. If we saw the keyword 'var'
     // or 'final', a closure is not legal here and we ignore the
     // opening parens.
     if (!var_seen && !parameter.is_final) {
       // The parsed parameter type is actually the function result type.
       const AbstractType& result_type =
-          AbstractType::Handle(parameter.type->raw());
+          AbstractType::Handle(isolate(), parameter.type->raw());
 
       // Finish parsing the function type parameter.
       ParamList func_params;
 
       // Add implicit closure object parameter.
       func_params.AddFinalParameter(
           TokenPos(),
           &Symbols::ClosureParameter(),
           &Type::ZoneHandle(Type::DynamicType()));
 
       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(
+      const Function& signature_function = Function::Handle(isolate(),
           Function::New(*parameter.name,
                         RawFunction::kSignatureFunction,
                         /* is_static = */ false,
                         /* is_const = */ false,
                         /* is_abstract = */ false,
                         /* is_external = */ false,
                         /* is_native = */ false,
                         current_class(),
                         parameter.name_pos));
       signature_function.set_result_type(result_type);
       AddFormalParamsToFunction(&func_params, signature_function);
-      const String& signature = String::Handle(signature_function.Signature());
+      const String& signature = String::Handle(isolate(),
+                                               signature_function.Signature());
       // Lookup the signature class, i.e. the class whose name is the signature.
       // We only lookup in the current library, but not in its imports, and only
       // create a new canonical signature class if it does not exist yet.
       Class& signature_class = Class::ZoneHandle(
           library_.LookupLocalClass(signature));
       if (signature_class.IsNull()) {
         signature_class = Class::NewSignatureClass(signature,
                                                    signature_function,
                                                    script_,
                                                    parameter.name_pos);
@@ skipping 139 matching lines @@
 
 // Resolve and return the dynamic function of the given name in the superclass.
 // If it is not found, and resolve_getter is true, try to resolve a getter of
 // the same name. If it is still not found, return noSuchMethod and
 // set is_no_such_method to true..
 RawFunction* Parser::GetSuperFunction(intptr_t token_pos,
                                       const String& name,
                                       ArgumentListNode* arguments,
                                       bool resolve_getter,
                                       bool* is_no_such_method) {
-  const Class& super_class = Class::Handle(current_class().SuperClass());
+  const Class& super_class = Class::Handle(
+      isolate(), current_class().SuperClass());
   if (super_class.IsNull()) {
     ErrorMsg(token_pos, "class '%s' does not have a superclass",
-             String::Handle(current_class().Name()).ToCString());
+             String::Handle(isolate(), current_class().Name()).ToCString());
   }
-  Function& super_func = Function::Handle(
+  Function& super_func = Function::Handle(isolate(),
       Resolver::ResolveDynamicAnyArgs(super_class, name));
   if (!super_func.IsNull() &&
       !super_func.AreValidArguments(arguments->length(),
                                     arguments->names(),
                                     NULL)) {
     super_func = Function::null();
   } else if (super_func.IsNull() && resolve_getter) {
     const String& getter_name = String::ZoneHandle(Field::GetterName(name));
     super_func = Resolver::ResolveDynamicAnyArgs(super_class, getter_name);
     ASSERT(super_func.IsNull() ||
@@ skipping 221 matching lines @@
 ClosureNode* Parser::CreateImplicitClosureNode(const Function& func,
                                                intptr_t token_pos,
                                                AstNode* receiver) {
   Function& implicit_closure_function =
       Function::ZoneHandle(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(
+      const Class& signature_class = Class::Handle(isolate(),
           implicit_closure_function.signature_class());
       if (signature_class.NumTypeParameters() > 0) {
         CaptureInstantiator();
       }
     }
   }
   return new ClosureNode(token_pos, implicit_closure_function, receiver, NULL);
 }
 
 
 AstNode* Parser::ParseSuperFieldAccess(const String& field_name,
                                        intptr_t field_pos) {
   TRACE_PARSER("ParseSuperFieldAccess");
   const Class& super_class = Class::ZoneHandle(current_class().SuperClass());
   if (super_class.IsNull()) {
     ErrorMsg("class '%s' does not have a superclass",
-             String::Handle(current_class().Name()).ToCString());
+             String::Handle(isolate(), current_class().Name()).ToCString());
   }
   AstNode* implicit_argument = LoadReceiver(field_pos);
 
   const String& getter_name =
       String::ZoneHandle(Field::GetterName(field_name));
   const Function& super_getter = Function::ZoneHandle(
       Resolver::ResolveDynamicAnyArgs(super_class, getter_name));
   if (super_getter.IsNull()) {
     const String& setter_name =
         String::ZoneHandle(Field::SetterName(field_name));
@@ skipping 19 matching lines @@
   }
   return new StaticGetterNode(
       field_pos, implicit_argument, true, super_class, field_name);
 }
 
 
 void Parser::GenerateSuperConstructorCall(const Class& cls,
                                           intptr_t supercall_pos,
                                           LocalVariable* receiver,
                                           ArgumentListNode* forwarding_args) {
-  const Class& super_class = Class::Handle(cls.SuperClass());
+  const Class& super_class = Class::Handle(isolate(), 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(super_class.SuperClass()).IsObjectClass())) {
+       Class::Handle(isolate(), super_class.SuperClass()).IsObjectClass())) {
     return;
   }
-  String& super_ctor_name = String::Handle(super_class.Name());
+  String& super_ctor_name = String::Handle(isolate(), super_class.Name());
   super_ctor_name = String::Concat(super_ctor_name, Symbols::Dot());
 
   ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
   // Implicit 'this' parameter is the first argument.
   AstNode* implicit_argument = new LoadLocalNode(supercall_pos, receiver);
   arguments->Add(implicit_argument);
   // Implicit construction phase parameter is second argument.
   AstNode* phase_parameter =
       new LiteralNode(supercall_pos,
                       Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll)));
   arguments->Add(phase_parameter);
 
   // If this is a super call in a forwarding constructor, add the user-
   // defined arguments to the super call and adjust the the super
   // constructor name to the respective named constructor if necessary.
   if (forwarding_args != NULL) {
     for (int i = 0; i < forwarding_args->length(); i++) {
       arguments->Add(forwarding_args->NodeAt(i));
     }
-    String& ctor_name = String::Handle(current_function().name());
-    String& class_name = String::Handle(cls.Name());
+    String& ctor_name = String::Handle(isolate(), current_function().name());
+    String& class_name = String::Handle(isolate(), cls.Name());
     if (ctor_name.Length() > class_name.Length() + 1) {
       // Generating a forwarding call to a named constructor 'C.n'.
       // Add the constructor name 'n' to the super constructor.
       ctor_name = String::SubString(ctor_name, class_name.Length() + 1);
       super_ctor_name = String::Concat(super_ctor_name, ctor_name);
     }
   }
 
   // Resolve super constructor function and check arguments.
   const Function& super_ctor = Function::ZoneHandle(
       super_class.LookupConstructor(super_ctor_name));
   if (super_ctor.IsNull()) {
       ErrorMsg(supercall_pos,
                "unresolved implicit call to super constructor '%s()'",
-               String::Handle(super_class.Name()).ToCString());
+               String::Handle(isolate(), super_class.Name()).ToCString());
   }
   if (current_function().is_const() && !super_ctor.is_const()) {
     ErrorMsg(supercall_pos, "implicit call to non-const super constructor");
   }
 
-  String& error_message = String::Handle();
+  String& error_message = String::Handle(isolate());
   if (!super_ctor.AreValidArguments(arguments->length(),
                                     arguments->names(),
                                     &error_message)) {
     ErrorMsg(supercall_pos,
              "invalid arguments passed to super constructor '%s()': %s",
-             String::Handle(super_class.Name()).ToCString(),
+             String::Handle(isolate(), super_class.Name()).ToCString(),
              error_message.ToCString());
   }
   current_block_->statements->Add(
       new StaticCallNode(supercall_pos, super_ctor, arguments));
 }
 
 
 AstNode* Parser::ParseSuperInitializer(const Class& cls,
                                        LocalVariable* receiver) {
   TRACE_PARSER("ParseSuperInitializer");
   ASSERT(CurrentToken() == Token::kSUPER);
   const intptr_t supercall_pos = TokenPos();
   ConsumeToken();
-  const Class& super_class = Class::Handle(cls.SuperClass());
+  const Class& super_class = Class::Handle(isolate(), cls.SuperClass());
   ASSERT(!super_class.IsNull());
-  String& ctor_name = String::Handle(super_class.Name());
+  String& ctor_name = String::Handle(isolate(), super_class.Name());
   ctor_name = String::Concat(ctor_name, Symbols::Dot());
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     ctor_name = String::Concat(ctor_name,
                                *ExpectIdentifier("constructor name expected"));
   }
   CheckToken(Token::kLPAREN, "parameter list expected");
 
   ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
   // 'this' parameter is the first argument to super class constructor.
@@ skipping 16 matching lines @@
   const Function& super_ctor = Function::ZoneHandle(
       super_class.LookupConstructor(ctor_name));
   if (super_ctor.IsNull()) {
     ErrorMsg(supercall_pos,
              "super class constructor '%s' not found",
              ctor_name.ToCString());
   }
   if (current_function().is_const() && !super_ctor.is_const()) {
     ErrorMsg(supercall_pos, "super constructor must be const");
   }
-  String& error_message = String::Handle();
+  String& error_message = String::Handle(isolate());
   if (!super_ctor.AreValidArguments(arguments->length(),
                                     arguments->names(),
                                     &error_message)) {
     ErrorMsg(supercall_pos,
              "invalid arguments passed to super class constructor '%s': %s",
              ctor_name.ToCString(),
              error_message.ToCString());
   }
   return new StaticCallNode(supercall_pos, super_ctor, arguments);
 }
@@ skipping 30 matching lines @@
              field_name.ToCString());
   }
   CheckDuplicateFieldInit(field_pos, initialized_fields, &field);
   AstNode* instance = new LoadLocalNode(field_pos, receiver);
   EnsureExpressionTemp();
   return new StoreInstanceFieldNode(field_pos, instance, field, init_expr);
 }
 
 
 void Parser::CheckFieldsInitialized(const Class& cls) {
-  const Array& fields = Array::Handle(cls.fields());
-  Field& field = Field::Handle();
+  const Array& fields = Array::Handle(isolate(), cls.fields());
+  Field& field = Field::Handle(isolate());
   SequenceNode* initializers = current_block_->statements;
   for (int field_num = 0; field_num < fields.Length(); field_num++) {
     field ^= fields.At(field_num);
     if (field.is_static()) {
       continue;
     }
 
     bool found = false;
     for (int i = 0; i < initializers->length(); i++) {
       found = false;
       if (initializers->NodeAt(i)->IsStoreInstanceFieldNode()) {
         StoreInstanceFieldNode* initializer =
             initializers->NodeAt(i)->AsStoreInstanceFieldNode();
         if (initializer->field().raw() == field.raw()) {
           found = true;
           break;
         }
       }
     }
 
     if (found) continue;
 
-    field.UpdateGuardedCidAndLength(Object::Handle());
+    field.UpdateGuardedCidAndLength(Object::Handle(isolate()));
   }
 }
 
 
 AstNode* Parser::ParseExternalInitializedField(const Field& field) {
   // Only use this function if the initialized field originates
   // 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(current_class().raw());
-  const Library& saved_library = Library::Handle(library().raw());
-  const Script& saved_script = Script::Handle(script().raw());
+  const Class& saved_class = Class::Handle(isolate(), current_class().raw());
+  const Library& saved_library = Library::Handle(isolate(), library().raw());
+  const Script& saved_script = Script::Handle(isolate(), script().raw());
   const intptr_t saved_token_pos = TokenPos();
 
-  set_current_class(Class::Handle(field.origin()));
-  set_library(Library::Handle(current_class().library()));
-  SetScript(Script::Handle(current_class().script()), field.token_pos());
+  set_current_class(Class::Handle(isolate(), field.origin()));
+  set_library(Library::Handle(isolate(), current_class().library()));
+  SetScript(Script::Handle(isolate(), current_class().script()),
+            field.token_pos());
 
   ASSERT(IsIdentifier());
   ConsumeToken();
   ExpectToken(Token::kASSIGN);
   AstNode* init_expr = NULL;
   intptr_t expr_pos = TokenPos();
   if (field.is_const()) {
     init_expr = ParseConstExpr();
   } else {
     init_expr = ParseExpr(kAllowConst, kConsumeCascades);
     if (init_expr->EvalConstExpr() != NULL) {
       init_expr =
           new LiteralNode(field.token_pos(),
                           EvaluateConstExpr(expr_pos, init_expr));
     }
   }
   set_current_class(saved_class);
   set_library(saved_library);
   SetScript(saved_script, saved_token_pos);
   return init_expr;
 }
 
 
 void Parser::ParseInitializedInstanceFields(const Class& cls,
                  LocalVariable* receiver,
                  GrowableArray<Field*>* initialized_fields) {
   TRACE_PARSER("ParseInitializedInstanceFields");
-  const Array& fields = Array::Handle(cls.fields());
-  Field& f = Field::Handle();
+  const Array& fields = Array::Handle(isolate(), cls.fields());
+  Field& f = Field::Handle(isolate());
   const intptr_t saved_pos = TokenPos();
   for (int i = 0; i < fields.Length(); i++) {
     f ^= fields.At(i);
     if (!f.is_static() && f.has_initializer()) {
       Field& field = Field::ZoneHandle();
       field ^= fields.At(i);
       if (field.is_final()) {
         // Final fields with initializer expression may not be initialized
         // again by constructors. Remember that this field is already
         // initialized.
@@ skipping 35 matching lines @@
 
 void Parser::CheckDuplicateFieldInit(intptr_t init_pos,
                                     GrowableArray<Field*>* initialized_fields,
                                     Field* field) {
   ASSERT(!field->is_static());
   for (int i = 0; i < initialized_fields->length(); i++) {
     Field* initialized_field = (*initialized_fields)[i];
     if (initialized_field->raw() == field->raw()) {
       ErrorMsg(init_pos,
                "duplicate initialization for field %s",
-               String::Handle(field->name()).ToCString());
+               String::Handle(isolate(), field->name()).ToCString());
     }
   }
   initialized_fields->Add(field);
 }
 
 
 void Parser::ParseInitializers(const Class& cls,
                                LocalVariable* receiver,
                                GrowableArray<Field*>* initialized_fields) {
   TRACE_PARSER("ParseInitializers");
@@ skipping 23 matching lines @@
 }
 
 
 void Parser::ParseConstructorRedirection(const Class& cls,
                                          LocalVariable* receiver) {
   TRACE_PARSER("ParseConstructorRedirection");
   ExpectToken(Token::kCOLON);
   ASSERT(CurrentToken() == Token::kTHIS);
   const intptr_t call_pos = TokenPos();
   ConsumeToken();
-  String& ctor_name = String::Handle(cls.Name());
+  String& ctor_name = String::Handle(isolate(), cls.Name());
 
   ctor_name = String::Concat(ctor_name, Symbols::Dot());
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     ctor_name = String::Concat(ctor_name,
                                *ExpectIdentifier("constructor name expected"));
   }
   CheckToken(Token::kLPAREN, "parameter list expected");
 
   ArgumentListNode* arguments = new ArgumentListNode(call_pos);
   // 'this' parameter is the first argument to constructor.
   AstNode* implicit_argument = new LoadLocalNode(call_pos, receiver);
   arguments->Add(implicit_argument);
   // Construction phase parameter is second argument.
   LocalVariable* phase_param = LookupPhaseParameter();
   ASSERT(phase_param != NULL);
   AstNode* phase_argument = new LoadLocalNode(call_pos, phase_param);
   arguments->Add(phase_argument);
   receiver->set_invisible(true);
   ParseActualParameters(arguments, kAllowConst);
   receiver->set_invisible(false);
   // Resolve the constructor.
   const Function& redirect_ctor = Function::ZoneHandle(
       cls.LookupConstructor(ctor_name));
   if (redirect_ctor.IsNull()) {
     ErrorMsg(call_pos, "constructor '%s' not found", ctor_name.ToCString());
   }
-  String& error_message = String::Handle();
+  String& error_message = String::Handle(isolate());
   if (!redirect_ctor.AreValidArguments(arguments->length(),
                                        arguments->names(),
                                        &error_message)) {
     ErrorMsg(call_pos,
              "invalid arguments passed to constructor '%s': %s",
              ctor_name.ToCString(),
              error_message.ToCString());
   }
   current_block_->statements->Add(
       new StaticCallNode(call_pos, redirect_ctor, arguments));
@@ skipping 68 matching lines @@
 
   // Empty constructor body.
   current_block_->statements->Add(new ReturnNode(Scanner::kNoSourcePos));
   SequenceNode* statements = CloseBlock();
   return statements;
 }
 
 
 void Parser::CheckRecursiveInvocation() {
   const GrowableObjectArray& pending_functions =
-      GrowableObjectArray::Handle(
+      GrowableObjectArray::Handle(isolate(),
           isolate()->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(current_function().UserVisibleName());
+          String::Handle(isolate(), current_function().UserVisibleName());
       ErrorMsg("circular dependency for function %s", fname.ToCString());
     }
   }
   ASSERT(!unregister_pending_function_);
   pending_functions.Add(current_function());
   unregister_pending_function_ = true;
 }
 
 
 // Parser is at the opening parenthesis of the formal parameter declaration
 // of function. Parse the formal parameters, initializers and code.
 SequenceNode* Parser::ParseConstructor(const Function& func,
                                        Array* default_parameter_values) {
   TRACE_PARSER("ParseConstructor");
   ASSERT(func.IsConstructor());
   ASSERT(!func.IsFactory());
   ASSERT(!func.is_static());
   ASSERT(!func.IsLocalFunction());
-  const Class& cls = Class::Handle(func.Owner());
+  const Class& cls = Class::Handle(isolate(), func.Owner());
   ASSERT(!cls.IsNull());
 
   CheckRecursiveInvocation();
 
   if (func.IsImplicitConstructor()) {
     // Special case: implicit constructor.
     // The parser adds an implicit default constructor when a class
     // does not have any explicit constructor or factory (see
     // Parser::AddImplicitConstructor).
     // There is no source text to parse. We just build the
@@ skipping 16 matching lines @@
       TokenPos(),
       &Symbols::PhaseParameter(),
       &Type::ZoneHandle(Type::SmiType()));
 
   if (func.is_const()) {
     params.SetImplicitlyFinal();
   }
   ParseFormalParameterList(allow_explicit_default_values, false, &params);
 
   SetupDefaultsForOptionalParams(&params, default_parameter_values);
-  ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
+  ASSERT(AbstractType::Handle(isolate(), func.result_type()).IsResolved());
   ASSERT(func.NumParameters() == params.parameters->length());
 
   // Now populate function scope with the formal parameters.
   AddFormalParamsToScope(&params, current_block_->scope);
 
   const bool is_redirecting_constructor =
       (CurrentToken() == Token::kCOLON) &&
           ((LookaheadToken(1) == Token::kTHIS) &&
               ((LookaheadToken(2) == Token::kLPAREN) ||
               ((LookaheadToken(2) == Token::kPERIOD) &&
@@ skipping 231 matching lines @@
 }
 
 
 // Parser is at the opening parenthesis of the formal parameter
 // declaration of the function or constructor.
 // Parse the formal parameters and code.
 SequenceNode* Parser::ParseFunc(const Function& func,
                                 Array* default_parameter_values) {
   TRACE_PARSER("ParseFunc");
   Function& saved_innermost_function =
-      Function::Handle(innermost_function().raw());
+      Function::Handle(isolate(), innermost_function().raw());
   innermost_function_ = func.raw();
 
   // Save current try index. Try index starts at zero for each function.
   intptr_t saved_try_index = last_used_try_index_;
   last_used_try_index_ = 0;
 
   // TODO(12455) : Need better validation mechanism.
 
   if (func.IsConstructor()) {
     SequenceNode* statements = ParseConstructor(func, default_parameter_values);
@@ skipping 35 matching lines @@
     AddFormalParamsToScope(&params, current_block_->scope);
   } else {
     ParseFormalParameterList(allow_explicit_default_values, false, &params);
 
     // The number of parameters and their type are not yet set in local
     // functions, since they are not 'top-level' parsed.
     if (func.IsLocalFunction()) {
       AddFormalParamsToFunction(&params, func);
     }
     SetupDefaultsForOptionalParams(&params, default_parameter_values);
-    ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
+    ASSERT(AbstractType::Handle(isolate(), func.result_type()).IsResolved());
     ASSERT(func.NumParameters() == params.parameters->length());
 
     // Check whether the function has any field initializer formal parameters,
     // which are not allowed in non-constructor functions.
     if (params.has_field_initializer) {
       for (int i = 0; i < params.parameters->length(); i++) {
         ParamDesc& param = (*params.parameters)[i];
         if (param.is_field_initializer) {
           ErrorMsg(param.name_pos,
                    "field initializer only allowed in constructors");
@@ skipping 14 matching lines @@
         // instantiate types.
         CaptureInstantiator();
       }
     }
   }
 
   OpenBlock();  // Open a nested scope for the outermost function block.
   intptr_t end_token_pos = 0;
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
-    if (String::Handle(func.name()).Equals(Symbols::EqualOperator())) {
-      const Class& owner = Class::Handle(func.Owner());
+    if (String::Handle(isolate(), func.name()).Equals(
+        Symbols::EqualOperator())) {
+      const Class& owner = Class::Handle(isolate(), func.Owner());
       if (!owner.IsObjectClass()) {
         AddEqualityNullCheck();
       }
     }
     ParseStatementSequence();
     end_token_pos = TokenPos();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
-    if (String::Handle(func.name()).Equals(Symbols::EqualOperator())) {
-      const Class& owner = Class::Handle(func.Owner());
+    if (String::Handle(isolate(), func.name()).Equals(
+        Symbols::EqualOperator())) {
+      const Class& owner = Class::Handle(isolate(), func.Owner());
       if (!owner.IsObjectClass()) {
         AddEqualityNullCheck();
       }
     }
     const intptr_t expr_pos = TokenPos();
     AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
     ASSERT(expr != NULL);
     current_block_->statements->Add(new ReturnNode(expr_pos, expr));
     end_token_pos = TokenPos();
   } else if (IsLiteral("native")) {
-    if (String::Handle(func.name()).Equals(Symbols::EqualOperator())) {
-      const Class& owner = Class::Handle(func.Owner());
+    if (String::Handle(isolate(), func.name()).Equals(
+        Symbols::EqualOperator())) {
+      const Class& owner = Class::Handle(isolate(), func.Owner());
       if (!owner.IsObjectClass()) {
         AddEqualityNullCheck();
       }
     }
     ParseNativeFunctionBlock(&params, func);
     end_token_pos = TokenPos();
     ExpectSemicolon();
   } else if (func.is_external()) {
     // Body of an external method contains a single throw.
     const String& function_name = String::ZoneHandle(func.name());
@@ skipping 111 matching lines @@
     if (is_top_level_ ||
         !ResolveIdentInLocalScope(qual_ident->ident_pos,
                                   *(qual_ident->ident),
                                   NULL)) {
       LibraryPrefix& lib_prefix = LibraryPrefix::ZoneHandle();
       if (!current_class().IsMixinApplication()) {
         lib_prefix = current_class().LookupLibraryPrefix(*(qual_ident->ident));
       } else {
         // TODO(hausner): Should we resolve the prefix via the library scope
         // rather than via the class?
-        Class& cls = Class::Handle(parsed_function()->function().origin());
+        Class& cls = Class::Handle(isolate(),
+                                   parsed_function()->function().origin());
         lib_prefix = cls.LookupLibraryPrefix(*(qual_ident->ident));
       }
       if (!lib_prefix.IsNull()) {
         // We have a library prefix qualified identifier, unless the prefix is
         // shadowed by a type parameter in scope.
         if (current_class().IsNull() ||
             (current_class().LookupTypeParameter(*(qual_ident->ident)) ==
              TypeParameter::null())) {
           ConsumeToken();  // Consume the kPERIOD token.
           qual_ident->lib_prefix = &lib_prefix;
@@ skipping 96 matching lines @@
       method->name = &String::ZoneHandle(Field::SetterSymbol(*method->name));
     }
     if ((method->params.num_fixed_parameters != expected_num_parameters) ||
         (method->params.num_optional_parameters != 0)) {
       ErrorMsg(method->name_pos, "illegal %s parameters",
                method->IsGetter() ? "getter" : "setter");
     }
   }
 
   // Parse redirecting factory constructor.
-  Type& redirection_type = Type::Handle();
-  String& redirection_identifier = String::Handle();
+  Type& redirection_type = Type::Handle(isolate());
+  String& redirection_identifier = String::Handle(isolate());
   bool is_redirecting = false;
   if (method->IsFactory() && (CurrentToken() == Token::kASSIGN)) {
     // Default parameter values are disallowed in redirecting factories.
     if (method->params.has_explicit_default_values) {
       ErrorMsg("redirecting factory '%s' may not specify default values "
                "for optional parameters",
                method->name->ToCString());
     }
     ConsumeToken();
     const intptr_t type_pos = TokenPos();
     is_redirecting = true;
-    const AbstractType& type = AbstractType::Handle(
+    const AbstractType& type = AbstractType::Handle(isolate(),
         ParseType(ClassFinalizer::kResolveTypeParameters));
     if (!type.IsMalformed() && type.IsTypeParameter()) {
       // Replace the type with a malformed type and compile a throw when called.
       redirection_type = ClassFinalizer::NewFinalizedMalformedType(
-          Error::Handle(),  // No previous error.
+          Error::Handle(isolate()),  // No previous error.
           script_,
           type_pos,
           "factory '%s' may not redirect to type parameter '%s'",
           method->name->ToCString(),
-          String::Handle(type.UserVisibleName()).ToCString());
+          String::Handle(isolate(), type.UserVisibleName()).ToCString());
     } else {
       // We handle malformed and malbounded redirection type at run time.
       redirection_type ^= type.raw();
     }
     if (CurrentToken() == Token::kPERIOD) {
       // Named constructor or factory.
       ConsumeToken();
       redirection_identifier = ExpectIdentifier("identifier expected")->raw();
     }
   } else if (CurrentToken() == Token::kCOLON) {
@@ skipping 125 matching lines @@
   RawFunction::Kind function_kind;
   if (method->IsFactoryOrConstructor()) {
     function_kind = RawFunction::kConstructor;
   } else if (method->IsGetter()) {
     function_kind = RawFunction::kGetterFunction;
   } else if (method->IsSetter()) {
     function_kind = RawFunction::kSetterFunction;
   } else {
     function_kind = RawFunction::kRegularFunction;
   }
-  Function& func = Function::Handle(
+  Function& func = Function::Handle(isolate(),
       Function::New(*method->name,
                     function_kind,
                     method->has_static,
                     method->has_const,
                     method->has_abstract,
                     method->has_external,
                     method->has_native,
                     current_class(),
                     method->decl_begin_pos));
   func.set_result_type(*method->type);
@@ skipping 45 matching lines @@
   }
   if (field->has_external) {
     ErrorMsg("keyword 'external' not allowed in field declaration");
   }
   if (field->has_factory) {
     ErrorMsg("keyword 'factory' not allowed in field declaration");
   }
   if (!field->has_static && field->has_const) {
     ErrorMsg(field->name_pos, "instance field may not be 'const'");
   }
-  Function& getter = Function::Handle();
-  Function& setter = Function::Handle();
+  Function& getter = Function::Handle(isolate());
+  Function& setter = Function::Handle(isolate());
   Field& class_field = Field::ZoneHandle();
-  Instance& init_value = Instance::Handle();
+  Instance& init_value = Instance::Handle(isolate());
   while (true) {
     bool has_initializer = CurrentToken() == Token::kASSIGN;
     bool has_simple_literal = false;
     if (has_initializer) {
       ConsumeToken();
       init_value = Object::sentinel().raw();
       // For static fields, the initialization expression will be parsed
       // through the kImplicitStaticFinalGetter method invocation/compilation.
       // For instance fields, the expression is parsed when a constructor
       // is compiled.
@@ skipping 33 matching lines @@
     field->field_ = &class_field;
     if (field->metadata_pos >= 0) {
       library_.AddFieldMetadata(class_field, field->metadata_pos);
     }
 
     // For static final fields (this includes static const fields), set value to
     // "uninitialized" and create a kImplicitStaticFinalGetter getter method.
     if (field->has_static && has_initializer) {
       class_field.set_value(init_value);
       if (!has_simple_literal) {
-        String& getter_name = String::Handle(Field::GetterSymbol(*field->name));
+        String& getter_name = String::Handle(isolate(),
+                                             Field::GetterSymbol(*field->name));
         getter = Function::New(getter_name,
                                RawFunction::kImplicitStaticFinalGetter,
                                field->has_static,
                                field->has_const,
                                /* is_abstract = */ false,
                                /* is_external = */ false,
                                /* is_native = */ false,
                                current_class(),
                                field->name_pos);
         getter.set_result_type(*field->type);
         members->AddFunction(getter);
 
         // Create initializer function for non-const fields.
         if (!class_field.is_const()) {
           const Function& init_function = Function::ZoneHandle(
               Function::NewStaticInitializer(class_field));
           members->AddFunction(init_function);
         }
       }
     }
 
     // For instance fields, we create implicit getter and setter methods.
     if (!field->has_static) {
-      String& getter_name = String::Handle(Field::GetterSymbol(*field->name));
+      String& getter_name = String::Handle(isolate(),
+                                           Field::GetterSymbol(*field->name));
       getter = Function::New(getter_name, RawFunction::kImplicitGetter,
                              field->has_static,
                              field->has_final,
                              /* is_abstract = */ false,
                              /* is_external = */ false,
                              /* is_native = */ false,
                              current_class(),
                              field->name_pos);
       ParamList params;
       ASSERT(current_class().raw() == getter.Owner());
       params.AddReceiver(ReceiverType(current_class()), field->name_pos);
       getter.set_result_type(*field->type);
       AddFormalParamsToFunction(&params, getter);
       members->AddFunction(getter);
       if (!field->has_final) {
         // Build a setter accessor for non-const fields.
-        String& setter_name = String::Handle(Field::SetterSymbol(*field->name));
+        String& setter_name = String::Handle(isolate(),
+                                             Field::SetterSymbol(*field->name));
         setter = Function::New(setter_name, RawFunction::kImplicitSetter,
                                field->has_static,
                                field->has_final,
                                /* is_abstract = */ false,
                                /* is_external = */ false,
                                /* is_native = */ false,
                                current_class(),
                                field->name_pos);
         ParamList params;
         ASSERT(current_class().raw() == setter.Owner());
         params.AddReceiver(ReceiverType(current_class()), field->name_pos);
         params.AddFinalParameter(TokenPos(),
                                  &Symbols::Value(),
                                  field->type);
-        setter.set_result_type(Type::Handle(Type::VoidType()));
+        setter.set_result_type(Type::Handle(isolate(), Type::VoidType()));
         AddFormalParamsToFunction(&params, setter);
         members->AddFunction(setter);
       }
     }
 
     if (CurrentToken() != Token::kCOMMA) {
       break;
     }
     ConsumeToken();
     field->name_pos = this->TokenPos();
@@ skipping 143 matching lines @@
                  members->class_name().ToCString());
       }
     } else if (member.has_static) {
       ErrorMsg(member.name_pos, "constructor cannot be static");
     }
     if (member.type != NULL) {
       ErrorMsg(member.name_pos, "constructor must not specify return type");
     }
     // Do not bypass class resolution by using current_class() directly, since
     // it may be a patch class.
-    const Object& result_type_class = Object::Handle(
-        UnresolvedClass::New(LibraryPrefix::Handle(),
+    const Object& result_type_class = Object::Handle(isolate(),
+        UnresolvedClass::New(LibraryPrefix::Handle(isolate()),
                              *member.name,
                              member.name_pos));
     // The type arguments of the result type are the type parameters of the
     // current class. Note that in the case of a patch class, they are copied
     // from the class being patched.
     member.type = &Type::ZoneHandle(Type::New(
         result_type_class,
-        TypeArguments::Handle(current_class().type_parameters()),
+        TypeArguments::Handle(isolate(), current_class().type_parameters()),
         member.name_pos));
 
     // We must be dealing with a constructor or named constructor.
     member.kind = RawFunction::kConstructor;
     *member.name = String::Concat(*member.name, Symbols::Dot());
     if (CurrentToken() == Token::kPERIOD) {
       // Named constructor.
       ConsumeToken();
       member.dict_name = ExpectIdentifier("identifier expected");
       *member.name = String::Concat(*member.name, *member.dict_name);
@@ skipping 102 matching lines @@
   } else if (CurrentToken() == Token::kABSTRACT) {
     is_abstract = true;
     ConsumeToken();
   }
   ExpectToken(Token::kCLASS);
   const intptr_t classname_pos = TokenPos();
   String& class_name = *ExpectUserDefinedTypeIdentifier("class name expected");
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing class '%s'\n", class_name.ToCString());
   }
-  Class& cls = Class::Handle();
-  TypeArguments& orig_type_parameters = TypeArguments::Handle();
-  Object& obj = Object::Handle(library_.LookupLocalObject(class_name));
+  Class& cls = Class::Handle(isolate());
+  TypeArguments& orig_type_parameters = TypeArguments::Handle(isolate());
+  Object& obj = Object::Handle(isolate(),
+                               library_.LookupLocalObject(class_name));
   if (obj.IsNull()) {
     if (is_patch) {
       ErrorMsg(classname_pos, "missing class '%s' cannot be patched",
                class_name.ToCString());
     }
     cls = Class::New(class_name, script_, classname_pos);
     library_.AddClass(cls);
   } else {
     if (!obj.IsClass()) {
       ErrorMsg(classname_pos, "'%s' is already defined",
@@ skipping 23 matching lines @@
       cls.set_token_pos(classname_pos);
     }
   }
   ASSERT(!cls.IsNull());
   ASSERT(cls.functions() == Object::empty_array().raw());
   set_current_class(cls);
   ParseTypeParameters(cls);
   if (is_patch) {
     // Check that the new type parameters are identical to the original ones.
     const TypeArguments& new_type_parameters =
-        TypeArguments::Handle(cls.type_parameters());
+        TypeArguments::Handle(isolate(), cls.type_parameters());
     const int new_type_params_count =
         new_type_parameters.IsNull() ? 0 : new_type_parameters.Length();
     const int orig_type_params_count =
         orig_type_parameters.IsNull() ? 0 : orig_type_parameters.Length();
     if (new_type_params_count != orig_type_params_count) {
       ErrorMsg(classname_pos,
                "class '%s' must be patched with identical type parameters",
                class_name.ToCString());
     }
-    TypeParameter& new_type_param = TypeParameter::Handle();
-    TypeParameter& orig_type_param = TypeParameter::Handle();
-    String& new_name = String::Handle();
-    String& orig_name = String::Handle();
+    TypeParameter& new_type_param = TypeParameter::Handle(isolate());
+    TypeParameter& orig_type_param = TypeParameter::Handle(isolate());
+    String& new_name = String::Handle(isolate());
+    String& orig_name = String::Handle(isolate());
     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);
       new_name = new_type_param.name();
       orig_name = orig_type_param.name();
       if (!new_name.Equals(orig_name)) {
         ErrorMsg(new_type_param.token_pos(),
                  "type parameter '%s' of patch class '%s' does not match "
                  "original type parameter '%s'",
                  new_name.ToCString(),
@@ skipping 13 matching lines @@
     library_.AddClassMetadata(cls, toplevel_class, metadata_pos);
   }
 
   const bool is_mixin_declaration = (CurrentToken() == Token::kASSIGN);
   if (is_mixin_declaration && is_patch) {
     ErrorMsg(classname_pos,
              "mixin application '%s' may not be a patch class",
              class_name.ToCString());
   }
 
-  AbstractType& super_type = Type::Handle();
+  AbstractType& super_type = Type::Handle(isolate());
   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()) {
-      ErrorMsg(Error::Handle(super_type.error()));
+      ErrorMsg(Error::Handle(isolate(), super_type.error()));
     }
     if (super_type.IsDynamicType()) {
       // Unlikely here, since super type is not resolved yet.
       ErrorMsg(type_pos,
                "class '%s' may not extend 'dynamic'",
                class_name.ToCString());
     }
     if (super_type.IsTypeParameter()) {
       ErrorMsg(type_pos,
                "class '%s' may not extend type parameter '%s'",
                class_name.ToCString(),
-               String::Handle(super_type.UserVisibleName()).ToCString());
+               String::Handle(isolate(),
+                              super_type.UserVisibleName()).ToCString());
     }
     // The class finalizer will check whether the super type is malbounded.
     if (is_mixin_declaration) {
       if (CurrentToken() != Token::kWITH) {
         ErrorMsg("mixin application clause 'with type' expected");
       }
       cls.set_is_mixin_app_alias();
       cls.set_is_synthesized_class();
     }
     if (CurrentToken() == Token::kWITH) {
@@ skipping 31 matching lines @@
     ExpectToken(Token::kRBRACE);
   }
 }
 
 
 void Parser::ParseClassDefinition(const Class& cls) {
   TRACE_PARSER("ParseClassDefinition");
   CompilerStats::num_classes_compiled++;
   set_current_class(cls);
   is_top_level_ = true;
-  String& class_name = String::Handle(cls.Name());
+  String& class_name = String::Handle(isolate(), cls.Name());
   const intptr_t class_pos = TokenPos();
   ClassDesc members(cls, class_name, false, class_pos);
   while (CurrentToken() != Token::kLBRACE) {
     ConsumeToken();
   }
   ExpectToken(Token::kLBRACE);
   while (CurrentToken() != Token::kRBRACE) {
     intptr_t metadata_pos = SkipMetadata();
     ParseClassMemberDefinition(&members, metadata_pos);
   }
   ExpectToken(Token::kRBRACE);
 
   CheckConstructors(&members);
 
   // Need to compute this here since MakeArray() will clear the
   // functions array in members.
   const bool need_implicit_constructor =
       !members.has_constructor() && !cls.is_patch();
 
   cls.AddFields(members.fields());
 
   // Creating a new array for functions marks the class as parsed.
-  const Array& array = Array::Handle(Array::MakeArray(members.functions()));
+  const Array& array = Array::Handle(isolate(),
+                                     Array::MakeArray(members.functions()));
   cls.SetFunctions(array);
 
   // Add an implicit constructor if no explicit constructor is present.
   // No implicit constructors are needed for patch classes.
   if (need_implicit_constructor) {
     AddImplicitConstructor(cls);
   }
 
   if (cls.is_patch()) {
     // Apply the changes to the patched class looked up above.
-    Object& obj = Object::Handle(library_.LookupLocalObject(class_name));
+    Object& obj = Object::Handle(isolate(),
+                                 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();
+    Error& error = Error::Handle(isolate());
     if (!orig_class.ApplyPatch(cls, &error)) {
       AppendErrorMsg(error, class_pos, "applying patch failed");
     }
   }
 }
 
 
 // Add an implicit constructor to the given class.
 void Parser::AddImplicitConstructor(const Class& cls) {
   // The implicit constructor is unnamed, has no explicit parameter.
   String& ctor_name = String::ZoneHandle(cls.Name());
   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(
+  Function& ctor = Function::Handle(isolate(),
       Function::New(ctor_name,
                     RawFunction::kConstructor,
                     /* is_static = */ false,
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     /* is_external = */ false,
                     /* is_native = */ false,
                     cls,
                     cls.token_pos()));
   ctor.set_end_token_pos(ctor.token_pos());
@@ skipping 53 matching lines @@
     const GrowableObjectArray& pending_classes,
     const Class& toplevel_class,
     intptr_t metadata_pos) {
   TRACE_PARSER("ParseMixinAppAlias");
   const intptr_t classname_pos = TokenPos();
   String& class_name = *ExpectUserDefinedTypeIdentifier("class name expected");
   if (FLAG_trace_parser) {
     OS::Print("toplevel parsing mixin application alias class '%s'\n",
               class_name.ToCString());
   }
-  const Object& obj = Object::Handle(library_.LookupLocalObject(class_name));
+  const Object& obj = Object::Handle(isolate(),
+                                     library_.LookupLocalObject(class_name));
   if (!obj.IsNull()) {
     ErrorMsg(classname_pos, "'%s' is already defined",
              class_name.ToCString());
   }
   const Class& mixin_application =
-      Class::Handle(Class::New(class_name, script_, classname_pos));
+      Class::Handle(isolate(), Class::New(class_name, script_, classname_pos));
   mixin_application.set_is_mixin_app_alias();
   library_.AddClass(mixin_application);
   set_current_class(mixin_application);
   ParseTypeParameters(mixin_application);
 
   ExpectToken(Token::kASSIGN);
 
   if (CurrentToken() == Token::kABSTRACT) {
     mixin_application.set_is_abstract();
     ConsumeToken();
   }
 
   const intptr_t type_pos = TokenPos();
   AbstractType& type =
-      AbstractType::Handle(ParseType(ClassFinalizer::kResolveTypeParameters));
+      AbstractType::Handle(isolate(),
+                           ParseType(ClassFinalizer::kResolveTypeParameters));
   if (type.IsTypeParameter()) {
     ErrorMsg(type_pos,
              "class '%s' may not extend type parameter '%s'",
              class_name.ToCString(),
-             String::Handle(type.UserVisibleName()).ToCString());
+             String::Handle(isolate(), type.UserVisibleName()).ToCString());
   }
 
   CheckToken(Token::kWITH, "mixin application 'with Type' expected");
   type = ParseMixins(type);
 
   mixin_application.set_super_type(type);
   mixin_application.set_is_synthesized_class();
 
   // This mixin application alias needs an implicit constructor, but it is
   // too early to call 'AddImplicitConstructor(mixin_application)' here,
@@ skipping 57 matching lines @@
 
   if (IsMixinAppAlias()) {
     if (FLAG_warn_mixin_typedef) {
       Warning("deprecated mixin application typedef");
     }
     ParseMixinAppAlias(pending_classes, toplevel_class, metadata_pos);
     return;
   }
 
   // Parse the result type of the function type.
-  AbstractType& result_type = Type::Handle(Type::DynamicType());
+  AbstractType& result_type = Type::Handle(isolate(), Type::DynamicType());
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
   } else if (!IsFunctionTypeAliasName()) {
     // Type annotations in typedef are never ignored, even in production mode.
     // Wait until we have an owner class before resolving the result type.
     result_type = ParseType(ClassFinalizer::kDoNotResolve);
   }
 
   const intptr_t alias_name_pos = TokenPos();
   const String* alias_name =
       ExpectUserDefinedTypeIdentifier("function alias name expected");
 
   // Lookup alias name and report an error if it is already defined in
   // the library scope.
-  const Object& obj = Object::Handle(library_.LookupLocalObject(*alias_name));
+  const Object& obj = Object::Handle(isolate(),
+                                     library_.LookupLocalObject(*alias_name));
   if (!obj.IsNull()) {
     ErrorMsg(alias_name_pos,
              "'%s' is already defined", alias_name->ToCString());
   }
 
   // Create the function type alias signature class. It will be linked to its
   // 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(
+  const Class& function_type_alias = Class::Handle(isolate(),
       Class::NewSignatureClass(*alias_name,
-                               Function::Handle(),
+                               Function::Handle(isolate()),
                                script_,
                                alias_name_pos));
   library_.AddClass(function_type_alias);
   set_current_class(function_type_alias);
   // Parse the type parameters of the function type.
   ParseTypeParameters(function_type_alias);
   // At this point, the type parameters have been parsed, so we can resolve the
   // result type.
   if (!result_type.IsNull()) {
     ResolveTypeFromClass(function_type_alias,
                          ClassFinalizer::kResolveTypeParameters,
                          &result_type);
   }
   // Parse the formal parameters of the function type.
   CheckToken(Token::kLPAREN, "formal parameter list expected");
   ParamList func_params;
 
   // Add implicit closure object parameter.
   func_params.AddFinalParameter(
       TokenPos(),
       &Symbols::ClosureParameter(),
       &Type::ZoneHandle(Type::DynamicType()));
 
   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(
+  Function& signature_function = Function::Handle(isolate(),
       Function::New(*alias_name,
                     RawFunction::kSignatureFunction,
                     /* is_static = */ false,
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     /* is_external = */ false,
                     /* is_native = */ false,
                     function_type_alias,
                     alias_name_pos));
   signature_function.set_result_type(result_type);
   AddFormalParamsToFunction(&func_params, signature_function);
 
   // Patch the signature function in the signature class.
   function_type_alias.PatchSignatureFunction(signature_function);
 
-  const String& signature = String::Handle(signature_function.Signature());
+  const String& signature = String::Handle(isolate(),
+                                           signature_function.Signature());
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing function type alias '%s'\n",
               signature.ToCString());
   }
   // Lookup the signature class, i.e. the class whose name is the signature.
   // We only lookup in the current library, but not in its imports, and only
   // create a new canonical signature class if it does not exist yet.
   Class& signature_class = Class::ZoneHandle(
       library_.LookupLocalClass(signature));
   if (signature_class.IsNull()) {
@@ skipping 92 matching lines @@
     }
     SkipTypeArguments();
   }
 }
 
 
 void Parser::ParseTypeParameters(const Class& cls) {
   TRACE_PARSER("ParseTypeParameters");
   if (CurrentToken() == Token::kLT) {
     const GrowableObjectArray& type_parameters_array =
-        GrowableObjectArray::Handle(GrowableObjectArray::New());
+        GrowableObjectArray::Handle(isolate(), GrowableObjectArray::New());
     intptr_t index = 0;
-    TypeParameter& type_parameter = TypeParameter::Handle();
-    TypeParameter& existing_type_parameter = TypeParameter::Handle();
-    String& existing_type_parameter_name = String::Handle();
-    AbstractType& type_parameter_bound = Type::Handle();
+    TypeParameter& type_parameter = TypeParameter::Handle(isolate());
+    TypeParameter& existing_type_parameter = TypeParameter::Handle(isolate());
+    String& existing_type_parameter_name = String::Handle(isolate());
+    AbstractType& type_parameter_bound = Type::Handle(isolate());
     do {
       ConsumeToken();
       const intptr_t metadata_pos = SkipMetadata();
       const intptr_t type_parameter_pos = TokenPos();
       String& type_parameter_name =
           *ExpectUserDefinedTypeIdentifier("type parameter expected");
       // Check for duplicate type parameters.
       for (intptr_t i = 0; i < index; i++) {
         existing_type_parameter ^= type_parameters_array.At(i);
         existing_type_parameter_name = existing_type_parameter.name();
@@ skipping 23 matching lines @@
       }
       index++;
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) || (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
       ErrorMsg("right angle bracket expected");
     }
     const TypeArguments& type_parameters =
-        TypeArguments::Handle(NewTypeArguments(type_parameters_array));
+        TypeArguments::Handle(isolate(),
+                              NewTypeArguments(type_parameters_array));
     cls.set_type_parameters(type_parameters);
     // Try to resolve the upper bounds, which will at least resolve the
     // referenced type parameters.
     const intptr_t num_types = type_parameters.Length();
     for (intptr_t i = 0; i < num_types; i++) {
       type_parameter ^= type_parameters.TypeAt(i);
       type_parameter_bound = type_parameter.bound();
       ResolveTypeFromClass(cls,
                            ClassFinalizer::kResolveTypeParameters,
                            &type_parameter_bound);
       type_parameter.set_bound(type_parameter_bound);
     }
   }
 }
 
 
 RawTypeArguments* Parser::ParseTypeArguments(
     ClassFinalizer::FinalizationKind finalization) {
   TRACE_PARSER("ParseTypeArguments");
   if (CurrentToken() == Token::kLT) {
     const GrowableObjectArray& types =
-        GrowableObjectArray::Handle(GrowableObjectArray::New());
-    AbstractType& type = AbstractType::Handle();
+        GrowableObjectArray::Handle(isolate(), GrowableObjectArray::New());
+    AbstractType& type = AbstractType::Handle(isolate());
     do {
       ConsumeToken();
       type = ParseType(finalization);
       // Map a malformed type argument to dynamic.
       if (type.IsMalformed()) {
         type = Type::DynamicType();
       }
       types.Add(type);
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) || (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
       ErrorMsg("right angle bracket expected");
     }
     if (finalization != ClassFinalizer::kIgnore) {
       return NewTypeArguments(types);
     }
   }
   return TypeArguments::null();
 }
 
 
 // Parse interface list and add to class cls.
 void Parser::ParseInterfaceList(const Class& cls) {
   TRACE_PARSER("ParseInterfaceList");
   ASSERT(CurrentToken() == Token::kIMPLEMENTS);
   const GrowableObjectArray& all_interfaces =
-      GrowableObjectArray::Handle(GrowableObjectArray::New());
-  AbstractType& interface = AbstractType::Handle();
+      GrowableObjectArray::Handle(isolate(), GrowableObjectArray::New());
+  AbstractType& interface = AbstractType::Handle(isolate());
   // First get all the interfaces already implemented by class.
-  Array& cls_interfaces = Array::Handle(cls.interfaces());
+  Array& cls_interfaces = Array::Handle(isolate(), cls.interfaces());
   for (intptr_t i = 0; i < cls_interfaces.Length(); i++) {
     interface ^= cls_interfaces.At(i);
     all_interfaces.Add(interface);
   }
   // Now parse and add the new interfaces.
   do {
     ConsumeToken();
     intptr_t interface_pos = TokenPos();
     interface = ParseType(ClassFinalizer::kResolveTypeParameters);
     if (interface.IsTypeParameter()) {
       ErrorMsg(interface_pos,
                "type parameter '%s' may not be used in interface list",
-               String::Handle(interface.UserVisibleName()).ToCString());
+               String::Handle(isolate(),
+                              interface.UserVisibleName()).ToCString());
     }
     all_interfaces.Add(interface);
   } while (CurrentToken() == Token::kCOMMA);
   cls_interfaces = Array::MakeArray(all_interfaces);
   cls.set_interfaces(cls_interfaces);
 }
 
 
 RawAbstractType* Parser::ParseMixins(const AbstractType& super_type) {
   TRACE_PARSER("ParseMixins");
   ASSERT(CurrentToken() == Token::kWITH);
   const GrowableObjectArray& mixin_types =
-      GrowableObjectArray::Handle(GrowableObjectArray::New());
-  AbstractType& mixin_type = AbstractType::Handle();
+      GrowableObjectArray::Handle(isolate(), GrowableObjectArray::New());
+  AbstractType& mixin_type = AbstractType::Handle(isolate());
   do {
     ConsumeToken();
     mixin_type = ParseType(ClassFinalizer::kResolveTypeParameters);
     if (mixin_type.IsDynamicType()) {
       // The string 'dynamic' is not resolved yet at this point, but a malformed
       // type mapped to dynamic can be encountered here.
       ErrorMsg(mixin_type.token_pos(), "illegal mixin of a malformed type");
     }
     if (mixin_type.IsTypeParameter()) {
       ErrorMsg(mixin_type.token_pos(),
                "mixin type '%s' may not be a type parameter",
-               String::Handle(mixin_type.UserVisibleName()).ToCString());
+               String::Handle(isolate(),
+                              mixin_type.UserVisibleName()).ToCString());
     }
     mixin_types.Add(mixin_type);
   } while (CurrentToken() == Token::kCOMMA);
   return MixinAppType::New(super_type,
-                           Array::Handle(Array::MakeArray(mixin_types)));
+      Array::Handle(isolate(), Array::MakeArray(mixin_types)));
 }
 
 
 void Parser::ParseTopLevelVariable(TopLevel* top_level,
                                    intptr_t metadata_pos) {
   TRACE_PARSER("ParseTopLevelVariable");
   const bool is_const = (CurrentToken() == Token::kCONST);
   // Const fields are implicitly final.
   const bool is_final = is_const || (CurrentToken() == Token::kFINAL);
   const bool is_static = true;
   const AbstractType& type = AbstractType::ZoneHandle(ParseConstFinalVarOrType(
       ClassFinalizer::kResolveTypeParameters));
-  Field& field = Field::Handle();
-  Function& getter = Function::Handle();
+  Field& field = Field::Handle(isolate());
+  Function& getter = Function::Handle(isolate());
   while (true) {
     const intptr_t name_pos = TokenPos();
     String& var_name = *ExpectIdentifier("variable name expected");
 
     if (library_.LookupLocalObject(var_name) != Object::null()) {
       ErrorMsg(name_pos, "'%s' is already defined", var_name.ToCString());
     }
 
     // Check whether a getter or setter for this name exists. A const
     // 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(Field::GetterName(var_name));
+    String& accessor_name = String::Handle(isolate(),
+                                           Field::GetterName(var_name));
     if (library_.LookupLocalObject(accessor_name) != Object::null()) {
       ErrorMsg(name_pos, "getter for '%s' is already defined",
                var_name.ToCString());
     }
     accessor_name = Field::SetterName(var_name);
     if (library_.LookupLocalObject(accessor_name) != Object::null()) {
       ErrorMsg(name_pos, "setter for '%s' is already defined",
                var_name.ToCString());
     }
 
     field = Field::New(var_name, is_static, is_final, is_const,
                        current_class(), name_pos);
     field.set_type(type);
-    field.set_value(Instance::Handle(Instance::null()));
+    field.set_value(Instance::Handle(isolate(), Instance::null()));
     top_level->fields.Add(field);
     library_.AddObject(field, var_name);
     if (metadata_pos >= 0) {
       library_.AddFieldMetadata(field, metadata_pos);
     }
     if (CurrentToken() == Token::kASSIGN) {
       ConsumeToken();
-      Instance& field_value = Instance::Handle(Object::sentinel().raw());
+      Instance& field_value = Instance::Handle(isolate(),
+                                               Object::sentinel().raw());
       bool has_simple_literal = false;
       if (LookaheadToken(1) == Token::kSEMICOLON) {
         has_simple_literal = IsSimpleLiteral(type, &field_value);
       }
       SkipExpr();
       field.set_value(field_value);
       if (!has_simple_literal) {
         // Create a static final getter.
-        String& getter_name = String::Handle(Field::GetterSymbol(var_name));
+        String& getter_name = String::Handle(isolate(),
+                                             Field::GetterSymbol(var_name));
         getter = Function::New(getter_name,
                                RawFunction::kImplicitStaticFinalGetter,
                                is_static,
                                is_const,
                                /* is_abstract = */ false,
                                /* is_external = */ false,
                                /* is_native = */ false,
                                current_class(),
                                name_pos);
         getter.set_result_type(type);
@@ skipping 19 matching lines @@
       ExpectSemicolon();  // Reports error.
     }
   }
 }
 
 
 void Parser::ParseTopLevelFunction(TopLevel* top_level,
                                    intptr_t metadata_pos) {
   TRACE_PARSER("ParseTopLevelFunction");
   const intptr_t decl_begin_pos = TokenPos();
-  AbstractType& result_type = Type::Handle(Type::DynamicType());
+  AbstractType& result_type = Type::Handle(isolate(), Type::DynamicType());
   const bool is_static = true;
   bool is_external = false;
   bool is_patch = false;
   if (is_patch_source() &&
       (CurrentToken() == Token::kIDENT) &&
       CurrentLiteral()->Equals("patch") &&
       (LookaheadToken(1) != Token::kLPAREN)) {
     ConsumeToken();
     is_patch = true;
   } else if (CurrentToken() == Token::kEXTERNAL) {
@@ skipping 12 matching lines @@
   }
   const intptr_t name_pos = TokenPos();
   const String& func_name = *ExpectIdentifier("function name expected");
 
   bool found = library_.LookupLocalObject(func_name) != Object::null();
   if (found && !is_patch) {
     ErrorMsg(name_pos, "'%s' is already defined", func_name.ToCString());
   } else if (!found && is_patch) {
     ErrorMsg(name_pos, "missing '%s' cannot be patched", func_name.ToCString());
   }
-  String& accessor_name = String::Handle(Field::GetterName(func_name));
+  String& accessor_name = String::Handle(isolate(),
+                                         Field::GetterName(func_name));
   if (library_.LookupLocalObject(accessor_name) != Object::null()) {
     ErrorMsg(name_pos, "'%s' is already defined as getter",
              func_name.ToCString());
   }
   // A setter named x= may co-exist with a function named x, thus we do
   // not need to check setters.
 
   CheckToken(Token::kLPAREN);
   const intptr_t function_pos = TokenPos();
   ParamList params;
@@ skipping 15 matching lines @@
     function_end_pos = TokenPos();
     ExpectSemicolon();
   } else if (IsLiteral("native")) {
     ParseNativeDeclaration();
     function_end_pos = TokenPos();
     ExpectSemicolon();
     is_native = true;
   } else {
     ErrorMsg("function block expected");
   }
-  Function& func = Function::Handle(
+  Function& func = Function::Handle(isolate(),
       Function::New(func_name,
                     RawFunction::kRegularFunction,
                     is_static,
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     is_external,
                     is_native,
                     current_class(),
                     decl_begin_pos));
   func.set_result_type(result_type);
@@ skipping 14 matching lines @@
 }
 
 
 void Parser::ParseTopLevelAccessor(TopLevel* top_level,
                                    intptr_t metadata_pos) {
   TRACE_PARSER("ParseTopLevelAccessor");
   const intptr_t decl_begin_pos = TokenPos();
   const bool is_static = true;
   bool is_external = false;
   bool is_patch = false;
-  AbstractType& result_type = AbstractType::Handle();
+  AbstractType& result_type = AbstractType::Handle(isolate());
   if (is_patch_source() &&
       (CurrentToken() == Token::kIDENT) &&
       CurrentLiteral()->Equals("patch")) {
     ConsumeToken();
     is_patch = true;
   } else if (CurrentToken() == Token::kEXTERNAL) {
     ConsumeToken();
     is_external = true;
   }
   bool is_getter = (CurrentToken() == Token::kGET);
@@ skipping 80 matching lines @@
     accessor_end_pos = TokenPos();
     ExpectSemicolon();
   } else if (IsLiteral("native")) {
     ParseNativeDeclaration();
     accessor_end_pos = TokenPos();
     ExpectSemicolon();
     is_native = true;
   } else {
     ErrorMsg("function block expected");
   }
-  Function& func = Function::Handle(
+  Function& func = Function::Handle(isolate(),
       Function::New(accessor_name,
                     is_getter ? RawFunction::kGetterFunction :
                                 RawFunction::kSetterFunction,
                     is_static,
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     is_external,
                     is_native,
                     current_class(),
                     decl_begin_pos));
@@ skipping 33 matching lines @@
   // tag handler.
   isolate()->BlockClassFinalization();
   Api::Scope api_scope(isolate());
   Dart_Handle result = handler(tag,
                                Api::NewHandle(isolate(), library_.raw()),
                                Api::NewHandle(isolate(), url.raw()));
   isolate()->UnblockClassFinalization();
   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();
+    Error& prev_error = Error::Handle(isolate());
     prev_error ^= Api::UnwrapHandle(result);
     AppendErrorMsg(prev_error, token_pos, "library handler failed");
   }
   if (tag == Dart_kCanonicalizeUrl) {
     if (!Dart_IsString(result)) {
       ErrorMsg(token_pos, "library handler failed URI canonicalization");
     }
   }
   return Api::UnwrapHandle(result);
 }
@@ skipping 45 matching lines @@
   const String& url = String::Cast(url_literal->AsLiteralNode()->literal());
   if (url.Length() == 0) {
     ErrorMsg("library url expected");
   }
   bool is_deferred_import = false;
   if (is_import && (IsLiteral("deferred"))) {
     is_deferred_import = true;
     ConsumeToken();
     CheckToken(Token::kAS, "'as' expected");
   }
-  String& prefix = String::Handle();
+  String& prefix = String::Handle(isolate());
   intptr_t prefix_pos = 0;
   if (is_import && (CurrentToken() == Token::kAS)) {
     ConsumeToken();
     prefix_pos = TokenPos();
     prefix = ExpectIdentifier("prefix identifier expected")->raw();
   }
 
-  Array& show_names = Array::Handle();
-  Array& hide_names = Array::Handle();
+  Array& show_names = Array::Handle(isolate());
+  Array& hide_names = Array::Handle(isolate());
   if (is_deferred_import || IsLiteral("show") || IsLiteral("hide")) {
     GrowableObjectArray& show_list =
-        GrowableObjectArray::Handle(GrowableObjectArray::New());
+        GrowableObjectArray::Handle(isolate(), GrowableObjectArray::New());
     GrowableObjectArray& hide_list =
-        GrowableObjectArray::Handle(GrowableObjectArray::New());
+        GrowableObjectArray::Handle(isolate(), GrowableObjectArray::New());
     // Libraries imported through deferred import automatically hide
     // the name 'loadLibrary'.
     if (is_deferred_import) {
       hide_list.Add(Symbols::LoadLibrary());
     }
     for (;;) {
       if (IsLiteral("show")) {
         ConsumeToken();
         ParseIdentList(&show_list);
       } else if (IsLiteral("hide")) {
         ConsumeToken();
         ParseIdentList(&hide_list);
       } else {
         break;
       }
     }
     if (show_list.Length() > 0) {
       show_names = Array::MakeArray(show_list);
     }
     if (hide_list.Length() > 0) {
       hide_names = Array::MakeArray(hide_list);
     }
   }
   ExpectSemicolon();
 
   // Canonicalize library URL.
   const String& canon_url = String::CheckedHandle(
       CallLibraryTagHandler(Dart_kCanonicalizeUrl, import_pos, url));
   // Lookup the library URL.
-  Library& library = Library::Handle(Library::LookupLibrary(canon_url));
+  Library& library = Library::Handle(isolate(),
+                                     Library::LookupLibrary(canon_url));
   if (library.IsNull()) {
     // Create an empty library to mark that we have initiated loading of this
     // library.
     library = Library::New(canon_url);
     library.Register();
     // Call the library tag handler to load the library.
     // TODO(hausner): do not load eagerly if import is deferred.
     CallLibraryTagHandler(Dart_kImportTag, import_pos, canon_url);
   }
 
-  Namespace& ns =
-      Namespace::Handle(Namespace::New(library, show_names, hide_names));
+  Namespace& ns = Namespace::Handle(isolate(),
+      Namespace::New(library, show_names, hide_names));
   if (metadata_pos >= 0) {
     ns.AddMetadata(metadata_pos, current_class());
   }
 
   if (is_import) {
     // Ensure that private dart:_ libraries are only imported into dart:
     // libraries.
-    const String& lib_url = String::Handle(library_.url());
+    const String& lib_url = String::Handle(isolate(), library_.url());
     if (canon_url.StartsWith(Symbols::DartSchemePrivate()) &&
         !lib_url.StartsWith(Symbols::DartScheme())) {
       ErrorMsg(import_pos, "private library is not accessible");
     }
     if (prefix.IsNull() || (prefix.Length() == 0)) {
       ASSERT(!is_deferred_import);
       library_.AddImport(ns);
     } else {
-      LibraryPrefix& library_prefix = LibraryPrefix::Handle();
+      LibraryPrefix& library_prefix = LibraryPrefix::Handle(isolate());
       library_prefix = library_.LookupLocalLibraryPrefix(prefix);
       if (!library_prefix.IsNull()) {
         // Check that prefix names of deferred import clauses are
         // unique.
         if (!is_deferred_import && library_prefix.is_deferred_load()) {
           ErrorMsg(prefix_pos,
                    "prefix '%s' already used in a deferred import clause",
                    prefix.ToCString());
         }
         if (is_deferred_import) {
@@ skipping 57 matching lines @@
   }
   while ((CurrentToken() == Token::kIMPORT) ||
       (CurrentToken() == Token::kEXPORT)) {
     ParseLibraryImportExport(metadata_pos);
     rewind_pos = TokenPos();
     metadata_pos = SkipMetadata();
   }
   // Core lib has not been explicitly imported, so we implicitly
   // import it here.
   if (!library_.ImportsCorelib()) {
-    Library& core_lib = Library::Handle(Library::CoreLibrary());
+    Library& core_lib = Library::Handle(isolate(), Library::CoreLibrary());
     ASSERT(!core_lib.IsNull());
-    const Namespace& core_ns = Namespace::Handle(
+    const Namespace& core_ns = Namespace::Handle(isolate(),
         Namespace::New(core_lib, Object::null_array(), Object::null_array()));
     library_.AddImport(core_ns);
   }
   while (CurrentToken() == Token::kPART) {
     ParseLibraryPart();
     rewind_pos = TokenPos();
     metadata_pos = SkipMetadata();
   }
   SetPosition(rewind_pos);
 }
@@ skipping 22 matching lines @@
   TRACE_PARSER("ParseTopLevel");
   // Collect the classes found at the top level in this growable array.
   // They need to be registered with class finalization after parsing
   // has been completed.
   ObjectStore* object_store = isolate()->object_store();
   const GrowableObjectArray& pending_classes =
       GrowableObjectArray::Handle(isolate(), object_store->pending_classes());
   SetPosition(0);
   is_top_level_ = true;
   TopLevel top_level;
-  Class& toplevel_class = Class::Handle(
+  Class& toplevel_class = Class::Handle(isolate(),
       Class::New(Symbols::TopLevel(), script_, TokenPos()));
   toplevel_class.set_library(library_);
 
   if (is_library_source() || is_patch_source()) {
     set_current_class(toplevel_class);
     ParseLibraryDefinition();
   } else if (is_part_source()) {
     ParsePartHeader();
   }
 
@@ skipping 24 matching lines @@
       } else if (CurrentToken() == Token::kEOS) {
         break;
       } else {
         UnexpectedToken();
       }
     }
   }
   if ((top_level.fields.Length() > 0) || (top_level.functions.Length() > 0)) {
     toplevel_class.AddFields(top_level.fields);
 
-    const Array& array = Array::Handle(Array::MakeArray(top_level.functions));
+    const Array& array = Array::Handle(isolate(),
+                                       Array::MakeArray(top_level.functions));
     toplevel_class.SetFunctions(array);
 
     library_.AddAnonymousClass(toplevel_class);
     pending_classes.Add(toplevel_class, Heap::kOld);
   }
 }
 
 
 void Parser::ChainNewBlock(LocalScope* outer_scope) {
-  Block* block = new Block(current_block_,
-                           outer_scope,
-                           new SequenceNode(TokenPos(), outer_scope));
+  Block* block = new(isolate()) Block(
+      current_block_,
+      outer_scope,
+      new(isolate()) SequenceNode(TokenPos(), outer_scope));
   current_block_ = block;
 }
 
 
 void Parser::OpenBlock() {
   ASSERT(current_block_ != NULL);
   LocalScope* outer_scope = current_block_->scope;
-  ChainNewBlock(new LocalScope(outer_scope,
-                               outer_scope->function_level(),
-                               outer_scope->loop_level()));
+  ChainNewBlock(new(isolate()) LocalScope(
+      outer_scope, outer_scope->function_level(), outer_scope->loop_level()));
 }
 
 
 void Parser::OpenLoopBlock() {
   ASSERT(current_block_ != NULL);
   LocalScope* outer_scope = current_block_->scope;
-  ChainNewBlock(new LocalScope(outer_scope,
-                               outer_scope->function_level(),
-                               outer_scope->loop_level() + 1));
+  ChainNewBlock(new(isolate()) LocalScope(
+      outer_scope,
+      outer_scope->function_level(),
+      outer_scope->loop_level() + 1));
 }
 
 
 void Parser::OpenFunctionBlock(const Function& func) {
   LocalScope* outer_scope;
   if (current_block_ == NULL) {
     if (!func.IsLocalFunction()) {
       // We are compiling a non-nested function.
       outer_scope = new(isolate()) LocalScope(NULL, 0, 0);
     } else {
@@ skipping 83 matching lines @@
 // Populate local scope with the formal parameters.
 void Parser::AddFormalParamsToScope(const ParamList* params,
                                     LocalScope* scope) {
   ASSERT((params != NULL) && (params->parameters != NULL));
   ASSERT(scope != NULL);
   const int num_parameters = params->parameters->length();
   for (int i = 0; i < num_parameters; i++) {
     ParamDesc& param_desc = (*params->parameters)[i];
     ASSERT(!is_top_level_ || param_desc.type->IsResolved());
     const String* name = param_desc.name;
-    LocalVariable* parameter = new LocalVariable(
+    LocalVariable* parameter = new(isolate()) LocalVariable(
         param_desc.name_pos, *name, *param_desc.type);
     if (!scope->InsertParameterAt(i, parameter)) {
       ErrorMsg(param_desc.name_pos,
                "name '%s' already exists in scope",
                param_desc.name->ToCString());
     }
     param_desc.var = parameter;
     if (param_desc.is_final) {
       parameter->set_is_final();
     }
     if (param_desc.is_field_initializer) {
       parameter->set_invisible(true);
     }
   }
 }
 
 
 // Builds ReturnNode/NativeBodyNode for a native function.
 void Parser::ParseNativeFunctionBlock(const ParamList* params,
                                       const Function& func) {
   ASSERT(func.is_native());
   TRACE_PARSER("ParseNativeFunctionBlock");
-  const Class& cls = Class::Handle(func.Owner());
-  const Library& library = Library::Handle(cls.library());
+  const Class& cls = Class::Handle(isolate(), func.Owner());
+  const Library& library = Library::Handle(isolate(), cls.library());
   ASSERT(func.NumParameters() == params->parameters->length());
 
   // Parse the function name out.
   const intptr_t native_pos = TokenPos();
   const String& native_name = ParseNativeDeclaration();
 
   // Now resolve the native function to the corresponding native entrypoint.
   const int num_params = NativeArguments::ParameterCountForResolution(func);
   bool auto_setup_scope = true;
   NativeFunction native_function = NativeEntry::ResolveNative(
       library, native_name, num_params, &auto_setup_scope);
   if (native_function == NULL) {
     ErrorMsg(native_pos,
              "native function '%s' (%" Pd " arguments) cannot be found",
              native_name.ToCString(), func.NumParameters());
   }
   func.SetIsNativeAutoSetupScope(auto_setup_scope);
 
   // Now add the NativeBodyNode and return statement.
   Dart_NativeEntryResolver resolver = library.native_entry_resolver();
   bool is_bootstrap_native = Bootstrap::IsBootstapResolver(resolver);
-  current_block_->statements->Add(
-      new ReturnNode(TokenPos(),
-                     new NativeBodyNode(TokenPos(),
-                                        Function::ZoneHandle(func.raw()),
-                                        native_name,
-                                        native_function,
-                                        current_block_->scope,
-                                        is_bootstrap_native)));
+  current_block_->statements->Add(new(isolate()) ReturnNode(
+      TokenPos(), new(isolate()) NativeBodyNode(
+          TokenPos(),
+          Function::ZoneHandle(func.raw()),
+          native_name,
+          native_function,
+          current_block_->scope,
+          is_bootstrap_native)));
 }
 
 
 LocalVariable* Parser::LookupReceiver(LocalScope* from_scope, bool test_only) {
   ASSERT(!current_function().is_static());
   return from_scope->LookupVariable(Symbols::This(), test_only);
 }
 
 
 LocalVariable* Parser::LookupTypeArgumentsParameter(LocalScope* from_scope,
@@ skipping 25 matching lines @@
 
 
 AstNode* Parser::LoadReceiver(intptr_t token_pos) {
   // A nested function may access 'this', referring to the receiver of the
   // outermost enclosing function.
   const bool kTestOnly = false;
   LocalVariable* receiver = LookupReceiver(current_block_->scope, kTestOnly);
   if (receiver == NULL) {
     ErrorMsg(token_pos, "illegal implicit access to receiver 'this'");
   }
-  return new LoadLocalNode(TokenPos(), receiver);
+  return new(isolate()) LoadLocalNode(TokenPos(), receiver);
 }
 
 
 AstNode* Parser::LoadTypeArgumentsParameter(intptr_t token_pos) {
   // A nested function may access ':type_arguments' to use as instantiator,
   // referring to the implicit first parameter of the outermost enclosing
   // factory function.
   const bool kTestOnly = false;
   LocalVariable* param = LookupTypeArgumentsParameter(current_block_->scope,
                                                       kTestOnly);
   ASSERT(param != NULL);
-  return new LoadLocalNode(TokenPos(), param);
+  return new(isolate()) LoadLocalNode(TokenPos(), param);
 }
 
 
 AstNode* Parser::CallGetter(intptr_t token_pos,
                             AstNode* object,
                             const String& name) {
-  return new InstanceGetterNode(token_pos, object, name);
+  return new(isolate()) InstanceGetterNode(token_pos, object, name);
 }
 
 
 // Returns ast nodes of the variable initialization.
 AstNode* Parser::ParseVariableDeclaration(const AbstractType& type,
                                           bool is_final,
                                           bool is_const) {
   TRACE_PARSER("ParseVariableDeclaration");
   ASSERT(IsIdentifier());
   const intptr_t ident_pos = TokenPos();
   const String& ident = *CurrentLiteral();
-  LocalVariable* variable = new LocalVariable(ident_pos, ident, type);
+  LocalVariable* variable = new(isolate()) LocalVariable(
+      ident_pos, ident, type);
   ConsumeToken();  // Variable identifier.
   AstNode* initialization = NULL;
   if (CurrentToken() == Token::kASSIGN) {
     // Variable initialization.
     const intptr_t assign_pos = TokenPos();
     ConsumeToken();
     AstNode* expr = ParseExpr(is_const, kConsumeCascades);
-    initialization = new StoreLocalNode(assign_pos, variable, expr);
+    initialization = new(isolate()) StoreLocalNode(
+        assign_pos, variable, expr);
     if (is_const) {
       ASSERT(expr->IsLiteralNode());
       variable->SetConstValue(expr->AsLiteralNode()->literal());
     }
   } else if (is_final || is_const) {
     ErrorMsg(ident_pos,
     "missing initialization of 'final' or 'const' variable");
   } else {
     // Initialize variable with null.
-    AstNode* null_expr = new LiteralNode(ident_pos, Instance::ZoneHandle());
-    initialization = new StoreLocalNode(ident_pos, variable, null_expr);
+    AstNode* null_expr = new(isolate()) LiteralNode(
+        ident_pos, Instance::ZoneHandle());
+    initialization = new(isolate()) StoreLocalNode(
+        ident_pos, variable, null_expr);
   }
 
   ASSERT(current_block_ != NULL);
   const intptr_t previous_pos =
   current_block_->scope->PreviousReferencePos(ident);
   if (previous_pos >= 0) {
     ASSERT(!script_.IsNull());
     if (previous_pos > ident_pos) {
       ErrorMsg(ident_pos,
                "initializer of '%s' may not refer to itself",
@@ skipping 98 matching lines @@
                                                 NULL);
     sequence->Add(ParseVariableDeclaration(type, is_final, is_const));
     initializers = sequence;
   }
   return initializers;
 }
 
 
 AstNode* Parser::ParseFunctionStatement(bool is_literal) {
   TRACE_PARSER("ParseFunctionStatement");
-  AbstractType& result_type = AbstractType::Handle();
+  AbstractType& result_type = AbstractType::Handle(isolate());
   const String* variable_name = NULL;
   const String* function_name = NULL;
 
   result_type = Type::DynamicType();
 
   const intptr_t function_pos = TokenPos();
   if (is_literal) {
     ASSERT(CurrentToken() == Token::kLPAREN);
     function_name = &Symbols::AnonymousClosure();
   } else {
@@ skipping 53 matching lines @@
   // passed as a function argument, or returned as a function result.
 
   LocalVariable* function_variable = NULL;
   Type& function_type = Type::ZoneHandle();
   if (variable_name != NULL) {
     // Since the function type depends on the signature of the closure function,
     // it cannot be determined before the formal parameter list of the closure
     // function is parsed. Therefore, we set the function type to a new
     // parameterized type to be patched after the actual type is known.
     // We temporarily use the class of the Function interface.
-    const Class& unknown_signature_class = Class::Handle(
-        Type::Handle(Type::Function()).type_class());
-    function_type = Type::New(
-        unknown_signature_class, TypeArguments::Handle(), function_pos);
+    const Class& unknown_signature_class = Class::Handle(isolate(),
+        Type::Handle(isolate(), Type::Function()).type_class());
+    function_type = Type::New(unknown_signature_class,
+                              TypeArguments::Handle(isolate()), function_pos);
     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 LocalVariable(function_pos,
+    function_variable = new(isolate()) LocalVariable(function_pos,
                                           *variable_name,
                                           function_type);
     function_variable->set_is_final();
     ASSERT(current_block_ != NULL);
     ASSERT(current_block_->scope != NULL);
     if (!current_block_->scope->AddVariable(function_variable)) {
       LocalVariable* existing_var =
           current_block_->scope->LookupVariable(function_variable->name(),
                                                 true);
       ASSERT(existing_var != NULL);
       if (existing_var->owner() == current_block_->scope) {
         ErrorMsg(function_pos, "identifier '%s' already defined",
                  function_variable->name().ToCString());
       } else {
         ErrorMsg(function_pos,
                  "'%s' from outer scope has already been used, cannot redefine",
                  function_variable->name().ToCString());
       }
     }
   }
 
   // Parse the local function.
-  Array& default_parameter_values = Array::Handle();
+  Array& default_parameter_values = Array::Handle(isolate());
   SequenceNode* statements = Parser::ParseFunc(function,
                                                &default_parameter_values);
 
   // Now that the local function has formal parameters, lookup the signature
   // class in the current library (but not in its imports) and only create a new
   // canonical signature class if it does not exist yet.
-  const String& signature = String::Handle(function.Signature());
+  const String& signature = String::Handle(isolate(), function.Signature());
   Class& signature_class = Class::ZoneHandle();
   if (!is_new_closure) {
     signature_class = function.signature_class();
   }
   if (signature_class.IsNull()) {
     signature_class = library_.LookupLocalClass(signature);
   }
   if (signature_class.IsNull()) {
     // If we don't have a signature class yet, this must be a closure we
     // have not parsed before.
@@ skipping 15 matching lines @@
   ASSERT(current_class().is_finalized());
 
   // Make sure that the instantiator is captured.
   if ((signature_class.NumTypeParameters() > 0) &&
       (current_block_->scope->function_level() > 0)) {
     CaptureInstantiator();
   }
 
   // Since the signature type is cached by the signature class, it may have
   // been finalized already.
-  Type& signature_type = Type::Handle(signature_class.SignatureType());
-  TypeArguments& signature_type_arguments =
-      TypeArguments::Handle(signature_type.arguments());
+  Type& signature_type = Type::Handle(isolate(),
+                                      signature_class.SignatureType());
+  TypeArguments& signature_type_arguments = TypeArguments::Handle(isolate(),
+      signature_type.arguments());
 
   if (!signature_type.IsFinalized()) {
     signature_type ^= ClassFinalizer::FinalizeType(
         signature_class, signature_type, ClassFinalizer::kCanonicalize);
 
     // The call to ClassFinalizer::FinalizeType may have
     // extended the vector of type arguments.
     signature_type_arguments = signature_type.arguments();
     ASSERT(signature_type_arguments.IsNull() ||
            (signature_type_arguments.Length() ==
@@ skipping 34 matching lines @@
   // captured. The captured variables will be recorded along with their
   // allocation information in a Scope object stored in the function object.
   // This Scope object is then provided to the compiler when compiling the local
   // function. It would be too early to record the captured variables here,
   // since further closure functions may capture more variables.
   // This Scope object is constructed after all variables have been allocated.
   // The local scope of the parsed function can be pruned, since contained
   // 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 ClosureNode(function_pos, function, NULL, statements->scope());
+  AstNode* closure = new(isolate()) ClosureNode(
+      function_pos, function, NULL, statements->scope());
 
   if (function_variable == NULL) {
     ASSERT(is_literal);
     return closure;
   } else {
-    AstNode* initialization =
-        new StoreLocalNode(function_pos, function_variable, closure);
+    AstNode* initialization = new(isolate()) StoreLocalNode(
+        function_pos, function_variable, closure);
     return initialization;
   }
 }
 
 
 // Returns true if the current and next tokens can be parsed as type
 // parameters. Current token position is not saved and restored.
 bool Parser::TryParseTypeParameters() {
   if (CurrentToken() == Token::kLT) {
     // We are possibly looking at type parameters. Find closing ">".
@@ skipping 364 matching lines @@
   ExpectToken(Token::kLPAREN);
   AstNode* cond_expr = ParseExpr(kAllowConst, kConsumeCascades);
   ExpectToken(Token::kRPAREN);
   const bool parsing_loop_body = false;
   SequenceNode* true_branch = ParseNestedStatement(parsing_loop_body, NULL);
   SequenceNode* false_branch = NULL;
   if (CurrentToken() == Token::kELSE) {
     ConsumeToken();
     false_branch = ParseNestedStatement(parsing_loop_body, NULL);
   }
-  AstNode* if_node = new IfNode(if_pos, cond_expr, true_branch, false_branch);
+  AstNode* if_node = new(isolate()) IfNode(
+      if_pos, cond_expr, true_branch, false_branch);
   if (label != NULL) {
     current_block_->statements->Add(if_node);
     SequenceNode* sequence = CloseBlock();
     sequence->set_label(label);
     if_node = sequence;
   }
   return if_node;
 }
 
 
@@ skipping 46 matching lines @@
       // Check that the type class does not override the == operator.
       // Check this only in the first loop iteration since all values
       // are of the same type, which we check above.
       if (ImplementsEqualOperator(val)) {
         ErrorMsg(val_pos,
             "type class of case expression must not implement operator ==");
       }
     }
   }
   if (first_value.IsInteger()) {
-    return Type::Handle(Type::IntType()).type_class();
+    return Type::Handle(isolate(), Type::IntType()).type_class();
   } else if (first_value.IsString()) {
-    return Type::Handle(Type::StringType()).type_class();
+    return Type::Handle(isolate(), Type::StringType()).type_class();
   }
   return first_value.clazz();
 }
 
 
 CaseNode* Parser::ParseCaseClause(LocalVariable* switch_expr_value,
                                   GrowableArray<LiteralNode*>* case_expr_values,
                                   SourceLabel* case_label) {
   TRACE_PARSER("ParseCaseClause");
   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 SequenceNode(case_pos, NULL);
+  SequenceNode* case_expressions = new(isolate()) SequenceNode(case_pos, NULL);
   while (CurrentToken() == Token::kCASE || CurrentToken() == Token::kDEFAULT) {
     if (CurrentToken() == Token::kCASE) {
       if (default_seen) {
         ErrorMsg("default clause must be last case");
       }
       ConsumeToken();  // Keyword case.
       const intptr_t expr_pos = TokenPos();
       AstNode* expr = ParseExpr(kRequireConst, kConsumeCascades);
       ASSERT(expr->IsLiteralNode());
       case_expr_values->Add(expr->AsLiteralNode());
 
-      AstNode* switch_expr_load = new LoadLocalNode(case_pos,
-                                                    switch_expr_value);
-      AstNode* case_comparison = new ComparisonNode(expr_pos,
-                                                    Token::kEQ,
-                                                    expr,
-                                                    switch_expr_load);
+      AstNode* switch_expr_load = new(isolate()) LoadLocalNode(
+          case_pos, switch_expr_value);
+      AstNode* case_comparison = new(isolate()) ComparisonNode(
+          expr_pos, Token::kEQ, expr, switch_expr_load);
       case_expressions->Add(case_comparison);
     } else {
       if (default_seen) {
         ErrorMsg("only one default clause is allowed");
       }
       ConsumeToken();  // Keyword default.
       default_seen = true;
       // The default case always succeeds.
     }
     ExpectToken(Token::kCOLON);
@@ skipping 12 matching lines @@
       next_token = CurrentToken();
     }
     if (next_token == Token::kRBRACE) {
       // End of switch statement.
       break;
     }
     if ((next_token == Token::kCASE) || (next_token == Token::kDEFAULT)) {
       // End of this case clause. If there is a possible fall-through to
       // the next case clause, throw an implicit FallThroughError.
       if (!abrupt_completing_seen) {
-        ArgumentListNode* arguments = new ArgumentListNode(TokenPos());
-        arguments->Add(new LiteralNode(
+        ArgumentListNode* arguments = new(isolate()) ArgumentListNode(
+            TokenPos());
+        arguments->Add(new(isolate()) LiteralNode(
             TokenPos(), Integer::ZoneHandle(Integer::New(TokenPos()))));
         current_block_->statements->Add(
             MakeStaticCall(Symbols::FallThroughError(),
                            Library::PrivateCoreLibName(Symbols::ThrowNew()),
                            arguments));
       }
       break;
     }
     // The next statement still belongs to this case.
     AstNode* statement = ParseStatement();
     if (statement != NULL) {
       current_block_->statements->Add(statement);
       abrupt_completing_seen |= IsAbruptCompleting(statement);
     }
   }
   SequenceNode* statements = CloseBlock();
-  return new CaseNode(case_pos, case_label,
+  return new(isolate()) CaseNode(case_pos, case_label,
       case_expressions, default_seen, switch_expr_value, statements);
 }
 
 
 AstNode* Parser::ParseSwitchStatement(String* label_name) {
   TRACE_PARSER("ParseSwitchStatement");
   ASSERT(CurrentToken() == Token::kSWITCH);
   const intptr_t switch_pos = TokenPos();
   SourceLabel* label =
       SourceLabel::New(switch_pos, label_name, SourceLabel::kSwitch);
   ConsumeToken();
   ExpectToken(Token::kLPAREN);
   const intptr_t expr_pos = TokenPos();
   AstNode* switch_expr = ParseExpr(kAllowConst, kConsumeCascades);
   ExpectToken(Token::kRPAREN);
   ExpectToken(Token::kLBRACE);
   OpenBlock();
   current_block_->scope->AddLabel(label);
 
   // Store switch expression in temporary local variable. The type of the
   // variable is set to dynamic. It will later be patched to match the
   // type of the case clause expressions. Therefore, we have to allocate
   // a new type representing dynamic and can't reuse the canonical
   // type object for dynamic.
-  const Type& temp_var_type =
-      Type::ZoneHandle(Type::New(Class::Handle(Object::dynamic_class()),
-                                 TypeArguments::Handle(),
-                                 expr_pos));
+  const Type& temp_var_type = Type::ZoneHandle(isolate(),
+       Type::New(Class::Handle(isolate(), Object::dynamic_class()),
+                 TypeArguments::Handle(isolate()),
+                 expr_pos));
   temp_var_type.SetIsFinalized();
-  LocalVariable* temp_variable =
-      new LocalVariable(expr_pos,  Symbols::SwitchExpr(), temp_var_type);
+  LocalVariable* temp_variable = new(isolate()) LocalVariable(
+      expr_pos,  Symbols::SwitchExpr(), temp_var_type);
   current_block_->scope->AddVariable(temp_variable);
-  AstNode* save_switch_expr =
-      new StoreLocalNode(expr_pos, temp_variable, switch_expr);
+  AstNode* save_switch_expr = new(isolate()) StoreLocalNode(
+      expr_pos, temp_variable, switch_expr);
   current_block_->statements->Add(save_switch_expr);
 
   // Parse case clauses
   bool default_seen = false;
   GrowableArray<LiteralNode*> case_expr_values;
   while (true) {
     // Check for statement label
     SourceLabel* case_label = NULL;
     if (IsIdentifier() && LookaheadToken(1) == Token::kCOLON) {
       // Case statements start with a label.
       String* label_name = CurrentLiteral();
       const intptr_t label_pos = TokenPos();
       ConsumeToken();  // Consume label identifier.
       ConsumeToken();  // Consume colon.
       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 SourceLabel(label_pos, *label_name, SourceLabel::kCase);
+        case_label = new(isolate()) SourceLabel(
+            label_pos, *label_name, SourceLabel::kCase);
         current_block_->scope->AddLabel(case_label);
       } else if (case_label->kind() == SourceLabel::kForward) {
         // We have seen a 'continue' with this label name. Resolve
         // the forward reference.
         case_label->ResolveForwardReference();
       } else {
         ErrorMsg(label_pos, "label '%s' already exists in scope",
                  label_name->ToCString());
       }
       ASSERT(case_label->kind() == SourceLabel::kCase);
@@ skipping 14 matching lines @@
     } else {
       break;
     }
   }
 
   // Check that all expressions in case clauses are of the same class,
   // or implement int, double or String. Patch the type of the temporary
   // variable holding the switch expression to match the type of the
   // case clause constants.
   temp_var_type.set_type_class(
-      Class::Handle(CheckCaseExpressions(case_expr_values)));
+      Class::Handle(isolate(), CheckCaseExpressions(case_expr_values)));
 
   // Check for unresolved label references.
   SourceLabel* unresolved_label =
       current_block_->scope->CheckUnresolvedLabels();
   if (unresolved_label != NULL) {
     ErrorMsg("unresolved reference to label '%s'",
              unresolved_label->name().ToCString());
   }
 
   SequenceNode* switch_body = CloseBlock();
   ExpectToken(Token::kRBRACE);
-  return new SwitchNode(switch_pos, label, switch_body);
+  return new(isolate()) SwitchNode(switch_pos, label, switch_body);
 }
 
 
 AstNode* Parser::ParseWhileStatement(String* label_name) {
   TRACE_PARSER("ParseWhileStatement");
   const intptr_t while_pos = TokenPos();
   SourceLabel* label =
       SourceLabel::New(while_pos, label_name, SourceLabel::kWhile);
   ConsumeToken();
   ExpectToken(Token::kLPAREN);
   AstNode* cond_expr = ParseExpr(kAllowConst, kConsumeCascades);
   ExpectToken(Token::kRPAREN);
   const bool parsing_loop_body =  true;
   SequenceNode* while_body = ParseNestedStatement(parsing_loop_body, label);
-  return new WhileNode(while_pos, label, cond_expr, while_body);
+  return new(isolate()) WhileNode(while_pos, label, cond_expr, while_body);
 }
 
 
 AstNode* Parser::ParseDoWhileStatement(String* label_name) {
   TRACE_PARSER("ParseDoWhileStatement");
   const intptr_t do_pos = TokenPos();
   SourceLabel* label =
       SourceLabel::New(do_pos, label_name, SourceLabel::kDoWhile);
   ConsumeToken();
   const bool parsing_loop_body =  true;
   SequenceNode* dowhile_body = ParseNestedStatement(parsing_loop_body, label);
   ExpectToken(Token::kWHILE);
   ExpectToken(Token::kLPAREN);
   AstNode* cond_expr = ParseExpr(kAllowConst, kConsumeCascades);
   ExpectToken(Token::kRPAREN);
   ExpectSemicolon();
-  return new DoWhileNode(do_pos, label, cond_expr, dowhile_body);
+  return new(isolate()) DoWhileNode(do_pos, label, cond_expr, dowhile_body);
 }
 
 
 AstNode* Parser::ParseForInStatement(intptr_t forin_pos,
                                      SourceLabel* label) {
   TRACE_PARSER("ParseForInStatement");
   bool is_final = (CurrentToken() == Token::kFINAL);
   if (CurrentToken() == Token::kCONST) {
     ErrorMsg("Loop variable cannot be 'const'");
   }
   const String* loop_var_name = NULL;
   LocalVariable* loop_var = NULL;
   intptr_t loop_var_pos = 0;
   if (LookaheadToken(1) == Token::kIN) {
     loop_var_pos = TokenPos();
     loop_var_name = ExpectIdentifier("variable name expected");
   } else {
     // The case without a type is handled above, so require a type here.
     const AbstractType& type =
         AbstractType::ZoneHandle(ParseConstFinalVarOrType(
             FLAG_enable_type_checks ? ClassFinalizer::kCanonicalize :
                                       ClassFinalizer::kIgnore));
     loop_var_pos = TokenPos();
     loop_var_name = ExpectIdentifier("variable name expected");
-    loop_var = new LocalVariable(loop_var_pos, *loop_var_name, type);
+    loop_var = new(isolate()) LocalVariable(loop_var_pos, *loop_var_name, type);
     if (is_final) {
       loop_var->set_is_final();
     }
   }
   ExpectToken(Token::kIN);
   const intptr_t collection_pos = TokenPos();
   AstNode* collection_expr = ParseExpr(kAllowConst, kConsumeCascades);
   ExpectToken(Token::kRPAREN);
 
   OpenBlock();  // Implicit block around while loop.
 
   // Generate implicit iterator variable and add to scope.
   // We could set the type of the implicit iterator variable to Iterator<T>
   // where T is the type of the for loop variable. However, the type error
   // would refer to the compiler generated iterator and could confuse the user.
   // It is better to leave the iterator untyped and postpone the type error
   // until the loop variable is assigned to.
   const AbstractType& iterator_type = Type::ZoneHandle(Type::DynamicType());
-  LocalVariable* iterator_var =
-      new LocalVariable(collection_pos, Symbols::ForInIter(), iterator_type);
+  LocalVariable* iterator_var = new(isolate()) LocalVariable(
+      collection_pos, Symbols::ForInIter(), iterator_type);
   current_block_->scope->AddVariable(iterator_var);
 
   // Generate initialization of iterator variable.
-  ArgumentListNode* no_args = new ArgumentListNode(collection_pos);
-  AstNode* get_iterator = new InstanceGetterNode(
+  ArgumentListNode* no_args = new(isolate()) ArgumentListNode(collection_pos);
+  AstNode* get_iterator = new(isolate()) InstanceGetterNode(
       collection_pos, collection_expr, Symbols::GetIterator());
   AstNode* iterator_init =
-      new StoreLocalNode(collection_pos, iterator_var, get_iterator);
+      new(isolate()) StoreLocalNode(collection_pos, iterator_var, get_iterator);
   current_block_->statements->Add(iterator_init);
 
   // Generate while loop condition.
-  AstNode* iterator_moveNext = new InstanceCallNode(
+  AstNode* iterator_moveNext = new(isolate()) InstanceCallNode(
       collection_pos,
-      new LoadLocalNode(collection_pos, iterator_var),
+      new(isolate()) LoadLocalNode(collection_pos, iterator_var),
       Symbols::MoveNext(),
       no_args);
 
   // Parse the for loop body. Ideally, we would use ParseNestedStatement()
   // here, but that does not work well because we have to insert an implicit
   // variable assignment and potentially a variable declaration in the
   // loop body.
   OpenLoopBlock();
   current_block_->scope->AddLabel(label);
 
-  AstNode* iterator_current = new InstanceGetterNode(
+  AstNode* iterator_current = new(isolate()) InstanceGetterNode(
       collection_pos,
-      new LoadLocalNode(collection_pos, iterator_var),
+      new(isolate()) LoadLocalNode(collection_pos, iterator_var),
       Symbols::Current());
 
   // Generate assignment of next iterator value to loop variable.
   AstNode* loop_var_assignment = NULL;
   if (loop_var != NULL) {
     // The for loop declares a new variable. Add it to the loop body scope.
     current_block_->scope->AddVariable(loop_var);
     loop_var_assignment =
-        new StoreLocalNode(loop_var_pos, loop_var, iterator_current);
+        new(isolate()) StoreLocalNode(loop_var_pos, loop_var, iterator_current);
   } else {
     AstNode* loop_var_primary =
         ResolveIdent(loop_var_pos, *loop_var_name, false);
     ASSERT(!loop_var_primary->IsPrimaryNode());
     loop_var_assignment = CreateAssignmentNode(
         loop_var_primary, iterator_current, loop_var_name, loop_var_pos);
     ASSERT(loop_var_assignment != NULL);
   }
   current_block_->statements->Add(loop_var_assignment);
 
   // Now parse the for-in loop statement or block.
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
     ParseStatementSequence();
     ExpectToken(Token::kRBRACE);
   } else {
     AstNode* statement = ParseStatement();
     if (statement != NULL) {
       current_block_->statements->Add(statement);
     }
   }
 
   SequenceNode* for_loop_statement = CloseBlock();
 
-  AstNode* while_statement =
-      new WhileNode(forin_pos, label, iterator_moveNext, for_loop_statement);
+  AstNode* while_statement = new(isolate()) WhileNode(
+      forin_pos, label, iterator_moveNext, for_loop_statement);
   current_block_->statements->Add(while_statement);
 
   return CloseBlock();  // Implicit block around while loop.
 }
 
 
 AstNode* Parser::ParseForStatement(String* label_name) {
   TRACE_PARSER("ParseForStatement");
   const intptr_t for_pos = TokenPos();
   ConsumeToken();
@@ skipping 30 matching lines @@
   const bool parsing_loop_body =  true;
   SequenceNode* body = ParseNestedStatement(parsing_loop_body, label);
 
   // Check whether any of the variables in the initializer part of
   // the for statement are captured by a closure. If so, we insert a
   // node that creates a new Context for the loop variable before
   // the increment expression is evaluated.
   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 SequenceNode(incr_pos, NULL);
-      incr_sequence->Add(new CloneContextNode(for_pos));
+      SequenceNode* incr_sequence = new(isolate()) SequenceNode(incr_pos, NULL);
+      incr_sequence->Add(new(isolate()) CloneContextNode(for_pos));
       if (increment != NULL) {
         incr_sequence->Add(increment);
       }
       increment = incr_sequence;
       break;
     }
   }
   AstNode* for_node =
-      new ForNode(for_pos,
+      new(isolate()) ForNode(for_pos,
                   label,
                   NodeAsSequenceNode(init_pos, initializer, NULL),
                   condition,
                   NodeAsSequenceNode(incr_pos, increment, NULL),
                   body);
   current_block_->statements->Add(for_node);
   return CloseBlock();
 }
 
 
 // Calling VM-internal helpers, uses implementation core library.
 AstNode* Parser::MakeStaticCall(const String& cls_name,
                                 const String& func_name,
                                 ArgumentListNode* arguments) {
-  const Class& cls = Class::Handle(Library::LookupCoreClass(cls_name));
+  const Class& cls = Class::Handle(isolate(),
+                                   Library::LookupCoreClass(cls_name));
   ASSERT(!cls.IsNull());
   const Function& func = Function::ZoneHandle(
       Resolver::ResolveStatic(cls,
                               func_name,
                               arguments->length(),
                               arguments->names()));
   ASSERT(!func.IsNull());
-  return new StaticCallNode(arguments->token_pos(), func, arguments);
+  return new(isolate()) StaticCallNode(arguments->token_pos(), func, arguments);
 }
 
 
 AstNode* Parser::MakeAssertCall(intptr_t begin, intptr_t end) {
-  ArgumentListNode* arguments = new ArgumentListNode(begin);
-  arguments->Add(new LiteralNode(begin,
+  ArgumentListNode* arguments = new(isolate()) ArgumentListNode(begin);
+  arguments->Add(new(isolate()) LiteralNode(begin,
       Integer::ZoneHandle(Integer::New(begin))));
-  arguments->Add(new LiteralNode(end,
+  arguments->Add(new(isolate()) LiteralNode(end,
       Integer::ZoneHandle(Integer::New(end))));
   return MakeStaticCall(Symbols::AssertionError(),
                         Library::PrivateCoreLibName(Symbols::ThrowNew()),
                         arguments);
 }
 
 
 AstNode* Parser::InsertClosureCallNodes(AstNode* condition) {
   if (condition->IsClosureNode() ||
       (condition->IsStoreLocalNode() &&
        condition->AsStoreLocalNode()->value()->IsClosureNode())) {
     // Function literal in assert implies a call.
     const intptr_t pos = condition->token_pos();
-    condition = BuildClosureCall(pos, condition, new ArgumentListNode(pos));
+    condition = BuildClosureCall(pos,
+                                 condition,
+                                 new(isolate()) ArgumentListNode(pos));
   } else if (condition->IsConditionalExprNode()) {
     ConditionalExprNode* cond_expr = condition->AsConditionalExprNode();
     cond_expr->set_true_expr(InsertClosureCallNodes(cond_expr->true_expr()));
     cond_expr->set_false_expr(InsertClosureCallNodes(cond_expr->false_expr()));
   }
   return condition;
 }
 
 
 AstNode* Parser::ParseAssertStatement() {
   TRACE_PARSER("ParseAssertStatement");
   ConsumeToken();  // Consume assert keyword.
   ExpectToken(Token::kLPAREN);
   const intptr_t condition_pos = TokenPos();
   if (!FLAG_enable_asserts && !FLAG_enable_type_checks) {
     SkipExpr();
     ExpectToken(Token::kRPAREN);
     return NULL;
   }
   AstNode* condition = ParseExpr(kAllowConst, kConsumeCascades);
   const intptr_t condition_end = TokenPos();
   ExpectToken(Token::kRPAREN);
   condition = InsertClosureCallNodes(condition);
-  condition = new UnaryOpNode(condition_pos, Token::kNOT, condition);
+  condition = new(isolate()) UnaryOpNode(condition_pos, Token::kNOT, condition);
   AstNode* assert_throw = MakeAssertCall(condition_pos, condition_end);
-  return new IfNode(condition_pos,
-                    condition,
-                    NodeAsSequenceNode(condition_pos, assert_throw, NULL),
-                    NULL);
+  return new(isolate()) IfNode(
+      condition_pos,
+      condition,
+      NodeAsSequenceNode(condition_pos, assert_throw, NULL),
+      NULL);
 }
 
 
 struct CatchParamDesc {
   CatchParamDesc()
       : token_pos(0), type(NULL), name(NULL), var(NULL) { }
   intptr_t token_pos;
   const AbstractType* type;
   const String* name;
   LocalVariable* var;
 };
 
 
 // Populate local scope of the catch block with the catch parameters.
 void Parser::AddCatchParamsToScope(CatchParamDesc* exception_param,
                                    CatchParamDesc* stack_trace_param,
                                    LocalScope* scope) {
   if (exception_param->name != NULL) {
-    LocalVariable* var = new LocalVariable(exception_param->token_pos,
-                                           *exception_param->name,
-                                           *exception_param->type);
+    LocalVariable* var = new(isolate()) LocalVariable(
+        exception_param->token_pos,
+        *exception_param->name,
+        *exception_param->type);
     var->set_is_final();
     bool added_to_scope = scope->AddVariable(var);
     ASSERT(added_to_scope);
     exception_param->var = var;
   }
   if (stack_trace_param->name != NULL) {
-    LocalVariable* var = new LocalVariable(stack_trace_param->token_pos,
-                                           *stack_trace_param->name,
-                                           *stack_trace_param->type);
+    LocalVariable* var = new(isolate()) LocalVariable(
+        stack_trace_param->token_pos,
+        *stack_trace_param->name,
+        *stack_trace_param->type);
     var->set_is_final();
     bool added_to_scope = scope->AddVariable(var);
     if (!added_to_scope) {
       ErrorMsg(stack_trace_param->token_pos,
                "name '%s' already exists in scope",
                stack_trace_param->name->ToCString());
     }
     stack_trace_param->var = var;
   }
 }
 
 
 SequenceNode* Parser::ParseFinallyBlock() {
   TRACE_PARSER("ParseFinallyBlock");
   OpenBlock();
   ExpectToken(Token::kLBRACE);
   ParseStatementSequence();
   ExpectToken(Token::kRBRACE);
   SequenceNode* finally_block = CloseBlock();
   return finally_block;
 }
 
 
 void Parser::PushTryBlock(Block* try_block) {
   intptr_t try_index = AllocateTryIndex();
-  TryBlocks* block = new TryBlocks(try_block, try_blocks_list_, try_index);
+  TryBlocks* block = new(isolate()) TryBlocks(
+      try_block, try_blocks_list_, try_index);
   try_blocks_list_ = block;
 }
 
 
 Parser::TryBlocks* Parser::PopTryBlock() {
   TryBlocks* innermost_try_block = try_blocks_list_;
   try_blocks_list_ = try_blocks_list_->outer_try_block();
   return innermost_try_block;
 }
 
@@ skipping 94 matching lines @@
     //    variables (as needed).
     // 2) Nested block with source code from catch clause block.
     OpenBlock();
     AddCatchParamsToScope(&exception_param, &stack_trace_param,
                           current_block_->scope);
 
     if (exception_param.var != NULL) {
       // 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 StoreLocalNode(catch_pos, exception_param.var,
-                             new LoadLocalNode(catch_pos, exception_var)));
+      current_block_->statements->Add(new(isolate()) StoreLocalNode(
+          catch_pos, exception_param.var, new(isolate()) LoadLocalNode(
+              catch_pos, exception_var)));
     }
     if (stack_trace_param.var != NULL) {
       // 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.
       *needs_stack_trace = true;
-      ArgumentListNode* no_args = new ArgumentListNode(catch_pos);
+      ArgumentListNode* no_args = new(isolate()) ArgumentListNode(catch_pos);
       ASSERT(stack_trace_var != NULL);
-      current_block_->statements->Add(
-          new StoreLocalNode(catch_pos, stack_trace_param.var,
-                             new LoadLocalNode(catch_pos, stack_trace_var)));
-      current_block_->statements->Add(
-          new InstanceCallNode(
-              catch_pos,
-              new LoadLocalNode(catch_pos, stack_trace_param.var),
-              Library::PrivateCoreLibName(Symbols::_setupFullStackTrace()),
-              no_args));
+      current_block_->statements->Add(new(isolate()) StoreLocalNode(
+          catch_pos, stack_trace_param.var, new(isolate()) LoadLocalNode(
+              catch_pos, stack_trace_var)));
+      current_block_->statements->Add(new(isolate()) InstanceCallNode(
+          catch_pos,
+          new(isolate()) LoadLocalNode(catch_pos, stack_trace_param.var),
+          Library::PrivateCoreLibName(Symbols::_setupFullStackTrace()),
+          no_args));
     }
 
     // Add nested block with user-defined code.  This blocks allows
     // declarations in the body to shadow the catch parameters.
     CheckToken(Token::kLBRACE);
     current_block_->statements->Add(ParseNestedStatement(false, NULL));
     catch_blocks.Add(CloseBlock());
 
     const bool is_bad_type =
         exception_param.type->IsMalformed() ||
         exception_param.type->IsMalbounded();
     if (exception_param.type->IsDynamicType() || is_bad_type) {
       // There is no exception type or else it is malformed or malbounded.
       // In the first case, unconditionally execute the catch body.  In the
       // second case, unconditionally throw.
       generic_catch_seen = true;
-      type_tests.Add(new LiteralNode(catch_pos, Bool::True()));
+      type_tests.Add(new(isolate()) LiteralNode(catch_pos, Bool::True()));
       if (is_bad_type) {
         // Replace the body with one that throws.
-        SequenceNode* block = new SequenceNode(catch_pos, NULL);
+        SequenceNode* block = new(isolate()) SequenceNode(catch_pos, NULL);
         block->Add(ThrowTypeError(catch_pos, *exception_param.type));
         catch_blocks.Last() = block;
       }
       // This catch clause will handle all exceptions. We can safely forget
       // all previous catch clause types.
       handler_types.SetLength(0);
       handler_types.Add(*exception_param.type);
     } else {
       // Has a type specification that is not malformed or malbounded.  Now
       // form an 'if type check' to guard the catch handler code.
       if (!exception_param.type->IsInstantiated() &&
           (current_block_->scope->function_level() > 0)) {
         // Make sure that the instantiator is captured.
         CaptureInstantiator();
       }
-      TypeNode* exception_type = new TypeNode(catch_pos, *exception_param.type);
-      AstNode* exception_value = new LoadLocalNode(catch_pos, exception_var);
+      TypeNode* exception_type = new(isolate()) TypeNode(
+          catch_pos, *exception_param.type);
+      AstNode* exception_value = new(isolate()) LoadLocalNode(
+          catch_pos, exception_var);
       if (!exception_type->type().IsInstantiated()) {
         EnsureExpressionTemp();
       }
-      type_tests.Add(new ComparisonNode(catch_pos, Token::kIS, exception_value,
-                                        exception_type));
+      type_tests.Add(new(isolate()) ComparisonNode(
+          catch_pos, Token::kIS, exception_value, exception_type));
 
       // Do not add uninstantiated types (e.g. type parameter T or generic
       // type List<T>), since the debugger won't be able to instantiate it
       // when walking the stack.
       //
       // This means that the debugger is not able to determine whether an
       // exception is caught if the catch clause uses generic types.  It
       // will report the exception as uncaught when in fact it might be
       // caught and handled when we unwind the stack.
       if (!generic_catch_seen && exception_param.type->IsInstantiated()) {
         handler_types.Add(*exception_param.type);
       }
     }
 
     ASSERT(type_tests.length() == catch_blocks.length());
   }
 
   // Build the if/then/else nest from the inside out.  Keep the AST simple
   // for the case of a single generic catch clause.  The initial value of
   // current is the last (innermost) else block if there were any catch
   // clauses.
   SequenceNode* current = NULL;
   if (!generic_catch_seen) {
     // 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 SequenceNode(handler_pos, NULL);
-    current->Add(
-        new ThrowNode(handler_pos,
-                      new LoadLocalNode(handler_pos, exception_var),
-                      new LoadLocalNode(handler_pos, stack_trace_var)));
+    current = new(isolate()) SequenceNode(handler_pos, NULL);
+    current->Add(new(isolate()) ThrowNode(
+        handler_pos,
+        new(isolate()) LoadLocalNode(handler_pos, exception_var),
+        new(isolate()) LoadLocalNode(handler_pos, stack_trace_var)));
   } else if (type_tests.Last()->IsLiteralNode()) {
     ASSERT(type_tests.Last()->AsLiteralNode()->literal().raw() ==
            Bool::True().raw());
     // The last body is entered unconditionally.  Start building the
     // if/then/else nest with that body as the innermost else block.
     // Note that it is nested inside an extra block which we opened
     // before we knew the body was entered unconditionally.
     type_tests.RemoveLast();
     current_block_->statements->Add(catch_blocks.RemoveLast());
     current = CloseBlock();
   }
   // If the last body was entered conditionally and there is no need to add
   // a rethrow, use an empty else body (current = NULL above).
 
   while (!type_tests.is_empty()) {
     AstNode* type_test = type_tests.RemoveLast();
     SequenceNode* catch_block = catch_blocks.RemoveLast();
-    current_block_->statements->Add(
-        new IfNode(type_test->token_pos(), type_test, catch_block, current));
+    current_block_->statements->Add(new(isolate()) IfNode(
+        type_test->token_pos(), type_test, catch_block, current));
     current = CloseBlock();
   }
   return current;
 }
 
 
 AstNode* Parser::ParseTryStatement(String* label_name) {
   TRACE_PARSER("ParseTryStatement");
 
   // We create three variables for exceptions here:
   // ':saved_try_context_var' - Used to save the context before the start of
   //                            the try block. The context register is
   //                            restored from this variable before
   //                            processing the catch block handler.
   // ':exception_var' - Used to save the current exception object that was
   //                    thrown.
   // ':stack_trace_var' - Used to save the current stack trace object which
   //                      the stack trace was copied into when an exception
   //                      was thrown.
   // :exception_var and :stack_trace_var get set with the exception object
   // and the stack trace object when an exception is thrown.  These three
   // implicit variables can never be captured.
   LocalVariable* context_var =
       current_block_->scope->LocalLookupVariable(Symbols::SavedTryContextVar());
   if (context_var == NULL) {
-    context_var = new LocalVariable(TokenPos(),
-                                    Symbols::SavedTryContextVar(),
-                                    Type::ZoneHandle(Type::DynamicType()));
+    context_var = new(isolate()) LocalVariable(
+        TokenPos(),
+        Symbols::SavedTryContextVar(),
+        Type::ZoneHandle(Type::DynamicType()));
     current_block_->scope->AddVariable(context_var);
   }
   LocalVariable* exception_var =
       current_block_->scope->LocalLookupVariable(Symbols::ExceptionVar());
   if (exception_var == NULL) {
-    exception_var = new LocalVariable(TokenPos(),
-                                      Symbols::ExceptionVar(),
-                                      Type::ZoneHandle(Type::DynamicType()));
+    exception_var = new(isolate()) LocalVariable(
+        TokenPos(),
+        Symbols::ExceptionVar(),
+        Type::ZoneHandle(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 LocalVariable(TokenPos(),
-                                        Symbols::StackTraceVar(),
-                                        Type::ZoneHandle(Type::DynamicType()));
+    stack_trace_var = new(isolate()) LocalVariable(
+        TokenPos(),
+        Symbols::StackTraceVar(),
+        Type::ZoneHandle(Type::DynamicType()));
     current_block_->scope->AddVariable(stack_trace_var);
   }
 
   const intptr_t try_pos = TokenPos();
   ConsumeToken();  // Consume the 'try'.
 
   SourceLabel* try_label = NULL;
   if (label_name != NULL) {
     try_label = SourceLabel::New(try_pos, label_name, SourceLabel::kStatement);
     OpenBlock();
@@ skipping 10 matching lines @@
 
   if ((CurrentToken() != Token::kCATCH) && !IsLiteral("on") &&
       (CurrentToken() != Token::kFINALLY)) {
     ErrorMsg("catch or finally clause expected");
   }
 
   // Now parse the 'catch' blocks if any.
   try_blocks_list_->enter_catch();
   const intptr_t handler_pos = TokenPos();
   const GrowableObjectArray& handler_types =
-      GrowableObjectArray::Handle(GrowableObjectArray::New());
+      GrowableObjectArray::Handle(isolate(), GrowableObjectArray::New());
   bool needs_stack_trace = false;
   SequenceNode* catch_handler_list =
       ParseCatchClauses(handler_pos, exception_var, stack_trace_var,
                         handler_types, &needs_stack_trace);
 
   TryBlocks* inner_try_block = PopTryBlock();
   const intptr_t try_index = inner_try_block->try_index();
   TryBlocks* outer_try_block = try_blocks_list_;
   const intptr_t outer_try_index = (outer_try_block != NULL)
       ? outer_try_block->try_index()
       : CatchClauseNode::kInvalidTryIndex;
 
   // Finally parse the 'finally' block.
   SequenceNode* finally_block = NULL;
   if (CurrentToken() == Token::kFINALLY) {
     ConsumeToken();  // Consume the 'finally'.
     const intptr_t finally_pos = TokenPos();
     // Add the finally block to the exit points recorded so far.
     intptr_t node_index = 0;
     AstNode* node_to_inline =
         inner_try_block->GetNodeToInlineFinally(node_index);
     while (node_to_inline != NULL) {
       finally_block = ParseFinallyBlock();
-      InlinedFinallyNode* node = new InlinedFinallyNode(finally_pos,
+      InlinedFinallyNode* node = new(isolate()) InlinedFinallyNode(finally_pos,
                                                         finally_block,
                                                         context_var,
                                                         outer_try_index);
       AddFinallyBlockToNode(node_to_inline, node);
       node_index += 1;
       node_to_inline = inner_try_block->GetNodeToInlineFinally(node_index);
       tokens_iterator_.SetCurrentPosition(finally_pos);
     }
     finally_block = ParseFinallyBlock();
   }
 
-  CatchClauseNode* catch_clause =
-      new CatchClauseNode(handler_pos,
-                          catch_handler_list,
-                          Array::ZoneHandle(Array::MakeArray(handler_types)),
-                          context_var,
-                          exception_var,
-                          stack_trace_var,
-                          (finally_block != NULL)
-                              ? AllocateTryIndex()
-                              : CatchClauseNode::kInvalidTryIndex,
-                          needs_stack_trace);
+  CatchClauseNode* catch_clause = new(isolate()) CatchClauseNode(
+      handler_pos,
+      catch_handler_list,
+      Array::ZoneHandle(Array::MakeArray(handler_types)),
+      context_var,
+      exception_var,
+      stack_trace_var,
+      (finally_block != NULL) ?
+          AllocateTryIndex() : CatchClauseNode::kInvalidTryIndex,
+      needs_stack_trace);
 
   // Now create the try/catch ast node and return it. If there is a label
   // on the try/catch, close the block that's embedding the try statement
   // and attach the label to it.
-  AstNode* try_catch_node =
-      new TryCatchNode(try_pos, try_block, context_var, catch_clause,
-                       finally_block, try_index);
+  AstNode* try_catch_node = new(isolate()) TryCatchNode(
+      try_pos, try_block, context_var, catch_clause, finally_block, try_index);
 
   if (try_label != NULL) {
     current_block_->statements->Add(try_catch_node);
     SequenceNode* sequence = CloseBlock();
     sequence->set_label(try_label);
     try_catch_node = sequence;
   }
   return try_catch_node;
 }
 
@@ skipping 20 matching lines @@
     }
     target = current_block_->scope->LookupLabel(target_name);
     if (target == NULL && jump_kind == Token::kCONTINUE) {
       // Either a reference to a non-existent label, or a forward reference
       // to a case label that we haven't seen yet. If we are inside a switch
       // statement, create a "forward reference" label in the scope of
       // the switch statement.
       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 SourceLabel(
+        target = new(isolate()) SourceLabel(
             TokenPos(), target_name, SourceLabel::kForward);
         switch_scope->AddLabel(target);
       }
     }
     if (target == NULL) {
       ErrorMsg(jump_pos, "label '%s' not found", target_name.ToCString());
     }
   } else {
     target = current_block_->scope->LookupInnermostLabel(jump_kind);
     if (target == NULL) {
       ErrorMsg(jump_pos, "'%s' is illegal here", Token::Str(jump_kind));
     }
   }
   ASSERT(target != NULL);
   if (jump_kind == Token::kCONTINUE) {
     if (target->kind() == SourceLabel::kSwitch) {
       ErrorMsg(jump_pos, "'continue' jump to switch statement is illegal");
     } else if (target->kind() == SourceLabel::kStatement) {
       ErrorMsg(jump_pos, "'continue' jump to label '%s' is illegal",
                target->name().ToCString());
     }
   }
   if (jump_kind == Token::kBREAK && target->kind() == SourceLabel::kCase) {
     ErrorMsg(jump_pos, "'break' to case clause label is illegal");
   }
   if (target->FunctionLevel() != current_block_->scope->function_level()) {
     ErrorMsg(jump_pos, "'%s' target must be in same function context",
              Token::Str(jump_kind));
   }
-  return new JumpNode(jump_pos, jump_kind, target);
+  return new(isolate()) JumpNode(jump_pos, jump_kind, target);
 }
 
 
 AstNode* Parser::ParseStatement() {
   TRACE_PARSER("ParseStatement");
   AstNode* statement = NULL;
   intptr_t label_pos = 0;
   String* label_name = NULL;
   if (IsIdentifier()) {
     if (LookaheadToken(1) == Token::kCOLON) {
@@ skipping 19 matching lines @@
     statement = ParseTryStatement(label_name);
   } else if (CurrentToken() == Token::kRETURN) {
     const intptr_t return_pos = TokenPos();
     ConsumeToken();
     if (CurrentToken() != Token::kSEMICOLON) {
       if (current_function().IsConstructor() &&
           (current_block_->scope->function_level() == 0)) {
         ErrorMsg(return_pos, "return of a value not allowed in constructors");
       }
       AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
-      statement = new ReturnNode(statement_pos, expr);
+      statement = new(isolate()) ReturnNode(statement_pos, expr);
     } else {
-      statement = new ReturnNode(statement_pos);
+      statement = new(isolate()) ReturnNode(statement_pos);
     }
     AddNodeForFinallyInlining(statement);
     ExpectSemicolon();
   } else if (CurrentToken() == Token::kIF) {
     statement = ParseIfStatement(label_name);
   } else if (CurrentToken() == Token::kASSERT) {
     statement = ParseAssertStatement();
     ExpectSemicolon();
   } else if (IsVariableDeclaration()) {
     statement = ParseVariableDeclarationList();
@@ skipping 36 matching lines @@
     // The exception and stack trace variables are bound in the block
     // containing the try.
     LocalScope* scope = try_blocks_list_->try_block()->scope->parent();
     ASSERT(scope != NULL);
     LocalVariable* excp_var =
         scope->LocalLookupVariable(Symbols::ExceptionVar());
     ASSERT(excp_var != NULL);
     LocalVariable* trace_var =
         scope->LocalLookupVariable(Symbols::StackTraceVar());
     ASSERT(trace_var != NULL);
-    statement = new ThrowNode(statement_pos,
-                              new LoadLocalNode(statement_pos, excp_var),
-                              new LoadLocalNode(statement_pos, trace_var));
+    statement = new(isolate()) ThrowNode(
+        statement_pos,
+        new(isolate()) LoadLocalNode(statement_pos, excp_var),
+        new(isolate()) LoadLocalNode(statement_pos, trace_var));
   } else {
     statement = ParseExpr(kAllowConst, kConsumeCascades);
     ExpectSemicolon();
   }
   return statement;
 }
 
 
 void Parser::ErrorMsg(intptr_t token_pos, const char* format, ...) const {
   va_list args;
   va_start(args, format);
-  const Error& error = Error::Handle(LanguageError::NewFormattedV(
-      Error::Handle(), script_, token_pos,
+  const Error& error = Error::Handle(isolate(), LanguageError::NewFormattedV(
+      Error::Handle(isolate()), script_, token_pos,
       LanguageError::kError, Heap::kNew, format, args));
   va_end(args);
   isolate()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 
 void Parser::ErrorMsg(const char* format, ...) {
   va_list args;
   va_start(args, format);
-  const Error& error = Error::Handle(LanguageError::NewFormattedV(
-      Error::Handle(), script_, TokenPos(),
+  const Error& error = Error::Handle(isolate(), LanguageError::NewFormattedV(
+      Error::Handle(isolate()), script_, TokenPos(),
       LanguageError::kError, Heap::kNew, format, args));
   va_end(args);
   isolate()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 
 void Parser::ErrorMsg(const Error& error) {
   Isolate::Current()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 
 void Parser::AppendErrorMsg(
       const Error& prev_error, intptr_t token_pos, const char* format, ...) {
   va_list args;
   va_start(args, format);
-  const Error& error = Error::Handle(
-      LanguageError::NewFormattedV(
-          prev_error, script_, token_pos,
-          LanguageError::kError, Heap::kNew,
-          format, args));
+  const Error& error = Error::Handle(isolate(), LanguageError::NewFormattedV(
+      prev_error, script_, token_pos,
+      LanguageError::kError, Heap::kNew,
+      format, args));
   va_end(args);
   isolate()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 
 void Parser::Warning(intptr_t token_pos, const char* format, ...) {
   if (FLAG_silent_warnings) return;
   va_list args;
   va_start(args, format);
-  const Error& error = Error::Handle(
-      LanguageError::NewFormattedV(
-          Error::Handle(), script_, token_pos,
-          LanguageError::kWarning, Heap::kNew,
-          format, args));
+  const Error& error = Error::Handle(isolate(), LanguageError::NewFormattedV(
+      Error::Handle(isolate()), script_, token_pos,
+      LanguageError::kWarning, Heap::kNew,
+      format, args));
   va_end(args);
   if (FLAG_warning_as_error) {
     isolate()->long_jump_base()->Jump(1, error);
     UNREACHABLE();
   } else {
     OS::Print("%s", error.ToErrorCString());
   }
 }
 
 
 void Parser::Warning(const char* format, ...) {
   if (FLAG_silent_warnings) return;
   va_list args;
   va_start(args, format);
-  const Error& error = Error::Handle(
-      LanguageError::NewFormattedV(
-          Error::Handle(), script_, TokenPos(),
-          LanguageError::kWarning, Heap::kNew,
-          format, args));
+  const Error& error = Error::Handle(isolate(), LanguageError::NewFormattedV(
+      Error::Handle(isolate()), script_, TokenPos(),
+      LanguageError::kWarning, Heap::kNew,
+      format, args));
   va_end(args);
   if (FLAG_warning_as_error) {
     isolate()->long_jump_base()->Jump(1, error);
     UNREACHABLE();
   } else {
     OS::Print("%s", error.ToErrorCString());
   }
 }
 
 
@@ skipping 85 matching lines @@
     if (node != NULL) {
       sequence->Add(node);
     }
     return sequence;
   }
   return node->AsSequenceNode();
 }
 
 
 AstNode* Parser::ThrowTypeError(intptr_t type_pos, const AbstractType& type) {
-  ArgumentListNode* arguments = new ArgumentListNode(type_pos);
+  ArgumentListNode* arguments = new(isolate()) ArgumentListNode(type_pos);
   // Location argument.
-  arguments->Add(new LiteralNode(
+  arguments->Add(new(isolate()) LiteralNode(
       type_pos, Integer::ZoneHandle(Integer::New(type_pos))));
   // Src value argument.
-  arguments->Add(new LiteralNode(type_pos, Instance::ZoneHandle()));
+  arguments->Add(new(isolate()) LiteralNode(type_pos, Instance::ZoneHandle()));
   // Dst type name argument.
-  arguments->Add(new LiteralNode(type_pos, Symbols::Malformed()));
+  arguments->Add(new(isolate()) LiteralNode(type_pos, Symbols::Malformed()));
   // Dst name argument.
-  arguments->Add(new LiteralNode(type_pos, Symbols::Empty()));
+  arguments->Add(new(isolate()) LiteralNode(type_pos, Symbols::Empty()));
   // Malformed type error or malbounded type error.
-  const Error& error = Error::Handle(type.error());
+  const Error& error = Error::Handle(isolate(), type.error());
   ASSERT(!error.IsNull());
-  arguments->Add(new LiteralNode(type_pos, String::ZoneHandle(
+  arguments->Add(new(isolate()) LiteralNode(type_pos, String::ZoneHandle(
       Symbols::New(error.ToErrorCString()))));
   return MakeStaticCall(Symbols::TypeError(),
                         Library::PrivateCoreLibName(Symbols::ThrowNew()),
                         arguments);
 }
 
 
 AstNode* Parser::ThrowNoSuchMethodError(intptr_t call_pos,
                                         const Class& cls,
                                         const String& function_name,
                                         ArgumentListNode* function_arguments,
                                         InvocationMirror::Call im_call,
                                         InvocationMirror::Type im_type,
                                         Function* func) {
-  ArgumentListNode* arguments = new ArgumentListNode(call_pos);
+  ArgumentListNode* arguments = new(isolate()) ArgumentListNode(call_pos);
   // Object receiver.
   // TODO(regis): For now, we pass a class literal of the unresolved
   // method's owner, but this is not specified and will probably change.
   Type& type = Type::ZoneHandle(
-      Type::New(cls, TypeArguments::Handle(), call_pos, Heap::kOld));
+      Type::New(cls, TypeArguments::Handle(isolate()), call_pos, Heap::kOld));
   type ^= ClassFinalizer::FinalizeType(
       current_class(), type, ClassFinalizer::kCanonicalize);
-  arguments->Add(new LiteralNode(call_pos, type));
+  arguments->Add(new(isolate()) LiteralNode(call_pos, type));
   // String memberName.
-  arguments->Add(new LiteralNode(
+  arguments->Add(new(isolate()) LiteralNode(
       call_pos, String::ZoneHandle(Symbols::New(function_name))));
   // Smi invocation_type.
   if (cls.IsTopLevel()) {
     ASSERT(im_call == InvocationMirror::kStatic ||
            im_call == InvocationMirror::kTopLevel);
     im_call = InvocationMirror::kTopLevel;
   }
-  arguments->Add(new LiteralNode(call_pos, Smi::ZoneHandle(
+  arguments->Add(new(isolate()) LiteralNode(call_pos, Smi::ZoneHandle(
       Smi::New(InvocationMirror::EncodeType(im_call, im_type)))));
   // List arguments.
   if (function_arguments == NULL) {
-    arguments->Add(new LiteralNode(call_pos, Array::ZoneHandle()));
+    arguments->Add(new(isolate()) LiteralNode(call_pos, Array::ZoneHandle()));
   } else {
-    ArrayNode* array = new ArrayNode(call_pos,
-                                     Type::ZoneHandle(Type::ArrayType()),
-                                     function_arguments->nodes());
+    ArrayNode* array = new(isolate()) ArrayNode(
+        call_pos,
+        Type::ZoneHandle(Type::ArrayType()),
+        function_arguments->nodes());
     arguments->Add(array);
   }
   // List argumentNames.
   if (function_arguments == NULL) {
-    arguments->Add(new LiteralNode(call_pos, Array::ZoneHandle()));
+    arguments->Add(new(isolate()) LiteralNode(call_pos, Array::ZoneHandle()));
   } else {
-    arguments->Add(new LiteralNode(call_pos, function_arguments->names()));
+    arguments->Add(new(isolate()) LiteralNode(
+        call_pos, function_arguments->names()));
   }
 
   // List existingArgumentNames.
   // Check if there exists a function with the same name unless caller
   // has done the lookup already. If there is a function with the same
   // name but incompatible parameters, inform the NoSuchMethodError what the
   // expected parameters are.
-  Function& function = Function::Handle();
+  Function& function = Function::Handle(isolate());
   if (func != NULL) {
     function = func->raw();
   } else {
     function = cls.LookupStaticFunction(function_name);
   }
   Array& array = Array::ZoneHandle();
   if (!function.IsNull()) {
     // The constructor for NoSuchMethodError takes a list of existing
     // parameter names to produce a descriptive error message explaining
     // the parameter mismatch. The problem is that the array of names
     // does not describe which parameters are optional positional or
     // named, which can lead to confusing error messages.
     // Since the NoSuchMethodError class only uses the list to produce
     // a string describing the expected parameters, we construct a more
     // descriptive string here and pass it as the only element of the
     // "existingArgumentNames" array of the NoSuchMethodError constructor.
     // TODO(13471): Separate the implementations of NoSuchMethodError
     // 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(function.UserVisibleFormalParameters()));
+    array.SetAt(0, String::Handle(isolate(),
+        function.UserVisibleFormalParameters()));
   }
-  arguments->Add(new LiteralNode(call_pos, array));
+  arguments->Add(new(isolate()) LiteralNode(call_pos, array));
 
   return MakeStaticCall(Symbols::NoSuchMethodError(),
                         Library::PrivateCoreLibName(Symbols::ThrowNew()),
                         arguments);
 }
 
 
 AstNode* Parser::ParseBinaryExpr(int min_preced) {
   TRACE_PARSER("ParseBinaryExpr");
   ASSERT(min_preced >= Token::Precedence(Token::kOR));
@@ skipping 18 matching lines @@
           op_kind = Token::kISNOT;
         }
         const intptr_t type_pos = TokenPos();
         const AbstractType& type = AbstractType::ZoneHandle(
             ParseType(ClassFinalizer::kCanonicalize));
         if (!type.IsInstantiated() &&
             (current_block_->scope->function_level() > 0)) {
           // Make sure that the instantiator is captured.
           CaptureInstantiator();
         }
-        right_operand = new TypeNode(type_pos, type);
+        right_operand = new(isolate()) TypeNode(type_pos, type);
         // In production mode, the type may be malformed.
         // In checked mode, the type may be malformed or malbounded.
         if (((op_kind == Token::kIS) || (op_kind == Token::kISNOT) ||
              (op_kind == Token::kAS)) &&
             type.IsMalformedOrMalbounded()) {
           // Note that a type error is thrown in a type test or in
           // a type cast even if the tested value is null.
           // We need to evaluate the left operand for potential
           // side effects.
-          LetNode* let = new LetNode(left_operand->token_pos());
+          LetNode* let = new(isolate()) LetNode(left_operand->token_pos());
           let->AddNode(left_operand);
           let->AddNode(ThrowTypeError(type_pos, type));
           left_operand = let;
           break;  // Type checks and casts can't be chained.
         }
       }
       if (Token::IsRelationalOperator(op_kind)
           || Token::IsTypeTestOperator(op_kind)
           || Token::IsTypeCastOperator(op_kind)
           || Token::IsEqualityOperator(op_kind)) {
         if (Token::IsTypeTestOperator(op_kind) ||
             Token::IsTypeCastOperator(op_kind)) {
           if (!right_operand->AsTypeNode()->type().IsInstantiated()) {
             EnsureExpressionTemp();
           }
         }
-        left_operand = new ComparisonNode(
+        left_operand = new(isolate()) ComparisonNode(
             op_pos, op_kind, left_operand, right_operand);
         break;  // Equality and relational operators cannot be chained.
       } else {
         left_operand = OptimizeBinaryOpNode(
             op_pos, op_kind, left_operand, right_operand);
       }
     }
     current_preced--;
   }
   return left_operand;
 }
 
 
 AstNode* Parser::ParseExprList() {
   TRACE_PARSER("ParseExprList");
   AstNode* expressions = ParseExpr(kAllowConst, kConsumeCascades);
   if (CurrentToken() == Token::kCOMMA) {
     // Collect comma-separated expressions in a non scope owning sequence node.
-    SequenceNode* list = new SequenceNode(TokenPos(), NULL);
+    SequenceNode* list = new(isolate()) SequenceNode(TokenPos(), NULL);
     list->Add(expressions);
     while (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
       AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
       list->Add(expr);
     }
     expressions = list;
   }
   return expressions;
 }
 
 
 void Parser::EnsureExpressionTemp() {
   // Temporary used later by the flow_graph_builder.
   parsed_function()->EnsureExpressionTemp();
 }
 
 
 void Parser::EnsureSavedCurrentContext() {
   // Used later by the flow_graph_builder to save current context.
   if (!parsed_function()->has_saved_current_context_var()) {
-    LocalVariable* temp =
-        new LocalVariable(current_function().token_pos(),
-                          Symbols::SavedCurrentContextVar(),
-                          Type::ZoneHandle(Type::DynamicType()));
+    LocalVariable* temp = new(isolate()) LocalVariable(
+        current_function().token_pos(),
+        Symbols::SavedCurrentContextVar(),
+        Type::ZoneHandle(Type::DynamicType()));
     ASSERT(temp != NULL);
     parsed_function()->set_saved_current_context_var(temp);
   }
 }
 
 
 LocalVariable* Parser::CreateTempConstVariable(intptr_t token_pos,
                                                const char* s) {
   char name[64];
   OS::SNPrint(name, 64, ":%s%" Pd, s, token_pos);
-  LocalVariable* temp =
-      new LocalVariable(token_pos,
-                        String::ZoneHandle(Symbols::New(name)),
-                        Type::ZoneHandle(Type::DynamicType()));
+  LocalVariable* temp = new(isolate()) LocalVariable(
+      token_pos,
+      String::ZoneHandle(Symbols::New(name)),
+      Type::ZoneHandle(Type::DynamicType()));
   temp->set_is_final();
   current_block_->scope->AddVariable(temp);
   return temp;
 }
 
 
 // TODO(srdjan): Implement other optimizations.
 AstNode* Parser::OptimizeBinaryOpNode(intptr_t op_pos,
                                       Token::Kind binary_op,
                                       AstNode* lhs,
                                       AstNode* rhs) {
   LiteralNode* lhs_literal = lhs->AsLiteralNode();
   LiteralNode* rhs_literal = rhs->AsLiteralNode();
   if ((lhs_literal != NULL) && (rhs_literal != NULL)) {
     if (lhs_literal->literal().IsDouble() &&
         rhs_literal->literal().IsDouble()) {
       double left_double = Double::Cast(lhs_literal->literal()).value();
       double right_double = Double::Cast(rhs_literal->literal()).value();
       if (binary_op == Token::kDIV) {
         const Double& dbl_obj = Double::ZoneHandle(
             Double::NewCanonical((left_double / right_double)));
-        return new LiteralNode(op_pos, dbl_obj);
+        return new(isolate()) LiteralNode(op_pos, dbl_obj);
       }
     }
   }
   if ((binary_op == Token::kAND) || (binary_op == Token::kOR)) {
     EnsureExpressionTemp();
   }
   if (binary_op == Token::kBIT_AND) {
     // Normalize so that rhs is a literal if any is.
     if ((rhs_literal == NULL) && (lhs_literal != NULL)) {
       // Swap.
       LiteralNode* temp = rhs_literal;
       rhs_literal = lhs_literal;
       lhs_literal = temp;
     }
     if ((rhs_literal != NULL) &&
         (rhs_literal->literal().IsSmi() || rhs_literal->literal().IsMint())) {
       const int64_t val = Integer::Cast(rhs_literal->literal()).AsInt64Value();
       if ((0 <= val) && (Utils::IsUint(32, val))) {
         if (lhs->IsBinaryOpNode() &&
             (lhs->AsBinaryOpNode()->kind() == Token::kSHL)) {
           // Merge SHL and BIT_AND into one "SHL with mask" node.
           BinaryOpNode* old = lhs->AsBinaryOpNode();
-          BinaryOpWithMask32Node* binop = new BinaryOpWithMask32Node(
+          BinaryOpWithMask32Node* binop = new(isolate()) BinaryOpWithMask32Node(
               old->token_pos(), old->kind(), old->left(), old->right(), val);
           return binop;
         }
       }
     }
   }
-  return new BinaryOpNode(op_pos, binary_op, lhs, rhs);
+  return new(isolate()) BinaryOpNode(op_pos, binary_op, lhs, rhs);
 }
 
 
 AstNode* Parser::ExpandAssignableOp(intptr_t op_pos,
                                     Token::Kind assignment_op,
                                     AstNode* lhs,
                                     AstNode* rhs) {
   TRACE_PARSER("ExpandAssignableOp");
   switch (assignment_op) {
     case Token::kASSIGN:
       return rhs;
     case Token::kASSIGN_ADD:
-      return new BinaryOpNode(op_pos, Token::kADD, lhs, rhs);
+      return new(isolate()) BinaryOpNode(op_pos, Token::kADD, lhs, rhs);
     case Token::kASSIGN_SUB:
-      return new BinaryOpNode(op_pos, Token::kSUB, lhs, rhs);
+      return new(isolate()) BinaryOpNode(op_pos, Token::kSUB, lhs, rhs);
     case Token::kASSIGN_MUL:
-      return new BinaryOpNode(op_pos, Token::kMUL, lhs, rhs);
+      return new(isolate()) BinaryOpNode(op_pos, Token::kMUL, lhs, rhs);
     case Token::kASSIGN_TRUNCDIV:
-      return new BinaryOpNode(op_pos, Token::kTRUNCDIV, lhs, rhs);
+      return new(isolate()) BinaryOpNode(op_pos, Token::kTRUNCDIV, lhs, rhs);
     case Token::kASSIGN_DIV:
-      return new BinaryOpNode(op_pos, Token::kDIV, lhs, rhs);
+      return new(isolate()) BinaryOpNode(op_pos, Token::kDIV, lhs, rhs);
     case Token::kASSIGN_MOD:
-      return new BinaryOpNode(op_pos, Token::kMOD, lhs, rhs);
+      return new(isolate()) BinaryOpNode(op_pos, Token::kMOD, lhs, rhs);
     case Token::kASSIGN_SHR:
-      return new BinaryOpNode(op_pos, Token::kSHR, lhs, rhs);
+      return new(isolate()) BinaryOpNode(op_pos, Token::kSHR, lhs, rhs);
     case Token::kASSIGN_SHL:
-      return new BinaryOpNode(op_pos, Token::kSHL, lhs, rhs);
+      return new(isolate()) BinaryOpNode(op_pos, Token::kSHL, lhs, rhs);
     case Token::kASSIGN_OR:
-      return new BinaryOpNode(op_pos, Token::kBIT_OR, lhs, rhs);
+      return new(isolate()) BinaryOpNode(op_pos, Token::kBIT_OR, lhs, rhs);
     case Token::kASSIGN_AND:
-      return new BinaryOpNode(op_pos, Token::kBIT_AND, lhs, rhs);
+      return new(isolate()) BinaryOpNode(op_pos, Token::kBIT_AND, lhs, rhs);
     case Token::kASSIGN_XOR:
-      return new BinaryOpNode(op_pos, Token::kBIT_XOR, lhs, rhs);
+      return new(isolate()) BinaryOpNode(op_pos, Token::kBIT_XOR, lhs, rhs);
     default:
       ErrorMsg(op_pos, "internal error: ExpandAssignableOp '%s' unimplemented",
           Token::Name(assignment_op));
       UNIMPLEMENTED();
       return NULL;
   }
 }
 
 
 // Evaluates the value of the compile time constant expression
 // and returns a literal node for the value.
 AstNode* Parser::FoldConstExpr(intptr_t expr_pos, AstNode* expr) {
   if (expr->IsLiteralNode()) {
     return expr;
   }
   if (expr->EvalConstExpr() == NULL) {
     ErrorMsg(expr_pos, "expression is not a valid compile-time constant");
   }
-  return new LiteralNode(expr_pos, EvaluateConstExpr(expr_pos, expr));
+  return new(isolate()) LiteralNode(
+      expr_pos, EvaluateConstExpr(expr_pos, expr));
 }
 
 
 LetNode* Parser::PrepareCompoundAssignmentNodes(AstNode** expr) {
   AstNode* node = *expr;
   intptr_t token_pos = node->token_pos();
-  LetNode* result = new LetNode(token_pos);
+  LetNode* result = new(isolate()) LetNode(token_pos);
   if (node->IsLoadIndexedNode()) {
     LoadIndexedNode* load_indexed = node->AsLoadIndexedNode();
     AstNode* array = load_indexed->array();
     AstNode* index = load_indexed->index_expr();
     if (!IsSimpleLocalOrLiteralNode(load_indexed->array())) {
       LocalVariable* t0 = result->AddInitializer(load_indexed->array());
-      array = new LoadLocalNode(token_pos, t0);
+      array = new(isolate()) LoadLocalNode(token_pos, t0);
     }
     if (!IsSimpleLocalOrLiteralNode(load_indexed->index_expr())) {
       LocalVariable* t1 = result->AddInitializer(
           load_indexed->index_expr());
-      index = new LoadLocalNode(token_pos, t1);
+      index = new(isolate()) LoadLocalNode(token_pos, t1);
     }
-    *expr = new LoadIndexedNode(token_pos,
+    *expr = new(isolate()) LoadIndexedNode(token_pos,
                                 array,
                                 index,
                                 load_indexed->super_class());
     return result;
   }
   if (node->IsInstanceGetterNode()) {
     InstanceGetterNode* getter = node->AsInstanceGetterNode();
     AstNode* receiver = getter->receiver();
     if (!IsSimpleLocalOrLiteralNode(getter->receiver())) {
       LocalVariable* t0 = result->AddInitializer(getter->receiver());
-      receiver = new LoadLocalNode(token_pos, t0);
+      receiver = new(isolate()) LoadLocalNode(token_pos, t0);
     }
-    *expr = new InstanceGetterNode(token_pos,
-                                   receiver,
-                                   getter->field_name());
+    *expr = new(isolate()) InstanceGetterNode(token_pos,
+                                              receiver,
+                                              getter->field_name());
     return result;
   }
   return result;
 }
 
 
 // Check whether the syntax of expression expr is a grammatically legal
 // assignable expression. This check is used to detect situations where
 // the expression itself is assignable, but the source is grammatically
 // wrong. The AST representation of an expression cannot distinguish
@@ skipping 20 matching lines @@
                                       const String* left_ident,
                                       intptr_t left_pos) {
   AstNode* result = original->MakeAssignmentNode(rhs);
   if (result == NULL) {
     String& name = String::ZoneHandle();
     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(original->AsLoadStaticFieldNode()->field().owner());
+      target_cls = &Class::Handle(isolate(),
+          original->AsLoadStaticFieldNode()->field().owner());
     } else if ((left_ident != NULL) &&
                (original->IsLiteralNode() ||
                 original->IsLoadLocalNode())) {
       name = left_ident->raw();
     }
     if (name.IsNull()) {
       ErrorMsg(left_pos, "expression is not assignable");
     }
     result = ThrowNoSuchMethodError(
         original->token_pos(),
@@ skipping 11 matching lines @@
              result->IsStoreLocalNode()) {
     // Ensure that the expression temp is allocated for nodes that may need it.
     EnsureExpressionTemp();
   }
   return result;
 }
 
 
 AstNode* Parser::ParseCascades(AstNode* expr) {
   intptr_t cascade_pos = TokenPos();
-  LetNode* cascade = new LetNode(cascade_pos);
+  LetNode* cascade = new(isolate()) LetNode(cascade_pos);
   LocalVariable* cascade_receiver_var = cascade->AddInitializer(expr);
   while (CurrentToken() == Token::kCASCADE) {
     cascade_pos = TokenPos();
     LoadLocalNode* load_cascade_receiver =
-        new LoadLocalNode(cascade_pos, cascade_receiver_var);
+        new(isolate()) LoadLocalNode(cascade_pos, cascade_receiver_var);
     if (Token::IsIdentifier(LookaheadToken(1))) {
       // Replace .. with . for ParseSelectors().
       token_kind_ = Token::kPERIOD;
     } else if (LookaheadToken(1) == Token::kLBRACK) {
       ConsumeToken();
     } else {
       ErrorMsg("identifier or [ expected after ..");
     }
     String* expr_ident =
         Token::IsIdentifier(CurrentToken()) ? CurrentLiteral() : NULL;
@@ skipping 24 matching lines @@
         AstNode* assign_expr =
             CreateAssignmentNode(expr, right_expr, expr_ident, expr_pos);
         ASSERT(assign_expr != NULL);
         expr = assign_expr;
       }
     }
     cascade->AddNode(expr);
   }
   // 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 LoadLocalNode(cascade_pos, cascade_receiver_var));
+  cascade->AddNode(new(isolate()) LoadLocalNode(
+      cascade_pos, cascade_receiver_var));
   return cascade;
 }
 
 
 // Convert loading of a static const field into a literal node.
 static AstNode* LiteralIfStaticConst(AstNode* expr) {
   if (expr->IsLoadStaticFieldNode()) {
     const Field& field = expr->AsLoadStaticFieldNode()->field();
     if (field.is_const()) {
       ASSERT(field.value() != Object::sentinel().raw());
@@ skipping 12 matching lines @@
   String* expr_ident =
       Token::IsIdentifier(CurrentToken()) ? CurrentLiteral() : NULL;
   const intptr_t expr_pos = TokenPos();
 
   if (CurrentToken() == Token::kTHROW) {
     ConsumeToken();
     if (CurrentToken() == Token::kSEMICOLON) {
       ErrorMsg("expression expected after throw");
     }
     AstNode* expr = ParseExpr(require_compiletime_const, consume_cascades);
-    return new ThrowNode(expr_pos, expr, NULL);
+    return new(isolate()) ThrowNode(expr_pos, expr, NULL);
   }
   AstNode* expr = ParseConditionalExpr();
   if (!Token::IsAssignmentOperator(CurrentToken())) {
     if ((CurrentToken() == Token::kCASCADE) && consume_cascades) {
       return ParseCascades(expr);
     }
     if (require_compiletime_const) {
       expr = FoldConstExpr(expr_pos, expr);
     } else {
       expr = LiteralIfStaticConst(expr);
@@ skipping 46 matching lines @@
 AstNode* Parser::ParseConditionalExpr() {
   TRACE_PARSER("ParseConditionalExpr");
   const intptr_t expr_pos = TokenPos();
   AstNode* expr = ParseBinaryExpr(Token::Precedence(Token::kOR));
   if (CurrentToken() == Token::kCONDITIONAL) {
     EnsureExpressionTemp();
     ConsumeToken();
     AstNode* expr1 = ParseExpr(kAllowConst, kNoCascades);
     ExpectToken(Token::kCOLON);
     AstNode* expr2 = ParseExpr(kAllowConst, kNoCascades);
-    expr = new ConditionalExprNode(expr_pos, expr, expr1, expr2);
+    expr = new(isolate()) ConditionalExprNode(expr_pos, expr, expr1, expr2);
   }
   return expr;
 }
 
 
 AstNode* Parser::ParseUnaryExpr() {
   TRACE_PARSER("ParseUnaryExpr");
   AstNode* expr = NULL;
   const intptr_t op_pos = TokenPos();
   if (IsPrefixOperator(CurrentToken())) {
@@ skipping 15 matching lines @@
         Token::IsIdentifier(CurrentToken()) ? CurrentLiteral() : NULL;
     const intptr_t expr_pos = TokenPos();
     expr = ParseUnaryExpr();
     if (!IsLegalAssignableSyntax(expr, TokenPos())) {
       ErrorMsg(expr_pos, "expression is not assignable");
     }
     // Is prefix.
     LetNode* let_expr = PrepareCompoundAssignmentNodes(&expr);
     Token::Kind binary_op =
         (incr_op == Token::kINCR) ? Token::kADD : Token::kSUB;
-    BinaryOpNode* add = new BinaryOpNode(
+    BinaryOpNode* add = new(isolate()) BinaryOpNode(
         op_pos,
         binary_op,
         expr,
-        new LiteralNode(op_pos, Smi::ZoneHandle(Smi::New(1))));
+        new(isolate()) LiteralNode(op_pos, Smi::ZoneHandle(Smi::New(1))));
     AstNode* store = CreateAssignmentNode(expr, add, expr_ident, expr_pos);
     ASSERT(store != NULL);
     let_expr->AddNode(store);
     expr = let_expr;
   } else {
     expr = ParsePostfixExpr();
   }
   return expr;
 }
 
 
 ArgumentListNode* Parser::ParseActualParameters(
                               ArgumentListNode* implicit_arguments,
                               bool require_const) {
   TRACE_PARSER("ParseActualParameters");
   ASSERT(CurrentToken() == Token::kLPAREN);
   const bool saved_mode = SetAllowFunctionLiterals(true);
   ArgumentListNode* arguments;
   if (implicit_arguments == NULL) {
-    arguments = new ArgumentListNode(TokenPos());
+    arguments = new(isolate()) ArgumentListNode(TokenPos());
   } else {
     arguments = implicit_arguments;
   }
-  const GrowableObjectArray& names =
-      GrowableObjectArray::Handle(GrowableObjectArray::New(Heap::kOld));
+  const GrowableObjectArray& names = GrowableObjectArray::Handle(isolate(),
+      GrowableObjectArray::New(Heap::kOld));
   bool named_argument_seen = false;
   if (LookaheadToken(1) != Token::kRPAREN) {
-    String& arg_name = String::Handle();
+    String& arg_name = String::Handle(isolate());
     do {
       ASSERT((CurrentToken() == Token::kLPAREN) ||
              (CurrentToken() == Token::kCOMMA));
       ConsumeToken();
       if (IsIdentifier() && (LookaheadToken(1) == Token::kCOLON)) {
         named_argument_seen = true;
         // The canonicalization of the arguments descriptor array built in
         // the code generator requires that the names are symbols, i.e.
         // canonicalized strings.
         ASSERT(CurrentLiteral()->IsSymbol());
@@ skipping 10 matching lines @@
         ErrorMsg("named argument expected");
       }
       arguments->Add(ParseExpr(require_const, kConsumeCascades));
     } while (CurrentToken() == Token::kCOMMA);
   } else {
     ConsumeToken();
   }
   ExpectToken(Token::kRPAREN);
   SetAllowFunctionLiterals(saved_mode);
   if (named_argument_seen) {
-    arguments->set_names(Array::Handle(Array::MakeArray(names)));
+    arguments->set_names(Array::Handle(isolate(), Array::MakeArray(names)));
   }
   return arguments;
 }
 
 
 AstNode* Parser::ParseStaticCall(const Class& cls,
                                  const String& func_name,
                                  intptr_t ident_pos) {
   TRACE_PARSER("ParseStaticCall");
   const intptr_t call_pos = TokenPos();
@@ skipping 15 matching lines @@
       // No field, check if we have an explicit getter function.
       const String& getter_name =
           String::ZoneHandle(Field::GetterName(func_name));
       const int kNumArguments = 0;  // no arguments.
       func = Resolver::ResolveStatic(cls,
                                      getter_name,
                                      kNumArguments,
                                      Object::empty_array());
       if (!func.IsNull()) {
         ASSERT(func.kind() != RawFunction::kImplicitStaticFinalGetter);
-        closure = new StaticGetterNode(call_pos,
-                                       NULL,
-                                       false,
-                                       Class::ZoneHandle(cls.raw()),
-                                       func_name);
+        closure = new(isolate()) StaticGetterNode(call_pos,
+                                                  NULL,
+                                                  false,
+                                                  Class::ZoneHandle(cls.raw()),
+                                                  func_name);
         return BuildClosureCall(call_pos, closure, arguments);
       }
     } else {
       closure = GenerateStaticFieldLookup(field, call_pos);
       return BuildClosureCall(call_pos, closure, arguments);
     }
     // Could not resolve static method: throw a NoSuchMethodError.
     return ThrowNoSuchMethodError(ident_pos,
                                   cls,
                                   func_name,
                                   arguments,
                                   InvocationMirror::kStatic,
                                   InvocationMirror::kMethod,
                                   NULL);  // No existing function.
   } else if (cls.IsTopLevel() &&
       (cls.library() == Library::CoreLibrary()) &&
       (func.name() == Symbols::Identical().raw())) {
     // This is the predefined toplevel function identical(a,b). Create
     // a comparison node instead.
     ASSERT(num_arguments == 2);
-    return new ComparisonNode(ident_pos,
-                              Token::kEQ_STRICT,
-                              arguments->NodeAt(0),
-                              arguments->NodeAt(1));
+    return new(isolate()) ComparisonNode(ident_pos,
+                                         Token::kEQ_STRICT,
+                                         arguments->NodeAt(0),
+                                         arguments->NodeAt(1));
   }
-  return new StaticCallNode(call_pos, func, arguments);
+  return new(isolate()) StaticCallNode(call_pos, func, arguments);
 }
 
 
 AstNode* Parser::ParseInstanceCall(AstNode* receiver, const String& func_name) {
   TRACE_PARSER("ParseInstanceCall");
   const intptr_t call_pos = TokenPos();
   CheckToken(Token::kLPAREN);
   ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
-  return new InstanceCallNode(call_pos, receiver, func_name, arguments);
+  return new(isolate()) InstanceCallNode(
+      call_pos, receiver, func_name, arguments);
 }
 
 
 AstNode* Parser::ParseClosureCall(AstNode* closure) {
   TRACE_PARSER("ParseClosureCall");
   const intptr_t call_pos = TokenPos();
   ASSERT(CurrentToken() == Token::kLPAREN);
   ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
   return BuildClosureCall(call_pos, closure, arguments);
 }
 
 
 AstNode* Parser::GenerateStaticFieldLookup(const Field& field,
                                            intptr_t ident_pos) {
   // If the static field has an initializer, initialize the field at compile
   // time, which is only possible if the field is const.
   AstNode* initializing_getter = RunStaticFieldInitializer(field, ident_pos);
   if (initializing_getter != NULL) {
     // The field is not yet initialized and could not be initialized at compile
     // time. The getter will initialize the field.
     return initializing_getter;
   }
   // The field is initialized.
   ASSERT(field.is_static());
   const Class& field_owner = Class::ZoneHandle(field.owner());
   const String& field_name = String::ZoneHandle(field.name());
-  const String& getter_name = String::Handle(Field::GetterName(field_name));
-  const Function& getter =
-      Function::Handle(field_owner.LookupStaticFunction(getter_name));
+  const String& getter_name = String::Handle(isolate(),
+      Field::GetterName(field_name));
+  const Function& getter = Function::Handle(isolate(),
+      field_owner.LookupStaticFunction(getter_name));
   // Never load field directly if there is a getter (deterministic AST).
   if (getter.IsNull() || field.is_const()) {
-    return new LoadStaticFieldNode(ident_pos, Field::ZoneHandle(field.raw()));
+    return new(isolate()) LoadStaticFieldNode(
+        ident_pos, Field::ZoneHandle(field.raw()));
   } else {
     ASSERT(getter.kind() == RawFunction::kImplicitStaticFinalGetter);
-    return new StaticGetterNode(ident_pos,
-                                NULL,  // Receiver.
-                                false,  // is_super_getter.
-                                field_owner,
-                                field_name);
+    return new(isolate()) StaticGetterNode(ident_pos,
+                                           NULL,  // Receiver.
+                                           false,  // is_super_getter.
+                                           field_owner,
+                                           field_name);
   }
 }
 
 
 AstNode* Parser::ParseStaticFieldAccess(const Class& cls,
                                         const String& field_name,
                                         intptr_t ident_pos,
                                         bool consume_cascades) {
   TRACE_PARSER("ParseStaticFieldAccess");
   AstNode* access = NULL;
@@ skipping 13 matching lines @@
       // there is a function of the same name.
       func = cls.LookupStaticFunction(field_name);
       if (!func.IsNull()) {
         access = CreateImplicitClosureNode(func, ident_pos, NULL);
       } else {
         // No function to closurize found found.
         // This field access may turn out to be a call to the setter.
         // Create a getter call, which may later be turned into
         // a setter call, or else the backend will generate
         // a throw NoSuchMethodError().
-        access = new StaticGetterNode(ident_pos,
-                                      NULL,
-                                      false,
-                                      Class::ZoneHandle(cls.raw()),
-                                      field_name);
+        access = new(isolate()) StaticGetterNode(
+            ident_pos, NULL, false, Class::ZoneHandle(cls.raw()), field_name);
       }
     } else {
       ASSERT(func.kind() != RawFunction::kImplicitStaticFinalGetter);
-      access = new StaticGetterNode(ident_pos,
-                                    NULL,
-                                    false,
-                                    Class::ZoneHandle(cls.raw()),
-                                    field_name);
+      access = new(isolate()) StaticGetterNode(
+          ident_pos, NULL, false, Class::ZoneHandle(cls.raw()), field_name);
     }
   } else {
     access = GenerateStaticFieldLookup(field, ident_pos);
   }
   return access;
 }
 
 
 AstNode* Parser::LoadFieldIfUnresolved(AstNode* node) {
   if (!node->IsPrimaryNode()) {
@@ skipping 11 matching lines @@
     // In metadata, an unresolved identifier cannot be a compile-time constant.
     String& name = String::CheckedZoneHandle(primary->primary().raw());
     if (parsing_metadata_) {
       ErrorMsg(primary->token_pos(),
                "unresolved identifier '%s' is not a compile-time constant",
                name.ToCString());
     }
     if (current_function().is_static() ||
         current_function().IsInFactoryScope()) {
       StaticGetterNode* getter =
-          new StaticGetterNode(primary->token_pos(),
-                               NULL,  // No receiver.
-                               false,  // Not a super getter.
-                               Class::ZoneHandle(current_class().raw()),
-                               name);
+          new(isolate()) StaticGetterNode(
+              primary->token_pos(),
+              NULL,  // No receiver.
+              false,  // Not a super getter.
+              Class::ZoneHandle(current_class().raw()),
+              name);
       getter->set_is_deferred(primary->is_deferred_reference());
       return getter;
     } else {
       AstNode* receiver = LoadReceiver(primary->token_pos());
       return CallGetter(node->token_pos(), receiver, name);
     }
   }
   return primary;
 }
 
@@ skipping 52 matching lines @@
           if (current_block_->scope->function_level() > 0) {
             // Make sure that the instantiator is captured.
             CaptureInstantiator();
           }
           TypeParameter& type_parameter = TypeParameter::ZoneHandle();
           type_parameter ^= ClassFinalizer::FinalizeType(
               current_class(),
               TypeParameter::Cast(primary_node->primary()),
               ClassFinalizer::kCanonicalize);
           ASSERT(!type_parameter.IsMalformed());
-          left = new TypeNode(primary->token_pos(), type_parameter);
+          left = new(isolate()) TypeNode(primary->token_pos(), type_parameter);
         } else {
           // Super field access handled in ParseSuperFieldAccess(),
           // super calls handled in ParseSuperCall().
           ASSERT(!primary_node->IsSuper());
           left = LoadFieldIfUnresolved(left);
         }
       }
       const intptr_t ident_pos = TokenPos();
       String* ident = ExpectIdentifier("identifier expected");
       if (CurrentToken() == Token::kLPAREN) {
         // Identifier followed by a opening paren: method call.
         if (left->IsPrimaryNode() &&
             left->AsPrimaryNode()->primary().IsClass()) {
           // Static method call prefixed with class name.
           const Class& cls = Class::Cast(left->AsPrimaryNode()->primary());
           selector = ParseStaticCall(cls, *ident, ident_pos);
         } else {
           selector = ParseInstanceCall(left, *ident);
         }
       } else {
         // Field access.
-        Class& cls = Class::Handle();
+        Class& cls = Class::Handle(isolate());
         if (left->IsPrimaryNode()) {
           PrimaryNode* primary_node = left->AsPrimaryNode();
           if (primary_node->primary().IsClass()) {
             // If the primary node referred to a class we are loading a
             // qualified static field.
             cls ^= primary_node->primary().raw();
           }
         }
         if (cls.IsNull()) {
           // Instance field access.
@@ skipping 17 matching lines @@
       ExpectToken(Token::kRBRACK);
       AstNode* array = left;
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary_node = left->AsPrimaryNode();
         const intptr_t primary_pos = primary_node->token_pos();
         if (primary_node->primary().IsFunction()) {
           array = LoadClosure(primary_node);
         } else if (primary_node->primary().IsClass()) {
           const Class& type_class = Class::Cast(primary_node->primary());
           AbstractType& type = Type::ZoneHandle(
-              Type::New(type_class, TypeArguments::Handle(),
+              Type::New(type_class, TypeArguments::Handle(isolate()),
                         primary_pos, Heap::kOld));
           type ^= ClassFinalizer::FinalizeType(
               current_class(), type, ClassFinalizer::kCanonicalize);
           // Type may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
-          array = new TypeNode(primary_pos, type);
+          array = new(isolate()) TypeNode(primary_pos, type);
         } else if (primary_node->primary().IsTypeParameter()) {
           if (current_function().is_static()) {
             const String& name = String::ZoneHandle(
                 TypeParameter::Cast(primary_node->primary()).name());
             ErrorMsg(primary_pos,
                      "cannot access type parameter '%s' from static function",
                      name.ToCString());
           }
           if (current_block_->scope->function_level() > 0) {
             // Make sure that the instantiator is captured.
             CaptureInstantiator();
           }
           TypeParameter& type_parameter = TypeParameter::ZoneHandle();
           type_parameter ^= ClassFinalizer::FinalizeType(
               current_class(),
               TypeParameter::Cast(primary_node->primary()),
               ClassFinalizer::kCanonicalize);
           ASSERT(!type_parameter.IsMalformed());
-          array = new TypeNode(primary_pos, type_parameter);
+          array = new(isolate()) TypeNode(primary_pos, type_parameter);
         } else {
           UNREACHABLE();  // Internal parser error.
         }
       }
-      selector =  new LoadIndexedNode(bracket_pos,
-                                      array,
-                                      index,
-                                      Class::ZoneHandle());
+      selector =  new(isolate()) LoadIndexedNode(
+          bracket_pos, array, index, Class::ZoneHandle());
     } else if (CurrentToken() == Token::kLPAREN) {
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary_node = left->AsPrimaryNode();
         const intptr_t primary_pos = primary_node->token_pos();
         if (primary_node->primary().IsFunction()) {
           const Function& func = Function::Cast(primary_node->primary());
           const String& func_name = String::ZoneHandle(func.name());
           if (func.is_static()) {
             // Parse static function call.
-            Class& cls = Class::Handle(func.Owner());
+            Class& cls = Class::Handle(isolate(), func.Owner());
             selector = ParseStaticCall(cls, func_name, primary_pos);
           } else {
             // Dynamic function call on implicit "this" parameter.
             if (current_function().is_static()) {
               ErrorMsg(primary_pos,
                        "cannot access instance method '%s' "
                        "from static function",
                        func_name.ToCString());
             }
             selector = ParseInstanceCall(LoadReceiver(primary_pos), func_name);
@@ skipping 25 matching lines @@
             ErrorMsg(primary_pos,
                      "cannot access type parameter '%s' from static function",
                      name.ToCString());
           } else {
             // Treat as call to unresolved (instance) method.
             selector = ParseInstanceCall(LoadReceiver(primary_pos), name);
           }
         } else if (primary_node->primary().IsClass()) {
           const Class& type_class = Class::Cast(primary_node->primary());
           AbstractType& type = Type::ZoneHandle(Type::New(
-              type_class, TypeArguments::Handle(), primary_pos));
+              type_class, TypeArguments::Handle(isolate()), primary_pos));
           type ^= ClassFinalizer::FinalizeType(
               current_class(), type, ClassFinalizer::kCanonicalize);
           // Type may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
-          selector = new TypeNode(primary_pos, type);
+          selector = new(isolate()) TypeNode(primary_pos, type);
         } else {
           UNREACHABLE();  // Internal parser error.
         }
       } else {
         // Left is not a primary node; this must be a closure call.
         AstNode* closure = left;
         if (parsing_metadata_) {
             // Compiling closure calls involves saving the current context based
             // on the current function, and metadata has no current function.
             // Fail early rather than limping along only to discover later that
             // we parsed something that isn't a compile-time constant.
             ErrorMsg(closure->token_pos(),
               "expression is not a valid compile-time constant");
         }
         selector = ParseClosureCall(closure);
       }
     } else {
       // No (more) selectors to parse.
       left = LoadFieldIfUnresolved(left);
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary_node = left->AsPrimaryNode();
         const intptr_t primary_pos = primary->token_pos();
         if (primary_node->primary().IsFunction()) {
           // Treat as implicit closure.
           left = LoadClosure(primary_node);
         } else if (primary_node->primary().IsClass()) {
           const Class& type_class = Class::Cast(primary_node->primary());
           AbstractType& type = Type::ZoneHandle(Type::New(
-              type_class, TypeArguments::Handle(), primary_pos));
+              type_class, TypeArguments::Handle(isolate()), primary_pos));
           type = ClassFinalizer::FinalizeType(
               current_class(), type, ClassFinalizer::kCanonicalize);
           // Type may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
-          left = new TypeNode(primary_pos, type);
+          left = new(isolate()) TypeNode(primary_pos, type);
         } else if (primary_node->primary().IsTypeParameter()) {
           if (current_function().is_static()) {
             const String& name = String::ZoneHandle(
                 TypeParameter::Cast(primary_node->primary()).name());
             ErrorMsg(primary_pos,
                      "cannot access type parameter '%s' from static function",
                      name.ToCString());
           }
           if (current_block_->scope->function_level() > 0) {
             // Make sure that the instantiator is captured.
             CaptureInstantiator();
           }
           TypeParameter& type_parameter = TypeParameter::ZoneHandle();
           type_parameter ^= ClassFinalizer::FinalizeType(
               current_class(),
               TypeParameter::Cast(primary_node->primary()),
               ClassFinalizer::kCanonicalize);
           ASSERT(!type_parameter.IsMalformed());
-          left = new TypeNode(primary_pos, type_parameter);
+          left = new(isolate()) TypeNode(primary_pos, type_parameter);
         } else if (primary_node->IsSuper()) {
           // Return "super" to handle unary super operator calls,
           // or to report illegal use of "super" otherwise.
           left = primary_node;
         } else {
           UNREACHABLE();  // Internal parser error.
         }
       }
       // Done parsing selectors.
       return left;
@@ skipping 16 matching lines @@
     if (!IsLegalAssignableSyntax(expr, TokenPos())) {
       ErrorMsg(expr_pos, "expression is not assignable");
     }
     Token::Kind incr_op = CurrentToken();
     ConsumeToken();
     // Not prefix.
     LetNode* let_expr = PrepareCompoundAssignmentNodes(&expr);
     LocalVariable* temp = let_expr->AddInitializer(expr);
     Token::Kind binary_op =
         (incr_op == Token::kINCR) ? Token::kADD : Token::kSUB;
-    BinaryOpNode* add = new BinaryOpNode(
+    BinaryOpNode* add = new(isolate()) BinaryOpNode(
         expr_pos,
         binary_op,
-        new LoadLocalNode(expr_pos, temp),
-        new LiteralNode(expr_pos, Smi::ZoneHandle(Smi::New(1))));
+        new(isolate()) LoadLocalNode(expr_pos, temp),
+        new(isolate()) LiteralNode(expr_pos, Smi::ZoneHandle(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 LoadLocalNode(expr_pos, temp));
+    let_expr->AddNode(new(isolate()) LoadLocalNode(expr_pos, temp));
     return let_expr;
   }
   return expr;
 }
 
 
 // Resolve the given type and its type arguments from the given scope class
 // according to the given type finalization mode.
 // If the given scope class is null, use the current library, but do not try to
 // resolve type parameters.
@@ skipping 161 matching lines @@
 }
 
 
 RawInstance* Parser::TryCanonicalize(const Instance& instance,
                                      intptr_t token_pos) {
   if (instance.IsNull()) {
     return instance.raw();
   }
   const char* error_str = NULL;
   Instance& result =
-      Instance::Handle(instance.CheckAndCanonicalize(&error_str));
+      Instance::Handle(isolate(), instance.CheckAndCanonicalize(&error_str));
   if (result.IsNull()) {
     ErrorMsg(token_pos, "Invalid const object %s", error_str);
   }
   return result.raw();
 }
 
 
 // If the field is already initialized, return no ast (NULL).
 // Otherwise, if the field is constant, initialize the field and return no ast.
 // If the field is not initialized and not const, return the ast for the getter.
 AstNode* Parser::RunStaticFieldInitializer(const Field& field,
                                            intptr_t field_ref_pos) {
   ASSERT(field.is_static());
   const Class& field_owner = Class::ZoneHandle(isolate(), field.owner());
   const String& field_name = String::ZoneHandle(isolate(), field.name());
   const String& getter_name = String::Handle(isolate(),
                                              Field::GetterName(field_name));
   const Function& getter = Function::Handle(
       isolate(), field_owner.LookupStaticFunction(getter_name));
   const Instance& value = Instance::Handle(isolate(), field.value());
   if (value.raw() == Object::transition_sentinel().raw()) {
     if (field.is_const()) {
       ErrorMsg("circular dependency while initializing static field '%s'",
                field_name.ToCString());
     } else {
       // The implicit static getter will throw the exception if necessary.
-      return new StaticGetterNode(field_ref_pos,
-                                  NULL,
-                                  false,
-                                  field_owner,
-                                  field_name);
+      return new(isolate()) StaticGetterNode(
+          field_ref_pos, NULL, false, field_owner, field_name);
     }
   } else if (value.raw() == Object::sentinel().raw()) {
     // This field has not been referenced yet and thus the value has
     // not been evaluated. If the field is const, call the static getter method
     // to evaluate the expression and canonicalize the value.
     if (field.is_const()) {
       field.set_value(Object::transition_sentinel());
       const int kNumArguments = 0;  // no arguments.
-      const Function& func = Function::Handle(
-          isolate(), Resolver::ResolveStatic(field_owner,
-                                             getter_name,
-                                             kNumArguments,
-                                             Object::empty_array()));
+      const Function& func = Function::Handle(isolate(),
+          Resolver::ResolveStatic(field_owner,
+                                  getter_name,
+                                  kNumArguments,
+                                  Object::empty_array()));
       ASSERT(!func.IsNull());
       ASSERT(func.kind() == RawFunction::kImplicitStaticFinalGetter);
       Object& const_value = Object::Handle(isolate());
       {
         PAUSETIMERSCOPE(isolate(), time_compilation);
         const_value = DartEntry::InvokeFunction(func, Object::empty_array());
       }
       if (const_value.IsError()) {
         const Error& error = Error::Cast(const_value);
         if (error.IsUnhandledException()) {
           // An exception may not occur in every parse attempt, i.e., the
           // generated AST is not deterministic. Therefore mark the function as
           // not optimizable.
           current_function().SetIsOptimizable(false);
           field.set_value(Object::null_instance());
           // It is a compile-time error if evaluation of a compile-time constant
           // would raise an exception.
           AppendErrorMsg(error, field_ref_pos,
                          "error initializing const field '%s'",
-                         String::Handle(field.name()).ToCString());
+                         String::Handle(isolate(), field.name()).ToCString());
         } else {
           isolate()->long_jump_base()->Jump(1, error);
           UNREACHABLE();
         }
       }
       ASSERT(const_value.IsNull() || const_value.IsInstance());
-      Instance& instance = Instance::Handle();
+      Instance& instance = Instance::Handle(isolate());
       instance ^= const_value.raw();
       instance = TryCanonicalize(instance, field_ref_pos);
       field.set_value(instance);
       return NULL;   // Constant
     } else {
-      return new StaticGetterNode(field_ref_pos,
-                                  NULL,
-                                  false,
-                                  field_owner,
-                                  field_name);
+      return new(isolate()) StaticGetterNode(
+          field_ref_pos, NULL, false, field_owner, field_name);
     }
   }
   if (getter.IsNull() ||
       (getter.kind() == RawFunction::kImplicitStaticFinalGetter)) {
     return NULL;
   }
   ASSERT(getter.kind() == RawFunction::kImplicitGetter);
-  return new StaticGetterNode(field_ref_pos,
-                              NULL,
-                              false,
-                              field_owner,
-                              field_name);
+  return new(isolate()) StaticGetterNode(
+      field_ref_pos, NULL, false, field_owner, field_name);
 }
 
 
 RawObject* Parser::EvaluateConstConstructorCall(
     const Class& type_class,
     const TypeArguments& type_arguments,
     const Function& constructor,
     ArgumentListNode* arguments) {
   // Factories have one extra argument: the type arguments.
   // 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(isolate(),
                                           Array::New(num_arguments));
   Instance& instance = Instance::Handle(isolate());
   if (!constructor.IsFactory()) {
     instance = Instance::New(type_class, Heap::kOld);
     if (!type_arguments.IsNull()) {
       if (!type_arguments.IsInstantiated()) {
         ErrorMsg("type must be constant in const constructor");
       }
       instance.SetTypeArguments(
-          TypeArguments::Handle(type_arguments.Canonicalize()));
+          TypeArguments::Handle(isolate(), type_arguments.Canonicalize()));
     }
     arg_values.SetAt(0, instance);
-    arg_values.SetAt(1, Smi::Handle(Smi::New(Function::kCtorPhaseAll)));
+    arg_values.SetAt(1, Smi::Handle(isolate(),
+                                    Smi::New(Function::kCtorPhaseAll)));
   } else {
     // Prepend type_arguments to list of arguments to factory.
     ASSERT(type_arguments.IsZoneHandle());
     arg_values.SetAt(0, type_arguments);
   }
   for (int i = 0; i < arguments->length(); i++) {
     AstNode* arg = arguments->NodeAt(i);
     // Arguments have been evaluated to a literal value already.
     ASSERT(arg->IsLiteralNode());
     arg_values.SetAt((i + kNumExtraArgs), arg->AsLiteralNode()->literal());
@@ skipping 38 matching lines @@
                                       const String &ident,
                                       AstNode** node) {
   TRACE_PARSER("ResolveIdentInLocalScope");
   // First try to find the identifier in the nested local scopes.
   LocalVariable* local = LookupLocalScope(ident);
   if (current_block_ != NULL) {
     current_block_->scope->AddReferencedName(ident_pos, ident);
   }
   if (local != NULL) {
     if (node != NULL) {
-      *node = new LoadLocalNode(ident_pos, local);
+      *node = new(isolate()) LoadLocalNode(ident_pos, local);
     }
     return true;
   }
 
   // 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(isolate());
   if (!current_class().IsMixinApplication()) {
     cls = current_class().raw();
@@ skipping 17 matching lines @@
     return true;
   }
 
   // Check if an instance/static function exists.
   func = cls.LookupFunction(ident);
   if (!func.IsNull() &&
       (func.IsDynamicFunction() ||
       func.IsStaticFunction() ||
       func.is_abstract())) {
     if (node != NULL) {
-      *node = new PrimaryNode(ident_pos,
-                              Function::ZoneHandle(isolate(), func.raw()));
+      *node = new(isolate()) PrimaryNode(
+          ident_pos, Function::ZoneHandle(isolate(), func.raw()));
     }
     return true;
   }
 
   // Now check if a getter/setter method exists for it in which case
   // it is still a field.
   func = cls.LookupGetterFunction(ident);
   if (!func.IsNull()) {
     if (func.IsDynamicFunction() || func.is_abstract()) {
       if (node != NULL) {
         CheckInstanceFieldAccess(ident_pos, ident);
-        ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
+        ASSERT(AbstractType::Handle(isolate(),
+                                    func.result_type()).IsResolved());
         *node = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
       }
       return true;
     } else if (func.IsStaticFunction()) {
       if (node != NULL) {
-        ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
+        ASSERT(AbstractType::Handle(isolate(),
+                                    func.result_type()).IsResolved());
         // The static getter may later be changed into a dynamically
         // resolved instance setter if no static setter can
         // be found.
         AstNode* receiver = NULL;
         const bool kTestOnly = true;
         if (parsing_metadata_) {
           ErrorMsg(ident_pos,
                    "'%s' is not a compile-time constant",
                    ident.ToCString());
         }
         if (!current_function().is_static() &&
             (LookupReceiver(current_block_->scope, kTestOnly) != NULL)) {
           receiver = LoadReceiver(ident_pos);
         }
-        *node = new StaticGetterNode(ident_pos,
+        *node = new(isolate()) StaticGetterNode(ident_pos,
                                      receiver,
                                      false,
                                      Class::ZoneHandle(isolate(), cls.raw()),
                                      ident);
       }
       return true;
     }
   }
   func = cls.LookupSetterFunction(ident);
   if (!func.IsNull()) {
     if (func.IsDynamicFunction() || func.is_abstract()) {
       if (node != NULL) {
         // We create a getter node even though a getter doesn't exist as
         // it could be followed by an assignment which will convert it to
         // a setter node. If there is no assignment we will get an error
         // when we try to invoke the getter.
         CheckInstanceFieldAccess(ident_pos, ident);
-        ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
+        ASSERT(AbstractType::Handle(isolate(),
+                                    func.result_type()).IsResolved());
         *node = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
       }
       return true;
     } else if (func.IsStaticFunction()) {
       if (node != NULL) {
         // We create a getter node even though a getter doesn't exist as
         // it could be followed by an assignment which will convert it to
         // a setter node. If there is no assignment we will get an error
         // when we try to invoke the getter.
-        *node = new StaticGetterNode(ident_pos,
-                                     NULL,
-                                     false,
-                                     Class::ZoneHandle(isolate(), cls.raw()),
-                                     ident);
+        *node = new(isolate()) StaticGetterNode(
+            ident_pos,
+            NULL,
+            false,
+            Class::ZoneHandle(isolate(), cls.raw()),
+            ident);
       }
       return true;
     }
   }
 
   // Nothing found in scope of current class.
   if (node != NULL) {
     *node = NULL;
   }
   return false;  // Not an unqualified identifier.
 }
 
 
 RawClass* Parser::ResolveClassInCurrentLibraryScope(const String& name) {
   HANDLESCOPE(isolate());
-  const Object& obj = Object::Handle(library_.ResolveName(name));
+  const Object& obj = Object::Handle(isolate(), library_.ResolveName(name));
   if (obj.IsClass()) {
     return Class::Cast(obj).raw();
   }
   return Class::null();
 }
 
 
 // Resolve an identifier by checking the global scope of the current
 // library. If not found in the current library, then look in the scopes
 // of all libraries that are imported without a library prefix.
 AstNode* Parser::ResolveIdentInCurrentLibraryScope(intptr_t ident_pos,
                                                    const String& ident) {
   TRACE_PARSER("ResolveIdentInCurrentLibraryScope");
   HANDLESCOPE(isolate());
-  const Object& obj = Object::Handle(library_.ResolveName(ident));
+  const Object& obj = Object::Handle(isolate(), library_.ResolveName(ident));
   if (obj.IsClass()) {
     const Class& cls = Class::Cast(obj);
-    return new PrimaryNode(ident_pos, Class::ZoneHandle(cls.raw()));
+    return new(isolate()) PrimaryNode(ident_pos, Class::ZoneHandle(cls.raw()));
   } else if (obj.IsField()) {
     const Field& field = Field::Cast(obj);
     ASSERT(field.is_static());
     return GenerateStaticFieldLookup(field, ident_pos);
   } else if (obj.IsFunction()) {
     const Function& func = Function::Cast(obj);
     ASSERT(func.is_static());
     if (func.IsGetterFunction() || func.IsSetterFunction()) {
-      return new StaticGetterNode(ident_pos,
-                                  /* receiver */ NULL,
-                                  /* is_super_getter */ false,
-                                  Class::ZoneHandle(func.Owner()),
-                                  ident);
+      return new(isolate()) StaticGetterNode(ident_pos,
+                                             /* receiver */ NULL,
+                                             /* is_super_getter */ false,
+                                             Class::ZoneHandle(func.Owner()),
+                                             ident);
 
     } else {
-      return new PrimaryNode(ident_pos, Function::ZoneHandle(func.raw()));
+      return new(isolate()) PrimaryNode(ident_pos,
+                                        Function::ZoneHandle(func.raw()));
     }
   } else {
     ASSERT(obj.IsNull() || obj.IsLibraryPrefix());
   }
   // Lexically unresolved primary identifiers are referenced by their name.
-  return new PrimaryNode(ident_pos, ident);
+  return new(isolate()) PrimaryNode(ident_pos, ident);
 }
 
 
 RawClass* Parser::ResolveClassInPrefixScope(const LibraryPrefix& prefix,
                                             const String& name) {
   HANDLESCOPE(isolate());
-  const Object& obj = Object::Handle(prefix.LookupObject(name));
+  const Object& obj = Object::Handle(isolate(), prefix.LookupObject(name));
   if (obj.IsClass()) {
     return Class::Cast(obj).raw();
   }
   return Class::null();
 }
 
 
 // Do a lookup for the identifier in the scope of the specified
 // library prefix. This means trying to resolve it locally in all of the
 // libraries present in the library prefix.
 AstNode* Parser::ResolveIdentInPrefixScope(intptr_t ident_pos,
                                            const LibraryPrefix& prefix,
                                            const String& ident) {
   TRACE_PARSER("ResolveIdentInPrefixScope");
   HANDLESCOPE(isolate());
-  Object& obj = Object::Handle();
+  Object& obj = Object::Handle(isolate());
   if (prefix.is_loaded()) {
     obj = prefix.LookupObject(ident);
   } else {
     // Remember that this function depends on an import prefix of an
     // unloaded deferred library. Note that parsed_function() can be
     // NULL when parsing expressions outside the scope of a function.
     if (parsed_function() != NULL) {
       parsed_function()->AddDeferredPrefix(prefix);
     }
   }
   const bool is_deferred = prefix.is_deferred_load();
   if (obj.IsNull()) {
     // Unresolved prefixed primary identifier.
     return NULL;
   } else if (obj.IsClass()) {
     const Class& cls = Class::Cast(obj);
     PrimaryNode* primary =
-        new PrimaryNode(ident_pos, Class::ZoneHandle(cls.raw()));
+        new(isolate()) PrimaryNode(ident_pos, Class::ZoneHandle(cls.raw()));
     primary->set_is_deferred(is_deferred);
     return primary;
   } else if (obj.IsField()) {
     const Field& field = Field::Cast(obj);
     ASSERT(field.is_static());
     AstNode* get_field = GenerateStaticFieldLookup(field, ident_pos);
     ASSERT(get_field != NULL);
     ASSERT(get_field->IsLoadStaticFieldNode() ||
            get_field->IsStaticGetterNode());
     if (get_field->IsLoadStaticFieldNode()) {
       get_field->AsLoadStaticFieldNode()->set_is_deferred(is_deferred);
     } else if (get_field->IsStaticGetterNode()) {
       get_field->AsStaticGetterNode()->set_is_deferred(is_deferred);
     }
     return get_field;
   } else if (obj.IsFunction()) {
     const Function& func = Function::Cast(obj);
     ASSERT(func.is_static());
     if (func.IsGetterFunction() || func.IsSetterFunction()) {
       StaticGetterNode* getter =
-          new StaticGetterNode(ident_pos,
+          new(isolate()) StaticGetterNode(ident_pos,
                                /* receiver */ NULL,
                                /* is_super_getter */ false,
-                               Class::ZoneHandle(func.Owner()),
+                               Class::ZoneHandle(isolate(), func.Owner()),
                                ident);
       getter->set_is_deferred(is_deferred);
       return getter;
     } else {
-      PrimaryNode* primary =
-          new PrimaryNode(ident_pos, Function::ZoneHandle(func.raw()));
+      PrimaryNode* primary = new(isolate()) PrimaryNode(
+           ident_pos, Function::ZoneHandle(isolate(), func.raw()));
       primary->set_is_deferred(is_deferred);
       return primary;
     }
   }
   // All possible object types are handled above.
   UNREACHABLE();
   return NULL;
 }
 
 
@@ skipping 16 matching lines @@
       TypeParameter& type_parameter = TypeParameter::ZoneHandle(
           current_class().LookupTypeParameter(ident));
       if (!type_parameter.IsNull()) {
         if (current_block_->scope->function_level() > 0) {
           // Make sure that the instantiator is captured.
           CaptureInstantiator();
         }
         type_parameter ^= ClassFinalizer::FinalizeType(
             current_class(), type_parameter, ClassFinalizer::kCanonicalize);
         ASSERT(!type_parameter.IsMalformed());
-        return new TypeNode(ident_pos, type_parameter);
+        return new(isolate()) TypeNode(ident_pos, type_parameter);
       }
     }
     // Not found in the local scope, and the name is not a type parameter.
     // Try finding the variable in the library scope (current library
     // and all libraries imported by it without a library prefix).
     resolved = ResolveIdentInCurrentLibraryScope(ident_pos, ident);
   }
   if (resolved->IsPrimaryNode()) {
     PrimaryNode* primary = resolved->AsPrimaryNode();
     const intptr_t primary_pos = primary->token_pos();
@@ skipping 18 matching lines @@
     } else if (primary->primary().IsFunction()) {
       if (allow_closure_names) {
         resolved = LoadClosure(primary);
       } else {
         ErrorMsg(ident_pos, "illegal reference to method '%s'",
                  ident.ToCString());
       }
     } else if (primary->primary().IsClass()) {
       const Class& type_class = Class::Cast(primary->primary());
       AbstractType& type = Type::ZoneHandle(
-          Type::New(type_class, TypeArguments::Handle(), primary_pos));
+          Type::New(type_class, TypeArguments::Handle(isolate()), primary_pos));
       type ^= ClassFinalizer::FinalizeType(
           current_class(), type, ClassFinalizer::kCanonicalize);
       // Type may be malbounded, but not malformed.
       ASSERT(!type.IsMalformed());
-      resolved = new TypeNode(primary_pos, type);
+      resolved = new(isolate()) TypeNode(primary_pos, type);
     }
   }
   return resolved;
 }
 
 
 // Parses type = [ident "."] ident ["<" type { "," type } ">"], then resolve and
 // finalize it according to the given type finalization mode.
 RawAbstractType* Parser::ParseType(
     ClassFinalizer::FinalizationKind finalization,
@@ skipping 10 matching lines @@
     SkipQualIdent();
   } else {
     ParseQualIdent(&type_name);
     // An identifier cannot be resolved in a local scope when top level parsing.
     if (!is_top_level_ &&
         (type_name.lib_prefix == NULL) &&
         ResolveIdentInLocalScope(type_name.ident_pos, *type_name.ident, NULL)) {
       // The type is malformed. Skip over its type arguments.
       ParseTypeArguments(ClassFinalizer::kIgnore);
       return ClassFinalizer::NewFinalizedMalformedType(
-          Error::Handle(),  // No previous error.
+          Error::Handle(isolate()),  // No previous error.
           script_,
           type_name.ident_pos,
           "using '%s' in this context is invalid",
           type_name.ident->ToCString());
     }
     if ((type_name.lib_prefix != NULL) &&
         type_name.lib_prefix->is_deferred_load() &&
         !allow_deferred_type) {
       ParseTypeArguments(ClassFinalizer::kIgnore);
       return ClassFinalizer::NewFinalizedMalformedType(
-          Error::Handle(),  // No previous error.
+          Error::Handle(isolate()),  // No previous error.
           script_,
           type_name.ident_pos,
           "using deferred type '%s.%s' is invalid",
-          String::Handle(type_name.lib_prefix->name()).ToCString(),
+          String::Handle(isolate(), type_name.lib_prefix->name()).ToCString(),
           type_name.ident->ToCString());
     }
   }
   Object& type_class = Object::Handle(isolate());
   // Leave type_class as null if type finalization mode is kIgnore.
   if (finalization != ClassFinalizer::kIgnore) {
     LibraryPrefix& lib_prefix = LibraryPrefix::Handle(isolate());
     if (type_name.lib_prefix != NULL) {
       lib_prefix = type_name.lib_prefix->raw();
     }
@@ skipping 15 matching lines @@
     }
   }
   return type.raw();
 }
 
 
 void Parser::CheckConstructorCallTypeArguments(
     intptr_t pos, const Function& constructor,
     const TypeArguments& type_arguments) {
   if (!type_arguments.IsNull()) {
-    const Class& constructor_class = Class::Handle(constructor.Owner());
+    const Class& constructor_class = Class::Handle(isolate(),
+                                                   constructor.Owner());
     ASSERT(!constructor_class.IsNull());
     ASSERT(constructor_class.is_finalized());
     ASSERT(type_arguments.IsCanonical());
     // Do not report the expected vs. actual number of type arguments, because
     // the type argument vector is flattened and raw types are allowed.
     if (type_arguments.Length() != constructor_class.NumTypeArguments()) {
       ErrorMsg(pos, "wrong number of type arguments passed to constructor");
     }
   }
 }
@@ skipping 36 matching lines @@
       if (FLAG_error_on_bad_type) {
         ErrorMsg(type_pos,
                  "a list literal takes one type argument specifying "
                  "the element type");
       }
       // Ignore type arguments.
       list_type_arguments = TypeArguments::null();
     }
   }
   ASSERT(list_type_arguments.IsNull() || (list_type_arguments.Length() == 1));
-  const Class& array_class = Class::Handle(
+  const Class& array_class = Class::Handle(isolate(),
       isolate()->object_store()->array_class());
   Type& type = Type::ZoneHandle(
       Type::New(array_class, list_type_arguments, type_pos));
   type ^= ClassFinalizer::FinalizeType(
       current_class(), type, ClassFinalizer::kCanonicalize);
   GrowableArray<AstNode*> element_list;
   // Parse the list elements. Note: there may be an optional extra
   // comma after the last element.
   if (!is_empty_literal) {
     const bool saved_mode = SetAllowFunctionLiterals(true);
     while (CurrentToken() != Token::kRBRACK) {
       const intptr_t element_pos = TokenPos();
       AstNode* element = ParseExpr(is_const, kConsumeCascades);
       if (FLAG_enable_type_checks &&
           !is_const &&
           !element_type.IsDynamicType()) {
-        element = new AssignableNode(element_pos,
-                                     element,
-                                     element_type,
-                                     Symbols::ListLiteralElement());
+        element = new(isolate()) AssignableNode(element_pos,
+                                                element,
+                                                element_type,
+                                                Symbols::ListLiteralElement());
       }
       element_list.Add(element);
       if (CurrentToken() == Token::kCOMMA) {
         ConsumeToken();
       } else if (CurrentToken() != Token::kRBRACK) {
         ErrorMsg("comma or ']' expected");
       }
     }
     ExpectToken(Token::kRBRACK);
     SetAllowFunctionLiterals(saved_mode);
   }
 
   if (is_const) {
     // Allocate and initialize the const list at compile time.
     Array& const_list =
         Array::ZoneHandle(Array::New(element_list.length(), Heap::kOld));
     const_list.SetTypeArguments(
-        TypeArguments::Handle(list_type_arguments.Canonicalize()));
-    Error& malformed_error = Error::Handle();
+        TypeArguments::Handle(isolate(), list_type_arguments.Canonicalize()));
+    Error& malformed_error = Error::Handle(isolate());
     for (int i = 0; i < element_list.length(); i++) {
       AstNode* elem = element_list[i];
       // Arguments have been evaluated to a literal value already.
       ASSERT(elem->IsLiteralNode());
       ASSERT(!is_top_level_);  // We cannot check unresolved types.
       if (FLAG_enable_type_checks &&
           !element_type.IsDynamicType() &&
           (!elem->AsLiteralNode()->literal().IsNull() &&
            !elem->AsLiteralNode()->literal().IsInstanceOf(
-               element_type, TypeArguments::Handle(), &malformed_error))) {
+               element_type,
+               TypeArguments::Handle(isolate()),
+               &malformed_error))) {
         // If the failure is due to a malformed type error, display it instead.
         if (!malformed_error.IsNull()) {
           ErrorMsg(malformed_error);
         } else {
           ErrorMsg(elem->AsLiteralNode()->token_pos(),
                    "list literal element at index %d must be "
                    "a constant of type '%s'",
                    i,
-                   String::Handle(element_type.UserVisibleName()).ToCString());
+                   String::Handle(isolate(),
+                       element_type.UserVisibleName()).ToCString());
         }
       }
       const_list.SetAt(i, elem->AsLiteralNode()->literal());
     }
     const_list ^= TryCanonicalize(const_list, literal_pos);
     const_list.MakeImmutable();
-    return new LiteralNode(literal_pos, const_list);
+    return new(isolate()) LiteralNode(literal_pos, const_list);
   } else {
     // Factory call at runtime.
     const Class& factory_class =
-        Class::Handle(Library::LookupCoreClass(Symbols::List()));
+        Class::Handle(isolate(), Library::LookupCoreClass(Symbols::List()));
     ASSERT(!factory_class.IsNull());
     const Function& factory_method = Function::ZoneHandle(
         factory_class.LookupFactory(
             Library::PrivateCoreLibName(Symbols::ListLiteralFactory())));
     ASSERT(!factory_method.IsNull());
     if (!list_type_arguments.IsNull() &&
         !list_type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureInstantiator();
     }
     TypeArguments& factory_type_args =
         TypeArguments::ZoneHandle(list_type_arguments.raw());
     // 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(Type::New(
+      Type& factory_type = Type::Handle(isolate(), Type::New(
           factory_class, factory_type_args, type_pos, Heap::kNew));
       factory_type ^= ClassFinalizer::FinalizeType(
           current_class(), factory_type, ClassFinalizer::kFinalize);
       factory_type_args = factory_type.arguments();
       ASSERT(factory_type_args.Length() == factory_class.NumTypeArguments());
     }
     factory_type_args = factory_type_args.Canonicalize();
-    ArgumentListNode* factory_param = new ArgumentListNode(literal_pos);
+    ArgumentListNode* factory_param = new(isolate()) ArgumentListNode(
+        literal_pos);
     if (element_list.length() == 0) {
       // TODO(srdjan): Use Object::empty_array once issue 9871 has been fixed.
       Array& empty_array = Array::ZoneHandle(Object::empty_array().raw());
       LiteralNode* empty_array_literal =
-          new LiteralNode(TokenPos(), empty_array);
+          new(isolate()) LiteralNode(TokenPos(), empty_array);
       factory_param->Add(empty_array_literal);
     } else {
-      ArrayNode* list = new ArrayNode(TokenPos(), type, element_list);
+      ArrayNode* list = new(isolate()) ArrayNode(
+          TokenPos(), type, element_list);
       factory_param->Add(list);
     }
     return CreateConstructorCallNode(literal_pos,
                                      factory_type_args,
                                      factory_method,
                                      factory_param);
   }
 }
 
 
 ConstructorCallNode* Parser::CreateConstructorCallNode(
     intptr_t token_pos,
     const TypeArguments& type_arguments,
     const Function& constructor,
     ArgumentListNode* arguments) {
   if (!type_arguments.IsNull() && !type_arguments.IsInstantiated()) {
     EnsureExpressionTemp();
   }
-  return new ConstructorCallNode(token_pos,
-                                 type_arguments,
-                                 constructor,
-                                 arguments);
+  return new(isolate()) ConstructorCallNode(
+      token_pos, type_arguments, constructor, arguments);
 }
 
 
 static void AddKeyValuePair(GrowableArray<AstNode*>* pairs,
                             bool is_const,
                             AstNode* key,
                             AstNode* value) {
   if (is_const) {
     ASSERT(key->IsLiteralNode());
     const Instance& new_key = key->AsLiteralNode()->literal();
@@ skipping 64 matching lines @@
   GrowableArray<AstNode*> kv_pairs_list;
   // Parse the map entries. Note: there may be an optional extra
   // comma after the last entry.
   while (CurrentToken() != Token::kRBRACE) {
     const bool saved_mode = SetAllowFunctionLiterals(true);
     const intptr_t key_pos = TokenPos();
     AstNode* key = ParseExpr(is_const, kConsumeCascades);
     if (FLAG_enable_type_checks &&
         !is_const &&
         !key_type.IsDynamicType()) {
-      key = new AssignableNode(key_pos,
-                               key,
-                               key_type,
-                               Symbols::ListLiteralElement());
+      key = new(isolate()) AssignableNode(
+          key_pos, key, key_type, Symbols::ListLiteralElement());
     }
     if (is_const) {
       ASSERT(key->IsLiteralNode());
       const Instance& key_value = key->AsLiteralNode()->literal();
       if (key_value.IsDouble()) {
         ErrorMsg(key_pos, "key value must not be of type double");
       }
       if (!key_value.IsInteger() &&
           !key_value.IsString() &&
           ImplementsEqualOperator(key_value)) {
         ErrorMsg(key_pos, "key value must not implement operator ==");
       }
     }
     ExpectToken(Token::kCOLON);
     const intptr_t value_pos = TokenPos();
     AstNode* value = ParseExpr(is_const, kConsumeCascades);
     SetAllowFunctionLiterals(saved_mode);
     if (FLAG_enable_type_checks &&
         !is_const &&
         !value_type.IsDynamicType()) {
-      value = new AssignableNode(value_pos,
-                                 value,
-                                 value_type,
-                                 Symbols::ListLiteralElement());
+      value = new(isolate()) AssignableNode(
+          value_pos, value, value_type, Symbols::ListLiteralElement());
     }
     AddKeyValuePair(&kv_pairs_list, is_const, key, value);
 
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
     } else if (CurrentToken() != Token::kRBRACE) {
       ErrorMsg("comma or '}' expected");
     }
   }
   ASSERT(kv_pairs_list.length() % 2 == 0);
   ExpectToken(Token::kRBRACE);
 
   if (is_const) {
     // Create the key-value pair array, canonicalize it and then create
     // the immutable map object with it. This all happens at compile time.
     // The resulting immutable map object is returned as a literal.
 
     // First, create the canonicalized key-value pair array.
     Array& key_value_array =
         Array::ZoneHandle(Array::New(kv_pairs_list.length(), Heap::kOld));
-    AbstractType& arg_type = Type::Handle();
-    Error& malformed_error = Error::Handle();
+    AbstractType& arg_type = Type::Handle(isolate());
+    Error& malformed_error = Error::Handle(isolate());
     for (int i = 0; i < kv_pairs_list.length(); i++) {
       AstNode* arg = kv_pairs_list[i];
       // Arguments have been evaluated to a literal value already.
       ASSERT(arg->IsLiteralNode());
       ASSERT(!is_top_level_);  // We cannot check unresolved types.
       if (FLAG_enable_type_checks) {
         if ((i % 2) == 0) {
           // Check key type.
           arg_type = key_type.raw();
         } else {
           // Check value type.
           arg_type = value_type.raw();
         }
         if (!arg_type.IsDynamicType() &&
             (!arg->AsLiteralNode()->literal().IsNull() &&
              !arg->AsLiteralNode()->literal().IsInstanceOf(
                  arg_type,
                  Object::null_type_arguments(),
                  &malformed_error))) {
           // If the failure is due to a malformed type error, display it.
           if (!malformed_error.IsNull()) {
             ErrorMsg(malformed_error);
           } else {
             ErrorMsg(arg->AsLiteralNode()->token_pos(),
                      "map literal %s at index %d must be "
                      "a constant of type '%s'",
                      ((i % 2) == 0) ? "key" : "value",
                      i >> 1,
-                     String::Handle(arg_type.UserVisibleName()).ToCString());
+                     String::Handle(isolate(),
+                                    arg_type.UserVisibleName()).ToCString());
           }
         }
       }
       key_value_array.SetAt(i, arg->AsLiteralNode()->literal());
     }
     key_value_array ^= TryCanonicalize(key_value_array, TokenPos());
     key_value_array.MakeImmutable();
 
     // Construct the map object.
-    const Class& immutable_map_class =
-        Class::Handle(Library::LookupCoreClass(Symbols::ImmutableMap()));
+    const Class& immutable_map_class = Class::Handle(isolate(),
+        Library::LookupCoreClass(Symbols::ImmutableMap()));
     ASSERT(!immutable_map_class.IsNull());
     // If the immutable map class extends other parameterized classes, we need
     // to adjust the type argument vector. This is currently not the case.
     ASSERT(immutable_map_class.NumTypeArguments() == 2);
-    ArgumentListNode* constr_args = new ArgumentListNode(TokenPos());
-    constr_args->Add(new LiteralNode(literal_pos, key_value_array));
+    ArgumentListNode* constr_args = new(isolate()) ArgumentListNode(TokenPos());
+    constr_args->Add(new(isolate()) LiteralNode(literal_pos, key_value_array));
     const Function& map_constr =
         Function::ZoneHandle(immutable_map_class.LookupConstructor(
             Library::PrivateCoreLibName(Symbols::ImmutableMapConstructor())));
     ASSERT(!map_constr.IsNull());
-    const Object& constructor_result = Object::Handle(
+    const Object& constructor_result = Object::Handle(isolate(),
         EvaluateConstConstructorCall(immutable_map_class,
                                      map_type_arguments,
                                      map_constr,
                                      constr_args));
     if (constructor_result.IsUnhandledException()) {
       AppendErrorMsg(Error::Cast(constructor_result),
                      literal_pos,
                      "error executing const Map constructor");
     } else {
       const Instance& const_instance = Instance::Cast(constructor_result);
-      return new LiteralNode(literal_pos,
-                             Instance::ZoneHandle(const_instance.raw()));
+      return new(isolate()) LiteralNode(
+          literal_pos, Instance::ZoneHandle(const_instance.raw()));
     }
   } else {
     // Factory call at runtime.
     const Class& factory_class =
-        Class::Handle(Library::LookupCoreClass(Symbols::Map()));
+        Class::Handle(isolate(), Library::LookupCoreClass(Symbols::Map()));
     ASSERT(!factory_class.IsNull());
     const Function& factory_method = Function::ZoneHandle(
         factory_class.LookupFactory(
             Library::PrivateCoreLibName(Symbols::MapLiteralFactory())));
     ASSERT(!factory_method.IsNull());
     if (!map_type_arguments.IsNull() &&
         !map_type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureInstantiator();
     }
     TypeArguments& factory_type_args =
         TypeArguments::ZoneHandle(map_type_arguments.raw());
     // 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(Type::New(
+      Type& factory_type = Type::Handle(isolate(), Type::New(
           factory_class, factory_type_args, type_pos, Heap::kNew));
       factory_type ^= ClassFinalizer::FinalizeType(
           current_class(), factory_type, ClassFinalizer::kFinalize);
       factory_type_args = factory_type.arguments();
       ASSERT(factory_type_args.Length() == factory_class.NumTypeArguments());
     }
     factory_type_args = factory_type_args.Canonicalize();
-    ArgumentListNode* factory_param = new ArgumentListNode(literal_pos);
+    ArgumentListNode* factory_param =
+        new(isolate()) ArgumentListNode(literal_pos);
     // The kv_pair array is temporary and of element type dynamic. It is passed
     // to the factory to initialize a properly typed map.
-    ArrayNode* kv_pairs = new ArrayNode(
+    ArrayNode* kv_pairs = new(isolate()) ArrayNode(
         TokenPos(),
         Type::ZoneHandle(Type::ArrayType()),
         kv_pairs_list);
     factory_param->Add(kv_pairs);
     return CreateConstructorCallNode(literal_pos,
                                      factory_type_args,
                                      factory_method,
                                      factory_param);
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 AstNode* Parser::ParseCompoundLiteral() {
   TRACE_PARSER("ParseCompoundLiteral");
   bool is_const = false;
   if (CurrentToken() == Token::kCONST) {
     is_const = true;
     ConsumeToken();
   }
   const intptr_t type_pos = TokenPos();
-  TypeArguments& type_arguments = TypeArguments::Handle(
+  TypeArguments& type_arguments = TypeArguments::Handle(isolate(),
       ParseTypeArguments(ClassFinalizer::kCanonicalize));
   // Malformed type arguments are mapped to dynamic, so we will not encounter
   // them here.
   // Map and List interfaces do not declare bounds on their type parameters, so
   // we will not see malbounded type arguments here.
   AstNode* primary = NULL;
   if ((CurrentToken() == Token::kLBRACK) ||
       (CurrentToken() == Token::kINDEX)) {
     primary = ParseListLiteral(type_pos, is_const, type_arguments);
   } else if (CurrentToken() == Token::kLBRACE) {
     primary = ParseMapLiteral(type_pos, is_const, type_arguments);
   } else {
     ErrorMsg("unexpected token %s", Token::Str(CurrentToken()));
   }
   return primary;
 }
 
 
 AstNode* Parser::ParseSymbolLiteral() {
   ASSERT(CurrentToken() == Token::kHASH);
   ConsumeToken();
   intptr_t symbol_pos = TokenPos();
-  String& symbol = String::Handle();
+  String& symbol = String::Handle(isolate());
   if (IsIdentifier()) {
     symbol = CurrentLiteral()->raw();
     ConsumeToken();
     while (CurrentToken() == Token::kPERIOD) {
       symbol = String::Concat(symbol, Symbols::Dot());
       ConsumeToken();
       symbol = String::Concat(symbol,
                               *ExpectIdentifier("identifier expected"));
     }
   } else if (Token::CanBeOverloaded(CurrentToken())) {
     symbol = String::New(Token::Str(CurrentToken()));
     ConsumeToken();
   } else {
     ErrorMsg("illegal symbol literal");
   }
   // Lookup class Symbol from internal library and call the
   // constructor to create a symbol instance.
-  const Library& lib = Library::Handle(Library::InternalLibrary());
-  const Class& symbol_class = Class::Handle(lib.LookupClass(Symbols::Symbol()));
+  const Library& lib = Library::Handle(isolate(), Library::InternalLibrary());
+  const Class& symbol_class = Class::Handle(isolate(),
+                                            lib.LookupClass(Symbols::Symbol()));
   ASSERT(!symbol_class.IsNull());
-  ArgumentListNode* constr_args = new ArgumentListNode(symbol_pos);
-  constr_args->Add(new LiteralNode(
+  ArgumentListNode* constr_args = new(isolate()) ArgumentListNode(symbol_pos);
+  constr_args->Add(new(isolate()) LiteralNode(
       symbol_pos, String::ZoneHandle(Symbols::New(symbol))));
   const Function& constr = Function::ZoneHandle(
       symbol_class.LookupConstructor(Symbols::SymbolCtor()));
   ASSERT(!constr.IsNull());
-  const Object& result = Object::Handle(
+  const Object& result = Object::Handle(isolate(),
       EvaluateConstConstructorCall(symbol_class,
-                                   TypeArguments::Handle(),
+                                   TypeArguments::Handle(isolate()),
                                    constr,
                                    constr_args));
   if (result.IsUnhandledException()) {
     AppendErrorMsg(Error::Cast(result),
                    symbol_pos,
                    "error executing const Symbol constructor");
   }
   const Instance& instance = Instance::Cast(result);
-  return new LiteralNode(symbol_pos, Instance::ZoneHandle(instance.raw()));
+  return new(isolate()) LiteralNode(symbol_pos,
+                                    Instance::ZoneHandle(instance.raw()));
 }
 
 
 static String& BuildConstructorName(const String& type_class_name,
                                     const String* named_constructor) {
   // By convention, the static function implementing a named constructor 'C'
   // for class 'A' is labeled 'A.C', and the static function implementing the
   // unnamed constructor for class 'A' is labeled 'A.'.
   // This convention prevents users from explicitly calling constructors.
   String& constructor_name =
       String::Handle(String::Concat(type_class_name, Symbols::Dot()));
   if (named_constructor != NULL) {
     constructor_name = String::Concat(constructor_name, *named_constructor);
   }
   return constructor_name;
 }
 
 
 AstNode* Parser::ParseNewOperator(Token::Kind op_kind) {
   TRACE_PARSER("ParseNewOperator");
   const intptr_t new_pos = TokenPos();
   ASSERT((op_kind == Token::kNEW) || (op_kind == Token::kCONST));
   bool is_const = (op_kind == Token::kCONST);
   if (!IsIdentifier()) {
     ErrorMsg("type name expected");
   }
   intptr_t type_pos = TokenPos();
   // Can't allocate const objects of a deferred type.
   const bool allow_deferred_type = !is_const;
-  AbstractType& type = AbstractType::Handle(
+  AbstractType& type = AbstractType::Handle(isolate(),
       ParseType(ClassFinalizer::kCanonicalizeWellFormed, allow_deferred_type));
   // In case the type is malformed, throw a dynamic type error after finishing
   // parsing the instance creation expression.
   if (!type.IsMalformed() && (type.IsTypeParameter() || type.IsDynamicType())) {
     // Replace the type with a malformed type.
     type = ClassFinalizer::NewFinalizedMalformedType(
-        Error::Handle(),  // No previous error.
+        Error::Handle(isolate()),  // No previous error.
         script_,
         type_pos,
         "%s'%s' cannot be instantiated",
         type.IsTypeParameter() ? "type parameter " : "",
         type.IsTypeParameter() ?
-            String::Handle(type.UserVisibleName()).ToCString() : "dynamic");
+            String::Handle(isolate(), type.UserVisibleName()).ToCString() :
+            "dynamic");
   }
 
   // The grammar allows for an optional ('.' identifier)? after the type, which
   // is a named constructor. Note that ParseType() above will not consume it as
   // part of a misinterpreted qualified identifier, because only a valid library
   // prefix is accepted as qualifier.
   String* named_constructor = NULL;
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     named_constructor = ExpectIdentifier("name of constructor expected");
   }
 
   // Parse constructor parameters.
   CheckToken(Token::kLPAREN);
   intptr_t call_pos = TokenPos();
   ArgumentListNode* arguments = ParseActualParameters(NULL, is_const);
 
   // Parsing is complete, so we can return a throw in case of a malformed or
   // malbounded type or report a compile-time error if the constructor is const.
   if (type.IsMalformedOrMalbounded()) {
     if (is_const) {
-      const Error& error = Error::Handle(type.error());
+      const Error& error = Error::Handle(isolate(), type.error());
       ErrorMsg(error);
     }
     return ThrowTypeError(type_pos, type);
   }
 
   // Resolve the type and optional identifier to a constructor or factory.
-  Class& type_class = Class::Handle(type.type_class());
-  String& type_class_name = String::Handle(type_class.Name());
+  Class& type_class = Class::Handle(isolate(), type.type_class());
+  String& type_class_name = String::Handle(isolate(), type_class.Name());
   TypeArguments& type_arguments =
       TypeArguments::ZoneHandle(type.arguments());
 
   // A constructor has an implicit 'this' parameter (instance to construct)
   // and a factory has an implicit 'this' parameter (type_arguments).
   // A constructor has a second implicit 'phase' parameter.
   intptr_t arguments_length = arguments->length() + 2;
 
   // An additional type check of the result of a redirecting factory may be
   // required.
   AbstractType& type_bound = AbstractType::ZoneHandle();
 
   // Make sure that an appropriate constructor exists.
   String& constructor_name =
       BuildConstructorName(type_class_name, named_constructor);
   Function& constructor = Function::ZoneHandle(
       type_class.LookupConstructor(constructor_name));
   if (constructor.IsNull()) {
     constructor = type_class.LookupFactory(constructor_name);
     if (constructor.IsNull()) {
       const String& external_constructor_name =
           (named_constructor ? constructor_name : type_class_name);
       // Replace the type with a malformed type and compile a throw or report a
       // compile-time error if the constructor is const.
       if (is_const) {
         type = ClassFinalizer::NewFinalizedMalformedType(
-            Error::Handle(),  // No previous error.
+            Error::Handle(isolate()),  // No previous error.
             script_,
             call_pos,
             "class '%s' has no constructor or factory named '%s'",
-            String::Handle(type_class.Name()).ToCString(),
+            String::Handle(isolate(), type_class.Name()).ToCString(),
             external_constructor_name.ToCString());
-        ErrorMsg(Error::Handle(type.error()));
+        ErrorMsg(Error::Handle(isolate(), type.error()));
       }
       return ThrowNoSuchMethodError(call_pos,
                                     type_class,
                                     external_constructor_name,
                                     arguments,
                                     InvocationMirror::kConstructor,
                                     InvocationMirror::kMethod,
                                     &constructor);
     } else if (constructor.IsRedirectingFactory()) {
       ClassFinalizer::ResolveRedirectingFactory(type_class, constructor);
-      Type& redirect_type = Type::Handle(constructor.RedirectionType());
+      Type& redirect_type = Type::Handle(isolate(),
+                                         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();
+        Error& error = Error::Handle(isolate());
         redirect_type ^= redirect_type.InstantiateFrom(type_arguments, &error);
         if (!error.IsNull()) {
           redirect_type = ClassFinalizer::NewFinalizedMalformedType(
               error,
               script_,
               call_pos,
               "redirecting factory type '%s' cannot be instantiated",
-              String::Handle(redirect_type.UserVisibleName()).ToCString());
+              String::Handle(isolate(),
+                             redirect_type.UserVisibleName()).ToCString());
         }
       }
       if (redirect_type.IsMalformedOrMalbounded()) {
         if (is_const) {
-          ErrorMsg(Error::Handle(redirect_type.error()));
+          ErrorMsg(Error::Handle(isolate(), redirect_type.error()));
         }
         return ThrowTypeError(redirect_type.token_pos(), redirect_type);
       }
       if (FLAG_enable_type_checks && !redirect_type.IsSubtypeOf(type, NULL)) {
         // Additional type checking of the result is necessary.
         type_bound = type.raw();
       }
       type = redirect_type.raw();
       type_class = type.type_class();
       type_class_name = type_class.Name();
       type_arguments = type.arguments();
       constructor = constructor.RedirectionTarget();
       constructor_name = constructor.name();
       ASSERT(!constructor.IsNull());
     }
     if (constructor.IsFactory()) {
       // A factory does not have the implicit 'phase' parameter.
       arguments_length -= 1;
     }
   }
 
   // It is ok to call a factory method of an abstract class, but it is
   // a dynamic error to instantiate an abstract class.
   ASSERT(!constructor.IsNull());
   if (type_class.is_abstract() && !constructor.IsFactory()) {
     // Evaluate arguments before throwing.
-    LetNode* result = new LetNode(call_pos);
+    LetNode* result = new(isolate()) LetNode(call_pos);
     for (intptr_t i = 0; i < arguments->length(); ++i) {
       result->AddNode(arguments->NodeAt(i));
     }
-    ArgumentListNode* error_arguments = new ArgumentListNode(type_pos);
-    error_arguments->Add(new LiteralNode(
+    ArgumentListNode* error_arguments =
+        new(isolate()) ArgumentListNode(type_pos);
+    error_arguments->Add(new(isolate()) LiteralNode(
         TokenPos(), Integer::ZoneHandle(Integer::New(type_pos))));
-    error_arguments->Add(new LiteralNode(
+    error_arguments->Add(new(isolate()) LiteralNode(
         TokenPos(), String::ZoneHandle(type_class_name.raw())));
     result->AddNode(
         MakeStaticCall(Symbols::AbstractClassInstantiationError(),
                        Library::PrivateCoreLibName(Symbols::ThrowNew()),
                        error_arguments));
     return result;
   }
-  String& error_message = String::Handle();
+  String& error_message = String::Handle(isolate());
   if (!constructor.AreValidArguments(arguments_length,
                                      arguments->names(),
                                      &error_message)) {
     const String& external_constructor_name =
         (named_constructor ? constructor_name : type_class_name);
     if (is_const) {
       ErrorMsg(call_pos,
                "invalid arguments passed to constructor '%s' "
                "for class '%s': %s",
                external_constructor_name.ToCString(),
-               String::Handle(type_class.Name()).ToCString(),
+               String::Handle(isolate(), type_class.Name()).ToCString(),
                error_message.ToCString());
     }
     return ThrowNoSuchMethodError(call_pos,
                                   type_class,
                                   external_constructor_name,
                                   arguments,
                                   InvocationMirror::kConstructor,
                                   InvocationMirror::kMethod,
                                   &constructor);
   }
 
   // Return a throw in case of a malformed or malbounded type or report a
   // compile-time error if the constructor is const.
   if (type.IsMalformedOrMalbounded()) {
     if (is_const) {
-      ErrorMsg(Error::Handle(type.error()));
+      ErrorMsg(Error::Handle(isolate(), type.error()));
     }
     return ThrowTypeError(type_pos, type);
   }
   type_arguments ^= type_arguments.Canonicalize();
   // Make the constructor call.
   AstNode* new_object = NULL;
   if (is_const) {
     if (!constructor.is_const()) {
       const String& external_constructor_name =
           (named_constructor ? constructor_name : type_class_name);
       ErrorMsg("non-const constructor '%s' cannot be used in "
                "const object creation",
                external_constructor_name.ToCString());
     }
-    const Object& constructor_result = Object::Handle(
+    const Object& constructor_result = Object::Handle(isolate(),
         EvaluateConstConstructorCall(type_class,
                                      type_arguments,
                                      constructor,
                                      arguments));
     if (constructor_result.IsUnhandledException()) {
       // It's a compile-time error if invocation of a const constructor
       // call fails.
       AppendErrorMsg(Error::Cast(constructor_result),
                      new_pos,
                      "error while evaluating const constructor");
     } else {
       // Const constructors can return null in the case where a const native
       // factory returns a null value. Thus we cannot use a Instance::Cast here.
-      Instance& const_instance = Instance::Handle();
+      Instance& const_instance = Instance::Handle(isolate());
       const_instance ^= constructor_result.raw();
-      new_object = new LiteralNode(new_pos,
+      new_object = new(isolate()) LiteralNode(new_pos,
                                    Instance::ZoneHandle(const_instance.raw()));
       if (!type_bound.IsNull()) {
         ASSERT(!type_bound.IsMalformed());
-        Error& malformed_error = Error::Handle();
+        Error& malformed_error = Error::Handle(isolate());
         ASSERT(!is_top_level_);  // We cannot check unresolved types.
         if (!const_instance.IsInstanceOf(type_bound,
-                                         TypeArguments::Handle(),
+                                         TypeArguments::Handle(isolate()),
                                          &malformed_error)) {
           type_bound = ClassFinalizer::NewFinalizedMalformedType(
               malformed_error,
               script_,
               new_pos,
               "const factory result is not an instance of '%s'",
-              String::Handle(type_bound.UserVisibleName()).ToCString());
+              String::Handle(isolate(),
+                             type_bound.UserVisibleName()).ToCString());
           new_object = ThrowTypeError(new_pos, type_bound);
         }
         type_bound = AbstractType::null();
       }
     }
   } else {
     CheckConstructorCallTypeArguments(new_pos, constructor, type_arguments);
     if (!type_arguments.IsNull() &&
         !type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureInstantiator();
     }
     // If the type argument vector is not instantiated, we verify in checked
     // mode at runtime that it is within its declared bounds.
     new_object = CreateConstructorCallNode(
         new_pos, type_arguments, constructor, arguments);
   }
   if (!type_bound.IsNull()) {
-    new_object = new AssignableNode(new_pos,
-                                    new_object,
-                                    type_bound,
-                                    Symbols::FactoryResult());
+    new_object = new(isolate()) AssignableNode(
+         new_pos, new_object, type_bound, Symbols::FactoryResult());
   }
   return new_object;
 }
 
 
 String& Parser::Interpolate(const GrowableArray<AstNode*>& values) {
   const Class& cls = Class::Handle(
       isolate(), Library::LookupCoreClass(Symbols::StringBase()));
   ASSERT(!cls.IsNull());
   const Function& func = Function::Handle(isolate(), cls.LookupStaticFunction(
@@ skipping 37 matching lines @@
 AstNode* Parser::ParseStringLiteral(bool allow_interpolation) {
   TRACE_PARSER("ParseStringLiteral");
   AstNode* primary = NULL;
   const intptr_t literal_start = TokenPos();
   ASSERT(CurrentToken() == Token::kSTRING);
   Token::Kind l1_token = LookaheadToken(1);
   if ((l1_token != Token::kSTRING) &&
       (l1_token != Token::kINTERPOL_VAR) &&
       (l1_token != Token::kINTERPOL_START)) {
     // Common case: no interpolation.
-    primary = new LiteralNode(literal_start, *CurrentLiteral());
+    primary = new(isolate()) LiteralNode(literal_start, *CurrentLiteral());
     ConsumeToken();
     return primary;
   }
   // String interpolation needed.
   bool is_compiletime_const = true;
   bool has_interpolation = false;
   GrowableArray<AstNode*> values_list;
   while (CurrentToken() == Token::kSTRING) {
     if (CurrentLiteral()->Length() > 0) {
       // Only add non-empty string sections to the values list
       // that will be concatenated.
-      values_list.Add(new LiteralNode(TokenPos(), *CurrentLiteral()));
+      values_list.Add(new(isolate()) LiteralNode(TokenPos(),
+                                                 *CurrentLiteral()));
     }
     ConsumeToken();
     while ((CurrentToken() == Token::kINTERPOL_VAR) ||
         (CurrentToken() == Token::kINTERPOL_START)) {
       if (!allow_interpolation) {
         ErrorMsg("string interpolation not allowed in this context");
       }
       has_interpolation = true;
       AstNode* expr = NULL;
       const intptr_t expr_pos = TokenPos();
@@ skipping 13 matching lines @@
       // a constant or not. Only strings, numbers, booleans and null values
       // are allowed in compile time const interpolations.
       if (is_compiletime_const) {
         const Object* const_expr = expr->EvalConstExpr();
         if ((const_expr != NULL) &&
             (const_expr->IsNumber() ||
             const_expr->IsString() ||
             const_expr->IsBool() ||
             const_expr->IsNull())) {
           // Change expr into a literal.
-          expr = new LiteralNode(expr_pos, EvaluateConstExpr(expr_pos, expr));
+          expr = new(isolate()) LiteralNode(expr_pos,
+                                            EvaluateConstExpr(expr_pos, expr));
         } else {
           is_compiletime_const = false;
         }
       }
       values_list.Add(expr);
     }
   }
   if (is_compiletime_const) {
     if (has_interpolation) {
-      primary = new LiteralNode(literal_start, Interpolate(values_list));
+      primary = new(isolate()) LiteralNode(
+          literal_start, Interpolate(values_list));
     } else {
-      const Array& strings = Array::Handle(Array::New(values_list.length()));
+      const Array& strings = Array::Handle(isolate(),
+                                           Array::New(values_list.length()));
       for (int i = 0; i < values_list.length(); i++) {
         const Instance& part = values_list[i]->AsLiteralNode()->literal();
         ASSERT(part.IsString());
         strings.SetAt(i, String::Cast(part));
       }
       String& lit = String::ZoneHandle(String::ConcatAll(strings, Heap::kOld));
       lit = Symbols::New(lit);
-      primary = new LiteralNode(literal_start, lit);
+      primary = new(isolate()) LiteralNode(literal_start, lit);
     }
   } else {
-    ArrayNode* values = new ArrayNode(
+    ArrayNode* values = new(isolate()) ArrayNode(
         TokenPos(),
         Type::ZoneHandle(Type::ArrayType()),
         values_list);
-    primary = new StringInterpolateNode(TokenPos(), values);
+    primary = new(isolate()) StringInterpolateNode(TokenPos(), values);
   }
   return primary;
 }
 
 
 AstNode* Parser::ParsePrimary() {
   TRACE_PARSER("ParsePrimary");
   ASSERT(!is_top_level_);
   AstNode* primary = NULL;
   if (IsFunctionLiteral()) {
     // The name of a literal function is visible from inside the function, but
     // must not collide with names in the scope declaring the literal.
     OpenBlock();
     primary = ParseFunctionStatement(true);
     CloseBlock();
   } else if (IsIdentifier()) {
     QualIdent qual_ident;
     intptr_t qual_ident_pos = TokenPos();
     ParseQualIdent(&qual_ident);
     if (qual_ident.lib_prefix == NULL) {
       if (!ResolveIdentInLocalScope(qual_ident.ident_pos,
                                     *qual_ident.ident,
                                     &primary)) {
         // Check whether the identifier is a type parameter.
         if (!current_class().IsNull()) {
           TypeParameter& type_param = TypeParameter::ZoneHandle(
               current_class().LookupTypeParameter(*(qual_ident.ident)));
           if (!type_param.IsNull()) {
-            return new PrimaryNode(qual_ident.ident_pos, type_param);
+            return new(isolate()) PrimaryNode(qual_ident.ident_pos, type_param);
           }
         }
         // This is a non-local unqualified identifier so resolve the
         // identifier locally in the main app library and all libraries
         // imported by it.
         primary = ResolveIdentInCurrentLibraryScope(qual_ident.ident_pos,
                                                     *qual_ident.ident);
       }
     } else {
       // This is a qualified identifier with a library prefix so resolve
       // the identifier locally in that library (we do not include the
       // libraries imported by that library).
       primary = ResolveIdentInPrefixScope(qual_ident.ident_pos,
                                           *qual_ident.lib_prefix,
                                           *qual_ident.ident);
       // If the identifier could not be resolved, throw a NoSuchMethodError.
       // Note: unlike in the case of an unqualified identifier, do not
       // interpret the unresolved identifier as an instance method or
       // instance getter call when compiling an instance method.
       if (primary == NULL) {
         if (qual_ident.lib_prefix->is_deferred_load() &&
             qual_ident.ident->Equals(Symbols::LoadLibrary())) {
           // Hack Alert: recognize special 'loadLibrary' call on the
           // prefix object. The prefix is the primary. Rewind parser and
           // let ParseSelectors() handle the loadLibrary call.
           SetPosition(qual_ident_pos);
           ConsumeToken();  // Prefix name.
-          primary = new LiteralNode(qual_ident_pos, *qual_ident.lib_prefix);
+          primary = new(isolate()) LiteralNode(
+              qual_ident_pos, *qual_ident.lib_prefix);
         } else {
           // TODO(hausner): Ideally we should generate the NoSuchMethodError
           // later, when we know more about how the unresolved name is used.
           // For example, we don't know yet whether the unresolved name
           // refers to a getter or a setter. However, it is more awkward
           // to distinuish four NoSuchMethodError cases all over the place
           // in the parser. The four cases are: prefixed vs non-prefixed
           // name, static vs dynamic context in which the unresolved name
           // is used. We cheat a little here by looking at the next token
           // to determine whether we have an unresolved method call or
@@ skipping 15 matching lines @@
                                            NULL);  // No existing function.
         }
       }
     }
     ASSERT(primary != NULL);
   } else if (CurrentToken() == Token::kTHIS) {
     LocalVariable* local = LookupLocalScope(Symbols::This());
     if (local == NULL) {
       ErrorMsg("receiver 'this' is not in scope");
     }
-    primary = new LoadLocalNode(TokenPos(), local);
+    primary = new(isolate()) LoadLocalNode(TokenPos(), local);
     ConsumeToken();
   } else if (CurrentToken() == Token::kINTEGER) {
     const Integer& literal = Integer::ZoneHandle(CurrentIntegerLiteral());
-    primary = new LiteralNode(TokenPos(), literal);
+    primary = new(isolate()) LiteralNode(TokenPos(), literal);
     ConsumeToken();
   } else if (CurrentToken() == Token::kTRUE) {
-    primary = new LiteralNode(TokenPos(), Bool::True());
+    primary = new(isolate()) LiteralNode(TokenPos(), Bool::True());
     ConsumeToken();
   } else if (CurrentToken() == Token::kFALSE) {
-    primary = new LiteralNode(TokenPos(), Bool::False());
+    primary = new(isolate()) LiteralNode(TokenPos(), Bool::False());
     ConsumeToken();
   } else if (CurrentToken() == Token::kNULL) {
-    primary = new LiteralNode(TokenPos(), Instance::ZoneHandle());
+    primary = new(isolate()) LiteralNode(TokenPos(), Instance::ZoneHandle());
     ConsumeToken();
   } else if (CurrentToken() == Token::kLPAREN) {
     ConsumeToken();
     const bool saved_mode = SetAllowFunctionLiterals(true);
     primary = ParseExpr(kAllowConst, kConsumeCascades);
     SetAllowFunctionLiterals(saved_mode);
     ExpectToken(Token::kRPAREN);
   } else if (CurrentToken() == Token::kDOUBLE) {
     Double& double_value = Double::ZoneHandle(CurrentDoubleLiteral());
     if (double_value.IsNull()) {
       ErrorMsg("invalid double literal");
     }
-    primary = new LiteralNode(TokenPos(), double_value);
+    primary = new(isolate()) LiteralNode(TokenPos(), double_value);
     ConsumeToken();
   } else if (CurrentToken() == Token::kSTRING) {
     primary = ParseStringLiteral(true);
   } else if (CurrentToken() == Token::kNEW) {
     ConsumeToken();
     primary = ParseNewOperator(Token::kNEW);
   } else if (CurrentToken() == Token::kCONST) {
     if ((LookaheadToken(1) == Token::kLT) ||
         (LookaheadToken(1) == Token::kLBRACK) ||
         (LookaheadToken(1) == Token::kINDEX) ||
@@ skipping 12 matching lines @@
     primary = ParseSymbolLiteral();
   } else if (CurrentToken() == Token::kSUPER) {
     if (parsing_metadata_) {
       ErrorMsg("cannot access superclass from metadata");
     }
     if (current_function().is_static()) {
       ErrorMsg("cannot access superclass from static method");
     }
     if (current_class().SuperClass() == Class::null()) {
       ErrorMsg("class '%s' does not have a superclass",
-               String::Handle(current_class().Name()).ToCString());
+               String::Handle(isolate(), current_class().Name()).ToCString());
     }
     if (current_class().IsMixinApplication()) {
-      const Type& mixin_type = Type::Handle(current_class().mixin());
+      const Type& mixin_type = Type::Handle(isolate(), current_class().mixin());
       if (mixin_type.type_class() == current_function().origin()) {
         ErrorMsg("method of mixin class '%s' may not refer to 'super'",
-                 String::Handle(Class::Handle(
+                 String::Handle(isolate(), Class::Handle(isolate(),
                      current_function().origin()).Name()).ToCString());
       }
     }
     const intptr_t super_pos = TokenPos();
     ConsumeToken();
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       const intptr_t ident_pos = TokenPos();
       const String& ident = *ExpectIdentifier("identifier expected");
       if (CurrentToken() == Token::kLPAREN) {
         primary = ParseSuperCall(ident);
       } else {
         primary = ParseSuperFieldAccess(ident, ident_pos);
       }
     } else if ((CurrentToken() == Token::kLBRACK) ||
         Token::CanBeOverloaded(CurrentToken()) ||
         (CurrentToken() == Token::kNE)) {
       primary = ParseSuperOperator();
     } else {
-      primary = new PrimaryNode(super_pos, Symbols::Super());
+      primary = new(isolate()) PrimaryNode(super_pos, Symbols::Super());
     }
   } else {
     UnexpectedToken();
   }
   return primary;
 }
 
 
 // Evaluate expression in expr and return the value. The expression must
 // be a compile time constant.
 const Instance& Parser::EvaluateConstExpr(intptr_t expr_pos, AstNode* expr) {
   if (expr->IsLiteralNode()) {
     return expr->AsLiteralNode()->literal();
   } else if (expr->IsLoadLocalNode() &&
       expr->AsLoadLocalNode()->local().IsConst()) {
     return *expr->AsLoadLocalNode()->local().ConstValue();
   } else if (expr->IsLoadStaticFieldNode()) {
     const Field& field = expr->AsLoadStaticFieldNode()->field();
     // We already checked that this field is const and has been
     // initialized.
     ASSERT(field.is_const());
     ASSERT(field.value() != Object::sentinel().raw());
     ASSERT(field.value() != Object::transition_sentinel().raw());
     return Instance::ZoneHandle(field.value());
   } else {
     ASSERT(expr->EvalConstExpr() != NULL);
-    ReturnNode* ret = new ReturnNode(expr->token_pos(), expr);
+    ReturnNode* ret = new(isolate()) ReturnNode(expr->token_pos(), expr);
     // Compile time constant expressions cannot reference anything from a
     // local scope.
-    LocalScope* empty_scope = new LocalScope(NULL, 0, 0);
-    SequenceNode* seq = new SequenceNode(expr->token_pos(), empty_scope);
+    LocalScope* empty_scope = new(isolate()) LocalScope(NULL, 0, 0);
+    SequenceNode* seq = new(isolate()) SequenceNode(expr->token_pos(),
+                                                    empty_scope);
     seq->Add(ret);
 
-    Object& result = Object::Handle(Compiler::ExecuteOnce(seq));
+    Object& result = Object::Handle(isolate(), Compiler::ExecuteOnce(seq));
     if (result.IsError()) {
       AppendErrorMsg(Error::Cast(result),
                      expr_pos,
                      "error evaluating constant expression");
     }
     ASSERT(result.IsInstance());
     Instance& value = Instance::ZoneHandle();
     value ^= result.raw();
     value = TryCanonicalize(value, TokenPos());
     return value;
@@ skipping 326 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart