Update yield warnings.

pkg/compiler/lib/src/resolution/signatures.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.
 
 part of resolution;
 
 /**
  * [SignatureResolver] resolves function signatures.
  */
 class SignatureResolver extends MappingVisitor<FormalElementX> {
@@ skipping 243 matching lines @@
   }
 
   /**
    * Resolves formal parameters and return type of a [FunctionExpression]
    * to a [FunctionSignature].
    *
    * If [createRealParameters] is `true`, the parameters will be
    * real parameters implementing the [ParameterElement] interface. Otherwise,
    * the parameters will only implement [FormalElement].
    */
-  static FunctionSignature analyze(Compiler compiler,
-                                   NodeList formalParameters,
-                                   Node returnNode,
-                                   FunctionTypedElement element,
-                                   ResolutionRegistry registry,
-                                   {MessageKind defaultValuesError,
-                                    bool createRealParameters: false}) {
+  static FunctionSignature analyze(
+      Compiler compiler,
+      NodeList formalParameters,
+      Node returnNode,
+      FunctionTypedElement element,
+      ResolutionRegistry registry,
+      {MessageKind defaultValuesError,
+       bool createRealParameters: false,
+       bool isFunctionExpression: false}) {
+
     SignatureResolver visitor = new SignatureResolver(compiler, element,
         registry, defaultValuesError: defaultValuesError,
         createRealParameters: createRealParameters);
     Link<Element> parameters = const Link<Element>();
     int requiredParameterCount = 0;
     if (formalParameters == null) {
       if (!element.isGetter) {
         if (element.isErroneous) {
           // If the element is erroneous, an error should already have been
           // reported. In the case of parse errors, it is possible that there
@@ skipping 20 matching lines @@
     }
     DartType returnType;
     if (element.isFactoryConstructor) {
       returnType = element.enclosingClass.thisType;
       // Because there is no type annotation for the return type of
       // this element, we explicitly add one.
       if (compiler.enableTypeAssertions) {
         registry.registerIsCheck(returnType);
       }
     } else {
-      returnType = visitor.resolveReturnType(returnNode);
+      AsyncMarker asyncMarker = AsyncMarker.SYNC;
+      if (isFunctionExpression) {
+        // Use async marker to determine the return type of function
+        // expressions.
+        FunctionElement function = element;
+        asyncMarker = function.asyncMarker;
+      }
+      switch (asyncMarker) {
+      case AsyncMarker.SYNC:
+        returnType = visitor.resolveReturnType(returnNode);
+        break;
+      case AsyncMarker.SYNC_STAR:
+        returnType = compiler.coreTypes.iterableType();
+        break;
+      case AsyncMarker.ASYNC:
+        returnType = compiler.coreTypes.futureType();
+        break;
+      case AsyncMarker.ASYNC_STAR:
+        returnType = compiler.coreTypes.streamType();
+        break;
+      }
     }
 
     if (element.isSetter && (requiredParameterCount != 1 ||
                                visitor.optionalParameterCount != 0)) {
       // If there are no formal parameters, we already reported an error above.
       if (formalParameters != null) {
         compiler.reportError(formalParameters,
                                  MessageKind.ILLEGAL_SETTER_FORMALS);
       }
     }
@@ skipping 58 matching lines @@
 
   DartType resolveReturnType(TypeAnnotation annotation) {
     if (annotation == null) return const DynamicType();
     DartType result = resolver.resolveTypeAnnotation(annotation);
     if (result == null) {
       return const DynamicType();
     }
     return result;
   }
 }