AST changes necessary for generic method support

pkg/analyzer/lib/src/generated/parser.dart

 // Copyright (c) 2014, 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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.parser;
 
+import 'dart:collection';
 import "dart:math" as math;
-import 'dart:collection';
 
 import 'ast.dart';
 import 'engine.dart' show AnalysisEngine, AnalysisOptionsImpl;
 import 'error.dart';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'scanner.dart';
 import 'source.dart';
 import 'utilities_collection.dart' show TokenMap;
 import 'utilities_dart.dart';
@@ skipping 234 matching lines @@
   'parseLibraryName_2': new MethodTrampoline(
       2, (Parser target, arg0, arg1) => target._parseLibraryName(arg0, arg1)),
   'parseListLiteral_2': new MethodTrampoline(
       2, (Parser target, arg0, arg1) => target._parseListLiteral(arg0, arg1)),
   'parseListOrMapLiteral_1': new MethodTrampoline(
       1, (Parser target, arg0) => target._parseListOrMapLiteral(arg0)),
   'parseLogicalAndExpression_0': new MethodTrampoline(
       0, (Parser target) => target._parseLogicalAndExpression()),
   'parseMapLiteral_2': new MethodTrampoline(
       2, (Parser target, arg0, arg1) => target._parseMapLiteral(arg0, arg1)),
-  'parseMethodDeclarationAfterParameters_6': new MethodTrampoline(6,
-      (Parser target, arg0, arg1, arg2, arg3, arg4, arg5) => target
+  'parseMethodDeclarationAfterParameters_7': new MethodTrampoline(7,
+      (Parser target, arg0, arg1, arg2, arg3, arg4, arg5, arg6) => target
           ._parseMethodDeclarationAfterParameters(
-              arg0, arg1, arg2, arg3, arg4, arg5)),
+              arg0, arg1, arg2, arg3, arg4, arg5, arg6)),
   'parseMethodDeclarationAfterReturnType_4': new MethodTrampoline(4,
       (Parser target, arg0, arg1, arg2, arg3) => target
           ._parseMethodDeclarationAfterReturnType(arg0, arg1, arg2, arg3)),
   'parseModifiers_0':
       new MethodTrampoline(0, (Parser target) => target._parseModifiers()),
   'parseMultiplicativeExpression_0': new MethodTrampoline(
       0, (Parser target) => target._parseMultiplicativeExpression()),
   'parseNativeClause_0':
       new MethodTrampoline(0, (Parser target) => target._parseNativeClause()),
   'parseNewExpression_0':
@@ skipping 1793 matching lines @@
    */
   bool _inSwitch = false;
 
   /**
    * A flag indicating whether the parser is currently in a constructor field
    * initializer, with no intervening parens, braces, or brackets.
    */
   bool _inInitializer = false;
 
   /**
+   * A flag indicating whether the parser is to parse generic method syntax.
+   */
+  bool parseGenericMethods = false;
+
+  /**
    * Initialize a newly created parser to parse the content of the given
    * [_source] and to report any errors that are found to the given
    * [_errorListener].
    */
   Parser(this._source, this._errorListener);
 
   void set currentToken(Token currentToken) {
     this._currentToken = currentToken;
   }
 
@@ skipping 340 matching lines @@
       if (commentAndMetadata.comment != null ||
           !commentAndMetadata.metadata.isEmpty) {
         //
         // We appear to have found an incomplete declaration at the end of the
         // class. At this point it consists of a metadata, which we don't want
         // to loose, so we'll treat it as a method declaration with a missing
         // name, parameters and empty body.
         //
         return new MethodDeclaration(commentAndMetadata.comment,
             commentAndMetadata.metadata, null, null, null, null, null,
-            _createSyntheticIdentifier(), new FormalParameterList(
+            _createSyntheticIdentifier(), null, new FormalParameterList(
                 null, new List<FormalParameter>(), null, null, null),
             new EmptyFunctionBody(_createSyntheticToken(TokenType.SEMICOLON)));
       }
       return null;
     } else if (_tokenMatches(_peek(), TokenType.PERIOD) &&
         _tokenMatchesIdentifier(_peekAt(2)) &&
         _tokenMatches(_peekAt(3), TokenType.OPEN_PAREN)) {
       return _parseConstructor(commentAndMetadata, modifiers.externalKeyword,
           _validateModifiersForConstructor(modifiers), modifiers.factoryKeyword,
           parseSimpleIdentifier(), getAndAdvance(), parseSimpleIdentifier(),
           parseFormalParameterList());
     } else if (_tokenMatches(_peek(), TokenType.OPEN_PAREN)) {
       SimpleIdentifier methodName = parseSimpleIdentifier();
       FormalParameterList parameters = parseFormalParameterList();
       if (_matches(TokenType.COLON) ||
           modifiers.factoryKeyword != null ||
           methodName.name == className) {
         return _parseConstructor(commentAndMetadata, modifiers.externalKeyword,
             _validateModifiersForConstructor(modifiers),
             modifiers.factoryKeyword, methodName, null, null, parameters);
       }
       _validateModifiersForGetterOrSetterOrMethod(modifiers);
       _validateFormalParameterList(parameters);
       return _parseMethodDeclarationAfterParameters(commentAndMetadata,
           modifiers.externalKeyword, modifiers.staticKeyword, null, methodName,
-          parameters);
+          null, parameters);
     } else if (_peek()
         .matchesAny([TokenType.EQ, TokenType.COMMA, TokenType.SEMICOLON])) {
       if (modifiers.constKeyword == null &&
           modifiers.finalKeyword == null &&
           modifiers.varKeyword == null) {
         _reportErrorForCurrentToken(
             ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE);
       }
       return _parseInitializedIdentifierList(commentAndMetadata,
           modifiers.staticKeyword, _validateModifiersForField(modifiers), null);
@@ skipping 59 matching lines @@
       if (methodName.name == className) {
         _reportErrorForNode(ParserErrorCode.CONSTRUCTOR_WITH_RETURN_TYPE, type);
         return _parseConstructor(commentAndMetadata, modifiers.externalKeyword,
             _validateModifiersForConstructor(modifiers),
             modifiers.factoryKeyword, methodName, null, null, parameters);
       }
       _validateModifiersForGetterOrSetterOrMethod(modifiers);
       _validateFormalParameterList(parameters);
       return _parseMethodDeclarationAfterParameters(commentAndMetadata,
           modifiers.externalKeyword, modifiers.staticKeyword, type, methodName,
-          parameters);
+          null, parameters);
     } else if (_tokenMatches(_peek(), TokenType.OPEN_CURLY_BRACKET)) {
       // We have found "TypeName identifier {", and are guessing that this is a
       // getter without the keyword 'get'.
       _validateModifiersForGetterOrSetterOrMethod(modifiers);
       _reportErrorForCurrentToken(ParserErrorCode.MISSING_GET);
       _currentToken = _injectToken(
           new Parser_SyntheticKeywordToken(Keyword.GET, _currentToken.offset));
       return _parseGetter(commentAndMetadata, modifiers.externalKeyword,
           modifiers.staticKeyword, type);
     }
@@ skipping 476 matching lines @@
    * parsed.
    *
    *     functionExpression ::=
    *         formalParameterList functionExpressionBody
    */
   FunctionExpression parseFunctionExpression() {
     FormalParameterList parameters = parseFormalParameterList();
     _validateFormalParameterList(parameters);
     FunctionBody body =
         _parseFunctionBody(false, ParserErrorCode.MISSING_FUNCTION_BODY, true);
-    return new FunctionExpression(parameters, body);
+    return new FunctionExpression(null, parameters, body);
   }
 
   /**
    * Parse an if-null expression.  Return the if-null expression that was
    * parsed.
    *
    *     ifNullExpression ::= logicalOrExpression ('??' logicalOrExpression)*
    */
   Expression parseIfNullExpression() {
     Expression expression = parseLogicalOrExpression();
@@ skipping 109 matching lines @@
     }
     SimpleIdentifier identifier = parseSimpleIdentifier();
     if (_matches(TokenType.OPEN_PAREN)) {
       FormalParameterList parameters = parseFormalParameterList();
       if (thisKeyword == null) {
         if (holder.keyword != null) {
           _reportErrorForToken(
               ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR, holder.keyword);
         }
         return new FunctionTypedFormalParameter(commentAndMetadata.comment,
-            commentAndMetadata.metadata, holder.type, identifier, parameters);
+            commentAndMetadata.metadata, holder.type, identifier, null,
+            parameters);
       } else {
         return new FieldFormalParameter(commentAndMetadata.comment,
             commentAndMetadata.metadata, holder.keyword, holder.type,
-            thisKeyword, period, identifier, parameters);
+            thisKeyword, period, identifier, null, parameters);
       }
     }
     TypeName type = holder.type;
     if (type != null) {
       if (_tokenMatchesKeyword(type.name.beginToken, Keyword.VOID)) {
         _reportErrorForToken(
             ParserErrorCode.VOID_PARAMETER, type.name.beginToken);
       } else if (holder.keyword != null &&
           _tokenMatchesKeyword(holder.keyword, Keyword.VAR)) {
         _reportErrorForToken(ParserErrorCode.VAR_AND_TYPE, holder.keyword);
       }
     }
     if (thisKeyword != null) {
       return new FieldFormalParameter(commentAndMetadata.comment,
           commentAndMetadata.metadata, holder.keyword, holder.type, thisKeyword,
-          period, identifier, null);
+          period, identifier, null, null);
     }
     return new SimpleFormalParameter(commentAndMetadata.comment,
         commentAndMetadata.metadata, holder.keyword, holder.type, identifier);
   }
 
   /**
    * Parse a prefixed identifier. Return the prefixed identifier that was
    * parsed.
    *
    *     prefixedIdentifier ::=
@@ skipping 268 matching lines @@
   }
 
   /**
    * Convert the given [method] declaration into the nearest valid top-level
    * function declaration (that is, the function declaration that most closely
    * captures the components of the given method declaration).
    */
   FunctionDeclaration _convertToFunctionDeclaration(MethodDeclaration method) =>
       new FunctionDeclaration(method.documentationComment, method.metadata,
           method.externalKeyword, method.returnType, method.propertyKeyword,
-          method.name, new FunctionExpression(method.parameters, method.body));
+          method.name, new FunctionExpression(
+              method.typeParameters, method.parameters, method.body));
 
   /**
    * Return `true` if the current token could be the start of a compilation unit
    * member. This method is used for recovery purposes to decide when to stop
    * skipping tokens after finding an error while parsing a compilation unit
    * member.
    */
   bool _couldBeStartOfCompilationUnitMember() {
     if ((_matchesKeyword(Keyword.IMPORT) ||
             _matchesKeyword(Keyword.EXPORT) ||
@@ skipping 678 matching lines @@
     // ambiguity by determining whether the primary consists of anything other
     // than an identifier and/or is followed by an assignableSelector.
     //
     Expression expression = _parsePrimaryExpression();
     bool isOptional = primaryAllowed || expression is SimpleIdentifier;
     while (true) {
       while (_matches(TokenType.OPEN_PAREN)) {
         ArgumentList argumentList = parseArgumentList();
         if (expression is SimpleIdentifier) {
           expression = new MethodInvocation(
-              null, null, expression as SimpleIdentifier, argumentList);
+              null, null, expression as SimpleIdentifier, null, argumentList);
         } else if (expression is PrefixedIdentifier) {
           PrefixedIdentifier identifier = expression as PrefixedIdentifier;
           expression = new MethodInvocation(identifier.prefix,
-              identifier.period, identifier.identifier, argumentList);
+              identifier.period, identifier.identifier, null, argumentList);
         } else if (expression is PropertyAccess) {
           PropertyAccess access = expression as PropertyAccess;
           expression = new MethodInvocation(access.target, access.operator,
-              access.propertyName, argumentList);
+              access.propertyName, null, argumentList);
         } else {
           expression =
-              new FunctionExpressionInvocation(expression, argumentList);
+              new FunctionExpressionInvocation(expression, null, argumentList);
         }
         if (!primaryAllowed) {
           isOptional = false;
         }
       }
       Expression selectorExpression = _parseAssignableSelector(
           expression, isOptional || (expression is PrefixedIdentifier));
       if (identical(selectorExpression, expression)) {
         if (!isOptional && (expression is PrefixedIdentifier)) {
           PrefixedIdentifier identifier = expression as PrefixedIdentifier;
@@ skipping 170 matching lines @@
       _reportErrorForToken(ParserErrorCode.MISSING_IDENTIFIER, _currentToken,
           [_currentToken.lexeme]);
       functionName = _createSyntheticIdentifier();
     }
     assert((expression == null && functionName != null) ||
         (expression != null && functionName == null));
     if (_currentToken.type == TokenType.OPEN_PAREN) {
       while (_currentToken.type == TokenType.OPEN_PAREN) {
         if (functionName != null) {
           expression = new MethodInvocation(
-              expression, period, functionName, parseArgumentList());
+              expression, period, functionName, null, parseArgumentList());
           period = null;
           functionName = null;
         } else if (expression == null) {
           // It should not be possible to get here.
           expression = new MethodInvocation(expression, period,
-              _createSyntheticIdentifier(), parseArgumentList());
+              _createSyntheticIdentifier(), null, parseArgumentList());
         } else {
-          expression =
-              new FunctionExpressionInvocation(expression, parseArgumentList());
+          expression = new FunctionExpressionInvocation(
+              expression, null, parseArgumentList());
         }
       }
     } else if (functionName != null) {
       expression = new PropertyAccess(expression, period, functionName);
       period = null;
     }
     assert(expression != null);
     bool progress = true;
     while (progress) {
       progress = false;
       Expression selector = _parseAssignableSelector(expression, true);
       if (!identical(selector, expression)) {
         expression = selector;
         progress = true;
         while (_currentToken.type == TokenType.OPEN_PAREN) {
           if (expression is PropertyAccess) {
             PropertyAccess propertyAccess = expression as PropertyAccess;
             expression = new MethodInvocation(propertyAccess.target,
-                propertyAccess.operator, propertyAccess.propertyName,
+                propertyAccess.operator, propertyAccess.propertyName, null,
                 parseArgumentList());
           } else {
             expression = new FunctionExpressionInvocation(
-                expression, parseArgumentList());
+                expression, null, parseArgumentList());
           }
         }
       }
     }
     if (_currentToken.type.isAssignmentOperator) {
       Token operator = getAndAdvance();
       _ensureAssignable(expression);
       expression = new AssignmentExpression(
           expression, operator, parseExpressionWithoutCascade());
     }
@@ skipping 1345 matching lines @@
     } else {
       body = new EmptyFunctionBody(_expect(TokenType.SEMICOLON));
     }
 //        if (!isStatement && matches(TokenType.SEMICOLON)) {
 //          // TODO(brianwilkerson) Improve this error message.
 //          reportError(ParserErrorCode.UNEXPECTED_TOKEN, currentToken.getLexeme());
 //          advance();
 //        }
     return new FunctionDeclaration(commentAndMetadata.comment,
         commentAndMetadata.metadata, externalKeyword, returnType, keyword, name,
-        new FunctionExpression(parameters, body));
+        new FunctionExpression(null, parameters, body));
   }
 
   /**
    * Parse a function declaration statement. Return the function declaration
    * statement that was parsed.
    *
    *     functionDeclarationStatement ::=
    *         functionSignature functionBody
    */
   Statement _parseFunctionDeclarationStatement() {
@@ skipping 106 matching lines @@
       _advance();
     }
     FunctionBody body = _parseFunctionBody(
         externalKeyword != null || staticKeyword == null,
         ParserErrorCode.STATIC_GETTER_WITHOUT_BODY, false);
     if (externalKeyword != null && body is! EmptyFunctionBody) {
       _reportErrorForCurrentToken(ParserErrorCode.EXTERNAL_GETTER_WITH_BODY);
     }
     return new MethodDeclaration(commentAndMetadata.comment,
         commentAndMetadata.metadata, externalKeyword, staticKeyword, returnType,
-        propertyKeyword, null, name, null, body);
+        propertyKeyword, null, name, null, null, body);
   }
 
   /**
    * Parse a list of identifiers. Return the list of identifiers that were
    * parsed.
    *
    *     identifierList ::=
    *         identifier (',' identifier)*
    */
   List<SimpleIdentifier> _parseIdentifierList() {
@@ skipping 300 matching lines @@
    * [parameters] is the parameters to the method. Return the method declaration
    * that was parsed.
    *
    *     functionDeclaration ::=
    *         ('external' 'static'?)? functionSignature functionBody
    *       | 'external'? functionSignature ';'
    */
   MethodDeclaration _parseMethodDeclarationAfterParameters(
       CommentAndMetadata commentAndMetadata, Token externalKeyword,
       Token staticKeyword, TypeName returnType, SimpleIdentifier name,
-      FormalParameterList parameters) {
+      TypeParameterList typeParameters, FormalParameterList parameters) {
     FunctionBody body = _parseFunctionBody(
         externalKeyword != null || staticKeyword == null,
         ParserErrorCode.MISSING_FUNCTION_BODY, false);
     if (externalKeyword != null) {
       if (body is! EmptyFunctionBody) {
         _reportErrorForNode(ParserErrorCode.EXTERNAL_METHOD_WITH_BODY, body);
       }
     } else if (staticKeyword != null) {
       if (body is EmptyFunctionBody && _parseFunctionBodies) {
         _reportErrorForNode(ParserErrorCode.ABSTRACT_STATIC_METHOD, body);
       }
     }
     return new MethodDeclaration(commentAndMetadata.comment,
         commentAndMetadata.metadata, externalKeyword, staticKeyword, returnType,
-        null, null, name, parameters, body);
+        null, null, name, typeParameters, parameters, body);
   }
 
   /**
    * Parse a method declaration. The [commentAndMetadata] is the documentation
    * comment and metadata to be associated with the declaration. The
    * [externalKeyword] is the 'external' token. The [staticKeyword] is the
    * static keyword, or `null` if the getter is not static. The [returnType] is
    * the return type of the method. Return the method declaration that was
    * parsed.
    *
@@ skipping 12 matching lines @@
       _reportErrorForToken(
           ParserErrorCode.MISSING_METHOD_PARAMETERS, _currentToken.previous);
       parameters = new FormalParameterList(
           _createSyntheticToken(TokenType.OPEN_PAREN), null, null, null,
           _createSyntheticToken(TokenType.CLOSE_PAREN));
     } else {
       parameters = parseFormalParameterList();
     }
     _validateFormalParameterList(parameters);
     return _parseMethodDeclarationAfterParameters(commentAndMetadata,
-        externalKeyword, staticKeyword, returnType, methodName, parameters);
+        externalKeyword, staticKeyword, returnType, methodName, null,
+        parameters);
   }
 
   /**
    * Parse the modifiers preceding a declaration. This method allows the
    * modifiers to appear in any order but does generate errors for duplicated
    * modifiers. Checks for other problems, such as having the modifiers appear
    * in the wrong order or specifying both 'const' and 'final', are reported in
    * one of the methods whose name is prefixed with `validateModifiersFor`.
    * Return the modifiers that were parsed.
    *
@@ skipping 335 matching lines @@
     }
     FormalParameterList parameters = parseFormalParameterList();
     _validateFormalParameterList(parameters);
     FunctionBody body =
         _parseFunctionBody(true, ParserErrorCode.MISSING_FUNCTION_BODY, false);
     if (externalKeyword != null && body is! EmptyFunctionBody) {
       _reportErrorForCurrentToken(ParserErrorCode.EXTERNAL_OPERATOR_WITH_BODY);
     }
     return new MethodDeclaration(commentAndMetadata.comment,
         commentAndMetadata.metadata, externalKeyword, null, returnType, null,
-        operatorKeyword, name, parameters, body);
+        operatorKeyword, name, null, parameters, body);
   }
 
   /**
    * Parse a return type if one is given, otherwise return `null` without
    * advancing. Return the return type that was parsed.
    */
   TypeName _parseOptionalReturnType() {
     if (_matchesKeyword(Keyword.VOID)) {
       return parseReturnType();
     } else if (_matchesIdentifier() &&
@@ skipping 57 matching lines @@
     if (_matches(TokenType.OPEN_SQUARE_BRACKET) ||
         _matches(TokenType.PERIOD) ||
         _matches(TokenType.QUESTION_PERIOD) ||
         _matches(TokenType.OPEN_PAREN)) {
       do {
         if (_matches(TokenType.OPEN_PAREN)) {
           ArgumentList argumentList = parseArgumentList();
           if (operand is PropertyAccess) {
             PropertyAccess access = operand as PropertyAccess;
             operand = new MethodInvocation(access.target, access.operator,
-                access.propertyName, argumentList);
+                access.propertyName, null, argumentList);
           } else {
-            operand = new FunctionExpressionInvocation(operand, argumentList);
+            operand =
+                new FunctionExpressionInvocation(operand, null, argumentList);
           }
         } else {
           operand = _parseAssignableSelector(operand, true);
         }
       } while (_matches(TokenType.OPEN_SQUARE_BRACKET) ||
           _matches(TokenType.PERIOD) ||
           _matches(TokenType.QUESTION_PERIOD) ||
           _matches(TokenType.OPEN_PAREN));
       return operand;
     }
@@ skipping 237 matching lines @@
     FormalParameterList parameters = parseFormalParameterList();
     _validateFormalParameterList(parameters);
     FunctionBody body = _parseFunctionBody(
         externalKeyword != null || staticKeyword == null,
         ParserErrorCode.STATIC_SETTER_WITHOUT_BODY, false);
     if (externalKeyword != null && body is! EmptyFunctionBody) {
       _reportErrorForCurrentToken(ParserErrorCode.EXTERNAL_SETTER_WITH_BODY);
     }
     return new MethodDeclaration(commentAndMetadata.comment,
         commentAndMetadata.metadata, externalKeyword, staticKeyword, returnType,
-        propertyKeyword, null, name, parameters, body);
+        propertyKeyword, null, name, null, parameters, body);
   }
 
   /**
    * Parse a shift expression. Return the shift expression that was parsed.
    *
    *     shiftExpression ::=
    *         additiveExpression (shiftOperator additiveExpression)*
    *       | 'super' (shiftOperator additiveExpression)+
    */
   Expression _parseShiftExpression() {
@@ skipping 3602 matching lines @@
   }
 
   /**
    * Copy resolution data from the [fromNode] to the [toNode].
    */
   static void copyResolutionData(AstNode fromNode, AstNode toNode) {
     ResolutionCopier copier = new ResolutionCopier();
     copier._isEqualNodes(fromNode, toNode);
   }
 }