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();
+    context.typeProvider = resynthesizer.typeProvider;
   }
 
   @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);
 
   @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;
   }
 }