Element model support for covariant

pkg/analyzer/lib/src/dart/element/builder.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.dart.element.builder;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 218 matching lines @@
   @override
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       FieldElement field =
           _fieldMap == null ? null : _fieldMap[parameterName.name];
       FieldFormalParameterElementImpl parameter =
           new FieldFormalParameterElementImpl.forNode(parameterName);
       _setCodeRange(parameter, node);
       parameter.isConst = node.isConst;
+      parameter.isExplicitlyCovariant = node.covariantKeyword != null;
       parameter.isFinal = node.isFinal;
       parameter.parameterKind = node.kind;
       if (field != null) {
         parameter.field = field;
       }
       _currentHolder.addParameter(parameter);
       parameterName.staticElement = parameter;
     }
     //
     // The children of this parameter include any parameters defined on the type
@@ skipping 365 matching lines @@
     VariableElementImpl element;
     if (fieldNode != null) {
       SimpleIdentifier fieldName = node.name;
       FieldElementImpl field;
       if ((isConst || isFinal && !fieldNode.isStatic) && hasInitializer) {
         field = new ConstFieldElementImpl.forNode(fieldName);
       } else {
         field = new FieldElementImpl.forNode(fieldName);
       }
       element = field;
+      field.isCovariant = fieldNode.covariantKeyword != null;
       field.isStatic = fieldNode.isStatic;
       _setCodeRange(element, node);
       setElementDocumentationComment(element, fieldNode);
       field.hasImplicitType = varList.type == null;
       _currentHolder.addField(field);
       fieldName.staticElement = field;
     } else {
       SimpleIdentifier variableName = node.name;
       TopLevelVariableElementImpl variable;
       if (isConst && hasInitializer) {
@@ skipping 12 matching lines @@
     }
     element.isConst = isConst;
     element.isFinal = isFinal;
     if (element is PropertyInducingElementImpl) {
       PropertyAccessorElementImpl_ImplicitGetter getter =
           new PropertyAccessorElementImpl_ImplicitGetter(element);
       _currentHolder.addAccessor(getter);
       if (!isConst && !isFinal) {
         PropertyAccessorElementImpl_ImplicitSetter setter =
             new PropertyAccessorElementImpl_ImplicitSetter(element);
+        if (fieldNode != null) {
+          (setter.parameters[0] as ParameterElementImpl).isExplicitlyCovariant =
+              fieldNode.covariantKeyword != null;
+        }
         _currentHolder.addAccessor(setter);
       }
     }
     return null;
   }
 
   @override
   Object visitVariableDeclarationList(VariableDeclarationList node) {
     super.visitVariableDeclarationList(node);
     AstNode parent = node.parent;
@@ skipping 716 matching lines @@
     if (normalParameter is FieldFormalParameter) {
       DefaultFieldFormalParameterElementImpl fieldParameter =
           new DefaultFieldFormalParameterElementImpl.forNode(parameterName);
       _setFieldParameterField(fieldParameter);
       parameter = fieldParameter;
     } else {
       parameter = new DefaultParameterElementImpl.forNode(parameterName);
     }
     _setCodeRange(parameter, node);
     parameter.isConst = node.isConst;
+    parameter.isExplicitlyCovariant = node.parameter.covariantKeyword != null;
     parameter.isFinal = node.isFinal;
     parameter.parameterKind = node.kind;
     // visible range
     _setParameterVisibleRange(node, parameter);
     if (normalParameter is SimpleFormalParameter &&
         normalParameter.type == null) {
       parameter.hasImplicitType = true;
     }
     _currentHolder.addParameter(parameter);
     parameterName.staticElement = parameter;
     normalParameter.accept(this);
     return null;
   }
 
   @override
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElementImpl parameter =
           new ParameterElementImpl.forNode(parameterName);
       _setCodeRange(parameter, node);
+      parameter.isConst = node.isConst;
+      parameter.isExplicitlyCovariant = node.covariantKeyword != null;
+      parameter.isFinal = node.isFinal;
       parameter.parameterKind = node.kind;
       _setParameterVisibleRange(node, parameter);
       _currentHolder.addParameter(parameter);
       parameterName.staticElement = parameter;
     }
     //
     // The children of this parameter include any parameters defined on the type
     //of this parameter.
     //
     ElementHolder holder = new ElementHolder();
     _visitChildren(holder, node);
     ParameterElementImpl element = node.element;
     element.metadata = _createElementAnnotations(node.metadata);
     element.parameters = holder.parameters;
     element.typeParameters = holder.typeParameters;
     holder.validate();
     return null;
   }
 
   @override
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElementImpl parameter =
           new ParameterElementImpl.forNode(parameterName);
       _setCodeRange(parameter, node);
       parameter.isConst = node.isConst;
+      parameter.isExplicitlyCovariant = node.covariantKeyword != null;
       parameter.isFinal = node.isFinal;
       parameter.parameterKind = node.kind;
       _setParameterVisibleRange(node, parameter);
       if (node.type == null) {
         parameter.hasImplicitType = true;
       }
       _currentHolder.addParameter(parameter);
       parameterName.staticElement = parameter;
     }
     super.visitSimpleFormalParameter(node);
@@ skipping 164 matching lines @@
     return null;
   }
 
   /**
    * Return the lexical identifiers associated with the given [identifiers].
    */
   static List<String> _getIdentifiers(NodeList<SimpleIdentifier> identifiers) {
     return identifiers.map((identifier) => identifier.name).toList();
   }
 }