Type check await for.

pkg/compiler/lib/src/typechecker.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.
 
 library dart2js.typechecker;
 
 import 'common/names.dart' show
     Identifiers;
 import 'common/tasks.dart' show
     CompilerTask;
@@ skipping 1774 matching lines @@
   }
 
   visitBreakStatement(BreakStatement node) {
     return const StatementType();
   }
 
   visitContinueStatement(ContinueStatement node) {
     return const StatementType();
   }
 
+  DartType computeForInElementType(ForIn node) {
+    VariableDefinitions declaredIdentifier =
+        node.declaredIdentifier.asVariableDefinitions();
+    if (declaredIdentifier != null) {
+      return
+          analyzeWithDefault(declaredIdentifier.type, const DynamicType());
+    } else {
+      return analyze(node.declaredIdentifier);
+    }
+  }
+
   visitAsyncForIn(AsyncForIn node) {
-    analyze(node.expression);
+    DartType elementType = computeForInElementType(node);
+    DartType expressionType = analyze(node.expression);
+    // TODO(johnniwinther): Move this to _CompilerCoreTypes.
+    compiler.streamClass.ensureResolved(compiler);
+    DartType streamOfDynamic = coreTypes.streamType();
+    if (!types.isAssignable(expressionType, streamOfDynamic)) {
+      reportMessage(node.expression,
+          MessageKind.NOT_ASSIGNABLE,
+          {'fromType': expressionType, 'toType': streamOfDynamic},
+          isHint: true);
+    } else {
+      InterfaceType interfaceType =
+          Types.computeInterfaceType(compiler, expressionType);
+      if (interfaceType != null) {
+        InterfaceType streamType =
+            interfaceType.asInstanceOf(compiler.streamClass);
+        if (streamType != null) {
+          DartType streamElementType = streamType.typeArguments.first;
+          if (!types.isAssignable(streamElementType, elementType)) {
+            reportMessage(node.expression,
+                MessageKind.FORIN_NOT_ASSIGNABLE,
+                {'currentType': streamElementType,
+                 'expressionType': expressionType,
+                 'elementType': elementType},
+                isHint: true);
+          }
+        }
+      }
+    }
     analyze(node.body);
     return const StatementType();
   }
 
   visitSyncForIn(SyncForIn node) {
-    DartType elementType;
-    VariableDefinitions declaredIdentifier =
-        node.declaredIdentifier.asVariableDefinitions();
-    if (declaredIdentifier != null) {
-      elementType =
-          analyzeWithDefault(declaredIdentifier.type, const DynamicType());
-    } else {
-      elementType = analyze(node.declaredIdentifier);
-    }
+    DartType elementType = computeForInElementType(node);
     DartType expressionType = analyze(node.expression);
     DartType iteratorType = lookupMemberType(node.expression,
         expressionType, Identifiers.iterator, MemberKind.GETTER);
     DartType currentType = lookupMemberType(node.expression,
               iteratorType, Identifiers.current, MemberKind.GETTER,
               isHint: true);
     if (!types.isAssignable(currentType, elementType)) {
       reportMessage(node.expression,
           MessageKind.FORIN_NOT_ASSIGNABLE,
           {'currentType': currentType,
@@ skipping 122 matching lines @@
 
   visitTypedef(Typedef node) {
     // Do not typecheck [Typedef] nodes.
   }
 
   visitNode(Node node) {
     compiler.internalError(node,
         'Unexpected node ${node.getObjectDescription()} in the type checker.');
   }
 }