Added full deferred loading semantic to precompiled/--noopt/eager-loading code

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/ast_transformer.h"
 #include "vm/bootstrap.h"
@@ skipping 20 matching lines @@
 #include "vm/scopes.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 #include "vm/tags.h"
 #include "vm/timer.h"
 #include "vm/zone.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, enable_debug_break, false, "Allow use of break \"message\".");
+DEFINE_FLAG(bool, enable_mirrors, true,
+    "Disable to make importing dart:mirrors an error.");
 DEFINE_FLAG(bool, load_deferred_eagerly, false,
     "Load deferred libraries eagerly.");
 DEFINE_FLAG(bool, trace_parser, false, "Trace parser operations.");
 DEFINE_FLAG(bool, warn_mixin_typedef, true, "Warning on legacy mixin typedef.");
+
+DECLARE_FLAG(bool, lazy_dispatchers);
+DECLARE_FLAG(bool, load_deferred_eagerly);
 DECLARE_FLAG(bool, throw_on_javascript_int_overflow);
 DECLARE_FLAG(bool, warn_on_javascript_compatibility);
-DEFINE_FLAG(bool, enable_mirrors, true,
-    "Disable to make importing dart:mirrors an error.");
-DECLARE_FLAG(bool, lazy_dispatchers);
 
 // Quick access to the current isolate and zone.
 #define I (isolate())
 #define Z (zone())
 
 
 #if defined(DEBUG)
 class TraceParser : public ValueObject {
  public:
   TraceParser(intptr_t token_pos,
@@ skipping 105 matching lines @@
 
 void ParsedFunction::SetRegExpCompileData(
     RegExpCompileData* regexp_compile_data) {
   ASSERT(regexp_compile_data_ == NULL);
   ASSERT(regexp_compile_data != NULL);
   regexp_compile_data_ = regexp_compile_data;
 }
 
 
 void ParsedFunction::AddDeferredPrefix(const LibraryPrefix& prefix) {
+  // 'deferred_prefixes_' are used to invalidate code, but no invalidation is
+  // needed if --load_deferred_eagerly.
+  ASSERT(!FLAG_load_deferred_eagerly);
   ASSERT(prefix.is_deferred_load());
   ASSERT(!prefix.is_loaded());
   for (intptr_t i = 0; i < deferred_prefixes_->length(); i++) {
     if ((*deferred_prefixes_)[i]->raw() == prefix.raw()) {
       return;
     }
   }
   deferred_prefixes_->Add(&LibraryPrefix::ZoneHandle(Z, prefix.raw()));
 }
 
@@ skipping 9846 matching lines @@
     SequenceNode* sequence = new SequenceNode(sequence_pos, scope);
     if (node != NULL) {
       sequence->Add(node);
     }
     return sequence;
   }
   return node->AsSequenceNode();
 }
 
 
-AstNode* Parser::ThrowTypeError(intptr_t type_pos, const AbstractType& type) {
+// Call _throwNewIfNotLoaded if prefix is not NULL, otherwise call _throwNew.
+AstNode* Parser::ThrowTypeError(intptr_t type_pos, const AbstractType& type,
+                                LibraryPrefix* prefix) {
   ArgumentListNode* arguments = new(Z) ArgumentListNode(type_pos);
+
+  String& method_name = String::Handle(Z);
+  if (prefix == NULL) {
+    method_name = Library::PrivateCoreLibName(Symbols::ThrowNew()).raw();
+  } else {
+    arguments->Add(new(Z) LiteralNode(type_pos, *prefix));
+    method_name = Library::PrivateCoreLibName(
+        Symbols::ThrowNewIfNotLoaded()).raw();
+  }
   // Location argument.
   arguments->Add(new(Z) LiteralNode(
       type_pos, Integer::ZoneHandle(Z, Integer::New(type_pos))));
   // Src value argument.
   arguments->Add(new(Z) LiteralNode(type_pos, Instance::ZoneHandle(Z)));
   // Dst type name argument.
   arguments->Add(new(Z) LiteralNode(type_pos, Symbols::Malformed()));
   // Dst name argument.
   arguments->Add(new(Z) LiteralNode(type_pos, Symbols::Empty()));
   // Malformed type error or malbounded type error.
   const Error& error = Error::Handle(Z, type.error());
   ASSERT(!error.IsNull());
   arguments->Add(new(Z) LiteralNode(type_pos, String::ZoneHandle(Z,
       Symbols::New(error.ToErrorCString()))));
-  return MakeStaticCall(Symbols::TypeError(),
-                        Library::PrivateCoreLibName(Symbols::ThrowNew()),
-                        arguments);
+  return MakeStaticCall(Symbols::TypeError(), method_name, arguments);
 }
 
 
+// Call _throwNewIfNotLoaded if prefix is not NULL, otherwise call _throwNew.
 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,
-                                        const Function* func) {
+                                        const Function* func,
+                                        const LibraryPrefix* prefix) {
   ArgumentListNode* arguments = new(Z) ArgumentListNode(call_pos);
+
+  String& method_name = String::Handle(Z);
+  if (prefix == NULL) {
+    method_name = Library::PrivateCoreLibName(Symbols::ThrowNew()).raw();
+  } else {
+    arguments->Add(new(Z) LiteralNode(call_pos, *prefix));
+    method_name = Library::PrivateCoreLibName(
+        Symbols::ThrowNewIfNotLoaded()).raw();
+  }
   // Object receiver.
   // If the function is external and dynamic, pass the actual receiver,
   // otherwise, pass a class literal of the unresolved method's owner.
   if ((func != NULL) && !func->IsNull() &&
       func->is_external() && !func->is_static()) {
     arguments->Add(LoadReceiver(func->token_pos()));
   } else {
     Type& type = Type::ZoneHandle(Z,
         Type::New(cls, TypeArguments::Handle(Z), call_pos, Heap::kOld));
     type ^= ClassFinalizer::FinalizeType(
@@ skipping 52 matching lines @@
     // 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(Z, function.UserVisibleFormalParameters()));
   }
   arguments->Add(new(Z) LiteralNode(call_pos, array));
 
-  return MakeStaticCall(Symbols::NoSuchMethodError(),
-                        Library::PrivateCoreLibName(Symbols::ThrowNew()),
-                        arguments);
+  return MakeStaticCall(Symbols::NoSuchMethodError(), method_name, arguments);
 }
 
 
 AstNode* Parser::ParseBinaryExpr(int min_preced) {
   TRACE_PARSER("ParseBinaryExpr");
   ASSERT(min_preced >= Token::Precedence(Token::kIFNULL));
   AstNode* left_operand = ParseUnaryExpr();
   if (left_operand->IsPrimaryNode() &&
       (left_operand->AsPrimaryNode()->IsSuper())) {
     ReportError(left_operand->token_pos(), "illegal use of 'super'");
@@ skipping 1653 matching lines @@
   if (ident.CharAt(0) == Library::kPrivateIdentifierStart) {
     // Private names are not exported by libraries. The name mangling
     // of private names with a library-specific suffix usually ensures
     // that _x in library A is not found when looked up from library B.
     // In the pathological case where a library imports itself with
     // a prefix, the name mangling would not help in hiding the private
     // name, so we need to explicitly reject private names here.
     return NULL;
   }
   Object& obj = Object::Handle(Z);
-  if (prefix.is_loaded()) {
+  if (prefix.is_loaded() || FLAG_load_deferred_eagerly) {
     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();
@@ skipping 115 matching lines @@
           current_class(), type, ClassFinalizer::kCanonicalize);
       // Type may be malbounded, but not malformed.
       ASSERT(!type.IsMalformed());
       resolved = new(Z) 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,
     bool allow_deferred_type,
     bool consume_unresolved_prefix) {
+  LibraryPrefix& prefix = LibraryPrefix::Handle(Z);
+  return ParseType(finalization, allow_deferred_type,
+                         consume_unresolved_prefix, &prefix);
+}
+
+// Parses type = [ident "."] ident ["<" type { "," type } ">"], then resolve and
+// finalize it according to the given type finalization mode. Returns prefix.
+RawAbstractType* Parser::ParseType(
+    ClassFinalizer::FinalizationKind finalization,
+    bool allow_deferred_type,
+    bool consume_unresolved_prefix,
+    LibraryPrefix* prefix) {
   TRACE_PARSER("ParseType");
   CheckToken(Token::kIDENT, "type name expected");
   intptr_t ident_pos = TokenPos();
-  LibraryPrefix& prefix = LibraryPrefix::Handle(Z);
   String& type_name = String::Handle(Z);
 
   if (finalization == ClassFinalizer::kIgnore) {
     if (!is_top_level_ && (current_block_ != NULL)) {
       // Add the library prefix or type class name to the list of referenced
       // names of this scope, even if the type is ignored.
       current_block_->scope->AddReferencedName(TokenPos(), *CurrentLiteral());
     }
     SkipQualIdent();
   } else {
-    prefix = ParsePrefix();
+    *prefix = ParsePrefix();
     type_name = CurrentLiteral()->raw();
     ConsumeToken();
 
     // Check whether we have a malformed qualified type name if the caller
     // requests to consume unresolved prefix names:
     // If we didn't see a valid prefix but the identifier is followed by
     // a period and another identifier, consume the qualified identifier
     // and create a malformed type.
     if (consume_unresolved_prefix &&
-        prefix.IsNull() &&
+        prefix->IsNull() &&
         (CurrentToken() == Token::kPERIOD) &&
         (Token::IsIdentifier(LookaheadToken(1)))) {
       if (!is_top_level_ && (current_block_ != NULL)) {
         // Add the unresolved prefix name to the list of referenced
         // names of this scope.
         current_block_->scope->AddReferencedName(TokenPos(), type_name);
       }
       ConsumeToken();  // Period token.
       ASSERT(IsIdentifier());
       String& qualified_name = String::Handle(Z, type_name.raw());
       qualified_name = String::Concat(qualified_name, Symbols::Dot());
       qualified_name = String::Concat(qualified_name, *CurrentLiteral());
       ConsumeToken();
       // The type is malformed. Skip over its type arguments.
       ParseTypeArguments(ClassFinalizer::kIgnore);
       return ClassFinalizer::NewFinalizedMalformedType(
           Error::Handle(Z),  // No previous error.
           script_,
           ident_pos,
           "qualified name '%s' does not refer to a type",
           qualified_name.ToCString());
     }
 
     // If parsing inside a local scope, check whether the type name
     // is shadowed by a local declaration.
     if (!is_top_level_ &&
-        (prefix.IsNull()) &&
+        (prefix->IsNull()) &&
         ResolveIdentInLocalScope(ident_pos, type_name, NULL)) {
       // The type is malformed. Skip over its type arguments.
       ParseTypeArguments(ClassFinalizer::kIgnore);
       return ClassFinalizer::NewFinalizedMalformedType(
           Error::Handle(Z),  // No previous error.
           script_,
           ident_pos,
           "using '%s' in this context is invalid",
           type_name.ToCString());
     }
-    if (!prefix.IsNull() && prefix.is_deferred_load()) {
+    if (!FLAG_load_deferred_eagerly &&
+        !prefix->IsNull() && prefix->is_deferred_load()) {
       // If deferred prefixes are allowed but it is not yet loaded,
       // remember that this function depends on the prefix.
-      if (allow_deferred_type && !prefix.is_loaded()) {
+      if (allow_deferred_type && !prefix->is_loaded()) {
         if (parsed_function() != NULL) {
-          parsed_function()->AddDeferredPrefix(prefix);
+          parsed_function()->AddDeferredPrefix(*prefix);
         }
       }
       // If the deferred prefixes are not allowed, or if the prefix is not yet
       // loaded when finalization is requested, return a malformed type.
       // Otherwise, handle resolution below, as needed.
       if (!allow_deferred_type ||
-          (!prefix.is_loaded()
+          (!prefix->is_loaded()
               && (finalization > ClassFinalizer::kResolveTypeParameters))) {
         ParseTypeArguments(ClassFinalizer::kIgnore);
         return ClassFinalizer::NewFinalizedMalformedType(
             Error::Handle(Z),  // No previous error.
             script_,
             ident_pos,
-            !prefix.is_loaded()
+            !prefix->is_loaded()
                 ? "deferred type '%s.%s' is not yet loaded"
                 : "using deferred type '%s.%s' is invalid",
-            String::Handle(Z, prefix.name()).ToCString(),
+            String::Handle(Z, prefix->name()).ToCString(),
             type_name.ToCString());
       }
     }
   }
   Object& type_class = Object::Handle(Z);
   // Leave type_class as null if type finalization mode is kIgnore.
   if (finalization != ClassFinalizer::kIgnore) {
-    type_class = UnresolvedClass::New(prefix, type_name, ident_pos);
+    type_class = UnresolvedClass::New(*prefix, type_name, ident_pos);
   }
   TypeArguments& type_arguments = TypeArguments::Handle(
       Z, ParseTypeArguments(finalization));
   if (finalization == ClassFinalizer::kIgnore) {
     return Type::DynamicType();
   }
   AbstractType& type = AbstractType::Handle(
       Z, Type::New(type_class, type_arguments, ident_pos));
   if (finalization >= ClassFinalizer::kResolveTypeParameters) {
     ResolveTypeFromClass(current_class(), finalization, &type);
@@ skipping 528 matching lines @@
   ASSERT((op_kind == Token::kNEW) || (op_kind == Token::kCONST));
   bool is_const = (op_kind == Token::kCONST);
   if (!IsIdentifier()) {
     ReportError("type name expected");
   }
   intptr_t type_pos = TokenPos();
   // Can't allocate const objects of a deferred type.
   const bool allow_deferred_type = !is_const;
   const bool consume_unresolved_prefix = (LookaheadToken(3) == Token::kLT) ||
                                          (LookaheadToken(3) == Token::kPERIOD);
+  LibraryPrefix& prefix = LibraryPrefix::ZoneHandle(Z);
   AbstractType& type = AbstractType::Handle(Z,
       ParseType(ClassFinalizer::kCanonicalizeWellFormed,
                 allow_deferred_type,
-                consume_unresolved_prefix));
+                consume_unresolved_prefix,
+                &prefix));
+  if (FLAG_load_deferred_eagerly &&
+      !prefix.IsNull() && prefix.is_deferred_load() && !prefix.is_loaded()) {
+    // Add runtime check.
+    Type& malformed_type = Type::Handle(Z);
+    malformed_type = ClassFinalizer::NewFinalizedMalformedType(
+        Error::Handle(Z),  // No previous error.
+        script_,
+        type_pos,
+        "deferred type '%s.%s' is not yet loaded",
+        String::Handle(Z, prefix.name()).ToCString(),
+        String::Handle(type.Name()).ToCString());
+    // Note: Adding a statement to current block is a hack, parsing an
+    // expression should have no side-effect.
+    current_block_->statements->Add(
+        ThrowTypeError(type_pos, malformed_type, &prefix));
+  }
   // 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(Z),  // No previous error.
         script_,
         type_pos,
         "%s'%s' cannot be instantiated",
         type.IsTypeParameter() ? "type parameter " : "",
@@ skipping 460 matching lines @@
               CurrentToken() == Token::kLPAREN ?
                   InvocationMirror::kMethod : InvocationMirror::kGetter;
           primary = ThrowNoSuchMethodError(qual_ident_pos,
                                            current_class(),
                                            qualified_name,
                                            NULL,  // No arguments.
                                            InvocationMirror::kTopLevel,
                                            call_type,
                                            NULL);  // No existing function.
         }
+      } else if (FLAG_load_deferred_eagerly && prefix.is_deferred_load()) {
+        // primary != NULL.
+        String& qualified_name = String::ZoneHandle(Z, prefix.name());
+        qualified_name = String::Concat(qualified_name, Symbols::Dot());
+        qualified_name = String::Concat(qualified_name, ident);
+        qualified_name = Symbols::New(qualified_name);
+        InvocationMirror::Type call_type =
+            CurrentToken() == Token::kLPAREN ?
+                InvocationMirror::kMethod : InvocationMirror::kGetter;
+        // Note: Adding a statement to current block is a hack, parsing an
+        // espression should have no side-effect.
+        current_block_->statements->Add(ThrowNoSuchMethodError(
+                                            qual_ident_pos,
+                                            current_class(),
+                                            qualified_name,
+                                            NULL,  // No arguments.
+                                            InvocationMirror::kTopLevel,
+                                            call_type,
+                                            NULL,  // No existing function.
+                                            &prefix));
       }
     }
     ASSERT(primary != NULL);
   } else if (token == Token::kTHIS) {
     LocalVariable* local = LookupLocalScope(Symbols::This());
     if (local == NULL) {
       ReportError("receiver 'this' is not in scope");
     }
     primary = new(Z) LoadLocalNode(TokenPos(), local);
     ConsumeToken();
@@ skipping 460 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart