Use sdk summaries in front_end/kernel_generator.

pkg/kernel/lib/analyzer/loader.dart

 // Copyright (c) 2016, 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 kernel.analyzer.loader;
 
 import 'dart:async';
 import 'dart:io' as io;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/physical_file_system.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/src/dart/scanner/scanner.dart';
 import 'package:analyzer/src/dart/sdk/sdk.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/parser.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source_io.dart';
+import 'package:analyzer/src/summary/summary_sdk.dart';
 import 'package:kernel/application_root.dart';
 import 'package:package_config/discovery.dart';
 import 'package:package_config/packages.dart';
 
 import '../ast.dart' as ast;
 import '../repository.dart';
 import '../target/targets.dart' show Target;
 import '../type_algebra.dart';
 import 'analyzer.dart';
 import 'ast_from_analyzer.dart';
 
 /// Options passed to the Dart frontend.
 class DartOptions {
   /// True if user code should be loaded in strong mode.
   bool strongMode;
 
   /// True if the Dart SDK should be loaded in strong mode.
   bool strongModeSdk;
+
+  /// Path to the sdk sources, ignored if sdkSummary is provided.
   String sdk;
+
+  /// Path to a summary of the sdk sources.
+  String sdkSummary;
+
+  /// Path to the `.packages` file.
   String packagePath;
+
+  /// Root used to relativize app file-urls, making them machine agnostic.
   ApplicationRoot applicationRoot;
+
   Map<Uri, Uri> customUriMappings;
+
+  /// Environment definitions provided via `-Dkey=value`.
   Map<String, String> declaredVariables;
 
   DartOptions(
       {bool strongMode: false,
       bool strongModeSdk,
       this.sdk,
+      this.sdkSummary,
       this.packagePath,
       ApplicationRoot applicationRoot,
       Map<Uri, Uri> customUriMappings,
       Map<String, String> declaredVariables})
       : this.customUriMappings = customUriMappings ?? <Uri, Uri>{},
         this.declaredVariables = declaredVariables ?? <String, String>{},
         this.strongMode = strongMode,
         this.strongModeSdk = strongModeSdk ?? strongMode,
         this.applicationRoot = applicationRoot ?? new ApplicationRoot.none();
 }
@@ skipping 556 matching lines @@
       if (error.errorCode is CompileTimeErrorCode ||
           error.errorCode is ParserErrorCode ||
           error.errorCode is ScannerErrorCode ||
           error.errorCode is StrongModeCode) {
         lines ??= context.computeLineInfo(source);
         errors.add(formatErrorMessage(error, source.shortName, lines));
       }
     }
   }
 
-  void loadEverything({Target target}) {
-    ensureLibraryIsLoaded(getLibraryReference(getDartCoreLibrary()));
-    if (target != null) {
-      for (var uri in target.extraRequiredLibraries) {
-        var library = _findLibraryElement(uri);
-        if (library == null) {
-          errors.add('Could not find required library $uri');
-          continue;
+  void loadEverything({Target target, bool compileSdk}) {
+    compileSdk ??= true;
+    if (compileSdk) {
+      ensureLibraryIsLoaded(getLibraryReference(getDartCoreLibrary()));
+      if (target != null) {
+        for (var uri in target.extraRequiredLibraries) {
+          var library = _findLibraryElement(uri);
+          if (library == null) {
+            errors.add('Could not find required library $uri');
+            continue;
+          }
+          ensureLibraryIsLoaded(getLibraryReference(library));
         }
-        ensureLibraryIsLoaded(getLibraryReference(library));
       }
     }
     for (int i = 0; i < repository.libraries.length; ++i) {
-      ensureLibraryIsLoaded(repository.libraries[i]);
+      var library = repository.libraries[i];
+      if (compileSdk || library.importUri.scheme != 'dart') {
+        ensureLibraryIsLoaded(library);
+      }
     }
   }
 
   /// Builds a list of sources that have been loaded.
   ///
   /// This operation may be expensive and should only be used for diagnostics.
   List<String> getLoadedFileNames() {
     var list = <String>[];
     for (var library in repository.libraries) {
       LibraryElement element = context.computeLibraryElement(context
           .sourceFactory
           .forUri2(applicationRoot.absoluteUri(library.importUri)));
       for (var unit in element.units) {
         list.add(unit.source.fullName);
       }
     }
     return list;
   }
 
   void _iterateWorklist() {
     while (temporaryClassWorklist.isNotEmpty) {
       var element = temporaryClassWorklist.removeLast();
       promoteToTypeLevel(element);
     }
   }
 
-  ast.Program loadProgram(Uri mainLibrary, {Target target}) {
+  ast.Program loadProgram(Uri mainLibrary, {Target target, bool compileSdk}) {
     ast.Library library = repository
         .getLibraryReference(applicationRoot.relativeUri(mainLibrary));
     ensureLibraryIsLoaded(library);
-    loadEverything(target: target);
+    loadEverything(target: target, compileSdk: compileSdk);
     var program = new ast.Program(repository.libraries);
     program.mainMethod = library.procedures.firstWhere(
         (member) => member.name?.name == 'main',
         orElse: () => null);
     for (LibraryElement libraryElement in libraryElements) {
       for (CompilationUnitElement compilationUnitElement
           in libraryElement.units) {
         var source = compilationUnitElement.source;
         LineInfo lineInfo = context.computeLineInfo(source);
         program.uriToLineStarts["file://${source.fullName}"] =
@@ skipping 78 matching lines @@
 AnalysisOptions createAnalysisOptions(bool strongMode) {
   return new AnalysisOptionsImpl()
     ..strongMode = strongMode
     ..generateImplicitErrors = false
     ..generateSdkErrors = false
     ..preserveComments = false
     ..hint = false
     ..enableSuperMixins = true;
 }
 
-DartSdk createDartSdk(String path, {bool strongMode}) {
+DartSdk createDartSdk(String path, {bool strongMode, bool isSummary}) {
+  if (isSummary) {
+    return new SummaryBasedDartSdk(path, strongMode);
+  }
   var resources = PhysicalResourceProvider.INSTANCE;
   return new FolderBasedDartSdk(resources, resources.getFolder(path))
     ..context
         .analysisOptions
         .setCrossContextOptionsFrom(createAnalysisOptions(strongMode));
 }
 
 class CustomUriResolver extends UriResolver {
   final ResourceUriResolver _resourceUriResolver;
   final Map<Uri, Uri> _customUrlMappings;
@@ skipping 22 matching lines @@
     return _resourceUriResolver.resolveAbsolute(mapped, actualUri);
   }
 
   Uri restoreAbsolute(Source source) {
     return _resourceUriResolver.restoreAbsolute(source);
   }
 }
 
 AnalysisContext createContext(DartOptions options, Packages packages,
     {DartSdk dartSdk}) {
-  dartSdk ??= createDartSdk(options.sdk, strongMode: options.strongModeSdk);
+  bool fromSummary = options.sdkSummary != null;
+  dartSdk ??= createDartSdk(fromSummary ? options.sdkSummary : options.sdk,
+      strongMode: options.strongModeSdk, isSummary: fromSummary);
 
   var resourceProvider = PhysicalResourceProvider.INSTANCE;
   var resourceUriResolver = new ResourceUriResolver(resourceProvider);
   List<UriResolver> resolvers = [];
   var customUriMappings = options.customUriMappings;
   if (customUriMappings != null && customUriMappings.length > 0) {
     resolvers
         .add(new CustomUriResolver(resourceUriResolver, customUriMappings));
   }
   resolvers.add(new DartUriResolver(dartSdk));
@@ skipping 11 matching lines @@
   AnalysisContext context = AnalysisEngine.instance.createAnalysisContext()
     ..sourceFactory = new SourceFactory(resolvers)
     ..analysisOptions = createAnalysisOptions(options.strongMode);
 
   options.declaredVariables.forEach((String name, String value) {
     context.declaredVariables.define(name, value);
   });
 
   return context;
 }