Fix async/await type checking in analyzer.

pkg/analyzer/test/generated/static_warning_code_test.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.static_warning_code_test;
 
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:unittest/unittest.dart';
 
@@ skipping 1389 matching lines @@
             HintCode.UNUSED_IMPORT]);
     verify([source]);
   }
 
   void test_importOfNonLibrary() {
     resolveWithErrors(<String>[r'''
 part of lib;
 class A {}''', r'''
 library lib;
 import 'lib1.dart' deferred as p;
-var a = new p.A();'''],
-          <ErrorCode>[StaticWarningCode.IMPORT_OF_NON_LIBRARY]);
+var a = new p.A();'''], <ErrorCode>[StaticWarningCode.IMPORT_OF_NON_LIBRARY]);
   }
 
   void test_inconsistentMethodInheritanceGetterAndMethod() {
     Source source = addSource(r'''
 abstract class A {
   int x();
 }
 abstract class B {
   int get x;
 }
@@ skipping 1516 matching lines @@
   void test_redirectToNonClass_undefinedIdentifier() {
     Source source = addSource(r'''
 class B {
   factory B() = A;
 }''');
     resolve(source);
     assertErrors(source, [StaticWarningCode.REDIRECT_TO_NON_CLASS]);
     verify([source]);
   }
 
+  void test_returnWithoutValue_async() {
+    Source source = addSource('''
+import 'dart:async';
+Future<int> f() async {
+  return;
+}
+''');
+    resolve(source);
+    assertErrors(source, [StaticWarningCode.RETURN_WITHOUT_VALUE]);
+    verify([source]);
+  }
+
   void test_returnWithoutValue_factoryConstructor() {
     Source source = addSource("class A { factory A() { return; } }");
     resolve(source);
     assertErrors(source, [StaticWarningCode.RETURN_WITHOUT_VALUE]);
     verify([source]);
   }
 
   void test_returnWithoutValue_function() {
     Source source = addSource("int f() { return; }");
     resolve(source);
@@ skipping 101 matching lines @@
   }
 
   void test_typeAnnotationDeferredClass_asExpression() {
     resolveWithErrors(<String>[r'''
 library lib1;
 class A {}''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 f(var v) {
   v as a.A;
-}'''],
-          <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
+}'''], <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
   }
 
   void test_typeAnnotationDeferredClass_catchClause() {
     resolveWithErrors(<String>[r'''
 library lib1;
 class A {}''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 f(var v) {
   try {
   } on a.A {
   }
-}'''],
-          <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
+}'''], <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
   }
 
   void test_typeAnnotationDeferredClass_fieldFormalParameter() {
     resolveWithErrors(<String>[r'''
 library lib1;
 class A {}''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 class C {
   var v;
   C(a.A this.v);
-}'''],
-          <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
+}'''], <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
   }
 
   void test_typeAnnotationDeferredClass_functionDeclaration_returnType() {
     resolveWithErrors(<String>[r'''
 library lib1;
 class A {}''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 a.A f() { return null; }'''],
           <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
@@ skipping 11 matching lines @@
   }
 
   void test_typeAnnotationDeferredClass_isExpression() {
     resolveWithErrors(<String>[r'''
 library lib1;
 class A {}''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 f(var v) {
   bool b = v is a.A;
-}'''],
-          <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
+}'''], <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
   }
 
   void test_typeAnnotationDeferredClass_methodDeclaration_returnType() {
     resolveWithErrors(<String>[r'''
 library lib1;
 class A {}''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 class C {
   a.A m() { return null; }
-}'''],
-          <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
+}'''], <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
   }
 
   void test_typeAnnotationDeferredClass_simpleFormalParameter() {
     resolveWithErrors(<String>[r'''
 library lib1;
 class A {}''', r'''
 library root;
 import 'lib1.dart' deferred as a;
-f(a.A v) {}'''],
-          <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
+f(a.A v) {}'''], <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
   }
 
   void test_typeAnnotationDeferredClass_typeArgumentList() {
     resolveWithErrors(<String>[r'''
 library lib1;
 class A {}''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 class C<E> {}
-C<a.A> c;'''],
-          <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
+C<a.A> c;'''], <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
   }
 
   void test_typeAnnotationDeferredClass_typeArgumentList2() {
     resolveWithErrors(<String>[r'''
 library lib1;
 class A {}''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 class C<E, F> {}
 C<a.A, a.A> c;'''],
@@ skipping 11 matching lines @@
 class C<E extends a.A> {}'''],
           <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
   }
 
   void test_typeAnnotationDeferredClass_variableDeclarationList() {
     resolveWithErrors(<String>[r'''
 library lib1;
 class A {}''', r'''
 library root;
 import 'lib1.dart' deferred as a;
-a.A v;'''],
-          <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
+a.A v;'''], <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
   }
 
   void test_typeParameterReferencedByStatic_field() {
     Source source = addSource(r'''
 class A<K> {
   static K k;
 }''');
     resolve(source);
     assertErrors(
         source,
@@ skipping 305 matching lines @@
 
   void test_voidReturnForGetter() {
     Source source = addSource(r'''
 class S {
   void get value {}
 }''');
     resolve(source);
     assertErrors(source, [StaticWarningCode.VOID_RETURN_FOR_GETTER]);
   }
 }