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 990 matching lines @@
     for (ClassElement type in _types) {
       if (((type as ClassElementImpl)).identifier == identifier) {
         return type as ClassElementImpl;
       }
     }
     return null;
   }
   LibraryElement get enclosingElement => super.enclosingElement as LibraryElement;
   List<FunctionElement> get functions => _functions;
   List<FunctionTypeAliasElement> get functionTypeAliases => _typeAliases;
-  String get identifier => source.encoding;
   ElementKind get kind => ElementKind.COMPILATION_UNIT;
   Source get source => _source;
   List<TopLevelVariableElement> get topLevelVariables => _variables;
   ClassElement getType(String className) {
     for (ClassElement type in _types) {
       if (type.name == className) {
         return type;
       }
     }
     return null;
@@ skipping 88 matching lines @@
     safelyVisitChildren(_types, visitor);
     safelyVisitChildren(_variables, visitor);
   }
   void appendTo(JavaStringBuilder builder) {
     if (_source == null) {
       builder.append("{compilation unit}");
     } else {
       builder.append(_source.fullName);
     }
   }
+  String get identifier => source.encoding;
 }
 /**
  * Instances of the class `ConstFieldElementImpl` implement a `FieldElement` for a
  * 'const' field that has an initializer.
  */
 class ConstFieldElementImpl extends FieldElementImpl {
 
   /**
    * The result of evaluating this variable's initializer.
    */
@@ skipping 301 matching lines @@
     this._name = StringUtilities.intern(name);
     this._nameOffset = nameOffset;
   }
   String computeDocumentationComment() {
     AnalysisContext context = this.context;
     if (context == null) {
       return null;
     }
     return context.computeDocumentationComment(this);
   }
-  bool operator ==(Object object) => object != null && object.runtimeType == runtimeType && ((object as Element)).location == location;
+  bool operator ==(Object object) {
+    if (identical(this, object)) {
+      return true;
+    }
+    if (object == null || hashCode != object.hashCode) {
+      return false;
+    }
+    return object.runtimeType == runtimeType && ((object as Element)).location == location;
+  }
   Element getAncestor(Type elementClass) {
     Element ancestor = _enclosingElement;
     while (ancestor != null && !isInstanceOf(ancestor, elementClass)) {
       ancestor = ancestor.enclosingElement;
     }
     return ancestor as Element;
   }
 
   /**
    * Return the child of this element that is uniquely identified by the given identifier, or
@@ skipping 127 matching lines @@
         child.accept(visitor);
       }
     }
   }
 
   /**
    * Set the enclosing element of this element to the given element.
    *
    * @param element the enclosing element of this element
    */
-  void set enclosingElement(ElementImpl element) {
-    _enclosingElement = element;
+  void set enclosingElement(Element element) {
+    _enclosingElement = element as ElementImpl;
   }
 
   /**
    * Set whether the given modifier is associated with this element to correspond to the given
    * value.
    *
    * @param modifier the modifier to be set
    * @param value `true` if the modifier is to be associated with this element
    */
   void setModifier(Modifier modifier, bool value) {
@@ skipping 34 matching lines @@
 
   /**
    * Initialize a newly created location from the given encoded form.
    *
    * @param encoding the encoded form of a location
    */
   ElementLocationImpl.con2(String encoding) {
     this.components = decode(encoding);
   }
   bool operator ==(Object object) {
+    if (identical(this, object)) {
+      return true;
+    }
     if (object is! ElementLocationImpl) {
       return false;
     }
     ElementLocationImpl location = object as ElementLocationImpl;
     List<String> otherComponents = location.components;
     int length = components.length;
     if (otherComponents.length != length) {
       return false;
     }
+    for (int i = length - 1; i >= 2; i--) {
+      if (components[i] != otherComponents[i]) {
+        return false;
+      }
+    }
+    if (length > 1 && !equalSourceComponents(components[1], otherComponents[1])) {
+      return false;
+    }
     if (length > 0 && !equalSourceComponents(components[0], otherComponents[0])) {
       return false;
     }
-    if (length > 1 && !equalSourceComponents(components[1], otherComponents[1])) {
-      return false;
-    }
-    for (int i = 2; i < length; i++) {
-      if (components[i] != otherComponents[i]) {
-        return false;
-      }
-    }
     return true;
   }
   String get encoding {
     JavaStringBuilder builder = new JavaStringBuilder();
     int length = components.length;
     for (int i = 0; i < length; i++) {
       if (i > 0) {
         builder.appendChar(_SEPARATOR_CHAR);
       }
       encode(builder, components[i]);
@@ skipping 73 matching lines @@
    * @param left the left component being compared
    * @param right the right component being compared
    * @return `true` if the given components are equal when the source type's are ignored
    */
   bool equalSourceComponents(String left, String right) {
     if (left == null) {
       return right == null;
     } else if (right == null) {
       return false;
     }
-    if (left.length <= 1 || right.length <= 1) {
+    int leftLength = left.length;
+    int rightLength = right.length;
+    if (leftLength != rightLength) {
+      return false;
+    } else if (leftLength <= 1 || rightLength <= 1) {
       return left == right;
     }
-    return left.substring(1) == right.substring(1);
+    return javaStringRegionMatches(left, 1, right, 1, leftLength - 1);
   }
 
   /**
    * Return the hash code of the given encoded source component, ignoring the source type indicator.
    *
    * @param sourceComponent the component to compute a hash code
    * @return the hash code of the given encoded source component
    */
   int hashSourceComponent(String sourceComponent) {
     if (sourceComponent.length <= 1) {
@@ skipping 425 matching lines @@
 
   /**
    * Initialize a newly created function element to have no name and the given offset. This is used
    * for function expressions, which have no name.
    *
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   FunctionElementImpl.con2(int nameOffset) : super.con2("", nameOffset);
   accept(ElementVisitor visitor) => visitor.visitFunctionElement(this);
-  String get identifier => "${name}@${nameOffset}";
   ElementKind get kind => ElementKind.FUNCTION;
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
   bool get isStatic => enclosingElement is CompilationUnitElement;
 
   /**
    * Set the visible range for this element to the range starting at the given offset with the given
    * length.
    *
    * @param offset the offset to the beginning of the visible range for this element
    * @param length the length of the visible range for this element, or `-1` if this element
    *          does not have a visible range
    */
   void setVisibleRange(int offset, int length) {
     _visibleRangeOffset = offset;
     _visibleRangeLength = length;
   }
   void appendTo(JavaStringBuilder builder) {
     String name = displayName;
     if (name != null) {
       builder.append(name);
     }
     super.appendTo(builder);
   }
+  String get identifier => "${name}@${nameOffset}";
 }
 /**
  * Instances of the class `FunctionTypeAliasElementImpl` implement a
  * `FunctionTypeAliasElement`.
  *
  * @coverage dart.engine.element
  */
 class FunctionTypeAliasElementImpl extends ElementImpl implements FunctionTypeAliasElement {
 
   /**
@@ skipping 564 matching lines @@
     Set<LibraryElement> libraries = new Set<LibraryElement>();
     for (ExportElement element in _exports) {
       LibraryElement library = element.exportedLibrary;
       if (library != null) {
         javaSetAdd(libraries, library);
       }
     }
     return new List.from(libraries);
   }
   List<ExportElement> get exports => _exports;
-  String get identifier => _definingCompilationUnit.source.encoding;
   List<LibraryElement> get importedLibraries {
     Set<LibraryElement> libraries = new Set<LibraryElement>();
     for (ImportElement element in _imports) {
       LibraryElement library = element.importedLibrary;
       if (library != null) {
         javaSetAdd(libraries, library);
       }
     }
     return new List.from(libraries);
   }
@@ skipping 98 matching lines @@
     }
     this._parts = parts;
   }
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_definingCompilationUnit, visitor);
     safelyVisitChildren(_exports, visitor);
     safelyVisitChildren(_imports, visitor);
     safelyVisitChildren(_parts, visitor);
   }
+  String get identifier => _definingCompilationUnit.source.encoding;
 
   /**
    * Answer `true` if the receiver directly or indirectly imports the dart:html libraries.
    *
    * @return `true` if the receiver directly or indirectly imports the dart:html libraries
    */
   bool get isOrImportsBrowserLibrary {
     List<LibraryElement> visited = new List<LibraryElement>();
     Source htmlLibSource = _context.sourceFactory.forUri(DartSdk.DART_HTML);
     visited.add(this);
@@ skipping 18 matching lines @@
   }
 }
 /**
  * Instances of the class `LocalVariableElementImpl` implement a `LocalVariableElement`.
  *
  * @coverage dart.engine.element
  */
 class LocalVariableElementImpl extends VariableElementImpl implements LocalVariableElement {
 
   /**
+   * Is `true` if this variable is potentially mutated somewhere in its scope.
+   */
+  bool _isPotentiallyMutated2 = false;
+
+  /**
    * 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 `-1` if this element does not have a
    * visible range.
    */
   int _visibleRangeLength = -1;
 
   /**
    * An empty array of field elements.
    */
   static List<LocalVariableElement> EMPTY_ARRAY = new List<LocalVariableElement>(0);
 
   /**
    * Initialize a newly created local variable element to have the given name.
    *
    * @param name the name of this element
    */
   LocalVariableElementImpl(Identifier name) : super.con1(name);
   accept(ElementVisitor visitor) => visitor.visitLocalVariableElement(this);
   ElementKind get kind => ElementKind.LOCAL_VARIABLE;
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
+  bool get isPotentiallyMutated => _isPotentiallyMutated2;
+
+  /**
+   * Specifies that this variable is potentially mutated somewhere in its scope.
+   */
+  void markPotentiallyMutated() {
+    _isPotentiallyMutated2 = true;
+  }
 
   /**
    * Set the visible range for this element to the range starting at the given offset with the given
    * length.
    *
    * @param offset the offset to the beginning of the visible range for this element
    * @param length the length of the visible range for this element, or `-1` if this element
    *          does not have a visible range
    */
   void setVisibleRange(int offset, int length) {
@@ skipping 239 matching lines @@
   }
 }
 /**
  * Instances of the class `ParameterElementImpl` implement a `ParameterElement`.
  *
  * @coverage dart.engine.element
  */
 class ParameterElementImpl extends VariableElementImpl implements ParameterElement {
 
   /**
+   * Is `true` if this variable is potentially mutated somewhere in its scope.
+   */
+  bool _isPotentiallyMutated3 = false;
+
+  /**
    * An array containing all of the parameters defined by this parameter element. There will only be
    * parameters if this parameter is a function typed parameter.
    */
   List<ParameterElement> _parameters = ParameterElementImpl.EMPTY_ARRAY;
 
   /**
    * The kind of this parameter.
    */
   ParameterKind _parameterKind;
 
@@ skipping 49 matching lines @@
   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 get isInitializingFormal => false;
+  bool get isPotentiallyMutated => _isPotentiallyMutated3;
+
+  /**
+   * Specifies that this variable is potentially mutated somewhere in its scope.
+   */
+  void markPotentiallyMutated() {
+    _isPotentiallyMutated3 = true;
+  }
 
   /**
    * 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 `-1` if this
    *          element does not have a default value
    */
   void setDefaultValueRange(int offset, int length) {
@@ skipping 159 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 299 matching lines @@
    *
    * @return the result of evaluating this variable's initializer
    */
   EvaluationResultImpl get evaluationResult => null;
   FunctionElement get initializer => _initializer;
   Type2 get type => _type;
   bool get isConst => hasModifier(Modifier.CONST);
   bool get isFinal => hasModifier(Modifier.FINAL);
 
   /**
+   * Return `true` if this variable is potentially mutated somewhere in its scope. This
+   * information is only available for local variables (including parameters).
+   *
+   * @return `true` if this variable is potentially mutated somewhere in its scope
+   */
+  bool get isPotentiallyMutated => false;
+
+  /**
    * Set whether this variable is const to correspond to the given value.
    *
    * @param isConst `true` if the variable is const
    */
   void set const3(bool isConst) {
     setModifier(Modifier.CONST, isConst);
   }
 
   /**
    * Set the result of evaluating this variable's initializer as a compile-time constant expression
@@ skipping 539 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 82 matching lines @@
   static final DynamicTypeImpl instance = new DynamicTypeImpl();
 
   /**
    * Prevent the creation of instances of this class.
    */
   DynamicTypeImpl() : super(new DynamicElementImpl(), Keyword.DYNAMIC.syntax) {
     ((element as DynamicElementImpl)).type = this;
   }
   bool operator ==(Object object) => object is DynamicTypeImpl;
   bool get isDynamic => true;
-  bool isMoreSpecificThan(Type2 type) => false;
+  bool isMoreSpecificThan(Type2 type) {
+    if (identical(this, type)) {
+      return true;
+    }
+    return false;
+  }
   bool isSubtypeOf(Type2 type) => true;
   bool isSupertypeOf(Type2 type) => true;
   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;
@@ skipping 200 matching lines @@
     return TypeParameterElementImpl.EMPTY_ARRAY;
   }
   int get hashCode {
     Element element = this.element;
     if (element == null) {
       return 0;
     }
     return element.hashCode;
   }
   bool isAssignableTo(Type2 type) => this.isSubtypeOf(type);
+  bool isMoreSpecificThan(Type2 type) {
+    if (type == null) {
+      return false;
+    } else if (identical(this, type) || type.isDynamic || type.isDartCoreFunction || type.isObject) {
+      return true;
+    } else if (type is! FunctionType) {
+      return false;
+    } else if (this == type) {
+      return true;
+    }
+    FunctionType t = this;
+    FunctionType s = type as FunctionType;
+    List<Type2> tTypes = t.normalParameterTypes;
+    List<Type2> tOpTypes = t.optionalParameterTypes;
+    List<Type2> sTypes = s.normalParameterTypes;
+    List<Type2> sOpTypes = s.optionalParameterTypes;
+    if ((sOpTypes.length > 0 && t.namedParameterTypes.length > 0) || (tOpTypes.length > 0 && s.namedParameterTypes.length > 0)) {
+      return false;
+    }
+    if (t.namedParameterTypes.length > 0) {
+      if (t.normalParameterTypes.length != s.normalParameterTypes.length) {
+        return false;
+      } else if (t.normalParameterTypes.length > 0) {
+        for (int i = 0; i < tTypes.length; i++) {
+          if (!tTypes[i].isMoreSpecificThan(sTypes[i])) {
+            return false;
+          }
+        }
+      }
+      Map<String, Type2> namedTypesT = t.namedParameterTypes;
+      Map<String, Type2> namedTypesS = s.namedParameterTypes;
+      if (namedTypesT.length < namedTypesS.length) {
+        return false;
+      }
+      JavaIterator<MapEntry<String, Type2>> iteratorS = new JavaIterator(getMapEntrySet(namedTypesS));
+      while (iteratorS.hasNext) {
+        MapEntry<String, Type2> entryS = iteratorS.next();
+        Type2 typeT = namedTypesT[entryS.getKey()];
+        if (typeT == null) {
+          return false;
+        }
+        if (!typeT.isMoreSpecificThan(entryS.getValue())) {
+          return false;
+        }
+      }
+    } else if (s.namedParameterTypes.length > 0) {
+      return false;
+    } else {
+      int tArgLength = tTypes.length + tOpTypes.length;
+      int sArgLength = sTypes.length + sOpTypes.length;
+      if (tArgLength < sArgLength || sTypes.length < tTypes.length) {
+        return false;
+      }
+      if (tOpTypes.length == 0 && sOpTypes.length == 0) {
+        for (int i = 0; i < sTypes.length; i++) {
+          if (!tTypes[i].isMoreSpecificThan(sTypes[i])) {
+            return false;
+          }
+        }
+      } else {
+        List<Type2> tAllTypes = new List<Type2>(sArgLength);
+        for (int i = 0; i < tTypes.length; i++) {
+          tAllTypes[i] = tTypes[i];
+        }
+        for (int i = tTypes.length, j = 0; i < sArgLength; i++, j++) {
+          tAllTypes[i] = tOpTypes[j];
+        }
+        List<Type2> sAllTypes = new List<Type2>(sArgLength);
+        for (int i = 0; i < sTypes.length; i++) {
+          sAllTypes[i] = sTypes[i];
+        }
+        for (int i = sTypes.length, j = 0; i < sArgLength; i++, j++) {
+          sAllTypes[i] = sOpTypes[j];
+        }
+        for (int i = 0; i < sAllTypes.length; i++) {
+          if (!tAllTypes[i].isMoreSpecificThan(sAllTypes[i])) {
+            return false;
+          }
+        }
+      }
+    }
+    Type2 tRetType = t.returnType;
+    Type2 sRetType = s.returnType;
+    return sRetType.isVoid || tRetType.isMoreSpecificThan(sRetType);
+  }
   bool isSubtypeOf(Type2 type) {
     if (type == null) {
       return false;
     } else if (identical(this, type) || type.isDynamic || type.isDartCoreFunction || type.isObject) {
       return true;
     } else if (type is! FunctionType) {
       return false;
     } else if (this == type) {
       return true;
     }
@@ skipping 21 matching lines @@
       if (namedTypesT.length < namedTypesS.length) {
         return false;
       }
       JavaIterator<MapEntry<String, Type2>> iteratorS = new JavaIterator(getMapEntrySet(namedTypesS));
       while (iteratorS.hasNext) {
         MapEntry<String, Type2> entryS = iteratorS.next();
         Type2 typeT = namedTypesT[entryS.getKey()];
         if (typeT == null) {
           return false;
         }
-        if (!entryS.getValue().isAssignableTo(typeT)) {
+        if (!typeT.isAssignableTo(entryS.getValue())) {
           return false;
         }
       }
     } else if (s.namedParameterTypes.length > 0) {
       return false;
     } else {
       int tArgLength = tTypes.length + tOpTypes.length;
       int sArgLength = sTypes.length + sOpTypes.length;
       if (tArgLength < sArgLength || sTypes.length < tTypes.length) {
         return false;
       }
       if (tOpTypes.length == 0 && sOpTypes.length == 0) {
         for (int i = 0; i < sTypes.length; i++) {
-          if (!sTypes[i].isAssignableTo(tTypes[i])) {
+          if (!tTypes[i].isAssignableTo(sTypes[i])) {
             return false;
           }
         }
       } else {
         List<Type2> tAllTypes = new List<Type2>(sArgLength);
         for (int i = 0; i < tTypes.length; i++) {
           tAllTypes[i] = tTypes[i];
         }
         for (int i = tTypes.length, j = 0; i < sArgLength; i++, j++) {
           tAllTypes[i] = tOpTypes[j];
         }
         List<Type2> sAllTypes = new List<Type2>(sArgLength);
         for (int i = 0; i < sTypes.length; i++) {
           sAllTypes[i] = sTypes[i];
         }
         for (int i = sTypes.length, j = 0; i < sArgLength; i++, j++) {
           sAllTypes[i] = sOpTypes[j];
         }
         for (int i = 0; i < sAllTypes.length; i++) {
-          if (!sAllTypes[i].isAssignableTo(tAllTypes[i])) {
+          if (!tAllTypes[i].isAssignableTo(sAllTypes[i])) {
             return false;
           }
         }
       }
     }
-    return s.returnType == VoidTypeImpl.instance || t.returnType.isAssignableTo(s.returnType);
+    Type2 tRetType = t.returnType;
+    Type2 sRetType = s.returnType;
+    return sRetType.isVoid || tRetType.isAssignableTo(sRetType);
   }
 
   /**
    * Set the actual types of the type arguments to the given types.
    *
    * @param typeArguments the actual types of the type arguments
    */
   void set typeArguments(List<Type2> typeArguments) {
     this._typeArguments = typeArguments;
   }
@@ skipping 1520 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);
 }