Add static type checking of "yield*" statements to analyzer.

pkg/analyzer/lib/src/generated/error_verifier.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 engine.resolver.error_verifier;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'ast.dart';
@@ skipping 1078 matching lines @@
 
   @override
   Object visitWhileStatement(WhileStatement node) {
     _checkForNonBoolCondition(node.condition);
     return super.visitWhileStatement(node);
   }
 
   @override
   Object visitYieldStatement(YieldStatement node) {
     if (_inGenerator) {
-      _checkForYieldOfInvalidType(node.expression);
+      _checkForYieldOfInvalidType(node.expression, node.star != null);
     } else {
       CompileTimeErrorCode errorCode;
       if (node.star != null) {
         errorCode = CompileTimeErrorCode.YIELD_EACH_IN_NON_GENERATOR;
       } else {
         errorCode = CompileTimeErrorCode.YIELD_IN_NON_GENERATOR;
       }
       _errorReporter.reportErrorForNode(errorCode, node);
     }
     return super.visitYieldStatement(node);
@@ skipping 4601 matching lines @@
     }
     return false;
   }
 
   /**
    * Check for a type mis-match between the yielded type and the declared
    * return type of a generator function.
    *
    * This method should only be called in generator functions.
    */
-  bool _checkForYieldOfInvalidType(Expression yieldExpression) {
+  bool _checkForYieldOfInvalidType(Expression yieldExpression,
+      bool isYieldEach) {
     assert(_inGenerator);
     if (_enclosingFunction == null) {
       return false;
     }
     DartType declaredReturnType = _enclosingFunction.returnType;
     DartType staticYieldedType = getStaticType(yieldExpression);
     DartType impliedReturnType;
-    if (_enclosingFunction.isAsynchronous) {
+    if (isYieldEach) {
+      impliedReturnType = staticYieldedType;
+    } else if (_enclosingFunction.isAsynchronous) {
       impliedReturnType =
           _typeProvider.streamType.substitute4(<DartType>[staticYieldedType]);
     } else {
       impliedReturnType =
           _typeProvider.iterableType.substitute4(<DartType>[staticYieldedType]);
     }
     if (impliedReturnType.isAssignableTo(declaredReturnType)) {
       return false;
     }
     _errorReporter.reportTypeErrorForNode(
@@ skipping 529 matching lines @@
     toCheck.add(type.element);
     // type arguments
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       for (DartType typeArgument in interfaceType.typeArguments) {
         _addTypeToCheck(typeArgument);
       }
     }
   }
 }