Add support for metadata annotation syntax (issue 4056)

compiler/java/com/google/dart/compiler/parser/DartParser.java

 // 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.
 
 package com.google.dart.compiler.parser;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.io.CharStreams;
 import com.google.dart.compiler.DartCompilationError;
@@ skipping 33 matching lines @@
 import com.google.dart.compiler.ast.DartFunctionTypeAlias;
 import com.google.dart.compiler.ast.DartIdentifier;
 import com.google.dart.compiler.ast.DartIfStatement;
 import com.google.dart.compiler.ast.DartImportDirective;
 import com.google.dart.compiler.ast.DartInitializer;
 import com.google.dart.compiler.ast.DartIntegerLiteral;
 import com.google.dart.compiler.ast.DartLabel;
 import com.google.dart.compiler.ast.DartLibraryDirective;
 import com.google.dart.compiler.ast.DartMapLiteral;
 import com.google.dart.compiler.ast.DartMapLiteralEntry;
+import com.google.dart.compiler.ast.DartAnnotation;
 import com.google.dart.compiler.ast.DartMethodDefinition;
 import com.google.dart.compiler.ast.DartMethodInvocation;
 import com.google.dart.compiler.ast.DartNamedExpression;
 import com.google.dart.compiler.ast.DartNativeBlock;
 import com.google.dart.compiler.ast.DartNativeDirective;
 import com.google.dart.compiler.ast.DartNewExpression;
 import com.google.dart.compiler.ast.DartNode;
+import com.google.dart.compiler.ast.DartNodeWithMetadata;
 import com.google.dart.compiler.ast.DartNullLiteral;
 import com.google.dart.compiler.ast.DartParameter;
 import com.google.dart.compiler.ast.DartParameterizedTypeNode;
 import com.google.dart.compiler.ast.DartParenthesizedExpression;
 import com.google.dart.compiler.ast.DartPartOfDirective;
 import com.google.dart.compiler.ast.DartPropertyAccess;
 import com.google.dart.compiler.ast.DartRedirectConstructorInvocation;
 import com.google.dart.compiler.ast.DartReturnBlock;
 import com.google.dart.compiler.ast.DartReturnStatement;
 import com.google.dart.compiler.ast.DartSourceDirective;
@@ skipping 225 matching lines @@
     
     try {
       beginCompilationUnit();
       ctx.unitAboutToCompile(dartSource, isDietParse);
       DartUnit unit = new DartUnit(dartSource, isDietParse);
 
       // parse any directives at the beginning of the source
       parseDirectives(unit);
 
       while (!EOS()) {
-        DartNode node = null;
+        DartNodeWithMetadata node = null;
         beginTopLevelElement();
+        List<DartAnnotation> metadata = parseMetadata();
         isParsingClass = isParsingInterface = false;
         // Check for ABSTRACT_KEYWORD.
         isTopLevelAbstract = false;
         topLevelAbstractModifierPosition = 0;
         if (optionalPseudoKeyword(ABSTRACT_KEYWORD)) {
           isTopLevelAbstract = true;
           topLevelAbstractModifierPosition = position();
         }
         // Parse top level element.
         if (optional(Token.CLASS)) {
           isParsingClass = true;
           node = done(parseClass());
         } else if (peekPseudoKeyword(0, INTERFACE_KEYWORD) && peek(1).equals(Token.IDENTIFIER)) {
           consume(Token.IDENTIFIER);
           isParsingInterface = true;
           node = done(parseClass());
         } else if (peekPseudoKeyword(0, TYPEDEF_KEYWORD)
             && (peek(1).equals(Token.IDENTIFIER) || peek(1).equals(Token.VOID))) {
           consume(Token.IDENTIFIER);
           node = done(parseFunctionTypeAlias());
         } else if (looksLikeDirective()) {
           reportErrorWithoutAdvancing(ParserErrorCode.DIRECTIVE_OUT_OF_ORDER);
           parseDirectives(unit);
         } else {
           node = done(parseFieldOrMethod(false));
         }
         // Parsing was successful, add node.
         if (node != null) {
+          node.setMetadata(metadata);
           unit.getTopLevelNodes().add(node);
           // Only "class" can be top-level abstract element.
           if (isTopLevelAbstract && !isParsingClass) {
             int abstractPositionEnd = topLevelAbstractModifierPosition + ABSTRACT_KEYWORD.length();
             Location location = new Location(topLevelAbstractModifierPosition, abstractPositionEnd);
             reportError(new DartCompilationError(source, location,
                 ParserErrorCode.ABSTRACT_TOP_LEVEL_ELEMENT));
           }
         }
       }
@@ skipping 119 matching lines @@
       nativePath.setSourceInfo(nativeDirective.getSourceInfo());
       libUnit.addNativePath(nativePath);
     }
 
     // add ourselves to the list of sources, so inline dart code will be parsed
     libUnit.addSourcePath(libUnit.getSelfSourcePath());
     return done(libUnit);
   }
 
   private void parseDirectives(DartUnit unit) {
+    List<DartAnnotation> metadata = parseMetadata();
     if (peekPseudoKeyword(0, LIBRARY_KEYWORD)) {
       DartLibraryDirective libraryDirective = parseLibraryDirective();
       for (DartDirective directive : unit.getDirectives()) {
         if (directive instanceof DartLibraryDirective) {
           reportError(position(), ParserErrorCode.ONLY_ONE_LIBRARY_DIRECTIVE);
           break;
         }
       }
+      libraryDirective.setMetadata(metadata);
       unit.getDirectives().add(libraryDirective);
     }
     while (peekPseudoKeyword(0, IMPORT_KEYWORD)) {
-      unit.getDirectives().add(parseImportDirective());
+      DartImportDirective importDirective = parseImportDirective();
+      importDirective.setMetadata(metadata);
+      unit.getDirectives().add(importDirective);
     }
     while (peekPseudoKeyword(0, PART_KEYWORD)) {
       if (peekPseudoKeyword(1, OF_KEYWORD)) {
-        unit.getDirectives().add(parsePartOfDirective());
+        DartPartOfDirective partOfDirective = parsePartOfDirective();
+        partOfDirective.setMetadata(metadata);
+        unit.getDirectives().add(partOfDirective);
       } else {
-        unit.getDirectives().add(parsePartDirective());
+        DartSourceDirective partDirective = parsePartDirective();
+        partDirective.setMetadata(metadata);
+        unit.getDirectives().add(partDirective);
       }
     }
     //
     // The code below is obsolete. We do not make any effort to find duplications between the old
     // and the new syntax because support for the old syntax will be removed very soon.
     //
     if (peek(0) == Token.LIBRARY) {
       beginLibraryDirective();
       DartLibraryDirective libraryDirective = parseObsoleteLibraryDirective();
       for (DartDirective directive : unit.getDirectives()) {
         if (directive instanceof DartLibraryDirective) {
           reportError(position(), ParserErrorCode.ONLY_ONE_LIBRARY_DIRECTIVE);
           break;
         }
       }
+      libraryDirective.setMetadata(metadata);
       unit.getDirectives().add(libraryDirective);
       done(libraryDirective);
     }
     while (peek(0) == Token.IMPORT) {
       beginImportDirective();
-      unit.getDirectives().add(done(parseObsoleteImportDirective()));
+      DartImportDirective importDirective = parseObsoleteImportDirective();
+      importDirective.setMetadata(metadata);
+      unit.getDirectives().add(done(importDirective));
     }
     while (peek(0) == Token.SOURCE) {
       beginSourceDirective();
-      unit.getDirectives().add(done(parseSourceDirective()));
+      DartSourceDirective sourceDirective = parseSourceDirective();
+      sourceDirective.setMetadata(metadata);
+      unit.getDirectives().add(done(sourceDirective));
     }
     while (peek(0) == Token.RESOURCE) {
       parseResourceDirective();
     }
     while (peek(0) == Token.NATIVE) {
       beginNativeDirective();
-      unit.getDirectives().add(done(parseNativeDirective()));
+      DartNativeDirective nativeDirective = parseNativeDirective();
+      nativeDirective.setMetadata(metadata);
+      unit.getDirectives().add(done(nativeDirective));
     }
   }
 
   private DartLibraryDirective parseLibraryDirective() {
     beginLibraryDirective();
     next(); // "library"
     DartExpression libraryName = parseLibraryName();
     expect(Token.SEMICOLON);
     return done(new DartLibraryDirective(libraryName));
   }
@@ skipping 154 matching lines @@
     expect(Token.NATIVE);
     expect(Token.LPAREN);
     beginLiteral();
     expect(Token.STRING);
     DartStringLiteral nativeUri = done(DartStringLiteral.get(ctx.getTokenString()));
     expect(Token.RPAREN);
     expect(Token.SEMICOLON);
     return new DartNativeDirective(nativeUri);
   }
 
+  private List<DartAnnotation> parseMetadata() {
+    List<DartAnnotation> metadata = new ArrayList<DartAnnotation>();
+    while (match(Token.AT)) {
+      beginMetadata();
+      next();
+      beginQualifiedIdentifier();
+      DartExpression name = parseQualified();
+      if (optional(Token.PERIOD)) {
+        name = new DartPropertyAccess(name, parseIdentifier());
+      }
+      done(name);
+      List<DartExpression> arguments = null;
+      if (match(Token.LPAREN)) {
+        arguments = parseArguments();
+      }
+      metadata.add(done(new DartAnnotation(name, arguments)));
+    }
+    return metadata;
+  }
+
   /**
    * <pre>
    * typeParameter
    *     : identifier (EXTENDS type)?
    *     ;
    *
    * typeParameters
    *     : '<' typeParameter (',' typeParameter)* '>'
    *     ;
    * </pre>
@@ skipping 170 matching lines @@
           members,
           typeParameters,
           modifiers));
     }
   }
 
   /**
    * Helper for {@link #parseClass()}.
    *
    * '{' classMemberDefinition* '}'
-   *
    */
   @Terminals(tokens={Token.RBRACE, Token.SEMICOLON})
   private void parseClassOrInterfaceBody(List<DartNode> members) {
     if (optional(Token.LBRACE)) {
       while (!match(Token.RBRACE) && !EOS() && !looksLikeTopLevelKeyword()) {
-        DartNode member = parseFieldOrMethod(true);
+        List<DartAnnotation> metadata = parseMetadata();
+        DartNodeWithMetadata member = parseFieldOrMethod(true);
         if (member != null) {
+          member.setMetadata(metadata);
           members.add(member);
         }
         // Recover at a semicolon
         if (optional(Token.SEMICOLON)) {
           reportUnexpectedToken(position(), null, Token.SEMICOLON);
         }
       }
       expectCloseBrace(true);
     } else {
       reportErrorWithoutAdvancing(ParserErrorCode.EXPECTED_CLASS_DECLARATION_LBRACE);
@@ skipping 206 matching lines @@
    *     | '[' ']' '=' { "[]=".equals($text) }?
    *     | NEGATE
    *     | CALL
    *     ;
    * </pre>
    *
    * @param allowStatic true if the static modifier is allowed
    * @return a {@link DartNode} representing the grammar fragment above
    */
   @Terminals(tokens={Token.SEMICOLON})
-  private DartNode parseFieldOrMethod(boolean allowStatic) {
+  private DartNodeWithMetadata parseFieldOrMethod(boolean allowStatic) {
     beginClassMember();
     Modifiers modifiers = Modifiers.NONE;
     if (peek(1) != Token.LPAREN && optionalPseudoKeyword(EXTERNAL_KEYWORD)) {
       modifiers = modifiers.makeExternal();
     }
     if (peek(1) != Token.LPAREN && optionalPseudoKeyword(STATIC_KEYWORD)) {
       if (!allowStatic) {
         reportError(position(), ParserErrorCode.TOP_LEVEL_CANNOT_BE_STATIC);
       } else {
         if (isParsingInterface
@@ skipping 47 matching lines @@
       // If factory is not allowed, ensure that it is valid as method.
       DartExpression actualName = factoryNode.getName();
       if (!allowStatic && !(actualName instanceof DartIdentifier)) {
         DartExpression replacementName = new DartIdentifier(actualName.toString());
         factoryNode.setName(replacementName);
       }
       // Done.
       return done(factoryNode);
     }
 
-    final DartNode member;
+    final DartNodeWithMetadata member;
 
     switch (peek(0)) {
       case VAR: {
         consume(Token.VAR);
         // Check for malformed method starting with 'var' : var ^ foo() { }
         if (peek(0).equals(Token.IDENTIFIER) && looksLikeMethodOrAccessorDefinition()) {
           reportError(position(), ParserErrorCode.VAR_IS_NOT_ALLOWED_ON_A_METHOD_DEFINITION);
           member = parseMethodOrAccessor(modifiers, null);
           break;
         }
@@ skipping 425 matching lines @@
       //if (!modifiers.isStatic()) {
       //  reportError(position(), ParserErrorCode.EXPORTED_FUNCTIONS_MUST_BE_STATIC);
       //}
       return done(parseFunctionStatementBody(!modifiers.isExternal(), true));
     } else {
       expect(Token.SEMICOLON);
       return done(new DartNativeBlock());
     }
   }
 
-  private DartNode parseMethodOrAccessor(Modifiers modifiers, DartTypeNode returnType) {
+  private DartNodeWithMetadata parseMethodOrAccessor(Modifiers modifiers, DartTypeNode returnType) {
     DartMethodDefinition method = done(parseMethod(modifiers, returnType));
     // Abstract method can not have a body.
     if (method.getFunction().getBody() != null) {
       if (isParsingInterface) {
         reportError(method.getName(), ParserErrorCode.INTERFACE_METHOD_WITH_BODY);
       }
       if (method.getModifiers().isAbstract()) {
         reportError(method.getName(), ParserErrorCode.ABSTRACT_METHOD_WITH_BODY);
       }
     }
@@ skipping 288 matching lines @@
    *     : normalFormalParameter ('=' constantExpression)?
    *     ;
    * 
    * defaultNamedParameter
    *     : normalFormalParameter (':' constantExpression)?
    *     ;
    * </pre>
    */
   private DartParameter parseFormalParameter(boolean isOptional, boolean isNamed) {
     beginFormalParameter();
+    List<DartAnnotation> metadata = parseMetadata();
     DartExpression paramName = null;
     DartTypeNode type = null;
     DartExpression defaultExpr = null;
     List<DartParameter> functionParams = null;
     boolean hasVar = false;
     Modifiers modifiers = Modifiers.NONE;
 
     if (isOptional) {
       modifiers = modifiers.makeOptional();
       // TODO(brianwilkerson) Remove the line below when we no longer need to support the old syntax.
@@ skipping 84 matching lines @@
         } else {
           reportError(position(), ParserErrorCode.DEFAULT_POSITIONAL_PARAMETER);
         }
         break;
 
       default:
         reportUnexpectedToken(position(), null, peek(0));
         break;
     }
 
-    return done(new DartParameter(paramName, type, functionParams, defaultExpr, modifiers));
+    DartParameter parameter = new DartParameter(paramName, type, functionParams, defaultExpr, modifiers);
+    parameter.setMetadata(metadata);
+    return done(parameter);
   }
 
   /**
    * <pre>
    * simpleFormalParameter
    *     : declaredIdentifier
    *     | identifier
    *     ;
    *
    * fieldFormalParameter
@@ skipping 2928 matching lines @@
   private void reportError(DartNode node, ErrorCode errorCode, Object... arguments) {
     if (node != null) {
       reportError(new DartCompilationError(node, errorCode, arguments));
     }
   }
 
   private boolean currentlyParsingToplevel() {
     return   !(isParsingInterface || isTopLevelAbstract || isParsingClass);
   }
 }