fix(parser): Allow one-off self-overrides

src/builder/action.rs

@@ -169,7 +169,7 @@ pub enum ArgAction {
     ///             .action(clap::ArgAction::SetFalse)
     ///     );
     ///
-    /// let matches = cmd.clone().try_get_matches_from(["mycmd", "--flag", "--flag"]).unwrap();
+    /// let matches = cmd.clone().try_get_matches_from(["mycmd", "--flag"]).unwrap();
     /// assert!(matches.contains_id("flag"));
     /// assert_eq!(
     ///     matches.get_one::<bool>("flag").copied(),

src/builder/debug_asserts.rs

@@ -686,11 +686,6 @@ fn assert_arg(arg: &Arg) {
         "Argument '{}' cannot conflict with itself",
         arg.get_id(),
     );
-    assert!(
-        !arg.overrides.iter().any(|x| *x == arg.id),
-        "Argument '{}' cannot override itself, its the default",
-        arg.get_id(),
-    );
 
     assert_eq!(
         arg.get_action().takes_values(),

src/parser/parser.rs

@@ -1180,7 +1180,9 @@ impl<'cmd> Parser<'cmd> {
                     self.cur_idx.set(self.cur_idx.get() + 1);
                     debug!("Parser::react: cur_idx:={}", self.cur_idx.get());
                 }
-                if matcher.remove(&arg.id) && !self.cmd.is_args_override_self() {
+                if matcher.remove(&arg.id)
+                    && !(self.cmd.is_args_override_self() || arg.overrides.contains(arg.get_id()))
+                {
                     return Err(ClapError::argument_conflict(
                         self.cmd,
                         arg.to_string(),
@@ -1221,7 +1223,9 @@ impl<'cmd> Parser<'cmd> {
                     raw_vals
                 };
 
-                if matcher.remove(&arg.id) && !self.cmd.is_args_override_self() {
+                if matcher.remove(&arg.id)
+                    && !(self.cmd.is_args_override_self() || arg.overrides.contains(arg.get_id()))
+                {
                     return Err(ClapError::argument_conflict(
                         self.cmd,
                         arg.to_string(),
@@ -1240,7 +1244,9 @@ impl<'cmd> Parser<'cmd> {
                     raw_vals
                 };
 
-                if matcher.remove(&arg.id) && self.cmd.is_args_override_self() {
+                if matcher.remove(&arg.id)
+                    && !(self.cmd.is_args_override_self() || arg.overrides.contains(arg.get_id()))
+                {
                     return Err(ClapError::argument_conflict(
                         self.cmd,
                         arg.to_string(),

tests/builder/action.rs

@@ -240,8 +240,15 @@ fn set_false() {
     assert_eq!(matches.contains_id("mammal"), true);
     assert_eq!(matches.index_of("mammal"), Some(1));
 
+    let result = cmd
+        .clone()
+        .try_get_matches_from(["test", "--mammal", "--mammal"]);
+    let err = result.err().unwrap();
+    assert_eq!(err.kind(), ErrorKind::ArgumentConflict);
+
     let matches = cmd
         .clone()
+        .args_override_self(true)
         .try_get_matches_from(["test", "--mammal", "--mammal"])
         .unwrap();
     assert_eq!(*matches.get_one::<bool>("mammal").unwrap(), false);

tests/builder/posix_compatible.rs

@@ -1,16 +1,36 @@
 use clap::{arg, error::ErrorKind, Arg, ArgAction, Command};
 
 #[test]
-#[should_panic = "Argument 'flag' cannot override itself"]
 fn flag_overrides_itself() {
-    Command::new("posix")
+    let res = Command::new("posix")
         .arg(
             arg!(--flag  "some flag"
             )
             .action(ArgAction::SetTrue)
             .overrides_with("flag"),
         )
-        .build();
+        .try_get_matches_from(vec!["", "--flag", "--flag"]);
+    assert!(res.is_ok(), "{}", res.unwrap_err());
+    let m = res.unwrap();
+    assert!(*m.get_one::<bool>("flag").expect("defaulted by clap"));
+}
+
+#[test]
+fn option_overrides_itself() {
+    let res = Command::new("posix")
+        .arg(
+            arg!(--opt <val> "some option")
+                .required(false)
+                .overrides_with("opt"),
+        )
+        .try_get_matches_from(vec!["", "--opt=some", "--opt=other"]);
+    assert!(res.is_ok(), "{}", res.unwrap_err());
+    let m = res.unwrap();
+    assert!(m.contains_id("opt"));
+    assert_eq!(
+        m.get_one::<String>("opt").map(|v| v.as_str()),
+        Some("other")
+    );
 }
 
 #[test]