Fix return type checking for generator functions.

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 1775 matching lines @@
       if (returnExpression == null) {
         return false;
       }
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR,
           returnExpression);
       return true;
     }
     // RETURN_WITHOUT_VALUE
     if (returnExpression == null) {
-      if (_computeReturnTypeForMethod(
-          null).isAssignableTo(expectedReturnType)) {
+      if (_inGenerator ||
+          _computeReturnTypeForMethod(null).isAssignableTo(expectedReturnType)) {
         return false;
       }
       _hasReturnWithoutValue = true;
       _errorReporter.reportErrorForNode(
           StaticWarningCode.RETURN_WITHOUT_VALUE,
           node);
       return true;
     } else if (_inGenerator) {
       // RETURN_IN_GENERATOR
       _errorReporter.reportErrorForNode(
@@ skipping 3357 matching lines @@
    * @param returnExpression the returned expression to evaluate
    * @param expectedReturnType the expressed return type by the enclosing method or function
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE].
    */
   bool _checkForReturnOfInvalidType(Expression returnExpression,
       DartType expectedReturnType) {
     if (_enclosingFunction == null) {
       return false;
     }
+    if (_inGenerator) {
+      // "return expression;" is disallowed in generators, but this is checked
+      // elsewhere.  Bare "return" is always allowed in generators regardless
+      // of the return type.  So no need to do any further checking.
+      return false;
+    }
     DartType staticReturnType = _computeReturnTypeForMethod(returnExpression);
     if (expectedReturnType.isVoid) {
       if (staticReturnType.isVoid ||
           staticReturnType.isDynamic ||
           staticReturnType.isBottom) {
         return false;
       }
       _errorReporter.reportTypeErrorForNode(
           StaticTypeWarningCode.RETURN_OF_INVALID_TYPE,
           returnExpression,
@@ skipping 583 matching lines @@
             CompileTimeErrorCode.IMPLEMENTS_SUPER_CLASS,
             interfaceNode,
             [superType.displayName]);
       }
     }
     // done
     return hasProblem;
   }
 
   DartType _computeReturnTypeForMethod(Expression returnExpression) {
-    // TODO(paulberry): do the right thing for generators.
+    // This method should never be called for generators, since generators are
+    // never allowed to contain return statements with expressions.
+    assert(!_inGenerator);
     if (returnExpression == null) {
       if (_enclosingFunction.isAsynchronous) {
         return _typeProvider.futureNullType;
       } else {
         return VoidTypeImpl.instance;
       }
     }
     DartType staticReturnType = getStaticType(returnExpression);
     if (staticReturnType != null &&
         _enclosingFunction.isAsynchronous &&
@@ skipping 439 matching lines @@
     toCheck.add(type.element);
     // type arguments
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       for (DartType typeArgument in interfaceType.typeArguments) {
         _addTypeToCheck(typeArgument);
       }
     }
   }
 }