anchor.diff:                      constructorB22, new Arguments.empty()),
                 ]),
           ]));
  +    nodeToNameMap[classB2] = 'B2';
  +    nodeToNameMap[constructorB12] = 'B12';
  +    nodeToNameMap[constructorB22] = 'B22';
   
       var outline1 = _newOutline([library1]);
       var outline2 = _newOutline([library2]);
       var outline3 = _newOutline([library3]);
   
  +    expect(_getLibraryText(library1, nodeToNameMap), r'''
  +class A[A1] {
  +  constructor a1[A11]();
  +}
  +''');
  +    expect(_getLibraryText(library2, nodeToNameMap), r'''
  +class A[A2] {
  +  constructor a1[A12]();
  +  constructor a2[A22]();
  +}
  +class B[B1] {
  +  constructor b1[B11]();
  +}
  +class S1 {
  +  constructor c1() :
  +      super[A12](),
  +      super[A22]();
  +  constructor c2() :
  +      redirect[A12](),
  +      redirect[A22]();
  +}
  +main2() {
  +  ConstructorInvocation[A12]();
  +  ConstructorInvocation[A22]();
  +}
  +''');
  +    expect(_getLibraryText(library3, nodeToNameMap), r'''
  +class B[B2] {
  +  constructor b1[B12]();
  +  constructor b2[B22]();
  +}
  +class S2 {
  +  constructor c1() :
  +      super[B12](),
  +      super[B22]();
  +  constructor c2() :
  +      redirect[B12](),
  +      redirect[B22]();
  +}
  +main3() {
  +  ConstructorInvocation[B12]();
  +  ConstructorInvocation[B22]();
  +}
  +''');
  +
       _runCombineTest([outline1, outline2, outline3], (result) {
         var library = _getLibrary(result.program, 'test');
  -
  -      var classA = _getClass(library, 'A');
  -      expect(_getConstructor(classA, 'a1'), same(constructorA11));
  -      expect(_getConstructor(classA, 'a2'), same(constructorA22));
  -
  -      // main2() is updated to point to "A.a1" from library1.
  -      // But "A.a2" is still from library2.
  -      var main2 = _getProcedure(library, 'main2', '@methods');
  -      expect(
  -          (_getProcedureExpression(main2, 0) as ConstructorInvocation).target,
  -          same(constructorA11));
  -      expect(
  -          (_getProcedureExpression(main2, 1) as ConstructorInvocation).target,
  -          same(constructorA22));
  -
  -      // Super invocations are updated.
  -      var classS1 = _getClass(library, 'S1');
  -      var constructorS1c1 = classS1.constructors[0];
  -      expect((constructorS1c1.initializers[0] as SuperInitializer).target,
  -          same(constructorA11));
  -      expect((constructorS1c1.initializers[1] as SuperInitializer).target,
  -          same(constructorA22));
  -      var constructorS1c2 = classS1.constructors[1];
  -      expect((constructorS1c2.initializers[0] as RedirectingInitializer).target,
  -          same(constructorA11));
  -      expect((constructorS1c2.initializers[1] as RedirectingInitializer).target,
  -          same(constructorA22));
  -
  -      var classB = _getClass(library, 'B');
  -      expect(_getConstructor(classB, 'b1'), same(constructorB11));
  -      expect(_getConstructor(classB, 'b2'), same(constructorB22));
  -
  -      // main3() is updated to point to "B.b1" from library2.
  -      var main3 = _getProcedure(library, 'main3', '@methods');
  -      expect(
  -          (_getProcedureExpression(main3, 0) as ConstructorInvocation).target,
  -          same(constructorB11));
  -      expect(
  -          (_getProcedureExpression(main3, 1) as ConstructorInvocation).target,
  -          same(constructorB22));
  -
  -      // Super invocations are updated.
  -      var classS2 = _getClass(library, 'S2');
  -      var constructorS2c1 = classS2.constructors[0];
  -      expect((constructorS2c1.initializers[0] as SuperInitializer).target,
  -          same(constructorB11));
  -      expect((constructorS2c1.initializers[1] as SuperInitializer).target,
  -          same(constructorB22));
  -      var constructorS2c2 = classS2.constructors[1];
  -      expect((constructorS2c2.initializers[0] as RedirectingInitializer).target,
  -          same(constructorB11));
  -      expect((constructorS2c2.initializers[1] as RedirectingInitializer).target,
  -          same(constructorB22));
  +      expect(_getLibraryText(library, nodeToNameMap), r'''
  +class A[A1] {
  +  constructor a1[A11]();
  +  constructor a2[A22]();
  +}
  +class B[B1] {
  +  constructor b1[B11]();
  +  constructor b2[B22]();
  +}
  +class S1 {
  +  constructor c1() :
  +      super[A11](),
  +      super[A22]();
  +  constructor c2() :
  +      redirect[A11](),
  +      redirect[A22]();
  +}
  +class S2 {
  +  constructor c1() :
  +      super[B11](),
  +      super[B22]();
  +  constructor c2() :
  +      redirect[B11](),
  +      redirect[B22]();
  +}
  +main2() {
  +  ConstructorInvocation[A11]();
  +  ConstructorInvocation[A22]();
  +}
  +main3() {
  +  ConstructorInvocation[B11]();
  +  ConstructorInvocation[B22]();
  +}
  +''');
       });
     }
   
  
positive.code:       state.verifySame();
      });
    }
  }
  
  /// The original state of an outline, and code that validates that after some
  
negative.code:         supertype: objectSuper,
          constructors: [constructorA12, constructorA22]);
      library2.addClass(classA2);
      var classB1 = new Class(
          name: 'B', supertype: objectSuper, constructors: [constructorB11]);
      library2.addClass(classB1);
      // Use 'A.a1' and 'A.a2' to validate later how they are rewritten.
      library2.addProcedure(_newExpressionsProcedure([
        new ConstructorInvocation(constructorA12, new Arguments.empty()),
  