Add parser support for covariant parameters

pkg/analyzer/lib/src/generated/error_verifier.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.error_verifier;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 721 matching lines @@
 
   @override
   Object visitForEachStatement(ForEachStatement node) {
     _checkForInIterable(node);
     return super.visitForEachStatement(node);
   }
 
   @override
   Object visitFormalParameterList(FormalParameterList node) {
     _checkDuplicateDefinitionInParameterList(node);
+    _checkUseOfCovariantInParameters(node);
     return super.visitFormalParameterList(node);
   }
 
   @override
   Object visitForStatement(ForStatement node) {
     if (node.condition != null) {
       _checkForNonBoolCondition(node.condition);
     }
     if (node.variables != null) {
       _checkDuplicateVariables(node.variables);
@@ skipping 5411 matching lines @@
         if (shouldSubstitute) {
           boundType = boundType.substitute2(argumentTypes, parameterTypes);
         }
         if (!_typeSystem.isSubtypeOf(argType, boundType)) {
           reportError(argument, argType, boundType);
         }
       }
     }
   }
 
+  void _checkUseOfCovariantInParameters(FormalParameterList node) {
+    AstNode parent = node.parent;
+    if (parent is MethodDeclaration && !parent.isStatic) {
+      return;
+    }
+    NodeList<FormalParameter> parameters = node.parameters;
+    int length = parameters.length;
+    for (int i = 0; i < length; i++) {
+      FormalParameter parameter = parameters[i];
+      Token keyword = parameter.covariantKeyword;
+      if (keyword != null) {
+        _errorReporter.reportErrorForToken(
+            CompileTimeErrorCode.INVALID_USE_OF_COVARIANT, keyword);
+      }
+    }
+  }
+
   DartType _computeReturnTypeForMethod(Expression returnExpression) {
     // This method should never be called for generators, since generators are
     // never allowed to contain return statements with expressions.
     assert(!_inGenerator);
     if (returnExpression == null) {
       if (_enclosingFunction.isAsynchronous) {
         return _typeProvider.futureNullType;
       } else {
         return VoidTypeImpl.instance;
       }
@@ skipping 837 matching lines @@
 class _InvocationCollector extends RecursiveAstVisitor {
   final List<String> superCalls = <String>[];
 
   @override
   visitMethodInvocation(MethodInvocation node) {
     if (node.target is SuperExpression) {
       superCalls.add(node.methodName.name);
     }
   }
 }