Implement OnlyOnce check and reporting

bpaf_core/src/error.rs

@@ -79,6 +79,7 @@ impl Message {
             // when handle gets thrown out
             Self::Killed => true,
             Self::Conflicts { .. } => false,
+            Self::OnlyOnce { .. } => false,
             Self::Unexpected => false,
             Self::ParseFailed(..) => false,
             Self::ArgNeedsValue { .. } => false,
@@ -186,8 +187,10 @@ pub(crate) enum Message {
     // /// Expected one or more items in the scope, got someting else if any
     // Expected(Vec<Item>, Option<usize>),
     //
-    // /// Parameter is accepted but only once
-    // OnlyOnce(/* winner */ usize, usize),
+    /// Parameter is accepted but only once
+    OnlyOnce {
+        name: Name<'static>,
+    },
 }
 
 impl Message {
@@ -229,6 +232,10 @@ impl Message {
                 res,
                 "{name} wants a value {meta}, got {val}, try using {name}={val}"
             )?,
+            Message::OnlyOnce { name } => write!(
+                res,
+                "argument `{name}` cannot be used multiple times in this context"
+            )?,
         }
         Ok(res)
     }

bpaf_core/src/visitor/explain_unparsed.rs

@@ -69,6 +69,9 @@ impl<'a> ExplainUnparsed<'a> {
             if let Some(err) = self.is_in_conflict(&parsed, name.as_ref()) {
                 return err;
             }
+            if let Some(err) = self.is_redundant(&parsed, name.as_ref()) {
+                return err;
+            }
         }
 
         // Suggestions I'd like to make
@@ -127,6 +130,23 @@ impl<'a> ExplainUnparsed<'a> {
         }
         None
     }
+
+    fn is_redundant(&self, parsed: &[Name], unparsed: Name) -> Option<Error> {
+        let unparsed_info = self.all_names.get(&unparsed)?;
+        if unparsed_info.in_many {
+            return None;
+        }
+
+        if parsed.contains(&unparsed) {
+            return Some(Error {
+                message: crate::error::Message::OnlyOnce {
+                    name: unparsed.to_owned(),
+                },
+            });
+        }
+
+        None
+    }
 }
 
 impl<'a> Visitor<'a> for ExplainUnparsed<'a> {

bpaf_core/tests/errors.rs

@@ -339,4 +339,12 @@ fn used_only_once_is_more_important_error() {
         err,
         "argument `--sort` cannot be used multiple times in this context"
     );
+    let err = opts
+        .run_inner(&["--sort", "--filter", "--sort", "--filter"])
+        .unwrap_err()
+        .unwrap_stderr();
+    assert_eq!(
+        err,
+        "argument `--sort` cannot be used multiple times in this context"
+    );
 }