Fix async/await type checking in analyzer.

pkg/analyzer/lib/src/generated/resolver.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;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/utilities_collection.dart';
@@ skipping 43 matching lines @@
    * a class.
    */
   ClassElement _enclosingClass;
 
   /**
    * The error reporter by which errors will be reported.
    */
   final ErrorReporter _errorReporter;
 
   /**
+   * The type Future<Null>, which is needed for determining whether it is safe
+   * to have a bare "return;" in an async method.
+   */
+  final InterfaceType _futureNullType;
+
+  /**
    * Create a new instance of the [BestPracticesVerifier].
    *
    * @param errorReporter the error reporter
    */
-  BestPracticesVerifier(this._errorReporter);
+  BestPracticesVerifier(this._errorReporter, TypeProvider typeProvider)
+      : _futureNullType = typeProvider.futureType.substitute4(

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

Should we make Future<Null> directly accessible through the typeProvider so that
it doesn't need to be re-created as often?

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

That's a good idea.  I need to do more work in this area to fix async* and
sync*, so I'll fold that into my next CL.

+          <DartType>[typeProvider.nullType]);
 
   @override
   Object visitArgumentList(ArgumentList node) {
     _checkForArgumentTypesNotAssignableInList(node);
     return super.visitArgumentList(node);
   }
 
   @override
   Object visitAsExpression(AsExpression node) {
     _checkForUnnecessaryCast(node);
@@ skipping 472 matching lines @@
       return true;
     }
     return false;
   }
 
   /**
    * Generate a hint for functions or methods that have a return type, but do not have a return
    * statement on all branches. At the end of blocks with no return, Dart implicitly returns
    * `null`, avoiding these implicit returns is considered a best practice.
    *
+   * Note: for async functions/methods, this hint only applies when the
+   * function has a return type that Future<Null> is not assignable to.
+   *
    * @param node the binary expression to check
    * @param body the function body
    * @return `true` if and only if a hint code is generated on the passed node
    * See [HintCode.MISSING_RETURN].
    */
   bool _checkForMissingReturn(TypeName returnType, FunctionBody body) {
     // Check that the method or function has a return type, and a function body
     if (returnType == null || body == null) {
       return false;
     }
     // Check that the body is a BlockFunctionBody
     if (body is! BlockFunctionBody) {
       return false;
     }
     // Check that the type is resolvable, and is not "void"
     DartType returnTypeType = returnType.type;
     if (returnTypeType == null || returnTypeType.isVoid) {
       return false;
     }
+    // For async, give no hint if Future<Null> is assignable to the return
+    // type.
+    if (body.isAsynchronous && _futureNullType.isAssignableTo(returnTypeType)) {
+      return false;
+    }
     // Check the block for a return statement, if not, create the hint
     BlockFunctionBody blockFunctionBody = body as BlockFunctionBody;
     if (!blockFunctionBody.accept(new ExitDetector())) {
       _errorReporter.reportErrorForNode(
           HintCode.MISSING_RETURN,
           returnType,
           [returnTypeType.displayName]);
       return true;
     }
     return false;
@@ skipping 3796 matching lines @@
 
 /**
  * Instances of the class `HintGenerator` traverse a library's worth of dart code at a time to
  * generate hints over the set of sources.
  *
  * See [HintCode].
  */
 class HintGenerator {
   final List<CompilationUnit> _compilationUnits;
 
-  final AnalysisContext _context;
+  final InternalAnalysisContext _context;
 
   final AnalysisErrorListener _errorListener;
 
   LibraryElement _library;
 
   ImportsVerifier _importsVerifier;
 
   bool _enableDart2JSHints = false;
 
   /**
@@ skipping 44 matching lines @@
     ErrorReporter errorReporter = new ErrorReporter(_errorListener, source);
     unit.accept(_importsVerifier);
     // dead code analysis
     unit.accept(new DeadCodeVerifier(errorReporter));
     unit.accept(_usedElementsVisitor);
     // dart2js analysis
     if (_enableDart2JSHints) {
       unit.accept(new Dart2JSVerifier(errorReporter));
     }
     // Dart best practices
-    unit.accept(new BestPracticesVerifier(errorReporter));
+    unit.accept(
+        new BestPracticesVerifier(errorReporter, _context.typeProvider));
     unit.accept(new OverrideVerifier(_manager, errorReporter));
     // Find to-do comments
     new ToDoFinder(errorReporter).findIn(unit);
     // pub analysis
     // TODO(danrubel/jwren) Commented out until bugs in the pub verifier are
     // fixed
     //    unit.accept(new PubVerifier(context, errorReporter));
   }
 }
 
@@ skipping 3211 matching lines @@
    * [AnalysisErrorListener] with the [recordingErrorListener].
    */
   RecordingErrorListener _errorListener;
 
   /**
    * A source object representing the core library (dart:core).
    */
   Source _coreLibrarySource;
 
   /**
+   * A Source object representing the async library (dart:async).
+   */
+  Source _asyncLibrarySource;
+
+  /**
    * The object representing the core library.
    */
   Library _coreLibrary;
 
   /**
+   * The object representing the async library.
+   */
+  Library _asyncLibrary;
+
+  /**
    * The object used to access the types from the core library.
    */
   TypeProvider _typeProvider;
 
   /**
    * A table mapping library sources to the information being maintained for those libraries.
    */
   HashMap<Source, Library> _libraryMap = new HashMap<Source, Library>();
 
   /**
    * A collection containing the libraries that are being resolved together.
    */
   Set<Library> _librariesInCycles;
 
   /**
    * Initialize a newly created library resolver to resolve libraries within the given context.
    *
    * @param analysisContext the analysis context in which the library is being analyzed
    */
   LibraryResolver(this.analysisContext) {
     this._errorListener = new RecordingErrorListener();
     _coreLibrarySource =
         analysisContext.sourceFactory.forUri(DartSdk.DART_CORE);
+    _asyncLibrarySource =
+        analysisContext.sourceFactory.forUri(DartSdk.DART_ASYNC);
   }
 
   /**
    * Return the listener to which analysis errors will be reported.
    *
    * @return the listener to which analysis errors will be reported
    */
   RecordingErrorListener get errorListener => _errorListener;
 
   /**
@@ skipping 31 matching lines @@
    */
   LibraryElement resolveEmbeddedLibrary(Source librarySource,
       CompilationUnit unit, bool fullAnalysis) {
     //
     // Create the objects representing the library being resolved and the core
     // library.
     //
     Library targetLibrary = _createLibraryWithUnit(librarySource, unit);
     _coreLibrary = _libraryMap[_coreLibrarySource];
     if (_coreLibrary == null) {
-      // This will be true unless the library being analyzed is the core
+      // This will only happen if the library being analyzed is the core
       // library.
       _coreLibrary = createLibrary(_coreLibrarySource);
       if (_coreLibrary == null) {
         LibraryResolver2.missingCoreLibrary(
             analysisContext,
             _coreLibrarySource);
       }
     }
+    _asyncLibrary = _libraryMap[_asyncLibrarySource];
+    if (_asyncLibrary == null) {
+      // This will only happen if the library being analyzed is the async
+      // library.
+      _asyncLibrary = createLibrary(_asyncLibrarySource);
+      if (_asyncLibrary == null) {
+        LibraryResolver2.missingAsyncLibrary(
+            analysisContext,
+            _asyncLibrarySource);
+      }
+    }
     //
     // Compute the set of libraries that need to be resolved together.
     //
     _computeEmbeddedLibraryDependencies(targetLibrary, unit);
     _librariesInCycles = _computeLibrariesInCycles(targetLibrary);
     //
     // Build the element models representing the libraries being resolved.
     // This is done in three steps:
     //
     // 1. Build the basic element models without making any connections
     //    between elements other than the basic parent/child relationships.
     //    This includes building the elements representing the libraries.
     // 2. Build the elements for the import and export directives. This
     //    requires that we have the elements built for the referenced
     //    libraries, but because of the possibility of circular references
     //    needs to happen after all of the library elements have been created.
     // 3. Build the rest of the type model by connecting superclasses, mixins,
     //    and interfaces. This requires that we be able to compute the names
     //    visible in the libraries being resolved, which in turn requires that
     //    we have resolved the import directives.
     //
     _buildElementModels();
     LibraryElement coreElement = _coreLibrary.libraryElement;
     if (coreElement == null) {
       throw new AnalysisException("Could not resolve dart:core");
     }
+    LibraryElement asyncElement = _asyncLibrary.libraryElement;
+    if (asyncElement == null) {
+      throw new AnalysisException("Could not resolve dart:async");
+    }
     _buildDirectiveModels();
-    _typeProvider = new TypeProviderImpl(coreElement);
+    _typeProvider = new TypeProviderImpl(coreElement, asyncElement);
     _buildTypeAliases();
     _buildTypeHierarchies();
     //
     // Perform resolution and type analysis.
     //
     // TODO(brianwilkerson) Decide whether we want to resolve all of the
     // libraries or whether we want to only resolve the target library.
     // The advantage to resolving everything is that we have already done part
     // of the work so we'll avoid duplicated effort. The disadvantage of
     // resolving everything is that we might do extra work that we don't
@@ skipping 23 matching lines @@
    * @throws AnalysisException if the library could not be resolved for some reason
    */
   LibraryElement resolveLibrary(Source librarySource, bool fullAnalysis) {
     //
     // Create the objects representing the library being resolved and the core
     // library.
     //
     Library targetLibrary = createLibrary(librarySource);
     _coreLibrary = _libraryMap[_coreLibrarySource];
     if (_coreLibrary == null) {
-      // This will be true unless the library being analyzed is the core
+      // This should only happen if the library being analyzed is the core
       // library.
       _coreLibrary = _createLibraryOrNull(_coreLibrarySource);
       if (_coreLibrary == null) {
         LibraryResolver2.missingCoreLibrary(
             analysisContext,
             _coreLibrarySource);
       }
     }
+    _asyncLibrary = _libraryMap[_asyncLibrarySource];
+    if (_asyncLibrary == null) {
+      // This should only happen if the library being analyzed is the async
+      // library.
+      _asyncLibrary = _createLibraryOrNull(_asyncLibrarySource);
+      if (_asyncLibrary == null) {
+        LibraryResolver2.missingAsyncLibrary(
+            analysisContext,
+            _asyncLibrarySource);
+      }
+    }
     //
     // Compute the set of libraries that need to be resolved together.
     //
     _computeLibraryDependencies(targetLibrary);
     _librariesInCycles = _computeLibrariesInCycles(targetLibrary);
     //
     // Build the element models representing the libraries being resolved.
     // This is done in three steps:
     //
     // 1. Build the basic element models without making any connections
     //    between elements other than the basic parent/child relationships.
     //    This includes building the elements representing the libraries, but
     //    excludes members defined in enums.
     // 2. Build the elements for the import and export directives. This
     //    requires that we have the elements built for the referenced
     //    libraries, but because of the possibility of circular references
     //    needs to happen after all of the library elements have been created.
     // 3. Build the members in enum declarations.
     // 4. Build the rest of the type model by connecting superclasses, mixins,
     //    and interfaces. This requires that we be able to compute the names
     //    visible in the libraries being resolved, which in turn requires that
     //    we have resolved the import directives.
     //
     _buildElementModels();
     LibraryElement coreElement = _coreLibrary.libraryElement;
     if (coreElement == null) {
       throw new AnalysisException("Could not resolve dart:core");
     }
+    LibraryElement asyncElement = _asyncLibrary.libraryElement;
+    if (asyncElement == null) {
+      throw new AnalysisException("Coulb not resolve dart:async");
+    }
     _buildDirectiveModels();
-    _typeProvider = new TypeProviderImpl(coreElement);
+    _typeProvider = new TypeProviderImpl(coreElement, asyncElement);
     _buildEnumMembers();
     _buildTypeAliases();
     _buildTypeHierarchies();
     _buildImplicitConstructors();
     //
     // Perform resolution and type analysis.
     //
     // TODO(brianwilkerson) Decide whether we want to resolve all of the
     // libraries or whether we want to only resolve the target library. The
     // advantage to resolving everything is that we have already done part of
@@ skipping 58 matching lines @@
    * to the given dependency map.
    *
    * @param library the library currently being added to the dependency map
    * @param dependencyMap the dependency map being computed
    * @param visitedLibraries the libraries that have already been visited, used to prevent infinite
    *          recursion
    */
   void _addToDependencyMap(Library library, HashMap<Library,
       List<Library>> dependencyMap, Set<Library> visitedLibraries) {
     if (visitedLibraries.add(library)) {
+      bool asyncFound = false;
       for (Library referencedLibrary in library.importsAndExports) {
         _addDependencyToMap(dependencyMap, library, referencedLibrary);
         _addToDependencyMap(referencedLibrary, dependencyMap, visitedLibraries);
+        if (identical(referencedLibrary, _asyncLibrary)) {
+          asyncFound = true;
+        }
       }
       if (!library.explicitlyImportsCore && !identical(library, _coreLibrary)) {
         _addDependencyToMap(dependencyMap, library, _coreLibrary);
       }
+      if (!asyncFound && !identical(library, _asyncLibrary)) {
+        _addDependencyToMap(dependencyMap, library, _asyncLibrary);
+        _addToDependencyMap(_asyncLibrary, dependencyMap, visitedLibraries);
+      }
     }
   }
 
   /**
    * Build the element model representing the combinators declared by the given directive.
    *
    * @param directive the directive that declares the combinators
    * @return an array containing the import combinators that were built
    */
   List<NamespaceCombinator> _buildCombinators(NamespaceDirective directive) {
@@ skipping 346 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
    * @throws AnalysisException if some portion of the library graph could not be traversed
    */
   void _computeLibraryDependenciesFromDirectives(Library library,
       List<Source> importedSources, List<Source> exportedSources) {
     List<Library> importedLibraries = new List<Library>();
     bool explicitlyImportsCore = false;
+    bool importsAsync = false;
     for (Source importedSource in importedSources) {
       if (importedSource == _coreLibrarySource) {
         explicitlyImportsCore = true;
       }
+      if (importedSource == _asyncLibrarySource) {
+        importsAsync = true;
+      }
       Library importedLibrary = _libraryMap[importedSource];
       if (importedLibrary == null) {
         importedLibrary = _createLibraryOrNull(importedSource);
         if (importedLibrary != null) {
           _computeLibraryDependencies(importedLibrary);
         }
       }
       if (importedLibrary != null) {
         importedLibraries.add(importedLibrary);
       }
@@ skipping 16 matching lines @@
     library.explicitlyImportsCore = explicitlyImportsCore;
     if (!explicitlyImportsCore && _coreLibrarySource != library.librarySource) {
       Library importedLibrary = _libraryMap[_coreLibrarySource];
       if (importedLibrary == null) {
         importedLibrary = _createLibraryOrNull(_coreLibrarySource);
         if (importedLibrary != null) {
           _computeLibraryDependencies(importedLibrary);
         }
       }
     }
+    if (!importsAsync && _asyncLibrarySource != library.librarySource) {
+      Library importedLibrary = _libraryMap[_asyncLibrarySource];
+      if (importedLibrary == null) {
+        importedLibrary = _createLibraryOrNull(_asyncLibrarySource);
+        if (importedLibrary != null) {
+          _computeLibraryDependencies(importedLibrary);
+        }
+      }
+    }
   }
 
   /**
    * Create an object to represent the information about the library defined by the compilation unit
    * with the given source. Return the library object that was created, or `null` if the
    * source is not valid.
    *
    * @param librarySource the source of the library's defining compilation unit
    * @return the library object that was created
    */
@@ skipping 161 matching lines @@
    * [AnalysisErrorListener] with the [recordingErrorListener].
    */
   RecordingErrorListener _errorListener;
 
   /**
    * A source object representing the core library (dart:core).
    */
   Source _coreLibrarySource;
 
   /**
+   * A source object representing the async library (dart:async).
+   */
+  Source _asyncLibrarySource;
+
+  /**
    * The object representing the core library.
    */
   ResolvableLibrary _coreLibrary;
 
   /**
+   * The object representing the async library.
+   */
+  ResolvableLibrary _asyncLibrary;
+
+  /**
    * The object used to access the types from the core library.
    */
   TypeProvider _typeProvider;
 
   /**
    * A table mapping library sources to the information being maintained for those libraries.
    */
   HashMap<Source, ResolvableLibrary> _libraryMap =
       new HashMap<Source, ResolvableLibrary>();
 
   /**
    * A collection containing the libraries that are being resolved together.
    */
   List<ResolvableLibrary> _librariesInCycle;
 
   /**
    * Initialize a newly created library resolver to resolve libraries within the given context.
    *
    * @param analysisContext the analysis context in which the library is being analyzed
    */
   LibraryResolver2(this.analysisContext) {
     this._errorListener = new RecordingErrorListener();
     _coreLibrarySource =
         analysisContext.sourceFactory.forUri(DartSdk.DART_CORE);
+    _asyncLibrarySource =
+        analysisContext.sourceFactory.forUri(DartSdk.DART_ASYNC);
   }
 
   /**
    * Return the listener to which analysis errors will be reported.
    *
    * @return the listener to which analysis errors will be reported
    */
   RecordingErrorListener get errorListener => _errorListener;
 
   /**
@@ skipping 18 matching lines @@
    */
   LibraryElement resolveLibrary(Source librarySource,
       List<ResolvableLibrary> librariesInCycle) {
     //
     // Build the map of libraries that are known.
     //
     this._librariesInCycle = librariesInCycle;
     _libraryMap = _buildLibraryMap();
     ResolvableLibrary targetLibrary = _libraryMap[librarySource];
     _coreLibrary = _libraryMap[_coreLibrarySource];
+    _asyncLibrary = _libraryMap[_asyncLibrarySource];
     //
     // Build the element models representing the libraries being resolved.
     // This is done in three steps:
     //
     // 1. Build the basic element models without making any connections
     //    between elements other than the basic parent/child relationships.
     //    This includes building the elements representing the libraries, but
     //    excludes members defined in enums.
     // 2. Build the elements for the import and export directives. This
     //    requires that we have the elements built for the referenced
     //    libraries, but because of the possibility of circular references
     //    needs to happen after all of the library elements have been created.
     // 3. Build the members in enum declarations.
     // 4. Build the rest of the type model by connecting superclasses, mixins,
     //    and interfaces. This requires that we be able to compute the names
     //    visible in the libraries being resolved, which in turn requires that
     //    we have resolved the import directives.
     //
     _buildElementModels();
     LibraryElement coreElement = _coreLibrary.libraryElement;
     if (coreElement == null) {
       missingCoreLibrary(analysisContext, _coreLibrarySource);
     }
+    LibraryElement asyncElement = _asyncLibrary.libraryElement;
+    if (asyncElement == null) {
+      missingAsyncLibrary(analysisContext, _asyncLibrarySource);
+    }
     _buildDirectiveModels();
-    _typeProvider = new TypeProviderImpl(coreElement);
+    _typeProvider = new TypeProviderImpl(coreElement, asyncElement);
     _buildEnumMembers();
     _buildTypeAliases();
     _buildTypeHierarchies();
     _buildImplicitConstructors();
     //
     // Perform resolution and type analysis.
     //
     // TODO(brianwilkerson) Decide whether we want to resolve all of the
     // libraries or whether we want to only resolve the target library. The
     // advantage to resolving everything is that we have already done part of
@@ skipping 396 matching lines @@
         ResolverVisitor visitor =
             new ResolverVisitor.con4(library, source, _typeProvider);
         ast.accept(visitor);
       }
     } finally {
       timeCounter.stop();
     }
   }
 
   /**
+   * Report that the async library could not be resolved in the given
+   * [analysisContext] and throw an exception.  [asyncLibrarySource] is the source
+   * representing the async library.
+   */
+  static void missingAsyncLibrary(AnalysisContext analysisContext,
+      Source asyncLibrarySource) {
+    throw new AnalysisException("Could not resolve dart:async");
+  }
+
+  /**
    * Report that the core library could not be resolved in the given analysis context and throw an
    * exception.
    *
    * @param analysisContext the analysis context in which the failure occurred
    * @param coreLibrarySource the source representing the core library
    * @throws AnalysisException always
    */
   static void missingCoreLibrary(AnalysisContext analysisContext,
       Source coreLibrarySource) {
     throw new AnalysisException("Could not resolve dart:core");
@@ skipping 4212 matching lines @@
   DartType get dynamicType;
 
   /**
    * Return the type representing the built-in type 'Function'.
    *
    * @return the type representing the built-in type 'Function'
    */
   InterfaceType get functionType;
 
   /**
+   * Return the type representing the built-in type 'Future'.
+   */
+  InterfaceType get futureType;
+
+  /**
    * Return the type representing the built-in type 'int'.
    *
    * @return the type representing the built-in type 'int'
    */
   InterfaceType get intType;
 
   /**
    * Return the type representing the built-in type 'List'.
    *
    * @return the type representing the built-in type 'List'
@@ skipping 91 matching lines @@
    * The type representing the built-in type 'dynamic'.
    */
   DartType _dynamicType;
 
   /**
    * The type representing the built-in type 'Function'.
    */
   InterfaceType _functionType;
 
   /**
+   * The type representing the built-in type 'Future'.
+   */
+  InterfaceType _futureType;
+
+  /**
    * The type representing the built-in type 'int'.
    */
   InterfaceType _intType;
 
   /**
    * The type representing the built-in type 'List'.
    */
   InterfaceType _listType;
 
   /**
@@ skipping 39 matching lines @@
   /**
    * The type representing typenames that can't be resolved.
    */
   DartType _undefinedType;
 
   /**
    * Initialize a newly created type provider to provide the types defined in the given library.
    *
    * @param coreLibrary the element representing the core library (dart:core).
    */
-  TypeProviderImpl(LibraryElement coreLibrary) {
-    _initializeFrom(coreLibrary);
+  TypeProviderImpl(LibraryElement coreLibrary, LibraryElement asyncLibrary) {
+    _initializeFrom(coreLibrary, asyncLibrary);
   }
 
   @override
   InterfaceType get boolType => _boolType;
 
   @override
   DartType get bottomType => _bottomType;
 
   @override
   InterfaceType get deprecatedType => _deprecatedType;
 
   @override
   InterfaceType get doubleType => _doubleType;
 
   @override
   DartType get dynamicType => _dynamicType;
 
   @override
   InterfaceType get functionType => _functionType;
 
   @override
+  InterfaceType get futureType => _futureType;
+
+  @override
   InterfaceType get intType => _intType;
 
   @override
   InterfaceType get listType => _listType;
 
   @override
   InterfaceType get mapType => _mapType;
 
   @override
   InterfaceType get nullType => _nullType;
@@ skipping 35 matching lines @@
       return null;
     }
     return (element as ClassElement).type;
   }
 
   /**
    * Initialize the types provided by this type provider from the given library.
    *
    * @param library the library containing the definitions of the core types
    */
-  void _initializeFrom(LibraryElement library) {
-    Namespace namespace =
-        new NamespaceBuilder().createPublicNamespaceForLibrary(library);
-    _boolType = _getType(namespace, "bool");
+  void _initializeFrom(LibraryElement coreLibrary,
+      LibraryElement asyncLibrary) {
+    Namespace coreNamespace =
+        new NamespaceBuilder().createPublicNamespaceForLibrary(coreLibrary);
+    Namespace asyncNamespace =
+        new NamespaceBuilder().createPublicNamespaceForLibrary(asyncLibrary);
+    _boolType = _getType(coreNamespace, "bool");
     _bottomType = BottomTypeImpl.instance;
-    _deprecatedType = _getType(namespace, "Deprecated");
-    _doubleType = _getType(namespace, "double");
+    _deprecatedType = _getType(coreNamespace, "Deprecated");
+    _doubleType = _getType(coreNamespace, "double");
     _dynamicType = DynamicTypeImpl.instance;
-    _functionType = _getType(namespace, "Function");
-    _intType = _getType(namespace, "int");
-    _listType = _getType(namespace, "List");
-    _mapType = _getType(namespace, "Map");
-    _nullType = _getType(namespace, "Null");
-    _numType = _getType(namespace, "num");
-    _objectType = _getType(namespace, "Object");
-    _stackTraceType = _getType(namespace, "StackTrace");
-    _stringType = _getType(namespace, "String");
-    _symbolType = _getType(namespace, "Symbol");
-    _typeType = _getType(namespace, "Type");
+    _functionType = _getType(coreNamespace, "Function");
+    _futureType = _getType(asyncNamespace, "Future");
+    _intType = _getType(coreNamespace, "int");
+    _listType = _getType(coreNamespace, "List");
+    _mapType = _getType(coreNamespace, "Map");
+    _nullType = _getType(coreNamespace, "Null");
+    _numType = _getType(coreNamespace, "num");
+    _objectType = _getType(coreNamespace, "Object");
+    _stackTraceType = _getType(coreNamespace, "StackTrace");
+    _stringType = _getType(coreNamespace, "String");
+    _symbolType = _getType(coreNamespace, "Symbol");
+    _typeType = _getType(coreNamespace, "Type");
     _undefinedType = UndefinedTypeImpl.instance;
   }
 }
 
 /**
  * Instances of the class `TypeResolverVisitor` are used to resolve the types associated with
  * the elements in the element model. This includes the types of superclasses, mixins, interfaces,
  * fields, methods, parameters, and local variables. As a side-effect, this also finishes building
  * the type hierarchy.
  */
@@ skipping 1880 matching lines @@
    * library.
    */
   final HashSet<String> members = new HashSet<String>();
 
   /**
    * Names of resolved or unresolved class members that are read in the
    * library.
    */
   final HashSet<String> readMembers = new HashSet<String>();
 }