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

pkg/kernel/lib/ast.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.
 
 /// -----------------------------------------------------------------------
 ///                           ERROR HANDLING
 /// -----------------------------------------------------------------------
 ///
 /// As a rule of thumb, errors that can be detected statically are handled by
 /// the frontend, typically by translating the erroneous code into a 'throw' or
@@ skipping 4198 matching lines @@
     return hash;
   }
 }
 
 // ------------------------------------------------------------------------
 //                                PROGRAM
 // ------------------------------------------------------------------------
 
 /// A way to bundle up all the libraries in a program.
 class Program extends TreeNode {
-  final CanonicalName root = new CanonicalName.root();
+  final CanonicalName root;

[Siggi Cherem (dart-lang), 2017/05/10 18:00:38]

Question for Kevin on API design here:
 - should we have a notion of a "Bundle" or something other than Program here
for our use-case?
 - if we do, we might still need a mechanism to create a program from a bundle
and avoid recomputing the canonical names, for that purpose alone it might be
valuable to allow passing in an existing root canonical name.

[Kevin Millikin (Google), 2017/05/11 08:22:55]

Even without these changes, Program is already not quite the right name.  The
name is a left-over from when we had a distinction between the binary format for
a (linked) program and (unlinked) bundle of libraries.

Let's just keep it for now.

 
   final List<Library> libraries;
 
   /// Map from a source file uri to a line-starts table and source code.
   /// Given a source file uri and a offset in that file one can translate
   /// it to a line:column position in that file.
   final Map<String, Source> uriToSource;
 
   /// Reference to the main method in one of the libraries.
   Reference mainMethodName;
 
-  Program([List<Library> libraries, Map<String, Source> uriToSource])
-      : libraries = libraries ?? <Library>[],
+  Program(
+      {CanonicalName nameRoot,
+      List<Library> libraries,
+      Map<String, Source> uriToSource})
+      : root = nameRoot ?? new CanonicalName.root(),
+        libraries = libraries ?? <Library>[],
         uriToSource = uriToSource ?? <String, Source>{} {
     setParents(this.libraries, this);
   }
 
   void computeCanonicalNames() {
     for (var library in libraries) {
+      if (library.canonicalName != null) continue;

[Kevin Millikin (Google), 2017/05/11 08:22:55]

Keep in mind that this approach of skipping libraries only works if a library
having a canonical name implies that every (named) thing in that library also
has a canonical name.

I don't know enough about your use case to know if that's true, but I'd rather
not assume it in package Kernel if we can think of a way around it.

(I'm thinking that you might want to read an external library from a binary, in
which case the library will have a canonical name.  Then later you might read
some named member of the library from some other source than a Kernel binary, in
which case it will not have a canonical name.  Skipping the library will never
build the name for that member.)

I'm also concerned about the converse problem.  You could imagine a Kernel
transformation that introduced fresh libraries (without a canonical name
computed) built out of members that were deserialized and so had a canonical
name.  For instance, maybe you wanted a transformation that combined distinct
libraries into new ones.  In that case, you will start naming the library and
then name the children and still hit the assert that you don't name something
that already has a name.

[scheglov, 2017/05/11 18:31:25]

OK, I rolled this back.

       root.getChildFromUri(library.importUri).bindTo(library.reference);
       library.computeCanonicalNames();
     }
   }
 
   void unbindCanonicalNames() {
     root.unbindAll();
   }
 
   Procedure get mainMethod => mainMethodName?.asProcedure;
@@ skipping 231 matching lines @@
 /// typedef has not been assigned a canonical name yet.
 ///
 /// Returns `null` if the typedef is `null`.
 CanonicalName getCanonicalNameOfTypedef(Typedef typedef_) {
   if (typedef_ == null) return null;
   if (typedef_.canonicalName == null) {
     throw '$typedef_ has no canonical name';
   }
   return typedef_.canonicalName;
 }