VM: Use a fake parsed function when parsing metadata.

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 256 matching lines @@
 
 // For parsing a compilation unit.
 Parser::Parser(const Script& script, const Library& library, intptr_t 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),
-      parsing_metadata_(false),
       current_member_(NULL),
       allow_function_literals_(true),
       parsed_function_(NULL),
       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),
       last_used_try_index_(0),
       unregister_pending_function_(false) {
   ASSERT(tokens_iterator_.IsValid());
   ASSERT(!library.IsNull());
 }
 
 
 // For parsing a function.
 Parser::Parser(const Script& script,
                ParsedFunction* parsed_function,
                intptr_t 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),
-      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(isolate_, Class::Handle(
           isolate_,
@@ skipping 564 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(isolate, cls.script());
-    const Library& lib = Library::Handle(isolate, cls.library());
-    Parser parser(script, lib, token_pos);
+    // Parsing metadata can involve following paths in the parser that are
+    // normally used for expressions and assume current_function is non-null,
+    // so we create a fake function to use as the current_function rather than
+    // scattering special cases throughout the parser.
+    const Function& fake_function = Function::ZoneHandle(Function::New(
+        Symbols::At(),
+        RawFunction::kRegularFunction,
+        true,  // is_static
+        false,  // is_const
+        false,  // is_abstract
+        false,  // is_external
+        false,  // is_native
+        cls,
+        token_pos));
+    ParsedFunction* parsed_function =
+        new ParsedFunction(isolate, fake_function);
+    Parser parser(script, parsed_function, token_pos);
     parser.set_current_class(cls);
-    parser.set_parsing_metadata(true);
 
     RawObject* metadata = parser.EvaluateMetadata();
     return metadata;
   } else {
     Error& error = Error::Handle(isolate);
     error = isolate->object_store()->sticky_error();
     isolate->object_store()->clear_sticky_error();
     return error.raw();
   }
   UNREACHABLE();
@@ skipping 7580 matching lines @@
   }
   PrimaryNode* primary = node->AsPrimaryNode();
   if (primary->primary().IsString()) {
     if (primary->IsSuper()) {
       return primary;
     }
     // In a static method, evaluation of an unresolved identifier causes a
     // NoSuchMethodError to be thrown.
     // In an instance method, we convert this into a getter call
     // for a field (which may be defined in a subclass.)
-    // 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(isolate()) StaticGetterNode(
               primary->token_pos(),
               NULL,  // No receiver.
               false,  // Not a super getter.
               Class::ZoneHandle(I, current_class().raw()),
               name);
       getter->set_is_deferred(primary->is_deferred_reference());
@@ skipping 13 matching lines @@
       Function::CheckedZoneHandle(primary->primary().raw());
   const String& funcname = String::ZoneHandle(I, func.name());
   if (func.is_static()) {
     // Static function access.
     ClosureNode* closure =
         CreateImplicitClosureNode(func, primary->token_pos(), NULL);
     closure->set_is_deferred(primary->is_deferred_reference());
     return closure;
   } else {
     // Instance function access.
-    if (parsing_metadata_) {
-      ErrorMsg(primary->token_pos(),
-               "cannot access instance method '%s' from metadata",
-               funcname.ToCString());
-    }
     if (current_function().is_static() ||
         current_function().IsInFactoryScope()) {
       ErrorMsg(primary->token_pos(),
                "cannot access instance method '%s' from static method",
                funcname.ToCString());
     }
     AstNode* receiver = LoadReceiver(primary->token_pos());
     return CallGetter(primary->token_pos(), receiver, funcname);
   }
   UNREACHABLE();
@@ skipping 182 matching lines @@
               current_class(), type, ClassFinalizer::kCanonicalize);
           // Type may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
           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.
@@ skipping 189 matching lines @@
   // A found name is treated as accessed and possibly marked as captured.
   const bool kTestOnly = false;
   return current_block_->scope->LookupVariable(ident, kTestOnly);
 }
 
 
 void Parser::CheckInstanceFieldAccess(intptr_t field_pos,
                                       const String& field_name) {
   // Fields are not accessible from a static function, except from a
   // constructor, which is considered as non-static by the compiler.
-  if (parsing_metadata_) {
-    ErrorMsg(field_pos,
-             "cannot access instance field '%s' from metadata",
-             field_name.ToCString());
-  }
   if (current_function().is_static()) {
     ErrorMsg(field_pos,
              "cannot access instance field '%s' from a static function",
              field_name.ToCString());
   }
 }
 
 
 bool Parser::ParsingStaticMember() const {
   if (is_top_level_) {
@@ skipping 167 matching lines @@
       isolate(), ArgumentsDescriptor::New(num_arguments, arguments->names()));
   Object& result = Object::Handle(isolate());
   {
     PAUSETIMERSCOPE(isolate(), time_compilation);
     result = DartEntry::InvokeFunction(
         constructor, arg_values, args_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. Unless we are evaluating metadata, in which case there
-      // is no current function.
-      if (!parsing_metadata_) {
-        current_function().SetIsOptimizable(false);
-      }
+      // not optimizable.
+      current_function().SetIsOptimizable(false);
       if (result.IsUnhandledException()) {
         return result.raw();
       } else {
         isolate()->long_jump_base()->Jump(1, Error::Cast(result));
         UNREACHABLE();
         return Object::null();
       }
   } else {
     if (constructor.IsFactory()) {
       // The factory method returns the allocated object.
@@ skipping 76 matching lines @@
       return true;
     } else if (func.IsStaticFunction()) {
       if (node != NULL) {
         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(isolate()) StaticGetterNode(ident_pos,
                                      receiver,
                                      false,
                                      Class::ZoneHandle(I, cls.raw()),
                                      ident);
       }
@@ skipping 1368 matching lines @@
       primary = ParseNewOperator(Token::kCONST);
     }
   } else if (token == Token::kLT ||
              token == Token::kLBRACK ||
              token == Token::kINDEX ||
              token == Token::kLBRACE) {
     primary = ParseCompoundLiteral();
   } else if (token == Token::kHASH) {
     primary = ParseSymbolLiteral();
   } else if (token == 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(isolate(), current_class().Name()).ToCString());
     }
     if (current_class().IsMixinApplication()) {
       const Type& mixin_type = Type::Handle(isolate(), current_class().mixin());
       if (mixin_type.type_class() == current_function().origin()) {
@@ skipping 394 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart