refactor: Remove lifetime from ArgPredicate

Author: epage

Diff for: src/builder/arg.rs

@@ -59,7 +59,7 @@ pub struct Arg<'help> {
     pub(crate) settings: ArgFlags,
     pub(crate) overrides: Vec<Id>,
     pub(crate) groups: Vec<Id>,
-    pub(crate) requires: Vec<(ArgPredicate<'help>, Id)>,
+    pub(crate) requires: Vec<(ArgPredicate, Id)>,
     pub(crate) r_ifs: Vec<(Id, OsString)>,
     pub(crate) r_ifs_all: Vec<(Id, OsString)>,
     pub(crate) r_unless: Vec<Id>,
@@ -73,7 +73,7 @@ pub struct Arg<'help> {
     pub(crate) num_vals: Option<ValueRange>,
     pub(crate) val_delim: Option<char>,
     pub(crate) default_vals: Vec<&'help OsStr>,
-    pub(crate) default_vals_ifs: Vec<(Id, ArgPredicate<'help>, Option<&'help OsStr>)>,
+    pub(crate) default_vals_ifs: Vec<(Id, ArgPredicate, Option<&'help OsStr>)>,
     pub(crate) default_missing_vals: Vec<&'help OsStr>,
     #[cfg(feature = "env")]
     pub(crate) env: Option<(&'help OsStr, Option<OsString>)>,
@@ -3266,7 +3266,7 @@ impl<'help> Arg<'help> {
     #[must_use]
     pub fn requires_if(mut self, val: &'help str, arg_id: impl Into<Id>) -> Self {
         self.requires
-            .push((ArgPredicate::Equals(OsStr::new(val)), arg_id.into()));
+            .push((ArgPredicate::Equals(val.to_owned().into()), arg_id.into()));
         self
     }
 
@@ -3321,7 +3321,7 @@ impl<'help> Arg<'help> {
     ) -> Self {
         self.requires.extend(
             ifs.into_iter()
-                .map(|(val, arg)| (ArgPredicate::Equals(OsStr::new(val)), arg.into())),
+                .map(|(val, arg)| (ArgPredicate::Equals(val.to_owned().into()), arg.into())),
         );
         self
     }

Diff for: src/builder/arg_predicate.rs

@@ -1,13 +1,15 @@
+use crate::OsStr;
+
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) enum ArgPredicate<'help> {
+pub(crate) enum ArgPredicate {
     IsPresent,
-    Equals(&'help std::ffi::OsStr),
+    Equals(OsStr),
 }
 
-impl<'help> From<Option<&'help std::ffi::OsStr>> for ArgPredicate<'help> {
+impl<'help> From<Option<&'help std::ffi::OsStr>> for ArgPredicate {
     fn from(other: Option<&'help std::ffi::OsStr>) -> Self {
         match other {
-            Some(other) => Self::Equals(other),
+            Some(other) => Self::Equals(other.to_owned().into()),
             None => Self::IsPresent,
         }
     }

Diff for: src/builder/command.rs

@@ -4333,7 +4333,7 @@ impl<'help> Command<'help> {
 
     pub(crate) fn unroll_arg_requires<F>(&self, func: F, arg: &Id) -> Vec<Id>
     where
-        F: Fn(&(ArgPredicate<'_>, Id)) -> Option<Id>,
+        F: Fn(&(ArgPredicate, Id)) -> Option<Id>,
     {
         let mut processed = vec![];
         let mut r_vec = vec![arg];

Diff for: src/lib.rs

@@ -109,6 +109,7 @@ pub use crate::util::color::ColorChoice;
 #[allow(unused_imports)]
 pub(crate) use crate::util::color::ColorChoice;
 pub use crate::util::Id;
+pub(crate) use crate::util::OsStr;
 pub(crate) use crate::util::Str;
 
 pub use crate::derive::{Args, CommandFactory, FromArgMatches, Parser, Subcommand, ValueEnum};

Diff for: src/output/usage.rs

@@ -359,7 +359,7 @@ impl<'help, 'cmd> Usage<'help, 'cmd> {
         };
 
         for a in required.iter() {
-            let is_relevant = |(val, req_arg): &(ArgPredicate<'_>, Id)| -> Option<Id> {
+            let is_relevant = |(val, req_arg): &(ArgPredicate, Id)| -> Option<Id> {
                 let required = match val {
                     ArgPredicate::Equals(_) => {
                         if let Some(matcher) = matcher {

Diff for: src/parser/arg_matcher.rs

@@ -125,7 +125,7 @@ impl ArgMatcher {
         self.matches.subcommand_name()
     }
 
-    pub(crate) fn check_explicit<'a>(&self, arg: &Id, predicate: &ArgPredicate<'a>) -> bool {
+    pub(crate) fn check_explicit(&self, arg: &Id, predicate: &ArgPredicate) -> bool {
         self.get(arg).map_or(false, |a| a.check_explicit(predicate))
     }
 

Diff for: src/parser/validator.rs

@@ -215,7 +215,7 @@ impl<'help, 'cmd> Validator<'help, 'cmd> {
         {
             debug!("Validator::gather_requires:iter:{:?}", name);
             if let Some(arg) = self.cmd.find(name) {
-                let is_relevant = |(val, req_arg): &(ArgPredicate<'_>, Id)| -> Option<Id> {
+                let is_relevant = |(val, req_arg): &(ArgPredicate, Id)| -> Option<Id> {
                     let required = matcher.check_explicit(&arg.id, val);
                     required.then(|| req_arg.clone())
                 };
@@ -281,15 +281,15 @@ impl<'help, 'cmd> Validator<'help, 'cmd> {
         // Validate the conditionally required args
         for a in self.cmd.get_arguments() {
             for (other, val) in &a.r_ifs {
-                if matcher.check_explicit(other, &ArgPredicate::Equals(val.as_os_str()))
+                if matcher.check_explicit(other, &ArgPredicate::Equals(val.into()))
                     && !matcher.check_explicit(&a.id, &ArgPredicate::IsPresent)
                 {
                     return self.missing_required_error(matcher, vec![a.id.clone()]);
                 }
             }
 
             let match_all = a.r_ifs_all.iter().all(|(other, val)| {
-                matcher.check_explicit(other, &ArgPredicate::Equals(val.as_os_str()))
+                matcher.check_explicit(other, &ArgPredicate::Equals(val.into()))
             });
             if match_all
                 && !a.r_ifs_all.is_empty()

Diff for: src/util/id.rs

@@ -100,7 +100,7 @@ impl PartialEq<str> for Id {
     }
 }
 
-impl<'s> PartialEq<&'s str> for Id {
+impl PartialEq<&'_ str> for Id {
     #[inline]
     fn eq(&self, other: &&str) -> bool {
         PartialEq::eq(self.as_str(), *other)

Diff for: src/util/mod.rs

@@ -4,10 +4,12 @@ mod flat_map;
 mod flat_set;
 mod graph;
 mod id;
+mod os_str;
 mod str;
 mod str_to_bool;
 
 pub use self::id::Id;
+pub use self::os_str::OsStr;
 pub use self::str::Str;
 
 pub(crate) use self::flat_map::Entry;

Diff for: src/util/os_str.rs

@@ -0,0 +1,204 @@
+/// A UTF-8-encoded fixed string
+#[derive(Default, Clone, Eq, PartialEq, PartialOrd, Ord, Hash)]
+pub struct OsStr {
+    name: Inner,
+}
+
+impl OsStr {
+    pub(crate) fn from_string(name: std::ffi::OsString) -> Self {
+        Self {
+            name: Inner::Owned(name.into_boxed_os_str()),
+        }
+    }
+
+    pub(crate) fn from_ref(name: &std::ffi::OsStr) -> Self {
+        Self {
+            name: Inner::Owned(Box::from(name)),
+        }
+    }
+
+    pub(crate) const fn from_static_ref(name: &'static std::ffi::OsStr) -> Self {
+        Self {
+            name: Inner::Static(name),
+        }
+    }
+
+    /// Get the raw string of the `OsStr`
+    pub fn as_os_str(&self) -> &std::ffi::OsStr {
+        self.name.as_os_str()
+    }
+}
+
+impl From<&'_ OsStr> for OsStr {
+    fn from(id: &'_ OsStr) -> Self {
+        id.clone()
+    }
+}
+
+impl From<std::ffi::OsString> for OsStr {
+    fn from(name: std::ffi::OsString) -> Self {
+        Self::from_string(name)
+    }
+}
+
+impl From<&'_ std::ffi::OsString> for OsStr {
+    fn from(name: &'_ std::ffi::OsString) -> Self {
+        Self::from_ref(name.as_os_str())
+    }
+}
+
+impl From<std::string::String> for OsStr {
+    fn from(name: std::string::String) -> Self {
+        Self::from_string(name.into())
+    }
+}
+
+impl From<&'_ std::string::String> for OsStr {
+    fn from(name: &'_ std::string::String) -> Self {
+        Self::from_ref(name.as_str().as_ref())
+    }
+}
+
+impl From<&'static std::ffi::OsStr> for OsStr {
+    fn from(name: &'static std::ffi::OsStr) -> Self {
+        Self::from_static_ref(name)
+    }
+}
+
+impl From<&'_ &'static std::ffi::OsStr> for OsStr {
+    fn from(name: &'_ &'static std::ffi::OsStr) -> Self {
+        Self::from_static_ref(*name)
+    }
+}
+
+impl From<&'static str> for OsStr {
+    fn from(name: &'static str) -> Self {
+        Self::from_static_ref(name.as_ref())
+    }
+}
+
+impl From<&'_ &'static str> for OsStr {
+    fn from(name: &'_ &'static str) -> Self {
+        Self::from_static_ref((*name).as_ref())
+    }
+}
+
+impl std::fmt::Debug for OsStr {
+    #[inline]
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Debug::fmt(self.as_os_str(), f)
+    }
+}
+
+impl std::ops::Deref for OsStr {
+    type Target = std::ffi::OsStr;
+
+    #[inline]
+    fn deref(&self) -> &std::ffi::OsStr {
+        self.as_os_str()
+    }
+}
+
+impl AsRef<std::ffi::OsStr> for OsStr {
+    #[inline]
+    fn as_ref(&self) -> &std::ffi::OsStr {
+        self.as_os_str()
+    }
+}
+
+impl AsRef<std::path::Path> for OsStr {
+    #[inline]
+    fn as_ref(&self) -> &std::path::Path {
+        std::path::Path::new(self)
+    }
+}
+
+impl std::borrow::Borrow<std::ffi::OsStr> for OsStr {
+    #[inline]
+    fn borrow(&self) -> &std::ffi::OsStr {
+        self.as_os_str()
+    }
+}
+
+impl PartialEq<str> for OsStr {
+    #[inline]
+    fn eq(&self, other: &str) -> bool {
+        PartialEq::eq(self.as_os_str(), other)
+    }
+}
+
+impl PartialEq<&'_ str> for OsStr {
+    #[inline]
+    fn eq(&self, other: &&str) -> bool {
+        PartialEq::eq(self.as_os_str(), *other)
+    }
+}
+
+impl<'s> PartialEq<&'s std::ffi::OsStr> for OsStr {
+    #[inline]
+    fn eq(&self, other: &&std::ffi::OsStr) -> bool {
+        PartialEq::eq(self.as_os_str(), *other)
+    }
+}
+
+impl PartialEq<std::string::String> for OsStr {
+    #[inline]
+    fn eq(&self, other: &std::string::String) -> bool {
+        PartialEq::eq(self.as_os_str(), other.as_str())
+    }
+}
+
+impl PartialEq<std::ffi::OsString> for OsStr {
+    #[inline]
+    fn eq(&self, other: &std::ffi::OsString) -> bool {
+        PartialEq::eq(self.as_os_str(), other.as_os_str())
+    }
+}
+
+#[derive(Clone)]
+enum Inner {
+    Static(&'static std::ffi::OsStr),
+    Owned(Box<std::ffi::OsStr>),
+}
+
+impl Inner {
+    fn as_os_str(&self) -> &std::ffi::OsStr {
+        match self {
+            Self::Static(s) => s,
+            Self::Owned(s) => s.as_ref(),
+        }
+    }
+}
+
+impl Default for Inner {
+    fn default() -> Self {
+        Self::Static(std::ffi::OsStr::new(""))
+    }
+}
+
+impl PartialEq for Inner {
+    fn eq(&self, other: &Inner) -> bool {
+        self.as_os_str() == other.as_os_str()
+    }
+}
+
+impl PartialOrd for Inner {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        self.as_os_str().partial_cmp(other.as_os_str())
+    }
+}
+
+impl Ord for Inner {
+    fn cmp(&self, other: &Inner) -> std::cmp::Ordering {
+        self.as_os_str().cmp(other.as_os_str())
+    }
+}
+
+impl Eq for Inner {}
+
+impl std::hash::Hash for Inner {
+    #[inline]
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.as_os_str().hash(state);
+    }
+}

Diff for: src/util/str.rs

@@ -124,7 +124,7 @@ impl PartialEq<str> for Str {
     }
 }
 
-impl<'s> PartialEq<&'s str> for Str {
+impl PartialEq<&'_ str> for Str {
     #[inline]
     fn eq(&self, other: &&str) -> bool {
         PartialEq::eq(self.as_str(), *other)