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 has an associated [CanonicalName], allowing it to be
+/// referenced by name. Libraries, classes, and members are linked nodes.
+///
+/// When created, a linked node has no associated canonical name, and must be
+/// linked to such a name before it can be referenced.  A canonical name is
+/// typically assigned by either:
+/// - Adding it to the a class or library using `addMember` or `addClass`.
+/// - Explicitly assigning a name using [CanonicalName.bindTo].
+abstract class LinkedNode extends TreeNode {
+  CanonicalName canonicalName;
+}
+
 // ------------------------------------------------------------------------
 //                      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 28 matching lines @@
   }
 
   /// 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) {
+    if (member.canonicalName == null || !member.canonicalName.isDummy) {
+      // This should not run from the dart2js/rasta adaptor.
+      getCanonicalNameOfLibrary(this).getChildFromMember(member).bindTo(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_) {
+    if (class_.canonicalName == null || !class_.canonicalName.isDummy) {
+      // This should not run from the dart2js/rasta adaptor.
+      getCanonicalNameOfLibrary(this).getChild(class_.name).bindTo(class_);
+    }
     class_.parent = this;
     classes.add(class_);
   }
 
   accept(TreeVisitor v) => v.visitLibrary(this);
 
   visitChildren(Visitor v) {
     visitList(classes, v);
     visitList(procedures, v);
     visitList(fields, v);
@@ skipping 53 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 87 matching lines @@
       ].expand((x) => x);
 
   /// The library containing this class.
   Library get enclosingLibrary => parent;
 
   /// Adds a member to this class.
   ///
   /// Throws an error if attempting to add a field or procedure to a mixin
   /// application.
   void addMember(Member member) {
+    if (member.canonicalName == null || !member.canonicalName.isDummy) {
+      // This should not run from the dart2js/rasta adaptor.
+      getCanonicalNameOfClass(this).getChildFromMember(member).bindTo(member);
+    }
     member.parent = this;
     if (member is Constructor) {
       constructors.add(member);
     } else if (member is Procedure) {
       procedures.add(member);
     } else if (member is Field) {
       fields.add(member);
     } else {
       throw new ArgumentError(member);
     }
@@ skipping 73 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>[];
@@ skipping 67 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);
     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
@@ skipping 54 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);
     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;
+  CanonicalName fieldName;
   Expression value;
 
-  FieldInitializer(this.field, this.value) {
+  FieldInitializer(Field field, Expression value)
+      : this.byName(getCanonicalNameOfMember(field), value);
+
+  FieldInitializer.byName(this.fieldName, this.value) {
     value?.parent = this;
   }
 
+  Field get field => fieldName?.asField;
+
+  void set field(Field field) {
+    fieldName = getCanonicalNameOfMember(field);
+  }
+
   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;
+  CanonicalName targetName;
   Arguments arguments;
 
-  SuperInitializer(this.target, this.arguments) {
+  SuperInitializer(Constructor target, Arguments arguments)
+      : this.byName(getCanonicalNameOfMember(target), arguments);
+
+  SuperInitializer.byName(this.targetName, this.arguments) {
     arguments?.parent = this;
   }
 
+  Constructor get target => targetName?.asConstructor;
+
+  void set target(Constructor target) {
+    targetName = getCanonicalNameOfMember(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;
+  CanonicalName targetName;
   Arguments arguments;
 
-  RedirectingInitializer(this.target, this.arguments) {
+  RedirectingInitializer(Constructor target, Arguments arguments)
+      : this.byName(getCanonicalNameOfMember(target), arguments);
+
+  RedirectingInitializer.byName(this.targetName, this.arguments) {
     arguments?.parent = this;
   }
 
+  Constructor get target => targetName?.asConstructor;
+
+  void set target(Constructor target) {
+    targetName = getCanonicalNameOfMember(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;
+  CanonicalName interfaceTargetName;
 
-  PropertyGet(this.receiver, this.name, [Member interfaceTarget]) {
+  PropertyGet(Expression receiver, Name name, [Member interfaceTarget])
+      : this.byName(receiver, name, getCanonicalNameOfMember(interfaceTarget));
+
+  PropertyGet.byName(this.receiver, this.name, this.interfaceTargetName) {
     receiver?.parent = this;
-    this.interfaceTarget = interfaceTarget;
   }
 
-  Member get interfaceTarget => _interfaceTargetReference?.target;
+  Member get interfaceTarget => interfaceTargetName?.asMember;
 
-  void set interfaceTarget(Member newTarget) {
-    _interfaceTargetReference = newTarget?._getterInterface;
+  void set interfaceTarget(Member member) {
+    interfaceTargetName = getCanonicalNameOfMember(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;
+  CanonicalName interfaceTargetName;
 
-  PropertySet(this.receiver, this.name, this.value, [Member interfaceTarget]) {
+  PropertySet(Expression receiver, Name name, Expression value,
+      [Member interfaceTarget])
+      : this.byName(
+            receiver, name, value, getCanonicalNameOfMember(interfaceTarget));
+
+  PropertySet.byName(
+      this.receiver, this.name, this.value, this.interfaceTargetName) {
     receiver?.parent = this;
     value?.parent = this;
-    this.interfaceTarget = interfaceTarget;
   }
 
-  Member get interfaceTarget => _interfaceTargetReference?.target;
+  Member get interfaceTarget => interfaceTargetName?.asMember;
 
-  void set interfaceTarget(Member newTarget) {
-    _interfaceTargetReference = newTarget?._setterInterface;
+  void set interfaceTarget(Member member) {
+    interfaceTargetName = getCanonicalNameOfMember(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;
+  CanonicalName targetName;
 
-  DirectPropertyGet(this.receiver, this.target) {
+  DirectPropertyGet(Expression receiver, Member target)
+      : this.byName(receiver, getCanonicalNameOfMember(target));
+
+  DirectPropertyGet.byName(this.receiver, this.targetName) {
     receiver?.parent = this;
   }
 
+  Member get target => targetName?.asMember;
+
+  void set target(Member target) {
+    targetName = getCanonicalNameOfMember(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;
+  CanonicalName targetName;
   Expression value;
 
-  DirectPropertySet(this.receiver, this.target, this.value) {
+  DirectPropertySet(Expression receiver, Member target, Expression value)
+      : this.byName(receiver, getCanonicalNameOfMember(target), value);
+
+  DirectPropertySet.byName(this.receiver, this.targetName, this.value) {
     receiver?.parent = this;
     value?.parent = this;
   }
 
+  Member get target => targetName?.asMember;
+
+  void set target(Member target) {
+    targetName = getCanonicalNameOfMember(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 Expression {
   Expression receiver;
-  Procedure target;
+  CanonicalName targetName;
   Arguments arguments;
 
-  DirectMethodInvocation(this.receiver, this.target, this.arguments) {
+  DirectMethodInvocation(
+      Expression receiver, Procedure target, Arguments arguments)
+      : this.byName(receiver, getCanonicalNameOfMember(target), arguments);
+
+  DirectMethodInvocation.byName(
+      this.receiver, this.targetName, this.arguments) {
     receiver?.parent = this;
     arguments?.parent = this;
   }
 
+  Procedure get target => targetName?.asProcedure;
+
+  void set target(Procedure target) {
+    targetName = getCanonicalNameOfMember(target);
+  }
+
   visitChildren(Visitor v) {
     receiver?.accept(v);
     target?.acceptReference(v);
     arguments?.accept(v);
   }
 
   transformChildren(Transformer v) {
     if (receiver != null) {
       receiver = receiver.accept(v);
       receiver?.parent = this;
@@ skipping 20 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;
+  CanonicalName interfaceTargetName;
 
-  SuperPropertyGet(this.name, [Member interfaceTarget]) {
-    _interfaceTargetReference = interfaceTarget?._getterInterface;
-  }
+  SuperPropertyGet(Name name, [Member interfaceTarget])
+      : this.byName(name, getCanonicalNameOfMember(interfaceTarget));
 
-  Member get interfaceTarget => _interfaceTargetReference?.target;
+  SuperPropertyGet.byName(this.name, this.interfaceTargetName);
 
-  void set interfaceTarget(Member newTarget) {
-    _interfaceTargetReference = newTarget?._getterInterface;
+  Member get interfaceTarget => interfaceTargetName?.asMember;
+
+  void set interfaceTarget(Member member) {
+    interfaceTargetName = getCanonicalNameOfMember(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;
+  CanonicalName interfaceTargetName;
 
-  SuperPropertySet(this.name, this.value, [Member interfaceTarget]) {
+  SuperPropertySet(Name name, Expression value, Member interfaceTarget)
+      : this.byName(name, value, getCanonicalNameOfMember(interfaceTarget));
+
+  SuperPropertySet.byName(this.name, this.value, this.interfaceTargetName) {
     value?.parent = this;
-    _interfaceTargetReference = interfaceTarget?._setterInterface;
   }
 
-  Member get interfaceTarget => _interfaceTargetReference?.target;
+  Member get interfaceTarget => interfaceTargetName?.asMember;
 
-  void set interfaceTarget(Member newTarget) {
-    _interfaceTargetReference = newTarget?._setterInterface;
+  void set interfaceTarget(Member member) {
+    interfaceTargetName = getCanonicalNameOfMember(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;
+  CanonicalName targetName;
 
-  StaticGet(this.target);
+  StaticGet(Member target) : this.byName(getCanonicalNameOfMember(target));
+
+  StaticGet.byName(this.targetName);
+
+  Member get target => targetName?.asMember;
+
+  void set target(Member target) {
+    targetName = getCanonicalNameOfMember(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;
+  CanonicalName targetName;
   Expression value;
 
-  StaticSet(this.target, this.value) {
+  StaticSet(Member target, Expression value)
+      : this.byName(getCanonicalNameOfMember(target), value);
+
+  StaticSet.byName(this.targetName, this.value) {
     value?.parent = this;
   }
 
+  Member get target => targetName?.asMember;
+
+  void set target(Member target) {
+    targetName = getCanonicalNameOfMember(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;
+  CanonicalName interfaceTargetName;
 
-  MethodInvocation(this.receiver, this.name, this.arguments,
-      [this.interfaceTarget]) {
+  MethodInvocation(Expression receiver, Name name, Arguments arguments,
+      [Procedure interfaceTarget])
+      : this.byName(receiver, name, arguments,
+            getCanonicalNameOfMember(interfaceTarget));
+
+  MethodInvocation.byName(
+      this.receiver, this.name, this.arguments, this.interfaceTargetName) {
     receiver?.parent = this;
     arguments?.parent = this;
   }
 
+  Procedure get interfaceTarget => interfaceTargetName?.asProcedure;
+
+  void set interfaceTarget(Member target) {
+    interfaceTargetName = getCanonicalNameOfMember(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;
 
-  Member interfaceTarget;
+  CanonicalName interfaceTargetName;
 
-  SuperMethodInvocation(this.name, this.arguments, this.interfaceTarget) {
+  SuperMethodInvocation(Name name, Arguments arguments,
+      [Procedure interfaceTarget])
+      : this.byName(name, arguments, getCanonicalNameOfMember(interfaceTarget));
+
+  SuperMethodInvocation.byName(
+      this.name, this.arguments, this.interfaceTargetName) {
     arguments?.parent = this;
   }
 
+  Procedure get interfaceTarget => interfaceTargetName?.asProcedure;
+
+  void set interfaceTarget(Procedure target) {
+    interfaceTargetName = getCanonicalNameOfMember(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;
+  CanonicalName targetName;
   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.byName(getCanonicalNameOfMember(target), arguments,
+            isConst: isConst);
+
+  StaticInvocation.byName(this.targetName, this.arguments,
+      {this.isConst: false}) {
     arguments?.parent = this;
   }
 
+  Procedure get target => targetName?.asProcedure;
+
+  void set target(Procedure target) {
+    targetName = getCanonicalNameOfMember(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;
+  CanonicalName targetName;
   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.byName(getCanonicalNameOfMember(target), arguments,
+            isConst: isConst);
+
+  ConstructorInvocation.byName(this.targetName, this.arguments,
+      {this.isConst: false}) {
     arguments?.parent = this;
   }
 
+  Constructor get target => targetName?.asConstructor;
+
+  void set target(Constructor target) {
+    targetName = getCanonicalNameOfMember(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 1181 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;
+  CanonicalName 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?.canonicalName);
+
+  factory Name.byReference(String name, CanonicalName 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 CanonicalName libraryName;
   bool get isPrivate => true;
 
-  _PrivateName(String name, Library library)
-      : this.library = library,
-        super._internal(_computeHashCode(name, library), name);
+  _PrivateName(String name, CanonicalName 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, CanonicalName libraryName) {
+    return 131 * name.hashCode + 17 * libraryName.hashCode;
   }
 }
 
 class _PublicName extends Name {
+  CanonicalName 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 CanonicalName 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.byName(getCanonicalNameOfClass(classNode),
+            typeArguments ?? _defaultTypeArguments(classNode));
+
+  InterfaceType.byName(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 CanonicalName className;
   final List<DartType> typeArguments;
 
-  Supertype(this.classNode, this.typeArguments);
+  Supertype(Class classNode, List<DartType> typeArguments)
+      : this.byName(getCanonicalNameOfClass(classNode), typeArguments);
+
+  Supertype.byName(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;
+  CanonicalName mainMethodName;
 
   Program([List<Library> libraries, Map<String, Source> uriToSource])
       : libraries = libraries ?? <Library>[],
         uriToSource = uriToSource ?? <String, Source>{} {
-    setParents(libraries, this);
+    setParents(this.libraries, this);
+  }
+
+  Procedure get mainMethod => mainMethodName?.asProcedure;
+
+  void set mainMethod(Procedure main) {
+    mainMethodName = getCanonicalNameOfMember(main);
   }
 
   accept(TreeVisitor v) => v.visitProgram(this);
 
   visitChildren(Visitor v) {
     visitList(libraries, v);
     mainMethod?.acceptReference(v);
   }
 
   transformChildren(Transformer v) {
@@ skipping 14 matching lines @@
       } else {
         high = mid - 1;
       }
     }
     int lineIndex = low;
     int lineStart = lines[lineIndex];
     int lineNumber = 1 + lineIndex;
     int columnNumber = 1 + offset - lineStart;
     return new Location(file, lineNumber, columnNumber);
   }
+
+  Library getLibraryReference(Uri uri) {
+    assert(uri.hasScheme);
+    var canonicalName = root.getChildFromUri(uri);
+    Library library;
+    if (canonicalName.definition == null) {
+      library = new Library(uri, isExternal: true);
+      canonicalName.bindTo(library);
+      libraries.add(library..parent = this);
+    } else {
+      library = canonicalName.definition;
+    }
+    return library;
+  }
 }
 
 /// A tuple with file, line, and column number, for displaying human-readable
 /// locations.
 class Location {
   final String file;
   final int line; // 1-based.
   final int column; // 1-based.
 
   Location(this.file, this.line, this.column);
@@ skipping 88 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`.
+CanonicalName getCanonicalNameOfMember(Member member) {
+  if (member == null) {
+    return null;
+  }
+  var name = member.canonicalName;
+  if (name == null) {
+    throw '$member has no canonical name. '
+        'It must be added to a class or library before it can be referenced.';
+  }
+  return name;
+}
+
+/// 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;
+  }
+  var name = class_.canonicalName;
+  if (name == null) {
+    throw '$class_ has no canonical name. '
+        'It must be added to a library before it can be referenced.';
+  }
+  return name;
+}
+
+/// 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;
+  }
+  var name = library.canonicalName;
+  if (name == null) {
+    throw '$library has no canonical name. '
+        'It must be added to a program before it can be referenced.';
+  }
+  return name;
+}