Handle metadata with type literals or qualified identifiers.

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/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 837 matching lines @@
 
 
 RawObject* Parser::ParseMetadata(const Class& cls, intptr_t token_pos) {
   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);
+    const Function& func = Function::ZoneHandle(Function::New(
+        Symbols::Empty(),
+        RawFunction::kRegularFunction,
+        true,  // is_static
+        false,  // is_const
+        false,  // is_abstract
+        false,  // is_external
+        cls,
+        token_pos));
+    ParsedFunction* parsed_function = new ParsedFunction(func);
+    Parser parser(script, parsed_function, token_pos);
     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();
 }
 
-
+// ZED
 RawArray* Parser::EvaluateMetadata() {
   if (CurrentToken() != Token::kAT) {
     ErrorMsg("Metadata character '@' expected");
   }
   GrowableObjectArray& meta_values =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   while (CurrentToken() == Token::kAT) {
     ConsumeToken();
     intptr_t expr_pos = TokenPos();
     if (!IsIdentifier()) {
       ExpectIdentifier("identifier expected");
     }
     AstNode* expr = NULL;
     if ((LookaheadToken(1) == Token::kLPAREN) ||
         ((LookaheadToken(1) == Token::kPERIOD) &&
             (LookaheadToken(3) == Token::kLPAREN)) ||
         ((LookaheadToken(1) == Token::kPERIOD) &&
             (LookaheadToken(3) == Token::kPERIOD) &&
             (LookaheadToken(5) == Token::kLPAREN))) {
       expr = ParseNewOperator(Token::kCONST);
     } else {
       expr = ParsePrimary();
+      expr = ParseSelectors(expr, false);

[rmacnak, 2013/10/24 18:45:03]

Expects a valid current_function.

[hausner, 2013/10/24 18:54:05]

You can't use this function here, or you'd accept metadata like @a[0]

     }
     if (expr->EvalConstExpr() == NULL) {
       ErrorMsg(expr_pos, "expression must be a compile-time constant");
     }
     const Instance& val = EvaluateConstExpr(expr);
     meta_values.Add(val);
   }
   return Array::MakeArray(meta_values);
 }
 
@@ skipping 9705 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart