VM can parse and ignore metadata

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 "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 1000 matching lines @@
 }
 
 
 void Parser::ParseFormalParameter(bool allow_explicit_default_value,
                                   ParamList* params) {
   TRACE_PARSER("ParseFormalParameter");
   ParamDesc parameter;
   bool var_seen = false;
   bool this_seen = false;
 
+  SkipMetadata();
   if (CurrentToken() == Token::kFINAL) {
     ConsumeToken();
     parameter.is_final = true;
   } else if (CurrentToken() == Token::kVAR) {
     ConsumeToken();
     var_seen = true;
     // The parameter type is the 'Dynamic' type.
     parameter.type = &Type::ZoneHandle(Type::DynamicType());
   }
   if (CurrentToken() == Token::kTHIS) {
@@ skipping 144 matching lines @@
       ASSERT(params->num_optional_parameters == 0);
     }
   }
   if (parameter.type->IsVoidType()) {
     ErrorMsg("parameter '%s' may not be 'void'", parameter.name->ToCString());
   }
   params->parameters->Add(parameter);
 }
 
 
+// Parses a sequence of normal or optional formal parameters.
+void Parser::ParseFormalParameters(bool allow_explicit_default_values,
+                                   ParamList* params) {
+  TRACE_PARSER("ParseFormalParameters");
+  do {
+    ConsumeToken();
+    if (!params->has_optional_positional_parameters &&
+        !params->has_optional_named_parameters &&
+        (CurrentToken() == Token::kLBRACK)) {
+      // End of normal parameters, start of optional positional parameters.
+      params->has_optional_positional_parameters = true;
+      return;
+    }
+    if (!params->has_optional_positional_parameters &&
+        !params->has_optional_named_parameters &&
+        (CurrentToken() == Token::kLBRACE)) {
+      // End of normal parameters, start of optional named parameters.
+      params->has_optional_named_parameters = true;
+      return;
+    }
+    ParseFormalParameter(allow_explicit_default_values, params);
+  } while (CurrentToken() == Token::kCOMMA);
+}
+
+
 void Parser::ParseFormalParameterList(bool allow_explicit_default_values,
                                       ParamList* params) {
   TRACE_PARSER("ParseFormalParameterList");
   ASSERT(CurrentToken() == Token::kLPAREN);
 
   if (LookaheadToken(1) != Token::kRPAREN) {
     // Parse fixed parameters.
     ParseFormalParameters(allow_explicit_default_values, params);
     if (params->has_optional_positional_parameters ||
         params->has_optional_named_parameters) {
@@ skipping 15 matching lines @@
         !params->has_optional_named_parameters) {
       ErrorMsg("',' or ')' expected");
     }
   } else {
     ConsumeToken();
   }
   ExpectToken(Token::kRPAREN);
 }
 
 
-// Parses a sequence of normal or optional formal parameters.
-void Parser::ParseFormalParameters(bool allow_explicit_default_values,
-                                   ParamList* params) {
-  TRACE_PARSER("ParseFormalParameters");
-  do {
-    ConsumeToken();
-    if (!params->has_optional_positional_parameters &&
-        !params->has_optional_named_parameters &&
-        (CurrentToken() == Token::kLBRACK)) {
-      // End of normal parameters, start of optional positional parameters.
-      params->has_optional_positional_parameters = true;
-      return;
-    }
-    if (!params->has_optional_positional_parameters &&
-        !params->has_optional_named_parameters &&
-        (CurrentToken() == Token::kLBRACE)) {
-      // End of normal parameters, start of optional named parameters.
-      params->has_optional_named_parameters = true;
-      return;
-    }
-    ParseFormalParameter(allow_explicit_default_values, params);
-  } while (CurrentToken() == Token::kCOMMA);
-}
-
-
 String& Parser::ParseNativeDeclaration() {
   TRACE_PARSER("ParseNativeDeclaration");
   ASSERT(IsLiteral("native"));
   ConsumeToken();
   if (CurrentToken() != Token::kSTRING) {
     ErrorMsg("string literal expected");
   }
   String& native_name = *CurrentLiteral();
   ConsumeToken();
   ExpectSemicolon();
@@ skipping 1856 matching lines @@
   if (CurrentToken() == Token::kIMPLEMENTS) {
     Array& interfaces = Array::Handle();
     const intptr_t interfaces_pos = TokenPos();
     interfaces = ParseInterfaceList();
     AddInterfaces(interfaces_pos, cls, interfaces);
   }
 
   ExpectToken(Token::kLBRACE);
   ClassDesc members(cls, class_name, false, class_pos);
   while (CurrentToken() != Token::kRBRACE) {
+    SkipMetadata();
     ParseClassMemberDefinition(&members);
   }
   ExpectToken(Token::kRBRACE);
 
   if (is_abstract || members.is_abstract()) {
     cls.set_is_abstract();
   }
 
   // Add an implicit constructor if no explicit constructor is present. No
   // implicit constructors are needed for patch classes.
@@ skipping 343 matching lines @@
   if (token_kind_ == Token::kGT) {
     ConsumeToken();
   } else if (token_kind_ == Token::kSHR) {
     token_kind_ = Token::kGT;
   } else {
     UNREACHABLE();
   }
 }
 
 
+void Parser::SkipMetadata() {
+  while (CurrentToken() == Token::kAT) {
+    ConsumeToken();
+    ExpectIdentifier("identifier expected");
+    if (CurrentToken() == Token::kPERIOD) {
+      ConsumeToken();
+      ExpectIdentifier("identifier expected");
+      if (CurrentToken() == Token::kPERIOD) {
+        ConsumeToken();
+        ExpectIdentifier("identifier expected");
+      }
+    }
+    if (CurrentToken() == Token::kLPAREN) {
+      SkipToMatchingParenthesis();
+    }
+  }
+}
+
+
 void Parser::SkipTypeArguments() {
   if (CurrentToken() == Token::kLT) {
     do {
       ConsumeToken();
       SkipType(false);
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) || (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
@@ skipping 25 matching lines @@
   if (CurrentToken() == Token::kLT) {
     const GrowableObjectArray& type_parameters_array =
         GrowableObjectArray::Handle(GrowableObjectArray::New());
     intptr_t index = 0;
     TypeParameter& type_parameter = TypeParameter::Handle();
     TypeParameter& existing_type_parameter = TypeParameter::Handle();
     String& existing_type_parameter_name = String::Handle();
     AbstractType& type_parameter_bound = Type::Handle();
     do {
       ConsumeToken();
+      SkipMetadata();
       if (CurrentToken() != Token::kIDENT) {
         ErrorMsg("type parameter name expected");
       }
       String& type_parameter_name = *CurrentLiteral();
       const intptr_t type_parameter_pos = TokenPos();
       // Check for duplicate type parameters.
       for (intptr_t i = 0; i < index; i++) {
         existing_type_parameter ^= type_parameters_array.At(i);
         existing_type_parameter_name = existing_type_parameter.name();
         if (existing_type_parameter_name.Equals(type_parameter_name)) {
@@ skipping 633 matching lines @@
   Class& toplevel_class = Class::Handle(
       Class::New(String::Handle(Symbols::TopLevel()), script_, TokenPos()));
   toplevel_class.set_library(library_);
 
   if (is_library_source()) {
     ParseLibraryDefinition();
   }
 
   while (true) {
     set_current_class(Class::Handle());  // No current class.
+    SkipMetadata();
     if (CurrentToken() == Token::kCLASS) {
       ParseClassDefinition(pending_classes);
     } else if ((CurrentToken() == Token::kTYPEDEF) &&
                (LookaheadToken(1) != Token::kLPAREN)) {
       ParseFunctionTypeAlias(pending_classes);
     } else if (CurrentToken() == Token::kINTERFACE) {
       ParseInterfaceDefinition(pending_classes);
     } else if ((CurrentToken() == Token::kABSTRACT) &&
         (LookaheadToken(1) == Token::kCLASS)) {
       ParseClassDefinition(pending_classes);
@@ skipping 342 matching lines @@
   }
   return ParseType(finalization);
 }
 
 
 // Returns ast nodes of the variable initialization. Variables without an
 // explicit initializer are initialized to null. If several variables are
 // declared, the individual initializers are collected in a sequence node.
 AstNode* Parser::ParseVariableDeclarationList() {
   TRACE_PARSER("ParseVariableDeclarationList");
+  SkipMetadata();
   bool is_final = (CurrentToken() == Token::kFINAL);
   bool is_const = (CurrentToken() == Token::kCONST);
   const AbstractType& type = AbstractType::ZoneHandle(ParseConstFinalVarOrType(
       FLAG_enable_type_checks ? ClassFinalizer::kCanonicalize :
                                 ClassFinalizer::kIgnore));
   if (!IsIdentifier()) {
     ErrorMsg("identifier expected");
   }
 
   AstNode* initializers = ParseVariableDeclaration(type, is_final, is_const);
@@ skipping 303 matching lines @@
     ConsumeToken();
     return true;
   } else if (CurrentToken() == Token::kIDENT) {
     return TryParseOptionalType();
   }
   return false;
 }
 
 
 // Look ahead to detect whether the next tokens should be parsed as
-// a variable declaration. Returns true if we detect the token pattern:
+// a variable declaration. Ignores optional metadata.
+// Returns true if we detect the token pattern:
 //     'var'
 //   | 'final'
 //   | const [type] ident (';' | '=' | ',')
 //   | type ident (';' | '=' | ',')
 // Token position remains unchanged.
 bool Parser::IsVariableDeclaration() {
   if ((CurrentToken() == Token::kVAR) ||
       (CurrentToken() == Token::kFINAL)) {
     return true;
   }
+  // Skip optional metadata.
+  if (CurrentToken() == Token::kAT) {
+    const intptr_t saved_pos = TokenPos();
+    SkipMetadata();
+    const bool is_var_decl = IsVariableDeclaration();
+    SetPosition(saved_pos);
+    return is_var_decl;
+  }
   if ((CurrentToken() != Token::kIDENT) && (CurrentToken() != Token::kCONST)) {
-    // Not a legal type identifier or const keyword
+    // Not a legal type identifier or const keyword or metadata
     return false;
   }
   const intptr_t saved_pos = TokenPos();
   bool is_var_decl = false;
   bool have_type = false;
   if (CurrentToken() == Token::kCONST) {
     ConsumeToken();
     have_type = true;  // Type is Dynamic.
   }
   if (IsIdentifier()) {  // Type or variable name.
@@ skipping 4547 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart