use std::{    path::Path,    sync::atomic::{AtomicBool, Ordering},}; use gix_features::progress::{NestedProgress, Progress};use gix_ref::transaction::{LogChange, PreviousValue, RefEdit, RefLog}; use crate::config::{    cache::util::ApplyLeniency,    tree::{Core, Extensions, Worktree},}; /// The kind of `HEAD` to install in a newly added worktree.#[derive(Clone, Debug, Eq, PartialEq)]pub enum Head {    /// Check out an existing local branch in the default reference namespace.    Attached(gix_ref::FullName),    /// Check out a commit with a detached `HEAD`.    Detached(gix_hash::ObjectId),} /// The error returned by [`Repository::add_worktree()`][crate::Repository::add_worktree()].#[derive(Debug, thiserror::Error)]#[expect(missing_docs)]pub enum Error {    #[error(transparent)]    ConfigBoolean(#[from] crate::config::boolean::Error),    #[error("Could not enable relative worktrees in the shared configuration")]    Configure(#[from] crate::config::file_mut::Error),    #[error("Could not set the repository format for relative worktrees")]    SetConfig(#[from] gix_config::file::set_raw_value::Error),    #[error("Could not upgrade the repository format for relative worktrees")]    RepositoryFormat(#[from] crate::config::Error),    #[error("Cannot upgrade repository format with unsupported extension {name:?}")]    UnsupportedExtension { name: String },    #[error("Could not read the source worktree configuration")]    ReadWorktreeConfig(#[source] gix_config::file::init::from_paths::Error),    #[error("Could not write the new worktree configuration")]    WriteWorktreeConfig(#[source] std::io::Error),    #[error("{name:?} is not a local branch")]    NotLocalBranch { name: gix_ref::FullName },    #[error("The local branch {name:?} is checked out in {worktree_dirs:?}")]    CheckedOut {        name: gix_ref::FullName,        worktree_dirs: Vec<std::path::PathBuf>,    },    #[error("The worktree destination {destination:?} is already registered")]    DestinationRegistered { destination: std::path::PathBuf },    #[error("Failed to read or iterate worktree directories")]    WorktreeListing(#[source] std::io::Error),    #[error("Could not open a worktree repository")]    OpenWorktreeRepo(#[source] crate::open::Error),    #[error("Failed to follow a symbolic reference while inspecting worktrees")]    FollowSymref(#[source] gix_ref::file::find::existing::Error),    #[error("The local branch could not be found")]    FindBranch(#[from] crate::reference::find::existing::Error),    #[error("The local branch could not be peeled to a commit")]    PeelBranch(#[from] crate::reference::peel::to_kind::Error),    #[error("The detached target is not an existing commit")]    FindDetachedCommit(#[from] crate::object::find::existing::with_conversion::Error),    #[error("Could not decode the commit")]    DecodeCommit(#[from] gix_object::decode::Error),    #[error("Could not prepare the linked worktree")]    Prepare(#[source] std::io::Error),    #[error("Could not write the linked worktree HEAD")]    WriteHead(#[source] std::io::Error),    #[error("Could not initialize the linked worktree HEAD and its reflog")]    InitializeHead(#[source] crate::reference::edit::Error),    #[error("Could not create an index from the target tree")]    IndexFromTree(#[from] crate::repository::index_from_tree::Error),    #[error(transparent)]    CheckoutOptions(#[from] crate::config::checkout_options::Error),    #[error("Failed to reopen the object database for checkout")]    OpenArcOdb(#[source] std::io::Error),    #[error(transparent)]    Checkout(#[from] gix_worktree_state::checkout::Error),    #[error("Adding the worktree was interrupted")]    Interrupted,    #[error("Could not write the linked worktree index")]    WriteIndex(#[from] gix_index::file::write::Error),    #[error("Could not finish adding the linked worktree")]    Persist(#[source] std::io::Error),} impl crate::Repository {    /// Add and check out a linked worktree at `destination` with the given `head`.    ///    /// Attached heads must name an existing local branch which isn't checked out or reserved by an ongoing    /// bisect or rebase in any worktree.    /// Reference namespaces are ignored for branch lookup, occupancy checks, and the returned repository, like    /// `git worktree add`. The source repository's namespace is preserved.    /// The destination must either not exist or be an empty, unregistered directory. Any files created by this    /// method are removed if adding the worktree fails or is interrupted.    ///    /// With `extensions.worktreeConfig`, the source's `config.worktree` is copied before checkout, excluding    /// `core.worktree` and a true `core.bare` setting.    /// The new `HEAD` reflog records its initial commit when `core.logAllRefUpdates` permits it.    ///    /// `core.sharedRepository` applies to repository metadata, including `HEAD`, its reflog, and the index.    /// Like Git when preparing `<destination>/.git`, this also applies shared permissions to newly created    /// destination and parent directories, as well as the common `worktrees` directory. Existing directories    /// retain their permissions. The private Git directory and checked-out files and subdirectories use normal    /// filesystem permissions, including the umask. As a deviation from Git, the linking files `.git`, `gitdir`,    /// `commondir`, and `locked` also receive shared permissions.    ///    /// `worktree.useRelativePaths` selects relative links instead of the default absolute links. When enabled,    /// the shared config is upgraded to repository format version 1 with `extensions.relativeWorktrees=true`.    /// This compatibility marker remains set even if checkout fails, and requires Git 2.48 or newer.    /// The parent repository's configuration snapshot is unchanged; call [`reload()`][Self::reload()] to refresh it.    pub fn add_worktree<P>(        &self,        destination: impl AsRef<Path>,        head: Head,        mut progress: P,        should_interrupt: &AtomicBool,    ) -> Result<(crate::Repository, gix_worktree_state::checkout::Outcome), Error>    where        P: NestedProgress,        P::SubProgress: NestedProgress + 'static,    {        let destination = destination.as_ref();        let relative_paths = Worktree::USE_RELATIVE_PATHS            .enrich_error(self.config.resolved.boolean(Worktree::USE_RELATIVE_PATHS))            .with_leniency(self.config.lenient_config)?            .unwrap_or_default();        let (head_target, commit_id, root_tree_id) = match head {            Head::Attached(name) => {                if name.category() != Some(gix_ref::Category::LocalBranch) {                    return Err(Error::NotLocalBranch { name });                }                let checked_out = self.checked_out_branches(None).map_err(|err| match err {                    crate::repository::worktree::CheckedOutBranchesError::WorktreeListing(err) => {                        Error::WorktreeListing(err)                    }                    crate::repository::worktree::CheckedOutBranchesError::OpenWorktreeRepo(err) => {                        Error::OpenWorktreeRepo(err)                    }                    crate::repository::worktree::CheckedOutBranchesError::FollowSymref(err) => Error::FollowSymref(err),                })?;                if let Some(worktree_dirs) = checked_out.get(&name) {                    return Err(Error::CheckedOut {                        name,                        worktree_dirs: worktree_dirs.clone(),                    });                }                let mut source = self.clone();                source.clear_namespace();                let mut reference = source.find_reference(name.as_ref())?;                let commit = reference.peel_to_commit()?;                let root_tree_id = commit.tree_id()?.detach();                (gix_ref::Target::Symbolic(name), commit.id, root_tree_id)            }            Head::Detached(commit_id) => {                let root_tree_id = self.find_commit(commit_id)?.tree_id()?.detach();                (gix_ref::Target::Object(commit_id), commit_id, root_tree_id)            }        };        if should_interrupt.load(Ordering::Relaxed) {            return Err(Error::Interrupted);        }         let main_repo = self.main_repo().map_err(Error::OpenWorktreeRepo)?;        let mut registered_destinations = main_repo.workdir().map(Path::to_owned).into_iter().collect::<Vec<_>>();        for worktree in self.worktrees().map_err(Error::WorktreeListing)? {            registered_destinations.push(worktree.base().map_err(Error::WorktreeListing)?);        }        let prepared = gix_worktree::add::prepare(            self.common_dir(),            destination,            gix_worktree::add::Options {                relative_paths,                shared_repository_permissions: self.config.shared_repository_permissions,            },        )        .map_err(Error::Prepare)?;        let canonical_destination = std::fs::canonicalize(prepared.work_dir()).map_err(Error::Prepare)?;        for registered_destination in registered_destinations {            let registered_destination = gix_path::realpath(registered_destination)                .map_err(|err| Error::WorktreeListing(std::io::Error::other(err)))?;            let same_destination = if registered_destination == prepared.work_dir() {                true            } else {                match std::fs::canonicalize(&registered_destination) {                    Ok(path) => path == canonical_destination,                    Err(err) if err.kind() == std::io::ErrorKind::NotFound => false,                    Err(err) => return Err(Error::WorktreeListing(err)),                }            };            if same_destination {                return Err(Error::DestinationRegistered {                    destination: destination.to_owned(),                });            }        }        if relative_paths {            let mut config = self.config_file_mut(self.common_dir().join("config"))?;            let version = Core::REPOSITORY_FORMAT_VERSION                .try_into_usize(config.integer(Core::REPOSITORY_FORMAT_VERSION))                .map_err(crate::config::Error::from)?                .unwrap_or_default();            if version > 1 {                return Err(crate::config::Error::UnsupportedRepositoryFormatVersion { version }.into());            }            if version == 0 {                // These are Git's grandfathered v0 extensions. Others become significant on upgrade.                for section in config.sections_by_name("extensions").into_iter().flatten() {                    for name in section.value_names() {                        if section.header().subsection_name().is_some()                            || !["noop", "preciousobjects", "partialclone", "worktreeconfig"]                                .iter()                                .any(|known| name.eq_ignore_ascii_case(known))                        {                            return Err(Error::UnsupportedExtension { name });                        }                    }                }                config.set_raw_value(Core::REPOSITORY_FORMAT_VERSION, "1")?;            }            let enabled = Extensions::RELATIVE_WORKTREES                .enrich_error(config.boolean(Extensions::RELATIVE_WORKTREES))?                .unwrap_or_default();            if version == 0 || !enabled {                config.set_raw_value(Extensions::RELATIVE_WORKTREES, "true")?;                config.commit()?;            }        }        // Opening the repository requires HEAD. Preserve symbolic targets so conditional configuration        // can see the branch; detached HEADs start at null so their first update records initialization.        let mut head_contents = Vec::with_capacity(6 + self.object_hash().len_in_hex());        let reflog_mode = match &head_target {            gix_ref::Target::Object(_) => {                self.object_hash()                    .null()                    .write_hex_to(&mut head_contents)                    .map_err(Error::WriteHead)?;                RefLog::AndReference            }            gix_ref::Target::Symbolic(name) => {                head_contents.extend_from_slice(b"ref: ");                head_contents.extend_from_slice(name.as_bstr());                RefLog::Only            }        };        head_contents.push(b'\n');        std::fs::write(prepared.git_dir().join("HEAD"), head_contents).map_err(Error::WriteHead)?;         if Extensions::WORKTREE_CONFIG            .enrich_error(self.config.resolved.boolean(Extensions::WORKTREE_CONFIG))            .with_leniency(self.config.lenient_config)?            .unwrap_or_default()        {            copy_worktree_config(                &self.git_dir().join("config.worktree"),                &prepared.git_dir().join("config.worktree"),            )?;        }         let options = self            .options            .clone()            .without_repository_environment_overrides()            .open_path_as_is(true);        let mut repo = crate::ThreadSafeRepository::open_opts(prepared.git_dir(), options)            .map_err(Error::OpenWorktreeRepo)?            .to_thread_local();        repo.clear_namespace();        gix_fs::set_shared_repository_permissions(            &repo.git_dir().join("HEAD"),            repo.config.shared_repository_permissions,        )        .map_err(Error::WriteHead)?;        // Like clone, initialize a symbolic HEAD's log without dereferencing or updating its branch.        repo.edit_reference(RefEdit::update_with_log(            "HEAD".try_into().expect("valid reference name"),            commit_id,            PreviousValue::Any,            LogChange {                mode: reflog_mode,                ..Default::default()            },        ))        .map_err(Error::InitializeHead)?;        let mut index = repo.index_from_tree(&root_tree_id)?;        let mut checkout_options = repo.checkout_options(gix_worktree::stack::state::attributes::Source::IdMapping)?;        checkout_options.destination_is_initially_empty = true;         let mut files = progress.add_child("checkout");        let mut bytes = progress.add_child("writing");        files.init(Some(index.entries().len()), crate::progress::count("files"));        bytes.init(None, crate::progress::bytes());        let started = std::time::Instant::now();        let outcome = gix_worktree_state::checkout(            &mut index,            prepared.work_dir(),            repo.objects.clone().into_arc().map_err(Error::OpenArcOdb)?,            &files,            &bytes,            should_interrupt,            checkout_options,        )?;        files.show_throughput(started);        bytes.show_throughput(started);        if should_interrupt.load(Ordering::Relaxed) {            return Err(Error::Interrupted);        }        index.write(Default::default(), repo.config.shared_repository_permissions)?;        prepared.persist().map_err(Error::Persist)?;        Ok((repo, outcome))    }} fn copy_worktree_config(source: &Path, destination: &Path) -> Result<(), Error> {    let mut config = match gix_config::File::from_path_no_includes(source.to_owned(), gix_config::Source::Worktree) {        Ok(config) => config,        Err(gix_config::file::init::from_paths::Error::Io { source, .. })            if source.kind() == std::io::ErrorKind::NotFound =>        {            return Ok(());        }        Err(err) => return Err(Error::ReadWorktreeConfig(err)),    };    if Core::BARE.enrich_error(config.boolean(Core::BARE))?.unwrap_or_default()        && let Ok(mut values) = config.raw_values_mut(Core::BARE)    {        values.delete_all();    }    if let Ok(mut values) = config.raw_values_mut(Core::WORKTREE) {        values.delete_all();    }    config        .write_to(&mut std::fs::File::create(destination).map_err(Error::WriteWorktreeConfig)?)        .map_err(Error::WriteWorktreeConfig)}