emacsd/elpa/cargo-20190902.754/cargo-process.elc

;ELC
;;; Compiled
;;; in Emacs version 26.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301!\210\300\302!\210\300\303!\210\300\304!\210\305\306\307\310\311\312\313\314&\210\315\316\317\320\321DD\322\323\324\313\306&\210\315\325\317\320\326DD\327\323\324\313\306&\210\315\330\317\320\331DD\332\323\333\313\306&\210\315\334\317\320\335DD\336\313\306%\207" [require compile button rust-mode markdown-mode custom-declare-group cargo-process nil "Cargo Process group." :prefix "cargo-process-" :group cargo custom-declare-variable cargo-process--custom-path-to-bin funcall function #[0 "\300\301!\206\302\301\303\"\206\304\207" [executable-find "cargo" expand-file-name "~/.cargo/bin" "/usr/local/bin/cargo"] 3] "Custom path to the cargo executable" :type file cargo-process--rustc-cmd #[0 "\300\301!\206\302\301\303\"\206\304\207" [executable-find "rustc" expand-file-name "~/.cargo/bin" "/usr/local/bin/rustc"] 3] "Custom path to the rustc executable" cargo-process--enable-rust-backtrace #[0 "\300\207" [nil] 1] "Set RUST_BACKTRACE environment variable to 1 for tasks test and run" boolean cargo-process--command-flags #[0 "\300\207" [#1=""] 1 #1#] "Flags to be added to every cargo command when run."] 8)
#@30 Keymap for Cargo major mode.
(defvar cargo-process-mode-map (byte-code "\301 \244\207" [compilation-mode-map make-sparse-keymap] 2) (#$ . 1553))
#@52 These commands should not specify a manifest file.
(defvar cargo-process--no-manifest-commands '("New" "Init" "Search" "Fmt") (#$ . 1705))
#@34 Command used last for repeating.
(defvar cargo-process-last-command nil (#$ . 1850))
(byte-code "\300\301!\210\302\303\304\305\306DD\307#\210\302\310\304\305\311DD\312#\210\302\313\304\305\314DD\315#\210\302\316\304\305\317DD\320#\210\302\321\304\305\322DD\320#\210\302\323\304\305\324DD\325#\210\302\326\304\305\327DD\330#\210\302\331\304\305\332DD\333#\210\302\334\304\305\335DD\336#\210\302\337\304\305\340DD\341#\210\302\342\304\305\343DD\344#\210\302\345\304\305\346DD\347#\210\302\350\304\305\351DD\352#\210\302\353\304\305\354DD\355#\210\302\356\304\305\357DD\360#\210\302\361\304\305\362DD\363#\210\302\364\304\305\365DD\366#\210\302\367\304\305\370DD\371#\210\302\372\304\305\373DD\374#\210\302\375\304\305\376DD\377#\210\302\201@\304\305\201ADD\201B#\210\302\201C\304\305\201DDD\201E#\207" [make-variable-buffer-local cargo-process-last-command custom-declare-variable cargo-process--command-bench funcall function #[0 "\300\207" [#1="bench"] 1 #1#] "Subcommand used by `cargo-process-bench'." cargo-process--command-build #[0 "\300\207" [#2="build"] 1 #2#] "Subcommand used by `cargo-process-build'." cargo-process--command-clean #[0 "\300\207" [#3="clean"] 1 #3#] "Subcommand used by `cargo-process-clean'." cargo-process--command-doc #[0 "\300\207" [#4="doc"] 1 #4#] "Subcommand used by `cargo-process-doc'." cargo-process--command-doc-open #[0 "\300\207" [#5="doc --open"] 1 #5#] cargo-process--command-new #[0 "\300\207" [#6="new"] 1 #6#] "Subcommand used by `cargo-process-new'." cargo-process--command-init #[0 "\300\207" [#7="init"] 1 #7#] "Subcommand used by `cargo-process-init'." cargo-process--command-run #[0 "\300\207" [#8="run"] 1 #8#] "Subcommand used by `cargo-process-run'." cargo-process--command-run-bin #[0 "\300\207" [#9="run --bin"] 1 #9#] "Subcommand used by `cargo-process-run-bin'." cargo-process--command-run-example #[0 "\300\207" [#10="run --example"] 1 #10#] "Subcommand used by `cargo-process-run-example'." cargo-process--command-search #[0 "\300\207" [#11="search"] 1 #11#] "Subcommand used by `cargo-process-search'." cargo-process--command-test #[0 "\300\207" [#12="test"] 1 #12#] "Subcommand used by `cargo-process-test'." cargo-process--command-current-test #[0 "\300\207" [#13="test"] 1 #13#] "Subcommand used by `cargo-process-current-test'." cargo-process--command-current-file-tests #[0 "\300\207" [#14="test"] 1 #14#] "Subcommand used by `cargo-process-current-file-tests'." cargo-process--command-update #[0 "\300\207" [#15="update"] 1 #15#] "Subcommand used by `cargo-process-update'." cargo-process--command-fmt #[0 "\300\207" [#16="fmt"] 1 #16#] "Subcommand used by `cargo-process-fmt'." cargo-process--command-outdated #[0 "\300\207" [#17="outdated -R"] 1 #17#] "Subcommand used by `cargo-process-outdated'." cargo-process--command-check #[0 "\300\207" [#18="check"] 1 #18#] "Subcommand used by `cargo-process-check'." cargo-process--command-clippy #[0 "\300\207" [#19="clippy"] 1 #19#] "Subcommand used by `cargo-process-clippy'." cargo-process--command-add #[0 "\300\207" [#20="add"] 1 #20#] "Subcommand used by `cargo-process-add'." cargo-process--command-rm #[0 "\300\207" [#21="rm"] 1 #21#] "Subcommand used by `cargo-process-rm'." cargo-process--command-upgrade #[0 "\300\207" [#22="upgrade"] 1 #22#] "Subcommand used by `cargo-process-upgrade'."] 5)
(defvar cargo-process-favorite-crates nil)
(byte-code "\300\301\302\303\304\305%\210\300\306\307\310\304\305%\210\300\311\312\313\304\305%\210\300\314\315\316\304\305%\210\300\317\320\321\304\305%\210\300\322\323\324\304\305%\207" [custom-declare-face cargo-process--ok-face ((t (:inherit success))) "Ok face" :group cargo-process cargo-process--error-face ((t (:inherit error))) "Error face" cargo-process--warning-face ((t (:inherit warning))) "Warning face" cargo-process--pointer-face ((t (:inherit font-lock-negation-char-face))) "Pointer face" cargo-process--standard-face ((t (:inherit font-lock-comment-face))) "Standard face" cargo-process--errno-face ((t (:inherit link))) "Error number face"] 6)
(defconst cargo-process--rust-backtrace "RUST_BACKTRACE")
#@40 Regex to find Rust unit test function.
(defconst cargo-process-test-regexp "^[[:space:]]*fn[[:space:]]*" (#$ . 5941))
(defconst cargo-process-test-mod-regexp "^[[:space:]]*mod[[:space:]]+[[:word:][:multibyte:]_][[:word:][:multibyte:]_[:digit:]]*[[:space:]]*{")
#@58 Minimal highlighting expressions for cargo-process mode.
(defconst cargo-process-font-lock-keywords '(("^error\\:?" quote cargo-process--error-face) ("^warning\\:?" quote cargo-process--warning-face) ("^ *\\^\\~* *$" quote cargo-process--pointer-face) ("^ *Compiling.*" quote cargo-process--standard-face) ("^ *Running.*" quote cargo-process--standard-face) ("^ *Updating.*" quote cargo-process--standard-face) ("test result: FAILED." quote cargo-process--error-face) ("test result: ok." quote cargo-process--ok-face) ("test .* FAILED" quote cargo-process--error-face) ("test .* ok" quote cargo-process--ok-face)) (#$ . 6208))
#@50 A regular expression to match Rust error number.
(defconst cargo-process--errno-regex "\\bE[0-9]\\{4\\}\\b" (#$ . 6841))
(define-button-type 'rustc-errno 'follow-link t 'face 'cargo-process--errno-face 'action 'cargo-process--explain-action)
(defalias 'cargo-process--defun-at-point-p #[0 "\301\302\303 \304 \"\"\207" [cargo-process-test-regexp string-match buffer-substring-no-properties line-beginning-position line-end-position] 5])
#@67 Find the root of the current Cargo project.

(fn &optional EXTRA)
(defalias 'cargo-process--project-root #[256 "\302\206	\303\"\211\205\304
P!\207" [buffer-file-name default-directory locate-dominating-file "Cargo.toml" file-truename] 5 (#$ . 7284)])
(defvar cargo-process-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [cargo-process-mode-hook variable-documentation put "Hook run after entering Cargo-Process. mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp cargo-process-mode-map definition-name cargo-process-mode] 4)
(defvar cargo-process-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\322#\207" [cargo-process-mode-abbrev-table cargo-process-mode-map variable-documentation put purecopy "Keymap for `cargo-process-mode'." boundp cargo-process-mode-syntax-table definition-name cargo-process-mode (lambda (#1=#:def-tmp-var) (defvar cargo-process-mode-syntax-table #1#)) make-syntax-table "Syntax table for `cargo-process-mode'." (lambda (#1#) (defvar cargo-process-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `cargo-process-mode'." derived-mode-parent compilation-mode] 5)
#@253 Major mode for the Cargo process buffer.

In addition to any hooks its parent mode `compilation-mode' might have run,
this mode runs the hook `cargo-process-mode-hook', as the final or penultimate step
during initialization.

\{cargo-process-mode-map}
(defalias 'cargo-process-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2035\211\321 =\203;\322\f\323 \"\210\210\324
\325\"\204R
#=\204R\326
\325#C#\210\327!\210\330\f!\210
#\327!\210\311\331\306\332!\210\307\333\334!\210\335\336\337\"\210\340\341$\"\210)\342\334!\207" [delay-mode-hooks major-mode mode-name cargo-process-mode-map cargo-process-mode-syntax-table cargo-process-mode-abbrev-table make-local-variable t compilation-mode cargo-process-mode "Cargo-Process." mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table "Cargo-Process" truncate-lines run-hooks cargo-process-mode-hook add-hook compilation-filter-hook cargo-process--add-errno-buttons font-lock-add-keywords nil run-mode-hooks local-abbrev-table cargo-process-font-lock-keywords] 5 (#$ . 8799) nil])
#@75 Execute after PROCESS return and EVENT is 'finished'.

(fn PROCESS EVENT)
(defalias 'cargo-process--finished-sentinel #[514 "\300\"\210\211\301\232\205\302\303!\207" [compilation-sentinel "finished\n" message "Cargo Process finished."] 5 (#$ . 10083)])
#@56 Execute commands BUFFER at process start.

(fn BUFFER)
(defalias 'cargo-process--activate-mode #[257 "r\211q\210\301 \210\302\300!\210\303\211)\207" [window-point-insertion-type cargo-process-mode make-local-variable t] 3 (#$ . 10346)])
#@139 Set RUST_BACKTRACE variable depending on the COMMAND used.
Always set to nil if cargo-process--enable-rust-backtrace is nil

(fn COMMAND)
(defalias 'set-rust-backtrace #[257 "\203\302\303\"\203\304	\305\"\207\304	\306\"\207" [cargo-process--enable-rust-backtrace cargo-process--rust-backtrace string-match "\\(test\\|run\\)" setenv "1" nil] 4 (#$ . 10591)])
#@49 Find the workspace root using `cargo metadata`.
(defalias 'cargo-process--workspace-root #[0 "\301 \205\302\303!\304P!\305
!\306\307\"A\266\202\207" [cargo-process--custom-path-to-bin cargo-process--project-root shell-command-to-string shell-quote-argument " metadata --format-version 1 --no-deps" json-read-from-string assoc workspace_root] 5 (#$ . 10961)])
#@13 

(fn NAME)
(defalias 'manifest-path-argument #[257 "\301\302!\211\205
\235?\205\303\304!P\207" [cargo-process--no-manifest-commands cargo-process--project-root "Cargo.toml" "--manifest-path " shell-quote-argument] 5 (#$ . 11330)])
#@230 Start the Cargo process NAME with the cargo command COMMAND.
OPENS-EXTERNAL is non-nil if the COMMAND is expected to open an external application.
Returns the created process.

(fn NAME COMMAND &optional LAST-CMD OPENS-EXTERNAL)
(defalias 'cargo-process--start #[1026 "\305!\210\306\307Q\310 \206\"\311\312\313\314\315!\n\316
!	F\317#\"!
\206'\n\320?\321\322\323\324\325!\326\"\327$\"\210E\330 \206F\n\331
\332\321\333\334\324\325\n!\335\"\336\337%#\210)\340!\341
\342\"\210\211\262
)\207" [cargo-process--custom-path-to-bin cargo-process--command-flags default-directory compilation-ask-about-save cargo-process-last-command set-rust-backtrace "*Cargo " "*" cargo-process--project-root cargo-process--maybe-read-command cargo-process--augment-cmd-for-os mapconcat identity shell-quote-argument manifest-path-argument " " save-some-buffers make-byte-code 0 "\300\205	\205\302\300\303	!\"\207" vconcat vector [buffer-file-name string-prefix-p file-truename] 4 cargo-process--workspace-root compilation-start cargo-process-mode 257 "\300\207" [] 2 "\n\n(fn _)" get-buffer-process set-process-sentinel cargo-process--finished-sentinel] 16 (#$ . 11575)])
#@71 Action called when the user activates Rust errno BUTTON.

(fn BUTTON)
(defalias 'cargo-process--explain-action #[257 "\300\301!!\207" [cargo-process--explain-help button-label] 4 (#$ . 12759)])
#@76 Display a detailed explaination of ERRNO in a markdown buffer.

(fn ERRNO)
(defalias 'cargo-process--explain-help #[257 "\306\307 \310r\311\312!q\210\313\314 \210\315\n\316Q!c\210)\317 \210\320\303!\210\310\320\304!\210\321\320\305!\210\322\323\324\325\326!\327\"\330$\331\332\333\334\335\336\337	GTEE#\331\340\341#P$\342\343!\210\343b\210p*\262
!\207" [inhibit-message buffer-read-only cargo-process--rustc-cmd markdown-fontify-code-blocks-natively markdown-fontify-code-block-default-mode kill-buffer-hook pop-to-buffer selected-window t get-buffer-create "*rust errno*" nil erase-buffer shell-command-to-string " --explain=" markdown-view-mode make-local-variable rust-mode make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [window-live-p select-window] 2 propertize " " display space :align-to - right-fringe face error markdown-toggle-markup-hiding 1 header-line-format] 11 (#$ . 12960)])
#@114 Turn error numbers into clickable links in Cargo process output.
Meant to be run as a `compilation-filter-hook'.
(defalias 'cargo-process--add-errno-buttons #[0 "\212`\303
b\210\304\n\305#\205\306\307\224\307\225\310\311$\210\202)\266\202)\207" [compilation-filter-start case-fold-search cargo-process--errno-regex nil re-search-forward t make-button 0 :type rustc-errno] 7 (#$ . 13884)])
#@26 Return the current test.
(defalias 'cargo-process--get-current-test #[0 "\212\300 \204	\301 \210\302 \210\303\304!\210\305`\306 \"\307
\310\"\211@\266\202)\207" [cargo-process--defun-at-point-p rust-beginning-of-defun beginning-of-line search-forward "fn " buffer-substring-no-properties line-end-position split-string "("] 4 (#$ . 14286)])
#@25 Return the current mod.
(defalias 'cargo-process--get-current-mod #[0 "\212\301\302\303#\205\304\305 \306 \"\307
!\310
\311\"\211A@\266\203)\207" [cargo-process-test-mod-regexp search-backward-regexp nil t buffer-substring-no-properties line-beginning-position line-end-position string-trim-left split-string " \\|{"] 5 (#$ . 14634)])
(defalias 'cargo-process--get-current-test-fullname #[0 "\300 \203\f\300 \301\302 Q\207\302 \207" [cargo-process--get-current-mod "::" cargo-process--get-current-test] 3])
#@146 Prompt to modify the DEFAULT command when the prefix argument is present.
Without the prefix argument, return DEFAULT immediately.

(fn DEFAULT)
(defalias 'cargo-process--maybe-read-command #[257 "\203	\301\302\"\207\207" [current-prefix-arg read-shell-command "Cargo command: "] 4 (#$ . 15152)])
#@96 Extract the list of dependencies from the
MANIFEST (i.e. Cargo.toml).

(fn &optional MANIFEST)
(defalias 'cargo-process--get-dependencies #[256 "r\300
\206	\301\302!!q\210\212\303~\210eb\210\304\305\303\306#\210\307\310\303\306#\2032\311 \210\312\313\306\"
B\262
\303\210\202\211\262
*\207" [find-file-noselect cargo-process--project-root "Cargo.toml" nil search-forward "[dependencies]" t re-search-forward "^[a-zA-Z-_]* *=" beginning-of-line thing-at-point sexp] 6 (#$ . 15458)])
#@148 Augment the cargo CMD according to OS. OPENS-EXTERNAL is non-nil
if the CMD is expected to open and external application.

(fn OPENS-EXTERNAL CMD)
(defalias 'cargo-process--augment-cmd-for-os #[514 "
\203\301\235\204\302\303!\203\304
P\207\207" [system-type (windows-nt ms-dos) executable-find "setsid" "setsid -w "] 4 (#$ . 15952)])
#@116 Run the Cargo bench command.
With the prefix argument, modify the command's invocation.
Cargo: Run the benchmarks.
(defalias 'cargo-process-bench #[0 "\301\302\"\207" [cargo-process--command-bench cargo-process--start "Bench"] 3 (#$ . 16300) nil])
#@125 Run the Cargo build command.
With the prefix argument, modify the command's invocation.
Cargo: Compile the current project.
(defalias 'cargo-process-build #[0 "\301\302\"\207" [cargo-process--command-build cargo-process--start "Build"] 3 (#$ . 16556) nil])
#@125 Run the Cargo clean command.
With the prefix argument, modify the command's invocation.
Cargo: Remove the target directory.
(defalias 'cargo-process-clean #[0 "\301\302\"\207" [cargo-process--command-clean cargo-process--start "Clean"] 3 (#$ . 16821) nil])
#@152 Run the Cargo doc command.
With the prefix argument, modify the command's invocation.
Cargo: Build this project's and its dependencies' documentation.
(defalias 'cargo-process-doc #[0 "\301\302\"\207" [cargo-process--command-doc cargo-process--start "Doc"] 3 (#$ . 17086) nil])
#@152 Run the Cargo doc command with the --open switch.
With the prefix argument, modify the command's invocation.
Cargo: Open this project's documentation.
(defalias 'cargo-process-doc-open #[0 "\301\302\303\304$\207" [cargo-process--command-doc-open cargo-process--start "Doc" nil t] 5 (#$ . 17372) nil])
#@252 Run the Cargo new command.
With the prefix argument, modify the command's invocation.
NAME is the name of your application.
If BIN is t then create a binary application, otherwise a library.
Cargo: Create a new cargo project.

(fn NAME &optional BIN)
(defalias 'cargo-process-new #[513 "\211\204\n\301\302!\203\303\202\304\305\306\307R\"\207" [cargo-process--command-new y-or-n-p "Create Bin Project? " " --bin" " --lib" cargo-process--start "New" " "] 9 (#$ . 17681) "sProject name: "])
#@343 Run the Cargo init command.
With the prefix argument, modify the command's invocation.
DIRECTORY is the directory you want to create a cargo project in.
If BIN is t then create a binary application, otherwise a library.
Cargo: Create a new cargo project in current directory.

DIRECTORY is created if necessary.

(fn DIRECTORY &optional BIN)
(defalias 'cargo-process-init #[513 "\211\204\n\301\302!\203\303\202\304\305\306\307R\"\310
\311\312\313\314\315\n!\316\"\317\320%\"\207" [cargo-process--command-init y-or-n-p "Create Bin Project? " " --bin" " --lib" cargo-process--start "Init" " " set-process-sentinel make-byte-code 514 "\301\302\303\300\"#\207" vconcat vector [cargo-process--open-manifest expand-file-name "Cargo.toml"] 8 "\n\n(fn PROCESS EVENT)"] 12 (#$ . 18185) (byte-code "\301\302\303\303$C\207" [default-directory read-directory-name "Directory: " nil] 5)])
#@77 Open the manifest file when process ends.

(fn PROCESS EVENT MANIFEST-PATH)
(defalias 'cargo-process--open-manifest #[771 "
\300\232\205	\301
!\207" ["finished\n" find-file] 5 (#$ . 19080)])
#@125 Run the Cargo run command.
With the prefix argument, modify the command's invocation.
Cargo: Build and execute src/main.rs.
(defalias 'cargo-process-run #[0 "\301\302\"\207" [cargo-process--command-run cargo-process--start "Run"] 3 (#$ . 19279) nil])
#@157 Run the Cargo run command --bin <name>.
With the prefix argument, modify the command's invocation.
Cargo: Build and execute a specific binary

(fn COMMAND)
(defalias 'cargo-process-run-bin #[257 "\301\302P\303Q\"\207" [cargo-process--command-run-bin cargo-process--start "Run " " "] 6 (#$ . 19538) "sBinary name: "])
#@166 Run the Cargo run command --example <name>.
With the prefix argument, modify the command's invocation.
Cargo: Build and execute with --example <name>.

(fn COMMAND)
(defalias 'cargo-process-run-example #[257 "\301\302P\303Q\"\207" [cargo-process--command-run-example cargo-process--start "Example " " "] 6 (#$ . 19865) "sExample name: "])
#@206 Run the Cargo search command.
With the prefix argument, modify the command's invocation.
SEARCH-TERM is used as the search term for the Cargo registry.
Cargo: Search registry for crates.

(fn SEARCH-TERM)
(defalias 'cargo-process-search #[257 "\301\302\303Q\"\207" [cargo-process--command-search cargo-process--start "Search" " "] 6 (#$ . 20214) "sSearch: "])
#@110 Run the Cargo test command.
With the prefix argument, modify the command's invocation.
Cargo: Run the tests.
(defalias 'cargo-process-test #[0 "\301\302\"\207" [cargo-process--command-test cargo-process--start "Test"] 3 (#$ . 20583) nil])
#@131 Run the Cargo test command for the current test.
With the prefix argument, modify the command's invocation.
Cargo: Run the tests.
(defalias 'cargo-process-current-test #[0 "\301\302\303\304 Q\"\207" [cargo-process--command-current-test cargo-process--start "Test" " " cargo-process--get-current-test-fullname] 5 (#$ . 20830) nil])
#@131 Run the Cargo test command for the current file.
With the prefix argument, modify the command's invocation.
Cargo: Run the tests.
(defalias 'cargo-process-current-file-tests #[0 "\301\302\303\304 Q\"\207" [cargo-process--command-current-file-tests cargo-process--start "Test" " " cargo-process--get-current-mod] 5 (#$ . 21169) nil])
#@139 Run the Cargo update command.
With the prefix argument, modify the command's invocation.
Cargo: Update dependencies listed in Cargo.lock.
(defalias 'cargo-process-update #[0 "\301\302\"\207" [cargo-process--command-update cargo-process--start "Update"] 3 (#$ . 21510) nil])
#@123 Run the Cargo fmt command.
With the prefix argument, modify the command's invocation.
Requires Cargo Fmt to be installed.
(defalias 'cargo-process-fmt #[0 "\301\302\"\207" [cargo-process--command-fmt cargo-process--start "Fmt"] 3 (#$ . 21792) nil])
#@133 Run the Cargo outdated command.
With the prefix argument, modify the command's invocation.
Requires Cargo Outdated to be installed.
(defalias 'cargo-process-outdated #[0 "\301\302\"\207" [cargo-process--command-outdated cargo-process--start "Outdated"] 3 (#$ . 22049) nil])
#@169 Run the Cargo check command.
With the prefix argument, modify the command's invocation.
Cargo: Check compile the current project.
Requires cargo-check to be installed.
(defalias 'cargo-process-check #[0 "\301\302\"\207" [cargo-process--command-check cargo-process--start "Check"] 3 (#$ . 22331) nil])
#@172 Run the Cargo clippy command.
With the prefix argument, modify the command's invocation.
Cargo: Clippy compile the current project.
Requires Cargo clippy to be installed.
(defalias 'cargo-process-clippy #[0 "\301\302\"\207" [cargo-process--command-clippy cargo-process--start "Clippy"] 3 (#$ . 22640) nil])
#@221 Run the Cargo add command.
With the prefix argument, modify the command's invocation.
CRATES is the name of the crate to add.
Cargo: This command allows you to add a dependency to a Cargo.toml manifest file.

(fn CRATE)
(defalias 'cargo-process-add #[257 "\301\302\303Q\"\207" [cargo-process--command-add cargo-process--start "Add" " "] 6 (#$ . 22955) (byte-code "\301\302\"C\207" [cargo-process-favorite-crates completing-read "Crate(s) to add: "] 3)])
#@200 Run the Cargo rm command.
With the prefix argument, modify the command's invocation.
CRATE is the name of the crate to remove.
Cargo: Remove a dependency from a Cargo.toml manifest file.

(fn CRATE)
(defalias 'cargo-process-rm #[257 "\211\203\f\301\302\303Q\"\207\304\305!\207" [cargo-process--command-rm cargo-process--start "Remove" " " message "No crates used in current project."] 6 (#$ . 23419) (byte-code "\300 \211\205\f\301\302\303\304$\262
C\207" [cargo-process--get-dependencies completing-read "Crate to remove: " nil t] 6)])
#@247 Run the Cargo update command.
With the prefix argument, modify the command's invocation.
If ALL is t then update all crates, otherwise specify CRATES.
Cargo: Upgrade dependencies as specified in the local manifest file

(fn &optional ALL CRATES)
(defalias 'cargo-process-upgrade #[512 "\301 \211\203,\204\302\303!\205\304\211?\205\305\306\307\310$\311\312\313\313\260\"\266\202\202/\314\315!\207" [cargo-process--command-upgrade cargo-process--get-dependencies y-or-n-p "Upgrade all crates? " "--all" completing-read "Crate(s) to upgrade: " nil confirm cargo-process--start "Upgrade" " " message "No crates used in current project."] 12 (#$ . 23968) nil])
#@37 Run the last cargo-process command.
(defalias 'cargo-process-repeat #[0 "\203	\301\302\"\207\303\304!\207" [cargo-process-last-command apply cargo-process--start message "No last Cargo command."] 3 (#$ . 24645) nil])
(byte-code "\301\302\303#\210\301\304\305#\210\306\307!\207" [cargo-process-mode-map define-key "n" forward-button "p" backward-button provide cargo-process] 4)