Update parser and scanner.

pkg/dart_parser/lib/src/parser.dart

 // 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.
 
 library dart_parser;
 
 import 'package:dart_scanner/src/keyword.dart' show
     Keyword;
 
 import 'package:dart_scanner/src/precedence.dart' show
@@ skipping 97 matching lines @@
  * [parseMetadataStar] corresponds to this grammar snippet: [:
  * metadata* :], and [parseTypeOpt] corresponds to: [: type? :].
  */
 class Parser {
   final Listener listener;
 
   bool mayParseFunctionExpressions = true;
 
   bool asyncAwaitKeywordsEnabled;
 
-  final bool enableGenericMethodSyntax;
-
-  Parser(this.listener,
-         {this.asyncAwaitKeywordsEnabled: false,
-          this.enableGenericMethodSyntax: false});
+  Parser(this.listener, {this.asyncAwaitKeywordsEnabled: false});
 
   Token parseUnit(Token token) {
     listener.beginCompilationUnit(token);
     int count = 0;
     while (!identical(token.kind, EOF_TOKEN)) {
       token = parseTopLevelDeclaration(token);
       count++;
     }
     listener.endCompilationUnit(count, token);
     return token;
@@ skipping 243 matching lines @@
       period = token;
       token = parseIdentifier(token.next);
     }
     token = parseArgumentsOpt(token);
     listener.endMetadata(atToken, period, token);
     return token;
   }
 
   Token parseTypedef(Token token) {
     Token typedefKeyword = token;
-    if (optional('=', peekAfterType(token.next))) {
-      // TODO(aprelev@gmail.com): Remove deprecated 'typedef' mixin application,
-      // remove corresponding diagnostic from members.dart.
-      listener.beginNamedMixinApplication(token);
-      token = parseIdentifier(token.next);
-      token = parseTypeVariablesOpt(token);
-      token = expect('=', token);
-      token = parseModifiers(token);
-      token = parseMixinApplication(token);
-      Token implementsKeyword = null;
-      if (optional('implements', token)) {
-        implementsKeyword = token;
-        token = parseTypeList(token.next);
-      }
-      listener.endNamedMixinApplication(
-          typedefKeyword, implementsKeyword, token);
-    } else {
-      listener.beginFunctionTypeAlias(token);
-      token = parseReturnTypeOpt(token.next);
-      token = parseIdentifier(token);
-      token = parseTypeVariablesOpt(token);
-      token = parseFormalParameters(token);
-      listener.endFunctionTypeAlias(typedefKeyword, token);
-    }
+    listener.beginFunctionTypeAlias(token);
+    token = parseReturnTypeOpt(token.next);
+    token = parseIdentifier(token);
+    token = parseTypeVariablesOpt(token);
+    token = parseFormalParameters(token);
+    listener.endFunctionTypeAlias(typedefKeyword, token);
     return expect(';', token);
   }
 
   Token parseMixinApplication(Token token) {
     listener.beginMixinApplication(token);
     token = parseType(token);
     token = expect('with', token);
     token = parseTypeList(token);
     listener.endMixinApplication();
     return token;
@@ skipping 38 matching lines @@
       }
       token = parseFormalParameter(token, FormalParameterType.REQUIRED);
     } while (optional(',', token));
     listener.endFormalParameters(parameterCount, begin, token);
     return expect(')', token);
   }
 
   Token parseFormalParameter(Token token, FormalParameterType type) {
     token = parseMetadataStar(token, forParameter: true);
     listener.beginFormalParameter(token);
+
+    // Skip over `covariant` token, if the next token is an identifier or
+    // modifier.
+    // This enables the case where `covariant` is the name of the parameter:
+    //    void foo(covariant);
+    if (identical(token.stringValue, 'covariant') &&
+        (token.next.isIdentifier() || isModifier(token.next))) {
+      token = token.next;
+    }
     token = parseModifiers(token);
     // TODO(ahe): Validate that there are formal parameters if void.
     token = parseReturnTypeOpt(token);
     Token thisKeyword = null;
     if (optional('this', token)) {
       thisKeyword = token;
       // TODO(ahe): Validate field initializers are only used in
       // constructors, and not for function-typed arguments.
       token = expect('.', token.next);
     }
     token = parseIdentifier(token);
     if (optional('(', token)) {
       listener.beginFunctionTypedFormalParameter(token);
       listener.handleNoTypeVariables(token);
       token = parseFormalParameters(token);
       listener.handleFunctionTypedFormalParameter(token);
-    } else if (enableGenericMethodSyntax && optional('<', token)) {
+    } else if (optional('<', token)) {
       listener.beginFunctionTypedFormalParameter(token);
       token = parseTypeVariablesOpt(token);
       token = parseFormalParameters(token);
       listener.handleFunctionTypedFormalParameter(token);
     }
     String value = token.stringValue;
     if ((identical('=', value)) || (identical(':', value))) {
       // TODO(ahe): Validate that these are only used for optional parameters.
       Token equal = token;
       token = parseExpression(token.next);
@@ skipping 98 matching lines @@
     token = tryParseQualified(token);
     if (token == null) return null;
     Token tokenAfterQualified = token;
     token = tryParseNestedTypeArguments(token);
     return token == null ? tokenAfterQualified : token;
   }
 
   /// Returns token after match if [token] matches identifier ('.' identifier)?,
   /// and otherwise returns null. Does not produce listener events.
   Token tryParseQualified(Token token) {
-    if (!identical(token.kind, IDENTIFIER_TOKEN)) return null;
+    if (!isValidTypeReference(token)) return null;
     token = token.next;
     if (!identical(token.kind, PERIOD_TOKEN)) return token;
     token = token.next;
     if (!identical(token.kind, IDENTIFIER_TOKEN)) return null;
     return token.next;
   }
 
   /// Returns token after match if [token] matches '<' type (',' type)* '>',
   /// and otherwise returns null. Does not produce listener events. The final
   /// '>' may be the first character in a '>>' token, in which case a synthetic
@@ skipping 84 matching lines @@
     Token begin = token;
     Token abstractKeyword;
     if (optional('abstract', token)) {
       abstractKeyword = token;
       token = token.next;
     }
     Token classKeyword = token;
     var isMixinApplication = optional('=', peekAfterType(token.next));
     if (isMixinApplication) {
       listener.beginNamedMixinApplication(begin);
-      token = parseIdentifier(token.next);
-      token = parseTypeVariablesOpt(token);
-      token = expect('=', token);
     } else {
       listener.beginClassDeclaration(begin);
     }
 
-    // TODO(aprelev@gmail.com): Once 'typedef' named mixin application is
-    // removed, move modifiers for named mixin application to the bottom of
-    // listener stack. This is so stacks for class declaration and named
-    // mixin application look similar.
     int modifierCount = 0;
     if (abstractKeyword != null) {
       parseModifier(abstractKeyword);
       modifierCount++;
     }
     listener.handleModifiers(modifierCount);
 
     if (isMixinApplication) {
+      token = parseIdentifier(token.next);
+      token = parseTypeVariablesOpt(token);
+      token = expect('=', token);
       return parseNamedMixinApplication(token, classKeyword);
     } else {
       return parseClass(begin, classKeyword);
     }
   }
 
   Token parseNamedMixinApplication(Token token, Token classKeyword) {
     token = parseMixinApplication(token);
     Token implementsKeyword = null;
     if (optional('implements', token)) {
@@ skipping 55 matching lines @@
     if (!identical(string, token.stringValue)) {
       return listener.expected(string, token);
     }
     return token.next;
   }
 
   Token parseTypeVariable(Token token) {
     listener.beginTypeVariable(token);
     token = parseIdentifier(token);
     Token extendsOrSuper = null;
-    if (optional('extends', token) ||
-        (enableGenericMethodSyntax && optional('super', token))) {
+    if (optional('extends', token) || optional('super', token)) {
       extendsOrSuper = token;
       token = parseType(token.next);
     } else {
       listener.handleNoType(token);
     }
     listener.endTypeVariable(token, extendsOrSuper);
     return token;
   }
 
   /**
@@ skipping 206 matching lines @@
     listener.handleModifiers(modifierCount);
     var kind = hasTypeOrModifier
         ? ErrorKind.EXTRANEOUS_MODIFIER
         : ErrorKind.EXTRANEOUS_MODIFIER_REPLACE;
     for (Token modifier in modifierList) {
       listener.reportError(modifier, kind, {'modifier': modifier});
     }
     return null;
   }
 
+  /// Removes the optional `covariant` token from the modifiers, if there
+  /// is no `static` in the list, and `covariant` is the first modifier.
+  Link<Token> removeOptCovariantTokenIfNotStatic(Link<Token> modifiers) {
+    if (modifiers.isEmpty ||
+        !identical(modifiers.first.stringValue, 'covariant')) {
+      return modifiers;
+    }
+    for (Token modifier in modifiers.tail) {
+      if (identical(modifier.stringValue, 'static')) {
+        return modifiers;
+      }
+    }
+    return modifiers.tail;
+  }
+
   Token parseFields(Token start, Link<Token> modifiers, Token type,
       Token getOrSet, Token name, bool isTopLevel) {
     bool hasType = type != null;
+
+    if (getOrSet == null && !isTopLevel) {
+      modifiers = removeOptCovariantTokenIfNotStatic(modifiers);
+    }
+
     Token varFinalOrConst =
         expectVarFinalOrConst(modifiers, hasType, !isTopLevel);
     bool isVar = false;
     bool hasModifier = false;
     if (varFinalOrConst != null) {
       hasModifier = true;
       isVar = optional('var', varFinalOrConst);
     }
 
     if (getOrSet != null) {
@@ skipping 58 matching lines @@
       listener.handleModifiers(0);
     }
 
     if (type == null) {
       listener.handleNoType(name);
     } else {
       parseReturnTypeOpt(type);
     }
     Token token = parseIdentifier(name);
 
-    if (enableGenericMethodSyntax && getOrSet == null) {
+    if (getOrSet == null) {
       token = parseTypeVariablesOpt(token);
     } else {
       listener.handleNoTypeVariables(token);
     }
     token = parseFormalParametersOpt(token);
     bool previousAsyncAwaitKeywordsEnabled = asyncAwaitKeywordsEnabled;
     token = parseAsyncModifier(token);
     token = parseFunctionBody(token, false, externalModifier != null);
     asyncAwaitKeywordsEnabled = previousAsyncAwaitKeywordsEnabled;
     Token endToken = token;
@@ skipping 264 matching lines @@
     return optional('factory', token);
   }
 
   Token parseMember(Token token) {
     token = parseMetadataStar(token);
     Token start = token;
     listener.beginMember(token);
     if (isFactoryDeclaration(token)) {
       token = parseFactoryMethod(token);
       listener.endMember();
-      assert (token != null);
+      assert(token != null);
       return token;
     }
 
     Link<Token> identifiers = findMemberName(token);
     if (identifiers.isEmpty) {
       return listener.expectedDeclaration(start);
     }
     Token afterName = identifiers.head;
     identifiers = identifiers.tail;
 
@@ skipping 26 matching lines @@
     token = afterName;
     bool isField;
     while (true) {
       // Loop to allow the listener to rewrite the token stream for
       // error handling.
       final String value = token.stringValue;
       if ((identical(value, '(')) ||
           (identical(value, '.')) ||
           (identical(value, '{')) ||
           (identical(value, '=>')) ||
-          (enableGenericMethodSyntax && identical(value, '<'))) {
+          (identical(value, '<'))) {
         isField = false;
         break;
       } else if (identical(value, ';')) {
         if (getOrSet != null) {
           // If we found a "get" keyword, this must be an abstract
           // getter.
           isField = (!identical(getOrSet.stringValue, 'get'));
           // TODO(ahe): This feels like a hack.
         } else {
           isField = true;
@@ skipping 74 matching lines @@
       token = parseOperatorName(name);
       if (staticModifier != null) {
         listener.reportError(staticModifier, ErrorKind.EXTRANEOUS_MODIFIER,
             {'modifier': staticModifier});
       }
     } else {
       token = parseIdentifier(name);
     }
 
     token = parseQualifiedRestOpt(token);
-    if (enableGenericMethodSyntax && getOrSet == null) {
+    if (getOrSet == null) {
       token = parseTypeVariablesOpt(token);
     } else {
       listener.handleNoTypeVariables(token);
     }
     token = parseFormalParametersOpt(token);
     token = parseInitializersOpt(token);
     bool previousAsyncAwaitKeywordsEnabled = asyncAwaitKeywordsEnabled;
     token = parseAsyncModifier(token);
     if (optional('=', token)) {
       token = parseRedirectingFactoryBody(token);
@@ skipping 70 matching lines @@
       }
       listener.beginFunctionName(token);
       if (optional('operator', token)) {
         token = parseOperatorName(token);
       } else {
         token = parseIdentifier(token);
       }
     }
     token = parseQualifiedRestOpt(token);
     listener.endFunctionName(token);
-    if (enableGenericMethodSyntax && getOrSet == null) {
+    if (getOrSet == null) {
       token = parseTypeVariablesOpt(token);
     } else {
       listener.handleNoTypeVariables(token);
     }
     token = parseFormalParametersOpt(token);
     token = parseInitializersOpt(token);
     bool previousAsyncAwaitKeywordsEnabled = asyncAwaitKeywordsEnabled;
     token = parseAsyncModifier(token);
     if (optional('=', token)) {
       token = parseRedirectingFactoryBody(token);
@@ skipping 24 matching lines @@
     return token;
   }
 
   Token parseFunctionExpression(Token token) {
     listener.beginFunction(token);
     listener.handleModifiers(0);
     token = parseReturnTypeOpt(token);
     listener.beginFunctionName(token);
     token = parseIdentifier(token);
     listener.endFunctionName(token);
-    if (enableGenericMethodSyntax) {
-      token = parseTypeVariablesOpt(token);
-    } else {
-      listener.handleNoTypeVariables(token);
-    }
+    token = parseTypeVariablesOpt(token);
     token = parseFormalParameters(token);
     listener.handleNoInitializers();
     bool previousAsyncAwaitKeywordsEnabled = asyncAwaitKeywordsEnabled;
     token = parseAsyncModifier(token);
     bool isBlock = optional('{', token);
     token = parseFunctionBody(token, true, false);
     asyncAwaitKeywordsEnabled = previousAsyncAwaitKeywordsEnabled;
     listener.endFunction(null, token);
     return isBlock ? token.next : token;
   }
@@ skipping 255 matching lines @@
         // TODO(eernst): Check for NPE as described in issue 26252.
         Token afterParens = endParen.next;
         if (optional('{', afterParens) ||
             optional('=>', afterParens) ||
             optional('async', afterParens) ||
             optional('sync', afterParens)) {
           // We are looking at "type identifier '(' ... ')'" followed
           // by '{', '=>', 'async', or 'sync'.
           return parseFunctionDeclaration(token);
         }
-      } else if (enableGenericMethodSyntax &&
-          identical(afterIdKind, LT_TOKEN)) {
+      } else if (identical(afterIdKind, LT_TOKEN)) {
         // We are looking at "type identifier '<'".
         BeginGroupToken beginAngle = afterId;
         Token endAngle = beginAngle.endGroup;
         if (endAngle != null &&
             identical(endAngle.next.kind, OPEN_PAREN_TOKEN)) {
           BeginGroupToken beginParen = endAngle.next;
           Token endParen = beginParen.endGroup;
           if (endParen != null) {
             Token afterParens = endParen.next;
             if (optional('{', afterParens) ||
@@ skipping 14 matching lines @@
       } else if (optional('(', token.next)) {
         BeginGroupToken begin = token.next;
         // TODO(eernst): Check for NPE as described in issue 26252.
         String afterParens = begin.endGroup.next.stringValue;
         if (identical(afterParens, '{') ||
             identical(afterParens, '=>') ||
             identical(afterParens, 'async') ||
             identical(afterParens, 'sync')) {
           return parseFunctionDeclaration(token);
         }
-      } else if (enableGenericMethodSyntax && optional('<', token.next)) {
+      } else if (optional('<', token.next)) {
         BeginGroupToken beginAngle = token.next;
         Token endAngle = beginAngle.endGroup;
         if (endAngle != null &&
             identical(endAngle.next.kind, OPEN_PAREN_TOKEN)) {
           BeginGroupToken beginParen = endAngle.next;
           Token endParen = beginParen.endGroup;
           if (endParen != null) {
             String afterParens = endParen.next.stringValue;
             if (identical(afterParens, '{') ||
                 identical(afterParens, '=>') ||
@@ skipping 493 matching lines @@
   /// Where
   ///   genericListLiteral ::= typeArguments '[' (expressionList ','?)? ']'
   ///   genericMapLiteral ::=
   ///       typeArguments '{' (mapLiteralEntry (',' mapLiteralEntry)* ','?)? '}'
   ///   genericFunctionLiteral ::=
   ///       typeParameters formalParameterList functionBody
   /// Provide token for [constKeyword] if preceded by 'const', null if not.
   Token parseLiteralListOrMapOrFunction(Token token, Token constKeyword) {
     assert(optional('<', token));
     BeginGroupToken begin = token;
-    if (enableGenericMethodSyntax &&
-        constKeyword == null &&
+    if (constKeyword == null &&
         begin.endGroup != null &&
         identical(begin.endGroup.next.kind, OPEN_PAREN_TOKEN)) {
       token = parseTypeVariablesOpt(token);
       return parseLiteralFunctionSuffix(token);
     } else {
       token = parseTypeArgumentsOpt(token);
       if (optional('{', token)) {
         return parseLiteralMapSuffix(token, constKeyword);
       } else if ((optional('[', token)) || (optional('[]', token))) {
         return parseLiteralListSuffix(token, constKeyword);
@@ skipping 22 matching lines @@
         isFunctionDeclaration(peek.next)) {
       return parseFunctionExpression(token);
     } else if (isFunctionDeclaration(token.next)) {
       return parseFunctionExpression(token);
     } else {
       return parseSend(token);
     }
   }
 
   bool isFunctionDeclaration(Token token) {
-    if (enableGenericMethodSyntax && optional('<', token)) {
+    if (optional('<', token)) {
       BeginGroupToken begin = token;
       if (begin.endGroup == null) return false;
       token = begin.endGroup.next;
     }
     if (optional('(', token)) {
       BeginGroupToken begin = token;
       // TODO(eernst): Check for NPE as described in issue 26252.
       String afterParens = begin.endGroup.next.stringValue;
       if (identical(afterParens, '{') ||
           identical(afterParens, '=>') ||
@@ skipping 128 matching lines @@
   }
 
   Token parseLiteralNull(Token token) {
     listener.handleLiteralNull(token);
     return token.next;
   }
 
   Token parseSend(Token token) {
     listener.beginSend(token);
     token = parseIdentifier(token);
-    if (enableGenericMethodSyntax && isValidMethodTypeArguments(token)) {
+    if (isValidMethodTypeArguments(token)) {
       token = parseTypeArgumentsOpt(token);
     } else {
       listener.handleNoTypeArguments(token);
     }
     token = parseArgumentsOpt(token);
     listener.endSend(token);
     return token;
   }
 
   Token skipArgumentsOpt(Token token) {
@@ skipping 466 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }