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.getter(
+             node.identifier.name, converter.convertElement(currentLibrary));

[Paul Berry, 2014/11/03 15:05:56]

I'm confused.  The only situation in which accessSemantics.kind should be
AccessKind.DYNAMIC should be something like this:

  class A {
    var x;
    f() {
      for (x in ...) { ... }
    }
  }

In which case, it seems like creating a getter on the current library is the
wrong thing to do.

(Side note: there is currently a bug where the "x" in "for (x in ...) { ... }"
will be incorrectly classified by ACCESS_SEMANTICS_VISITOR as a read access
rather than a write access.  I'll upload a CL to fix that shortly.)

[Johnni Winther, 2014/11/04 12:58:53]

The selector should have been a setter. Nice catch! Will be tested when we have
support for field declarations (soon-ish).

+       } else {
+         variableElement = converter.convertElement(accessSemantics.element);

[Paul Berry, 2014/11/03 15:05:56]

This seems like it will break if the variable in the for loop is undefined,
since in that case accessSemantics.element will be null.

[Johnni Winther, 2014/11/04 12:58:53]

Yes. We seem to be missing a statically unresolved access semantics for the case
when implicit this cannot be assumed, i.e. static/top-level context.

+       }
+    } 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));
+  }
 }