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 860 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();
+      // Can be x, C, L.C, C.x, or L.C.x.
+      expr = ParsePrimary();  // Consumes x, C or L.C.
+

[hausner, 2013/10/28 23:06:01]

You could simplify the following code a bit if you rewrite it as, roughly:

Class& cls = Class::Handle();
if (expr is primary node) {
  if (primary node contains class) {
    cls = ....
    expr = new TypeNode(...);
  } else {
    error: expression must refer to class or static const field
  }
}
if (CurrentToken() == Token::kPERIOD) {
  error if cls is null.
  error if static field does not exist
  error if field is not const
  expr = GenerateStaticFieldLookup()
}

+      if (CurrentToken() == Token::kPERIOD) {
+        ConsumeToken();
+        const intptr_t ident_pos = TokenPos();
+        String* ident = ExpectIdentifier("identifier expected");
+
+        Class& cls = Class::Handle();
+        if (expr->IsPrimaryNode()) {
+          PrimaryNode* primary_node = expr->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()) {
+          ErrorMsg(expr_pos, "class expected");

[rmacnak, 2013/10/28 22:06:35]

Is this the appropriate position to point at?

[hausner, 2013/10/28 23:06:01]

yes

+        }
+        const Field& field = Field::Handle(cls.LookupStaticField(*ident));
+        if (field.IsNull()) {
+          ErrorMsg(ident_pos, "field expected");

[rmacnak, 2013/10/28 22:06:35]

Perhaps "<ident> is not a field of <class>"?

[hausner, 2013/10/28 23:06:01]

I like this slightly better if you format the error message with the actual
field and class name.

Also, you should check whether the field is const. It's not strictly necessary,
since non-const fields will fail const expression evaluation, but it gives users
a more specific error message. 

if (!field.is_const()) {
  ErrorMsg(....);
}

+        }
+        expr = GenerateStaticFieldLookup(field, TokenPos());
+      }
+
+      // C or L.C.
+      if (expr->IsPrimaryNode()) {
+        PrimaryNode* primary_node = expr->AsPrimaryNode();
+        if (primary_node->primary().IsClass()) {
+          const Class& type_class = Class::Cast(primary_node->primary());
+          AbstractType& type = Type::ZoneHandle(
+             Type::New(type_class, TypeArguments::Handle(),
+                       primary_node->token_pos(), Heap::kOld));
+          type = ClassFinalizer::FinalizeType(
+              current_class(), type, ClassFinalizer::kCanonicalize);
+          // Type may be malbounded, but not malformed.
+          ASSERT(!type.IsMalformed());
+          expr = new TypeNode(primary_node->token_pos(), type);
+        }
+      }
     }
     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 9696 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart