Fix async/await type checking in analyzer.

pkg/analyzer/lib/src/generated/engine.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine;
 
 import "dart:math" as math;
@@ skipping 950 matching lines @@
    * The set of declared variables used when computing constant values.
    */
   DeclaredVariables _declaredVariables = new DeclaredVariables();
 
   /**
    * A source representing the core library.
    */
   Source _coreLibrarySource;
 
   /**
+   * A source representing the async library.
+   */
+  Source _asyncLibrarySource;
+
+  /**
    * The partition that contains analysis results that are not shared with other contexts.
    */
   CachePartition _privatePartition;
 
   /**
    * A table mapping the sources known to the context to the information known about the source.
    */
   AnalysisCache _cache;
 
   /**
@@ skipping 415 matching lines @@
     } else if (factory.context != null) {
       throw new IllegalStateException(
           "Source factories cannot be shared between contexts");
     }
     if (_sourceFactory != null) {
       _sourceFactory.context = null;
     }
     factory.context = this;
     _sourceFactory = factory;
     _coreLibrarySource = _sourceFactory.forUri(DartSdk.DART_CORE);
+    _asyncLibrarySource = _sourceFactory.forUri(DartSdk.DART_ASYNC);
     _cache = createCacheFromSourceFactory(factory);
     _invalidateAllLocalResolutionInformation(true);
   }
 
   /**
    * Return a list of the sources that would be processed by [performAnalysisTask]. This
    * method duplicates, and must therefore be kept in sync with, [getNextAnalysisTask].
    * This method is intended to be used for testing purposes only.
    *
    * @return a list of the sources that would be processed by [performAnalysisTask]
@@ skipping 54 matching lines @@
   @override
   TypeProvider get typeProvider {
     Source coreSource = sourceFactory.forUri(DartSdk.DART_CORE);
     if (coreSource == null) {
       throw new AnalysisException("Could not create a source for dart:core");
     }
     LibraryElement coreElement = computeLibraryElement(coreSource);
     if (coreElement == null) {
       throw new AnalysisException("Could not create an element for dart:core");
     }
-    return new TypeProviderImpl(coreElement);
+    Source asyncSource = sourceFactory.forUri(DartSdk.DART_ASYNC);
+    if (asyncSource == null) {
+      throw new AnalysisException("Could not create a source for dart:async");
+    }
+    LibraryElement asyncElement = computeLibraryElement(asyncSource);
+    if (asyncElement == null) {
+      throw new AnalysisException("Could not create an element for dart:async");
+    }
+    return new TypeProviderImpl(coreElement, asyncElement);
   }
 
   @override
   void addListener(AnalysisListener listener) {
     if (!_listeners.contains(listener)) {
       _listeners.add(listener);
     }
   }
 
   @override
@@ skipping 3859 matching lines @@
     if (_taskData != null) {
       // At least one part needs to be parsed.
       return;
     }
     // All of the AST's necessary to perform a resolution of the library cycle
     // have been gathered, so it is no longer necessary to retain them in the
     // cache.
     AnalysisContextImpl_this._neededForResolution = null;
   }
 
+  bool _addDependency(ResolvableLibrary dependant, Source dependency,
+      List<ResolvableLibrary> dependencyList) {
+    if (dependant.librarySource == dependency) {
+      // Don't add a dependency of a library on itself; there's no point.
+      return true;
+    }
+    ResolvableLibrary importedLibrary = _libraryMap[dependency];
+    if (importedLibrary == null) {
+      importedLibrary = _createLibraryOrNull(dependency);
+      if (importedLibrary != null) {
+        _computeLibraryDependencies(importedLibrary);
+        if (_taskData != null) {
+          return false;
+        }
+      }
+    }
+    if (importedLibrary != null) {
+      if (dependencyList != null) {
+        dependencyList.add(importedLibrary);
+      }
+      _dependencyGraph.addEdge(dependant, importedLibrary);
+    }
+    return true;
+  }
+
   /**
    * Recursively traverse the libraries reachable from the given library, creating instances of
    * the class [Library] to represent them, and record the references in the library
    * objects.
    *
    * @param library the library to be processed to find libraries that have not yet been traversed
    * @throws AnalysisException if some portion of the library graph could not be traversed
    */
   void _computeLibraryDependencies(ResolvableLibrary library) {
     Source librarySource = library.librarySource;
@@ skipping 22 matching lines @@
    *
    * @param library the library to be processed to find libraries that have not yet been traversed
    * @param importedSources an array containing the sources that are imported into the given
    *          library
    * @param exportedSources an array containing the sources that are exported from the given
    *          library
    */
   void _computeLibraryDependenciesFromDirectives(ResolvableLibrary library,
       List<Source> importedSources, List<Source> exportedSources) {
     int importCount = importedSources.length;
-    if (importCount > 0) {
-      List<ResolvableLibrary> importedLibraries = new List<ResolvableLibrary>();
-      bool explicitlyImportsCore = false;
-      for (int i = 0; i < importCount; i++) {
-        Source importedSource = importedSources[i];
-        if (importedSource == AnalysisContextImpl_this._coreLibrarySource) {
-          explicitlyImportsCore = true;
-        }
-        ResolvableLibrary importedLibrary = _libraryMap[importedSource];
-        if (importedLibrary == null) {
-          importedLibrary = _createLibraryOrNull(importedSource);
-          if (importedLibrary != null) {
-            _computeLibraryDependencies(importedLibrary);
-            if (_taskData != null) {
-              return;
-            }
-          }
-        }
-        if (importedLibrary != null) {
-          importedLibraries.add(importedLibrary);
-          _dependencyGraph.addEdge(library, importedLibrary);
-        }
+    List<ResolvableLibrary> importedLibraries = new List<ResolvableLibrary>();
+    bool explicitlyImportsCore = false;
+    bool importsAsync = false;
+    for (int i = 0; i < importCount; i++) {
+      Source importedSource = importedSources[i];
+      if (importedSource == AnalysisContextImpl_this._coreLibrarySource) {
+        explicitlyImportsCore = true;
+      } else if (importedSource ==
+          AnalysisContextImpl_this._asyncLibrarySource) {
+        importsAsync = true;
       }
-      library.explicitlyImportsCore = explicitlyImportsCore;
-      if (!explicitlyImportsCore &&
-          AnalysisContextImpl_this._coreLibrarySource != library.librarySource) {
-        ResolvableLibrary importedLibrary =
-            _libraryMap[AnalysisContextImpl_this._coreLibrarySource];
-        if (importedLibrary == null) {
-          importedLibrary =
-              _createLibraryOrNull(AnalysisContextImpl_this._coreLibrarySource);
-          if (importedLibrary != null) {
-            _computeLibraryDependencies(importedLibrary);
-            if (_taskData != null) {
-              return;
-            }
-          }
-        }
-        if (importedLibrary != null) {
-          importedLibraries.add(importedLibrary);
-          _dependencyGraph.addEdge(library, importedLibrary);
-        }
-      }
-      library.importedLibraries = importedLibraries;
-    } else {
-      library.explicitlyImportsCore = false;
-      ResolvableLibrary importedLibrary =
-          _libraryMap[AnalysisContextImpl_this._coreLibrarySource];
-      if (importedLibrary == null) {
-        importedLibrary =
-            _createLibraryOrNull(AnalysisContextImpl_this._coreLibrarySource);
-        if (importedLibrary != null) {
-          _computeLibraryDependencies(importedLibrary);
-          if (_taskData != null) {
-            return;
-          }
-        }
-      }
-      if (importedLibrary != null) {
-        _dependencyGraph.addEdge(library, importedLibrary);
-        library.importedLibraries = <ResolvableLibrary>[importedLibrary];
+      if (!_addDependency(library, importedSource, importedLibraries)) {
+        return;
       }
     }
+    library.explicitlyImportsCore = explicitlyImportsCore;
+    if (!explicitlyImportsCore) {
+      if (!_addDependency(
+          library,
+          AnalysisContextImpl_this._coreLibrarySource,
+          importedLibraries)) {
+        return;
+      }
+    }
+    if (!importsAsync) {
+      // Add a dependency on async to ensure that the Future element will be
+      // built before we generate errors and warnings for async methods.  Also
+      // include it in importedLibraries, so that it will be picked up by
+      // LibraryResolver2._buildLibraryMap().
+      // TODO(paulberry): this is a bit of a hack, since the async library
+      // isn't actually being imported.

[Brian Wilkerson, 2015/02/02 19:41:48]

I don't think this is (or should be) necessary under the current implementation
because core indirectly imports async (via convert), so if the core element
model has been built then the async element model will have also been built.

[Paul Berry, 2015/02/02 20:55:38]

Hmm, your reasoning seems valid.  However, if I remove this code I get a lot of
unit test failures.  Perhaps in the various mock SDK's we use for unit testing,
core doesn't indirectly import async.

Even if we can figure out a way to remove this code and fix the unit test
failures, I'm not sure it would be a net win, since then we would be in a
situation where analyzer's correctness depends on an the existence of an
implicit import relationship in the SDK.  I'd rather avoid that if possible,
since it's conceivable (though not particularly likely) that a future version of
the SDK won't have this implicit import relationship, causing subtle breakages.

If I'm not mistaken this code is going to go away when we move to the new task
model, and I'm hoping that when we do that we'll be able to represent the
dependency on async in a less hacky way.  So for now I think I will land the
code as is.  But I've updated the TODO comment to capture this discussion.  If
you feel strongly that this is a bad way to go, I'll be happy to discuss it
tomorrow.

+      if (!_addDependency(
+          library,
+          AnalysisContextImpl_this._asyncLibrarySource,
+          importedLibraries)) {
+        return;
+      }
+    }
+    library.importedLibraries = importedLibraries;
     int exportCount = exportedSources.length;
     if (exportCount > 0) {
       List<ResolvableLibrary> exportedLibraries = new List<ResolvableLibrary>();
       for (int i = 0; i < exportCount; i++) {
         Source exportedSource = exportedSources[i];
-        ResolvableLibrary exportedLibrary = _libraryMap[exportedSource];
-        if (exportedLibrary == null) {
-          exportedLibrary = _createLibraryOrNull(exportedSource);
-          if (exportedLibrary != null) {
-            _computeLibraryDependencies(exportedLibrary);
-            if (_taskData != null) {
-              return;
-            }
-          }
-        }
-        if (exportedLibrary != null) {
-          exportedLibraries.add(exportedLibrary);
-          _dependencyGraph.addEdge(library, exportedLibrary);
+        if (!_addDependency(library, exportedSource, exportedLibraries)) {
+          return;
         }
       }
       library.exportedLibraries = exportedLibraries;
     }
   }
 
   /**
    * Gather the resolvable AST structures for each of the compilation units in each of the
    * libraries in the cycle. This is done in two phases: first we ensure that we have cached an
    * AST structure for each compilation unit, then we gather them. We split the work this way
@@ skipping 6821 matching lines @@
     if (element.id == _id) {
       result = element;
       throw new _ElementByIdFinderException();
     }
     super.visitElement(element);
   }
 }
 
 class _ElementByIdFinderException {
 }