Implement canonical name scheme in kernel.

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 38 matching lines @@
 /// has to update parent pointers manually.
 ///
 library kernel.ast;
 
 import 'visitor.dart';
 export 'visitor.dart';
 
 import 'type_propagation/type_propagation.dart';
 export 'type_propagation/type_propagation.dart';
 
+import 'canonical_name.dart' show CanonicalName;
+export 'canonical_name.dart' show CanonicalName;
+
 import 'transformations/flags.dart';
 import 'text/ast_to_text.dart';
 import 'type_algebra.dart';
 import 'type_environment.dart';
 
 /// Any type of node in the IR.
 abstract class Node {
   const Node();
 
   accept(Visitor v);
@@ skipping 76 matching lines @@
   Location get location {
     if (fileOffset == noOffset) return parent?.location;
     return _getLocationInEnclosingFile(fileOffset);
   }
 
   Location _getLocationInEnclosingFile(int offset) {
     return parent?._getLocationInEnclosingFile(offset);
   }
 }
 
+/// An AST node that can be referenced by other nodes.
+///
+/// There is a single [box] belonging to this node, providing a level of
+/// indirection that is needed during serialization.
+abstract class LinkedNode extends TreeNode {

[Kevin Millikin (Google), 2017/02/22 09:09:30]

Suggestion: LinkedNode ==> NamedNode, LinkedNodeBox ==> Reference.  Then change
Box everywhere to Ref or Reference.

[asgerf, 2017/02/22 10:06:54]

Done.

+  final LinkedNodeBox box;
+
+  LinkedNode(LinkedNodeBox box)
+      : this.box = box ?? new LinkedNodeBox() {
+    this.box.node = this;
+  }
+
+  CanonicalName get canonicalName => box?.canonicalName;
+}
+
+/// Indirection between a reference and its definition.
+class LinkedNodeBox {
+  CanonicalName canonicalName;
+  LinkedNode node;
+
+  Library get asLibrary {
+    if (node == null) throw 'The box is empty. A library was expected';
+    return node as Library;
+  }
+
+  Class get asClass {
+    if (node == null) throw 'The box is empty. A class was expected';
+    return node as Class;
+  }
+
+  Member get asMember {
+    if (node == null) throw 'The box is empty. A member was expected';
+    return node as Member;
+  }
+
+  Field get asField {
+    if (node == null) throw 'The box is empty. A field was expected';
+    return node as Field;
+  }
+
+  Constructor get asConstructor {
+    if (node == null) throw 'The box is empty. A constructor was expected';
+    return node as Constructor;
+  }
+
+  Procedure get asProcedure {
+    if (node == null) throw 'The box is empty. A procedure was expected';
+    return node as Procedure;
+  }
+}
+
 // ------------------------------------------------------------------------
 //                      LIBRARIES and CLASSES
 // ------------------------------------------------------------------------
 
-class Library extends TreeNode implements Comparable<Library> {
+class Library extends LinkedNode implements Comparable<Library> {
   /// An import path to this library.
   ///
   /// The [Uri] should have the `dart`, `package`, `app`, or `file` scheme.
   ///
   /// If the URI has the `app` scheme, it is relative to the application root.
   Uri importUri;
 
   /// The uri of the source file this library was loaded from.
   String fileUri;
 
@@ skipping 14 matching lines @@
   final List<Procedure> procedures;
   final List<Field> fields;
 
   Library(this.importUri,
       {this.name,
       this.isExternal: false,
       List<DeferredImport> imports,
       List<Class> classes,
       List<Procedure> procedures,
       List<Field> fields,
-      this.fileUri})
+      this.fileUri,
+      LinkedNodeBox box})
       : this.deferredImports = imports ?? <DeferredImport>[],
         this.classes = classes ?? <Class>[],
         this.procedures = procedures ?? <Procedure>[],
-        this.fields = fields ?? <Field>[] {
+        this.fields = fields ?? <Field>[],
+        super(box) {
     setParents(this.classes, this);
     setParents(this.procedures, this);
     setParents(this.fields, this);
   }
 
   /// Returns the top-level fields and procedures defined in this library.
   ///
   /// This getter is for convenience, not efficiency.  Consider manually
   /// iterating the members to speed up code in production.
   Iterable<Member> get members =>
       <Iterable<Member>>[fields, procedures].expand((x) => x);
 
   void addMember(Member member) {
     member.parent = this;
     if (member is Procedure) {
       procedures.add(member);
     } else if (member is Field) {
       fields.add(member);
     } else {
       throw new ArgumentError(member);
     }
   }
 
   void addClass(Class class_) {
     class_.parent = this;
     classes.add(class_);
   }
 
+  void computeCanonicalNames() {
+    assert(canonicalName != null);
+    for (var field in fields) {
+      canonicalName.getChildFromMember(field).bindTo(field.box);
+    }
+    for (var member in procedures) {
+      canonicalName.getChildFromMember(member).bindTo(member.box);
+    }
+    for (var class_ in classes) {
+      canonicalName.getChild(class_.name).bindTo(class_.box);
+      class_.computeCanonicalNames();
+    }
+  }
+
   accept(TreeVisitor v) => v.visitLibrary(this);
 
   visitChildren(Visitor v) {
     visitList(classes, v);
     visitList(procedures, v);
     visitList(fields, v);
   }
 
   transformChildren(Transformer v) {
     transformList(classes, v, this);
@@ skipping 10 matching lines @@
   /// the names across all [toString] calls.
   String toString() => debugLibraryName(this);
 
   Location _getLocationInEnclosingFile(int offset) {
     return enclosingProgram.getLocation(fileUri, offset);
   }
 }
 
 /// An import of form: `import <url> deferred as <name>;`.
 class DeferredImport extends TreeNode {
-  Library importedLibrary;
+  LinkedNodeBox importedLibraryBox;
   String name;
 
-  DeferredImport(this.importedLibrary, this.name);
+  DeferredImport(Library importedLibrary, String name)
+      : this.byBox(importedLibrary.box, name);
+
+  DeferredImport.byBox(this.importedLibraryBox, this.name);
 
   Library get enclosingLibrary => parent;
+  Library get importedLibrary => importedLibraryBox.node;
 
   accept(TreeVisitor v) => v.visitDeferredImport(this);
 
   visitChildren(Visitor v) {}
 
   transformChildren(Transformer v) {}
 }
 
 /// The degree to which the contents of a class have been loaded into memory.
 ///
@@ skipping 41 matching lines @@
   /// not necessarily at [Body] level.
   Body,
 }
 
 /// Declaration of a regular class or a mixin application.
 ///
 /// Mixin applications may not contain fields or procedures, as they implicitly
 /// use those from its mixed-in type.  However, the IR does not enforce this
 /// rule directly, as doing so can obstruct transformations.  It is possible to
 /// transform a mixin application to become a regular class, and vice versa.
-class Class extends TreeNode {
+class Class extends LinkedNode {
   /// The degree to which the contents of the class have been loaded.
   ClassLevel level = ClassLevel.Body;
 
   /// List of metadata annotations on the class.
   ///
   /// This defaults to an immutable empty list. Use [addAnnotation] to add
   /// annotations if needed.
   List<Expression> annotations = const <Expression>[];
 
   /// Name of the class.
@@ skipping 36 matching lines @@
   Class(
       {this.name,
       this.isAbstract: false,
       this.supertype,
       this.mixedInType,
       List<TypeParameter> typeParameters,
       List<Supertype> implementedTypes,
       List<Constructor> constructors,
       List<Procedure> procedures,
       List<Field> fields,
-      this.fileUri})
+      this.fileUri,
+      LinkedNodeBox box})
       : this.typeParameters = typeParameters ?? <TypeParameter>[],
         this.implementedTypes = implementedTypes ?? <Supertype>[],
         this.fields = fields ?? <Field>[],
         this.constructors = constructors ?? <Constructor>[],
-        this.procedures = procedures ?? <Procedure>[] {
+        this.procedures = procedures ?? <Procedure>[],
+        super(box) {
     setParents(this.typeParameters, this);
     setParents(this.constructors, this);
     setParents(this.procedures, this);
     setParents(this.fields, this);
   }
 
+  void computeCanonicalNames() {
+    assert(canonicalName != null);
+    for (var member in fields) {
+      canonicalName.getChildFromMember(member).bindTo(member.box);
+    }
+    for (var member in procedures) {
+      canonicalName.getChildFromMember(member).bindTo(member.box);
+    }
+    for (var member in constructors) {
+      canonicalName.getChildFromMember(member).bindTo(member.box);
+    }
+  }
+
   /// The immediate super class, or `null` if this is the root class.
   Class get superclass => supertype?.classNode;
 
   /// The mixed-in class if this is a mixin application, otherwise `null`.
   ///
   /// Note that this may itself be a mixin application.  Use [mixin] to get the
   /// class that has the fields and procedures.
   Class get mixedInClass => mixedInType?.classNode;
 
   /// The class that declares the field and procedures of this class.
@@ skipping 112 matching lines @@
 
   Location _getLocationInEnclosingFile(int offset) {
     return enclosingProgram.getLocation(fileUri, offset);
   }
 }
 
 // ------------------------------------------------------------------------
 //                            MEMBERS
 // ------------------------------------------------------------------------
 
-/// A indirect reference to a member, which can be updated to point at another
-/// member at a later time.
-class _MemberAccessor {
-  Member target;
-  _MemberAccessor(this.target);
-}
-
-abstract class Member extends TreeNode {
+abstract class Member extends LinkedNode {
   /// End offset in the source file it comes from. Valid values are from 0 and
   /// up, or -1 ([TreeNode.noOffset]) if the file end offset is not available
   /// (this is the default if none is specifically set).
   int fileEndOffset = TreeNode.noOffset;
 
   /// List of metadata annotations on the member.
   ///
   /// This defaults to an immutable empty list. Use [addAnnotation] to add
   /// annotations if needed.
   List<Expression> annotations = const <Expression>[];
   Name name;
 
   /// Flags summarizing the kinds of AST nodes contained in this member, for
   /// speeding up transformations that only affect certain types of nodes.
   ///
   /// See [TransformerFlag] for the meaning of each bit.
   ///
   /// These should not be used for any purpose other than skipping certain
   /// members if it can be determined that no work is needed in there.
   ///
   /// It is valid for these flags to be false positives in rare cases, so
   /// transformers must tolerate the case where a flag is spuriously set.
   ///
   /// This value is not serialized; it is populated by the frontend and the
   /// deserializer.
   //
   // TODO(asgerf): It might be worthwhile to put this on classes as well.
   int transformerFlags = 0;
 
-  Member(this.name);
+  Member(this.name, LinkedNodeBox box) : super(box);
 
   Class get enclosingClass => parent is Class ? parent : null;
   Library get enclosingLibrary => parent is Class ? parent.parent : parent;
 
   accept(MemberVisitor v);
   acceptReference(MemberReferenceVisitor v);
 
   /// If true, the member is part of an external library, that is, it is defined
   /// in another build unit.  Such members have no body or initializer present
   /// in the IR.
@@ skipping 37 matching lines @@
     annotations.add(node);
     node.parent = this;
   }
 
   DartType get getterType;
   DartType get setterType;
 
   bool get containsSuperCalls {
     return transformerFlags & TransformerFlag.superCalls != 0;
   }
-
-  _MemberAccessor get _getterInterface;
-  _MemberAccessor get _setterInterface;
 }
 
 /// A field declaration.
 ///
 /// The implied getter and setter for the field are not represented explicitly,
 /// but can be made explicit if needed.
 class Field extends Member {
-  _MemberAccessor _getterInterface, _setterInterface;
-
   DartType type; // Not null. Defaults to DynamicType.
   InferredValue inferredValue; // May be null.
   int flags = 0;
   Expression initializer; // May be null.
 
   /// The uri of the source file this field was loaded from.
   String fileUri;
 
   Field(Name name,
       {this.type: const DynamicType(),
       this.inferredValue,
       this.initializer,
       bool isFinal: false,
       bool isConst: false,
       bool isStatic: false,
       bool hasImplicitGetter,
       bool hasImplicitSetter,
       int transformerFlags: 0,
-      this.fileUri})
-      : super(name) {
-    _getterInterface = new _MemberAccessor(this);
-    _setterInterface = new _MemberAccessor(this);
+      this.fileUri,
+      LinkedNodeBox box})
+      : super(name, box) {
     assert(type != null);
     initializer?.parent = this;
     this.isFinal = isFinal;
     this.isConst = isConst;
     this.isStatic = isStatic;
     this.hasImplicitGetter = hasImplicitGetter ?? !isStatic;
     this.hasImplicitSetter = hasImplicitSetter ?? (!isStatic && !isFinal);
     this.transformerFlags = transformerFlags;
   }
 
@@ skipping 79 matching lines @@
     transformList(annotations, v, this);
     if (initializer != null) {
       initializer = initializer.accept(v);
       initializer?.parent = this;
     }
   }
 
   DartType get getterType => type;
   DartType get setterType => isMutable ? type : const BottomType();
 
-  /// Makes all [PropertyGet]s that have this field as its interface target
-  /// use [getter] as its interface target instead.
-  ///
-  /// That can be used to introduce an explicit getter for a field instead of
-  /// its implicit getter.
-  ///
-  /// This method only updates the stored interface target -- the caller must
-  /// ensure that [getter] actually becomes the target for dispatches that
-  /// would previously hit the implicit field getter.
-  ///
-  /// [DirectPropertyGet]s are not affected, and will continue to access the
-  /// field directly. [PropertyGet] nodes created after the call will not be
-  /// affected until the method is called again.
-  ///
-  /// Existing [ClassHierarchy] instances are not affected by this call.
-  void replaceGetterInterfaceWith(Procedure getter) {
-    _getterInterface.target = getter;
-    _getterInterface = new _MemberAccessor(this);
-  }
-
-  /// Makes all [PropertySet]s that have this field as its interface target
-  /// use [setter] as its interface target instead.
-  ///
-  /// That can be used to introduce an explicit setter for a field instead of
-  /// its implicit setter.
-  ///
-  /// This method only updates the stored interface target -- the caller must
-  /// ensure that [setter] actually becomes the target for dispatches that
-  /// would previously hit the implicit field setter.
-  ///
-  /// [DirectPropertySet] and [FieldInitializer]s are not affected, and will
-  /// continue to access the field directly.  [PropertySet] nodes created after
-  /// the call will not be affected until the method is called again.
-  ///
-  /// Existing [ClassHierarchy] instances are not affected by this call.
-  void replaceSetterInterfaceWith(Procedure setter) {
-    _setterInterface.target = setter;
-    _setterInterface = new _MemberAccessor(this);
-  }
-
   Location _getLocationInEnclosingFile(int offset) {
     return enclosingProgram.getLocation(fileUri, offset);
   }
 }
 
 /// A generative constructor, possibly redirecting.
 ///
 /// Note that factory constructors are treated as [Procedure]s.
 ///
 /// Constructors do not take type parameters.  Type arguments from a constructor
 /// invocation should be matched with the type parameters declared in the class.
 ///
 /// For unnamed constructors, the name is an empty string (in a [Name]).
 class Constructor extends Member {
   int flags = 0;
   FunctionNode function;
   List<Initializer> initializers;
 
   Constructor(this.function,
       {Name name,
       bool isConst: false,
       bool isExternal: false,
       List<Initializer> initializers,
-      int transformerFlags: 0})
+      int transformerFlags: 0,
+      LinkedNodeBox box})
       : this.initializers = initializers ?? <Initializer>[],
-        super(name) {
+        super(name, box) {
     function?.parent = this;
     setParents(this.initializers, this);
     this.isConst = isConst;
     this.isExternal = isExternal;
     this.transformerFlags = transformerFlags;
   }
 
   static const int FlagConst = 1 << 0; // Must match serialized bit positions.
   static const int FlagExternal = 1 << 1;
 
@@ skipping 28 matching lines @@
     transformList(annotations, v, this);
     if (function != null) {
       function = function.accept(v);
       function?.parent = this;
     }
     transformList(initializers, v, this);
   }
 
   DartType get getterType => const BottomType();
   DartType get setterType => const BottomType();
-
-  _MemberAccessor get _getterInterface {
-    throw 'Constructors cannot be used as getters';
-  }
-
-  _MemberAccessor get _setterInterface {
-    throw 'Constructors cannot be used as setters';
-  }
 }
 
 /// A method, getter, setter, index-getter, index-setter, operator overloader,
 /// or factory.
 ///
 /// Procedures can have the static, abstract, and/or external modifier, although
 /// only the static and external modifiers may be used together.
 ///
 /// For non-static procedures the name is required for dynamic dispatch.
 /// For external procedures the name is required for identifying the external
 /// implementation.
 ///
 /// For methods, getters, and setters the name is just as it was declared.
 /// For setters this does not include a trailing `=`.
 /// For index-getters/setters, this is `[]` and `[]=`.
 /// For operators, this is the token for the operator, e.g. `+` or `==`,
 /// except for the unary minus operator, whose name is `unary-`.
 class Procedure extends Member {
-  _MemberAccessor _reference;
   ProcedureKind kind;
   int flags = 0;
   FunctionNode function; // Body is null if and only if abstract or external.
 
   /// The uri of the source file this procedure was loaded from.
   String fileUri;
 
   Procedure(Name name, this.kind, this.function,
       {bool isAbstract: false,
       bool isStatic: false,
       bool isExternal: false,
       bool isConst: false,
       int transformerFlags: 0,
-      this.fileUri})
-      : super(name) {
-    _reference = new _MemberAccessor(this);
+      this.fileUri,
+      LinkedNodeBox box})
+      : super(name, box) {
     function?.parent = this;
     this.isAbstract = isAbstract;
     this.isStatic = isStatic;
     this.isExternal = isExternal;
     this.isConst = isConst;
     this.transformerFlags = transformerFlags;
   }
 
   static const int FlagStatic = 1 << 0; // Must match serialized bit positions.
   static const int FlagAbstract = 1 << 1;
@@ skipping 52 matching lines @@
   DartType get getterType {
     return isGetter ? function.returnType : function.functionType;
   }
 
   DartType get setterType {
     return isSetter
         ? function.positionalParameters[0].type
         : const BottomType();
   }
 
-  _MemberAccessor get _getterInterface => _reference;
-  _MemberAccessor get _setterInterface => _reference;
-
   Location _getLocationInEnclosingFile(int offset) {
     return enclosingProgram.getLocation(fileUri, offset);
   }
 }
 
 enum ProcedureKind {
   Method,
   Getter,
   Setter,
   Operator,
@@ skipping 25 matching lines @@
 /// A field assignment `field = value` occurring in the initializer list of
 /// a constructor.
 ///
 /// This node has nothing to do with declaration-site field initializers; those
 /// are [Expression]s stored in [Field.initializer].
 //
 // TODO: The frontend should check that all final fields are initialized
 //  exactly once, and that no fields are assigned twice in the initializer list.
 class FieldInitializer extends Initializer {
   /// Reference to the field being initialized.  Not null.
-  Field field;
+  LinkedNodeBox fieldBox;
   Expression value;
 
-  FieldInitializer(this.field, this.value) {
+  FieldInitializer(Field field, Expression value)
+      : this.byBox(field?.box, value);
+
+  FieldInitializer.byBox(this.fieldBox, this.value) {
     value?.parent = this;
   }
 
+  Field get field => fieldBox?.node;
+
+  void set field(Field field) {
+    fieldBox = field?.box;
+  }
+
   accept(InitializerVisitor v) => v.visitFieldInitializer(this);
 
   visitChildren(Visitor v) {
     field?.acceptReference(v);
     value?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (value != null) {
       value = value.accept(v);
       value?.parent = this;
     }
   }
 }
 
 /// A super call `super(x,y)` occurring in the initializer list of a
 /// constructor.
 ///
 /// There are no type arguments on this call.
 //
 // TODO: The frontend should check that there is no more than one super call.
 //
 // DESIGN TODO: Consider if the frontend should insert type arguments derived
 // from the extends clause.
 class SuperInitializer extends Initializer {
   /// Reference to the constructor being invoked in the super class. Not null.
-  Constructor target;
+  LinkedNodeBox targetBox;
   Arguments arguments;
 
-  SuperInitializer(this.target, this.arguments) {
+  SuperInitializer(Constructor target, Arguments arguments)
+      : this.byBox(getBoxOfMember(target), arguments);
+
+  SuperInitializer.byBox(this.targetBox, this.arguments) {
     arguments?.parent = this;
   }
 
+  Constructor get target => targetBox?.asConstructor;
+
+  void set target(Constructor target) {
+    targetBox = getBoxOfMember(target);
+  }
+
   accept(InitializerVisitor v) => v.visitSuperInitializer(this);
 
   visitChildren(Visitor v) {
     target?.acceptReference(v);
     arguments?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (arguments != null) {
       arguments = arguments.accept(v);
       arguments?.parent = this;
     }
   }
 }
 
 /// A redirecting call `this(x,y)` occurring in the initializer list of
 /// a constructor.
 //
 // TODO: The frontend should check that this is the only initializer and if the
 // constructor has a body or if there is a cycle in the initializer calls.
 class RedirectingInitializer extends Initializer {
   /// Reference to the constructor being invoked in the same class. Not null.
-  Constructor target;
+  LinkedNodeBox targetBox;
   Arguments arguments;
 
-  RedirectingInitializer(this.target, this.arguments) {
+  RedirectingInitializer(Constructor target, Arguments arguments)
+      : this.byBox(getBoxOfMember(target), arguments);
+
+  RedirectingInitializer.byBox(this.targetBox, this.arguments) {
     arguments?.parent = this;
   }
 
+  Constructor get target => targetBox?.asConstructor;
+
+  void set target(Constructor target) {
+    targetBox = getBoxOfMember(target);
+  }
+
   accept(InitializerVisitor v) => v.visitRedirectingInitializer(this);
 
   visitChildren(Visitor v) {
     target?.acceptReference(v);
     arguments?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (arguments != null) {
       arguments = arguments.accept(v);
@@ skipping 272 matching lines @@
   }
 }
 
 /// Expression of form `x.field`.
 ///
 /// This may invoke a getter, read a field, or tear off a method.
 class PropertyGet extends Expression {
   Expression receiver;
   Name name;
 
-  _MemberAccessor _interfaceTargetReference;
+  LinkedNodeBox interfaceTargetBox;
 
-  PropertyGet(this.receiver, this.name, [Member interfaceTarget]) {
+  PropertyGet(Expression receiver, Name name, [Member interfaceTarget])
+      : this.byBox(receiver, name, getBoxOfMember(interfaceTarget));
+
+  PropertyGet.byBox(this.receiver, this.name, this.interfaceTargetBox) {
     receiver?.parent = this;
-    this.interfaceTarget = interfaceTarget;
   }
 
-  Member get interfaceTarget => _interfaceTargetReference?.target;
+  Member get interfaceTarget => interfaceTargetBox?.asMember;
 
-  void set interfaceTarget(Member newTarget) {
-    _interfaceTargetReference = newTarget?._getterInterface;
+  void set interfaceTarget(Member member) {
+    interfaceTargetBox = getBoxOfMember(member);
   }
 
   DartType getStaticType(TypeEnvironment types) {
     var interfaceTarget = this.interfaceTarget;
     if (interfaceTarget != null) {
       Class superclass = interfaceTarget.enclosingClass;
       var receiverType = receiver.getStaticTypeAsInstanceOf(superclass, types);
       return Substitution
           .fromInterfaceType(receiverType)
           .substituteType(interfaceTarget.getterType);
@@ skipping 26 matching lines @@
 /// Expression of form `x.field = value`.
 ///
 /// This may invoke a setter or assign a field.
 ///
 /// Evaluates to the value of [value].
 class PropertySet extends Expression {
   Expression receiver;
   Name name;
   Expression value;
 
-  _MemberAccessor _interfaceTargetReference;
+  LinkedNodeBox interfaceTargetBox;
 
-  PropertySet(this.receiver, this.name, this.value, [Member interfaceTarget]) {
+  PropertySet(Expression receiver, Name name, Expression value,
+      [Member interfaceTarget])
+      : this.byBox(
+            receiver, name, value, getBoxOfMember(interfaceTarget));
+
+  PropertySet.byBox(
+      this.receiver, this.name, this.value, this.interfaceTargetBox) {
     receiver?.parent = this;
     value?.parent = this;
-    this.interfaceTarget = interfaceTarget;
   }
 
-  Member get interfaceTarget => _interfaceTargetReference?.target;
+  Member get interfaceTarget => interfaceTargetBox?.asMember;
 
-  void set interfaceTarget(Member newTarget) {
-    _interfaceTargetReference = newTarget?._setterInterface;
+  void set interfaceTarget(Member member) {
+    interfaceTargetBox = getBoxOfMember(member);
   }
 
   DartType getStaticType(TypeEnvironment types) => value.getStaticType(types);
 
   accept(ExpressionVisitor v) => v.visitPropertySet(this);
 
   visitChildren(Visitor v) {
     receiver?.accept(v);
     name?.accept(v);
     value?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (receiver != null) {
       receiver = receiver.accept(v);
       receiver?.parent = this;
     }
     if (value != null) {
       value = value.accept(v);
       value?.parent = this;
     }
   }
 }
 
 /// Directly read a field, call a getter, or tear off a method.
 class DirectPropertyGet extends Expression {
   Expression receiver;
-  Member target;
+  LinkedNodeBox targetBox;
 
-  DirectPropertyGet(this.receiver, this.target) {
+  DirectPropertyGet(Expression receiver, Member target)
+      : this.byBox(receiver, getBoxOfMember(target));
+
+  DirectPropertyGet.byBox(this.receiver, this.targetBox) {
     receiver?.parent = this;
   }
 
+  Member get target => targetBox?.asMember;
+
+  void set target(Member target) {
+    targetBox = getBoxOfMember(target);
+  }
+
   visitChildren(Visitor v) {
     receiver?.accept(v);
     target?.acceptReference(v);
   }
 
   transformChildren(Transformer v) {
     if (receiver != null) {
       receiver = receiver.accept(v);
       receiver?.parent = this;
     }
   }
 
   accept(ExpressionVisitor v) => v.visitDirectPropertyGet(this);
 
   DartType getStaticType(TypeEnvironment types) {
     Class superclass = target.enclosingClass;
     var receiverType = receiver.getStaticTypeAsInstanceOf(superclass, types);
     return Substitution
         .fromInterfaceType(receiverType)
         .substituteType(target.getterType);
   }
 }
 
 /// Directly assign a field, or call a setter.
 ///
 /// Evaluates to the value of [value].
 class DirectPropertySet extends Expression {
   Expression receiver;
-  Member target;
+  LinkedNodeBox targetBox;
   Expression value;
 
-  DirectPropertySet(this.receiver, this.target, this.value) {
+  DirectPropertySet(Expression receiver, Member target, Expression value)
+      : this.byBox(receiver, getBoxOfMember(target), value);
+
+  DirectPropertySet.byBox(this.receiver, this.targetBox, this.value) {
     receiver?.parent = this;
     value?.parent = this;
   }
 
+  Member get target => targetBox?.asMember;
+
+  void set target(Member target) {
+    targetBox = getBoxOfMember(target);
+  }
+
   visitChildren(Visitor v) {
     receiver?.accept(v);
     target?.acceptReference(v);
     value?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (receiver != null) {
       receiver = receiver.accept(v);
       receiver?.parent = this;
     }
     if (value != null) {
       value = value.accept(v);
       value?.parent = this;
     }
   }
 
   accept(ExpressionVisitor v) => v.visitDirectPropertySet(this);
 
   DartType getStaticType(TypeEnvironment types) => value.getStaticType(types);
 }
 
 /// Directly call an instance method, bypassing ordinary dispatch.
 class DirectMethodInvocation extends InvocationExpression {
   Expression receiver;
-  Procedure target;
+  LinkedNodeBox targetBox;
   Arguments arguments;
 
-  DirectMethodInvocation(this.receiver, this.target, this.arguments) {
+  DirectMethodInvocation(
+      Expression receiver, Procedure target, Arguments arguments)
+      : this.byBox(receiver, getBoxOfMember(target), arguments);
+
+  DirectMethodInvocation.byBox(
+      this.receiver, this.targetBox, this.arguments) {
     receiver?.parent = this;
     arguments?.parent = this;
   }
 
+  Procedure get target => targetBox?.asProcedure;
+
+  void set target(Procedure target) {
+    targetBox = getBoxOfMember(target);
+  }
+
   Name get name => target?.name;
 
   visitChildren(Visitor v) {
     receiver?.accept(v);
     target?.acceptReference(v);
     arguments?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (receiver != null) {
@@ skipping 22 matching lines @@
         .fromPairs(target.function.typeParameters, arguments.types)
         .substituteType(returnType);
   }
 }
 
 /// Expression of form `super.field`.
 ///
 /// This may invoke a getter, read a field, or tear off a method.
 class SuperPropertyGet extends Expression {
   Name name;
-  _MemberAccessor _interfaceTargetReference;
+  LinkedNodeBox interfaceTargetBox;
 
-  SuperPropertyGet(this.name, [Member interfaceTarget]) {
-    _interfaceTargetReference = interfaceTarget?._getterInterface;
-  }
+  SuperPropertyGet(Name name, [Member interfaceTarget])
+      : this.byBox(name, getBoxOfMember(interfaceTarget));
 
-  Member get interfaceTarget => _interfaceTargetReference?.target;
+  SuperPropertyGet.byBox(this.name, this.interfaceTargetBox);
 
-  void set interfaceTarget(Member newTarget) {
-    _interfaceTargetReference = newTarget?._getterInterface;
+  Member get interfaceTarget => interfaceTargetBox?.asMember;
+
+  void set interfaceTarget(Member member) {
+    interfaceTargetBox = getBoxOfMember(member);
   }
 
   DartType getStaticType(TypeEnvironment types) {
     Class declaringClass = interfaceTarget.enclosingClass;
     if (declaringClass.typeParameters.isEmpty) {
       return interfaceTarget.getterType;
     }
     var receiver =
         types.hierarchy.getTypeAsInstanceOf(types.thisType, declaringClass);
     return Substitution
@@ skipping 11 matching lines @@
 }
 
 /// Expression of form `super.field = value`.
 ///
 /// This may invoke a setter or assign a field.
 ///
 /// Evaluates to the value of [value].
 class SuperPropertySet extends Expression {
   Name name;
   Expression value;
-  _MemberAccessor _interfaceTargetReference;
+  LinkedNodeBox interfaceTargetBox;
 
-  SuperPropertySet(this.name, this.value, [Member interfaceTarget]) {
+  SuperPropertySet(Name name, Expression value, Member interfaceTarget)
+      : this.byBox(name, value, getBoxOfMember(interfaceTarget));
+
+  SuperPropertySet.byBox(this.name, this.value, this.interfaceTargetBox) {
     value?.parent = this;
-    _interfaceTargetReference = interfaceTarget?._setterInterface;
   }
 
-  Member get interfaceTarget => _interfaceTargetReference?.target;
+  Member get interfaceTarget => interfaceTargetBox?.asMember;
 
-  void set interfaceTarget(Member newTarget) {
-    _interfaceTargetReference = newTarget?._setterInterface;
+  void set interfaceTarget(Member member) {
+    interfaceTargetBox = getBoxOfMember(member);
   }
 
   DartType getStaticType(TypeEnvironment types) => value.getStaticType(types);
 
   accept(ExpressionVisitor v) => v.visitSuperPropertySet(this);
 
   visitChildren(Visitor v) {
     name?.accept(v);
     value?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (value != null) {
       value = value.accept(v);
       value?.parent = this;
     }
   }
 }
 
 /// Read a static field, call a static getter, or tear off a static method.
 class StaticGet extends Expression {
   /// A static field, getter, or method (for tear-off).
-  Member target;
+  LinkedNodeBox targetBox;
 
-  StaticGet(this.target);
+  StaticGet(Member target) : this.byBox(getBoxOfMember(target));
+
+  StaticGet.byBox(this.targetBox);
+
+  Member get target => targetBox?.asMember;
+
+  void set target(Member target) {
+    targetBox = getBoxOfMember(target);
+  }
 
   DartType getStaticType(TypeEnvironment types) => target.getterType;
 
   accept(ExpressionVisitor v) => v.visitStaticGet(this);
 
   visitChildren(Visitor v) {
     target?.acceptReference(v);
   }
 
   transformChildren(Transformer v) {}
 }
 
 /// Assign a static field or call a static setter.
 ///
 /// Evaluates to the value of [value].
 class StaticSet extends Expression {
   /// A mutable static field or a static setter.
-  Member target;
+  LinkedNodeBox targetBox;
   Expression value;
 
-  StaticSet(this.target, this.value) {
+  StaticSet(Member target, Expression value)
+      : this.byBox(getBoxOfMember(target), value);
+
+  StaticSet.byBox(this.targetBox, this.value) {
     value?.parent = this;
   }
 
+  Member get target => targetBox?.asMember;
+
+  void set target(Member target) {
+    targetBox = getBoxOfMember(target);
+  }
+
   DartType getStaticType(TypeEnvironment types) => value.getStaticType(types);
 
   accept(ExpressionVisitor v) => v.visitStaticSet(this);
 
   visitChildren(Visitor v) {
     target?.acceptReference(v);
     value?.accept(v);
   }
 
   transformChildren(Transformer v) {
@@ skipping 73 matching lines @@
   /// May be `null` if the target is a synthetic static member without a name.
   Name get name;
 }
 
 /// Expression of form `x.foo(y)`.
 class MethodInvocation extends InvocationExpression {
   Expression receiver;
   Name name;
   Arguments arguments;
 
-  Procedure interfaceTarget;
+  LinkedNodeBox interfaceTargetBox;
 
-  MethodInvocation(this.receiver, this.name, this.arguments,
-      [this.interfaceTarget]) {
+  MethodInvocation(Expression receiver, Name name, Arguments arguments,
+      [Procedure interfaceTarget])
+      : this.byBox(receiver, name, arguments,
+            getBoxOfMember(interfaceTarget));
+
+  MethodInvocation.byBox(
+      this.receiver, this.name, this.arguments, this.interfaceTargetBox) {
     receiver?.parent = this;
     arguments?.parent = this;
   }
 
+  Procedure get interfaceTarget => interfaceTargetBox?.asProcedure;
+
+  void set interfaceTarget(Member target) {
+    interfaceTargetBox = getBoxOfMember(target);
+  }
+
   DartType getStaticType(TypeEnvironment types) {
     if (interfaceTarget != null) {
       if (types.isOverloadedArithmeticOperator(interfaceTarget)) {
         return types.getTypeOfOverloadedArithmetic(
             receiver.getStaticType(types),
             arguments.positional[0].getStaticType(types));
       }
       Class superclass = interfaceTarget.enclosingClass;
       var receiverType = receiver.getStaticTypeAsInstanceOf(superclass, types);
       var returnType = Substitution
@@ skipping 41 matching lines @@
   }
 }
 
 /// Expression of form `super.foo(x)`.
 ///
 /// The provided arguments might not match the parameters of the target.
 class SuperMethodInvocation extends InvocationExpression {
   Name name;
   Arguments arguments;
 
-  Procedure interfaceTarget;
+  LinkedNodeBox interfaceTargetBox;
 
-  SuperMethodInvocation(this.name, this.arguments, this.interfaceTarget) {
+  SuperMethodInvocation(Name name, Arguments arguments,
+      [Procedure interfaceTarget])
+      : this.byBox(name, arguments, getBoxOfMember(interfaceTarget));
+
+  SuperMethodInvocation.byBox(
+      this.name, this.arguments, this.interfaceTargetBox) {
     arguments?.parent = this;
   }
 
+  Procedure get interfaceTarget => interfaceTargetBox?.asProcedure;
+
+  void set interfaceTarget(Procedure target) {
+    interfaceTargetBox = getBoxOfMember(target);
+  }
+
   DartType getStaticType(TypeEnvironment types) {
     if (interfaceTarget == null) return const DynamicType();
     Class superclass = interfaceTarget.enclosingClass;
     var receiverType =
         types.hierarchy.getTypeAsInstanceOf(types.thisType, superclass);
     var returnType = Substitution
         .fromInterfaceType(receiverType)
         .substituteType(interfaceTarget.function.returnType);
     return Substitution
         .fromPairs(interfaceTarget.function.typeParameters, arguments.types)
@@ skipping 13 matching lines @@
       arguments?.parent = this;
     }
   }
 }
 
 /// Expression of form `foo(x)`, or `const foo(x)` if the target is an
 /// external constant factory.
 ///
 /// The provided arguments might not match the parameters of the target.
 class StaticInvocation extends InvocationExpression {
-  Procedure target;
+  LinkedNodeBox targetBox;
   Arguments arguments;
 
   /// True if this is a constant call to an external constant factory.
   bool isConst;
 
   Name get name => target?.name;
 
-  StaticInvocation(this.target, this.arguments, {this.isConst: false}) {
+  StaticInvocation(Procedure target, Arguments arguments, {bool isConst: false})
+      : this.byBox(getBoxOfMember(target), arguments,
+            isConst: isConst);
+
+  StaticInvocation.byBox(this.targetBox, this.arguments,
+      {this.isConst: false}) {
     arguments?.parent = this;
   }
 
+  Procedure get target => targetBox?.asProcedure;
+
+  void set target(Procedure target) {
+    targetBox = getBoxOfMember(target);
+  }
+
   DartType getStaticType(TypeEnvironment types) {
     return Substitution
         .fromPairs(target.function.typeParameters, arguments.types)
         .substituteType(target.function.returnType);
   }
 
   accept(ExpressionVisitor v) => v.visitStaticInvocation(this);
 
   visitChildren(Visitor v) {
     target?.acceptReference(v);
     arguments?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (arguments != null) {
       arguments = arguments.accept(v);
       arguments?.parent = this;
     }
   }
 }
 
 /// Expression of form `new Foo(x)` or `const Foo(x)`.
 ///
 /// The provided arguments might not match the parameters of the target.
 //
 // DESIGN TODO: Should we pass type arguments in a separate field
 // `classTypeArguments`? They are quite different from type arguments to
 // generic functions.
 class ConstructorInvocation extends InvocationExpression {
-  Constructor target;
+  LinkedNodeBox targetBox;
   Arguments arguments;
   bool isConst;
 
   Name get name => target?.name;
 
-  ConstructorInvocation(this.target, this.arguments, {this.isConst: false}) {
+  ConstructorInvocation(Constructor target, Arguments arguments,
+      {bool isConst: false})
+      : this.byBox(getBoxOfMember(target), arguments,
+            isConst: isConst);
+
+  ConstructorInvocation.byBox(this.targetBox, this.arguments,
+      {this.isConst: false}) {
     arguments?.parent = this;
   }
 
+  Constructor get target => targetBox?.asConstructor;
+
+  void set target(Constructor target) {
+    targetBox = getBoxOfMember(target);
+  }
+
   DartType getStaticType(TypeEnvironment types) {
     return arguments.types.isEmpty
         ? target.enclosingClass.rawType
         : new InterfaceType(target.enclosingClass, arguments.types);
   }
 
   accept(ExpressionVisitor v) => v.visitConstructorInvocation(this);
 
   visitChildren(Visitor v) {
     target?.acceptReference(v);
@@ skipping 1226 matching lines @@
 /// statically resolved references are represented in nameless form.
 ///
 /// [Name]s are immutable and compare based on structural equality, and they
 /// are not AST nodes.
 ///
 /// The [toString] method returns a human-readable string that includes the
 /// library name for private names; uniqueness is not guaranteed.
 abstract class Name implements Node {
   final int hashCode;
   final String name;
+  LinkedNodeBox get libraryName;
   Library get library;
   bool get isPrivate;
 
   Name._internal(this.hashCode, this.name);
 
-  factory Name(String name, [Library library]) {
+  factory Name(String name, [Library library]) =>
+      new Name.byReference(name, library?.box);
+
+  factory Name.byReference(String name, LinkedNodeBox libraryName) {
     /// Use separate subclasses for the public and private case to save memory
     /// for public names.
     if (name.startsWith('_')) {
-      assert(library != null);
-      return new _PrivateName(name, library);
+      assert(libraryName != null);
+      return new _PrivateName(name, libraryName);
     } else {
       return new _PublicName(name);
     }
   }
 
   bool operator ==(other) {
     return other is Name && name == other.name && library == other.library;
   }
 
   accept(Visitor v) => v.visitName(this);
 
   visitChildren(Visitor v) {
     // DESIGN TODO: Should we visit the library as a library reference?
   }
 }
 
 class _PrivateName extends Name {
-  final Library library;
+  final LinkedNodeBox libraryName;
   bool get isPrivate => true;
 
-  _PrivateName(String name, Library library)
-      : this.library = library,
-        super._internal(_computeHashCode(name, library), name);
+  _PrivateName(String name, LinkedNodeBox libraryName)
+      : this.libraryName = libraryName,
+        super._internal(_computeHashCode(name, libraryName), name);
 
   String toString() => library != null ? '$library::$name' : name;
 
-  static int _computeHashCode(String name, Library library) {
-    return 131 * name.hashCode + 17 * library.hashCode;
+  Library get library => libraryName.asLibrary;
+
+  static int _computeHashCode(String name, LinkedNodeBox libraryName) {
+    return 131 * name.hashCode + 17 * libraryName.hashCode;
   }
 }
 
 class _PublicName extends Name {
+  LinkedNodeBox get libraryName => null;
   Library get library => null;
   bool get isPrivate => false;
 
   _PublicName(String name) : super._internal(name.hashCode, name);
 
   String toString() => name;
 }
 
 // ------------------------------------------------------------------------
 //                             TYPES
@@ skipping 59 matching lines @@
 
   const BottomType();
 
   accept(DartTypeVisitor v) => v.visitBottomType(this);
   visitChildren(Visitor v) {}
 
   bool operator ==(Object other) => other is BottomType;
 }
 
 class InterfaceType extends DartType {
-  final Class classNode;
+  final LinkedNodeBox className;
   final List<DartType> typeArguments;
 
   /// The [typeArguments] list must not be modified after this call. If the
   /// list is omitted, 'dynamic' type arguments are filled in.
   InterfaceType(Class classNode, [List<DartType> typeArguments])
-      : this.classNode = classNode,
-        this.typeArguments = typeArguments ?? _defaultTypeArguments(classNode);
+      : this.byBox(getBoxOfClass(classNode),
+            typeArguments ?? _defaultTypeArguments(classNode));
+
+  InterfaceType.byBox(this.className, this.typeArguments);
+
+  Class get classNode => className.asClass;
 
   static List<DartType> _defaultTypeArguments(Class classNode) {
     if (classNode.typeParameters.length == 0) {
       // Avoid allocating a list in this very common case.
       return const <DartType>[];
     } else {
       return new List<DartType>.filled(
           classNode.typeParameters.length, const DynamicType());
     }
   }
 
   accept(DartTypeVisitor v) => v.visitInterfaceType(this);
 
   visitChildren(Visitor v) {
     classNode.acceptReference(v);
     visitList(typeArguments, v);
   }
 
   bool operator ==(Object other) {
     if (identical(this, other)) return true;
     if (other is InterfaceType) {
-      if (classNode != other.classNode) return false;
+      if (className != other.className) return false;
       if (typeArguments.length != other.typeArguments.length) return false;
       for (int i = 0; i < typeArguments.length; ++i) {
         if (typeArguments[i] != other.typeArguments[i]) return false;
       }
       return true;
     } else {
       return false;
     }
   }
 
   int get hashCode {
-    int hash = 0x3fffffff & classNode.hashCode;
+    int hash = 0x3fffffff & className.hashCode;
     for (int i = 0; i < typeArguments.length; ++i) {
       hash = 0x3fffffff & (hash * 31 + (hash ^ typeArguments[i].hashCode));
     }
     return hash;
   }
 }
 
 /// A possibly generic function type.
 class FunctionType extends DartType {
   final List<TypeParameter> typeParameters;
@@ skipping 167 matching lines @@
   transformChildren(Transformer v) {
     bound = v.visitDartType(bound);
   }
 
   /// Returns a possibly synthesized name for this type parameter, consistent
   /// with the names used across all [toString] calls.
   String toString() => debugQualifiedTypeParameterName(this);
 }
 
 class Supertype extends Node {
-  final Class classNode;
+  final LinkedNodeBox className;
   final List<DartType> typeArguments;
 
-  Supertype(this.classNode, this.typeArguments);
+  Supertype(Class classNode, List<DartType> typeArguments)
+      : this.byBox(getBoxOfClass(classNode), typeArguments);
+
+  Supertype.byBox(this.className, this.typeArguments);
+
+  Class get classNode => className.asClass;
 
   accept(Visitor v) => v.visitSupertype(this);
 
   visitChildren(Visitor v) {
     classNode.acceptReference(v);
     visitList(typeArguments, v);
   }
 
   InterfaceType get asInterfaceType {
     return new InterfaceType(classNode, typeArguments);
   }
 
   bool operator ==(Object other) {
     if (identical(this, other)) return true;
     if (other is Supertype) {
-      if (classNode != other.classNode) return false;
+      if (className != other.className) return false;
       if (typeArguments.length != other.typeArguments.length) return false;
       for (int i = 0; i < typeArguments.length; ++i) {
         if (typeArguments[i] != other.typeArguments[i]) return false;
       }
       return true;
     } else {
       return false;
     }
   }
 
   int get hashCode {
-    int hash = 0x3fffffff & classNode.hashCode;
+    int hash = 0x3fffffff & className.hashCode;
     for (int i = 0; i < typeArguments.length; ++i) {
       hash = 0x3fffffff & (hash * 31 + (hash ^ typeArguments[i].hashCode));
     }
     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 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.
-  Procedure mainMethod;
+  LinkedNodeBox mainMethodName;
 
   Program([List<Library> libraries, Map<String, Source> uriToSource])
       : libraries = libraries ?? <Library>[],
         uriToSource = uriToSource ?? <String, Source>{} {
-    setParents(libraries, this);
+    setParents(this.libraries, this);
+  }
+
+  void computeCanonicalNames() {
+    for (var library in libraries) {
+      root.getChildFromUri(library.importUri).bindTo(library.box);
+      library.computeCanonicalNames();
+    }
+  }
+
+  void unbindCanonicalNames() {
+    root.unbindAll();
+  }
+
+  Procedure get mainMethod => mainMethodName?.asProcedure;
+
+  void set mainMethod(Procedure main) {
+    mainMethodName = getBoxOfMember(main);
   }
 
   accept(TreeVisitor v) => v.visitProgram(this);
 
   visitChildren(Visitor v) {
     visitList(libraries, v);
     mainMethod?.acceptReference(v);
   }
 
   transformChildren(Transformer v) {
@@ skipping 122 matching lines @@
     }
   }
 }
 
 class Source {
   final List<int> lineStarts;
   final String source;
 
   Source(this.lineStarts, this.source);
 }
+
+/// Returns the canonical name of [member], or throws an exception if the
+/// member has not been assigned a canonical name yet.
+///
+/// Returns `null` if the member is `null`.
+LinkedNodeBox getBoxOfMember(Member member) {
+  return member?.box;
+}
+
+/// Returns the canonical name of [class_], or throws an exception if the
+/// class has not been assigned a canonical name yet.
+///
+/// Returns `null` if the class is `null`.
+LinkedNodeBox getBoxOfClass(Class class_) {
+  return class_?.box;
+}
+
+/// Returns the canonical name of [library], or throws an exception if the
+/// library has not been assigned a canonical name yet.
+///
+/// Returns `null` if the library is `null`.
+LinkedNodeBox getBoxOfLibrary(Library library) {
+  return library?.box;
+}
+
+/// Returns the canonical name of [member], or throws an exception if the
+/// member has not been assigned a canonical name yet.
+///
+/// Returns `null` if the member is `null`.
+CanonicalName getCanonicalNameOfMember(Member member) {
+  if (member == null) return null;
+  if (member.canonicalName == null) {
+    throw '$member has no canonical name';
+  }
+  return member.canonicalName;
+}
+
+/// Returns the canonical name of [class_], or throws an exception if the
+/// class has not been assigned a canonical name yet.
+///
+/// Returns `null` if the class is `null`.
+CanonicalName getCanonicalNameOfClass(Class class_) {
+  if (class_ == null) return null;
+  if (class_.canonicalName == null) {
+    throw '$class_ has no canonical name';
+  }
+  return class_.canonicalName;
+}
+
+/// Returns the canonical name of [library], or throws an exception if the
+/// library has not been assigned a canonical name yet.
+///
+/// Returns `null` if the library is `null`.
+CanonicalName getCanonicalNameOfLibrary(Library library) {
+  if (library == null) return null;
+  if (library.canonicalName == null) {
+    throw '$library has no canonical name';
+  }
+  return library.canonicalName;
+}