1.83 update

.github/workflows/main.yml

@@ -173,6 +173,13 @@ jobs:
     - run: rustup target add ${{ matrix.other }}
     - run: rustup component add rustc-dev llvm-tools-preview rust-docs
       if: startsWith(matrix.rust, 'nightly')
+    # Install fish, zsh, and elvish only on Ubuntu systems
+    - name: Install fish, zsh, and elvish on Ubuntu
+      run: sudo apt update -y && sudo apt install fish zsh elvish -y
+      if: matrix.os == 'ubuntu-latest'
+    - name: Install fish, elvish on macOS
+      run: brew install fish elvish
+      if: matrix.os == 'macos-14' || matrix.os == 'macos-13'
     - run: sudo apt update -y && sudo apt install lldb gcc-multilib libsecret-1-0 libsecret-1-dev -y
       if: matrix.os == 'ubuntu-latest'
     - run: rustup component add rustfmt || echo "rustfmt not available"
@@ -227,6 +234,7 @@ jobs:
       - run: rustup update --no-self-update stable && rustup default stable
       - run: rustup target add i686-unknown-linux-gnu
       - run: sudo apt update -y && sudo apt install gcc-multilib libsecret-1-0 libsecret-1-dev -y
+      - run: sudo apt update -y && sudo apt install fish zsh elvish -y
       - run: rustup component add rustfmt || echo "rustfmt not available"
       - run: cargo test -p cargo
         env:

Cargo.toml

@@ -36,7 +36,9 @@ cargo-util = { version = "0.2.14", path = "crates/cargo-util" }
 cargo-util-schemas = { version = "0.6.0", path = "crates/cargo-util-schemas" }
 cargo_metadata = "0.18.1"
 clap = "4.5.11"
+clap_complete = { version = "4.5.24", features = ["unstable-dynamic"] }
 color-print = "0.3.6"
+completest-pty = "0.5.3"
 core-foundation = { version = "0.10.0", features = ["mac_os_10_7_support"] }
 crates-io = { version = "0.40.4", path = "crates/crates-io" }
 criterion = { version = "0.5.1", features = ["html_reports"] }
@@ -153,6 +155,7 @@ cargo-platform.workspace = true
 cargo-util-schemas.workspace = true
 cargo-util.workspace = true
 clap = { workspace = true, features = ["wrap_help"] }
+clap_complete.workspace = true
 color-print.workspace = true
 crates-io.workspace = true
 curl = { workspace = true, features = ["http2"] }
@@ -239,6 +242,7 @@ features = [
 [dev-dependencies]
 annotate-snippets = { workspace = true, features = ["testing-colors"] }
 cargo-test-support.workspace = true
+completest-pty.workspace = true
 gix = { workspace = true, features = ["revision"] }
 same-file.workspace = true
 snapbox.workspace = true

src/bin/cargo/main.rs

@@ -1,5 +1,6 @@
 #![allow(clippy::self_named_module_files)] // false positive in `commands/build.rs`
 
+use cargo::core::features;
 use cargo::core::shell::Shell;
 use cargo::util::network::http::http_handle;
 use cargo::util::network::http::needs_custom_http_transport;
@@ -28,6 +29,13 @@ fn main() {
         }
     };
 
+    let nightly_features_allowed = matches!(&*features::channel(), "nightly" | "dev");
+    if nightly_features_allowed {
+        clap_complete::CompleteEnv::with_factory(|| cli::cli(&mut gctx))
+            .var("CARGO_COMPLETE")
+            .complete();
+    }
+
     let result = if let Some(lock_addr) = cargo::ops::fix_get_proxy_lock_addr() {
         cargo::ops::fix_exec_rustc(&gctx, &lock_addr).map_err(|e| CliError::from(e))
     } else {

src/doc/src/reference/unstable.md

@@ -117,6 +117,7 @@ Each new feature described below should explain how to use it.
     * [script](#script) --- Enable support for single-file `.rs` packages.
     * [lockfile-path](#lockfile-path) --- Allows to specify a path to lockfile other than the default path `<workspace_root>/Cargo.lock`.
     * [package-workspace](#package-workspace) --- Allows for packaging and publishing multiple crates in a workspace.
+    * [native-completions](#native-completions) --- Move cargo shell completions to native completions.
 
 ## allow-features
 
@@ -1686,6 +1687,30 @@ cargo +nightly -Zpackage-workspace --registry=my-registry package -p foo -p dep
 cargo +nightly -Zpackage-workspace --index=https://example.com package -p foo -p dep
 ```
 
+## native-completions
+* Original Issue: [#6645](https://github.com/rust-lang/cargo/issues/6645)
+* Tracking Issue: [#14520](https://github.com/rust-lang/cargo/issues/14520)
+
+This feature moves the handwritten completion scripts to Rust native, making it
+easier for us to add, extend and test new completions. This feature is enabled with the
+nightly channel, without requiring additional `-Z` options.
+
+### How to use native-completions feature:
+- bash:
+  Add `source <(CARGO_COMPLETE=bash cargo)` to your .bashrc.
+
+- zsh:
+  Add `source <(CARGO_COMPLETE=zsh cargo)` to your .zshrc.
+
+- fish:
+  Add `source (CARGO_COMPLETE=fish cargo | psub)` to `$XDG_CONFIG_HOME/fish/completions/cargo.fish`
+
+- elvish:
+  Add `eval (E:CARGO_COMPLETE=elvish cargo | slurp)` to `$XDG_CONFIG_HOME/elvish/rc.elv`
+
+- powershell:
+  Add `CARGO_COMPLETE=powershell cargo | Invoke-Expression` to `$PROFILE`.
+
 # Stabilized and removed features
 
 ## Compile progress

tests/testsuite/main.rs

@@ -166,6 +166,7 @@ mod rustflags;
 mod rustup;
 mod script;
 mod search;
+mod shell_completions;
 mod shell_quoting;
 mod source_replacement;
 mod ssh;

tests/testsuite/shell_completions.rs

@@ -0,0 +1,200 @@
+#![cfg(unix)]
+
+use cargo_test_support::cargo_test;
+use completest_pty::Runtime;
+use snapbox::assert_data_eq;
+
+#[cargo_test]
+fn bash() {
+    // HACK: At least on CI, bash is not working on macOS
+    if cfg!(target_os = "macos") {
+        return;
+    }
+
+    let input = "cargo \t\t";
+    let expected = snapbox::str![
+        "% 
+--version          --help             check              install            read-manifest      update
+--list             -V                 clean              locate-project     remove             vendor
+--explain          -v                 config             login              report             verify-project
+--verbose          -q                 doc                logout             run                version
+--quiet            -C                 fetch              metadata           rustc              yank
+--color            -Z                 fix                new                rustdoc            
+--locked           -h                 generate-lockfile  owner              search             
+--offline          add                help               package            test               
+--frozen           bench              info               pkgid              tree               
+--config           build              init               publish            uninstall          "
+    ];
+    let actual = complete(input, "bash");
+    assert_data_eq!(actual, expected);
+}
+
+#[cargo_test]
+fn elvish() {
+    // HACK: At least on CI, elvish is not working on macOS
+    if cfg!(target_os = "macos") {
+        return;
+    }
+
+    let input = "cargo \t\t";
+    let expected = snapbox::str![
+        "% cargo --config
+ COMPLETING argument  
+--color    --version  check              install         read-manifest  update        
+--config   -C         clean              locate-project  remove         vendor        
+--explain  -V         config             login           report         verify-project
+--frozen   -Z         doc                logout          run            version       
+--help     -h         fetch              metadata        rustc          yank          
+--list     -q         fix                new             rustdoc      
+--locked   -v         generate-lockfile  owner           search       
+--offline  add        help               package         test         
+--quiet    bench      info               pkgid           tree         
+--verbose  build      init               publish         uninstall    "
+    ];
+    let actual = complete(input, "elvish");
+    assert_data_eq!(actual, expected);
+}
+
+#[cargo_test]
+fn fish() {
+    // HACK: At least on CI, fish is not working on macOS
+    if cfg!(target_os = "macos") {
+        return;
+    }
+
+    let input = "cargo \t\t";
+    let expected = snapbox::str![
+        "% cargo 
+--version                                                                                  (Print version info and exit)
+--list                                                                                         (List installed commands)
+--explain                                                      (Provide a detailed explanation of a rustc error message)
+--verbose                                                        (Use verbose output (-vv very verbose/build.rs output))
+--quiet                                                                                (Do not print cargo log messages)
+--color                                                                                  (Coloring: auto, always, never)
+--locked                                                                (Assert that `Cargo.lock` will remain unchanged)
+--offline                                                                            (Run without accessing the network)
+--frozen                                                          (Equivalent to specifying both --locked and --offline)
+--config                                                                                (Override a configuration value)
+--help                                                                                                      (Print help)
+-V                                                                                         (Print version info and exit)
+-v                                                               (Use verbose output (-vv very verbose/build.rs output))
+-q                                                                                     (Do not print cargo log messages)
+-C                                                            (Change to DIRECTORY before doing anything (nightly-only))
+-Z                                             (Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details)
+-h                                                                                                          (Print help)
+add                                                                     (Add dependencies to a Cargo.toml manifest file)
+bench                                                                        (Execute all benchmarks of a local package)
+build                                                              (Compile a local package and all of its dependencies)
+check                                                     (Check a local package and all of its dependencies for errors)
+clean                                                            (Remove artifacts that cargo has generated in the past)
+config                                                                                    (Inspect configuration values)
+doc                                                                                    (Build a package's documentation)
+fetch                                                                 (Fetch dependencies of a package from the network)
+fix                                                                  (Automatically fix lint warnings reported by rustc)
+generate-lockfile                                                                  (Generate the lockfile for a package)
+help                                                                              (Displays help for a cargo subcommand)
+info                                                               (Display information about a package in the registry)
+init                                                               (Create a new cargo package in an existing directory)
+install                                                                                          (Install a Rust binary)
+locate-project                                             (Print a JSON representation of a Cargo.toml file's location)
+login                                                                                            (Log in to a registry.)
+logout                                                                   (Remove an API token from the registry locally)
+metadata  (Output the resolved dependencies of a package, the concrete used versions including overrides, in machine-r…)
+new                                                                               (Create a new cargo package at <path>)
+owner                                                                     (Manage the owners of a crate on the registry)
+package                                                        (Assemble the local package into a distributable tarball)
+pkgid                                                                    (Print a fully qualified package specification)
+publish                                                                               (Upload a package to the registry)
+read-manifest                                                    (Print a JSON representation of a Cargo.toml manifest.)
+remove                                                             (Remove dependencies from a Cargo.toml manifest file)
+report                                                                   (Generate and display various kinds of reports)
+run                                                                       (Run a binary or example of the local package)
+rustc                                                        (Compile a package, and pass extra options to the compiler)
+rustdoc                                                 (Build a package's documentation, using specified custom flags.)
+search                                                  (Search packages in the registry. Default registry is crates.io)
+test                                      (Execute all unit and integration tests and build examples of a local package)
+tree                                                                (Display a tree visualization of a dependency graph)
+uninstall                                                                                         (Remove a Rust binary)
+update                                                          (Update dependencies as recorded in the local lock file)
+vendor                                                                   (Vendor all dependencies for a project locally)
+verify-project                                                                     (Check correctness of crate manifest)
+version                                                                                       (Show version information)
+yank                                                                              (Remove a pushed crate from the index)"];
+
+    let actual = complete(input, "fish");
+    assert_data_eq!(actual, expected);
+}
+
+#[cargo_test]
+fn zsh() {
+    let input = "cargo \t\t";
+    let expected = snapbox::str![
+        "% cargo
+--color            --version          check              install            read-manifest      update
+--config           -C                 clean              locate-project     remove             vendor
+--explain          -V                 config             login              report             verify-project
+--frozen           -Z                 doc                logout             run                version
+--help             -h                 fetch              metadata           rustc              yank
+--list             -q                 fix                new                rustdoc            
+--locked           -v                 generate-lockfile  owner              search             
+--offline          add                help               package            test               
+--quiet            bench              info               pkgid              tree               
+--verbose          build              init               publish            uninstall          "
+    ];
+    let actual = complete(input, "zsh");
+    assert_data_eq!(actual, expected);
+}
+
+fn complete(input: &str, shell: &str) -> String {
+    let shell = shell.into();
+
+    // Load the runtime
+    let mut runtime = match shell {
+        "bash" => load_runtime::<completest_pty::BashRuntimeBuilder>("bash"),
+        "elvish" => load_runtime::<completest_pty::ElvishRuntimeBuilder>("elvish"),
+        "fish" => load_runtime::<completest_pty::FishRuntimeBuilder>("fish"),
+        "zsh" => load_runtime::<completest_pty::ZshRuntimeBuilder>("zsh"),
+        _ => panic!("Unsupported shell: {}", shell),
+    };
+
+    // Exec the completion
+    let term = completest_pty::Term::new();
+    let actual = runtime.complete(input, &term).unwrap();
+
+    actual
+}
+
+// Return the scratch directory to keep it not being dropped
+fn load_runtime<R: completest_pty::RuntimeBuilder>(shell: &str) -> Box<dyn completest_pty::Runtime>
+where
+    <R as completest_pty::RuntimeBuilder>::Runtime: 'static,
+{
+    let home = cargo_test_support::paths::home();
+
+    let bin_path = cargo_test_support::cargo_exe();
+    let bin_root = bin_path.parent().unwrap().to_owned();
+
+    let mut runtime = Box::new(R::new(bin_root, home).unwrap());
+
+    match shell {
+        "bash" => runtime
+            .register("", "source <(CARGO_COMPLETE=bash cargo)")
+            .unwrap(),
+        "elvish" => runtime
+            .register("", "eval (E:CARGO_COMPLETE=elvish cargo | slurp)")
+            .unwrap(),
+        "fish" => runtime
+            .register("cargo", "source (CARGO_COMPLETE=fish cargo | psub)")
+            .unwrap(),
+        "zsh" => runtime
+            .register(
+                "cargo",
+                "#compdef cargo
+source <(CARGO_COMPLETE=zsh cargo)",
+            )
+            .unwrap(),
+        _ => panic!("Unsupported shell: {}", shell),
+    }
+
+    runtime
+}