Use SummarySdkAnalysisContext if the SDK has the analysis_summary file.

pkg/analyzer/lib/src/generated/sdk_io.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 analyzer.src.generated.sdk_io;
 
 import 'dart:io';
 
 import 'package:analyzer/src/context/context.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/java_engine_io.dart';
 import 'package:analyzer/src/generated/java_io.dart';
 import 'package:analyzer/src/generated/parser.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source_io.dart';
+import 'package:analyzer/src/summary/format.dart' show SdkBundle;
+import 'package:analyzer/src/summary/summary_sdk.dart';
+import 'package:path/path.dart' as pathos;
 
 /**
  * A Dart SDK installed in a specified directory. Typical Dart SDK layout is
  * something like...
  *
  *     dart-sdk/
  *        bin/
  *           dart[.exe]  <-- VM
  *        lib/
  *           core/
@@ skipping 203 matching lines @@
    * should be used when it is available
    */
   DirectoryBasedDartSdk(JavaFile sdkDirectory, [bool useDart2jsPaths = false]) {
     this._sdkDirectory = sdkDirectory.getAbsoluteFile();
     _libraryMap = initialLibraryMap(useDart2jsPaths);
   }
 
   @override
   AnalysisContext get context {
     if (_analysisContext == null) {
-      _analysisContext = new SdkAnalysisContext();
+      SdkBundle sdkBundle = _getSummarySdkBundle();
+      if (sdkBundle != null) {
+        _analysisContext = new SummarySdkAnalysisContext(sdkBundle);
+      } else {
+        _analysisContext = new SdkAnalysisContext();
+      }
       SourceFactory factory = new SourceFactory([new DartUriResolver(this)]);
       _analysisContext.sourceFactory = factory;
       List<String> uris = this.uris;
       ChangeSet changeSet = new ChangeSet();
       for (String uri in uris) {
         changeSet.addedSource(factory.forUri(uri));
       }
       _analysisContext.applyChanges(changeSet);
     }
     return _analysisContext;
@@ skipping 271 matching lines @@
         file = file.getParentFile();
         file = new JavaFile.relative(file, relativePath);
       }
       return new FileBasedSource(file, parseUriWithException(dartUri));
     } on URISyntaxException {
       return null;
     }
   }
 
   /**
+   * Return the [SdkBundle] for this SDK, if it exists, or `null` otherwise.
+   */
+  SdkBundle _getSummarySdkBundle() {
+    String rootPath = directory.getAbsolutePath();
+    String path = pathos.join(rootPath, 'lib', '_internal', 'analysis_summary');
+    File file = new File(path);
+    if (file.existsSync()) {

[Brian Wilkerson, 2016/01/05 18:46:18]

Should we catch IO exceptions here and return `null`, or do we want the
exception to propagate (and if the latter, how far)?

[Paul Berry, 2016/01/05 19:33:43]

I hope we can propagate (or at least report) the exception in such a way that if
it causes unit tests to fail, it will be obvious what has gone wrong.

Historically we have had enough defensive coding surrounding the code that
accesses core types in the SDK that when I've introduced a bug that interferes
with core types, the exception I got had no obvious relationship to the root
cause of the problem, and it was really difficult to figure out what I had done
wrong.  I'd like to avoid creating a similar situation here.

[scheglov, 2016/01/05 20:27:57]

I will catch all exceptions here and report them with
AnalysisEngine.instance.logger.logError().

+      List<int> bytes = file.readAsBytesSync();
+      return new SdkBundle.fromBuffer(bytes);
+    }
+    return null;
+  }
+
+  /**
    * Return the given [file] if it exists and is executable, or `null` if it
    * does not exist or is not executable.
    */
   JavaFile _verifyExecutable(JavaFile file) =>
       file.isExecutable() ? file : null;
 }
 
 /**
  * An object used to read and parse the libraries file
  * (dart-sdk/lib/_internal/sdk_library_metadata/lib/libraries.dart) for information
@@ skipping 50 matching lines @@
     SdkLibrariesReader_LibraryBuilder libraryBuilder =
         new SdkLibrariesReader_LibraryBuilder(_useDart2jsPaths);
     // If any syntactic errors were found then don't try to visit the AST
     // structure.
     if (!errorListener.errorReported) {
       unit.accept(libraryBuilder);
     }
     return libraryBuilder.librariesMap;
   }
 }