fix(alias): place generated args correctly for run wrappers

cargo-fc generates Cargo args (--target, --no-default-features,
--features=..., --message-format) per invocation. For aliases that
expand through `cargo run -- ...` wrappers these were placed and detected
incorrectly: generated args could land after the wrapper's `--` and reach
the wrapped program instead of Cargo, and wrapper/program flags named
like Cargo's were mistaken for cargo-fc input.

Extract the forwarded-arg splitting and generated-arg placement into
invocation_args.rs and:

- Insert generated args before Cargo's `--`, but preserve an alias-defined
  `--` boundary so a wrapped command (e.g.
  `lint = "run --package wrapper -- lint"`) receives them.
- Detect explicit `--target` and `--message-format` only on Cargo's own
  flags, so wrapper/program flags no longer suppress diagnostics mode or
  skip target injection.
- Keep user program arguments after `--` out of target and feature-matrix
  planning.

Author: romnn

CHANGELOG.md

@@ -7,6 +7,25 @@
 - Fixed `--aggregate-targets` for aliases that expand through `cargo run -- ...`
   wrappers, avoiding a misleading direct-`run` fallback note when target args
   are passed to the wrapped command.
+- Fixed `--diagnostics-only` and `--dedupe` for aliases that expand through
+  `cargo run -- ...` wrappers so the generated `--message-format` argument is
+  passed to the wrapped command instead of the wrapper package.
+- Fixed run aliases such as `serve = "run --package app"` so user program
+  arguments after `--` do not make cargo-fc pass generated matrix arguments to
+  the program instead of Cargo.
+- Fixed explicit `--target` detection for aliases that expand through
+  `cargo run -- ...` wrappers.
+- Fixed alias-defined wrapper `cargo run` flags such as `--target` and
+  `--features` so they continue to configure the wrapper package instead of
+  being treated as cargo-fc target planning or target-package feature matrix
+  input.
+- Fixed diagnostics suppression so only Cargo's actual `--message-format` flag
+  disables cargo-fc diagnostics mode; similarly named wrapper/program flags are
+  left alone.
+- Fixed wrapper-package `--message-format` flags so they do not suppress
+  diagnostics mode for the wrapped command.
+- Fixed aliases whose wrapped command has its own `--` separator so generated
+  cargo-fc args are inserted before the wrapped command's program arguments.
 
 ## [0.2.1]
 

src/cargo_alias.rs

@@ -20,6 +20,11 @@ const MAX_ALIAS_EXPANSIONS: usize = 50;
 pub(crate) struct AliasExpansion {
     pub(crate) args: Vec<String>,
     pub(crate) expanded: bool,
+    /// Whether a resolved alias body, not the user's trailing args, contributed
+    /// a `--` separator. This is true for
+    /// `lint = "run --package wrapper -- lint"` and false for
+    /// `serve = "run --package app"` invoked as `cargo fc serve -- arg`.
+    pub(crate) alias_provided_double_dash: bool,
 }
 
 #[derive(Debug, Deserialize)]
@@ -108,6 +113,7 @@ pub(crate) fn expand_aliases_with_info(args: Vec<String>, workspace_root: &Path)
         return AliasExpansion {
             args,
             expanded: false,
+            alias_provided_double_dash: false,
         };
     };
     match args.get(idx) {
@@ -116,6 +122,7 @@ pub(crate) fn expand_aliases_with_info(args: Vec<String>, workspace_root: &Path)
             return AliasExpansion {
                 args,
                 expanded: false,
+                alias_provided_double_dash: false,
             };
         }
     }
@@ -124,6 +131,7 @@ pub(crate) fn expand_aliases_with_info(args: Vec<String>, workspace_root: &Path)
         return AliasExpansion {
             args,
             expanded: false,
+            alias_provided_double_dash: false,
         };
     }
 
@@ -133,6 +141,7 @@ pub(crate) fn expand_aliases_with_info(args: Vec<String>, workspace_root: &Path)
     let mut rest: Vec<String> = args.get(idx..).unwrap_or_default().to_vec();
     let mut expansions = 0;
     let mut changed = false;
+    let mut alias_provided_double_dash = false;
     for _ in 0..MAX_ALIAS_EXPANSIONS {
         let Some(token) = rest.first().cloned() else {
             break;
@@ -149,6 +158,7 @@ pub(crate) fn expand_aliases_with_info(args: Vec<String>, workspace_root: &Path)
             break;
         }
         let mut expanded = expansion.clone();
+        alias_provided_double_dash |= expanded.iter().any(|arg| arg == "--");
         expanded.extend_from_slice(rest.get(1..).unwrap_or_default());
         rest = expanded;
         expansions += 1;
@@ -167,12 +177,14 @@ pub(crate) fn expand_aliases_with_info(args: Vec<String>, workspace_root: &Path)
         );
         rest = original_rest;
         changed = false;
+        alias_provided_double_dash = false;
     }
 
     head.extend(rest);
     AliasExpansion {
         args: head,
         expanded: changed,
+        alias_provided_double_dash,
     }
 }
 
@@ -277,6 +289,31 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn tracks_only_alias_provided_double_dash() -> eyre::Result<()> {
+        let tmp = TempDir::new()?;
+        write(
+            &tmp,
+            "[alias]\nwrapper = \"run --package wrapper -- lint\"\nserve = \"run --package app\"\n",
+        )?;
+
+        let wrapper = expand_aliases_with_info(vec!["wrapper".to_string()], tmp.path());
+        let serve = expand_aliases_with_info(
+            vec![
+                "serve".to_string(),
+                "--".to_string(),
+                "program-arg".to_string(),
+            ],
+            tmp.path(),
+        );
+
+        // Only separators from alias bodies select after-separator placement;
+        // user-provided trailing args stay program argv for a normal run alias.
+        assert!(wrapper.alias_provided_double_dash);
+        assert!(!serve.alias_provided_double_dash);
+        Ok(())
+    }
+
     #[test]
     fn leaves_builtin_subcommand_untouched() -> eyre::Result<()> {
         let tmp = TempDir::new()?;

src/cli.rs

@@ -56,7 +56,9 @@ trait ArgumentParser {
     ///
     /// When `has_value` is `true`, this matches `--flag value` and
     /// `--flag=value` forms and returns the value part. When `has_value` is
-    /// `false`, it matches bare flags like `--flag`.
+    /// `false`, it matches bare flags like `--flag`. In both modes, `--`
+    /// remains the forwarded-argument boundary and is never consumed as a flag
+    /// value.
     fn get_all(&self, arg: &str, has_value: bool)
     -> Vec<(std::ops::RangeInclusive<usize>, String)>;
 }
@@ -73,13 +75,13 @@ impl ArgumentParser for Vec<String> {
                 break;
             }
             match (a, self.get(idx + 1)) {
-                (key, Some(value)) if key == arg && has_value => {
+                (key, Some(value)) if key == arg && has_value && value != "--" => {
                     matched.push((idx..=idx + 1, value.clone()));
                 }
                 (key, _) if key == arg && !has_value => {
                     matched.push((idx..=idx, key.clone()));
                 }
-                (key, _) if key.starts_with(&format!("{arg}=")) => {
+                (key, _) if has_value && key.starts_with(&format!("{arg}=")) => {
                     let value = key.trim_start_matches(&format!("{arg}="));
                     matched.push((idx..=idx, value.to_string()));
                 }
@@ -164,6 +166,9 @@ pub(crate) fn subcommand_token_index(args: &[impl AsRef<str>]) -> Option<usize>
     for (idx, arg) in args.iter().map(AsRef::as_ref).enumerate() {
         if skip_next {
             skip_next = false;
+            if arg == "--" {
+                return None;
+            }
             continue;
         }
         if arg == "--" {
@@ -625,6 +630,9 @@ pub fn parse_arguments(bin_name: &str) -> eyre::Result<(Options, Vec<String>)> {
         ..Options::default()
     };
 
+    // Every cargo-fc option extracted below must use `get_all` or `mark_flag`.
+    // Those helpers stop at the first `--`, so `cargo fc run -- --help` keeps
+    // `--help` as a binary argument instead of turning into cargo-fc help.
     // Extract path to manifest to operate on
     for (span, manifest_path) in args.get_all("--manifest-path", true) {
         let manifest_path = PathBuf::from(manifest_path);
@@ -836,15 +844,71 @@ mod test {
         let args = vec![
             "run".to_string(),
             "--".to_string(),
+            "--manifest-path".to_string(),
+            "Cargo.toml".to_string(),
+            "--package".to_string(),
+            "pkg".to_string(),
+            "-p".to_string(),
+            "pkg".to_string(),
+            "--exclude-package".to_string(),
+            "pkg".to_string(),
             "--help".to_string(),
             "matrix".to_string(),
+            "--pretty".to_string(),
             "--driver".to_string(),
             "cross".to_string(),
+            "--only-packages-with-lib-target".to_string(),
+            "--pedantic".to_string(),
+            "--errors-only".to_string(),
+            "--packages-only".to_string(),
+            "--diagnostics-only".to_string(),
+            "--fail-fast".to_string(),
+            "--no-prune-implied".to_string(),
+            "--show-pruned".to_string(),
+            "--aggregate-targets".to_string(),
+            "--no-targets".to_string(),
+            "--install-missing-targets".to_string(),
+            "--dedupe".to_string(),
+            "--dedup".to_string(),
+            "--summary-only".to_string(),
+            "--summary".to_string(),
+            "--silent".to_string(),
+            "--workspace".to_string(),
         ];
 
-        assert!(args.get_all("--help", false).is_empty());
-        assert!(args.get_all("matrix", false).is_empty());
-        assert!(args.get_all("--driver", true).is_empty());
+        for flag in [
+            "--manifest-path",
+            "--package",
+            "-p",
+            "--exclude-package",
+            "--driver",
+        ] {
+            assert!(args.get_all(flag, true).is_empty(), "{flag}");
+        }
+        for flag in [
+            "--help",
+            "matrix",
+            "--pretty",
+            "--only-packages-with-lib-target",
+            "--pedantic",
+            "--errors-only",
+            "--packages-only",
+            "--diagnostics-only",
+            "--fail-fast",
+            "--no-prune-implied",
+            "--show-pruned",
+            "--aggregate-targets",
+            "--no-targets",
+            "--install-missing-targets",
+            "--dedupe",
+            "--dedup",
+            "--summary-only",
+            "--summary",
+            "--silent",
+            "--workspace",
+        ] {
+            assert!(args.get_all(flag, false).is_empty(), "{flag}");
+        }
     }
 
     #[test]
@@ -863,6 +927,35 @@ mod test {
         assert_eq!(matches[0].1, "cargo");
     }
 
+    #[test]
+    fn argument_parser_does_not_treat_inline_values_as_boolean_flags() {
+        let args = vec![
+            "--summary-only=false".to_string(),
+            "--driver=cargo".to_string(),
+        ];
+
+        assert!(args.get_all("--summary-only", false).is_empty());
+        let matches = args.get_all("--driver", true);
+        assert_eq!(matches.len(), 1);
+        assert_eq!(matches[0].1, "cargo");
+    }
+
+    #[test]
+    fn argument_parser_does_not_consume_double_dash_as_value() {
+        let args = vec![
+            "--driver".to_string(),
+            "--".to_string(),
+            "program-arg".to_string(),
+        ];
+
+        assert!(args.get_all("--driver", true).is_empty());
+    }
+
+    #[test]
+    fn cargo_subcommand_token_stops_at_double_dash_after_value_flag() {
+        sim_assert_eq!(cargo_subcommand_token(&["--config", "--", "clippy"]), None);
+    }
+
     #[test]
     fn cargo_subcommand_treats_unknown_aliases_as_other() {
         sim_assert_eq!(cargo_subcommand(&["lint"]), CargoSubcommand::Other);