Revert "Use single InputPackagesResultProvider, without SdkSummaryResultProvider."

pkg/analyzer/lib/src/summary/resynthesize.dart

 // Copyright (c) 2015, 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 summary_resynthesizer;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/handle.dart';
 import 'package:analyzer/src/dart/element/member.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/testing/ast_test_factory.dart';
 import 'package:analyzer/src/generated/testing/token_factory.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
-import 'package:analyzer/src/summary/summary_sdk.dart';
 
 /**
  * Implementation of [ElementResynthesizer] used when resynthesizing an element
  * model from summaries.
  */
 abstract class SummaryResynthesizer extends ElementResynthesizer {
   /**
+   * The parent [SummaryResynthesizer] which is asked to resynthesize elements
+   * and get summaries before this resynthesizer attempts to do this.
+   * Can be `null`.
+   */
+  final SummaryResynthesizer parent;
+
+  /**
    * Source factory used to convert URIs to [Source] objects.
    */
   final SourceFactory sourceFactory;
 
   /**
    * Cache of [Source] objects that have already been converted from URIs.
    */
   final Map<String, Source> _sources = <String, Source>{};
 
   /**
-   * The [TypeProvider] used to obtain SDK types during resynthesis.
+   * The [TypeProvider] used to obtain core types (such as Object, int, List,
+   * and dynamic) during resynthesis.
    */
-  TypeProvider _typeProvider;
+  final TypeProvider typeProvider;
 
   /**
    * Indicates whether the summary should be resynthesized assuming strong mode
    * semantics.
    */
   final bool strongMode;
 
   /**
    * Map of compilation units resynthesized from summaries.  The two map keys
    * are the first two elements of the element's location (the library URI and
@@ skipping 10 matching lines @@
   final Map<String, Map<String, Map<String, Element>>> _resynthesizedElements =
       <String, Map<String, Map<String, Element>>>{};
 
   /**
    * Map of libraries which have been resynthesized from summaries.  The map
    * key is the library URI.
    */
   final Map<String, LibraryElement> _resynthesizedLibraries =
       <String, LibraryElement>{};
 
-  SummaryResynthesizer(
-      AnalysisContext context, this.sourceFactory, this.strongMode)
-      : super(context) {
-    _buildTypeProvider();
-  }
+  SummaryResynthesizer(this.parent, AnalysisContext context, this.typeProvider,
+      this.sourceFactory, this.strongMode)
+      : super(context);
 
   /**
    * Number of libraries that have been resynthesized so far.
    */
   int get resynthesisCount => _resynthesizedLibraries.length;
 
   /**
-   * The [TypeProvider] used to obtain SDK types during resynthesis.
+   * Perform delayed finalization of the `dart:core` and `dart:async` libraries.
    */
-  TypeProvider get typeProvider => _typeProvider;
+  void finalizeCoreAsyncLibraries() {
+    (_resynthesizedLibraries['dart:core'] as LibraryElementImpl)
+        .createLoadLibraryFunction(typeProvider);
+    (_resynthesizedLibraries['dart:async'] as LibraryElementImpl)
+        .createLoadLibraryFunction(typeProvider);
+  }
 
   @override
   Element getElement(ElementLocation location) {
     List<String> components = location.components;
     String libraryUri = components[0];
+    // Ask the parent resynthesizer.
+    if (parent != null && parent._hasLibrarySummary(libraryUri)) {
+      return parent.getElement(location);
+    }
     // Resynthesize locally.
     if (components.length == 1) {
       return getLibraryElement(libraryUri);
     } else if (components.length == 2) {
       Map<String, CompilationUnitElement> libraryMap =
           _resynthesizedUnits[libraryUri];
       if (libraryMap == null) {
         getLibraryElement(libraryUri);
         libraryMap = _resynthesizedUnits[libraryUri];
         assert(libraryMap != null);
@@ skipping 76 matching lines @@
     } else {
       throw new UnimplementedError(location.toString());
     }
   }
 
   /**
    * Get the [LibraryElement] for the given [uri], resynthesizing it if it
    * hasn't been resynthesized already.
    */
   LibraryElement getLibraryElement(String uri) {
+    if (parent != null && parent._hasLibrarySummary(uri)) {
+      return parent.getLibraryElement(uri);
+    }
     return _resynthesizedLibraries.putIfAbsent(uri, () {
-      LinkedLibrary serializedLibrary = getLinkedSummary(uri);
+      LinkedLibrary serializedLibrary = _getLinkedSummaryOrNull(uri);
       Source librarySource = _getSource(uri);
       if (serializedLibrary == null) {
         LibraryElementImpl libraryElement =
             new LibraryElementImpl(context, '', -1, 0);
         libraryElement.isSynthetic = true;
         CompilationUnitElementImpl unitElement =
             new CompilationUnitElementImpl(librarySource.shortName);
         libraryElement.definingCompilationUnit = unitElement;
         unitElement.source = librarySource;
         unitElement.librarySource = librarySource;
         libraryElement.createLoadLibraryFunction(typeProvider);
         libraryElement.publicNamespace = new Namespace({});
         libraryElement.exportNamespace = new Namespace({});
         return libraryElement;
       }
-      UnlinkedUnit unlinkedSummary = getUnlinkedSummary(uri);
+      UnlinkedUnit unlinkedSummary = _getUnlinkedSummaryOrNull(uri);
       if (unlinkedSummary == null) {
         throw new StateError('Unable to find unlinked summary: $uri');
       }
       List<UnlinkedUnit> serializedUnits = <UnlinkedUnit>[unlinkedSummary];
       for (String part in serializedUnits[0].publicNamespace.parts) {
         Source partSource = sourceFactory.resolveUri(librarySource, part);
         if (partSource == null) {
           serializedUnits.add(null);
         } else {
           String partAbsUri = partSource.uri.toString();
-          serializedUnits.add(getUnlinkedSummary(partAbsUri) ??
+          serializedUnits.add(_getUnlinkedSummaryOrNull(partAbsUri) ??
               new UnlinkedUnitBuilder(codeRange: new CodeRangeBuilder()));
         }
       }
       _LibraryResynthesizer libraryResynthesizer = new _LibraryResynthesizer(
           this, serializedLibrary, serializedUnits, librarySource);
       LibraryElement library = libraryResynthesizer.buildLibrary();
       _resynthesizedUnits[uri] = libraryResynthesizer.resynthesizedUnits;
       return library;
     });
   }
@@ skipping 12 matching lines @@
    */
   UnlinkedUnit getUnlinkedSummary(String uri);
 
   /**
    * Return `true` if this resynthesizer can provide summaries of the libraries
    * with the given [uri].  Caller has already checked that
    * `parent.hasLibrarySummary(uri)` returns `false`.
    */
   bool hasLibrarySummary(String uri);
 
-  void _buildTypeProvider() {
-    var coreLibrary = getLibraryElement('dart:core') as LibraryElementImpl;
-    var asyncLibrary = getLibraryElement('dart:async') as LibraryElementImpl;
-    SummaryTypeProvider summaryTypeProvider = new SummaryTypeProvider();
-    summaryTypeProvider.initializeCore(coreLibrary);
-    summaryTypeProvider.initializeAsync(asyncLibrary);
-    coreLibrary.createLoadLibraryFunction(summaryTypeProvider);
-    asyncLibrary.createLoadLibraryFunction(summaryTypeProvider);
-    _typeProvider = summaryTypeProvider;
+  /**
+   * Return the [LinkedLibrary] for the given [uri] or return `null` if it
+   * could not be found.
+   */
+  LinkedLibrary _getLinkedSummaryOrNull(String uri) {
+    if (parent != null && parent._hasLibrarySummary(uri)) {
+      return parent._getLinkedSummaryOrNull(uri);
+    }
+    return getLinkedSummary(uri);
   }
 
   /**
    * Get the [Source] object for the given [uri].
    */
   Source _getSource(String uri) {
     return _sources.putIfAbsent(uri, () => sourceFactory.forUri(uri));
   }
+
+  /**
+   * Return the [UnlinkedUnit] for the given [uri] or return `null` if it
+   * could not be found.
+   */
+  UnlinkedUnit _getUnlinkedSummaryOrNull(String uri) {
+    if (parent != null && parent._hasLibrarySummary(uri)) {
+      return parent._getUnlinkedSummaryOrNull(uri);
+    }
+    return getUnlinkedSummary(uri);
+  }
+
+  /**
+   * Return `true` if this resynthesizer can provide summaries of the libraries
+   * with the given [uri].
+   */
+  bool _hasLibrarySummary(String uri) {
+    if (parent != null && parent._hasLibrarySummary(uri)) {
+      return true;
+    }
+    return hasLibrarySummary(uri);
+  }
 }
 
 /**
  * Builder of [Expression]s from [UnlinkedExpr]s.
  */
 class _ConstExprBuilder {
   static const ARGUMENT_LIST = 'ARGUMENT_LIST';
 
   final _UnitResynthesizer resynthesizer;
   final ElementImpl context;
@@ skipping 1590 matching lines @@
   static String _getElementIdentifier(String name, ReferenceKind kind) {
     if (kind == ReferenceKind.topLevelPropertyAccessor ||
         kind == ReferenceKind.propertyAccessor) {
       if (!name.endsWith('=')) {
         return name + '?';
       }
     }
     return name;
   }
 }