The same file added on both sides, identically, is one file c2e1d09047db

        let tview = self.tree_view(&mut target)?;

        let Ok(mut state) = self.load_state_history(&heads) else {

        let Ok(view) = self.tree_view(&mut state) else {

            return;

        };

        let tree = self.tree_view(&mut state)?;

        let tree = self.tree_view(&mut state)?;

    /// The tree of `state` as every reader sees it ([`State::view`]), with

    /// the graphs built that it compares: same-path additions with

    /// identical content are one entry, not a name conflict.

    pub fn tree_view(&self, state: &mut State) -> Result<crate::tree::TreeView> {

        let need = state.unify_candidates();

        if !need.is_empty() {

            self.load_graphs_of(state, &need)?;

        }

        Ok(state.view())

    }

        let Some(node) = self

            .tree_view(&mut state)?

            .entries

            .get(path)

            .map(|e| e.node)

        else {

            tree: self.tree_view(&mut base)?,

        self.tree_view(&mut base)?;

        // The tree alone names the nodes: no file graph is built (but for

        // same-path additions it compares). The working copy's base comes

        // from the workspace's state index.

        let mut state = match self.working_copy() {

        let view = self.repo.tree_view(&mut state)?;

        let mut nodes: HashSet<NodeId> = view

        // A file shown as one of identical additions is all of them.

        for (dup, shown) in &view.unified {

            if nodes.contains(shown) {

                nodes.insert(*dup);

            }

        }

        b.retire_unified();

            self.tree_view(&mut base)?

        let view = st.view();

                let (o, e) = select_hunks(&snap.wc, indices, &snap.base_snapshot.tree.unified);

    // The nodes shown as one with a selected node are retired with it.

    for (dup, shown) in &base_snapshot.tree.unified {

        if nodes.contains(shown) {

            nodes.insert(*dup);

        }

    }

/// The nodes `unified` shows as one with another (a base's

/// [`TreeView::unified`](crate::tree::TreeView::unified)) are retired with

/// any hunk of the node shown.

fn select_hunks(

    wc: &Change,

    indices: &[usize],

    unified: &BTreeMap<NodeId, NodeId>,

) -> (Vec<TreeOp>, Vec<Edit>) {

                }

            }

        }

    }

    // The retirement of a node shown as one with a selected node.

    if !unified.is_empty() {

        let chosen: HashSet<NodeId> = (0..n_ops)

            .filter(|i| ops_sel[*i])

            .map(|i| wc.tree_ops[i].node())

            .chain(

                (0..wc.edits.len())

                    .filter(|j| edits_sel[*j])

                    .map(|j| wc.edits[j].node()),

            )

            .collect();

        for (i, o) in wc.tree_ops.iter().enumerate() {

            if let TreeOp::RemoveNode { node, .. } = o {

                if unified.get(node).is_some_and(|s| chosen.contains(s)) {

                    ops_sel[i] = true;

        // A retired duplicate goes with the node shown: no hunk of its own.

        if is_unified_retirement(op, base_snapshot) {

            continue;

        }

        let view = self.tree_view(&mut state)?;

        let (ops, edits) = select_hunks(&snap.wc, &keep, &snap.base_snapshot.tree.unified);

        let node_in = |mut state: State| -> Result<Option<HashSet<NodeId>>> {

            Ok(nodes_at(&self.tree_view(&mut state)?, path))

        };

        let nodes = match node_in(self.load_state_indexed(&wc.deps)?)? {

            None => node_in(self.load_state_history(&heads)?)?,

        let Some(nodes) = nodes else {

        Ok(self.entries_touching_up_to(entries, nodes, None))

        let Some(nodes) = nodes_at(&state.view(), path) else {

        Ok(self.entries_touching_up_to(self.log_of(state), nodes, limit))

        wanted: HashSet<NodeId>,

}

/// The node at `path` in `view`, with the nodes it shows as one with it

/// (identical additions, spec §9.2): the file's history is all of theirs.

fn nodes_at(view: &crate::tree::TreeView, path: &str) -> Option<HashSet<NodeId>> {

    let node = view.entries.get(path)?.node;

    let mut out = HashSet::from([node]);

    out.extend(

        view.unified

            .iter()

            .filter(|(_, shown)| **shown == node)

            .map(|(dup, _)| *dup),

    );

    Some(out)

    for op in change

        .tree_ops

        .iter()

        .filter(|o| !is_unified_retirement(o, base_snapshot))

    {

    /// Nodes the base shows as one with another (identical additions at one

    /// path, spec §9.2) are retired by the change that first touches the

    /// node shown: edited, moved, removed or given a mode alone, it would

    /// differ from them and the name conflict would come back. Nothing

    /// else changes for the user, so no status reports it.

    fn retire_unified(&mut self) {

        let unified = &self.base_snapshot.tree.unified;

        if unified.is_empty() {

            return;

        }

        let touched: HashSet<NodeId> = self

            .tree_ops

            .iter()

            .map(|o| o.node())

            .chain(self.edits.iter().map(|e| e.node()))

            .collect();

        let mut retired: HashSet<(ChangeHash, u32)> = HashSet::new();

        for op in &self.tree_ops {

            match op {

                TreeOp::Move { old, .. } => {

                    retired.insert((old.change, old.index));

                }

                TreeOp::RemoveNode { placement, .. } => {

                    retired.insert((placement.change, placement.index));

                }

                TreeOp::AddNode { .. } | TreeOp::SetMode { .. } => {}

            }

        }

        let mut extra = Vec::new();

        for (dup, shown) in unified {

            if !touched.contains(shown) {

                continue;

            }

            for (k, _) in self.base.tree().live_placements(dup) {

                if retired.insert(k) {

                    extra.push(TreeOp::RemoveNode {

                        node: *dup,

                        placement: op_ref(k),

                    });

                }

            }

        }

        self.tree_ops.extend(extra);

    }

/// Whether `op` retires a node `base_snapshot` shows as one with another

/// (spec §9.2): part of touching that node, never a removal the user made.

fn is_unified_retirement(op: &TreeOp, base_snapshot: &Snapshot) -> bool {

    matches!(op, TreeOp::RemoveNode { node, .. } if base_snapshot.tree.unified.contains_key(node))

}

    for op in change

        .tree_ops

        .iter()

        .filter(|o| !is_unified_retirement(o, base_snapshot))

    {

/// Each of two bookmarks adds `path` (a file written by `side` on each)

/// from the same base, and the second is merged into the first. Returns

/// the repository on `main`, the merge's heads, and the three changes.

fn merged_additions(

    side: impl Fn(&Path, bool),

) -> (tempfile::TempDir, Repo, Vec<ChangeHash>, [ChangeHash; 3]) {

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

    let root = dir.path().to_path_buf();

    let mut repo = Repo::init(&root).unwrap();

    write(&root, "keep.txt", b"k\n");

    let h1 = repo.commit("base", &[]).unwrap();

    repo.bookmark_create("side", None).unwrap();

    side(&root, false);

    let ha = repo.commit("add on main", &[]).unwrap();

    repo.bookmark_switch("side", false).unwrap();

    side(&root, true);

    let hb = repo.commit("add on side", &[]).unwrap();

    repo.bookmark_switch("main", false).unwrap();

    let m = repo.merge("side").unwrap();

    assert!(m.changed && m.checked_out);

    (dir, repo, m.heads, [h1, ha, hb])

}

fn conflict_copies(root: &Path) -> Vec<String> {

    let mut out: Vec<String> = fs::read_dir(root)

        .unwrap()

        .map(|e| e.unwrap().file_name().to_string_lossy().into_owned())

        .filter(|n| n.contains(".oxy-conflict-"))

        .collect();

    out.sort();

    out

}

/// The same path added on two bookmarks with identical content is one

/// file after the merge (oxygen#101): no conflict, nothing to resolve,

/// nothing recorded; and editing or removing it later keeps it one.

#[test]

fn identical_additions_unify_on_merge() {

    hermetic();

    let (dir, repo, heads, [h1, ha, hb]) =

        merged_additions(|root, _| write(root, "x.txt", b"same\nlines\n"));

    let root = dir.path();

    // The tree graph has the name conflict; every reader sees one file.

    let st = repo.load_state(&heads).unwrap();

    assert!(st

        .tree()

        .view()

        .conflicts

        .iter()

        .any(|c| matches!(c, crate::tree::TreeConflict::Name { .. })));

    let snap = st.materialize();

    assert!(!snap.is_conflicted(), "{:?}", snap.tree.conflicts);

    assert_eq!(

        snap.files.keys().cloned().collect::<Vec<_>>(),

        ["keep.txt", "x.txt"]

    );

    assert!(

        matches!(&snap.files["x.txt"].content, FileContent::Text { bytes, .. } if bytes == b"same\nlines\n")

    );

    assert_eq!(snap.tree.unified.len(), 1);

    // On disk once, the working copy clean, nothing to commit.

    assert_eq!(fs::read(root.join("x.txt")).unwrap(), b"same\nlines\n");

    assert!(

        conflict_copies(root).is_empty(),

        "{:?}",

        conflict_copies(root)

    );

    let s = repo.snapshot("status").unwrap();

    assert!(s.statuses.is_empty(), "{:?}", statuses(&s));

    assert!(!s.changed && !s.resolves);

    assert!(!s.base_snapshot.is_conflicted());

    assert!(s.wc.tree_ops.is_empty() && s.wc.edits.is_empty());

    let json = repo.status_json(&s).unwrap();

    assert!(json.contains("\"conflicted\":false"), "{json}");

    assert!(repo.commit("nothing", &[]).is_err());

    assert_eq!(repo.file_at("x.txt", None).unwrap(), b"same\nlines\n");

    // A peer holding the same changes, added in another order, agrees.

    let mut peer = State::new();

    for h in [hb, ha, h1] {

        peer.add_unchecked(repo.store().get_change(&h).unwrap());

    }

    peer.validate().unwrap();

    let ps = peer.materialize();

    assert!(!ps.is_conflicted());

    assert_eq!(ps.tree.entries["x.txt"], snap.tree.entries["x.txt"]);

    assert_eq!(ps.tree.unified, snap.tree.unified);

    // The file's history is both additions.

    let log: Vec<ChangeHash> = repo

        .log_for_path("x.txt")

        .unwrap()

        .iter()

        .map(|e| e.hash)

        .collect();

    assert!(log.contains(&ha) && log.contains(&hb), "{log:?}");

    // Edited and committed: one file still, the duplicate retired with it.

    write(root, "x.txt", b"same\nedited\n");

    let s = repo.snapshot("status").unwrap();

    assert_eq!(statuses(&s), vec![("x.txt".into(), ChangeStatus::Modified)]);

    let he = repo.commit("edit x", &[]).unwrap();

    let c = repo.store().get_change(&he).unwrap();

    assert_eq!(c.kind, ChangeKind::Normal);

    let (dup, _) = snap.tree.unified.iter().next().unwrap();

    assert!(

        c.tree_ops

            .iter()

            .any(|o| matches!(o, TreeOp::RemoveNode { node, .. } if node == dup)),

        "{:?}",

        c.tree_ops

    );

    let d = repo.describe_change(&he).unwrap();

    assert!(!d.contains("D x.txt"), "{d}");

    let st = repo.load_state(&repo.bookmark_heads().unwrap()).unwrap();

    assert!(

        st.tree().view().conflicts.is_empty(),

        "nothing left to unify"

    );

    let snap = st.materialize();

    assert!(!snap.is_conflicted());

    assert!(

        matches!(&snap.files["x.txt"].content, FileContent::Text { bytes, .. } if bytes == b"same\nedited\n")

    );

    assert!(!repo.snapshot("status").unwrap().changed);

    // Removed and committed: gone.

    fs::remove_file(root.join("x.txt")).unwrap();

    repo.commit("drop x", &[]).unwrap();

    let snap = repo

        .load_state(&repo.bookmark_heads().unwrap())

        .unwrap()

        .materialize();

    assert!(!snap.is_conflicted(), "{:?}", snap.tree.conflicts);

    assert_eq!(snap.files.keys().cloned().collect::<Vec<_>>(), ["keep.txt"]);

    assert!(!root.join("x.txt").exists());

}

/// Removing, renaming, or committing just the path of a unified file

/// retires its duplicate with it, so the conflict never comes back.

#[test]

fn unified_additions_stay_one_when_removed_renamed_or_committed_alone() {

    hermetic();

    let add = |root: &Path, _: bool| write(root, "x.txt", b"same\n");

    for how in ["remove", "rename", "path", "hunk"] {

        let (dir, repo, _, _) = merged_additions(add);

        let root = dir.path();

        match how {

            "remove" => fs::remove_file(root.join("x.txt")).unwrap(),

            "rename" => fs::rename(root.join("x.txt"), root.join("y.txt")).unwrap(),

            _ => {

                write(root, "x.txt", b"same\nmore\n");

                write(root, "other.txt", b"o\n");

            }

        }

        let s = repo.snapshot("status").unwrap();

        let h = match how {

            "path" => repo

                .commit_selection("x alone", &[], &Selection::Paths(vec!["x.txt".into()]))

                .unwrap(),

            "hunk" => {

                let (_, hunks) = repo.hunks().unwrap();

                // The duplicate's retirement is no hunk of its own.

                assert!(hunks.iter().all(|h| !h.text.starts_with("D ")), "{hunks:?}");

                let x: Vec<usize> = hunks

                    .iter()

                    .filter(|h| h.path == "x.txt")

                    .map(|h| h.index)

                    .collect();

                assert!(!x.is_empty());

                repo.commit_selection("x hunks", &[], &Selection::Hunks(x))

                    .unwrap()

            }

            _ => repo.commit(how, &[]).unwrap(),

        };

        assert!(!s.base_snapshot.is_conflicted());

        let heads = repo.bookmark_heads().unwrap();

        assert!(heads.contains(&h));

        let snap = repo.load_state(&heads).unwrap().materialize();

        assert!(!snap.is_conflicted(), "{how}: {:?}", snap.tree.conflicts);

        let want: &[&str] = match how {

            "remove" => &["keep.txt"],

            "rename" => &["keep.txt", "y.txt"],

            _ => &["keep.txt", "x.txt"],

        };

        assert_eq!(

            snap.files.keys().cloned().collect::<Vec<_>>(),

            want,

            "{how}"

        );

        assert!(conflict_copies(root).is_empty(), "{how}");

    }

}

/// The same path added with different content, or a different mode, is a

/// name conflict as before.

#[test]

fn additions_that_differ_still_conflict() {

    hermetic();

    #[cfg(unix)]

    use std::os::unix::fs::PermissionsExt;

    let content =

        |root: &Path, side: bool| write(root, "x.txt", if side { b"two\n" } else { b"one\n" });

    let mode = |root: &Path, side: bool| {

        write(root, "x.txt", b"same\n");

        #[cfg(unix)]

        if side {

            fs::set_permissions(root.join("x.txt"), fs::Permissions::from_mode(0o755)).unwrap();

        }

    };

    let check = |what: &str, side: &dyn Fn(&Path, bool)| {

        let (dir, repo, heads, _) = merged_additions(side);

        let snap = repo.load_state(&heads).unwrap().materialize();

        assert!(snap.tree.unified.is_empty(), "{what}");

        assert!(

            snap.tree.conflicts.iter().any(

                |c| matches!(c, crate::tree::TreeConflict::Name { name, .. } if name == "x.txt")

            ),

            "{what}: {:?}",

            snap.tree.conflicts

        );

        assert_eq!(

            conflict_copies(dir.path()),

            ["x.txt.oxy-conflict-1", "x.txt.oxy-conflict-2"],

            "{what}"

        );

        assert!(!dir.path().join("x.txt").exists(), "{what}");

    };

    check("content", &content);

    #[cfg(unix)]

    check("mode", &mode);

    #[cfg(not(unix))]

    let _ = mode;

}

/// The same subrepo at the same pin, added on two bookmarks, is one

/// subrepo after the merge (oxygen#101), as is the identical

/// `.oxymodules` beside it.

#[test]

fn the_same_subrepo_added_on_two_bookmarks_unifies() {

    hermetic();

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

    let root = dir.path();

    let lib_origin = Repo::init(&root.join("lib-origin")).unwrap();

    let lib_url = root.join("lib-origin").to_string_lossy().to_string();

    let lib = Repo::clone(&lib_url, &root.join("lib"))

        .unwrap()

        .with_home(root.join("home"));

    write(&root.join("lib"), "lib.txt", b"v1\n");

    lib.commit("lib v1", &[]).unwrap();

    assert!(lib.push("origin", false).unwrap()[0].ok);

    let _ = lib_origin;

    let app_dir = root.join("app");

    let mut app = Repo::init(&app_dir).unwrap().with_home(root.join("home"));

    write(&app_dir, "main.txt", b"app\n");

    app.commit("base", &[]).unwrap();

    app.bookmark_create("side", None).unwrap();

    app.submodule_add(&lib_url, "rstar-api", None).unwrap();

    let modules = fs::read(app_dir.join(".oxymodules")).unwrap();

    app.commit("rstar-api on main", &[]).unwrap();

    // On the other bookmark the nested repository is still there (it is

    // never deleted); registering it again adds it at the same pin.

    app.bookmark_switch("side", false).unwrap();

    assert!(app_dir.join("rstar-api/.oxy").is_dir());

    write(&app_dir, ".oxymodules", &modules);

    let s = app.snapshot("status").unwrap();

    assert_eq!(

        statuses(&s),

        vec![

            (".oxymodules".into(), ChangeStatus::Added),

            ("rstar-api".into(), ChangeStatus::Added)

        ]

    );

    app.commit("rstar-api on side", &[]).unwrap();

    app.bookmark_switch("main", false).unwrap();

    let m = app.merge("side").unwrap();

    assert!(m.changed && m.checked_out);

    let snap = app.load_state(&m.heads).unwrap().materialize();

    assert!(!snap.is_conflicted(), "{:?}", snap.tree.conflicts);

    assert_eq!(snap.tree.unified.len(), 2);

    assert_eq!(snap.files["rstar-api"].kind, NodeKind::Subrepo);

    assert!(conflict_copies(&app_dir).is_empty());

    let s = app.snapshot("status").unwrap();

    assert!(s.statuses.is_empty(), "{:?}", statuses(&s));

    assert!(!s.base_snapshot.is_conflicted());

    assert_eq!(

        fs::read_to_string(app_dir.join("rstar-api/lib.txt")).unwrap(),

        "v1\n"

    );

}

    /// The tree as readers see it ([`State::view`]), once worked out for

    /// a tree with name conflicts; cleared by every change added.

    unified_view: std::sync::OnceLock<TreeView>,

            unified_view: self.unified_view.clone(),

    /// The tree as every reader sees it: the tree graph's view, with the

    /// same path added on several lines of history with identical content

    /// shown as one entry rather than a name conflict (spec §9.2). The

    /// text files among such candidates must be built in a history-only

    /// state ([`State::unify_candidates`]); until they are, they are shown

    /// as the conflict.

    pub fn view(&self) -> TreeView {

        if let Some(v) = self.unified_view.get() {

            return v.clone();

        }

        let raw = self.tree.view();

        if !raw

            .conflicts

            .iter()

            .any(|c| matches!(c, crate::tree::TreeConflict::Name { .. }))

        {

            return raw;

        }

        let (view, decided) = self.tree.unify(raw, |es| self.same_content(es));

        if decided {

            let _ = self.unified_view.set(view.clone());

        }

        view

    }

    /// The text files [`State::view`] must compare and a history-only

    /// state has not built: candidates of the tree's name conflicts.

    pub fn unify_candidates(&self) -> Vec<NodeId> {

        let Some(deferred) = &self.deferred else {

            return Vec::new();

        };

        if self.unified_view.get().is_some() {

            return Vec::new();

        }

        let raw = self.tree.view();

        let mut out = Vec::new();

        for c in &raw.conflicts {

            if let crate::tree::TreeConflict::Name { nodes, .. } = c {

                out.extend(nodes.iter().filter(|n| deferred.contains_key(*n)));

            }

        }

        out

    }

    /// Whether the entries' contents are identical, unconflicted: the same

    /// rendering for text files, the same single blob for opaque ones,

    /// symlinks and subrepos. `None` for a text file not built yet.

    fn same_content(&self, entries: &[&crate::tree::TreeEntry]) -> Option<bool> {

        let text = |e: &crate::tree::TreeEntry| e.kind == NodeKind::File && !e.mode.opaque;

        let mut first: Option<Vec<u8>> = None;

        let mut first_blob: Option<ObjectRef> = None;

        for e in entries {

            if text(e) {

                if self

                    .deferred

                    .as_ref()

                    .is_some_and(|d| d.contains_key(&e.node))

                {

                    return None;

                }

                let (bytes, m) = self.render_file(&e.node);

                if m.is_conflicted() {

                    return Some(false);

                }

                match &first {

                    None => first = Some(bytes),

                    Some(b) if *b == bytes => {}

                    Some(_) => return Some(false),

                }

            } else {

                let [blob] = self.live_blobs(&e.node)[..] else {

                    return Some(false);

                };

                match first_blob {

                    None => first_blob = Some(blob),

                    Some(b) if b == blob => {}

                    Some(_) => return Some(false),

                }

            }

        }

        Some(true)

    }

        self.unified_view = Default::default();

        let tree = self.view();

    /// files are unchanged and not conflicted. Its tree is the tree

    /// graph's own view, as a Git import builds against it: same-path

    /// additions are not unified ([`State::view`]), since the import's

    /// merge records Git's tree for them itself.

        self.materialize_leaving(self.tree.view(), |_, e| skip.contains(&e.node))

    /// `render` (a few, where the caller knows the rest unchanged), with

    /// the tree as [`State::view`] has it.

        self.materialize_leaving(self.view(), |p, _| !render.contains(p))

    /// As [`State::materialize_only`], rendering only the text files of

        self.materialize_leaving(self.view(), |_, e| !render.contains(&e.node))

        tree: TreeView,

    /// Nodes added at a place another node holds with identical content

    /// (spec §9.2), each with the node the view shows there in its stead:

    /// one file to every reader, and retired by the first change that

    /// touches the node shown ([`TreeGraph::unify`]).

    pub unified: BTreeMap<NodeId, NodeId>,

    /// `view` (this graph's) with each name conflict between nodes added

    /// with identical content made one entry (spec §9.2): the node whose

    /// placement there has the least key is shown at the plain name, and

    /// the others are listed in [`TreeView::unified`]. Only a group of

    /// files, symlinks or subrepos of one kind and mode, none in another

    /// conflict, is offered to `same`, one entry per node, which says

    /// whether their contents are identical (`None`: it cannot tell yet).

    /// The key order is the same for every peer, so all show one node.

    /// Also returns whether `same` answered for every group.

    pub fn unify(

        &self,

        mut view: TreeView,

        same: impl Fn(&[&TreeEntry]) -> Option<bool>,

    ) -> (TreeView, bool) {

        let mut decided = true;

        if !view

            .conflicts

            .iter()

            .any(|c| matches!(c, TreeConflict::Name { .. }))

        {

            return (view, decided);

        }

        // Nodes in any other conflict stay as they are.

        let mut troubled: HashSet<NodeId> = HashSet::new();

        for c in &view.conflicts {

            match c {

                TreeConflict::Name { .. } => {}

                TreeConflict::MultiPlacement { node, .. }

                | TreeConflict::Orphan { node, .. }

                | TreeConflict::Cycle { node }

                | TreeConflict::Mode { node, .. } => {

                    troubled.insert(*node);

                }

            }

        }

        let mut of_node: HashMap<NodeId, Vec<&TreeEntry>> = HashMap::new();

        for e in view.entries.values() {

            of_node.entry(e.node).or_default().push(e);

        }

        // (paths to drop, entry to add, duplicates) per unified group.

        let mut merged: Vec<(Vec<String>, TreeEntry, Vec<NodeId>)> = Vec::new();

        let mut gone: HashSet<usize> = HashSet::new();

        for (i, c) in view.conflicts.iter().enumerate() {

            let TreeConflict::Name {

                parent,

                name,

                nodes,

            } = c

            else {

                continue;

            };

            if nodes.iter().any(|n| troubled.contains(n)) {

                continue;

            }

            // The group's entries: each node's placements at this place.

            let mut group: Vec<&TreeEntry> = Vec::new();

            for n in nodes {

                for e in of_node.get(n).into_iter().flatten() {

                    if self

                        .placement(&e.placement)

                        .is_some_and(|p| p.parent == *parent && p.name == *name)

                    {

                        group.push(e);

                    }

                }

            }

            let Some(first) = group.first() else {

                continue;

            };

            if first.kind == NodeKind::Dir

                || group

                    .iter()

                    .any(|e| e.kind != first.kind || e.mode != first.mode)

            {

                continue;

            }

            group.sort_by_key(|e| e.placement);

            let mut reps: Vec<&TreeEntry> = Vec::new();

            for e in &group {

                if !reps.iter().any(|r| r.node == e.node) {

                    reps.push(e);

                }

            }

            if reps.len() < 2 {

                continue;

            }

            match same(&reps) {

                Some(true) => {}

                Some(false) => continue,

                None => {

                    decided = false;

                    continue;

                }

            }

            let shown = reps[0];

            let path = match shown.path.rsplit_once('/') {

                Some((dir, _)) => format!("{dir}/{name}"),

                None => name.clone(),

            };

            merged.push((

                group.iter().map(|e| e.path.clone()).collect(),

                TreeEntry {

                    path,

                    ..shown.clone()

                },

                reps[1..].iter().map(|e| e.node).collect(),

            ));

            gone.insert(i);

        }

        drop(of_node);

        if merged.is_empty() {

            return (view, decided);

        }

        let entries = std::sync::Arc::make_mut(&mut view.entries);

        for (paths, shown, dups) in merged {

            for p in paths {

                entries.remove(&p);

            }

            for d in dups {

                view.unified.insert(d, shown.node);

            }

            entries.insert(shown.path.clone(), shown);

        }

        let mut i = 0;

        view.conflicts.retain(|_| {

            i += 1;

            !gone.contains(&(i - 1))

        });

        (view, decided)

    }

}

impl TreeGraph {

            unified: BTreeMap::new(),

    }

    /// Identical additions at one place are one entry, the node with the

    /// least placement key shown; anything else stays a name conflict.

    #[test]

    fn identical_additions_unify() {

        let mut g = TreeGraph::new();

        add(&mut g, 1, 0, 1, NodeKind::Dir, NodeId::ROOT, "d");

        add(&mut g, 3, 0, 3, NodeKind::File, nid(1), "a.txt");

        add(&mut g, 2, 0, 2, NodeKind::File, nid(1), "a.txt");

        let raw = g.view();

        let (v, decided) = g.unify(raw.clone(), |es| {

            assert_eq!(es.len(), 2, "one entry per node");

            Some(true)

        });

        assert!(decided);

        assert_eq!(paths(&v), ["d", "d/a.txt"]);

        assert!(v.conflicts.is_empty());

        assert_eq!(v.entries["d/a.txt"].node, nid(2), "the least placement key");

        assert_eq!(v.entries["d/a.txt"].placement, (h(2), 0));

        assert_eq!(v.unified, [(nid(3), nid(2))].into_iter().collect());

        // Different contents, or not known yet: the conflict as it was.

        let (v, decided) = g.unify(raw.clone(), |_| Some(false));

        assert!(decided);

        assert_eq!(v, raw);

        let (v, decided) = g.unify(raw.clone(), |_| None);

        assert!(!decided);

        assert_eq!(v, raw);

        // Directories, and kinds that differ, are never offered.

        let mut g = TreeGraph::new();

        add(&mut g, 1, 0, 1, NodeKind::Dir, NodeId::ROOT, "d");

        add(&mut g, 2, 0, 2, NodeKind::Dir, NodeId::ROOT, "d");

        add(&mut g, 3, 0, 3, NodeKind::File, NodeId::ROOT, "f");

        add(&mut g, 4, 0, 4, NodeKind::Symlink, NodeId::ROOT, "f");

        let raw = g.view();

        let (v, _) = g.unify(raw.clone(), |_| panic!("not offered"));

        assert_eq!(v, raw);

- **Name conflict.** Two live nodes share a placement. The same path added with identical content on several lines of history is not one, as Git unifies an addition both sides of a merge made: when every node at the placement is a file, symlink, or subrepo of one kind and one mode, none is in another tree conflict, and their contents are the same and unconflicted (one rendering for text files; one live blob for opaque files, symlink targets, and subrepo pins), the state shows a single entry, the node whose placement has the least `PlacementRef`, so every peer shows the same one. Nothing is resolved and no change is recorded. The first change that touches the node shown (an edit, `Move`, `RemoveNode`, or `SetMode`) also deletes the others' placements, or they would differ from it and the conflict would return; a working-copy snapshot adds those deletions with the touch and reports no change of its own for them. Directories are not unified. A Git import builds against the tree without this unification, so an import of a merge records Git's tree for such a path itself (§23).