Delay Class parsing until the class is actually used.

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 243 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TryBlocks);
 };
 
 
 void Parser::TryBlocks::AddNodeForFinallyInlining(AstNode* node) {
   inlined_finally_nodes_.Add(node);
 }
 
 
 // For parsing a compilation unit.
-Parser::Parser(const Script& script, const Library& library)
+Parser::Parser(const Script& script, const Library& library, intptr_t token_pos)
     : script_(Script::Handle(script.raw())),
-      tokens_iterator_(TokenStream::Handle(script.tokens()), 0),
+      tokens_iterator_(TokenStream::Handle(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()),
       current_class_(Class::Handle()),
       library_(Library::Handle(library.raw())),
       try_blocks_list_(NULL) {
@@ skipping 68 matching lines @@
   }
   tokens_iterator_.SetCurrentPosition(position);
   token_kind_ = Token::kILLEGAL;
 }
 
 
 void Parser::ParseCompilationUnit(const Library& library,
                                   const Script& script) {
   ASSERT(Isolate::Current()->long_jump_base()->IsSafeToJump());
   TimerScope timer(FLAG_compiler_stats, &CompilerStats::parser_timer);
-  Parser parser(script, library);
+  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 364 matching lines @@
     return false;
   } else if ((seq->length()) == 1 &&
              (seq->NodeAt(seq->length() - 1)->IsSequenceNode())) {
     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()) {
+    TimerScope timer(FLAG_compiler_stats, &CompilerStats::parser_timer);
+    Isolate* isolate = Isolate::Current();
+    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);
+  }
+}
+
+
 void Parser::ParseFunction(ParsedFunction* parsed_function) {
   TimerScope timer(FLAG_compiler_stats, &CompilerStats::parser_timer);
   Isolate* isolate = Isolate::Current();
   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());
@@ skipping 2444 matching lines @@
     }
     ParseFieldDefinition(members, &member);
   } else {
     UnexpectedToken();
   }
   current_member_ = NULL;
   members->AddMember(member);
 }
 
 
-void Parser::ParseClassDefinition(const GrowableObjectArray& pending_classes) {
-  TRACE_PARSER("ParseClassDefinition");
+void Parser::ParseClassDeclaration(const GrowableObjectArray& pending_classes) {
+  TRACE_PARSER("ParseClassDeclaration");
   bool is_patch = false;
   bool is_abstract = false;
   if (is_patch_source() &&
       (CurrentToken() == Token::kIDENT) &&
       CurrentLiteral()->Equals("patch")) {
     ConsumeToken();
     is_patch = true;
   } else if (CurrentToken() == Token::kABSTRACT) {
     is_abstract = true;
     ConsumeToken();
   }
-  const intptr_t class_pos = TokenPos();
   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));
   if (obj.IsNull()) {
@@ skipping 22 matching lines @@
     } else {
       // Not patching a class, but it has been found. This must be one of the
       // pre-registered classes from object.cc or a duplicate definition.
       if (!(cls.is_prefinalized() ||
             RawObject::IsTypedDataViewClassId(cls.id()))) {
         ErrorMsg(classname_pos, "class '%s' is already defined",
                  class_name.ToCString());
       }
       // Pre-registered classes need their scripts connected at this time.
       cls.set_script(script_);
+      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());
@@ skipping 51 matching lines @@
     // No extends clause: implicitly extend Object.
     super_type = Type::ObjectType();
   }
   ASSERT(!super_type.IsNull());
   cls.set_super_type(super_type);
 
   if (CurrentToken() == Token::kIMPLEMENTS) {
     ParseInterfaceList(cls);
   }
 
+  if (is_abstract) {
+    cls.set_is_abstract();
+  }
+  if (is_patch) {
+    // Apply the changes to the patched class looked up above.
+    ASSERT(obj.raw() == library_.LookupLocalObject(class_name));
+    // The patched class must not be finalized yet.
+    const Class& orig_class = Class::Cast(obj);
+    ASSERT(!orig_class.is_finalized());
+    orig_class.set_patch_class(cls);
+    cls.set_is_patch();
+  }
+  pending_classes.Add(cls, Heap::kOld);
+
+  if (CurrentToken() != Token::kLBRACE) {
+    ErrorMsg("{ expected");
+  }
+  SkipBlock();
+}
+
+
+void Parser::ParseClassDefinition(const Class& cls) {
+  TRACE_PARSER("ParseClassDefinition");
+  set_current_class(cls);
+  is_top_level_ = true;
+  String& class_name = String::Handle(cls.Name());
+  const intptr_t class_pos = TokenPos();
+  ClassDesc members(cls, class_name, false, class_pos);
+  while (CurrentToken() != Token::kLBRACE) {
+    ConsumeToken();
+  }
   ExpectToken(Token::kLBRACE);
-  ClassDesc members(cls, class_name, false, class_pos);
   while (CurrentToken() != Token::kRBRACE) {
     SkipMetadata();
     ParseClassMemberDefinition(&members);
   }
   ExpectToken(Token::kRBRACE);
 
-  if (is_abstract) {
-    cls.set_is_abstract();
-  }
-
   CheckConstructors(&members);
 
   // Need to compute this here since MakeArray() will clear the
   // functions array in members.
   const bool need_implicit_constructor =
-      !members.has_constructor() && !is_patch;
+      !members.has_constructor() && !cls.is_patch();
 
   Array& array = Array::Handle();
   array = Array::MakeArray(members.fields());
   cls.SetFields(array);
 
   // Creating a new array for functions marks the class as parsed.
   array = 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 (!is_patch) {
-    pending_classes.Add(cls, Heap::kOld);
-  } else {
+  if (cls.is_patch()) {
     // Apply the changes to the patched class looked up above.
-    ASSERT(obj.raw() == library_.LookupLocalObject(class_name));
+    Object& obj = Object::Handle(library_.LookupLocalObject(class_name));
     // The patched class must not be finalized yet.
-    ASSERT(!Class::Cast(obj).is_finalized());
-    const char* err_msg = Class::Cast(obj).ApplyPatch(cls);
+    const Class& orig_class = Class::Cast(obj);
+    ASSERT(!orig_class.is_finalized());
+    const char* err_msg = orig_class.ApplyPatch(cls);
     if (err_msg != NULL) {
-      ErrorMsg(classname_pos, "applying patch failed with '%s'", err_msg);
+      ErrorMsg(class_pos, "applying patch failed with '%s'", err_msg);
     }
   }
 }
 
 
 // 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());
@@ skipping 104 matching lines @@
   }
 
   if (CurrentToken() != Token::kWITH) {
     ErrorMsg("mixin application 'with Type' expected");
   }
   type = ParseMixins(type);
 
   // TODO(hausner): treat the mixin application as an alias, not as a base
   // class whose super class is the mixin application!
   mixin_application.set_super_type(type);
+  mixin_application.set_is_synthesized_class();
 
   AddImplicitConstructor(mixin_application);
   if (CurrentToken() == Token::kIMPLEMENTS) {
     ParseInterfaceList(mixin_application);
   }
   ExpectSemicolon();
   pending_classes.Add(mixin_application, Heap::kOld);
 }
 
 
@@ skipping 388 matching lines @@
     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()));
     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.
     mixin_application_interfaces = Array::New(1);
     mixin_application_interfaces.SetAt(0, mixin_type);
     mixin_application.set_interfaces(mixin_application_interfaces);
 
     // For the type arguments of the mixin application type, we need
     // a copy of the type arguments to the mixin type. The simplest way
     // to get the copy is to rewind the parser, parse the mixin type
@@ skipping 564 matching lines @@
   if (is_library_source() || is_patch_source()) {
     ParseLibraryDefinition();
   } else if (is_part_source()) {
     ParsePartHeader();
   }
 
   while (true) {
     set_current_class(Class::Handle());  // No current class.
     SkipMetadata();
     if (CurrentToken() == Token::kCLASS) {
-      ParseClassDefinition(pending_classes);
+      ParseClassDeclaration(pending_classes);
     } else if ((CurrentToken() == Token::kTYPEDEF) &&
                (LookaheadToken(1) != Token::kLPAREN)) {
       set_current_class(toplevel_class);
       ParseTypedef(pending_classes);
     } else if ((CurrentToken() == Token::kABSTRACT) &&
         (LookaheadToken(1) == Token::kCLASS)) {
-      ParseClassDefinition(pending_classes);
+      ParseClassDeclaration(pending_classes);
     } else if (is_patch_source() && IsLiteral("patch") &&
                (LookaheadToken(1) == Token::kCLASS)) {
-      ParseClassDefinition(pending_classes);
+      ParseClassDeclaration(pending_classes);
     } else {
       set_current_class(toplevel_class);
       if (IsVariableDeclaration()) {
         ParseTopLevelVariable(&top_level);
       } else if (IsFunctionDeclaration()) {
         ParseTopLevelFunction(&top_level);
       } else if (IsTopLevelAccessor()) {
         ParseTopLevelAccessor(&top_level);
       } else if (CurrentToken() == Token::kEOS) {
         break;
@@ skipping 3505 matching lines @@
 
 
 const Type* Parser::ReceiverType(intptr_t type_pos) const {
   ASSERT(!current_class().IsNull());
   TypeArguments& type_arguments = TypeArguments::Handle();
   if (current_class().NumTypeParameters() > 0) {
     type_arguments = current_class().type_parameters();
   }
   Type& type = Type::ZoneHandle(
       Type::New(current_class(), type_arguments, type_pos));
-  if (!is_top_level_) {
+  if (!is_top_level_ || current_class().is_type_finalized()) {
     type ^= ClassFinalizer::FinalizeType(
         current_class(), type, ClassFinalizer::kCanonicalizeWellFormed);
   }
   return &type;
 }
 
 
 bool Parser::IsInstantiatorRequired() const {
   ASSERT(!current_function().IsNull());
   if (current_function().is_static() &&
@@ skipping 1918 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart