Fix async/await type checking in analyzer.

pkg/analyzer/test/generated/resolver_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.resolver_test;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 3057 matching lines @@
     verify([source]);
   }
 
   void test_isNotDouble() {
     Source source = addSource("var v = 1 is! double;");
     resolve(source);
     assertErrors(source, [HintCode.IS_NOT_DOUBLE]);
     verify([source]);
   }
 
+  void test_missingReturn_async() {
+    Source source = addSource('''
+import 'dart:async';
+Future<int> f() async {}
+''');
+    resolve(source);
+    assertErrors(source, [HintCode.MISSING_RETURN]);
+    verify([source]);
+  }
+
   void test_missingReturn_function() {
     Source source = addSource("int f() {}");
     resolve(source);
     assertErrors(source, [HintCode.MISSING_RETURN]);
     verify([source]);
   }
 
   void test_missingReturn_method() {
     Source source = addSource(r'''
 class A {
@@ skipping 2976 matching lines @@
     expect(nonPrefixedElement, same(nonPrefixedType));
   }
 }
 
 @reflectiveTest
 class LibraryResolver2Test extends ResolverTestCase {
   LibraryResolver2 _resolver;
 
   Source _coreLibrarySource;
 
+  Source _asyncLibrarySource;
+
   @override
   void setUp() {
     super.setUp();
     _resolver = new LibraryResolver2(analysisContext2);
     _coreLibrarySource =
         analysisContext2.sourceFactory.forUri(DartSdk.DART_CORE);
+    _asyncLibrarySource =
+        analysisContext2.sourceFactory.forUri(DartSdk.DART_ASYNC);
   }
 
   void test_imports_relative() {
     Source sourceA = addSource(r'''
 library libA;
 import 'libB.dart';
 class A {}''');
     Source sourceB = addNamedSource("/libB.dart", r'''
 library libB;
 import 'test.dart
 class B {}''');
     List<ResolvableLibrary> cycle = new List<ResolvableLibrary>();
     ResolvableLibrary coreLib = _createResolvableLibrary(_coreLibrarySource);
     coreLib.libraryElement = analysisContext2.computeLibraryElement(
         _coreLibrarySource) as LibraryElementImpl;
+    ResolvableLibrary asyncLib = _createResolvableLibrary(_asyncLibrarySource);
+    asyncLib.libraryElement = analysisContext2.computeLibraryElement(
+        _asyncLibrarySource) as LibraryElementImpl;
     ResolvableLibrary libA = _createResolvableLibrary(sourceA);
     ResolvableLibrary libB = _createResolvableLibrary(sourceB);
-    libA.importedLibraries = <ResolvableLibrary>[coreLib, libB];
-    libB.importedLibraries = <ResolvableLibrary>[coreLib, libA];
+    libA.importedLibraries = <ResolvableLibrary>[coreLib, asyncLib, libB];
+    libB.importedLibraries = <ResolvableLibrary>[coreLib, asyncLib, libA];
     cycle.add(libA);
     cycle.add(libB);
     LibraryElement library = _resolver.resolveLibrary(sourceA, cycle);
     List<LibraryElement> importedLibraries = library.importedLibraries;
     assertNamedElements(importedLibraries, ["dart.core", "libB"]);
   }
 
   ResolvableLibrary _createResolvableLibrary(Source source) {
     CompilationUnit unit = analysisContext2.parseCompilationUnit(source);
     ResolvableLibrary resolvableLibrary = new ResolvableLibrary(source);
@@ skipping 6857 matching lines @@
     // Create a mock library element with the types expected to be in dart:core.
     // We cannot use either ElementFactory or TestTypeProvider (which uses
     // ElementFactory) because we side-effect the elements in ways that would
     // break other tests.
     //
     InterfaceType objectType = _classElement("Object", null).type;
     InterfaceType boolType = _classElement("bool", objectType).type;
     InterfaceType numType = _classElement("num", objectType).type;
     InterfaceType doubleType = _classElement("double", numType).type;
     InterfaceType functionType = _classElement("Function", objectType).type;
+    InterfaceType futureType = _classElement("Future", objectType, ["T"]).type;
     InterfaceType intType = _classElement("int", numType).type;
     InterfaceType listType = _classElement("List", objectType, ["E"]).type;
     InterfaceType mapType = _classElement("Map", objectType, ["K", "V"]).type;
     InterfaceType stackTraceType = _classElement("StackTrace", objectType).type;
     InterfaceType stringType = _classElement("String", objectType).type;
     InterfaceType symbolType = _classElement("Symbol", objectType).type;
     InterfaceType typeType = _classElement("Type", objectType).type;
     CompilationUnitElementImpl coreUnit =
         new CompilationUnitElementImpl("core.dart");
     coreUnit.types = <ClassElement>[
         boolType.element,
         doubleType.element,
         functionType.element,
         intType.element,
         listType.element,
         mapType.element,
         objectType.element,
         stackTraceType.element,
         stringType.element,
         symbolType.element,
         typeType.element];
+    CompilationUnitElementImpl asyncUnit =
+        new CompilationUnitElementImpl("async.dart");
+    asyncUnit.types = <ClassElement>[futureType.element];
+    AnalysisContextImpl context = new AnalysisContextImpl();
     LibraryElementImpl coreLibrary = new LibraryElementImpl.forNode(
-        new AnalysisContextImpl(),
+        context,
         AstFactory.libraryIdentifier2(["dart.core"]));
     coreLibrary.definingCompilationUnit = coreUnit;
+    LibraryElementImpl asyncLibrary = new LibraryElementImpl.forNode(
+        context,
+        AstFactory.libraryIdentifier2(["dart.async"]));
+    asyncLibrary.definingCompilationUnit = asyncUnit;
     //
     // Create a type provider and ensure that it can return the expected types.
     //
-    TypeProviderImpl provider = new TypeProviderImpl(coreLibrary);
+    TypeProviderImpl provider = new TypeProviderImpl(coreLibrary, asyncLibrary);
     expect(provider.boolType, same(boolType));
     expect(provider.bottomType, isNotNull);
     expect(provider.doubleType, same(doubleType));
     expect(provider.dynamicType, isNotNull);
     expect(provider.functionType, same(functionType));
+    expect(provider.futureType, same(futureType));
     expect(provider.intType, same(intType));
     expect(provider.listType, same(listType));
     expect(provider.mapType, same(mapType));
     expect(provider.objectType, same(objectType));
     expect(provider.stackTraceType, same(stackTraceType));
     expect(provider.stringType, same(stringType));
     expect(provider.symbolType, same(symbolType));
     expect(provider.typeType, same(typeType));
   }
 
@@ skipping 618 matching lines @@
         // check propagated type
         FunctionType propagatedType = node.propagatedType as FunctionType;
         expect(propagatedType.returnType, test.typeProvider.stringType);
       } on AnalysisException catch (e, stackTrace) {
         thrownException[0] = new CaughtException(e, stackTrace);
       }
     }
     return null;
   }
 }