Native completions have incorrect behavior when completing in the middle with `sudo`

[epage]

Problem

cargo does not complete correctly when I try to complete in the middle with sudo using the native-completions feature.

Steps

1. Run source <(CARGO_COMPLETE=bash cargo +nightly) to ensure that we're using native-completions feature
2. Create a cargo project with two examples, apple and banana
3. Invoke completion like this:

cargo build --example ap<TAB> --example banana

4. Notice that we've got the correct result:

cargo build --example apple --example banana

5. Prepend with sudo and invoke completion again:

sudo cargo build --example ap<TAB> --example banana

6. Notice that we've got the wrong result:

sudo cargo build --example banana --example banana

Possible Solution(s)

No response

Notes

Completions by rustup completions bash are correct in both cases, and this bug only occurs when using completions by CARGO_COMPLETE=bash cargo +nightly.

Version

$ cargo +nightly version --verbose
cargo 1.91.0-nightly (71eb84f21 2025-08-17)
release: 1.91.0-nightly
commit-hash: 71eb84f21aef43c07580c6aed6f806a6299f5042
commit-date: 2025-08-17
host: x86_64-unknown-linux-gnu
libgit2: 1.9.1 (sys:0.20.2 vendored)
libcurl: 8.14.1-DEV (sys:0.4.82+curl-8.14.1 vendored ssl:OpenSSL/3.5.0)
ssl: OpenSSL 3.5.0 8 Apr 2025
os: Ubuntu 24.4.0 (noble) [64-bit]

[epage]

In figuring this out, maybe we'd gain insights into how to resolve #5653

[Unique-Usman]

Hi @epage, following up with our discussion, I will like to take on this. Thank you.

[Unique-Usman]

Hi @epage, I am already looking towards the issue,

The main cause of the issue is mostly because, the Native was setup only for when the command starts with Cargo but, was not setup when the command start with sudo. I guess the solution will be to find where the completion is defined or implemented, and implement it for Sudo scenerio.

[Unique-Usman]

Also @epage, I am guessing the reason why the issue is open against clap is because the cargo uses a library from the clap ?

[epage]

The main cause of the issue is mostly because, the Native was setup only for when the command starts with Cargo but, was not setup when the command start with sudo. I guess the solution will be to find where the completion is defined or implemented, and implement it for Sudo scenerio.

Maybe I'm missing something but that seems to be re-framing the symptom while the root cause still needs to be determined.

It appears that sudo can tell bash to delegate completions to another program (like we want in #5653). What does this look like to our completer? How is this normally expected to work in completers?

I am guessing the reason why the issue is open against clap is because the cargo uses a library from the clap ?

Yes, cargo is using clap_complete::env to handle completions.

[Unique-Usman]

Hi @epage,

So, I have made some attempt in figuring out what the problem is with when sudo is placed at the front of the cargo,

Basically when someone run

source <(CARGO_COMPLETE=bash cargo +nightly)

this part of the command is used

https://github.com/rust-lang/cargo/blob/master/src/bin/cargo/main.rs#L43

    if nightly_features_allowed {
        let _span = tracing::span!(tracing::Level::TRACE, "completions").entered();
        let args = std::env::args_os();
        let current_dir = std::env::current_dir().ok();
        let completer = clap_complete::CompleteEnv::with_factory(|| {
            let mut gctx = GlobalContext::default().expect("already loaded without errors");
            cli::cli(&mut gctx)
        })
        .var("CARGO_COMPLETE");
        if completer
            .try_complete(args, current_dir.as_deref())

and the above basically make a call to clap

 pub fn try_complete(
        self,
        args: impl IntoIterator<Item = impl Into<OsString>>,
        current_dir: Option<&std::path::Path>,
    ) -> clap::error::Result<bool> {
        self.try_complete_(args.into_iter().map(|a| a.into()).collect(), current_dir)
    }

    fn try_complete_(
        self,
        mut args: Vec<OsString>,
        current_dir: Option<&std::path::Path>,
    ) -> clap::error::Result<bool> {
        let Some(name) = std::env::var_os(self.var) else {
            return Ok(false);
        };
        if name.is_empty() || name == "0" {
            return Ok(false);
        }

        // Ensure any child processes called for custom completers don't activate their own
        // completion logic.
        std::env::remove_var(self.var);

        let shell = self.shell(std::path::Path::new(&name))?;

        let mut cmd = (self.factory)();
        cmd.build();

        let completer = args.remove(0);
        let escape_index = args
            .iter()
            .position(|a| *a == "--")
            .map(|i| i + 1)
            .unwrap_or(args.len());
        args.drain(0..escape_index);
        if args.is_empty() {
            let mut buf = Vec::new();
            self.write_registration(&cmd, current_dir, shell, completer, &mut buf)?;
            std::io::stdout().write_all(&buf)?;
        } else {
            let mut buf = Vec::new();
            shell.write_complete(&mut cmd, args, current_dir, &mut buf)?;
            std::io::stdout().write_all(&buf)?;
        }

at this point, the if args.is_empty() will be true and self.write_registration() will be called and this will make a call to shell.write_registration()

https://github.com/clap-rs/clap/blob/master/clap_complete/src/env/mod.rs#L245

and shell.write_registration() basically makes a create a shell program

        let script = r#"
_clap_complete_NAME() {
    local IFS=$'\013'
    local _CLAP_COMPLETE_INDEX=${COMP_CWORD}
    local _CLAP_COMPLETE_COMP_TYPE=${COMP_TYPE}
    if compopt +o nospace 2> /dev/null; then
        local _CLAP_COMPLETE_SPACE=false
    else
        local _CLAP_COMPLETE_SPACE=true
    fi
    local words=("${COMP_WORDS[@]}")
    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
        words[COMP_CWORD]="$2"
    fi
    COMPREPLY=( $( \
        _CLAP_IFS="$IFS" \
        _CLAP_COMPLETE_INDEX="$_CLAP_COMPLETE_INDEX" \
        _CLAP_COMPLETE_COMP_TYPE="$_CLAP_COMPLETE_COMP_TYPE" \
        _CLAP_COMPLETE_SPACE="$_CLAP_COMPLETE_SPACE" \
        VAR="bash" \
        "COMPLETER" -- "${words[@]}" \
    ) )
    if [[ $? != 0 ]]; then
        unset COMPREPLY
    elif [[ $_CLAP_COMPLETE_SPACE == false ]] && [[ "${COMPREPLY-}" =~ [=/:]$ ]]; then
        compopt -o nospace
    fi
}
if [[ "${BASH_VERSINFO[0]}" -eq 4 && "${BASH_VERSINFO[1]}" -ge 4 || "${BASH_VERSINFO[0]}" -gt 4 ]]; then
    complete -o nospace -o bashdefault -o nosort -F _clap_complete_NAME BIN
else
    complete -o nospace -o bashdefault -F _clap_complete_NAME BIN
fi
"#
        .replace("NAME", &escaped_name)
        .replace("BIN", bin)
        .replace("COMPLETER", &completer)

and this is what is sourced.

https://github.com/clap-rs/clap/blob/master/clap_complete/src/env/shells.rs

[Unique-Usman]

an example version created for me

_clap_complete_cargo() {
    local IFS=$'\013'
    local _CLAP_COMPLETE_INDEX=${COMP_CWORD}
    local _CLAP_COMPLETE_COMP_TYPE=${COMP_TYPE}
    if compopt +o nospace 2> /dev/null; then
        local _CLAP_COMPLETE_SPACE=false
    else
        local _CLAP_COMPLETE_SPACE=true
    fi
    local words=("${COMP_WORDS[@]}")
    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
        words[COMP_CWORD]="$2"
    fi
    COMPREPLY=( $( \
        _CLAP_IFS="$IFS" \
        _CLAP_COMPLETE_INDEX="$_CLAP_COMPLETE_INDEX" \
        _CLAP_COMPLETE_COMP_TYPE="$_CLAP_COMPLETE_COMP_TYPE" \
        _CLAP_COMPLETE_SPACE="$_CLAP_COMPLETE_SPACE" \
        CARGO_COMPLETE="bash" \
        "/home/uniqueusman/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/bin/cargo" -- "${words[@]}" \
    ) )
    if [[ $? != 0 ]]; then
        unset COMPREPLY
    elif [[ $_CLAP_COMPLETE_SPACE == false ]] && [[ "${COMPREPLY-}" =~ [=/:]$ ]]; then
        compopt -o nospace
    fi
}
if [[ "${BASH_VERSINFO[0]}" -eq 4 && "${BASH_VERSINFO[1]}" -ge 4 || "${BASH_VERSINFO[0]}" -gt 4 ]]; then
    complete -o nospace -o bashdefault -o nosort -F _clap_complete_cargo cargo
else
    complete -o nospace -o bashdefault -F _clap_complete_cargo cargo
fi

[Unique-Usman]

So any time a completion start with cargo it basically call the above shell function which set some variable and basically the cargo again and passed those variables to it.

The shell is able to know that it should called cargo for completion when the first part of the completion is cargo because of the below script.

if [[ "${BASH_VERSINFO[0]}" -eq 4 && "${BASH_VERSINFO[1]}" -ge 4 || "${BASH_VERSINFO[0]}" -gt 4 ]]; then
    complete -o nospace -o bashdefault -o nosort -F _clap_complete_cargo cargo
else
    complete -o nospace -o bashdefault -F _clap_complete_cargo cargo
fi

for completion instead of cargo to call shell.write_registration() it basically call shell.write_completion which take care of the completion.

https://github.com/clap-rs/clap/blob/master/clap_complete/src/env/shells.rs#L72C5-L72C7

From what I understand the problem when the shell sees sudo cargo, it is calling completion for the sudo and not for the cargo,

One solution I am thinking of is that,

We enhanced the bash script generated by shell.write_completion to sort of call completion for cargo when it see that the second argument after sudo is cargo

something like this will be the crux of the command

    if [[ "${words[0]}" == "sudo" && "${words[1]}" == "cargo" ]]; then

what do you think ?