Propagate a type in asynchronous for-in statements (issue 23945)

pkg/analyzer/lib/src/generated/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.
 
 // 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';
@@ skipping 67 matching lines @@
   int get hashCode => 0;
 
   @override
   bool get isBottom => true;
 
   @override
   bool operator ==(Object object) => identical(object, this);
 
   @override
   bool isMoreSpecificThan(DartType type,
-      [bool withDynamic = false, Set<Element> visitedElements]) => true;
+          [bool withDynamic = false, Set<Element> visitedElements]) =>
+      true;
 
   @override
   bool isSubtypeOf(DartType type) => true;
 
   @override
   bool isSupertypeOf(DartType type) => false;
 
   @override
   TypeImpl pruned(List<FunctionTypeAliasElement> prune) => this;
 
   @override
   BottomTypeImpl substitute2(
-      List<DartType> argumentTypes, List<DartType> parameterTypes,
-      [List<FunctionTypeAliasElement> prune]) => this;
+          List<DartType> argumentTypes, List<DartType> parameterTypes,
+          [List<FunctionTypeAliasElement> prune]) =>
+      this;
 }
 
 /**
  * Type created internally if a circular reference is ever detected.  Behaves
  * like `dynamic`, except that when converted to a string it is displayed as
  * `...`.
  */
 class CircularTypeImpl extends DynamicTypeImpl {
   CircularTypeImpl() : super._circular();
 
@@ skipping 1034 matching lines @@
 
   PropertyAccessorElement _internalLookUpConcreteGetter(
       String getterName, LibraryElement library, bool includeThisClass) {
     PropertyAccessorElement getter =
         _internalLookUpGetter(getterName, library, includeThisClass);
     while (getter != null && getter.isAbstract) {
       Element definingClass = getter.enclosingElement;
       if (definingClass is! ClassElementImpl) {
         return null;
       }
-      getter = (definingClass as ClassElementImpl)._internalLookUpGetter(
-          getterName, library, false);
+      getter = (definingClass as ClassElementImpl)
+          ._internalLookUpGetter(getterName, library, false);
     }
     return getter;
   }
 
   MethodElement _internalLookUpConcreteMethod(
       String methodName, LibraryElement library, bool includeThisClass) {
     MethodElement method =
         _internalLookUpMethod(methodName, library, includeThisClass);
     while (method != null && method.isAbstract) {
       ClassElement definingClass = method.enclosingElement;
       if (definingClass == null) {
         return null;
       }
       method = definingClass.lookUpInheritedMethod(methodName, library);
     }
     return method;
   }
 
   PropertyAccessorElement _internalLookUpConcreteSetter(
       String setterName, LibraryElement library, bool includeThisClass) {
     PropertyAccessorElement setter =
         _internalLookUpSetter(setterName, library, includeThisClass);
     while (setter != null && setter.isAbstract) {
       Element definingClass = setter.enclosingElement;
       if (definingClass is! ClassElementImpl) {
         return null;
       }
-      setter = (definingClass as ClassElementImpl)._internalLookUpSetter(
-          setterName, library, false);
+      setter = (definingClass as ClassElementImpl)
+          ._internalLookUpSetter(setterName, library, false);
     }
     return setter;
   }
 
   PropertyAccessorElement _internalLookUpGetter(
       String getterName, LibraryElement library, bool includeThisClass) {
     HashSet<ClassElement> visitedClasses = new HashSet<ClassElement>();
     ClassElement currentElement = this;
     if (includeThisClass) {
       PropertyAccessorElement element = currentElement.getGetter(getterName);
@@ skipping 1334 matching lines @@
 
   /**
    * Return the offset of the name of this element in the file that contains the
    * declaration of this element, or `-1` if this element is synthetic, does not
    * have a name, or otherwise does not have an offset.
    */
   int get nameOffset;
 
   /**
    * **DEPRECATED** Use `computeNode()` instead.
-   * 
+   *
    * Return the resolved [AstNode] node that declares this element, or `null` if
    * this element is synthetic or isn't contained in a compilation unit, such as
    * a [LibraryElement].
    *
    * This method is expensive, because resolved AST might be evicted from cache,
    * so parsing and resolving will be performed.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    */
   @deprecated
@@ skipping 1529 matching lines @@
    * so parsing and resolving will be performed.
    */
   @override
   AstNode computeNode();
 }
 
 /**
  * A concrete implementation of a [FieldElement].
  */
 class FieldElementImpl extends PropertyInducingElementImpl
-    with PotentiallyConstVariableElement implements FieldElement {
+    with PotentiallyConstVariableElement
+    implements FieldElement {
   /**
    * An empty list of field elements.
    */
   @deprecated // Use FieldElement.EMPTY_LIST
   static const List<FieldElement> EMPTY_ARRAY = const <FieldElement>[];
 
   /**
    * Initialize a newly created synthetic field element to have the given [name]
    * at the given [offset].
    */
@@ skipping 853 matching lines @@
     if (parameters.length == 0) {
       return namedParameterTypes;
     }
     List<DartType> typeParameters =
         TypeParameterTypeImpl.getTypes(this.typeParameters);
     for (ParameterElement parameter in parameters) {
       if (parameter.parameterKind == ParameterKind.NAMED) {
         DartType type = parameter.type;
         if (typeArguments.length != 0 &&
             typeArguments.length == typeParameters.length) {
-          type = (type as TypeImpl).substitute2(
-              typeArguments, typeParameters, newPrune);
+          type = (type as TypeImpl)
+              .substitute2(typeArguments, typeParameters, newPrune);
         } else {
           type = (type as TypeImpl).pruned(newPrune);
         }
         namedParameterTypes[parameter.name] = type;
       }
     }
     return namedParameterTypes;
   }
 
   /**
@@ skipping 24 matching lines @@
       return DartType.EMPTY_LIST;
     }
     List<DartType> typeParameters =
         TypeParameterTypeImpl.getTypes(this.typeParameters);
     List<DartType> types = new List<DartType>();
     for (ParameterElement parameter in parameters) {
       if (parameter.parameterKind == ParameterKind.REQUIRED) {
         DartType type = parameter.type;
         if (typeArguments.length != 0 &&
             typeArguments.length == typeParameters.length) {
-          type = (type as TypeImpl).substitute2(
-              typeArguments, typeParameters, newPrune);
+          type = (type as TypeImpl)
+              .substitute2(typeArguments, typeParameters, newPrune);
         } else {
           type = (type as TypeImpl).pruned(newPrune);
         }
         types.add(type);
       }
     }
     return types;
   }
 
   @override
   List<DartType> get optionalParameterTypes {
     List<ParameterElement> parameters = baseParameters;
     if (parameters.length == 0) {
       return DartType.EMPTY_LIST;
     }
     List<DartType> typeParameters =
         TypeParameterTypeImpl.getTypes(this.typeParameters);
     List<DartType> types = new List<DartType>();
     for (ParameterElement parameter in parameters) {
       if (parameter.parameterKind == ParameterKind.POSITIONAL) {
         DartType type = parameter.type;
         if (typeArguments.length != 0 &&
             typeArguments.length == typeParameters.length) {
-          type = (type as TypeImpl).substitute2(
-              typeArguments, typeParameters, newPrune);
+          type = (type as TypeImpl)
+              .substitute2(typeArguments, typeParameters, newPrune);
         } else {
           type = (type as TypeImpl).pruned(newPrune);
         }
         types.add(type);
       }
     }
     return types;
   }
 
   @override
@@ skipping 161 matching lines @@
       return false;
     }
     // named parameters case
     if (t.namedParameterTypes.length > 0) {
       // check that the number of required parameters are equal, and check that
       // every t_i is more specific than every s_i
       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] as TypeImpl).isMoreSpecificThan(
-              sTypes[i], withDynamic)) {
+          if (!(tTypes[i] as TypeImpl)
+              .isMoreSpecificThan(sTypes[i], withDynamic)) {
             return false;
           }
         }
       }
       Map<String, DartType> namedTypesT = t.namedParameterTypes;
       Map<String, DartType> namedTypesS = s.namedParameterTypes;
       // if k >= m is false, return false: the passed function type has more
       // named parameter types than this
       if (namedTypesT.length < namedTypesS.length) {
         return false;
       }
       // Loop through each element in S verifying that T has a matching
       // parameter name and that the corresponding type is more specific then
       // the type in S.
       for (String keyS in namedTypesS.keys) {
         DartType typeT = namedTypesT[keyS];
         if (typeT == null) {
           return false;
         }
-        if (!(typeT as TypeImpl).isMoreSpecificThan(
-            namedTypesS[keyS], withDynamic)) {
+        if (!(typeT as TypeImpl)
+            .isMoreSpecificThan(namedTypesS[keyS], withDynamic)) {
           return false;
         }
       }
     } else if (s.namedParameterTypes.length > 0) {
       return false;
     } else {
       // positional parameter case
       int tArgLength = tTypes.length + tOpTypes.length;
       int sArgLength = sTypes.length + sOpTypes.length;
       // Check that the total number of parameters in t is greater than or equal
       // to the number of parameters in s and that the number of required
       // parameters in s is greater than or equal to the number of required
       // parameters in t.
       if (tArgLength < sArgLength || sTypes.length < tTypes.length) {
         return false;
       }
       if (tOpTypes.length == 0 && sOpTypes.length == 0) {
         // No positional arguments, don't copy contents to new array
         for (int i = 0; i < sTypes.length; i++) {
-          if (!(tTypes[i] as TypeImpl).isMoreSpecificThan(
-              sTypes[i], withDynamic)) {
+          if (!(tTypes[i] as TypeImpl)
+              .isMoreSpecificThan(sTypes[i], withDynamic)) {
             return false;
           }
         }
       } else {
         // Else, we do have positional parameters, copy required and positional
         // parameter types into arrays to do the compare (for loop below).
         List<DartType> tAllTypes = new List<DartType>(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<DartType> sAllTypes = new List<DartType>(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] as TypeImpl).isMoreSpecificThan(
-              sAllTypes[i], withDynamic)) {
+          if (!(tAllTypes[i] as TypeImpl)
+              .isMoreSpecificThan(sAllTypes[i], withDynamic)) {
             return false;
           }
         }
       }
     }
     DartType tRetType = t.returnType;
     DartType sRetType = s.returnType;
     return sRetType.isVoid ||
         (tRetType as TypeImpl).isMoreSpecificThan(sRetType, withDynamic);
   }
@@ skipping 1331 matching lines @@
       //
       ClassElement tElement = this.element;
       ClassElement sElement = type.element;
       if (tElement == sElement) {
         List<DartType> tArguments = typeArguments;
         List<DartType> sArguments = type.typeArguments;
         if (tArguments.length != sArguments.length) {
           return false;
         }
         for (int i = 0; i < tArguments.length; i++) {
-          if (!(tArguments[i] as TypeImpl).isMoreSpecificThan(
-              sArguments[i], withDynamic)) {
+          if (!(tArguments[i] as TypeImpl)
+              .isMoreSpecificThan(sArguments[i], withDynamic)) {
             return false;
           }
         }
         return true;
       }
     }
     //
     // Transitivity: T << U and U << S.
     //
     // First check for infinite loops
     if (element == null) {
       return false;
     }
     if (visitedElements == null) {
       visitedElements = new HashSet<ClassElement>();
     } else if (visitedElements.contains(element)) {
       return false;
     }
     visitedElements.add(element);
     try {
       // Iterate over all of the types U that are more specific than T because
       // they are direct supertypes of T and return true if any of them are more
       // specific than S.
       InterfaceTypeImpl supertype = superclass;
       if (supertype != null &&
           supertype.isMoreSpecificThan(type, withDynamic, visitedElements)) {
         return true;
       }
       for (InterfaceType interfaceType in interfaces) {
-        if ((interfaceType as InterfaceTypeImpl).isMoreSpecificThan(
-            type, withDynamic, visitedElements)) {
+        if ((interfaceType as InterfaceTypeImpl)
+            .isMoreSpecificThan(type, withDynamic, visitedElements)) {
           return true;
         }
       }
       for (InterfaceType mixinType in mixins) {
-        if ((mixinType as InterfaceTypeImpl).isMoreSpecificThan(
-            type, withDynamic, visitedElements)) {
+        if ((mixinType as InterfaceTypeImpl)
+            .isMoreSpecificThan(type, withDynamic, visitedElements)) {
           return true;
         }
       }
       // If a type I includes an instance method named `call`, and the type of
       // `call` is the function type F, then I is considered to be more specific
       // than F.
       MethodElement callMethod = getMethod('call');
       if (callMethod != null && !callMethod.isStatic) {
         FunctionTypeImpl callType = callMethod.type;
         if (callType.isMoreSpecificThan(type, withDynamic, visitedElements)) {
@@ skipping 953 matching lines @@
   void _addVisibleLibraries(
       Set<LibraryElement> visibleLibraries, bool includeExports) {
     // maybe already processed
     if (!visibleLibraries.add(this)) {
       return;
     }
     // add imported libraries
     for (ImportElement importElement in _imports) {
       LibraryElement importedLibrary = importElement.importedLibrary;
       if (importedLibrary != null) {
-        (importedLibrary as LibraryElementImpl)._addVisibleLibraries(
-            visibleLibraries, true);
+        (importedLibrary as LibraryElementImpl)
+            ._addVisibleLibraries(visibleLibraries, true);
       }
     }
     // add exported libraries
     if (includeExports) {
       for (ExportElement exportElement in _exports) {
         LibraryElement exportedLibrary = exportElement.exportedLibrary;
         if (exportedLibrary != null) {
-          (exportedLibrary as LibraryElementImpl)._addVisibleLibraries(
-              visibleLibraries, true);
+          (exportedLibrary as LibraryElementImpl)
+              ._addVisibleLibraries(visibleLibraries, true);
         }
       }
     }
   }
 
   /**
    * Return `true` if the given [library] is up to date with respect to the
    * given [timeStamp]. The set of [visitedLibraries] is used to prevent
    * infinite recusion in the case of mutually dependent libraries.
    */
@@ skipping 73 matching lines @@
    * so parsing and resolving will be performed.
    */
   @override
   VariableDeclaration computeNode();
 }
 
 /**
  * A concrete implementation of a [LocalVariableElement].
  */
 class LocalVariableElementImpl extends VariableElementImpl
-    with PotentiallyConstVariableElement implements LocalVariableElement {
+    with PotentiallyConstVariableElement
+    implements LocalVariableElement {
   /**
    * An empty list of field elements.
    */
   @deprecated // Use LocalVariableElement.EMPTY_LIST
   static const List<LocalVariableElement> EMPTY_ARRAY =
       const <LocalVariableElement>[];
 
   /**
    * The offset to the beginning of the visible range for this element.
    */
@@ skipping 889 matching lines @@
   List<TypeParameterElement> get typeParameters;
 
   @override
   FormalParameter computeNode();
 }
 
 /**
  * A concrete implementation of a [ParameterElement].
  */
 class ParameterElementImpl extends VariableElementImpl
-    with PotentiallyConstVariableElement implements ParameterElement {
+    with PotentiallyConstVariableElement
+    implements ParameterElement {
   /**
    * An empty list of parameter elements.
    */
   @deprecated // Use ParameterElement.EMPTY_LIST
   static const List<ParameterElement> EMPTY_ARRAY = const <ParameterElement>[];
 
   /**
    * A list containing all of the parameters defined by this parameter element.
    * There will only be parameters if this parameter is a function typed
    * parameter.
@@ skipping 1168 matching lines @@
       const <TopLevelVariableElement>[];
 
   @override
   VariableDeclaration computeNode();
 }
 
 /**
  * A concrete implementation of a [TopLevelVariableElement].
  */
 class TopLevelVariableElementImpl extends PropertyInducingElementImpl
-    with PotentiallyConstVariableElement implements TopLevelVariableElement {
+    with PotentiallyConstVariableElement
+    implements TopLevelVariableElement {
   /**
    * An empty list of top-level variable elements.
    */
   @deprecated // Use TopLevelVariableElement.EMPTY_LIST
   static const List<TopLevelVariableElement> EMPTY_ARRAY =
       const <TopLevelVariableElement>[];
 
   /**
    * Initialize a newly created synthetic top-level variable element to have the
    * given [name] and [offset].
@@ skipping 222 matching lines @@
    */
   static List<DartType> substitute(List<DartType> types,
       List<DartType> argumentTypes, List<DartType> parameterTypes,
       [List<FunctionTypeAliasElement> prune]) {
     int length = types.length;
     if (length == 0) {
       return types;
     }
     List<DartType> newTypes = new List<DartType>(length);
     for (int i = 0; i < length; i++) {
-      newTypes[i] = (types[i] as TypeImpl).substitute2(
-          argumentTypes, parameterTypes, prune);
+      newTypes[i] = (types[i] as TypeImpl)
+          .substitute2(argumentTypes, parameterTypes, prune);
     }
     return newTypes;
   }
 }
 
 /**
  * A type parameter.
  */
-abstract class TypeParameterElement implements Element {
+abstract class TypeParameterElement implements TypeDefiningElement {
   /**
    * An empty list of type parameter elements.
    */
   static const List<TypeParameterElement> EMPTY_LIST =
       const <TypeParameterElement>[];
 
   /**
    * Return the type representing the bound associated with this parameter, or
    * `null` if this parameter does not have an explicit bound.
    */
@@ skipping 573 matching lines @@
     // bottom <: void (as bottom is a subtype of all types).
     // void <: dynamic (as dynamic is a supertype of all types)
     return identical(type, this) || type.isDynamic;
   }
 
   @override
   TypeImpl pruned(List<FunctionTypeAliasElement> prune) => this;
 
   @override
   VoidTypeImpl substitute2(
-      List<DartType> argumentTypes, List<DartType> parameterTypes,
-      [List<FunctionTypeAliasElement> prune]) => this;
+          List<DartType> argumentTypes, List<DartType> parameterTypes,
+          [List<FunctionTypeAliasElement> prune]) =>
+      this;
 }
 
 /**
  * A visitor that visit all the elements recursively and fill the given [map].
  */
 class _BuildOffsetToElementMap extends GeneralizingElementVisitor {
   final Map<int, Element> map;
 
   _BuildOffsetToElementMap(this.map);
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }