Support for the 'covariant' keyword for formal parameters.

pkg/front_end/lib/src/fasta/parser/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 fasta.parser.parser;
 
 import '../scanner.dart' show
     ErrorToken;
 
 import '../scanner/recover.dart' show
@@ skipping 481 matching lines @@
 
   Token parseFormalParameter(Token token, FormalParameterType kind,
       {bool inFunctionType: false}) {
     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);
+    Token covariantKeyword;
     if (identical(token.stringValue, 'covariant') &&
         (token.next.isIdentifier() || isModifier(token.next))) {
+      covariantKeyword = token;
       token = token.next;
     }
     token = parseModifiers(token);
     bool isNamedParameter = kind == FormalParameterType.NAMED;
 
     Token thisKeyword = null;
     if (inFunctionType && isNamedParameter) {
       token = parseType(token);
       token =
           parseIdentifier(token, IdentifierContext.formalParameterDeclaration);
@@ skipping 53 matching lines @@
       if (kind.isRequired) {
         reportRecoverableError(
             equal, ErrorKind.RequiredParameterWithDefault);
       } else if (kind.isPositional && identical(':', value)) {
         reportRecoverableError(
             equal, ErrorKind.PositionalParameterWithEquals);
       }
     } else {
       listener.handleFormalParameterWithoutValue(token);
     }
-    listener.endFormalParameter(thisKeyword, kind);
+    listener.endFormalParameter(covariantKeyword, thisKeyword, kind);
     return token;
   }
 
   Token parseOptionalFormalParameters(Token token, bool isNamed,
       {bool inFunctionType: false}) {
     Token begin = token;
     listener.beginOptionalFormalParameters(begin);
     assert((isNamed && optional('{', token)) || optional('[', token));
     int parameterCount = 0;
     do {
@@ skipping 2955 matching lines @@
         break;
     }
     if (isRecoverable) {
       listener.handleRecoverableError(token, kind, arguments);
       return null;
     } else {
       return listener.handleUnrecoverableError(token, kind, arguments);
     }
   }
 }