Element model support for covariant

pkg/analyzer/lib/src/dart/element/element.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.element;
 
 import 'dart:collection';
 import 'dart:math' show min;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 4200 matching lines @@
           unlinkedVariable, enclosingClass);
     } else {
       return new FieldElementImpl.forSerialized(
           unlinkedVariable, enclosingClass);
     }
   }
 
   @override
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
 
+  /**
+   * Return `true` if this field was explicitly marked as being covariant.
+   */
+  bool get isCovariant {
+    if (_unlinkedVariable != null) {
+      return _unlinkedVariable.isCovariant;
+    }
+    return hasModifier(Modifier.COVARIANT);
+  }
+
+  /**
+   * Set whether this field is explicitly marked as being covariant.
+   */
+  void set isCovariant(bool isCovariant) {
+    _assertNotResynthesized(_unlinkedVariable);
+    setModifier(Modifier.COVARIANT, isCovariant);
+  }
+
   @override
   bool get isEnumConstant =>
       enclosingElement != null ? enclosingElement.isEnum : false;
 
   @override
   bool get isStatic {
     if (_unlinkedVariable != null) {
       return _unlinkedVariable.isStatic;
     }
     return hasModifier(Modifier.STATIC);
@@ skipping 2053 matching lines @@
    * asynchronous.
    */
   static const Modifier ASYNCHRONOUS = const Modifier('ASYNCHRONOUS', 1);
 
   /**
    * Indicates that the modifier 'const' was applied to the element.
    */
   static const Modifier CONST = const Modifier('CONST', 2);
 
   /**
+   * Indicates that the modifier 'covariant' was applied to the element.
+   */
+  static const Modifier COVARIANT = const Modifier('COVARIANT', 3);
+
+  /**
    * Indicates that the import element represents a deferred library.
    */
-  static const Modifier DEFERRED = const Modifier('DEFERRED', 3);
+  static const Modifier DEFERRED = const Modifier('DEFERRED', 4);
 
   /**
    * Indicates that a class element was defined by an enum declaration.
    */
-  static const Modifier ENUM = const Modifier('ENUM', 4);
+  static const Modifier ENUM = const Modifier('ENUM', 5);
 
   /**
    * Indicates that a class element was defined by an enum declaration.
    */
-  static const Modifier EXTERNAL = const Modifier('EXTERNAL', 5);
+  static const Modifier EXTERNAL = const Modifier('EXTERNAL', 6);
 
   /**
    * Indicates that the modifier 'factory' was applied to the element.
    */
-  static const Modifier FACTORY = const Modifier('FACTORY', 6);
+  static const Modifier FACTORY = const Modifier('FACTORY', 7);
 
   /**
    * Indicates that the modifier 'final' was applied to the element.
    */
-  static const Modifier FINAL = const Modifier('FINAL', 7);
+  static const Modifier FINAL = const Modifier('FINAL', 8);
 
   /**
    * Indicates that an executable element has a body marked as being a
    * generator.
    */
-  static const Modifier GENERATOR = const Modifier('GENERATOR', 8);
+  static const Modifier GENERATOR = const Modifier('GENERATOR', 9);
 
   /**
    * Indicates that the pseudo-modifier 'get' was applied to the element.
    */
-  static const Modifier GETTER = const Modifier('GETTER', 9);
+  static const Modifier GETTER = const Modifier('GETTER', 10);
 
   /**
    * A flag used for libraries indicating that the defining compilation unit
    * contains at least one import directive whose URI uses the "dart-ext"
    * scheme.
    */
-  static const Modifier HAS_EXT_URI = const Modifier('HAS_EXT_URI', 10);
+  static const Modifier HAS_EXT_URI = const Modifier('HAS_EXT_URI', 11);
 
   /**
    * Indicates that the associated element did not have an explicit type
    * associated with it. If the element is an [ExecutableElement], then the
    * type being referred to is the return type.
    */
-  static const Modifier IMPLICIT_TYPE = const Modifier('IMPLICIT_TYPE', 11);
+  static const Modifier IMPLICIT_TYPE = const Modifier('IMPLICIT_TYPE', 12);
 
   /**
    * Indicates that a class is a mixin application.
    */
   static const Modifier MIXIN_APPLICATION =
-      const Modifier('MIXIN_APPLICATION', 12);
+      const Modifier('MIXIN_APPLICATION', 13);
 
   /**
    * Indicates that a class contains an explicit reference to 'super'.
    */
   static const Modifier REFERENCES_SUPER =
-      const Modifier('REFERENCES_SUPER', 13);
+      const Modifier('REFERENCES_SUPER', 14);
 
   /**
    * Indicates that the pseudo-modifier 'set' was applied to the element.
    */
-  static const Modifier SETTER = const Modifier('SETTER', 14);
+  static const Modifier SETTER = const Modifier('SETTER', 15);
 
   /**
    * Indicates that the modifier 'static' was applied to the element.
    */
-  static const Modifier STATIC = const Modifier('STATIC', 15);
+  static const Modifier STATIC = const Modifier('STATIC', 16);
 
   /**
    * Indicates that the element does not appear in the source code but was
    * implicitly created. For example, if a class does not define any
    * constructors, an implicit zero-argument constructor will be created and it
    * will be marked as being synthetic.
    */
-  static const Modifier SYNTHETIC = const Modifier('SYNTHETIC', 16);
+  static const Modifier SYNTHETIC = const Modifier('SYNTHETIC', 17);
 
   static const List<Modifier> values = const [
     ABSTRACT,
     ASYNCHRONOUS,
     CONST,
+    COVARIANT,
     DEFERRED,
     ENUM,
     EXTERNAL,
     FACTORY,
     FINAL,
     GENERATOR,
     GETTER,
     HAS_EXT_URI,
     IMPLICIT_TYPE,
     MIXIN_APPLICATION,
@@ skipping 697 matching lines @@
   }
 
   @override
   void set isConst(bool isConst) {
     _assertNotResynthesized(_unlinkedParam);
     super.isConst = isConst;
   }
 
   @override
   bool get isCovariant {
-    if (inheritsCovariant) {
+    if (isExplicitlyCovariant || inheritsCovariant) {
       return true;
     }
     for (ElementAnnotationImpl annotation in metadata) {
       if (annotation.isCovariant) {
         return true;
       }
     }
     return false;
   }
 
+  /**
+   * Return true if this parameter is explicitly marked as being covariant.
+   */
+  bool get isExplicitlyCovariant {
+    if (_unlinkedParam != null) {
+      return _unlinkedParam.isExplicitlyCovariant;
+    }
+    return hasModifier(Modifier.COVARIANT);
+  }
+
+  /**
+   * Set whether this variable parameter is explicitly marked as being covariant.
+   */
+  void set isExplicitlyCovariant(bool isCovariant) {
+    _assertNotResynthesized(_unlinkedParam);
+    setModifier(Modifier.COVARIANT, isCovariant);
+  }
+
   @override
   bool get isFinal {
     if (_unlinkedParam != null) {
       return false;
     }
     return super.isFinal;
   }
 
   @override
   void set isFinal(bool isFinal) {
@@ skipping 246 matching lines @@
       PropertyAccessorElementImpl_ImplicitSetter setter)
       : setter = setter,
         super('_${setter.variable.name}', setter.variable.nameOffset) {
     enclosingElement = setter;
     isSynthetic = true;
     parameterKind = ParameterKind.REQUIRED;
   }
 
   @override
   bool get isCovariant {
-    if (inheritsCovariant) {
+    if (isExplicitlyCovariant || inheritsCovariant) {
       return true;
     }
     for (ElementAnnotationImpl annotation in setter.variable.metadata) {
       if (annotation.isCovariant) {
         return true;
       }
     }
     return false;
   }
 
   @override
+  bool get isExplicitlyCovariant {
+    PropertyInducingElement variable = setter.variable;
+    if (variable is FieldElementImpl) {
+      return variable.isCovariant;
+    }
+    return false;
+  }
+
+  @override
   DartType get type => setter.variable.type;
 
   @override
   void set type(DartType type) {
     assert(false); // Should never be called.
   }
 }
 
 /**
  * A mixin that provides a common implementation for methods defined in
@@ skipping 1156 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }