Handle undefined field/getter access from arguments to const constructors in metadata, and related …

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 226 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(Class::Handle(
           isolate_,
@@ skipping 569 matching lines @@
   Isolate* isolate = Isolate::Current();
   StackZone zone(isolate);
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   isolate->set_long_jump_base(&jump);
   if (setjmp(*jump.Set()) == 0) {
     const Script& script = Script::Handle(cls.script());
     const Library& lib = Library::Handle(cls.library());
     Parser parser(script, lib, token_pos);
     parser.set_current_class(cls);
+    parser.set_parsing_metadata(true);
     return parser.EvaluateMetadata();
   } else {
     Error& error = Error::Handle();
     error = isolate->object_store()->sticky_error();
     isolate->object_store()->clear_sticky_error();
     isolate->set_long_jump_base(base);
     return error.raw();
   }
   UNREACHABLE();
   return Object::null();
@@ skipping 7364 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()) {
       return new StaticGetterNode(primary->token_pos(),
                                   NULL,  // No receiver.
                                   false,  // Not a super getter.
                                   Class::ZoneHandle(current_class().raw()),
                                   name);
     } else {
       AstNode* receiver = LoadReceiver(primary->token_pos());
       return CallGetter(node->token_pos(), receiver, name);
     }
   }
   return primary;
 }
 
 
 AstNode* Parser::LoadClosure(PrimaryNode* primary) {
   ASSERT(primary->primary().IsFunction());
   AstNode* closure = NULL;
   const Function& func =
       Function::CheckedZoneHandle(primary->primary().raw());
   const String& funcname = String::ZoneHandle(func.name());
   if (func.is_static()) {
     // Static function access.
     closure = CreateImplicitClosureNode(func, primary->token_pos(), NULL);
   } 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());
     closure = CallGetter(primary->token_pos(), receiver, funcname);
   }
   return closure;
@@ skipping 362 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 2007 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart