Revert "Add NormalFormalParameter.covariantKeyword setter and factory parameter."

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 4145 matching lines @@
     }
     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(
+      SimpleFormalParameterImpl parameter = astFactory.simpleFormalParameter(
           commentAndMetadata.comment,
           commentAndMetadata.metadata,
-          covariantKeyword,
           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(
+        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 {
+        FieldFormalParameterImpl parameter = astFactory.fieldFormalParameter(
             commentAndMetadata.comment,
             commentAndMetadata.metadata,
-            covariantKeyword,
-            holder.type,
-            astFactory.simpleIdentifier(identifier.token, isDeclaration: true),
-            typeParameters,
-            parameters,
-            question: question);
-      } else {
-        return astFactory.fieldFormalParameter(
-            commentAndMetadata.comment,
-            commentAndMetadata.metadata,
-            covariantKeyword,
             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,
-          covariantKeyword,
           holder.keyword,
           type,
           thisKeyword,
           period,
           identifier,
           null,
           null);
+      parameter.covariantKeyword = covariantKeyword;
+      return parameter;
     }
-    return astFactory.simpleFormalParameter(
+    SimpleFormalParameterImpl parameter = astFactory.simpleFormalParameter(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
-        covariantKeyword,
         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 4244 matching lines @@
    */
   Parser_SyntheticKeywordToken(Keyword keyword, int offset)
       : super(keyword, offset);
 
   @override
   int get length => 0;
 
   @override
   Token copy() => new Parser_SyntheticKeywordToken(keyword, offset);
 }