Cache the isolate pointer in the parser object.

runtime/vm/parser.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/parser.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 237 matching lines @@
 };
 
 
 void Parser::TryBlocks::AddNodeForFinallyInlining(AstNode* node) {
   inlined_finally_nodes_.Add(node);
 }
 
 
 // For parsing a compilation unit.
 Parser::Parser(const Script& script, const Library& library, intptr_t token_pos)
-    : script_(Script::Handle(script.raw())),
-      tokens_iterator_(TokenStream::Handle(script.tokens()), token_pos),
+    : isolate_(Isolate::Current()),
+      script_(Script::Handle(isolate_, script.raw())),
+      tokens_iterator_(TokenStream::Handle(isolate_, script.tokens()),
+                       token_pos),
       token_kind_(Token::kILLEGAL),
       current_block_(NULL),
       is_top_level_(false),
       current_member_(NULL),
       allow_function_literals_(true),
       parsed_function_(NULL),
-      innermost_function_(Function::Handle()),
-      literal_token_(LiteralToken::Handle()),
-      current_class_(Class::Handle()),
-      library_(Library::Handle(library.raw())),
+      innermost_function_(Function::Handle(isolate_)),
+      literal_token_(LiteralToken::Handle(isolate_)),
+      current_class_(Class::Handle(isolate_)),
+      library_(Library::Handle(isolate_, library.raw())),
       try_blocks_list_(NULL) {
   ASSERT(tokens_iterator_.IsValid());
   ASSERT(!library.IsNull());
 }
 
 
 // For parsing a function.
 Parser::Parser(const Script& script,
                ParsedFunction* parsed_function,
                intptr_t token_position)
-    : script_(Script::Handle(script.raw())),
-      tokens_iterator_(TokenStream::Handle(script.tokens()), token_position),
+    : isolate_(Isolate::Current()),
+      script_(Script::Handle(isolate_, script.raw())),
+      tokens_iterator_(TokenStream::Handle(isolate_, script.tokens()),
+                       token_position),
       token_kind_(Token::kILLEGAL),
       current_block_(NULL),
       is_top_level_(false),
       current_member_(NULL),
       allow_function_literals_(true),
       parsed_function_(parsed_function),
-      innermost_function_(Function::Handle(parsed_function->function().raw())),
-      literal_token_(LiteralToken::Handle()),
-      current_class_(Class::Handle(parsed_function->function().Owner())),
+      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(
+          isolate_,
           parsed_function->function().origin()).library())),
       try_blocks_list_(NULL) {
   ASSERT(tokens_iterator_.IsValid());
   ASSERT(!current_function().IsNull());
   if (FLAG_enable_type_checks) {
     EnsureExpressionTemp();
   }
 }
 
 
@@ skipping 3427 matching lines @@
       ExpectIdentifier("name expected");
     }
     SkipTypeArguments();
   }
 }
 
 
 void Parser::ParseTypeParameters(const Class& cls) {
   TRACE_PARSER("ParseTypeParameters");
   if (CurrentToken() == Token::kLT) {
-    Isolate* isolate = Isolate::Current();
     const GrowableObjectArray& type_parameters_array =
         GrowableObjectArray::Handle(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();
     do {
       ConsumeToken();
       SkipMetadata();
@@ skipping 10 matching lines @@
         }
       }
       if (CurrentToken() == Token::kEXTENDS) {
         ConsumeToken();
         // A bound may refer to the owner of the type parameter it applies to,
         // i.e. to the class or interface currently being parsed.
         // Postpone resolution in order to avoid resolving the class and its
         // type parameters, as they are not fully parsed yet.
         type_parameter_bound = ParseType(ClassFinalizer::kDoNotResolve);
       } else {
-        type_parameter_bound = isolate->object_store()->object_type();
+        type_parameter_bound = isolate()->object_store()->object_type();
       }
       type_parameter = TypeParameter::New(cls,
                                           index,
                                           type_parameter_name,
                                           type_parameter_bound,
                                           type_parameter_pos);
       type_parameters_array.Add(type_parameter);
       index++;
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
@@ skipping 114 matching lines @@
                "mixin type '%s' may not be a type parameter",
                String::Handle(mixin_type.UserVisibleName()).ToCString());
     }
 
     // The name of the mixin application class is a combination of
     // the superclass and mixin class.
     String& mixin_app_name = String::Handle();
     mixin_app_name = mixin_super_type.ClassName();
     mixin_app_name = String::Concat(mixin_app_name, Symbols::Ampersand());
     mixin_app_name = String::Concat(mixin_app_name,
-                                     String::Handle(mixin_type.ClassName()));
+                                    String::Handle(mixin_type.ClassName()));
     mixin_app_name = Symbols::New(mixin_app_name);
 
     mixin_application = Class::New(mixin_app_name, script_, mixin_pos);
     mixin_application.set_super_type(mixin_super_type);
     mixin_application.set_mixin(Type::Cast(mixin_type));
     mixin_application.set_library(library_);
     mixin_application.set_is_synthesized_class();
     AddImplicitConstructor(mixin_application);
     // Add the mixin type to the interfaces that the mixin application
     // class implements. This is necessary so that type tests work.
@@ skipping 305 matching lines @@
   } else {
     library_.ReplaceObject(func, accessor_name);
   }
 }
 
 
 
 RawObject* Parser::CallLibraryTagHandler(Dart_LibraryTag tag,
                                           intptr_t token_pos,
                                           const String& url) {
-  Isolate* isolate = Isolate::Current();
-  Dart_LibraryTagHandler handler = isolate->library_tag_handler();
+  Dart_LibraryTagHandler handler = isolate()->library_tag_handler();
   if (handler == NULL) {
     if (url.StartsWith(Symbols::DartScheme())) {
       if (tag == Dart_kCanonicalizeUrl) {
         return url.raw();
       }
       return Object::null();
     }
     ErrorMsg(token_pos, "no library handler registered");
   }
   Dart_Handle result = handler(tag,
-                               Api::NewHandle(isolate, library_.raw()),
-                               Api::NewHandle(isolate, url.raw()));
+                               Api::NewHandle(isolate(), library_.raw()),
+                               Api::NewHandle(isolate(), url.raw()));
   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();
     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");
@@ skipping 211 matching lines @@
   }
   ExpectSemicolon();
 }
 
 
 void Parser::ParseTopLevel() {
   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.
-  Isolate* isolate = Isolate::Current();
-  ObjectStore* object_store = isolate->object_store();
+  ObjectStore* object_store = isolate()->object_store();
   const GrowableObjectArray& pending_classes =
-      GrowableObjectArray::Handle(isolate, object_store->pending_classes());
+      GrowableObjectArray::Handle(isolate(), object_store->pending_classes());
   SetPosition(0);
   is_top_level_ = true;
   TopLevel top_level;
   Class& toplevel_class = Class::Handle(
       Class::New(Symbols::TopLevel(), script_, TokenPos()));
   toplevel_class.set_library(library_);
 
   if (is_library_source() || is_patch_source()) {
     ParseLibraryDefinition();
   } else if (is_part_source()) {
@@ skipping 2057 matching lines @@
   OS::Print("%s", buf.ToCString());
 }
 
 
 void Parser::ErrorMsg(intptr_t token_pos, const char* format, ...) {
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
       FormatError(script_, token_pos, "Error", format, args));
   va_end(args);
-  Isolate::Current()->long_jump_base()->Jump(1, error);
+  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(
       FormatError(script_, TokenPos(), "Error", format, args));
   va_end(args);
-  Isolate::Current()->long_jump_base()->Jump(1, error);
+  isolate()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 
 void Parser::ErrorMsg(const Error& error) {
-  Isolate::Current()->long_jump_base()->Jump(1, error);
+  isolate()->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(FormatErrorWithAppend(
       prev_error, script_, token_pos, "Error", format, args));
   va_end(args);
-  Isolate::Current()->long_jump_base()->Jump(1, error);
+  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(
       FormatError(script_, token_pos, "Warning", format, args));
   va_end(args);
   if (FLAG_warning_as_error) {
-    Isolate::Current()->long_jump_base()->Jump(1, 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(
       FormatError(script_, TokenPos(), "Warning", format, args));
   va_end(args);
   if (FLAG_warning_as_error) {
-    Isolate::Current()->long_jump_base()->Jump(1, error);
+    isolate()->long_jump_base()->Jump(1, error);
     UNREACHABLE();
   } else {
     OS::Print("%s", error.ToErrorCString());
   }
 }
 
 
 void Parser::Unimplemented(const char* msg) {
   ErrorMsg(TokenPos(), "%s", msg);
 }
@@ skipping 1466 matching lines @@
           // generated AST is not deterministic. Therefore mark the function as
           // not optimizable.
           current_function().set_is_optimizable(false);
           field.set_value(Instance::null_object());
           // It is a compile-time error if evaluation of a compile-time constant
           // would raise an exception.
           AppendErrorMsg(error, TokenPos(),
                          "error initializing const field '%s'",
                          String::Handle(field.name()).ToCString());
         } else {
-          Isolate::Current()->long_jump_base()->Jump(1, error);
+          isolate()->long_jump_base()->Jump(1, error);
         }
       }
       ASSERT(const_value.IsNull() || const_value.IsInstance());
       Instance& instance = Instance::Handle();
       instance ^= const_value.raw();
       if (!instance.IsNull()) {
         instance ^= instance.Canonicalize();
       }
       field.set_value(instance);
     } else {
@@ skipping 42 matching lines @@
                                                arg_values,
                                                arg_descriptor));
   if (result.IsError()) {
       // 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().set_is_optimizable(false);
       if (result.IsUnhandledException()) {
         return result.raw();
       } else {
-        Isolate::Current()->long_jump_base()->Jump(1, Error::Cast(result));
+        isolate()->long_jump_base()->Jump(1, Error::Cast(result));
         UNREACHABLE();
         return Object::null();
       }
   } else {
     if (!instance.IsNull()) {
       instance ^= instance.Canonicalize();
     }
     return instance.raw();
   }
 }
 
 
 // Do a lookup for the identifier in the block scope and the class scope
 // return true if the identifier is found, false otherwise.
 // If node is non NULL return an AST node corresponding to the identifier.
 bool Parser::ResolveIdentInLocalScope(intptr_t ident_pos,
                                       const String &ident,
                                       AstNode** node) {
   TRACE_PARSER("ResolveIdentInLocalScope");
-  Isolate* isolate = Isolate::Current();
   // First try to find the identifier in the nested local scopes.
   LocalVariable* local = LookupLocalScope(ident);
   if (local != NULL) {
     if (node != NULL) {
       if (local->IsConst()) {
         *node = new LiteralNode(ident_pos, *local->ConstValue());
       } else {
         *node = new 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);
+  Class& cls = Class::Handle(isolate());
   if (current_class().mixin() == Type::null()) {
     cls = current_class().raw();
   } else {
     cls = parsed_function()->function().origin();
   }
-  Function& func = Function::Handle(isolate, Function::null());
-  Field& field = Field::Handle(isolate, Field::null());
+  Function& func = Function::Handle(isolate(), Function::null());
+  Field& field = Field::Handle(isolate(), Field::null());
 
   // First check if a field exists.
   field = cls.LookupField(ident);
   if (!field.IsNull()) {
     if (node != NULL) {
       if (!field.is_static()) {
         CheckInstanceFieldAccess(ident_pos, ident);
         *node = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
       } else {
         *node = GenerateStaticFieldLookup(field, ident_pos);
       }
     }
     return true;
   }
 
   // Check if an instance/static function exists.
   func = cls.LookupFunction(ident);
   if (!func.IsNull() &&
       (func.IsDynamicFunction() || func.IsStaticFunction())) {
     if (node != NULL) {
       *node = new PrimaryNode(ident_pos,
-                              Function::ZoneHandle(isolate, func.raw()));
+                              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()) {
       if (node != NULL) {
@@ skipping 11 matching lines @@
         AstNode* receiver = NULL;
         const bool kTestOnly = true;
         ASSERT(!current_function().IsInFactoryScope());
         if (!current_function().is_static() &&
             (LookupReceiver(current_block_->scope, kTestOnly) != NULL)) {
           receiver = LoadReceiver(ident_pos);
         }
         *node = new StaticGetterNode(ident_pos,
                                      receiver,
                                      false,
-                                     Class::ZoneHandle(isolate, cls.raw()),
+                                     Class::ZoneHandle(isolate(), cls.raw()),
                                      ident);
       }
       return true;
     }
   }
   func = cls.LookupSetterFunction(ident);
   if (!func.IsNull()) {
     if (func.IsDynamicFunction()) {
       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());
         *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()),
+                                     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.
 }
 
 
-static RawObject* LookupNameInLibrary(const Library& lib, const String& name) {
-  Object& obj = Object::Handle();
+static RawObject* LookupNameInLibrary(Isolate* isolate,
+                                      const Library& lib,
+                                      const String& name) {
+  Object& obj = Object::Handle(isolate);
   obj = lib.LookupLocalObject(name);
   if (!obj.IsNull()) {
     return obj.raw();
   }
-  String& accessor_name = String::Handle(Field::GetterName(name));
+  String& accessor_name = String::Handle(isolate, Field::GetterName(name));
   obj = lib.LookupLocalObject(accessor_name);
   if (!obj.IsNull()) {
     return obj.raw();
   }
   accessor_name = Field::SetterName(name);
   obj = lib.LookupLocalObject(accessor_name);
   return obj.raw();
 }
 
 
-static RawObject* LookupNameInImport(const Namespace& ns, const String& name) {
-  Object& obj = Object::Handle();
+static RawObject* LookupNameInImport(Isolate* isolate,
+                                     const Namespace& ns,
+                                     const String& name) {
+  Object& obj = Object::Handle(isolate);
   obj = ns.Lookup(name);
   if (!obj.IsNull()) {
     return obj.raw();
   }
   // If the given name is filtered out by the import, don't look up the
   // getter and setter names.
   if (ns.HidesName(name)) {
     return Object::null();
   }
-  String& accessor_name = String::Handle(Field::GetterName(name));
+  String& accessor_name = String::Handle(isolate, Field::GetterName(name));
   obj = ns.Lookup(accessor_name);
   if (!obj.IsNull()) {
     return obj.raw();
   }
   accessor_name = Field::SetterName(name);
   obj = ns.Lookup(accessor_name);
   return obj.raw();
 }
 
 
 // Resolve a name 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.
 // Issue an error if the name is not found in the global scope
 // of the current library, but is defined in more than one imported
 // library, i.e. if the name cannot be resolved unambiguously.
 RawObject* Parser::ResolveNameInCurrentLibraryScope(intptr_t ident_pos,
                                                     const String& name,
                                                     Error* error) {
   TRACE_PARSER("ResolveNameInCurrentLibraryScope");
-  Object& obj = Object::Handle(LookupNameInLibrary(library_, name));
+  HANDLESCOPE(isolate());
+  Object& obj = Object::Handle(isolate(),
+                               LookupNameInLibrary(isolate(), library_, name));
   if (obj.IsNull()) {
     // Name is not found in current library. Check scope of all
     // imported libraries.
-    String& first_lib_url = String::Handle();
-    Namespace& import = Namespace::Handle();
+    String& first_lib_url = String::Handle(isolate());
+    Namespace& import = Namespace::Handle(isolate());
     intptr_t num_imports = library_.num_imports();
-    Object& imported_obj = Object::Handle();
-    Library& lib = Library::Handle();
+    Object& imported_obj = Object::Handle(isolate());
+    Library& lib = Library::Handle(isolate());
     for (int i = 0; i < num_imports; i++) {
       import = library_.ImportAt(i);
-      imported_obj = LookupNameInImport(import, name);
+      imported_obj = LookupNameInImport(isolate(), import, name);
       if (!imported_obj.IsNull()) {
         lib ^= import.library();
         if (!first_lib_url.IsNull()) {
           // Found duplicate definition.
           Error& ambiguous_ref_error = Error::Handle();
           if (first_lib_url.raw() == lib.url()) {
             ambiguous_ref_error = FormatErrorMsg(
                 script_, ident_pos, "Error",
                 "ambiguous reference: "
                 "'%s' as library '%s' is imported multiple times",
@@ skipping 75 matching lines @@
   // Lexically unresolved primary identifiers are referenced by their name.
   return new PrimaryNode(ident_pos, ident);
 }
 
 
 RawObject* Parser::ResolveNameInPrefixScope(intptr_t ident_pos,
                                             const LibraryPrefix& prefix,
                                             const String& name,
                                             Error* error) {
   TRACE_PARSER("ResolveNameInPrefixScope");
-  Namespace& import = Namespace::Handle();
-  String& first_lib_url = String::Handle();
-  Object& obj = Object::Handle();
-  Object& resolved_obj = Object::Handle();
-  const Array& imports = Array::Handle(prefix.imports());
+  HANDLESCOPE(isolate());
+  Namespace& import = Namespace::Handle(isolate());
+  String& first_lib_url = String::Handle(isolate());
+  Object& obj = Object::Handle(isolate());
+  Object& resolved_obj = Object::Handle(isolate());
+  const Array& imports = Array::Handle(isolate(), prefix.imports());
+  Library& lib = Library::Handle(isolate());
   for (intptr_t i = 0; i < prefix.num_imports(); i++) {
     import ^= imports.At(i);
-    resolved_obj = LookupNameInImport(import, name);
+    resolved_obj = LookupNameInImport(isolate(), import, name);
     if (!resolved_obj.IsNull()) {
       obj = resolved_obj.raw();
-      const Library& lib = Library::Handle(import.library());
+      lib = import.library();
       if (first_lib_url.IsNull()) {
         first_lib_url = lib.url();
       } else {
         // Found duplicate definition.
         Error& ambiguous_ref_error = Error::Handle();
         if (first_lib_url.raw() == lib.url()) {
           ambiguous_ref_error = FormatErrorMsg(
               script_, ident_pos, "Error",
               "ambiguous reference: '%s.%s' is imported multiple times",
               String::Handle(prefix.name()).ToCString(),
@@ skipping 160 matching lines @@
   } 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)) {
       ErrorMsg(type_name.ident_pos, "using '%s' in this context is invalid",
                type_name.ident->ToCString());
     }
   }
-  Object& type_class = Object::Handle();
+  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();
+    LibraryPrefix& lib_prefix = LibraryPrefix::Handle(isolate());
     if (type_name.lib_prefix != NULL) {
       lib_prefix = type_name.lib_prefix->raw();
     }
     type_class = UnresolvedClass::New(lib_prefix,
                                       *type_name.ident,
                                       type_name.ident_pos);
   }
-  Error& malformed_error = Error::Handle();
+  Error& malformed_error = Error::Handle(isolate());
   AbstractTypeArguments& type_arguments =
-      AbstractTypeArguments::Handle(ParseTypeArguments(&malformed_error,
+      AbstractTypeArguments::Handle(isolate(),
+                                    ParseTypeArguments(&malformed_error,
                                                        finalization));
   if (finalization == ClassFinalizer::kIgnore) {
     return Type::DynamicType();
   }
   AbstractType& type = AbstractType::Handle(
+      isolate(),
       Type::New(type_class, type_arguments, type_name.ident_pos));
   // In production mode, malformed type arguments are mapped to dynamic.
   // In checked mode, a type with malformed type arguments is malformed.
   if (FLAG_enable_type_checks && !malformed_error.IsNull()) {
-    Type& parameterized_type = Type::Handle();
+    Type& parameterized_type = Type::Handle(isolate());
     parameterized_type ^= type.raw();
-    parameterized_type.set_type_class(Class::Handle(Object::dynamic_class()));
+    parameterized_type.set_type_class(
+        Class::Handle(isolate(), Object::dynamic_class()));
     parameterized_type.set_arguments(
         AbstractTypeArguments::null_object());
     parameterized_type.set_malformed_error(malformed_error);
   }
   if (finalization >= ClassFinalizer::kTryResolve) {
     ResolveTypeFromClass(current_class(), finalization, &type);
     if (finalization >= ClassFinalizer::kCanonicalize) {
       type ^= ClassFinalizer::FinalizeType(current_class(), type, finalization);
     }
   }
@@ skipping 44 matching lines @@
                "the element type");
     }
     if (is_const && !element_type.IsInstantiated()) {
       ErrorMsg(type_pos,
                "the type argument of a constant list literal cannot include "
                "a type variable");
     }
   }
   ASSERT(type_arguments.IsNull() || (type_arguments.Length() == 1));
   const Class& array_class = Class::Handle(
-      Isolate::Current()->object_store()->array_class());
+      isolate()->object_store()->array_class());
   Type& type = Type::ZoneHandle(
       Type::New(array_class, 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) {
@@ skipping 904 matching lines @@
     ReturnNode* ret = new 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);
     seq->Add(ret);
 
     Object& result = Object::Handle(Compiler::ExecuteOnce(seq));
     if (result.IsError()) {
       // Propagate the compilation error.
-      Isolate::Current()->long_jump_base()->Jump(1, Error::Cast(result));
+      isolate()->long_jump_base()->Jump(1, Error::Cast(result));
       UNREACHABLE();
     }
     ASSERT(result.IsInstance());
     Instance& value = Instance::ZoneHandle();
     value ^= result.raw();
     if (!value.IsNull()) {
       value ^= value.Canonicalize();
     }
     return value;
   }
@@ skipping 281 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart