Enum MergeConflictKind 

pub enum MergeConflictKind {
    Content {
        add_add: bool,
    },
    ModifyDelete {
        deleted_in: String,
        modified_in: String,
    },
    RenameContent {
        old_path: Vec<u8>,
    },
    RenameRenameTwoToOne {
        ours_path: Vec<u8>,
        theirs_path: Vec<u8>,
    },
    RenameRenameOneToTwo {
        old_path: Vec<u8>,
        ours_path: Vec<u8>,
        theirs_path: Vec<u8>,
        ours_label: String,
        theirs_label: String,
    },
    RenameRenameOneToTwoStage,
    DirRenameSplit {
        source_dir: Vec<u8>,
    },
    RenameDelete {
        old_path: Vec<u8>,
        renamed_in: String,
        deleted_in: String,
    },
    FileDirectory {
        original_path: Vec<u8>,
        moved_from: String,
    },
    DirRenameLocation {
        old_path: Vec<u8>,
        renamed_from: Option<Vec<u8>>,
        added_in: String,
        dir_renamed_in: String,
        back_to_self: bool,
    },
    DirRenameImplicitCollision {
        sources: Vec<Vec<u8>>,
    },
    DistinctTypes {
        original_path: Vec<u8>,
        ours_renamed: Option<Vec<u8>>,
        theirs_renamed: Option<Vec<u8>>,
    },
    DistinctTypesStage,
}

The kind of conflict recorded for a path, used to render the stable conflict-type token and human message.

Variants

Content

Both sides changed the file content differently (or both added it with differing content — an add/add).

Fields

add_add: bool

ModifyDelete

The file was deleted on one side and modified on the other.

Fields

deleted_in: String

The side label that deleted the path.

modified_in: String

The side label that modified (and thus kept) the path.

RenameContent

A file renamed on one side, with a content conflict against the other side’s change at the destination.

Fields

old_path: Vec<u8>

The original (pre-rename) path.

RenameRenameTwoToOne

Two paths were renamed to the same destination, producing a rename/rename(2to1) conflict.

Fields

ours_path: Vec<u8>

Ours’ pre-destination path.

theirs_path: Vec<u8>

Theirs’ pre-destination path.

RenameRenameOneToTwo

One source path was renamed to different destinations on each side, producing a rename/rename(1to2) conflict.

Fields

old_path: Vec<u8>

The pre-rename source path.

ours_path: Vec<u8>

Ours’ destination path.

theirs_path: Vec<u8>

Theirs’ destination path.

ours_label: String

The label for our side.

theirs_label: String

The label for their side.

RenameRenameOneToTwoStage

An auxiliary higher-stage entry for a rename/rename(1to2) conflict. The user-facing message is emitted by [RenameRenameOneToTwo].

DirRenameSplit

A directory was split evenly across multiple destinations, so no directory rename could be applied for paths the other side left there.

Fields

source_dir: Vec<u8>

The original directory with no unique destination.

RenameDelete

A file renamed on one side whose source was deleted on the other side.

Fields

old_path: Vec<u8>

The pre-rename source path.

renamed_in: String

The side label that performed the rename.

deleted_in: String

The side label that deleted the source.

FileDirectory

A file collides with a directory at the same path in the merged result: the directory wins at the original path and the file is moved aside to path~<branch> (merge-ort’s D/F conflict, unique_path). git emits CONFLICT (file/directory): directory in the way of <old> from <branch>; moving it to <new> instead.

Fields

original_path: Vec<u8>

The original (pre-move) path now occupied by the directory.

moved_from: String

The side label whose file was moved aside.

DirRenameLocation

A path was added/renamed under a directory the other side renamed, so the merge silently moved it into the renamed directory but, in merge.directoryRenames=conflict mode, flags it for the user to confirm. git emits CONFLICT (file location): ... suggesting it should perhaps be moved to <new_path>. The tree still contains the re-homed content.

Fields

old_path: Vec<u8>

The pre-re-home path (old_path in git’s message): where the side placed the file before directory-rename detection moved it.

renamed_from: Option<Vec<u8>>

Some(source) when the file was renamed into old_path by this side (git’s “renamed to” wording, naming the original source); None when it was a fresh add (git’s “added in” wording).

added_in: String

The side label that added/renamed the file (branch_with_new_path).

dir_renamed_in: String

The side label that renamed the directory (branch_with_dir_rename).

back_to_self: bool

True when the directory rename moved the file back onto its own base source path (rename-to-self) and the other side modified that path. The CONFLICT (file location) message is the same, but git records the path UNMERGED (stages 1/2/3) instead of staging the re-homed content cleanly: the index writers stage these 1/2/3, not at stage 0.

DirRenameImplicitCollision

A directory rename would have moved one or more paths onto this path, but it is already occupied (a file/dir in the way) or several sources map here. git emits CONFLICT (implicit dir rename): Existing file/dir at <path> in the way of implicit directory rename(s) putting the following path(s) there: <sources>. The path keeps its original content; the re-homed sources are left where they were.

Fields

sources: Vec<Vec<u8>>

The source path(s) the directory rename tried to move onto this path.

DistinctTypes

The two sides hold different object types at one path (regular↔symlink, regular↔gitlink, symlink↔gitlink). git’s process_entry (merge-ort.c ~4220) renames each regular-file side to path~<branch> so each type can be recorded somewhere, ignoring -Xours/-Xtheirs, and emits a single CONFLICT (distinct types) line. (gitlink↔gitlink and symlink↔symlink share an S_IFMT and never reach this arm.) This kind is attached to the leaf that carries the message — the side left at original_path when only one side moved, else ours; the other renamed leaf carries [DistinctTypesStage].

Fields

original_path: Vec<u8>

The original colliding path (git’s message subject and sort key).

ours_renamed: Option<Vec<u8>>

Some(p) when ours was renamed aside to p; None when ours stayed at original_path.

theirs_renamed: Option<Vec<u8>>

Some(p) when theirs was renamed aside to p; None when theirs stayed at original_path.

DistinctTypesStage

The non-message-carrying leaf of a [DistinctTypes] conflict. The user-facing line is emitted once by the [DistinctTypes] leaf.

Trait Implementations

impl Clone for MergeConflictKind

fn clone(&self) -> MergeConflictKind

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MergeConflictKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for MergeConflictKind

impl PartialEq for MergeConflictKind

fn eq(&self, other: &MergeConflictKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for MergeConflictKind