When using SDK outline, transplant its names into the name root.

pkg/front_end/lib/src/incremental/kernel_driver.dart

 // Copyright (c) 2017, 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.
 
 import 'dart:async';
 
 import 'package:front_end/file_system.dart';
 import 'package:front_end/src/base/api_signature.dart';
 import 'package:front_end/src/base/performace_logger.dart';
 import 'package:front_end/src/base/processed_options.dart';
+import 'package:front_end/src/byte_store/byte_store.dart';
 import 'package:front_end/src/fasta/compiler_context.dart';
 import 'package:front_end/src/fasta/dill/dill_library_builder.dart';
 import 'package:front_end/src/fasta/dill/dill_target.dart';
 import 'package:front_end/src/fasta/kernel/kernel_target.dart';
 import 'package:front_end/src/fasta/kernel/utils.dart';
 import 'package:front_end/src/fasta/ticker.dart';
 import 'package:front_end/src/fasta/uri_translator.dart';
-import 'package:front_end/src/byte_store/byte_store.dart';
 import 'package:front_end/src/incremental/file_state.dart';
 import 'package:kernel/binary/ast_from_binary.dart';
 import 'package:kernel/core_types.dart';
 import 'package:kernel/kernel.dart' hide Source;
 import 'package:kernel/src/incremental_class_hierarchy.dart';
 import 'package:kernel/type_environment.dart';
 import 'package:meta/meta.dart';
 
 /// This function is invoked for each newly discovered file, and the returned
 /// [Future] is awaited before reading the file content.
@@ skipping 95 matching lines @@
   /// reported using [invalidate].
   ///
   /// If the driver has the cached result for the file with the current file
   /// state, it is returned.
   ///
   /// Otherwise the driver will compute new kernel files and return them.
   Future<KernelResult> getKernel(Uri uri) async {
     return await runWithFrontEndContext('Compute delta', () async {
       await _refreshInvalidatedFiles();
 
+      CanonicalName nameRoot = new CanonicalName.root();
+
       // Load the SDK outline before building the graph, so that the file
       // system state is configured to skip SDK libraries.
-      await _loadSdkOutline();
+      await _loadSdkOutline(nameRoot);
 
       // Ensure that the graph starting at the entry point is ready.
       FileState entryLibrary =
           await _logger.runAsync('Build graph of files', () async {
         return await _fsState.getFile(uri);
       });
 
       List<LibraryCycle> cycles = _logger.run('Compute library cycles', () {
         List<LibraryCycle> cycles = entryLibrary.topologicalOrder;
         _logger.writeln('Computed ${cycles.length} cycles.');
         return cycles;
       });
 
-      CanonicalName nameRoot = new CanonicalName.root();
       DillTarget dillTarget = new DillTarget(
           new Ticker(isVerbose: false), _uriTranslator, _options.target);
 
       // If there is SDK outline, load it.
       if (_sdkOutline != null) {
         dillTarget.loader.appendLibraries(_sdkOutline);
         await dillTarget.buildOutlines();
       }
 
       List<LibraryCycleResult> results = [];
@@ skipping 191 matching lines @@
       for (var part in library.partFiles) {
         signatureBuilder.addBytes(part.contentHash);
       }
     }
 
     return signatureBuilder.toHex();
   }
 
   /// Load the SDK outline if its bytes are provided, and configure the file
   /// system state to skip SDK library files.
-  Future<Null> _loadSdkOutline() async {
+  Future<Null> _loadSdkOutline(CanonicalName nameRoot) async {
     if (_sdkOutlineBytes != null) {
       if (_sdkOutline == null) {
         await _logger.runAsync('Load SDK outline from bytes.', () async {
           _sdkOutline = new Program();

[Siggi Cherem (dart-lang), 2017/08/11 17:27:27]

I'm not sure I follow - wouldn't it work instead if we pass `nameRoot` here to
this constructor instead?

[scheglov, 2017/08/11 17:29:23]

We use different "nameRoot" each time.

It will work, if we re-load SDK outline each time form binary.

[scheglov, 2017/08/11 17:32:45]

Yes, that's what I was saying - we do this for every other library.
It's just SDK that it special - it does not depend on any other library, so
potentially we could keep it loaded. But it's messy. I will rework.

           new BinaryBuilder(_sdkOutlineBytes).readProgram(_sdkOutline);
           // Configure the file system state to skip the outline libraries.
           for (var outlineLibrary in _sdkOutline.libraries) {
             _fsState.skipSdkLibraries.add(outlineLibrary.importUri);
           }
         });
       }
+      for (var sdkLibrary in _sdkOutline.libraries) {
+        nameRoot.transplantChild(sdkLibrary.canonicalName);
+      }
     }
   }
 
   /// Refresh all the invalidated files and update dependencies.
   Future<Null> _refreshInvalidatedFiles() async {
     await _logger.runAsync('Refresh invalidated files', () async {
       // Create a copy to avoid concurrent modifications.
       var invalidatedFiles = _invalidatedFiles.toList();
       _invalidatedFiles.clear();
 
@@ skipping 36 matching lines @@
 
   LibraryCycleResult(this.cycle, this.signature, this.kernelLibraries);
 }
 
 @visibleForTesting
 class _TestView {
   /// The list of [LibraryCycle]s compiled for the last delta.
   /// It does not include libraries which were read from the cache.
   final List<LibraryCycle> compiledCycles = [];
 }