Version 0.8.10.1

dart/pkg/analyzer/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 4294 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;
+  bool _isPotentiallyMutatedInScope2 = false;
+
+  /**
+   * Is `true` if this variable is potentially mutated somewhere in closure.
+   */
+  bool _isPotentiallyMutatedInClosure2 = 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.
    */
@@ skipping 11 matching lines @@
    */
   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;
+  bool get isPotentiallyMutatedInClosure => _isPotentiallyMutatedInClosure2;
+  bool get isPotentiallyMutatedInScope => _isPotentiallyMutatedInScope2;
+
+  /**
+   * Specifies that this variable is potentially mutated somewhere in closure.
+   */
+  void markPotentiallyMutatedInClosure() {
+    _isPotentiallyMutatedInClosure2 = true;
+  }
 
   /**
    * Specifies that this variable is potentially mutated somewhere in its scope.
    */
-  void markPotentiallyMutated() {
-    _isPotentiallyMutated2 = true;
+  void markPotentiallyMutatedInScope() {
+    _isPotentiallyMutatedInScope2 = 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
    */
@@ skipping 242 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;
+  bool _isPotentiallyMutatedInScope3 = false;
+
+  /**
+   * Is `true` if this variable is potentially mutated somewhere in closure.
+   */
+  bool _isPotentiallyMutatedInClosure3 = 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.
    */
@@ skipping 51 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;
+  bool get isPotentiallyMutatedInClosure => _isPotentiallyMutatedInClosure3;
+  bool get isPotentiallyMutatedInScope => _isPotentiallyMutatedInScope3;
+
+  /**
+   * Specifies that this variable is potentially mutated somewhere in closure.
+   */
+  void markPotentiallyMutatedInClosure() {
+    _isPotentiallyMutatedInClosure3 = true;
+  }
 
   /**
    * Specifies that this variable is potentially mutated somewhere in its scope.
    */
-  void markPotentiallyMutated() {
-    _isPotentiallyMutated3 = true;
+  void markPotentiallyMutatedInScope() {
+    _isPotentiallyMutatedInScope3 = 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
    */
@@ skipping 479 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 closure. This
+   * information is only available for local variables (including parameters).
+   *
+   * @return `true` if this variable is potentially mutated somewhere in closure
+   */
+  bool get isPotentiallyMutatedInClosure => false;
+
+  /**
    * 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;
+  bool get isPotentiallyMutatedInScope => 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);
   }
 
@@ skipping 618 matching lines @@
    * The unique instance of this class.
    */
   static final BottomTypeImpl instance = new BottomTypeImpl();
 
   /**
    * Prevent the creation of instances of this class.
    */
   BottomTypeImpl() : super(null, "<bottom>");
   bool operator ==(Object object) => identical(object, this);
   bool get isBottom => true;
-  bool isMoreSpecificThan(Type2 type) => true;
+  bool isMoreSpecificThan3(Type2 type, bool withDynamic) => true;
   bool isSubtypeOf(Type2 type) => true;
   bool isSupertypeOf(Type2 type) => false;
   BottomTypeImpl substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes) => this;
 }
 /**
  * The unique instance of the class `DynamicTypeImpl` implements the type `dynamic`.
  *
  * @coverage dart.engine.type
  */
 class DynamicTypeImpl extends TypeImpl {
 
   /**
    * The unique instance of this class.
    */
   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) {
+  bool isMoreSpecificThan3(Type2 type, bool withDynamic) {
     if (identical(this, type)) {
       return true;
     }
-    return false;
+    return withDynamic;
   }
   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];
       }
     }
@@ skipping 201 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) {
+  bool isMoreSpecificThan3(Type2 type, bool withDynamic) {
     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])) {
+          if (!tTypes[i].isMoreSpecificThan3(sTypes[i], withDynamic)) {
             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())) {
+        if (!typeT.isMoreSpecificThan3(entryS.getValue(), withDynamic)) {
           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])) {
+          if (!tTypes[i].isMoreSpecificThan3(sTypes[i], withDynamic)) {
             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])) {
+          if (!tAllTypes[i].isMoreSpecificThan3(sAllTypes[i], withDynamic)) {
             return false;
           }
         }
       }
     }
     Type2 tRetType = t.returnType;
     Type2 sRetType = s.returnType;
-    return sRetType.isVoid || tRetType.isMoreSpecificThan(sRetType);
+    return sRetType.isVoid || tRetType.isMoreSpecificThan3(sRetType, withDynamic);
   }
   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 508 matching lines @@
     return element.hashCode;
   }
   bool get isDartCoreFunction {
     ClassElement element = this.element;
     if (element == null) {
       return false;
     }
     return element.name == "Function" && element.library.isDartCore;
   }
   bool isDirectSupertypeOf(InterfaceType type) {
-    ClassElement i = element;
-    ClassElement j = type.element;
-    InterfaceType supertype = j.supertype;
+    InterfaceType i = this;
+    InterfaceType j = type;
+    ClassElement jElement = j.element;
+    InterfaceType supertype = jElement.supertype;
     if (supertype == null) {
       return false;
     }
-    ClassElement supertypeElement = supertype.element;
-    if (supertypeElement == i) {
+    List<Type2> jArgs = j.typeArguments;
+    List<Type2> jVars = jElement.type.typeArguments;
+    supertype = supertype.substitute2(jArgs, jVars);
+    if (supertype == i) {
       return true;
     }
-    for (InterfaceType interfaceType in j.interfaces) {
-      if (interfaceType.element == i) {
+    for (InterfaceType interfaceType in jElement.interfaces) {
+      interfaceType = interfaceType.substitute2(jArgs, jVars);
+      if (interfaceType == i) {
         return true;
       }
     }
-    for (InterfaceType mixinType in j.mixins) {
-      if (mixinType.element == i) {
+    for (InterfaceType mixinType in jElement.mixins) {
+      mixinType = mixinType.substitute2(jArgs, jVars);
+      if (mixinType == i) {
         return true;
       }
     }
     return false;
   }
-  bool isMoreSpecificThan(Type2 type) {
+  bool isMoreSpecificThan3(Type2 type, bool withDynamic) {
     if (identical(type, DynamicTypeImpl.instance)) {
       return true;
     } else if (type is! InterfaceType) {
       return false;
     }
-    return isMoreSpecificThan2(type as InterfaceType, new Set<ClassElement>());
+    return isMoreSpecificThan2(type as InterfaceType, new Set<ClassElement>(), withDynamic);
   }
   bool get isObject => element.supertype == null;
   bool isSubtypeOf(Type2 type) {
     if (identical(type, DynamicTypeImpl.instance)) {
       return true;
     } else if (type is TypeParameterType) {
       return true;
     } else if (type is FunctionType) {
       ClassElement element = this.element;
       MethodElement callMethod = element.lookUpMethod("call", element.library);
@@ skipping 154 matching lines @@
       builder.append("<");
       for (int i = 0; i < argumentCount; i++) {
         if (i > 0) {
           builder.append(", ");
         }
         ((_typeArguments[i] as TypeImpl)).appendTo(builder);
       }
       builder.append(">");
     }
   }
-  bool isMoreSpecificThan2(InterfaceType s, Set<ClassElement> visitedClasses) {
+  bool isMoreSpecificThan2(InterfaceType s, Set<ClassElement> visitedClasses, bool withDynamic) {
     if (this == s) {
       return true;
     }
     if (s.isDirectSupertypeOf(this)) {
       return true;
     }
     ClassElement tElement = this.element;
     ClassElement sElement = s.element;
     if (tElement == sElement) {
       List<Type2> tArguments = typeArguments;
       List<Type2> sArguments = s.typeArguments;
       if (tArguments.length != sArguments.length) {
         return false;
       }
       for (int i = 0; i < tArguments.length; i++) {
-        if (!tArguments[i].isMoreSpecificThan(sArguments[i])) {
+        if (!tArguments[i].isMoreSpecificThan3(sArguments[i], withDynamic)) {
           return false;
         }
       }
       return true;
     }
     ClassElement element = this.element;
     if (element == null || visitedClasses.contains(element)) {
       return false;
     }
     javaSetAdd(visitedClasses, element);
     InterfaceType supertype = superclass;
-    if (supertype != null && ((supertype as InterfaceTypeImpl)).isMoreSpecificThan2(s, visitedClasses)) {
+    if (supertype != null && ((supertype as InterfaceTypeImpl)).isMoreSpecificThan2(s, visitedClasses, withDynamic)) {
       return true;
     }
     for (InterfaceType interfaceType in interfaces) {
-      if (((interfaceType as InterfaceTypeImpl)).isMoreSpecificThan2(s, visitedClasses)) {
+      if (((interfaceType as InterfaceTypeImpl)).isMoreSpecificThan2(s, visitedClasses, withDynamic)) {
         return true;
       }
     }
     for (InterfaceType mixinType in mixins) {
-      if (((mixinType as InterfaceTypeImpl)).isMoreSpecificThan2(s, visitedClasses)) {
+      if (((mixinType as InterfaceTypeImpl)).isMoreSpecificThan2(s, visitedClasses, withDynamic)) {
         return true;
       }
     }
     return false;
   }
   bool isSubtypeOf2(InterfaceType type, Set<ClassElement> visitedClasses) {
     InterfaceType typeT = this;
     InterfaceType typeS = type;
     ClassElement elementT = element;
     if (elementT == null || visitedClasses.contains(elementT)) {
       return false;
     }
     javaSetAdd(visitedClasses, elementT);
-    typeT = substitute2(_typeArguments, elementT.type.typeArguments);
     if (typeT == typeS) {
       return true;
     } else if (elementT == typeS.element) {
       List<Type2> typeTArgs = typeT.typeArguments;
       List<Type2> typeSArgs = typeS.typeArguments;
       if (typeTArgs.length != typeSArgs.length) {
         return false;
       }
       for (int i = 0; i < typeTArgs.length; i++) {
         if (!typeTArgs[i].isSubtypeOf(typeSArgs[i])) {
@@ skipping 79 matching lines @@
     this._name = name;
   }
   String get displayName => name;
   Element get element => _element;
   Type2 getLeastUpperBound(Type2 type) => null;
   String get name => _name;
   bool isAssignableTo(Type2 type) => this.isSubtypeOf(type) || type.isSubtypeOf(this);
   bool get isBottom => false;
   bool get isDartCoreFunction => false;
   bool get isDynamic => false;
-  bool isMoreSpecificThan(Type2 type) => false;
+  bool isMoreSpecificThan(Type2 type) => isMoreSpecificThan3(type, false);
+  bool isMoreSpecificThan3(Type2 type, bool withDynamic) => false;
   bool get isObject => false;
   bool isSupertypeOf(Type2 type) => type.isSubtypeOf(this);
   bool get isVoid => false;
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
     appendTo(builder);
     return builder.toString();
   }
 
   /**
@@ skipping 45 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 s) {
+  bool isMoreSpecificThan3(Type2 s, bool withDynamic) {
     if (this == s) {
       return true;
     }
     if (s.isBottom) {
       return true;
     }
     if (s.isDynamic) {
       return true;
     }
-    return isMoreSpecificThan3(s, new Set<Type2>());
+    return isMoreSpecificThan4(s, new Set<Type2>(), withDynamic);
   }
-  bool isSubtypeOf(Type2 s) => isMoreSpecificThan(s);
+  bool isSubtypeOf(Type2 s) => isMoreSpecificThan3(s, 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;
   }
-  bool isMoreSpecificThan3(Type2 s, Set<Type2> visitedTypes) {
+  bool isMoreSpecificThan4(Type2 s, Set<Type2> visitedTypes, bool withDynamic) {
     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 boundTypeParameter.isMoreSpecificThan4(s, visitedTypes, withDynamic);
     }
-    return bound.isMoreSpecificThan(s);
+    return bound.isMoreSpecificThan3(s, withDynamic);
   }
 }
 /**
  * The unique instance of the class `VoidTypeImpl` implements the type `void`.
  *
  * @coverage dart.engine.type
  */
 class VoidTypeImpl extends TypeImpl implements VoidType {
 
   /**
@@ skipping 552 matching lines @@
 
   /**
    * Return `true` if this type is more specific than the given type.
    *
    * @param type the type being compared with this type
    * @return `true` if this type is more specific than the given type
    */
   bool isMoreSpecificThan(Type2 type);
 
   /**
+   * Return `true` if this type is more specific than the given type.
+   *
+   * @param type the type being compared with this type
+   * @param withDynamic `true` if "dynamic" should be considered as a subtype of any type
+   * @return `true` if this type is more specific than the given type
+   */
+  bool isMoreSpecificThan3(Type2 type, bool withDynamic);
+
+  /**
    * Return `true` if this type represents the type 'Object'.
    *
    * @return `true` if this type represents the type 'Object'
    */
   bool get isObject;
 
   /**
    * Return `true` if this type is a subtype of the given type.
    *
    * @param type the type being compared with this type
@@ skipping 43 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);
 }