// Copyright (c) 2017, 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.

import 'package:front_end/src/incremental/combine.dart';
import 'package:kernel/ast.dart';
import 'package:kernel/core_types.dart';
import 'package:kernel/testing/mock_sdk_program.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';

main() {
  defineReflectiveSuite(() {
    defineReflectiveTests(CombineTest);
  });
}

@reflectiveTest
class CombineTest {
  Program sdk;
  CoreTypes coreTypes;

  Supertype get objectSuper => coreTypes.objectClass.asThisSupertype;

  void setUp() {
    sdk = createMockSdkProgram();
    coreTypes = new CoreTypes(sdk);
  }

  void test_class_mergeLibrary_appendClass() {
    var libraryA1 = _newLibrary('a');
    libraryA1.addClass(new Class(name: 'A', supertype: objectSuper));

    var libraryA2 = _newLibrary('a');
    libraryA2.addClass(new Class(name: 'B', supertype: objectSuper));

    var outline1 = _newOutline([libraryA1]);
    var outline2 = _newOutline([libraryA2]);

    _runCombineTest([outline1, outline2], (result) {
      var libraryA = _getLibrary(result.program, 'a');

      var classA = _getClass(libraryA, 'A');
      expect(classA.members, isEmpty);

      var classB = _getClass(libraryA, 'B');
      expect(classB.members, isEmpty);
    });
  }

  /// We test two cases of class declarations:
  ///   * When a class to merge is first time declared in the first library;
  ///   * When a class to merge is first time declared in the second library.
  ///
  /// With two cases of constructor declarations:
  ///   * Already defined, so references to it should be rewritten.
  ///   * First defined in this outline, so references to it can be kept as is.
  ///
  /// For each case we validate [DirectMethodInvocation], [MethodInvocation],
  /// and [SuperMethodInvocation].
  void test_class_procedure_constructor() {
    var nodeToNameMap = <NamedNode, String>{};

    var library1 = _newLibrary('test');
    var constructorA11 = _newConstructor('a1');
    var classA1 = new Class(
        name: 'A', supertype: objectSuper, constructors: [constructorA11]);
    library1.addClass(classA1);
    nodeToNameMap[classA1] = 'A1';
    nodeToNameMap[constructorA11] = 'A11';

    var library2 = _newLibrary('test');
    var constructorA12 = _newConstructor('a1');
    var constructorA22 = _newConstructor('a2');
    var constructorB11 = _newConstructor('b1');
    var classA2 = new Class(
        name: 'A',
        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()),
      new ConstructorInvocation(constructorA22, new Arguments.empty()),
    ], name: 'main2'));
    library2.addClass(new Class(
        name: 'S1',
        supertype: classA2.asThisSupertype,
        constructors: [
          new Constructor(new FunctionNode(new EmptyStatement()),
              name: new Name('c1'),
              initializers: [
                new SuperInitializer(constructorA12, new Arguments.empty()),
                new SuperInitializer(constructorA22, new Arguments.empty()),
              ]),
          new Constructor(new FunctionNode(new EmptyStatement()),
              name: new Name('c2'),
              initializers: [
                new RedirectingInitializer(
                    constructorA12, new Arguments.empty()),
                new RedirectingInitializer(
                    constructorA22, new Arguments.empty()),
              ]),
        ]));
    nodeToNameMap[classA2] = 'A2';
    nodeToNameMap[constructorA12] = 'A12';
    nodeToNameMap[constructorA22] = 'A22';
    nodeToNameMap[constructorB11] = 'B11';
    nodeToNameMap[classB1] = 'B1';
    nodeToNameMap[constructorB11] = 'B11';

    var library3 = _newLibrary('test');
    var constructorB12 = _newConstructor('b1');
    var constructorB22 = _newConstructor('b2');
    var classB2 = new Class(
        name: 'B',
        supertype: objectSuper,
        constructors: [constructorB12, constructorB22]);
    library3.addClass(classB2);
    library3.addProcedure(_newExpressionsProcedure([
      new ConstructorInvocation(constructorB12, new Arguments.empty()),
      new ConstructorInvocation(constructorB22, new Arguments.empty()),
    ], name: 'main3'));
    library3.addClass(new Class(
        name: 'S2',
        supertype: classA2.asThisSupertype,
        constructors: [
          new Constructor(new FunctionNode(new EmptyStatement()),
              name: new Name('c1'),
              initializers: [
                new SuperInitializer(constructorB12, new Arguments.empty()),
                new SuperInitializer(constructorB22, new Arguments.empty()),
              ]),
          new Constructor(new FunctionNode(new EmptyStatement()),
              name: new Name('c2'),
              initializers: [
                new RedirectingInitializer(
                    constructorB12, new Arguments.empty()),
                new RedirectingInitializer(
                    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');
      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]();
}
''');
    });
  }

  /// We test two cases of class declarations:
  ///   * When a class to merge is first time declared in the first library;
  ///   * When a class to merge is first time declared in the second library.
  ///
  /// With two cases of field declarations:
  ///   * Already defined, so references to it should be rewritten.
  ///   * First defined in this outline, so references to it can be kept as is.
  ///
  /// For each case we validate [DirectMethodInvocation], [MethodInvocation],
  /// and [SuperMethodInvocation].
  void test_class_procedure_field() {
    var library1 = _newLibrary('test');
    var fieldA11 = _newField('a1');
    var classA1 =
        new Class(name: 'A', supertype: objectSuper, fields: [fieldA11]);
    library1.addClass(classA1);

    var library2 = _newLibrary('test');
    var fieldA12 = _newField('a1');
    var fieldA22 = _newField('a2');
    var fieldB11 = _newField('b1');
    var classA2 = new Class(
        name: 'A', supertype: objectSuper, fields: [fieldA12, fieldA22]);
    library2.addClass(classA2);
    library2.addClass(
        new Class(name: 'B', supertype: objectSuper, fields: [fieldB11]));
    // Use 'A.a1' and 'A.a2' to validate later how they are rewritten.
    library2.addProcedure(_newExpressionsProcedure([
      new DirectPropertyGet(null, fieldA12),
      new PropertyGet(null, null, fieldA12),
      new DirectPropertySet(null, fieldA12, null),
      new PropertySet(null, null, null, fieldA12),
      new DirectPropertyGet(null, fieldA22),
      new PropertyGet(null, null, fieldA22),
      new DirectPropertySet(null, fieldA22, null),
      new PropertySet(null, null, null, fieldA22),
    ], name: 'main2'));
    library2.addClass(
        new Class(name: 'S1', supertype: classA2.asThisSupertype, procedures: [
      _newExpressionsProcedure([
        new SuperPropertyGet(null, fieldA12),
        new SuperPropertySet(null, null, fieldA12),
        new SuperPropertyGet(null, fieldA22),
        new SuperPropertySet(null, null, fieldA22),
      ], name: 'foo')
    ]));

    var library3 = _newLibrary('test');
    var fieldB12 = _newField('b1');
    var fieldB22 = _newField('b2');
    library3.addClass(new Class(
        name: 'B', supertype: objectSuper, fields: [fieldB12, fieldB22]));
    library3.addProcedure(_newExpressionsProcedure([
      new DirectPropertyGet(null, fieldB12),
      new PropertyGet(null, null, fieldB12),
    ], name: 'main3'));
    library3.addClass(
        new Class(name: 'S2', supertype: classA2.asThisSupertype, procedures: [
      _newExpressionsProcedure([
        new SuperPropertyGet(null, fieldB12),
        new SuperPropertySet(null, null, fieldB12),
        new SuperPropertyGet(null, fieldB22),
        new SuperPropertySet(null, null, fieldB22),
      ], name: 'foo')
    ]));

    var outline1 = _newOutline([library1]);
    var outline2 = _newOutline([library2]);
    var outline3 = _newOutline([library3]);

    _runCombineTest([outline1, outline2, outline3], (result) {
      var library = _getLibrary(result.program, 'test');

      var classA = _getClass(library, 'A');
      expect(_getField(classA, 'a1'), same(fieldA11));
      expect(_getField(classA, 'a2'), same(fieldA22));

      // 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 DirectPropertyGet).target,
          same(fieldA11));
      expect((_getProcedureExpression(main2, 1) as PropertyGet).interfaceTarget,
          same(fieldA11));
      expect((_getProcedureExpression(main2, 2) as DirectPropertySet).target,
          same(fieldA11));
      expect((_getProcedureExpression(main2, 3) as PropertySet).interfaceTarget,
          same(fieldA11));

      // Super invocations are updated.
      var classS1 = _getClass(library, 'S1');
      var fooS1 = _getProcedure(classS1, 'foo', '@methods');
      expect(
          (_getProcedureExpression(fooS1, 0) as SuperPropertyGet)
              .interfaceTarget,
          same(fieldA11));
      expect(
          (_getProcedureExpression(fooS1, 1) as SuperPropertySet)
              .interfaceTarget,
          same(fieldA11));
      expect(
          (_getProcedureExpression(fooS1, 2) as SuperPropertyGet)
              .interfaceTarget,
          same(fieldA22));
      expect(
          (_getProcedureExpression(fooS1, 3) as SuperPropertySet)
              .interfaceTarget,
          same(fieldA22));

      var classB = _getClass(library, 'B');
      expect(_getField(classB, 'b1'), same(fieldB11));
      expect(_getField(classB, 'b2'), same(fieldB22));

      // main3() is updated to point to "B.b1" from library2.
      var main3 = _getProcedure(library, 'main3', '@methods');
      expect((_getProcedureExpression(main3, 0) as DirectPropertyGet).target,
          same(fieldB11));
      expect((_getProcedureExpression(main3, 1) as PropertyGet).interfaceTarget,
          same(fieldB11));

      // Super invocations are updated.
      var classS2 = _getClass(library, 'S2');
      var fooS2 = _getProcedure(classS2, 'foo', '@methods');
      expect(
          (_getProcedureExpression(fooS2, 0) as SuperPropertyGet)
              .interfaceTarget,
          same(fieldB11));
      expect(
          (_getProcedureExpression(fooS2, 1) as SuperPropertySet)
              .interfaceTarget,
          same(fieldB11));
      expect(
          (_getProcedureExpression(fooS2, 2) as SuperPropertyGet)
              .interfaceTarget,
          same(fieldB22));
      expect(
          (_getProcedureExpression(fooS2, 3) as SuperPropertySet)
              .interfaceTarget,
          same(fieldB22));
    });
  }

  /// We test two cases of class declarations:
  ///   * When a class to merge is first time declared in the first library;
  ///   * When a class to merge is first time declared in the second library.
  ///
  /// With two cases of setter declarations:
  ///   * Already defined, so references to it should be rewritten.
  ///   * First defined in this outline, so references to it can be kept as is.
  ///
  /// For each case we validate [DirectPropertyGet], [PropertyGet],
  /// and [SuperPropertyGet].
  void test_class_procedure_getter() {
    var library1 = _newLibrary('test');
    var procedureA11 = _newGetter('a1');
    var classA1 = new Class(
        name: 'A', supertype: objectSuper, procedures: [procedureA11]);
    library1.addClass(classA1);

    var library2 = _newLibrary('test');
    var procedureA12 = _newGetter('a1');
    var procedureA22 = _newGetter('a2');
    var procedureB11 = _newGetter('b1');
    var classA2 = new Class(
        name: 'A',
        supertype: objectSuper,
        procedures: [procedureA12, procedureA22]);
    library2.addClass(classA2);
    library2.addClass(new Class(
        name: 'B', supertype: objectSuper, procedures: [procedureB11]));
    // Use 'A.a1' and 'A.a2' to validate later how they are rewritten.
    library2.addProcedure(_newExpressionsProcedure([
      new DirectPropertyGet(null, procedureA12),
      new PropertyGet(null, null, procedureA12),
      new DirectPropertyGet(null, procedureA22),
      new PropertyGet(null, null, procedureA22),
    ], name: 'main2'));
    library2.addClass(
        new Class(name: 'S1', supertype: classA2.asThisSupertype, procedures: [
      _newExpressionsProcedure([
        new SuperPropertyGet(null, procedureA12),
        new SuperPropertyGet(null, procedureA22),
      ], name: 'foo')
    ]));

    var library3 = _newLibrary('test');
    var procedureB12 = _newGetter('b1');
    var procedureB22 = _newGetter('b2');
    library3.addClass(new Class(
        name: 'B',
        supertype: objectSuper,
        procedures: [procedureB12, procedureB22]));
    library3.addProcedure(_newExpressionsProcedure([
      new DirectPropertyGet(null, procedureB12),
      new PropertyGet(null, null, procedureB12),
    ], name: 'main3'));
    library3.addClass(
        new Class(name: 'S2', supertype: classA2.asThisSupertype, procedures: [
      _newExpressionsProcedure([
        new SuperPropertyGet(null, procedureB12),
        new SuperPropertyGet(null, procedureB22),
      ], name: 'foo')
    ]));

    var outline1 = _newOutline([library1]);
    var outline2 = _newOutline([library2]);
    var outline3 = _newOutline([library3]);

    _runCombineTest([outline1, outline2, outline3], (result) {
      var library = _getLibrary(result.program, 'test');

      var classA = _getClass(library, 'A');
      expect(_getProcedure(classA, 'a1', '@getters'), same(procedureA11));
      expect(_getProcedure(classA, 'a2', '@getters'), same(procedureA22));

      // 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 DirectPropertyGet).target,
          same(procedureA11));
      expect((_getProcedureExpression(main2, 1) as PropertyGet).interfaceTarget,
          same(procedureA11));
      expect((_getProcedureExpression(main2, 2) as DirectPropertyGet).target,
          same(procedureA22));
      expect((_getProcedureExpression(main2, 3) as PropertyGet).interfaceTarget,
          same(procedureA22));

      // Super invocations are updated.
      var classS1 = _getClass(library, 'S1');
      var fooS1 = _getProcedure(classS1, 'foo', '@methods');
      expect(
          (_getProcedureExpression(fooS1, 0) as SuperPropertyGet)
              .interfaceTarget,
          same(procedureA11));
      expect(
          (_getProcedureExpression(fooS1, 1) as SuperPropertyGet)
              .interfaceTarget,
          same(procedureA22));

      var classB = _getClass(library, 'B');
      expect(_getProcedure(classB, 'b1', '@getters'), same(procedureB11));
      expect(_getProcedure(classB, 'b2', '@getters'), same(procedureB22));

      // main3() is updated to point to "B.b1" from library2.
      var main3 = _getProcedure(library, 'main3', '@methods');
      expect((_getProcedureExpression(main3, 0) as DirectPropertyGet).target,
          same(procedureB11));
      expect((_getProcedureExpression(main3, 1) as PropertyGet).interfaceTarget,
          same(procedureB11));

      // Super invocations are updated.
      var classS2 = _getClass(library, 'S2');
      var fooS2 = _getProcedure(classS2, 'foo', '@methods');
      expect(
          (_getProcedureExpression(fooS2, 0) as SuperPropertyGet)
              .interfaceTarget,
          same(procedureB11));
      expect(
          (_getProcedureExpression(fooS2, 1) as SuperPropertyGet)
              .interfaceTarget,
          same(procedureB22));
    });
  }

  /// We test two cases of class declarations:
  ///   * When a class to merge is first time declared in the first library;
  ///   * When a class to merge is first time declared in the second library.
  ///
  /// With two cases of method declarations:
  ///   * Already defined, so references to it should be rewritten.
  ///   * First defined in this outline, so references to it can be kept as is.
  ///
  /// For each case we validate [DirectMethodInvocation], [MethodInvocation],
  /// and [SuperMethodInvocation].
  void test_class_procedure_method() {
    var library1 = _newLibrary('test');
    var procedureA11 = _newMethod('a1');
    var classA1 = new Class(
        name: 'A', supertype: objectSuper, procedures: [procedureA11]);
    library1.addClass(classA1);

    var library2 = _newLibrary('test');
    var procedureA12 = _newMethod('a1');
    var procedureA22 = _newMethod('a2');
    var procedureB11 = _newMethod('b1');
    var classA2 = new Class(
        name: 'A',
        supertype: objectSuper,
        procedures: [procedureA12, procedureA22]);
    library2.addClass(classA2);
    library2.addClass(new Class(
        name: 'B', supertype: objectSuper, procedures: [procedureB11]));
    // Use 'A.a1' and 'A.a2' to validate later how they are rewritten.
    library2.addProcedure(_newExpressionsProcedure([
      new DirectMethodInvocation(null, procedureA12, new Arguments.empty()),
      new MethodInvocation(null, null, new Arguments.empty(), procedureA12),
      new DirectMethodInvocation(null, procedureA22, new Arguments.empty()),
      new MethodInvocation(null, null, new Arguments.empty(), procedureA22),
    ], name: 'main2'));
    library2.addClass(
        new Class(name: 'S1', supertype: classA2.asThisSupertype, procedures: [
      _newExpressionsProcedure([
        new SuperMethodInvocation(null, null, procedureA12),
        new SuperMethodInvocation(null, null, procedureA22),
      ], name: 'foo')
    ]));

    var library3 = _newLibrary('test');
    var procedureB12 = _newMethod('b1');
    var procedureB22 = _newMethod('b2');
    library3.addClass(new Class(
        name: 'B',
        supertype: objectSuper,
        procedures: [procedureB12, procedureB22]));
    library3.addProcedure(_newExpressionsProcedure([
      new DirectMethodInvocation(null, procedureB12, new Arguments.empty()),
      new MethodInvocation(null, null, new Arguments.empty(), procedureB12),
    ], name: 'main3'));
    library3.addClass(
        new Class(name: 'S2', supertype: classA2.asThisSupertype, procedures: [
      _newExpressionsProcedure([
        new SuperMethodInvocation(null, null, procedureB12),
        new SuperMethodInvocation(null, null, procedureB22),
      ], name: 'foo')
    ]));

    var outline1 = _newOutline([library1]);
    var outline2 = _newOutline([library2]);
    var outline3 = _newOutline([library3]);

    _runCombineTest([outline1, outline2, outline3], (result) {
      var library = _getLibrary(result.program, 'test');

      var classA = _getClass(library, 'A');
      expect(_getProcedure(classA, 'a1', '@methods'), same(procedureA11));
      expect(_getProcedure(classA, 'a2', '@methods'), same(procedureA22));

      // 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 DirectMethodInvocation).target,
          same(procedureA11));
      expect(
          (_getProcedureExpression(main2, 1) as MethodInvocation)
              .interfaceTarget,
          same(procedureA11));
      expect(
          (_getProcedureExpression(main2, 2) as DirectMethodInvocation).target,
          same(procedureA22));
      expect(
          (_getProcedureExpression(main2, 3) as MethodInvocation)
              .interfaceTarget,
          same(procedureA22));

      // Super invocations are updated.
      var classS1 = _getClass(library, 'S1');
      var fooS1 = _getProcedure(classS1, 'foo', '@methods');
      expect(
          (_getProcedureExpression(fooS1, 0) as SuperMethodInvocation)
              .interfaceTarget,
          same(procedureA11));
      expect(
          (_getProcedureExpression(fooS1, 1) as SuperMethodInvocation)
              .interfaceTarget,
          same(procedureA22));

      var classB = _getClass(library, 'B');
      expect(_getProcedure(classB, 'b1', '@methods'), same(procedureB11));
      expect(_getProcedure(classB, 'b2', '@methods'), same(procedureB22));

      // main3() is updated to point to "B.b1" from library2.
      var main3 = _getProcedure(library, 'main3', '@methods');
      expect(
          (_getProcedureExpression(main3, 0) as DirectMethodInvocation).target,
          same(procedureB11));
      expect(
          (_getProcedureExpression(main3, 1) as MethodInvocation)
              .interfaceTarget,
          same(procedureB11));

      // Super invocations are updated.
      var classS2 = _getClass(library, 'S2');
      var fooS2 = _getProcedure(classS2, 'foo', '@methods');
      expect(
          (_getProcedureExpression(fooS2, 0) as SuperMethodInvocation)
              .interfaceTarget,
          same(procedureB11));
      expect(
          (_getProcedureExpression(fooS2, 1) as SuperMethodInvocation)
              .interfaceTarget,
          same(procedureB22));
    });
  }

  /// We test two cases of class declarations:
  ///   * When a class to merge is first time declared in the first library;
  ///   * When a class to merge is first time declared in the second library.
  ///
  /// With two cases of setter declarations:
  ///   * Already defined, so references to it should be rewritten.
  ///   * First defined in this outline, so references to it can be kept as is.
  ///
  /// For each case we validate [DirectPropertySet], [PropertySet],
  /// and [SuperPropertySet].
  void test_class_procedure_setter() {
    var library1 = _newLibrary('test');
    var procedureA11 = _newSetter('a1');
    var classA1 = new Class(
        name: 'A', supertype: objectSuper, procedures: [procedureA11]);
    library1.addClass(classA1);

    var library2 = _newLibrary('test');
    var procedureA12 = _newSetter('a1');
    var procedureA22 = _newSetter('a2');
    var procedureB11 = _newSetter('b1');
    var classA2 = new Class(
        name: 'A',
        supertype: objectSuper,
        procedures: [procedureA12, procedureA22]);
    library2.addClass(classA2);
    library2.addClass(new Class(
        name: 'B', supertype: objectSuper, procedures: [procedureB11]));
    // Use 'A.a1' and 'A.a2' to validate later how they are rewritten.
    library2.addProcedure(_newExpressionsProcedure([
      new DirectPropertySet(null, procedureA12, new IntLiteral(0)),
      new PropertySet(null, null, new IntLiteral(0), procedureA12),
      new DirectPropertySet(null, procedureA22, new IntLiteral(0)),
      new PropertySet(null, null, new IntLiteral(0), procedureA22),
    ], name: 'main2'));
    library2.addClass(
        new Class(name: 'S1', supertype: classA2.asThisSupertype, procedures: [
      _newExpressionsProcedure([
        new SuperPropertySet(null, new IntLiteral(0), procedureA12),
        new SuperPropertySet(null, new IntLiteral(0), procedureA22),
      ], name: 'foo')
    ]));

    var library3 = _newLibrary('test');
    var procedureB12 = _newSetter('b1');
    var procedureB22 = _newSetter('b2');
    library3.addClass(new Class(
        name: 'B',
        supertype: objectSuper,
        procedures: [procedureB12, procedureB22]));
    library3.addProcedure(_newExpressionsProcedure([
      new DirectPropertySet(null, procedureB12, new IntLiteral(0)),
      new PropertySet(null, null, new IntLiteral(0), procedureB12),
    ], name: 'main3'));
    library3.addClass(
        new Class(name: 'S2', supertype: classA2.asThisSupertype, procedures: [
      _newExpressionsProcedure([
        new SuperPropertySet(null, new IntLiteral(0), procedureB12),
        new SuperPropertySet(null, new IntLiteral(0), procedureB22),
      ], name: 'foo')
    ]));

    var outline1 = _newOutline([library1]);
    var outline2 = _newOutline([library2]);
    var outline3 = _newOutline([library3]);

    _runCombineTest([outline1, outline2, outline3], (result) {
      var library = _getLibrary(result.program, 'test');

      var classA = _getClass(library, 'A');
      expect(_getProcedure(classA, 'a1', '@setters'), same(procedureA11));
      expect(_getProcedure(classA, 'a2', '@setters'), same(procedureA22));

      // 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 DirectPropertySet).target,
          same(procedureA11));
      expect((_getProcedureExpression(main2, 1) as PropertySet).interfaceTarget,
          same(procedureA11));
      expect((_getProcedureExpression(main2, 2) as DirectPropertySet).target,
          same(procedureA22));
      expect((_getProcedureExpression(main2, 3) as PropertySet).interfaceTarget,
          same(procedureA22));

      // Super invocations are updated.
      var classS1 = _getClass(library, 'S1');
      var fooS1 = _getProcedure(classS1, 'foo', '@methods');
      expect(
          (_getProcedureExpression(fooS1, 0) as SuperPropertySet)
              .interfaceTarget,
          same(procedureA11));
      expect(
          (_getProcedureExpression(fooS1, 1) as SuperPropertySet)
              .interfaceTarget,
          same(procedureA22));

      var classB = _getClass(library, 'B');
      expect(_getProcedure(classB, 'b1', '@setters'), same(procedureB11));
      expect(_getProcedure(classB, 'b2', '@setters'), same(procedureB22));

      // main3() is updated to point to "B.b1" from library2.
      var main3 = _getProcedure(library, 'main3', '@methods');
      expect((_getProcedureExpression(main3, 0) as DirectPropertySet).target,
          same(procedureB11));
      expect((_getProcedureExpression(main3, 1) as PropertySet).interfaceTarget,
          same(procedureB11));

      // Super invocations are updated.
      var classS2 = _getClass(library, 'S2');
      var fooS2 = _getProcedure(classS2, 'foo', '@methods');
      expect(
          (_getProcedureExpression(fooS2, 0) as SuperPropertySet)
              .interfaceTarget,
          same(procedureB11));
      expect(
          (_getProcedureExpression(fooS2, 1) as SuperPropertySet)
              .interfaceTarget,
          same(procedureB22));
    });
  }

  void test_field() {
    var libraryA1 = _newLibrary('a');
    libraryA1.addField(_newField('A'));

    var libraryA2 = _newLibrary('a');
    libraryA2.addField(_newField('B'));

    var outline1 = _newOutline([libraryA1]);
    var outline2 = _newOutline([libraryA2]);

    _runCombineTest([outline1, outline2], (result) {
      var libraryA = _getLibrary(result.program, 'a');
      _getField(libraryA, 'A');
      _getField(libraryA, 'B');
    });
  }

  void test_field_skipDuplicate() {
    var libraryA1 = _newLibrary('a');
    libraryA1.addField(_newField('A'));
    libraryA1.addField(_newField('B'));

    var libraryA2 = _newLibrary('a');
    libraryA2.addField(_newField('A'));
    libraryA2.addField(_newField('C'));

    var outline1 = _newOutline([libraryA1]);
    var outline2 = _newOutline([libraryA2]);

    _runCombineTest([outline1, outline2], (result) {
      var libraryA = _getLibrary(result.program, 'a');
      _getField(libraryA, 'A');
      _getField(libraryA, 'B');
      _getField(libraryA, 'C');
    });
  }

  void test_field_updateReferences() {
    var libraryA1 = _newLibrary('a');
    var fieldA1A = _newField('A');
    libraryA1.addField(fieldA1A);

    var libraryA2 = _newLibrary('a');
    var fieldA2A = _newField('A');
    libraryA2.addField(fieldA2A);

    var libraryB = _newLibrary('b');
    libraryB.addProcedure(_newExpressionsProcedure([
      new StaticGet(fieldA2A),
      new StaticSet(fieldA2A, new IntLiteral(0)),
    ]));

    var outline1 = _newOutline([libraryA1]);
    var outline2 = _newOutline([libraryA2, libraryB]);

    _runCombineTest([outline1, outline2], (result) {
      var libraryA = _getLibrary(result.program, 'a');
      _getField(libraryA, 'A');

      var libraryB = _getLibrary(result.program, 'b');
      var main = _getProcedure(libraryB, 'main', '@methods');
      expect((_getProcedureExpression(main, 0) as StaticGet).targetReference,
          same(fieldA1A.reference));
      expect((_getProcedureExpression(main, 1) as StaticSet).targetReference,
          same(fieldA1A.reference));
    });
  }

  void test_library_replaceReference() {
    var libraryA1 = _newLibrary('a');

    var libraryA2 = _newLibrary('a');

    var libraryB = _newLibrary('b');
    libraryB.dependencies.add(new LibraryDependency.import(libraryA2));

    var outline1 = _newOutline([libraryA1]);
    var outline2 = _newOutline([libraryA2, libraryB]);

    _runCombineTest([outline1, outline2], (result) {
      var libraryA = _getLibrary(result.program, 'a');

      var libraryB = _getLibrary(result.program, 'b');
      expect(libraryB.dependencies, hasLength(1));
      expect(libraryB.dependencies[0].targetLibrary, libraryA);
    });
  }

  void test_procedure_getter() {
    var libraryA1 = _newLibrary('a');
    libraryA1.addProcedure(_newGetter('A'));

    var libraryA2 = _newLibrary('a');
    libraryA2.addProcedure(_newGetter('B'));

    var outline1 = _newOutline([libraryA1]);
    var outline2 = _newOutline([libraryA2]);

    _runCombineTest([outline1, outline2], (result) {
      var libraryA = _getLibrary(result.program, 'a');
      _getProcedure(libraryA, 'A', '@getters');
      _getProcedure(libraryA, 'B', '@getters');
    });
  }

  void test_procedure_getter_skipDuplicate() {
    var libraryA1 = _newLibrary('a');
    libraryA1.addProcedure(_newGetter('A'));
    libraryA1.addProcedure(_newGetter('B'));

    var libraryA2 = _newLibrary('a');
    libraryA2.addProcedure(_newGetter('A'));
    libraryA2.addProcedure(_newGetter('C'));

    var outline1 = _newOutline([libraryA1]);
    var outline2 = _newOutline([libraryA2]);

    _runCombineTest([outline1, outline2], (result) {
      var libraryA = _getLibrary(result.program, 'a');
      _getProcedure(libraryA, 'A', '@getters');
      _getProcedure(libraryA, 'B', '@getters');
      _getProcedure(libraryA, 'C', '@getters');
    });
  }

  void test_procedure_getter_updateReferences() {
    var libraryA1 = _newLibrary('a');
    var procedureA1A = _newGetter('A');
    libraryA1.addProcedure(procedureA1A);

    var libraryA2 = _newLibrary('a');
    var procedureA2A = _newGetter('A');
    libraryA2.addProcedure(procedureA2A);

    var libraryB = _newLibrary('b');
    libraryB.addProcedure(_newExpressionsProcedure([
      new StaticGet(procedureA2A),
    ]));

    var outline1 = _newOutline([libraryA1]);
    var outline2 = _newOutline([libraryA2, libraryB]);

    _runCombineTest([outline1, outline2], (result) {
      var libraryA = _getLibrary(result.program, 'a');
      _getProcedure(libraryA, 'A', '@getters');

      var libraryB = _getLibrary(result.program, 'b');
      var main = _getProcedure(libraryB, 'main', '@methods');
      expect((_getProcedureExpression(main, 0) as StaticGet).targetReference,
          same(procedureA1A.reference));
    });
  }

  void test_procedure_method() {
    var libraryA1 = _newLibrary('a');
    libraryA1.addProcedure(_newMethod('A'));

    var libraryA2 = _newLibrary('a');
    libraryA2.addProcedure(_newMethod('B'));

    var outline1 = _newOutline([libraryA1]);
    var outline2 = _newOutline([libraryA2]);

    _runCombineTest([outline1, outline2], (result) {
      var libraryA = _getLibrary(result.program, 'a');
      _getProcedure(libraryA, 'A', '@methods');
      _getProcedure(libraryA, 'B', '@methods');
    });
  }

  void test_procedure_method_skipDuplicate() {
    var libraryA1 = _newLibrary('a');
    libraryA1.addProcedure(_newMethod('A'));
    libraryA1.addProcedure(_newMethod('B'));

    var libraryA2 = _newLibrary('a');
    libraryA2.addProcedure(_newMethod('A'));
    libraryA2.addProcedure(_newMethod('C'));

    var outline1 = _newOutline([libraryA1]);
    var outline2 = _newOutline([libraryA2]);

    _runCombineTest([outline1, outline2], (result) {
      var libraryA = _getLibrary(result.program, 'a');
      _getProcedure(libraryA, 'A', '@methods');
      _getProcedure(libraryA, 'B', '@methods');
      _getProcedure(libraryA, 'C', '@methods');
    });
  }

  void test_procedure_method_updateReferences() {
    var libraryA1 = _newLibrary('a');
    var procedureA1A = _newMethod('A');
    libraryA1.addProcedure(procedureA1A);

    var libraryA2 = _newLibrary('a');
    var procedureA2A = _newMethod('A');
    libraryA2.addProcedure(procedureA2A);

    var libraryB = _newLibrary('b');
    libraryB.addProcedure(_newExpressionsProcedure([
      new StaticInvocation(procedureA2A, new Arguments.empty()),
    ]));

    var outline1 = _newOutline([libraryA1]);
    var outline2 = _newOutline([libraryA2, libraryB]);

    _runCombineTest([outline1, outline2], (result) {
      var libraryA = _getLibrary(result.program, 'a');
      _getProcedure(libraryA, 'A', '@methods');

      var libraryB = _getLibrary(result.program, 'b');
      var main = _getProcedure(libraryB, 'main', '@methods');
      expect(
          (_getProcedureExpression(main, 0) as StaticInvocation)
              .targetReference,
          same(procedureA1A.reference));
    });
  }

  void test_procedure_setter() {
    var libraryA1 = _newLibrary('a');
    libraryA1.addProcedure(_newSetter('A'));

    var libraryA2 = _newLibrary('a');
    libraryA2.addProcedure(_newSetter('B'));

    var outline1 = _newOutline([libraryA1]);
    var outline2 = _newOutline([libraryA2]);

    _runCombineTest([outline1, outline2], (result) {
      var libraryA = _getLibrary(result.program, 'a');
      _getProcedure(libraryA, 'A', '@setters');
      _getProcedure(libraryA, 'B', '@setters');
    });
  }

  void test_procedure_setter_skipDuplicate() {
    var libraryA1 = _newLibrary('a');
    libraryA1.addProcedure(_newSetter('A'));
    libraryA1.addProcedure(_newSetter('B'));

    var libraryA2 = _newLibrary('a');
    libraryA2.addProcedure(_newSetter('A'));
    libraryA2.addProcedure(_newSetter('C'));

    var outline1 = _newOutline([libraryA1]);
    var outline2 = _newOutline([libraryA2]);

    _runCombineTest([outline1, outline2], (result) {
      var libraryA = _getLibrary(result.program, 'a');
      _getProcedure(libraryA, 'A', '@setters');
      _getProcedure(libraryA, 'B', '@setters');
      _getProcedure(libraryA, 'C', '@setters');
    });
  }

  void test_procedure_setter_updateReferences() {
    var libraryA1 = _newLibrary('a');
    var procedureA1A = _newSetter('A');
    libraryA1.addProcedure(procedureA1A);

    var libraryA2 = _newLibrary('a');
    var procedureA2A = _newSetter('A');
    libraryA2.addProcedure(procedureA2A);

    var libraryB = _newLibrary('b');
    libraryB.addProcedure(_newExpressionsProcedure([
      new StaticSet(procedureA2A, new IntLiteral(0)),
    ]));

    var outline1 = _newOutline([libraryA1]);
    var outline2 = _newOutline([libraryA2, libraryB]);

    _runCombineTest([outline1, outline2], (result) {
      var libraryA = _getLibrary(result.program, 'a');
      _getProcedure(libraryA, 'A', '@setters');

      var libraryB = _getLibrary(result.program, 'b');
      var main = _getProcedure(libraryB, 'main', '@methods');
      expect((_getProcedureExpression(main, 0) as StaticSet).targetReference,
          same(procedureA1A.reference));
    });
  }

  void test_undo_twice() {
    var libraryA1 = _newLibrary('a');
    libraryA1.addField(_newField('A'));

    var libraryA2 = _newLibrary('a');
    libraryA2.addField(_newField('B'));

    var outline1 = _newOutline([libraryA1]);
    var outline2 = _newOutline([libraryA2]);

    var result = combine([outline1, outline2]);
    result.undo();
    expect(() => result.undo(), throwsStateError);
  }

  /// Get a single [Class] with the given [name].
  /// Throw if there is not exactly one.
  Class _getClass(Library library, String name) {
    var results = library.classes.where((class_) => class_.name == name);
    expect(results, hasLength(1), reason: 'Expected only one: $name');
    Class result = results.first;
    expect(result.parent, library);
    expect(result.canonicalName.parent, library.canonicalName);
    return result;
  }

  /// Get a single [Field] with the given [name].
  /// Throw if there is not exactly one.
  Field _getField(NamedNode parent, String name) {
    List<Field> fields;
    if (parent is Library) {
      fields = parent.fields;
    } else if (parent is Class) {
      fields = parent.fields;
    } else {
      throw new ArgumentError('Only Library or Class expected');
    }

    var results = fields.where((field) => field.name.name == name);
    expect(results, hasLength(1), reason: 'Expected only one: $name');
    Field result = results.first;
    expect(result.parent, parent);
    var parentName = parent.canonicalName.getChild('@fields');
    expect(result.canonicalName.parent, parentName);
    return result;
  }

  /// Get a single [Library] with the given [name].
  /// Throw if there is not exactly one.
  Library _getLibrary(Program program, String name) {
    var results = program.libraries.where((library) => library.name == name);
    expect(results, hasLength(1), reason: 'Expected only one: $name');
    var result = results.first;
    expect(result.parent, program);
    expect(result.canonicalName.parent, program.root);
    return result;
  }

  /// Get a single [Procedure] with the given [name].
  /// Throw if there is not exactly one.
  Procedure _getProcedure(NamedNode parent, String name, String prefixName) {
    List<Procedure> procedures;
    if (parent is Library) {
      procedures = parent.procedures;
    } else if (parent is Class) {
      procedures = parent.procedures;
    } else {
      throw new ArgumentError('Only Library or Class expected');
    }

    Iterable<Procedure> results =
        procedures.where((procedure) => procedure.name.name == name);
    expect(results, hasLength(1), reason: 'Expected only one: $name');
    Procedure result = results.first;
    expect(result.parent, parent);

    var parentName = parent.canonicalName.getChild(prefixName);
    expect(result.canonicalName.parent, parentName);

    return result;
  }

  /// Return the [Expression] in the [index]th statement of the [procedure]'s
  /// block body.
  Expression _getProcedureExpression(Procedure procedure, int index) {
    Block mainBlock = procedure.function.body;
    ExpressionStatement statement = mainBlock.statements[index];
    return statement.expression;
  }

  Constructor _newConstructor(String name, {Statement body}) {
    body ??= new EmptyStatement();
    return new Constructor(new FunctionNode(body), name: new Name(name));
  }

  Procedure _newExpressionsProcedure(List<Expression> expressions,
      {String name: 'main'}) {
    var statements =
        expressions.map((e) => new ExpressionStatement(e)).toList();
    return new Procedure(new Name(name), ProcedureKind.Method,
        new FunctionNode(new Block(statements)));
  }

  Field _newField(String name) {
    return new Field(new Name(name));
  }

  Procedure _newGetter(String name) {
    return new Procedure(new Name(name), ProcedureKind.Getter,
        new FunctionNode(new ExpressionStatement(new IntLiteral((0)))));
  }

  Library _newLibrary(String name) {
    var uri = Uri.parse('org-dartlang:///$name.dart');
    return new Library(uri, name: name);
  }

  Procedure _newMethod(String name, {Statement body}) {
    body ??= new EmptyStatement();
    return new Procedure(
        new Name(name), ProcedureKind.Method, new FunctionNode(body));
  }

  Program _newOutline(List<Library> libraries) {
    var outline = new Program(libraries: libraries);
    outline.computeCanonicalNames();
    return outline;
  }

  Procedure _newSetter(String name) {
    return new Procedure(
        new Name(name),
        ProcedureKind.Setter,
        new FunctionNode(new EmptyStatement(),
            positionalParameters: [new VariableDeclaration('_')]));
  }

  void _runCombineTest(
      List<Program> outlines, void checkResult(CombineResult result)) {
    // Store the original state.
    var states = <Program, _OutlineState>{};
    for (var outline in outlines) {
      states[outline] = new _OutlineState(outline);
    }

    // Combine the outlines and check the result.
    var result = combine(outlines);
    checkResult(result);

    // Undo and verify that the state is the same as the original.
    result.undo();
    states.forEach((outline, state) {
      state.verifySame();
    });
  }

  /// Return the text presentation of the [library] that is not a normal Kernel
  /// AST text, but includes portions that we want to test - declarations
  /// and references.  The map [nodeToName] must have entries for all
  /// referenced nodes, other declarations are optional.
  static String _getLibraryText(
      Library library, Map<NamedNode, String> nodeToName) {
    var buffer = new StringBuffer();

    String getNodeName(NamedNode node) {
      String name = nodeToName[node];
      if (name != null) {
        return '[$name]';
      } else {
        return '';
      }
    }

    void writeStatement(Statement node, String indent) {
      if (node is ExpressionStatement) {
        Expression expression = node.expression;
        String prefix = expression.runtimeType.toString();
        Member target;
        if (expression is ConstructorInvocation) {
          target = expression.target;
        } else if (expression is DirectMethodInvocation) {
          target = expression.target;
        } else if (expression is MethodInvocation) {
          target = expression.interfaceTarget;
        } else if (expression is SuperMethodInvocation) {
          target = expression.interfaceTarget;
        } else {
          var type = expression.runtimeType;
          fail('Unsupported expression: $type');
        }
        String name = nodeToName[target];
        expect(name, isNotNull, reason: target.toString());
        buffer.writeln('$indent$prefix[$name]();');
      } else {
        fail('Unsupported statement: (${node.runtimeType}) $node');
      }
    }

    void writeBody(Statement body, String indent) {
      if (body is EmptyStatement) {
        buffer.writeln(';');
      } else if (body is Block) {
        buffer.write(' {');
        if (body.statements.isNotEmpty) {
          buffer.writeln();
          for (var statement in body.statements) {
            writeStatement(statement, '$indent  ');
          }
          buffer.writeln('$indent}');
        } else {
          buffer.writeln('}');
        }
      } else {
        fail('Not implemented ${body.runtimeType}');
      }
    }

    void writeField(Field node, String indent) {
      fail('Not implemented ${node.runtimeType}');
    }

    void writeInitializer(Initializer node, String indent) {
      String kind;
      Constructor target;
      if (node is RedirectingInitializer) {
        kind = 'redirect';
        target = node.target;
      } else if (node is SuperInitializer) {
        kind = 'super';
        target = node.target;
      } else {
        fail('Not implemented ${node.runtimeType}');
      }
      String name = nodeToName[target];
      expect(name, isNotNull, reason: target.toString());
      buffer.write('${indent}${kind}[$name]()');
    }

    void writeConstructor(Constructor node, String indent) {
      String name = getNodeName(node);
      buffer.write('${indent}constructor ${node.name}$name()');
      List<Initializer> initializers = node.initializers;
      if (initializers.isNotEmpty) {
        buffer.writeln(' :');
        for (int i = 0; i < initializers.length; i++) {
          Initializer initializer = initializers[i];
          writeInitializer(initializer, '      ');
          if (i != initializers.length - 1) {
            buffer.writeln(',');
          }
        }
      }
      writeBody(node.function.body, indent);
    }

    void writeProcedure(NamedNode parent, Procedure node, String indent) {
      String prefixName;
      String kindStr;
      ProcedureKind kind = node.kind;
      if (kind == ProcedureKind.Method) {
        prefixName = '@methods';
        kindStr = '';
      } else if (kind == ProcedureKind.Getter) {
        prefixName = '@getters';
        kindStr = 'get ';
      } else if (kind == ProcedureKind.Getter) {
        prefixName = '@setters';
        kindStr = 'set ';
      } else {
        fail('Unsupported kind: $kind');
      }

      // Verify canonical names linkage.
      var parentName = parent.canonicalName.getChild(prefixName);
      expect(node.canonicalName.parent, parentName);

      String nodeName = getNodeName(node);
      buffer.write('$indent$kindStr${node.name}$nodeName()');
      writeBody(node.function.body, indent);
    }

    void writeClass(Class node) {
      String nodeName = getNodeName(node);
      buffer.write('class ${node.name}$nodeName {');
      if (!node.members.isEmpty) {
        buffer.writeln();
        for (var field in node.fields) {
          writeField(field, '  ');
        }
        for (var constructor in node.constructors) {
          writeConstructor(constructor, '  ');
        }
        for (var procedure in node.procedures) {
          writeProcedure(node, procedure, '  ');
        }
      }
      buffer.writeln('}');
    }

    for (var node in library.fields) {
      writeField(node, '');
    }

    for (var node in library.classes) {
      writeClass(node);
    }

    for (var node in library.procedures) {
      writeProcedure(library, node, '');
    }

    return buffer.toString();
  }
}

/// The original state of an outline, and code that validates that after some
/// manipulations (e.g. combine and undo) the state stays the same.
class _OutlineState {
  final Program outline;
  final initialCollector = new _StateCollector();

  _OutlineState(this.outline) {
    outline.accept(initialCollector);
  }

  void verifySame() {
    var collector = new _StateCollector();
    outline.accept(collector);
    expect(collector.nodes, initialCollector.nodes);
    expect(collector.references, initialCollector.references);
    initialCollector.libraryParents.forEach((library, outline) {
      expect(library.canonicalName.parent, outline.root);
      expect(library.parent, outline);
    });
    initialCollector.nodeParents.forEach((child, parent) {
      expect(child.parent, parent);
      if (child is Member) {
        var qualifier = CanonicalName.getMemberQualifier(child);
        var parentName = parent.canonicalName.getChild(qualifier);
        expect(child.canonicalName.parent, parentName);
      } else {
        expect(child.canonicalName.parent, parent.canonicalName);
      }
    });
  }
}

class _StateCollector extends RecursiveVisitor {
  final List<Node> nodes = [];
  final Map<NamedNode, NamedNode> nodeParents = {};
  final Map<Library, Program> libraryParents = {};
  final List<Reference> references = [];

  @override
  void defaultMemberReference(Member node) {
    references.add(node.reference);
  }

  @override
  void defaultNode(Node node) {
    nodes.add(node);
    if (node is Library) {
      libraryParents[node] = node.parent as Program;
    } else if (node is NamedNode) {
      nodeParents[node] = node.parent as NamedNode;
    }
    super.defaultNode(node);
  }

  @override
  void visitClassReference(Class node) {
    references.add(node.reference);
  }

  @override
  visitLibraryDependency(LibraryDependency node) {
    references.add(node.importedLibraryReference);
    super.visitLibraryDependency(node);
  }

  @override
  void visitTypedefReference(Typedef node) {
    references.add(node.reference);
  }
}