Use single InputPackagesResultProvider, without SdkSummaryResultProvider.

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

 import 'dart:io' as io;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/context/context.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
-import 'package:analyzer/src/generated/resolver.dart';
+import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/resynthesize.dart';
 import 'package:analyzer/src/task/dart.dart';
 import 'package:analyzer/src/util/fast_uri.dart';
 import 'package:analyzer/task/dart.dart';
 import 'package:analyzer/task/general.dart';
 import 'package:analyzer/task/model.dart';
 import 'package:front_end/src/base/source.dart';
 
 /**
  * The [ResultProvider] that provides results from input package summaries.
  */
 class InputPackagesResultProvider extends ResynthesizerResultProvider {
   InputPackagesResultProvider(
       InternalAnalysisContext context, SummaryDataStore dataStore)
       : super(context, dataStore) {
-    AnalysisContext sdkContext = context.sourceFactory.dartSdk.context;
-    createResynthesizer(sdkContext, sdkContext.typeProvider);
+    createResynthesizer();
   }
 
   @override
   bool hasResultsForSource(Source source) {
     String uriString = source.uri.toString();
     return resynthesizer.hasLibrarySummary(uriString);
   }
 }
 
 /**
@@ skipping 72 matching lines @@
 }
 
 /**
  * The [ResultProvider] that provides results using summary resynthesizer.
  */
 abstract class ResynthesizerResultProvider extends ResultProvider {
   final InternalAnalysisContext context;
   final SummaryDataStore _dataStore;
 
   _FileBasedSummaryResynthesizer _resynthesizer;
-  ResynthesizerResultProvider _sdkProvider;
 
   ResynthesizerResultProvider(this.context, this._dataStore);
 
   SummaryResynthesizer get resynthesizer => _resynthesizer;
 
   /**
    * Add a new [bundle] to the resynthesizer.
    */
   void addBundle(String path, PackageBundle bundle) {
     _dataStore.addBundle(path, bundle);
   }
 
   @override
   bool compute(CacheEntry entry, ResultDescriptor result) {
-    if (_sdkProvider != null && _sdkProvider.compute(entry, result)) {
+    AnalysisTarget target = entry.target;
+
+    if (result == TYPE_PROVIDER) {
+      entry.setValue(result as ResultDescriptor<TypeProvider>,
+          _resynthesizer.typeProvider, TargetedResult.EMPTY_LIST);
       return true;
     }
-    AnalysisTarget target = entry.target;
 
     // LINE_INFO can be provided using just the UnlinkedUnit.
     if (target is Source && result == LINE_INFO) {
       String uriString = target.uri.toString();
       UnlinkedUnit unlinkedUnit = _dataStore.unlinkedMap[uriString];
       if (unlinkedUnit != null) {
         List<int> lineStarts = unlinkedUnit.lineStarts;
         if (lineStarts.isNotEmpty) {
           LineInfo lineInfo = new LineInfo(lineStarts);
           entry.setValue(result as ResultDescriptor<LineInfo>, lineInfo,
@@ skipping 104 matching lines @@
     }
     // Unknown target.
     return false;
   }
 
   /**
    * Create the [resynthesizer] instance.
    *
    * Subclasses must call this method in their constructors.
    */
-  void createResynthesizer(
-      InternalAnalysisContext sdkContext, TypeProvider typeProvider) {
-    // Set the type provider to prevent the context from computing it.
-    context.typeProvider = typeProvider;
-    // Create a chained resynthesizer.
-    _sdkProvider = sdkContext?.resultProvider;
-    _resynthesizer = new _FileBasedSummaryResynthesizer(
-        _sdkProvider?.resynthesizer,
-        context,
-        typeProvider,
-        context.sourceFactory,
-        context.analysisOptions.strongMode,
-        _dataStore);
+  void createResynthesizer() {
+    _resynthesizer = new _FileBasedSummaryResynthesizer(context,
+        context.sourceFactory, context.analysisOptions.strongMode, _dataStore);
   }
 
   /**
    * Return `true` if this result provider can provide a result for the
    * given [source].  The provider must ensure that [addBundle] is invoked for
    * every bundle that would be required to provide results for the [source].
    */
   bool hasResultsForSource(Source source);
 }
 
@@ skipping 131 matching lines @@
     addBundle(path, bundle);
   }
 }
 
 /**
  * A concrete resynthesizer that serves summaries from given file paths.
  */
 class _FileBasedSummaryResynthesizer extends SummaryResynthesizer {
   final SummaryDataStore _dataStore;
 
-  _FileBasedSummaryResynthesizer(
-      SummaryResynthesizer parent,
-      AnalysisContext context,
-      TypeProvider typeProvider,
-      SourceFactory sourceFactory,
-      bool strongMode,
-      this._dataStore)
-      : super(parent, context, typeProvider, sourceFactory, strongMode);
+  _FileBasedSummaryResynthesizer(AnalysisContext context,
+      SourceFactory sourceFactory, bool strongMode, this._dataStore)
+      : super(null, context, sourceFactory, strongMode);

[Paul Berry, 2017/01/23 22:36:45]

It looks like there are no remaining code paths that pass a non-null parent to
the superclass constructor.  Can we get rid of this constructor parameter now
(and the associated logic inside the superclass)?

(Ok with me if you want to postpone this to a follow-up CL)

[scheglov, 2017/01/23 22:44:49]

Yes, I want to clean this up in the following CL.

 
   @override
   LinkedLibrary getLinkedSummary(String uri) {
     return _dataStore.linkedMap[uri];
   }
 
   @override
   UnlinkedUnit getUnlinkedSummary(String uri) {
     return _dataStore.unlinkedMap[uri];
   }
 
   @override
   bool hasLibrarySummary(String uri) {
     LinkedLibrary linkedLibrary = _dataStore.linkedMap[uri];
     return linkedLibrary != null;
   }
 }