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 875 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 = ParseQualified(expr);
     }
     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 7516 matching lines @@
       }
       // Done parsing selectors.
       return left;
     }
     ASSERT(selector != NULL);
     left = selector;
   }
 }
 
 
+AstNode* Parser::ParseQualified(AstNode* primary) {

[rmacnak, 2013/10/24 21:33:56]

Yuck. This is basically ParseSelectors with about half of the cases chopped out.

[hausner, 2013/10/24 23:19:48]

I think this is way more complicated than need be. First of all, after you parse
the qualified part (with ParsePrimary), you have only one optional selector to
deal with, so the while loop is wrong. 

I find the name of the function misleading. The qualified identifier has already
been parsed at this point. All you do here is parse one additonal selector of
the form "." ident. That identifier can only refer to a static field of the
primary you parsed earlier, everything else is an error.

+  AstNode* left = primary;
+  while (true) {
+    AstNode* selector = NULL;
+    if (CurrentToken() == Token::kPERIOD) {
+      ConsumeToken();
+      if (left->IsPrimaryNode()) {
+        if (left->AsPrimaryNode()->primary().IsFunction()) {
+          left = LoadClosure(left->AsPrimaryNode());
+        } else if (left->AsPrimaryNode()->primary().IsTypeParameter()) {
+          if (current_block_->scope->function_level() > 0) {
+            // Make sure that the instantiator is captured.
+            CaptureInstantiator();
+          }
+          TypeParameter& type_parameter = TypeParameter::ZoneHandle();
+          type_parameter ^= ClassFinalizer::FinalizeType(
+              current_class(),
+              TypeParameter::Cast(left->AsPrimaryNode()->primary()),
+              ClassFinalizer::kFinalize);
+          ASSERT(!type_parameter.IsMalformed());
+          left = new TypeNode(primary->token_pos(), type_parameter);
+        } 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");
+      if (CurrentToken() == Token::kLPAREN) {

[hausner, 2013/10/24 23:19:48]

This can't happen for metadata.

+        // Identifier followed by a opening paren: method call.
+        if (left->IsPrimaryNode() &&
+            left->AsPrimaryNode()->primary().IsClass()) {
+          // Static method call prefixed with class name.
+          const Class& cls = Class::Cast(left->AsPrimaryNode()->primary());
+          selector = ParseStaticCall(cls, *ident, ident_pos);
+        } else {
+          selector = ParseInstanceCall(left, *ident);
+        }
+      } else {
+        // Field access.
+        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.
+          selector = CallGetter(ident_pos, left, *ident);
+        } else {
+          // Static field access.
+          selector =
+              ParseStaticFieldAccess(cls, *ident, ident_pos, true);
+        }
+      }
+    } else {
+      // No (more) selectors to parse.
+      if (left->IsPrimaryNode()) {
+        PrimaryNode* primary = left->AsPrimaryNode();
+        if (primary->primary().IsFunction()) {
+          // 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);
+        } else if (primary->primary().IsTypeParameter()) {
+          if (current_block_->scope->function_level() > 0) {
+            // Make sure that the instantiator is captured.
+            CaptureInstantiator();
+          }
+          TypeParameter& type_parameter = TypeParameter::ZoneHandle();
+          type_parameter ^= ClassFinalizer::FinalizeType(
+              current_class(),
+              TypeParameter::Cast(primary->primary()),
+              ClassFinalizer::kFinalize);
+          ASSERT(!type_parameter.IsMalformed());
+          left = new TypeNode(primary->token_pos(), type_parameter);
+        }
+      }
+      // Done parsing selectors.
+      return left;
+    }
+    ASSERT(selector != NULL);
+    left = selector;
+  }
+}
+
+
 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 2169 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart