Type check for-in statements.

pkg/analyzer/lib/src/generated/type_system.dart

 // Copyright (c) 2015, 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.
 
 library analyzer.src.generated.type_system;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
 import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
 import 'package:analyzer/src/generated/utilities_dart.dart';
 
 typedef bool _GuardedSubtypeChecker<T>(T t1, T t2, Set<Element> visited);
 
 /**
  * Implementation of [TypeSystem] using the strong mode rules.
  * https://github.com/dart-lang/dev_compiler/blob/master/STRONG_MODE.md
  */
 class StrongTypeSystemImpl extends TypeSystem {
   final _specTypeSystem = new TypeSystemImpl();
 
-  StrongTypeSystemImpl();
-
   bool anyParameterType(FunctionType ft, bool predicate(DartType t)) {
     return ft.parameters.any((p) => predicate(p.type));
   }
 
   @override
   bool canPromoteToType(DartType to, DartType from) => isSubtypeOf(to, from);
 
   /**
    * Given a type t, if t is an interface type with a call method
    * defined, return the function type for the call method, otherwise
@@ skipping 463 matching lines @@
    */
   bool isMoreSpecificThan(DartType leftType, DartType rightType);
 
   /**
    * Return `true` if the [leftType] is a subtype of the [rightType] (that is,
    * if leftType <: rightType).
    */
   bool isSubtypeOf(DartType leftType, DartType rightType);
 
   /**
+   * Searches the superinterfaces of [type] for implementations of [genericType]
+   * and returns the most specific type argument used for that generic type.
+   *
+   * For example, given [type] `List<int>` and [genericType] `Iterable<T>`,
+   * returns [int].
+   *
+   * Returns `null` if [type] does not implement [genericType].
+   */
+  // TODO(jmesserly): this is very similar to code used for flattening futures.
+  // The only difference is, because of a lack of TypeProvider, the other method
+  // has to match the Future type by its name and library. Here was are passed
+  // in the correct type.
+  DartType mostSpecificTypeArgument(DartType type, DartType genericType) {
+    if (type is! InterfaceType) return null;
+
+    // Walk the superinterface hierarchy looking for [genericType].
+    List<DartType> candidates = <DartType>[];
+    HashSet<ClassElement> visitedClasses = new HashSet<ClassElement>();
+    void recurse(InterfaceTypeImpl interface) {
+      if (interface.element == genericType.element &&
+          interface.typeArguments.isNotEmpty) {
+        candidates.add(interface.typeArguments[0]);
+      }
+      if (visitedClasses.add(interface.element)) {
+        if (interface.superclass != null) {
+          recurse(interface.superclass);
+        }
+        interface.mixins.forEach(recurse);
+        interface.interfaces.forEach(recurse);
+        visitedClasses.remove(interface.element);
+      }
+    }
+
+    recurse(type);
+
+    // Since the interface may be implemented multiple times with different
+    // type arguments, choose the best one.
+    return InterfaceTypeImpl.findMostSpecificType(candidates, this);
+  }
+
+  /**
    * Given a [DartType] type, return the [TypeParameterElement]s corresponding
    * to its formal type parameters (if any).
    *
    * @param type the type whose type arguments are to be returned
    * @return the type arguments associated with the given type
    */
   List<TypeParameterElement> typeFormalsAsElements(DartType type) {
     if (type is FunctionType) {
       return type.typeFormals;
     } else if (type is InterfaceType) {
@@ skipping 429 matching lines @@
       } else {
         passedOut = true;
       }
     } else if (type is FunctionType) {
       _visitFunctionType(typeParam, type, paramIn);
     } else if (type is InterfaceType) {
       _visitInterfaceType(typeParam, type, paramIn);
     }
   }
 }