Add type inference logic for "for-in" loops.

pkg/front_end/lib/src/fasta/kernel/kernel_shadow_ast.dart

 // Copyright (c) 2017, 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 file declares a "shadow hierarchy" of concrete classes which extend
 /// the kernel class hierarchy, adding methods and fields needed by the
 /// BodyBuilder.
 ///
 /// Instances of these classes may be created using the factory methods in
 /// `ast_factory.dart`.
@@ skipping 422 matching lines @@
     // absolute URI.
     return enclosingLibrary.importUri.toString();
   }
 
   void _setInferredType(DartType inferredType) {
     _isInferred = true;
     super.type = inferredType;
   }
 }
 
+/// Concrete shadow object representing a for-in loop in kernel form.
+class KernelForInStatement extends ForInStatement implements KernelStatement {
+  final bool _declaresVariable;
+
+  KernelForInStatement(VariableDeclaration variable, Expression iterable,
+      Statement body, this._declaresVariable,
+      {bool isAsync: false})
+      : super(variable, iterable, body, isAsync: isAsync);
+
+  @override
+  void _inferStatement(KernelTypeInferrer inferrer) {
+    inferrer.listener.forInStatementEnter(this);
+    var iterableClass = isAsync
+        ? inferrer.coreTypes.streamClass
+        : inferrer.coreTypes.iterableClass;
+    DartType context;
+    bool typeNeeded = false;
+    KernelVariableDeclaration variable;
+    if (_declaresVariable) {
+      variable = this.variable;
+      if (variable._implicitlyTyped) {
+        typeNeeded = true;
+        // TODO(paulberry): In this case, should the context be `Iterable<?>`?
+      } else {
+        context = inferrer.wrapType(variable.type, iterableClass);
+      }
+    } else {
+      // TODO(paulberry): In this case, should the context be based on the
+      // declared type of the loop variable?

[ahe, 2017/05/29 13:39:22]

Notice also that the loop variable corresponds to a write to a variable in the
enclosing scope. So there may be some diagnostics that point to the wrong
location.

[Paul Berry, 2017/05/29 14:23:32]

Good point.  I've added a TODO to address this.

+    }
+    var inferredExpressionType =
+        inferrer.inferExpression(iterable, context, typeNeeded);
+    if (typeNeeded) {
+      var inferredType = const DynamicType();
+      if (inferredExpressionType is InterfaceType) {
+        InterfaceType supertype = inferrer.classHierarchy
+            .getTypeAsInstanceOf(inferredExpressionType, iterableClass);
+        if (supertype != null) {
+          inferredType = supertype.typeArguments[0];
+        }
+      }
+      inferrer.instrumentation?.record(
+          Uri.parse(inferrer.uri),
+          variable.fileOffset,
+          'type',
+          new InstrumentationValueForType(inferredType));
+      variable.type = inferredType;
+    }
+    inferrer.inferStatement(body);
+    inferrer.listener.forInStatementExit(this);
+  }
+}
+
 /// Concrete shadow object representing a local function declaration in kernel
 /// form.
 class KernelFunctionDeclaration extends FunctionDeclaration
     implements KernelStatement {
   KernelFunctionDeclaration(VariableDeclaration variable, FunctionNode function)
       : super(variable, function);
 
   @override
   void _inferStatement(KernelTypeInferrer inferrer) {
     inferrer.listener.functionDeclarationEnter(this);
@@ skipping 1082 matching lines @@
           closureContext.isAsync
               ? inferrer.coreTypes.streamClass
               : inferrer.coreTypes.iterableClass);
     }
     var inferredType = inferrer.inferExpression(
         expression, typeContext, closureContext != null);
     closureContext.handleYield(inferrer, isYieldStar, inferredType);
     inferrer.listener.yieldStatementExit(this);
   }
 }