Git import: a large merge's already-built file no longer renders empty 33be24095b4b

- **A large merge's file no longer imports empty (#71).** When a merge rendered its files in batches, a file whose graph the import had already built came out empty, so the merge recorded the whole file as inserted again and conflicted with itself: VS Code's history failed verification from 2016 on. Built graphs are now copied. The 10 412-commit reproducer imports and verifies every commit.

        .or_else(|| {

            std::env::var("OXY_MERGE_BATCH")

                .ok()

                .and_then(|v| v.parse().ok())

        })

                    let shed_at = std::env::var("OXY_MERGE_SHED")

                        .ok()

                        .and_then(|v| v.parse().ok())

                        .unwrap_or(MERGE_SHED_COMMITS);

                    if others > shed_at {

/// Two unrelated histories that both add the same file, joined by two

/// independent merges on two branches, then those branches merged: Git

/// merges identical additions cleanly, and the import must too (#71,

/// found in VS Code's history).

#[test]

fn git_import_joins_unrelated_histories_that_add_the_same_file() {

    // Batches of one: every merge renders apart from the state, where a

    // file whose graph the state had built came out empty (#71).

    crate::repo::git::set_merge_batch_for_tests(Some(1));

    hermetic();

    if std::process::Command::new("git")

        .arg("--version")

        .output()

        .is_err()

    {

        eprintln!("git not installed; skipping");

        return;

    }

    let dir = tempfile::tempdir().unwrap();

    let root = dir.path();

    let g = root.join("src.git");

    fs::create_dir_all(&g).unwrap();

    let git = |args: &[&str]| -> String {

        let out = std::process::Command::new("git")

            .arg("-C")

            .arg(&g)

            .args([

                "-c",

                "user.name=Grace",

                "-c",

                "[email protected]",

                "-c",

                "commit.gpgsign=false",

            ])

            .args(args)

            .output()

            .unwrap();

        assert!(

            out.status.success(),

            "git {args:?}: {}",

            String::from_utf8_lossy(&out.stderr)

        );

        String::from_utf8_lossy(&out.stdout).trim().to_string()

    };

    let text = b"/* header */\nconst a = 1;\nconst b = 2;\n";

    // History A: main.

    git(&["init", "-q", "-b", "main"]);

    write(&g, "gulpfile.js", text);

    write(&g, "a.txt", b"a\n");

    git(&["add", "."]);

    git(&["commit", "-q", "-m", "A root"]);

    // History B: an unrelated root adding the same file, identical.

    git(&["checkout", "-q", "--orphan", "fork"]);

    git(&["rm", "-q", "-r", "--cached", "."]);

    for f in ["gulpfile.js", "a.txt"] {

        let _ = fs::remove_file(g.join(f));

    }

    write(&g, "gulpfile.js", text);

    write(&g, "b.txt", b"b\n");

    git(&["add", "."]);

    git(&["commit", "-q", "-m", "B root"]);

    // Two branches from main, each joining B on its own.

    git(&["checkout", "-q", "-b", "one", "main"]);

    git(&[

        "merge",

        "-q",

        "--no-ff",

        "--allow-unrelated-histories",

        "-m",

        "join on one",

        "fork",

    ]);

    git(&["checkout", "-q", "-b", "two", "main"]);

    write(&g, "a.txt", b"a\ntwo\n");

    git(&["commit", "-q", "-am", "work on two"]);

    git(&[

        "merge",

        "-q",

        "--no-ff",

        "--allow-unrelated-histories",

        "-m",

        "join on two",

        "fork",

    ]);

    // Then the two joins meet, and the file is reformatted after.

    git(&["checkout", "-q", "main"]);

    git(&["merge", "-q", "--no-ff", "-m", "merge one", "one"]);

    git(&["merge", "-q", "--no-ff", "-m", "merge two", "two"]);

    write(

        &g,

        "gulpfile.js",

        b"/* header */\nconst a = 1;\nconst b = 3;\n",

    );

    git(&["commit", "-q", "-am", "after"]);

    let dest = root.join("dest");

    let repo = Repo::init(&dest).unwrap().with_home(root.join("home"));

    repo.import_git(&g, "main").unwrap();

    let v = repo.verify_git_import(&g, "main").unwrap();

    assert!(v.mismatches.is_empty(), "{:?}", v.mismatches);

    assert_eq!(

        fs::read(dest.join("gulpfile.js")).unwrap(),

        b"/* header */\nconst a = 1;\nconst b = 3;\n"

    );

}

/// As above, but the two joins keep different copies (each branch had a

/// different version when it joined), and later work edits each copy:

/// the shape of VS Code's c67ef57cda90 (#71).

#[test]

fn git_import_joins_where_each_join_kept_a_different_copy() {

    // Batches of one: every merge renders apart from the state, where a

    // file whose graph the state had built came out empty (#71).

    crate::repo::git::set_merge_batch_for_tests(Some(1));

    hermetic();

    if std::process::Command::new("git")

        .arg("--version")

        .output()

        .is_err()

    {

        eprintln!("git not installed; skipping");

        return;

    }

    let dir = tempfile::tempdir().unwrap();

    let root = dir.path();

    let g = root.join("src.git");

    fs::create_dir_all(&g).unwrap();

    let run = |args: &[&str]| {

        std::process::Command::new("git")

            .arg("-C")

            .arg(&g)

            .args([

                "-c",

                "user.name=Grace",

                "-c",

                "[email protected]",

                "-c",

                "commit.gpgsign=false",

            ])

            .args(args)

            .output()

            .unwrap()

    };

    let git = |args: &[&str]| -> String {

        let out = run(args);

        assert!(

            out.status.success(),

            "git {args:?}: {}",

            String::from_utf8_lossy(&out.stderr)

        );

        String::from_utf8_lossy(&out.stdout).trim().to_string()

    };

    git(&["init", "-q", "-b", "main"]);

    write(

        &g,

        "gulpfile.js",

        b"/* header */\nconst a = 1;\nconst b = 2;\n",

    );

    git(&["add", "."]);

    git(&["commit", "-q", "-m", "A root"]);

    write(

        &g,

        "gulpfile.js",

        b"/* header */\nconst a = 1;\n\nconst b = 2;\n",

    );

    git(&["commit", "-q", "-am", "whitespace"]);

    git(&["checkout", "-q", "--orphan", "fork"]);

    git(&["rm", "-q", "-r", "--cached", "."]);

    let _ = fs::remove_file(g.join("gulpfile.js"));

    write(

        &g,

        "gulpfile.js",

        b"/* header */\nconst a = 1;\nconst b = 2;\nconst c = 3;\n",

    );

    git(&["add", "."]);

    git(&["commit", "-q", "-m", "B root"]);

    // Branch one joins B keeping main's copy; branch two keeps B's.

    for (branch, keep) in [("one", "ours"), ("two", "theirs")] {

        git(&["checkout", "-q", "-b", branch, "main"]);

        let _ = run(&[

            "merge",

            "-q",

            "--no-ff",

            "--allow-unrelated-histories",

            "-m",

            "join",

            "fork",

        ]);

        git(&["checkout", &format!("--{keep}"), "gulpfile.js"]);

        git(&["add", "gulpfile.js"]);

        git(&["commit", "-q", "-m", &format!("join on {branch}")]);

    }

    // Each branch then edits its copy.

    git(&["checkout", "-q", "one"]);

    write(

        &g,

        "gulpfile.js",

        b"/* header */\nconst a = 1;\n\nconst b = 2;\n// tslint\n",

    );

    git(&["commit", "-q", "-am", "tslint on one"]);

    git(&["checkout", "-q", "two"]);

    write(

        &g,

        "gulpfile.js",

        b"/* header */\nconst a = 1;\nconst b = 2;\nconst c = 3;\n// fmt\n",

    );

    write(&g, "extra.txt", b"x\n");

    write(&g, "more.txt", b"m\n");

    git(&["add", "."]);

    git(&["commit", "-q", "-am", "fmt on two"]);

    // They meet: resolved by hand.

    git(&["checkout", "-q", "one"]);

    let _ = run(&["merge", "-q", "--no-ff", "-m", "merge two", "two"]);

    write(

        &g,

        "gulpfile.js",

        b"/* header */\nconst a = 1;\nconst b = 2;\nconst c = 3;\n// tslint\n// fmt\n",

    );

    git(&["add", "gulpfile.js"]);

    git(&["commit", "-q", "-m", "merge two into one"]);

    let dest = root.join("dest");

    let repo = Repo::init(&dest).unwrap().with_home(root.join("home"));

    repo.import_git(&g, "one").unwrap();

    let v = repo.verify_git_import(&g, "one").unwrap();

    assert!(v.mismatches.is_empty(), "{:?}", v.mismatches);

}

        // A file this state has built has no deferred history: its graph

        // is the built one, copied. Built from an empty history instead, it

        // rendered as an empty file, and a merge taking this path recorded

        // the whole file as inserted again, conflicting with itself (#71).

        let mut built: Vec<(NodeId, FileGraph)> = Vec::new();

        let mut copies: Vec<(NodeId, Deferred)> = Vec::new();

        for n in nodes {

            match (self.files.get(n), deferred.get(n)) {

                (Some(g), _) => built.push((*n, (**g).clone())),

                (None, d) => copies.push((*n, d.map(|d| (**d).clone()).unwrap_or_default())),

            }

        }

        let mut out = build_deferred(copies, load, read_change)?;

        out.extend(built);

        Ok(out)