Support for-in in analyzer2dart.

pkg/analyzer2dart/lib/src/cps_generator.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.
 
 library analyzer2dart.cps_generator;
 
 import 'package:analyzer/analyzer.dart';
 
 import 'package:compiler/implementation/dart_types.dart' as dart2js;
 import 'package:compiler/implementation/elements/elements.dart' as dart2js;
@@ skipping 13 matching lines @@
 
 class CpsGeneratingVisitor extends SemanticVisitor<ir.Node>
     with IrBuilderMixin<AstNode> {
   final analyzer.Element element;
   final ElementConverter converter;
 
   CpsGeneratingVisitor(this.converter, this.element);
 
   Source get currentSource => element.source;
 
+  analyzer.LibraryElement get currentLibrary => element.library;
+
   ir.Node visit(AstNode node) => node.accept(this);
 
   @override
   ir.FunctionDefinition visitFunctionDeclaration(FunctionDeclaration node) {
     analyzer.FunctionElement function = node.element;
     dart2js.FunctionElement element = converter.convertElement(function);
     return withBuilder(
         new IrBuilder(DART_CONSTANT_SYSTEM,
                       element,
                       // TODO(johnniwinther): Supported closure variables.
@@ skipping 292 matching lines @@
                        buildBody: subbuild(node.body),
                        buildUpdate: subbuildSequence(node.updaters));
   }
 
   @override
   visitWhileStatement(WhileStatement node) {
     // TODO(johnniwinther): Support `while` as a jump target.
     irBuilder.buildWhile(buildCondition: subbuild(node.condition),
                          buildBody: subbuild(node.body));
   }
+
+  @override
+  visitDeclaredIdentifier(DeclaredIdentifier node) {
+    giveUp(node, "Unexpected node: DeclaredIdentifier");
+  }
+
+  @override
+  visitForEachStatement(ForEachStatement node) {
+    SubbuildFunction buildVariableDeclaration;
+    dart2js.Element variableElement;
+    Selector variableSelector;
+    if (node.identifier != null) {
+       AccessSemantics accessSemantics =
+           node.identifier.accept(ACCESS_SEMANTICS_VISITOR);
+       if (accessSemantics.kind == AccessKind.DYNAMIC) {
+         variableSelector = new Selector.setter(
+             node.identifier.name, converter.convertElement(currentLibrary));
+       } else if (accessSemantics.element != null) {
+         variableElement = converter.convertElement(accessSemantics.element);
+         variableSelector = new Selector.setter(
+             variableElement.name,
+             converter.convertElement(accessSemantics.element.library));
+       } else {
+         giveUp(node, 'For-in of unresolved variable: $accessSemantics');
+       }
+    } else {
+      assert(invariant(
+          node, node.loopVariable != null, "Loop variable expected"));
+      variableElement = converter.convertElement(node.loopVariable.element);
+      buildVariableDeclaration = (IrBuilder builder) {
+        builder.declareLocalVariable(variableElement);
+      };
+    }
+    // TODO(johnniwinther): Support `for-in` as a jump target.
+    irBuilder.buildForIn(
+        buildExpression: subbuild(node.iterable),
+        buildVariableDeclaration: buildVariableDeclaration,
+        variableElement: variableElement,
+        variableSelector: variableSelector,
+        buildBody: subbuild(node.body));
+  }
 }