- Landing https://codereview.chromium.org/293963008/

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 363 matching lines @@
   tokens_iterator_.SetCurrentPosition(position);
   token_kind_ = Token::kILLEGAL;
 }
 
 
 void Parser::ParseCompilationUnit(const Library& library,
                                   const Script& script) {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate->long_jump_base()->IsSafeToJump());
   TimerScope timer(FLAG_compiler_stats, &CompilerStats::parser_timer);
-  VMTagScope tagScope(isolate, VMTag::kCompileTagId);
+  VMTagScope tagScope(isolate, VMTag::kCompileTopLevelTagId);
   Parser parser(script, library, 0);
   parser.ParseTopLevel();
 }
 
 
 Token::Kind Parser::CurrentToken() {
   if (token_kind_ == Token::kILLEGAL) {
     token_kind_ = tokens_iterator_.CurrentTokenKind();
     if (token_kind_ == Token::kERROR) {
       ErrorMsg(TokenPos(), "%s", CurrentLiteral()->ToCString());
@@ skipping 328 matching lines @@
     return HasReturnNode(seq->NodeAt(seq->length() - 1)->AsSequenceNode());
   } else {
     return seq->NodeAt(seq->length() - 1)->IsReturnNode();
   }
 }
 
 
 void Parser::ParseClass(const Class& cls) {
   if (!cls.is_synthesized_class()) {
     Isolate* isolate = Isolate::Current();
-    VMTagScope tagScope(isolate, VMTag::kCompileTagId);
     TimerScope timer(FLAG_compiler_stats, &CompilerStats::parser_timer);
     ASSERT(isolate->long_jump_base()->IsSafeToJump());
     const Script& script = Script::Handle(isolate, cls.script());
     const Library& lib = Library::Handle(isolate, cls.library());
     Parser parser(script, lib, cls.token_pos());
     parser.ParseClassDefinition(cls);
   }
 }
 
 
@@ skipping 38 matching lines @@
     isolate->object_store()->clear_sticky_error();
     return error.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 
 void Parser::ParseFunction(ParsedFunction* parsed_function) {
   Isolate* isolate = Isolate::Current();
-  VMTagScope tagScope(isolate, VMTag::kCompileTagId);
   TimerScope timer(FLAG_compiler_stats, &CompilerStats::parser_timer);
   CompilerStats::num_functions_compiled++;
   ASSERT(isolate->long_jump_base()->IsSafeToJump());
   ASSERT(parsed_function != NULL);
   const Function& func = parsed_function->function();
   const Script& script = Script::Handle(isolate, func.script());
   Parser parser(script, parsed_function, func.token_pos());
   SequenceNode* node_sequence = NULL;
   Array& default_parameter_values = Array::ZoneHandle(isolate, Array::null());
   switch (func.kind()) {
@@ skipping 7967 matching lines @@
                                   ClassFinalizer::FinalizationKind finalization,
                                   AbstractType* type) {
   ASSERT(finalization >= ClassFinalizer::kResolveTypeParameters);
   ASSERT(type != NULL);
   if (type->IsResolved()) {
     return;
   }
   // Resolve class.
   if (!type->HasResolvedTypeClass()) {
     const UnresolvedClass& unresolved_class =
-        UnresolvedClass::Handle(type->unresolved_class());
+        UnresolvedClass::Handle(isolate(), type->unresolved_class());
     const String& unresolved_class_name =
-        String::Handle(unresolved_class.ident());
-    Class& resolved_type_class = Class::Handle();
+        String::Handle(isolate(), unresolved_class.ident());
+    Class& resolved_type_class = Class::Handle(isolate());
     if (unresolved_class.library_prefix() == LibraryPrefix::null()) {
       if (!scope_class.IsNull()) {
         // First check if the type is a type parameter of the given scope class.
         const TypeParameter& type_parameter = TypeParameter::Handle(
+            isolate(),
             scope_class.LookupTypeParameter(unresolved_class_name));
         if (!type_parameter.IsNull()) {
           // A type parameter is considered to be a malformed type when
           // referenced by a static member.
           if (ParsingStaticMember()) {
             ASSERT(scope_class.raw() == current_class().raw());
             *type = ClassFinalizer::NewFinalizedMalformedType(
-                Error::Handle(),  // No previous error.
+                Error::Handle(isolate()),  // No previous error.
                 script_,
                 type->token_pos(),
                 "type parameter '%s' cannot be referenced "
                 "from static member",
-                String::Handle(type_parameter.name()).ToCString());
+                String::Handle(isolate(), type_parameter.name()).ToCString());
             return;
           }
           // A type parameter cannot be parameterized, so make the type
           // malformed if type arguments have previously been parsed.
-          if (!TypeArguments::Handle(type->arguments()).IsNull()) {
+          if (!TypeArguments::Handle(isolate(), type->arguments()).IsNull()) {
             *type = ClassFinalizer::NewFinalizedMalformedType(
-                Error::Handle(),  // No previous error.
+                Error::Handle(isolate()),  // No previous error.
                 script_,
                 type_parameter.token_pos(),
                 "type parameter '%s' cannot be parameterized",
-                String::Handle(type_parameter.name()).ToCString());
+                String::Handle(isolate(), type_parameter.name()).ToCString());
             return;
           }
           *type = type_parameter.raw();
           return;
         }
       }
       // The referenced class may not have been parsed yet. It would be wrong
       // to resolve it too early to an imported class of the same name.
       if (finalization > ClassFinalizer::kResolveTypeParameters) {
         // Resolve classname in the scope of the current library.
         resolved_type_class = ResolveClassInCurrentLibraryScope(
             unresolved_class_name);
       }
     } else {
       LibraryPrefix& lib_prefix =
-          LibraryPrefix::Handle(unresolved_class.library_prefix());
+          LibraryPrefix::Handle(isolate(), unresolved_class.library_prefix());
       // Resolve class name in the scope of the library prefix.
       resolved_type_class =
           ResolveClassInPrefixScope(lib_prefix, unresolved_class_name);
     }
     // At this point, we can only have a parameterized_type.
     const Type& parameterized_type = Type::Cast(*type);
     if (!resolved_type_class.IsNull()) {
       // Replace unresolved class with resolved type class.
       parameterized_type.set_type_class(resolved_type_class);
     } else if (finalization >= ClassFinalizer::kCanonicalize) {
       ClassFinalizer::FinalizeMalformedType(
-          Error::Handle(),  // No previous error.
+          Error::Handle(isolate()),  // No previous error.
           script_,
           parameterized_type,
           "type '%s' is not loaded",
-          String::Handle(parameterized_type.UserVisibleName()).ToCString());
+          String::Handle(isolate(),
+                         parameterized_type.UserVisibleName()).ToCString());
       return;
     }
   }
   // Resolve type arguments, if any.
-  const TypeArguments& arguments = TypeArguments::Handle(type->arguments());
-      TypeArguments::Handle(type->arguments());
+  const TypeArguments& arguments = TypeArguments::Handle(isolate(),
+                                                         type->arguments());
+      TypeArguments::Handle(isolate(), type->arguments());
   if (!arguments.IsNull()) {
     const intptr_t num_arguments = arguments.Length();
     for (intptr_t i = 0; i < num_arguments; i++) {
-      AbstractType& type_argument = AbstractType::Handle(arguments.TypeAt(i));
+      AbstractType& type_argument = AbstractType::Handle(isolate(),
+                                                         arguments.TypeAt(i));
       ResolveTypeFromClass(scope_class, finalization, &type_argument);
       arguments.SetTypeAt(i, type_argument);
     }
   }
 }
 
 
 LocalVariable* Parser::LookupLocalScope(const String& ident) {
   if (current_block_ == NULL) {
     return NULL;
@@ skipping 2085 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart