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 859 matching lines @@
     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 = ParseMemberSelection(expr);
     }
     if (expr->EvalConstExpr() == NULL) {
       ErrorMsg(expr_pos, "expression must be a compile-time constant");
     }
     const Instance& val = EvaluateConstExpr(expr_pos, expr);
     meta_values.Add(val);
   }
   return Array::MakeArray(meta_values);
 }
 
@@ skipping 7522 matching lines @@
       }
       // Done parsing selectors.
       return left;
     }
     ASSERT(selector != NULL);
     left = selector;
   }
 }
 
 
+AstNode* Parser::ParseMemberSelection(AstNode* primary) {
+  AstNode* left = primary;
+
+  if (CurrentToken() == Token::kPERIOD) {
+    ConsumeToken();
+    if (left->IsPrimaryNode()) {
+      if (left->AsPrimaryNode()->primary().IsFunction()) {

[hausner, 2013/10/25 20:24:25]

I still don't understand why you handle this case. A selector in metadata can
only refer to a static const field of a class, nothing else.

+        left = LoadClosure(left->AsPrimaryNode());
+      } else {
+        // Super field access handled in ParseSuperFieldAccess(),
+        // super calls handled in ParseSuperCall().
+        ASSERT(!left->AsPrimaryNode()->IsSuper());
+        left = LoadFieldIfUnresolved(left);
+      }
+    }
+    const intptr_t ident_pos = TokenPos();
+    String* ident = ExpectIdentifier("identifier expected");
+
+    Class& cls = Class::Handle();
+    if (left->IsPrimaryNode()) {
+      PrimaryNode* primary_node = left->AsPrimaryNode();
+      if (primary_node->primary().IsClass()) {
+        // If the primary node referred to a class we are loading a
+        // qualified static field.
+        cls ^= primary_node->primary().raw();
+      }
+    }
+    if (cls.IsNull()) {
+      // Instance field access.
+      return CallGetter(ident_pos, left, *ident);
+    } else {
+      // Static field access.
+      return ParseStaticFieldAccess(cls, *ident, ident_pos, true);
+    }
+  }
+
+  // No selector to parse.
+  if (left->IsPrimaryNode()) {
+    PrimaryNode* primary = left->AsPrimaryNode();
+    if (primary->primary().IsFunction()) {

[hausner, 2013/10/25 20:24:25]

ditto

+      // Treat as implicit closure.
+      left = LoadClosure(primary);
+    } else if (primary->primary().IsClass()) {
+      const Class& type_class = Class::Cast(primary->primary());
+      AbstractType& type = Type::ZoneHandle(
+          Type::New(type_class, TypeArguments::Handle(),
+                    primary->token_pos(), Heap::kOld));
+      type = ClassFinalizer::FinalizeType(
+          current_class(), type, ClassFinalizer::kCanonicalize);
+      // Type may be malbounded, but not malformed.
+      ASSERT(!type.IsMalformed());
+      left = new TypeNode(primary->token_pos(), type);
+    }
+  }
+  return left;
+}
+
+
 AstNode* Parser::ParsePostfixExpr() {
   TRACE_PARSER("ParsePostfixExpr");
   String* expr_ident =
       Token::IsIdentifier(CurrentToken()) ? CurrentLiteral() : NULL;
   const intptr_t expr_pos = TokenPos();
   AstNode* expr = ParsePrimary();
   expr = ParseSelectors(expr, false);
   if (IsIncrementOperator(CurrentToken())) {
     TRACE_PARSER("IncrementOperator");
     Token::Kind incr_op = CurrentToken();
@@ skipping 2179 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart