Add a way to use shared CanonicalName root to deserialize Program.

pkg/front_end/lib/src/fasta/kernel/kernel_target.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 fasta.kernel_target;
 
 import 'dart:async' show Future;
 
 import 'dart:io' show File, IOSink;
 
 import 'package:front_end/file_system.dart';
 import 'package:kernel/ast.dart'
     show
         Arguments,
         AsyncMarker,
+        CanonicalName,
         Class,
         Constructor,
         DartType,
         DynamicType,
         EmptyStatement,
         Expression,
         ExpressionStatement,
         Field,
         FieldInitializer,
         FunctionNode,
@@ skipping 197 matching lines @@
       String message = error.format();
       print(message);
       errors.add(message);
     }
     program = erroneousProgram(isFullProgram);
     return uri == null
         ? new Future<Program>.value(program)
         : writeLinkedProgram(uri, program, isFullProgram: isFullProgram);
   }
 
-  Future<Program> writeOutline(Uri uri) async {
+  Future<Program> writeOutline(Uri uri, {CanonicalName nameRoot}) async {
     if (loader.first == null) return null;
     try {
       loader.createTypeInferenceEngine();
       await loader.buildOutlines();
       loader.coreLibrary
           .becomeCoreLibrary(const DynamicType(), const VoidType());
       dynamicType.bind(loader.coreLibrary["dynamic"]);
       loader.resolveParts();
       loader.computeLibraryScopes();
       loader.resolveTypes();
       loader.checkSemantics();
       loader.buildProgram();
       List<SourceClassBuilder> sourceClasses = collectAllSourceClasses();
       installDefaultSupertypes();
       installDefaultConstructors(sourceClasses);
       loader.resolveConstructors();
       loader.finishTypeVariables(objectClassBuilder);
-      program = link(new List<Library>.from(loader.libraries));
+      program =
+          link(new List<Library>.from(loader.libraries), nameRoot: nameRoot);
       loader.computeHierarchy(program);
       loader.checkOverrides(sourceClasses);
       loader.prepareInitializerInference();
       loader.performInitializerInference();
       if (uri == null) return program;
       return await writeLinkedProgram(uri, program, isFullProgram: false);
     } on InputError catch (e) {
       return handleInputError(uri, e, isFullProgram: false);
     } catch (e, s) {
       return reportCrash(e, s, loader?.currentUriForCrashReporting);
@@ skipping 99 matching lines @@
       library.addBuilder(mainBuilder.name, mainBuilder, -1);
       mainBuilder.body = new ExpressionStatement(
           new Throw(new StringLiteral("${errors.join('\n')}")));
     }
     library.build(loader.coreLibrary);
     return link(<Library>[library.library]);
   }
 
   /// Creates a program by combining [libraries] with the libraries of
   /// `dillTarget.loader.program`.
-  Program link(List<Library> libraries) {
+  Program link(List<Library> libraries, {CanonicalName nameRoot}) {
     Map<String, Source> uriToSource =
         new Map<String, Source>.from(this.uriToSource);
 
-    final Program binary = dillTarget.loader.program;
-    if (binary != null) {
-      libraries.addAll(binary.libraries);
-      uriToSource.addAll(binary.uriToSource);

[Siggi Cherem (dart-lang), 2017/05/12 17:29:25]

do we need to preserve this somehow? (when linking a full program, we will need
to include the uriToSource for all the other code to get appropriate debug
information in the resulting program, I believe.

I'm OK marking this with a TODO for this CL and do this separately. Possibly
we'd track uriToSource in loader as well?

[scheglov, 2017/05/12 17:44:21]

I will add TODO for now.

-    }
+    libraries.addAll(dillTarget.loader.libraries);
 
     // TODO(ahe): Remove this line. Kernel seems to generate a default line map
     // that used when there's no fileUri on an element. Instead, ensure all
     // elements have a fileUri.
     uriToSource[""] = new Source(<int>[0], const <int>[]);
-    Program program = new Program(libraries, uriToSource);
+    Program program = new Program(
+        nameRoot: nameRoot, libraries: libraries, uriToSource: uriToSource);
     if (loader.first != null) {
       Builder builder = loader.first.lookup("main", -1, null);
       if (builder is KernelProcedureBuilder) {
         program.mainMethod = builder.procedure;
       }
     }
     if (errors.isEmpty || dillTarget.isLoaded) {
       runLinkTransformations(program);
     }
     ticker.logMs("Linked program");
@@ skipping 322 matching lines @@
   }
   for (Constructor constructor in superclass.constructors) {
     if (constructor.name.name.isEmpty) {
       return constructor.function.requiredParameterCount == 0
           ? constructor
           : null;
     }
   }
   return null;
 }