New analyzer_experimental snapshot.

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 'utilities_collection.dart';
 import 'source.dart';
 import 'scanner.dart' show Keyword;
 import 'ast.dart' show Identifier, LibraryIdentifier;
@@ skipping 1301 matching lines @@
 
   /**
    * Return `true` if this accessor is abstract. Accessors are abstract if they are not
    * external and have no body.
    *
    * @return `true` if this accessor is abstract
    */
   bool get isAbstract;
 
   /**
+   * Return `true` if this setter for final variable, so it causes warning when used.
+   *
+   * @return `true` if this accessor is excluded setter
+   */
+  bool get isExcludedSetter;
+
+  /**
    * Return `true` if this accessor represents a getter.
    *
    * @return `true` if this accessor represents a getter
    */
   bool get isGetter;
 
   /**
    * Return `true` if this accessor represents a setter.
    *
    * @return `true` if this accessor represents a setter
@@ skipping 49 matching lines @@
 }
 /**
  * The interface `ShowElementCombinator` defines the behavior of combinators that cause some
  * of the names in a namespace to be visible (and the rest hidden) when being imported.
  *
  * @coverage dart.engine.element
  */
 abstract class ShowElementCombinator implements NamespaceCombinator {
 
   /**
+   * Return the offset of the character immediately following the last character of this node.
+   *
+   * @return the offset of the character just past this node
+   */
+  int get end;
+
+  /**
+   * Return the offset of the 'show' keyword of this element.
+   *
+   * @return the offset of the 'show' keyword of this element
+   */
+  int get offset;
+
+  /**
    * Return an array containing the names that are to be made visible in the importing library if
    * they are defined in the imported library.
    *
    * @return the names from the imported library that are visible in the importing library
    */
   List<String> get shownNames;
 }
 /**
  * The interface `TopLevelVariableElement` defines the behavior of elements representing a
  * top-level variable.
@@ skipping 3037 matching lines @@
 }
 /**
  * Instances of the class `MultiplyDefinedElementImpl` represent a collection of elements that
  * have the same name within the same scope.
  *
  * @coverage dart.engine.element
  */
 class MultiplyDefinedElementImpl implements MultiplyDefinedElement {
 
   /**
+   * Return an element that represents the given conflicting elements.
+   *
+   * @param context the analysis context in which the multiply defined elements are defined
+   * @param firstElement the first element that conflicts
+   * @param secondElement the second element that conflicts
+   */
+  static Element fromElements(AnalysisContext context, Element firstElement, Element secondElement) {
+    List<Element> conflictingElements = computeConflictingElements(firstElement, secondElement);
+    int length = conflictingElements.length;
+    if (length == 0) {
+      return null;
+    } else if (length == 1) {
+      return conflictingElements[0];
+    }
+    return new MultiplyDefinedElementImpl(context, conflictingElements);
+  }
+
+  /**
+   * Add the given element to the list of elements. If the element is a multiply-defined element,
+   * add all of the conflicting elements that it represents.
+   *
+   * @param elements the list to which the element(s) are to be added
+   * @param element the element(s) to be added
+   */
+  static void add(Set<Element> elements, Element element) {
+    if (element is MultiplyDefinedElementImpl) {
+      for (Element conflictingElement in ((element as MultiplyDefinedElementImpl))._conflictingElements) {
+        javaSetAdd(elements, conflictingElement);
+      }
+    } else {
+      javaSetAdd(elements, element);
+    }
+  }
+
+  /**
+   * Use the given elements to construct an array of conflicting elements. If either of the given
+   * elements are multiply-defined elements then the conflicting elements they represent will be
+   * included in the array. Otherwise, the element itself will be included.
+   *
+   * @param firstElement the first element to be included
+   * @param secondElement the second element to be included
+   * @return an array containing all of the conflicting elements
+   */
+  static List<Element> computeConflictingElements(Element firstElement, Element secondElement) {
+    Set<Element> elements = new Set<Element>();
+    add(elements, firstElement);
+    add(elements, secondElement);
+    return new List.from(elements);
+  }
+
+  /**
    * The analysis context in which the multiply defined elements are defined.
    */
   AnalysisContext _context;
 
   /**
    * The name of the conflicting elements.
    */
   String _name;
 
   /**
    * A list containing all of the elements that conflict.
    */
   List<Element> _conflictingElements;
 
   /**
    * Initialize a newly created element to represent a list of conflicting elements.
    *
    * @param context the analysis context in which the multiply defined elements are defined
-   * @param firstElement the first element that conflicts
-   * @param secondElement the second element that conflicts
-   */
-  MultiplyDefinedElementImpl.con1(AnalysisContext context, Element firstElement, Element secondElement) {
-    this._context = context;
-    _name = firstElement.name;
-    _conflictingElements = computeConflictingElements(firstElement, secondElement);
-  }
-
-  /**
-   * Initialize a newly created element to represent a list of conflicting elements.
-   *
-   * @param context the analysis context in which the multiply defined elements are defined
    * @param conflictingElements the elements that conflict
    */
-  MultiplyDefinedElementImpl.con2(AnalysisContext context, List<Element> conflictingElements) {
+  MultiplyDefinedElementImpl(AnalysisContext context, List<Element> conflictingElements) {
     this._context = context;
     _name = conflictingElements[0].name;
     this._conflictingElements = conflictingElements;
   }
   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;
@@ skipping 23 matching lines @@
       if (i > 0) {
         builder.append(", ");
       }
       ((_conflictingElements[i] as ElementImpl)).appendTo(builder);
     }
     builder.append("]");
     return builder.toString();
   }
   void visitChildren(ElementVisitor visitor) {
   }
-
-  /**
-   * Add the given element to the list of elements. If the element is a multiply-defined element,
-   * add all of the conflicting elements that it represents.
-   *
-   * @param elements the list to which the element(s) are to be added
-   * @param element the element(s) to be added
-   */
-  void add(Set<Element> elements, Element element) {
-    if (element is MultiplyDefinedElementImpl) {
-      for (Element conflictingElement in ((element as MultiplyDefinedElementImpl))._conflictingElements) {
-        javaSetAdd(elements, conflictingElement);
-      }
-    } else {
-      javaSetAdd(elements, element);
-    }
-  }
-
-  /**
-   * Use the given elements to construct an array of conflicting elements. If either of the given
-   * elements are multiply-defined elements then the conflicting elements they represent will be
-   * included in the array. Otherwise, the element itself will be included.
-   *
-   * @param firstElement the first element to be included
-   * @param secondElement the second element to be included
-   * @return an array containing all of the conflicting elements
-   */
-  List<Element> computeConflictingElements(Element firstElement, Element secondElement) {
-    Set<Element> elements = new Set<Element>();
-    add(elements, firstElement);
-    add(elements, secondElement);
-    return new List.from(elements);
-  }
 }
 /**
  * Instances of the class `ParameterElementImpl` implement a `ParameterElement`.
  *
  * @coverage dart.engine.element
  */
 class ParameterElementImpl extends VariableElementImpl implements ParameterElement {
 
   /**
    * An array containing all of the parameters defined by this parameter element. There will only be
@@ skipping 237 matching lines @@
     return ElementKind.SETTER;
   }
   String get name {
     if (isSetter) {
       return "${super.name}=";
     }
     return super.name;
   }
   PropertyInducingElement get variable => _variable;
   bool get isAbstract => hasModifier(Modifier.ABSTRACT);
+  bool get isExcludedSetter => isSetter && _variable.isFinal;
   bool get isGetter => hasModifier(Modifier.GETTER);
   bool get isSetter => hasModifier(Modifier.SETTER);
   bool get isStatic => hasModifier(Modifier.STATIC);
 
   /**
    * Set whether this accessor is abstract to correspond to the given value.
    *
    * @param isAbstract `true` if the accessor is abstract
    */
   void set abstract(bool isAbstract) {
@@ skipping 107 matching lines @@
  *
  * @coverage dart.engine.element
  */
 class ShowElementCombinatorImpl implements ShowElementCombinator {
 
   /**
    * The names that are to be made visible in the importing library if they are defined in the
    * imported library.
    */
   List<String> _shownNames = StringUtilities.EMPTY_ARRAY;
+
+  /**
+   * The offset of the character immediately following the last character of this node.
+   */
+  int _end = -1;
+
+  /**
+   * The offset of the 'show' keyword of this element.
+   */
+  int _offset = 0;
+  int get end => _end;
+  int get offset => _offset;
   List<String> get shownNames => _shownNames;
 
   /**
+   * Set the the offset of the character immediately following the last character of this node.
+   */
+  void set end(int endOffset) {
+    this._end = endOffset;
+  }
+
+  /**
+   * Sets the offset of the 'show' keyword of this directive.
+   */
+  void set offset(int offset) {
+    this._offset = offset;
+  }
+
+  /**
    * Set the names that are to be made visible in the importing library if they are defined in the
    * imported library to the given names.
    *
    * @param shownNames the names that are to be made visible in the importing library
    */
   void set shownNames(List<String> shownNames) {
     this._shownNames = shownNames;
   }
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
@@ skipping 570 matching lines @@
    *
    * @param baseParameter the base parameter for which a member might be created
    * @param definingType the type defining the parameters and arguments to be used in the
    *          substitution
    * @return the parameter element that will return the correctly substituted types
    */
   static ParameterElement from(ParameterElement baseParameter, ParameterizedType definingType) {
     if (baseParameter == null || definingType.typeArguments.length == 0) {
       return baseParameter;
     }
-    Type2 baseType = baseParameter.type;
-    List<Type2> argumentTypes = definingType.typeArguments;
-    List<Type2> parameterTypes = TypeParameterTypeImpl.getTypes(definingType.typeParameters);
-    Type2 substitutedType = baseType.substitute2(argumentTypes, parameterTypes);
-    if (baseType == substitutedType) {
-      return baseParameter;
+    if (baseParameter is! FieldFormalParameterElement) {
+      Type2 baseType = baseParameter.type;
+      List<Type2> argumentTypes = definingType.typeArguments;
+      List<Type2> parameterTypes = TypeParameterTypeImpl.getTypes(definingType.typeParameters);
+      Type2 substitutedType = baseType.substitute2(argumentTypes, parameterTypes);
+      if (baseType == substitutedType) {
+        return baseParameter;
+      }
     }
     return new ParameterMember(baseParameter, definingType);
   }
 
   /**
    * Initialize a newly created element to represent a parameter of the given parameterized type.
    *
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
@@ skipping 104 matching lines @@
   PropertyAccessorElement get correspondingSetter => from(baseElement.correspondingSetter, definingType);
   Element get enclosingElement => baseElement.enclosingElement;
   PropertyInducingElement get variable {
     PropertyInducingElement variable = baseElement.variable;
     if (variable is FieldElement) {
       return FieldMember.from(variable as FieldElement, definingType);
     }
     return variable;
   }
   bool get isAbstract => baseElement.isAbstract;
+  bool get isExcludedSetter => baseElement.isExcludedSetter;
   bool get isGetter => baseElement.isGetter;
   bool get isSetter => baseElement.isSetter;
   String toString() {
     PropertyAccessorElement baseElement = this.baseElement;
     List<ParameterElement> parameters = this.parameters;
     FunctionType type = this.type;
     JavaStringBuilder builder = new JavaStringBuilder();
     if (isGetter) {
       builder.append("get ");
     } else {
@@ skipping 1248 matching lines @@
   /**
    * Initialize a newly created type parameter type to be declared by the given element and to have
    * the given name.
    *
    * @param element the element representing the declaration of the type parameter
    */
   TypeParameterTypeImpl(TypeParameterElement element) : super(element, element.name);
   bool operator ==(Object object) => object is TypeParameterTypeImpl && element == ((object as TypeParameterTypeImpl)).element;
   TypeParameterElement get element => super.element as TypeParameterElement;
   int get hashCode => element.hashCode;
-  bool isMoreSpecificThan(Type2 type) {
-    Type2 upperBound = element.bound;
-    return type == upperBound;
+  bool isMoreSpecificThan(Type2 s) {
+    if (this == s) {
+      return true;
+    }
+    if (s.isBottom) {
+      return true;
+    }
+    if (s.isDynamic) {
+      return true;
+    }
+    return isMoreSpecificThan3(s, new Set<Type2>());
   }
-  bool isSubtypeOf(Type2 type) => true;
+  bool isSubtypeOf(Type2 s) => isMoreSpecificThan(s);
   Type2 substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes) {
     int length = parameterTypes.length;
     for (int i = 0; i < length; i++) {
       if (parameterTypes[i] == this) {
         return argumentTypes[i];
       }
     }
     return this;
   }
+  bool isMoreSpecificThan3(Type2 s, Set<Type2> visitedTypes) {
+    Type2 bound = element.bound;
+    if (s == bound) {
+      return true;
+    }
+    if (s.isObject) {
+      return true;
+    }
+    if (bound == null) {
+      return false;
+    }
+    if (bound is TypeParameterTypeImpl) {
+      TypeParameterTypeImpl boundTypeParameter = bound as TypeParameterTypeImpl;
+      if (visitedTypes.contains(bound)) {
+        return false;
+      }
+      javaSetAdd(visitedTypes, bound);
+      return boundTypeParameter.isMoreSpecificThan3(s, visitedTypes);
+    }
+    return bound.isMoreSpecificThan(s);
+  }
 }
 /**
  * The unique instance of the class `VoidTypeImpl` implements the type `void`.
  *
  * @coverage dart.engine.type
  */
 class VoidTypeImpl extends TypeImpl implements VoidType {
 
   /**
    * The unique instance of this class.
@@ skipping 614 matching lines @@
 }
 /**
  * The interface `VoidType` defines the behavior of the unique object representing the type
  * `void`.
  *
  * @coverage dart.engine.type
  */
 abstract class VoidType implements Type2 {
   VoidType substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes);
 }