Add parser support for covariant parameters

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.
 
 library analyzer.src.generated.parser;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 71 matching lines @@
    */
   Token abstractKeyword;
 
   /**
    * The token representing the keyword 'const', or `null` if the keyword was
    * not found.
    */
   Token constKeyword;
 
   /**
+   * The token representing the keyword 'covariant', or `null` if the keyword
+   * was not found.
+   */
+  Token covariantKeyword;
+
+  /**
    * The token representing the keyword 'external', or `null` if the keyword was
    * not found.
    */
   Token externalKeyword;
 
   /**
    * The token representing the keyword 'factory', or `null` if the keyword was
    * not found.
    */
   Token factoryKeyword;
@@ skipping 1153 matching lines @@
             TokenType.COMMA,
             TokenType.SEMICOLON
           ])) {
             //
             // We appear to have a variable declaration with a type of "void".
             //
             _reportErrorForNode(ParserErrorCode.VOID_VARIABLE, returnType);
             return parseInitializedIdentifierList(
                 commentAndMetadata,
                 modifiers.staticKeyword,
+                modifiers.covariantKeyword,
                 _validateModifiersForField(modifiers),
                 returnType);
           }
         }
         if (_isOperator(_currentToken)) {
           //
           // We appear to have found an operator declaration without the
           // 'operator' keyword.
           //
           _validateModifiersForOperator(modifiers);
@@ skipping 44 matching lines @@
         return null;
       } else if (_isOperator(_currentToken)) {
         //
         // We appear to have found an operator declaration without the
         // 'operator' keyword.
         //
         _validateModifiersForOperator(modifiers);
         return parseOperator(
             commentAndMetadata, modifiers.externalKeyword, null);
       }
-      Token keyword = modifiers.varKeyword;
-      if (keyword == null) {
-        keyword = modifiers.finalKeyword;
-      }
-      if (keyword == null) {
-        keyword = modifiers.constKeyword;
-      }
+      Token keyword = modifiers.varKeyword ??
+          modifiers.finalKeyword ??
+          modifiers.constKeyword;
       if (keyword != null) {
         //
         // We appear to have found an incomplete field declaration.
         //
         _reportErrorForCurrentToken(ParserErrorCode.MISSING_IDENTIFIER);
         VariableDeclaration variable = astFactory.variableDeclaration(
             createSyntheticIdentifier(), null, null);
         List<VariableDeclaration> variables = <VariableDeclaration>[variable];
-        return astFactory.fieldDeclaration(
+        FieldDeclarationImpl field = astFactory.fieldDeclaration(
             commentAndMetadata.comment,
             commentAndMetadata.metadata,
             null,
             astFactory.variableDeclarationList(
                 null, null, keyword, null, variables),
             _expect(TokenType.SEMICOLON));
+        field.covariantKeyword = modifiers.covariantKeyword;
+        return field;
       }
       _reportErrorForToken(
           ParserErrorCode.EXPECTED_CLASS_MEMBER, _currentToken);
       if (commentAndMetadata.comment != null ||
           commentAndMetadata.hasMetadata) {
         //
         // 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.
@@ skipping 58 matching lines @@
       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);
+      return parseInitializedIdentifierList(
+          commentAndMetadata,
+          modifiers.staticKeyword,
+          modifiers.covariantKeyword,
+          _validateModifiersForField(modifiers),
+          null);
     } else if (keyword == Keyword.TYPEDEF) {
       _reportErrorForCurrentToken(ParserErrorCode.TYPEDEF_IN_CLASS);
       // TODO(brianwilkerson) We don't currently have any way to capture the
       // function type alias that was parsed.
       _parseFunctionTypeAlias(commentAndMetadata, getAndAdvance());
       return null;
     } else {
       Token token = _skipTypeParameterList(_peek());
       if (token != null && _tokenMatches(token, TokenType.OPEN_PAREN)) {
         return _parseMethodDeclarationAfterReturnType(commentAndMetadata,
@@ skipping 19 matching lines @@
     } else if (!_matchesIdentifier()) {
       if (_matches(TokenType.CLOSE_CURLY_BRACKET)) {
         //
         // We appear to have found an incomplete declaration at the end of the
         // class. At this point it consists of a type name, so we'll treat it as
         // a field declaration with a missing field name and semicolon.
         //
         return parseInitializedIdentifierList(
             commentAndMetadata,
             modifiers.staticKeyword,
+            modifiers.covariantKeyword,
             _validateModifiersForField(modifiers),
             type);
       }
       if (_isOperator(_currentToken)) {
         //
         // We appear to have found an operator declaration without the
         // 'operator' keyword.
         //
         _validateModifiersForOperator(modifiers);
         return parseOperator(
             commentAndMetadata, modifiers.externalKeyword, type);
       }
       //
       // We appear to have found an incomplete declaration before another
       // declaration. At this point it consists of a type name, so we'll treat
       // it as a field declaration with a missing field name and semicolon.
       //
       _reportErrorForToken(
           ParserErrorCode.EXPECTED_CLASS_MEMBER, _currentToken);
       try {
         _lockErrorListener();
         return parseInitializedIdentifierList(
             commentAndMetadata,
             modifiers.staticKeyword,
+            modifiers.covariantKeyword,
             _validateModifiersForField(modifiers),
             type);
       } finally {
         _unlockErrorListener();
       }
     } else if (_tokenMatches(next, TokenType.OPEN_PAREN)) {
       SimpleIdentifier methodName =
           _parseSimpleIdentifierUnchecked(isDeclaration: true);
       TypeParameterList typeParameters = _parseGenericCommentTypeParameters();
       FormalParameterList parameters = parseFormalParameterList();
@@ skipping 25 matching lines @@
     } else if (_tokenMatches(next, 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);
     }
-    return parseInitializedIdentifierList(commentAndMetadata,
-        modifiers.staticKeyword, _validateModifiersForField(modifiers), type);
+    return parseInitializedIdentifierList(
+        commentAndMetadata,
+        modifiers.staticKeyword,
+        modifiers.covariantKeyword,
+        _validateModifiersForField(modifiers),
+        type);
   }
 
   /**
    * Parse a single combinator. Return the combinator that was parsed, or `null`
    * if no combinator is found.
    *
    *     combinator ::=
    *         'show' identifier (',' identifier)*
    *       | 'hide' identifier (',' identifier)*
    */
@@ skipping 1988 matching lines @@
 
   /**
    * Parse a list of initialized identifiers. The [commentAndMetadata] is the
    * documentation comment and metadata to be associated with the declaration.
    * The [staticKeyword] is the static keyword, or `null` if the getter is not
    * static. The [keyword] is the token representing the 'final', 'const' or
    * 'var' keyword, or `null` if there is no keyword. The [type] is the type
    * that has already been parsed, or `null` if 'var' was provided. Return the
    * getter that was parsed.
    *
-   *     ?? ::=
-   *         'static'? ('var' | type) initializedIdentifierList ';'
+   *     declaration ::=
+   *         ('static' | 'covariant')? ('var' | type) initializedIdentifierList ';'
    *       | 'final' type? initializedIdentifierList ';'
    *
    *     initializedIdentifierList ::=
    *         initializedIdentifier (',' initializedIdentifier)*
    *
    *     initializedIdentifier ::=
    *         identifier ('=' expression)?
    */
   FieldDeclaration parseInitializedIdentifierList(
       CommentAndMetadata commentAndMetadata,
       Token staticKeyword,
+      Token covariantKeyword,
       Token keyword,
       TypeAnnotation type) {
     VariableDeclarationList fieldList =
         parseVariableDeclarationListAfterType(null, keyword, type);
-    return astFactory.fieldDeclaration(
+    FieldDeclarationImpl field = astFactory.fieldDeclaration(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         staticKeyword,
         fieldList,
         _expect(TokenType.SEMICOLON));
+    field.covariantKeyword = covariantKeyword;
+    return field;
   }
 
   /**
    * Parse an instance creation expression. The [keyword] is the 'new' or
    * 'const' keyword that introduces the expression. Return the instance
    * creation expression that was parsed.
    *
    *     instanceCreationExpression ::=
    *         ('new' | 'const') type ('.' identifier)? argumentList
    */
@@ skipping 236 matching lines @@
           modifiers.abstractKeyword = getAndAdvance();
         }
       } else if (keyword == Keyword.CONST) {
         if (modifiers.constKeyword != null) {
           _reportErrorForCurrentToken(
               ParserErrorCode.DUPLICATED_MODIFIER, [_currentToken.lexeme]);
           _advance();
         } else {
           modifiers.constKeyword = getAndAdvance();
         }
+      } else if (keyword == Keyword.COVARIANT) {
+        if (modifiers.constKeyword != null) {
+          _reportErrorForCurrentToken(
+              ParserErrorCode.DUPLICATED_MODIFIER, [_currentToken.lexeme]);
+          _advance();
+        } else {
+          modifiers.covariantKeyword = getAndAdvance();
+        }
       } else if (keyword == Keyword.EXTERNAL) {
         if (modifiers.externalKeyword != null) {
           _reportErrorForCurrentToken(
               ParserErrorCode.DUPLICATED_MODIFIER, [_currentToken.lexeme]);
           _advance();
         } else {
           modifiers.externalKeyword = getAndAdvance();
         }
       } else if (keyword == Keyword.FACTORY) {
         if (modifiers.factoryKeyword != null) {
@@ skipping 265 matching lines @@
    *
    *     fieldFormalParameter ::=
    *         metadata finalConstVarOrType? 'this' '.' identifier
    *
    *     simpleFormalParameter ::=
    *         declaredIdentifier
    *       | metadata identifier
    */
   NormalFormalParameter parseNormalFormalParameter(
       {bool inFunctionType: false}) {
+    Token covariantKeyword;
     CommentAndMetadata commentAndMetadata = parseCommentAndMetadata();
+    if (_matchesKeyword(Keyword.COVARIANT)) {
+      covariantKeyword = getAndAdvance();
+    }
     FinalConstVarOrType holder = parseFinalConstVarOrType(!inFunctionType,
         inFunctionType: inFunctionType);
     Token thisKeyword = null;
     Token period = null;
     if (_matchesKeyword(Keyword.THIS)) {
       thisKeyword = getAndAdvance();
       period = _expect(TokenType.PERIOD);
     }
     if (!_matchesIdentifier() && inFunctionType) {
-      return astFactory.simpleFormalParameter(commentAndMetadata.comment,
-          commentAndMetadata.metadata, holder.keyword, holder.type, null);
+      SimpleFormalParameterImpl parameter = astFactory.simpleFormalParameter(
+          commentAndMetadata.comment,
+          commentAndMetadata.metadata,
+          holder.keyword,
+          holder.type,
+          null);
+      parameter.covariantKeyword = covariantKeyword;
+      return parameter;
     }
     SimpleIdentifier identifier = parseSimpleIdentifier();
     TypeParameterList typeParameters = _parseGenericMethodTypeParameters();
     if (_matches(TokenType.OPEN_PAREN)) {
       FormalParameterList parameters = _parseFormalParameterListUnchecked();
       if (thisKeyword == null) {
         if (holder.keyword != null) {
           _reportErrorForToken(
               ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR, holder.keyword);
         }
         Token question = null;
         if (enableNnbd && _matches(TokenType.QUESTION)) {
           question = getAndAdvance();
         }
-        return astFactory.functionTypedFormalParameter(
-            commentAndMetadata.comment,
-            commentAndMetadata.metadata,
-            holder.type,
-            astFactory.simpleIdentifier(identifier.token, isDeclaration: true),
-            typeParameters,
-            parameters,
-            question: question);
+        FunctionTypedFormalParameterImpl parameter =
+            astFactory.functionTypedFormalParameter(
+                commentAndMetadata.comment,
+                commentAndMetadata.metadata,
+                holder.type,
+                astFactory.simpleIdentifier(identifier.token,
+                    isDeclaration: true),
+                typeParameters,
+                parameters,
+                question: question);
+        parameter.covariantKeyword = covariantKeyword;
+        return parameter;
       } else {
-        return astFactory.fieldFormalParameter(
+        FieldFormalParameterImpl parameter = astFactory.fieldFormalParameter(
             commentAndMetadata.comment,
             commentAndMetadata.metadata,
             holder.keyword,
             holder.type,
             thisKeyword,
             period,
             identifier,
             typeParameters,
             parameters);
+        parameter.covariantKeyword = covariantKeyword;
+        return parameter;
       }
     } else if (typeParameters != null) {
       // TODO(brianwilkerson) Report an error. It looks like a function-typed
       // parameter with no parameter list.
       //_reportErrorForToken(ParserErrorCode.MISSING_PARAMETERS, typeParameters.endToken);
     }
     TypeAnnotation type = holder.type;
     if (type != null) {
       if (type is TypeName &&
           _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) {
       // TODO(brianwilkerson) If there are type parameters but no parameters,
       // should we create a synthetic empty parameter list here so we can
       // capture the type parameters?
-      return astFactory.fieldFormalParameter(
+      FieldFormalParameterImpl parameter = astFactory.fieldFormalParameter(
           commentAndMetadata.comment,
           commentAndMetadata.metadata,
           holder.keyword,
           type,
           thisKeyword,
           period,
           identifier,
           null,
           null);
+      parameter.covariantKeyword = covariantKeyword;
+      return parameter;
     }
-    return astFactory.simpleFormalParameter(
+    SimpleFormalParameterImpl parameter = astFactory.simpleFormalParameter(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         holder.keyword,
         type,
         astFactory.simpleIdentifier(identifier.token, isDeclaration: true));
+    parameter.covariantKeyword = covariantKeyword;
+    return parameter;
   }
 
   /**
    * Parse an operator declaration. The [commentAndMetadata] is the
    * documentation comment and metadata to be associated with the declaration.
    * The [externalKeyword] is the 'external' token. The [returnType] is the
    * return type that has already been parsed, or `null` if there was no return
    * type. Return the operator declaration that was parsed.
    *
    *     operatorDeclaration ::=
@@ skipping 3919 matching lines @@
 
   /**
    * Validate that the given set of [modifiers] is appropriate for a constructor
    * and return the 'const' keyword if there is one.
    */
   Token _validateModifiersForConstructor(Modifiers modifiers) {
     if (modifiers.abstractKeyword != null) {
       _reportErrorForToken(
           ParserErrorCode.ABSTRACT_CLASS_MEMBER, modifiers.abstractKeyword);
     }
+    if (modifiers.covariantKeyword != null) {
+      _reportErrorForToken(
+          ParserErrorCode.COVARIANT_CONSTRUCTOR, modifiers.covariantKeyword);
+    }
     if (modifiers.finalKeyword != null) {
       _reportErrorForToken(
           ParserErrorCode.FINAL_CONSTRUCTOR, modifiers.finalKeyword);
     }
     if (modifiers.staticKeyword != null) {
       _reportErrorForToken(
           ParserErrorCode.STATIC_CONSTRUCTOR, modifiers.staticKeyword);
     }
     if (modifiers.varKeyword != null) {
       _reportErrorForToken(
@@ skipping 52 matching lines @@
     }
     if (modifiers.externalKeyword != null) {
       _reportErrorForToken(
           ParserErrorCode.EXTERNAL_FIELD, modifiers.externalKeyword);
     }
     if (modifiers.factoryKeyword != null) {
       _reportErrorForToken(
           ParserErrorCode.NON_CONSTRUCTOR_FACTORY, modifiers.factoryKeyword);
     }
     Token staticKeyword = modifiers.staticKeyword;
+    Token covariantKeyword = modifiers.covariantKeyword;
     Token constKeyword = modifiers.constKeyword;
     Token finalKeyword = modifiers.finalKeyword;
     Token varKeyword = modifiers.varKeyword;
     if (constKeyword != null) {
+      if (covariantKeyword != null) {
+        _reportErrorForToken(
+            ParserErrorCode.CONST_AND_COVARIANT, covariantKeyword);
+      }
       if (finalKeyword != null) {
         _reportErrorForToken(ParserErrorCode.CONST_AND_FINAL, finalKeyword);
       }
       if (varKeyword != null) {
         _reportErrorForToken(ParserErrorCode.CONST_AND_VAR, varKeyword);
       }
       if (staticKeyword != null && constKeyword.offset < staticKeyword.offset) {
         _reportErrorForToken(ParserErrorCode.STATIC_AFTER_CONST, staticKeyword);
       }
     } else if (finalKeyword != null) {
+      if (covariantKeyword != null) {
+        _reportErrorForToken(
+            ParserErrorCode.FINAL_AND_COVARIANT, covariantKeyword);
+      }
       if (varKeyword != null) {
         _reportErrorForToken(ParserErrorCode.FINAL_AND_VAR, varKeyword);
       }
       if (staticKeyword != null && finalKeyword.offset < staticKeyword.offset) {
         _reportErrorForToken(ParserErrorCode.STATIC_AFTER_FINAL, staticKeyword);
       }
-    } else if (varKeyword != null &&
-        staticKeyword != null &&
-        varKeyword.offset < staticKeyword.offset) {
-      _reportErrorForToken(ParserErrorCode.STATIC_AFTER_VAR, staticKeyword);
+    } else if (varKeyword != null) {
+      if (staticKeyword != null && varKeyword.offset < staticKeyword.offset) {
+        _reportErrorForToken(ParserErrorCode.STATIC_AFTER_VAR, staticKeyword);
+      }
+      if (covariantKeyword != null &&
+          varKeyword.offset < covariantKeyword.offset) {
+        _reportErrorForToken(
+            ParserErrorCode.COVARIANT_AFTER_VAR, covariantKeyword);
+      }
+    }
+    if (covariantKeyword != null && staticKeyword != null) {
+      _reportErrorForToken(ParserErrorCode.COVARIANT_AND_STATIC, staticKeyword);
     }
     return Token.lexicallyFirst([constKeyword, finalKeyword, varKeyword]);
   }
 
   /**
    * Validate that the given set of [modifiers] is appropriate for a local
    * function.
    */
   void _validateModifiersForFunctionDeclarationStatement(Modifiers modifiers) {
     if (modifiers.abstractKeyword != null ||
@@ skipping 70 matching lines @@
       _reportErrorForToken(
           ParserErrorCode.VAR_RETURN_TYPE, modifiers.varKeyword);
     }
   }
 
   /**
    * Validate that the given set of [modifiers] is appropriate for a top-level
    * declaration.
    */
   void _validateModifiersForTopLevelDeclaration(Modifiers modifiers) {
+    if (modifiers.covariantKeyword != null) {
+      _reportErrorForToken(ParserErrorCode.COVARIANT_TOP_LEVEL_DECLARATION,
+          modifiers.covariantKeyword);
+    }
     if (modifiers.factoryKeyword != null) {
       _reportErrorForToken(ParserErrorCode.FACTORY_TOP_LEVEL_DECLARATION,
           modifiers.factoryKeyword);
     }
     if (modifiers.staticKeyword != null) {
       _reportErrorForToken(ParserErrorCode.STATIC_TOP_LEVEL_DECLARATION,
           modifiers.staticKeyword);
     }
   }
 
@@ skipping 87 matching lines @@
    */
   Parser_SyntheticKeywordToken(Keyword keyword, int offset)
       : super(keyword, offset);
 
   @override
   int get length => 0;
 
   @override
   Token copy() => new Parser_SyntheticKeywordToken(keyword, offset);
 }