Clean up analyzer_experimental after Annotation disambiguation.

pkg/analyzer_experimental/lib/src/generated/element.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 library engine.element;
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'source.dart';
 import 'scanner.dart' show Keyword;
 import 'ast.dart' show Identifier, LibraryIdentifier;
 import 'sdk.dart' show DartSdk;
 import 'html.dart' show XmlTagNode;
 import 'engine.dart' show AnalysisContext;
 import 'constant.dart' show EvaluationResultImpl;
 import 'utilities_dart.dart';
 /**
- * The interface {@code Annotation} defines the behavior of objects representing a single annotation
- * associated with an element.
- * @coverage dart.engine.element
- */
-abstract class Annotation {
-
-  /**
-   * Return the element representing the field, variable, or const constructor being used as an
-   * annotation.
-   * @return the field, variable, or constructor being used as an annotation
-   */
-  Element get element;
-}
-/**
  * The interface {@code ClassElement} defines the behavior of elements that represent a class.
  * @coverage dart.engine.element
  */
 abstract class ClassElement implements Element {
 
   /**
    * Return an array containing all of the accessors (getters and setters) declared in this class.
    * @return the accessors declared in this class
    */
   List<PropertyAccessorElement> get accessors;
@@ skipping 211 matching lines @@
    */
   PropertyAccessorElement lookUpSetter(String setterName, LibraryElement library);
 }
 /**
  * The interface {@code ClassMemberElement} defines the behavior of elements that are contained
  * within a {@link ClassElement}.
  */
 abstract class ClassMemberElement implements Element {
 
   /**
-   * Return the type in which this constructor is defined.
-   * @return the type in which this constructor is defined
+   * Return the type in which this member is defined.
+   * @return the type in which this member is defined
    */
   ClassElement get enclosingElement;
 }
 /**
  * The interface {@code CompilationUnitElement} defines the behavior of elements representing a
  * compilation unit.
  * @coverage dart.engine.element
  */
 abstract class CompilationUnitElement implements Element, UriReferencedElement {
 
@@ skipping 161 matching lines @@
    * Return an object representing the location of this element in the element model. The object can
    * be used to locate this element at a later time.
    * @return the location of this element in the element model
    */
   ElementLocation get location;
 
   /**
    * Return an array containing all of the metadata associated with this element.
    * @return the metadata associated with this element
    */
-  List<Annotation> get metadata;
+  List<ElementAnnotation> get metadata;
 
   /**
    * Return the name of this element, or {@code null} if this element does not have a name.
    * @return the name of this element
    */
   String get name;
 
   /**
    * Return the offset of the name of this element in the file that contains the declaration of this
    * element, or {@code -1} if this element is synthetic, does not have a name, or otherwise does
@@ skipping 28 matching lines @@
   bool isSynthetic();
 
   /**
    * Use the given visitor to visit all of the children of this element. There is no guarantee of
    * the order in which the children will be visited.
    * @param visitor the visitor that will be used to visit the children of this element
    */
   void visitChildren(ElementVisitor<Object> visitor);
 }
 /**
+ * The interface {@code ElementAnnotation} defines the behavior of objects representing a single
+ * annotation associated with an element.
+ * @coverage dart.engine.element
+ */
+abstract class ElementAnnotation {
+
+  /**
+   * Return the element representing the field, variable, or const constructor being used as an
+   * annotation.
+   * @return the field, variable, or constructor being used as an annotation
+   */
+  Element get element;
+}
+/**
  * The enumeration {@code ElementKind} defines the various kinds of elements in the element model.
  * @coverage dart.engine.element
  */
 class ElementKind implements Comparable<ElementKind> {
   static final ElementKind CLASS = new ElementKind('CLASS', 0, "class");
   static final ElementKind COMPILATION_UNIT = new ElementKind('COMPILATION_UNIT', 1, "compilation unit");
   static final ElementKind CONSTRUCTOR = new ElementKind('CONSTRUCTOR', 2, "constructor");
   static final ElementKind DYNAMIC = new ElementKind('DYNAMIC', 3, "<dynamic>");
   static final ElementKind EMBEDDED_HTML_SCRIPT = new ElementKind('EMBEDDED_HTML_SCRIPT', 4, "embedded html script");
   static final ElementKind ERROR = new ElementKind('ERROR', 5, "<error>");
@@ skipping 509 matching lines @@
   static final List<NamespaceCombinator> EMPTY_ARRAY = new List<NamespaceCombinator>(0);
 }
 /**
  * The interface {@code ParameterElement} defines the behavior of elements representing a parameter
  * defined within an executable element.
  * @coverage dart.engine.element
  */
 abstract class ParameterElement implements LocalElement, VariableElement {
 
   /**
+   * Return a source range that covers the portion of the source in which the default value for this
+   * parameter is specified, or {@code null} if there is no default value.
+   * @return the range of characters in which the default value of this parameter is specified
+   */
+  SourceRange get defaultValueRange;
+
+  /**
    * Return the kind of this parameter.
    * @return the kind of this parameter
    */
   ParameterKind get parameterKind;
 
   /**
    * Return an array containing all of the parameters defined by this parameter. A parameter will
    * only define other parameters if it is a function typed parameter.
    * @return the parameters defined by this parameter element
    */
@@ skipping 442 matching lines @@
   R visitLocalVariableElement(LocalVariableElement element) => null;
   R visitMethodElement(MethodElement element) => null;
   R visitMultiplyDefinedElement(MultiplyDefinedElement element) => null;
   R visitParameterElement(ParameterElement element) => null;
   R visitPrefixElement(PrefixElement element) => null;
   R visitPropertyAccessorElement(PropertyAccessorElement element) => null;
   R visitTopLevelVariableElement(TopLevelVariableElement element) => null;
   R visitTypeVariableElement(TypeVariableElement element) => null;
 }
 /**
- * Instances of the class {@code AnnotationImpl} implement an {@link Annotation}.
- * @coverage dart.engine.element
- */
-class AnnotationImpl implements Annotation {
-
-  /**
-   * The element representing the field, variable, or constructor being used as an annotation.
-   */
-  Element _element;
-
-  /**
-   * An empty array of annotations.
-   */
-  static List<AnnotationImpl> EMPTY_ARRAY = new List<AnnotationImpl>(0);
-
-  /**
-   * Initialize a newly created annotation.
-   * @param element the element representing the field, variable, or constructor being used as an
-   * annotation
-   */
-  AnnotationImpl(Element element) {
-    this._element = element;
-  }
-  Element get element => _element;
-  String toString() => "@${_element.toString()}";
-}
-/**
  * Instances of the class {@code ClassElementImpl} implement a {@code ClassElement}.
  * @coverage dart.engine.element
  */
 class ClassElementImpl extends ElementImpl implements ClassElement {
 
   /**
    * An array containing all of the accessors (getters and setters) contained in this class.
    */
   List<PropertyAccessorElement> _accessors = PropertyAccessorElementImpl.EMPTY_ARRAY;
 
@@ skipping 817 matching lines @@
 
   /**
    * Set the type defined by this element to the given type.
    * @param type the type defined by this element
    */
   void set type(DynamicTypeImpl type2) {
     this._type = type2;
   }
 }
 /**
+ * Instances of the class {@code ElementAnnotationImpl} implement an {@link ElementAnnotation}.
+ * @coverage dart.engine.element
+ */
+class ElementAnnotationImpl implements ElementAnnotation {
+
+  /**
+   * The element representing the field, variable, or constructor being used as an annotation.
+   */
+  Element _element;
+
+  /**
+   * An empty array of annotations.
+   */
+  static List<ElementAnnotationImpl> EMPTY_ARRAY = new List<ElementAnnotationImpl>(0);
+
+  /**
+   * Initialize a newly created annotation.
+   * @param element the element representing the field, variable, or constructor being used as an
+   * annotation
+   */
+  ElementAnnotationImpl(Element element) {
+    this._element = element;
+  }
+  Element get element => _element;
+  String toString() => "@${_element.toString()}";
+}
+/**
  * The abstract class {@code ElementImpl} implements the behavior common to objects that implement
  * an {@link Element}.
  * @coverage dart.engine.element
  */
 abstract class ElementImpl implements Element {
 
   /**
    * The enclosing element of this element, or {@code null} if this element is at the root of the
    * element structure.
    */
@@ skipping 11 matching lines @@
   int _nameOffset = 0;
 
   /**
    * A bit-encoded form of the modifiers associated with this element.
    */
   Set<Modifier> _modifiers;
 
   /**
    * An array containing all of the metadata associated with this element.
    */
-  List<Annotation> _metadata = AnnotationImpl.EMPTY_ARRAY;
+  List<ElementAnnotation> _metadata = ElementAnnotationImpl.EMPTY_ARRAY;
 
   /**
    * A cached copy of the calculated hashCode for this element.
    */
   int _cachedHashCode = 0;
 
   /**
    * Initialize a newly created element to have the given name.
    * @param name the name of this element
    */
@@ skipping 42 matching lines @@
   AnalysisContext get context {
     if (_enclosingElement == null) {
       return null;
     }
     return _enclosingElement.context;
   }
   String get displayName => _name;
   Element get enclosingElement => _enclosingElement;
   LibraryElement get library => getAncestor(LibraryElement);
   ElementLocation get location => new ElementLocationImpl.con1(this);
-  List<Annotation> get metadata => _metadata;
+  List<ElementAnnotation> get metadata => _metadata;
   String get name => _name;
   int get nameOffset => _nameOffset;
   Source get source {
     if (_enclosingElement == null) {
       return null;
     }
     return _enclosingElement.source;
   }
   int get hashCode {
     if (_cachedHashCode == 0) {
       _cachedHashCode = location.hashCode;
     }
     return _cachedHashCode;
   }
   bool isAccessibleIn(LibraryElement library2) {
     if (Identifier.isPrivateName(_name)) {
       return library2 == library;
     }
     return true;
   }
   bool isSynthetic() => hasModifier(Modifier.SYNTHETIC);
 
   /**
    * Set the metadata associate with this element to the given array of annotations.
    * @param metadata the metadata to be associated with this element
    */
-  void set metadata(List<Annotation> metadata2) {
+  void set metadata(List<ElementAnnotation> metadata2) {
     this._metadata = metadata2;
   }
 
   /**
    * Set the offset of the name of this element in the file that contains the declaration of this
    * element to the given value. This is normally done via the constructor, but this method is
    * provided to support unnamed constructors.
    * @param nameOffset the offset to the beginning of the name
    */
   void set nameOffset(int nameOffset2) {
@@ skipping 1485 matching lines @@
   accept(ElementVisitor visitor) => visitor.visitMultiplyDefinedElement(this);
   String computeDocumentationComment() => null;
   Element getAncestor(Type elementClass) => null;
   List<Element> get conflictingElements => _conflictingElements;
   AnalysisContext get context => _context;
   String get displayName => _name;
   Element get enclosingElement => null;
   ElementKind get kind => ElementKind.ERROR;
   LibraryElement get library => null;
   ElementLocation get location => null;
-  List<Annotation> get metadata => AnnotationImpl.EMPTY_ARRAY;
+  List<ElementAnnotation> get metadata => ElementAnnotationImpl.EMPTY_ARRAY;
   String get name => _name;
   int get nameOffset => -1;
   Source get source => null;
   bool isAccessibleIn(LibraryElement library) {
     for (Element element in _conflictingElements) {
       if (element.isAccessibleIn(library)) {
         return true;
       }
     }
     return false;
@@ skipping 57 matching lines @@
    * parameters if this parameter is a function typed parameter.
    */
   List<ParameterElement> _parameters = ParameterElementImpl.EMPTY_ARRAY;
 
   /**
    * The kind of this parameter.
    */
   ParameterKind _parameterKind;
 
   /**
+   * The offset to the beginning of the default value range for this element.
+   */
+  int _defaultValueRangeOffset = 0;
+
+  /**
+   * The length of the default value range for this element, or {@code -1} if this element does not
+   * have a default value.
+   */
+  int _defaultValueRangeLength = -1;
+
+  /**
    * The offset to the beginning of the visible range for this element.
    */
   int _visibleRangeOffset = 0;
 
   /**
    * The length of the visible range for this element, or {@code -1} if this element does not have a
    * visible range.
    */
   int _visibleRangeLength = -1;
 
   /**
    * An empty array of field elements.
    */
   static List<ParameterElement> EMPTY_ARRAY = new List<ParameterElement>(0);
 
   /**
    * Initialize a newly created parameter element to have the given name.
    * @param name the name of this element
    */
   ParameterElementImpl(Identifier name) : super.con1(name) {
   }
   accept(ElementVisitor visitor) => visitor.visitParameterElement(this);
+  SourceRange get defaultValueRange {
+    if (_defaultValueRangeLength < 0) {
+      return null;
+    }
+    return new SourceRange(_defaultValueRangeOffset, _defaultValueRangeLength);
+  }
   ElementKind get kind => ElementKind.PARAMETER;
   ParameterKind get parameterKind => _parameterKind;
   List<ParameterElement> get parameters => _parameters;
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
   bool isInitializingFormal() => false;
 
   /**
+   * Set the range of the default value for this parameter to the range starting at the given offset
+   * with the given length.
+   * @param offset the offset to the beginning of the default value range for this element
+   * @param length the length of the default value range for this element, or {@code -1} if this
+   * element does not have a default value
+   */
+  void setDefaultValueRange(int offset, int length) {
+    _defaultValueRangeOffset = offset;
+    _defaultValueRangeLength = length;
+  }
+
+  /**
    * Set the kind of this parameter to the given kind.
    * @param parameterKind the new kind of this parameter
    */
   void set parameterKind(ParameterKind parameterKind2) {
     this._parameterKind = parameterKind2;
   }
 
   /**
    * Set the parameters defined by this executable element to the given parameters.
    * @param parameters the parameters defined by this executable element
@@ skipping 686 matching lines @@
   /**
    * Return the element on which the parameterized element was created.
    * @return the element on which the parameterized element was created
    */
   Element get baseElement => _baseElement;
   AnalysisContext get context => _baseElement.context;
   String get displayName => _baseElement.displayName;
   ElementKind get kind => _baseElement.kind;
   LibraryElement get library => _baseElement.library;
   ElementLocation get location => _baseElement.location;
-  List<Annotation> get metadata => _baseElement.metadata;
+  List<ElementAnnotation> get metadata => _baseElement.metadata;
   String get name => _baseElement.name;
   int get nameOffset => _baseElement.nameOffset;
   Source get source => _baseElement.source;
   bool isAccessibleIn(LibraryElement library) => _baseElement.isAccessibleIn(library);
   bool isSynthetic() => _baseElement.isSynthetic();
   void visitChildren(ElementVisitor<Object> visitor) {
   }
 
   /**
    * Return the type in which the element is defined.
@@ skipping 164 matching lines @@
         return ConstructorMember.from((element as ConstructorElement), definingInterfaceType) as Element;
       } else if (element is MethodElement) {
         return MethodMember.from((element as MethodElement), definingInterfaceType) as Element;
       } else if (element is PropertyAccessorElement) {
         return PropertyAccessorMember.from((element as PropertyAccessorElement), definingInterfaceType) as Element;
       }
     }
     return element;
   }
   ParameterElement get baseElement => super.baseElement as ParameterElement;
+  SourceRange get defaultValueRange => baseElement.defaultValueRange;
   Element get enclosingElement => baseElement.enclosingElement;
   ParameterKind get parameterKind => baseElement.parameterKind;
   List<ParameterElement> get parameters {
     List<ParameterElement> baseParameters = baseElement.parameters;
     int parameterCount = baseParameters.length;
     if (parameterCount == 0) {
       return baseParameters;
     }
     List<ParameterElement> parameterizedParameters = new List<ParameterElement>(parameterCount);
     for (int i = 0; i < parameterCount; i++) {
@@ skipping 909 matching lines @@
   }
   bool isMoreSpecificThan(Type2 type) {
     if (identical(type, DynamicTypeImpl.instance)) {
       return true;
     } else if (type is! InterfaceType) {
       return false;
     }
     return isMoreSpecificThan2((type as InterfaceType), new Set<ClassElement>());
   }
   bool isObject() => element.supertype == null;
-  bool isSubtypeOf(Type2 type) {
-    if (identical(type, DynamicTypeImpl.instance)) {
+  bool isSubtypeOf(Type2 type2) {
+    if (identical(type2, DynamicTypeImpl.instance)) {
       return true;
-    } else if (type is TypeVariableType) {
+    } else if (type2 is TypeVariableType) {
       return true;
-    } else if (type is! InterfaceType) {
+    } else if (type2 is FunctionType) {
+      ClassElement element = this.element;
+      MethodElement callMethod = element.lookUpMethod("call", element.library);
+      if (callMethod != null) {
+        return callMethod.type.isSubtypeOf(type2);
+      }
       return false;
-    } else if (this == type) {
+    } else if (type2 is! InterfaceType) {
+      return false;
+    } else if (this == type2) {
       return true;
     }
-    return isSubtypeOf2((type as InterfaceType), new Set<ClassElement>());
+    return isSubtypeOf2((type2 as InterfaceType), new Set<ClassElement>());
   }
   ConstructorElement lookUpConstructor(String constructorName, LibraryElement library) {
     ConstructorElement constructorElement;
     if (constructorName == null) {
       constructorElement = element.unnamedConstructor;
     } else {
       constructorElement = element.getNamedConstructor(constructorName);
     }
     if (constructorElement == null || !constructorElement.isAccessibleIn(library)) {
       return null;
@@ skipping 915 matching lines @@
 abstract class TypeVariableType implements Type2 {
   TypeVariableElement get element;
 }
 /**
  * The interface {@code VoidType} defines the behavior of the unique object representing the type{@code void}.
  * @coverage dart.engine.type
  */
 abstract class VoidType implements Type2 {
   VoidType substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes);
 }