Handle for-in loops

lib/src/checker/resolver.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.
 
 /// Encapsulates how to invoke the analyzer resolver and overrides how it
 /// computes types on expressions to use our restricted set of types.
 library dev_compiler.src.checker.resolver;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 602 matching lines @@
     if (type == null || type == _typeProvider.bottomType) return;
     element.type = type;
     if (element is PropertyInducingElement) {
       element.getter.returnType = type;
       if (!element.isFinal && !element.isConst) {
         element.setter.parameters[0].type = type;
       }
     }
   }
 
+  // TODO(vsm): Use leafp's matchType here?
+  DartType _findIteratedType(InterfaceType type) {
+    if (type.element == _typeProvider.iterableType.element) {
+      var typeArguments = type.typeArguments;
+      assert(typeArguments.length == 1);
+      return typeArguments[0];
+    }
+
+    if (type == _typeProvider.objectType) return null;
+
+    var result = _findIteratedType(type.superclass);
+    if (result != null) return result;
+
+    for (final parent in type.interfaces) {
+      result = _findIteratedType(parent);
+      if (result != null) return result;
+    }
+
+    for (final parent in type.mixins) {
+      result = _findIteratedType(parent);
+      if (result != null) return result;
+    }
+
+    return null;
+  }
+
+  @override
+  visitDeclaredIdentifier(DeclaredIdentifier node) {
+    super.visitDeclaredIdentifier(node);
+    if (node.type != null) return;
+
+    var parent = node.parent;
+    assert(parent is ForEachStatement);
+    var expr = parent.iterable;
+    var element = node.element as LocalVariableElementImpl;
+    var exprType = expr.staticType;
+    if (exprType is InterfaceType) {
+      var iteratedType = _findIteratedType(exprType);
+      if (iteratedType != null) {
+        element.type = iteratedType;
+      }
+    }
+  }
+
   @override // to propagate types to identifiers
   visitMethodInvocation(MethodInvocation node) {
     // TODO(sigmund): follow up with analyzer team - why is this needed?
     visitSimpleIdentifier(node.methodName);
     super.visitMethodInvocation(node);
 
     var e = node.methodName.staticElement;
     if (e is FunctionElement &&
         e.library.name == '_foreign_helper' &&
         e.name == 'JS') {
@@ skipping 32 matching lines @@
     }
   }
 
   // Review note: no longer need to override visitFunctionExpression, this is
   // handled by the analyzer internally.
   // TODO(vsm): in visitbinaryExpression: check computeStaticReturnType result?
   // TODO(vsm): in visitFunctionDeclaration: Should we ever use the expression
   // type in a (...) => expr or just the written type?
 
 }