fixes #221, initial sync*, async, async* implementation

lib/src/checker/checker.dart

 // Copyright (c) 2015, 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 dev_compiler.src.checker.checker;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/scanner.dart' show Token, TokenType;
@@ skipping 388 matching lines @@
     var field = node.fieldName;
     DartType staticType = rules.elementType(field.staticElement);
     checkAssignment(node.expression, staticType);
     node.visitChildren(this);
   }
 
   @override
   void visitForEachStatement(ForEachStatement node) {
     // Check that the expression is an Iterable.
     var expr = node.iterable;
-    var iterableType = rules.provider.iterableType;
+    var iterableType = node.awaitKeyword != null
+        ? rules.provider.streamType
+        : rules.provider.iterableType;
     var loopVariable = node.identifier != null
         ? node.identifier
         : node.loopVariable.identifier;
     var iteratorType = loopVariable.staticType;
     var checkedType = iterableType.substitute4([iteratorType]);
     checkAssignment(expr, checkedType);
     node.visitChildren(this);
   }
 
   @override
@@ skipping 151 matching lines @@
     var element = node.staticElement;
     if (element == null) {
       _recordMessage(new MissingTypeError(node));
     } else {
       var type = node.staticElement.type;
       checkArgumentList(node.argumentList, type);
     }
     node.visitChildren(this);
   }
 
-  DartType _getExpectedReturnType(FunctionBody body, bool yieldStar) {
-    FunctionType functionType;
-    var parent = body.parent;
-    if (parent is Declaration) {
-      functionType = rules.elementType(parent.element);
-    } else {
-      assert(parent is FunctionExpression);
-      functionType = rules.getStaticType(parent);
-    }
-
-    var type = functionType.returnType;
-    var provider = rules.provider;
-
-    InterfaceType expectedType = null;
-    if (body.isAsynchronous) {
-      if (body.isGenerator) {
-        // Stream<T> -> T
-        expectedType = provider.streamType;
-      } else {
-        // Future<T> -> T
-        // TODO(vsm): Revisit with issue #228.
-        expectedType = provider.futureType;
-      }
-    } else {
-      if (body.isGenerator) {
-        // Iterable<T> -> T
-        expectedType = provider.iterableType;
-      } else {
-        // T -> T
-        return type;
-      }
-    }
-    if (yieldStar) {
-      if (type.isDynamic) {
-        // Ensure it's at least a Stream / Iterable.
-        return expectedType.substitute4([provider.dynamicType]);
-      } else {
-        // Analyzer will provide a separate error if expected type
-        // is not compatible with type.
-        return type;
-      }
-    }
-    if (type.isDynamic) {
-      return type;
-    } else if (type is InterfaceType && type.element == expectedType.element) {
-      return type.typeArguments[0];
-    } else {
-      // Malformed type - fallback on analyzer error.
-      return null;
-    }
-  }
-
-  FunctionBody _getFunctionBody(AstNode node) {
-    while (node is! FunctionBody) {
-      node = node.parent;
-    }
-    return node as FunctionBody;
-  }
-
   void _checkReturnOrYield(Expression expression, AstNode node,
-      [bool yieldStar = false]) {
-    var body = _getFunctionBody(node);
-    var type = _getExpectedReturnType(body, yieldStar);
+      {bool yieldStar: false}) {
+    var body = node.getAncestor((n) => n is FunctionBody);
+    var type = rules.getExpectedReturnType(body, yieldStar: yieldStar);
     if (type == null) {
       // We have a type mismatch: the async/async*/sync* modifier does
       // not match the return or yield type.  We should have already gotten an
       // analyzer error in this case.
       return;
     }
     // TODO(vsm): Enforce void or dynamic (to void?) when expression is null.
     if (expression != null) checkAssignment(expression, type);
   }
 
   @override
   void visitExpressionFunctionBody(ExpressionFunctionBody node) {
     _checkReturnOrYield(node.expression, node);
     node.visitChildren(this);
   }
 
   @override
   void visitReturnStatement(ReturnStatement node) {
     _checkReturnOrYield(node.expression, node);
     node.visitChildren(this);
   }
 
   @override
   void visitYieldStatement(YieldStatement node) {
-    _checkReturnOrYield(node.expression, node, node.star != null);
+    _checkReturnOrYield(node.expression, node, yieldStar: node.star != null);
     node.visitChildren(this);
   }
 
   @override
   void visitPropertyAccess(PropertyAccess node) {
     var target = node.realTarget;
     if (rules.isDynamicTarget(target)) {
       _recordDynamicInvoke(node, target);
     }
     node.visitChildren(this);
@@ skipping 318 matching lines @@
     if (info is CoercionInfo) {
       // TODO(jmesserly): if we're run again on the same AST, we'll produce the
       // same annotations. This should be harmless. This might go away once
       // CodeChecker is integrated better with analyzer, as it will know that
       // checking has already been performed.
       // assert(CoercionInfo.get(info.node) == null);
       CoercionInfo.set(info.node, info);
     }
   }
 }