Fix async/await type checking in 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 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 (VoidTypeImpl.instance.isAssignableTo(expectedReturnType)) {
+      if (_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;
     }
-    DartType staticReturnType = getStaticType(returnExpression);
+    DartType staticReturnType = _computeReturnTypeForMethod(returnExpression);
     if (expectedReturnType.isVoid) {
       if (staticReturnType.isVoid ||
           staticReturnType.isDynamic ||
           staticReturnType.isBottom) {
         return false;
       }
       _errorReporter.reportTypeErrorForNode(
           StaticTypeWarningCode.RETURN_OF_INVALID_TYPE,
           returnExpression,
           [staticReturnType, expectedReturnType, _enclosingFunction.displayName]);
       return true;
     }
-    if (_enclosingFunction.isAsynchronous && !_enclosingFunction.isGenerator) {
-      // TODO(brianwilkerson) Figure out how to get the type "Future" so that we
-      // can build the type we need to test against.
-//            InterfaceType impliedType = "Future<" + flatten(staticReturnType) + ">"
-//            if (impliedType.isAssignableTo(expectedReturnType)) {
-//              return false;
-//            }
-//            errorReporter.reportTypeErrorForNode(
-//                StaticTypeWarningCode.RETURN_OF_INVALID_TYPE,
-//                returnExpression,
-//                impliedType,
-//                expectedReturnType.getDisplayName(),
-//                enclosingFunction.getDisplayName());
-//            return true;
-      return false;
-    }
     if (staticReturnType.isAssignableTo(expectedReturnType)) {
       return false;
     }
     _errorReporter.reportTypeErrorForNode(
         StaticTypeWarningCode.RETURN_OF_INVALID_TYPE,
         returnExpression,
         [staticReturnType, expectedReturnType, _enclosingFunction.displayName]);
     return true;
     // TODO(brianwilkerson) Define a hint corresponding to the warning and
     // report it if appropriate.
@@ skipping 569 matching lines @@
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.IMPLEMENTS_SUPER_CLASS,
             interfaceNode,
             [superType.displayName]);
       }
     }
     // done
     return hasProblem;
   }
 
+  DartType _computeReturnTypeForMethod(Expression returnExpression) {
+    // TODO(paulberry): do the right thing for generators.
+    if (returnExpression == null) {
+      if (_enclosingFunction.isAsynchronous) {
+        return _typeProvider.futureType.substitute4(
+            <DartType>[_typeProvider.nullType]);
+      } else {
+        return VoidTypeImpl.instance;
+      }
+    }
+    DartType staticReturnType = getStaticType(returnExpression);
+    if (staticReturnType != null &&
+        _enclosingFunction.isAsynchronous &&
+        staticReturnType.element != _typeProvider.futureType.element) {
+      return _typeProvider.futureType.substitute4(<DartType>[staticReturnType]);
+    }
+    return staticReturnType;
+  }
+
   /**
    * Return the error code that should be used when the given class references itself directly.
    *
    * @param classElt the class that references itself
    * @return the error code that should be used
    */
   ErrorCode _getBaseCaseErrorCode(ClassElement classElt) {
     InterfaceType supertype = classElt.supertype;
     if (supertype != null && _enclosingClass == supertype.element) {
       return
@@ skipping 423 matching lines @@
     toCheck.add(type.element);
     // type arguments
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       for (DartType typeArgument in interfaceType.typeArguments) {
         _addTypeToCheck(typeArgument);
       }
     }
   }
 }