Model 'await for' as an explicit node in tree and fix its handling.

pkg/compiler/lib/src/resolution/members.dart

 // Copyright (c) 2012, 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.
 
 part of resolution;
 
 abstract class TreeElements {
   AnalyzableElement get analyzedElement;
   Iterable<Node> get superUses;
 
@@ skipping 3580 matching lines @@
       registry.useLabel(node, label);
     }
     registry.registerTargetOf(node, target);
   }
 
   registerImplicitInvocation(String name, int arity) {
     Selector selector = new Selector.call(name, null, arity);
     registry.registerDynamicInvocation(selector);
   }
 
-  visitForIn(ForIn node) {
-    LibraryElement library = enclosingElement.library;
+  visitAsyncForIn(AsyncForIn node) {
+    registry.registerAsyncForIn(node);
+    registry.setCurrentSelector(node, compiler.currentSelector);
+    registry.registerDynamicGetter(compiler.currentSelector);
+    registry.setMoveNextSelector(node, compiler.moveNextSelector);
+    registry.registerDynamicInvocation(compiler.moveNextSelector);
+
+    visit(node.expression);
+
+    Scope blockScope = new BlockScope(scope);
+    visitForInDeclaredIdentifierIn(node.declaredIdentifier, node, blockScope);
+    visitLoopBodyIn(node, node.body, blockScope);
+  }
+
+  visitSyncForIn(SyncForIn node) {
     registry.setIteratorSelector(node, compiler.iteratorSelector);
     registry.registerDynamicGetter(compiler.iteratorSelector);
     registry.setCurrentSelector(node, compiler.currentSelector);
     registry.registerDynamicGetter(compiler.currentSelector);
     registry.setMoveNextSelector(node, compiler.moveNextSelector);
     registry.registerDynamicInvocation(compiler.moveNextSelector);
 
     visit(node.expression);
+
     Scope blockScope = new BlockScope(scope);
-    Node declaration = node.declaredIdentifier;
+    visitForInDeclaredIdentifierIn(node.declaredIdentifier, node, blockScope);
+    visitLoopBodyIn(node, node.body, blockScope);
+  }
+
+  visitForInDeclaredIdentifierIn(Node declaration, ForIn node,
+                                 Scope blockScope) {
+    LibraryElement library = enclosingElement.library;
 
     bool oldAllowFinalWithoutInitializer = allowFinalWithoutInitializer;
     allowFinalWithoutInitializer = true;
     visitIn(declaration, blockScope);
     allowFinalWithoutInitializer = oldAllowFinalWithoutInitializer;
 
     Send send = declaration.asSend();
     VariableDefinitions variableDefinitions =
         declaration.asVariableDefinitions();
     Element loopVariable;
@@ skipping 29 matching lines @@
       registry.setSelector(declaration, loopVariableSelector);
       registerSend(loopVariableSelector, loopVariable);
     } else {
       // The selector may only be null if we reported an error.
       assert(invariant(declaration, compiler.compilationFailed));
     }
     if (loopVariable != null) {
       // loopVariable may be null if it could not be resolved.
       registry.setForInVariable(node, loopVariable);
     }
-    visitLoopBodyIn(node, node.body, blockScope);
   }
 
   visitLabel(Label node) {
     // Labels are handled by their containing statements/cases.
   }
 
   visitLabeledStatement(LabeledStatement node) {
     Statement body = node.statement;
     JumpTarget targetElement = getOrDefineTarget(body);
     Map<String, LabelDefinition> labelElements = <String, LabelDefinition>{};
@@ skipping 1404 matching lines @@
 }
 
 /// The result for the resolution of the `assert` method.
 class AssertResult implements ResolutionResult {
   const AssertResult();
 
   Element get element => null;
 
   String toString() => 'AssertResult()';
 }