1 files changed, 29 insertions, 29 deletions

diff --git a/vendor/xflags/src/rt.rs b/vendor/xflags/src/rt.rs
index 988e6cc23..0b3d98c2b 100644
--- a/vendor/xflags/src/rt.rs
+++ b/vendor/xflags/src/rt.rs
@@ -15,36 +15,41 @@ macro_rules! bail {
 }
 
 pub struct Parser {
+    after_double_dash: bool,
     rargs: Vec<OsString>,
 }
 
 impl Parser {
     pub fn new(mut args: Vec<OsString>) -> Self {
         args.reverse();
-        Self { rargs: args }
+        Self { after_double_dash: false, rargs: args }
     }
 
     pub fn new_from_env() -> Self {
-        let mut args = std::env::args_os().collect::<Vec<_>>();
-        args.reverse();
-        args.pop();
-        Self { rargs: args }
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.rargs.is_empty()
+        let args = std::env::args_os().collect::<Vec<_>>();
+        let mut res = Parser::new(args);
+        let _progn = res.next();
+        res
     }
 
-    pub fn peek_flag(&self) -> Option<&str> {
-        self.rargs.last().and_then(|it| it.to_str()).filter(|it| it.starts_with('-'))
-    }
     pub fn pop_flag(&mut self) -> Option<Result<String, OsString>> {
-        if self.peek_flag().is_some() {
-            self.next().map(|it| it.into_string())
-        } else {
+        if self.after_double_dash {
             self.next().map(Err)
+        } else {
+            let arg = self.next()?;
+            let arg_str = arg.to_str().unwrap_or_default();
+            if arg_str.starts_with('-') {
+                if arg_str == "--" {
+                    self.after_double_dash = true;
+                    return self.next().map(Err);
+                }
+                Some(arg.into_string())
+            } else {
+                Some(Err(arg))
+            }
         }
     }
+
     pub fn push_back(&mut self, arg: Result<String, OsString>) {
         let arg = match arg {
             Ok(it) => it.into(),
@@ -53,15 +58,12 @@ impl Parser {
         self.rargs.push(arg)
     }
 
-    pub fn next(&mut self) -> Option<OsString> {
+    fn next(&mut self) -> Option<OsString> {
         self.rargs.pop()
     }
 
     pub fn next_value(&mut self, flag: &str) -> Result<OsString> {
-        if self.peek_flag().is_some() {
-            bail!("expected a value for `{}`", flag)
-        }
-        self.next().ok_or_else(|| format_err!("expected a value for `{}`", flag))
+        self.next().ok_or_else(|| format_err!("expected a value for `{flag}`"))
     }
 
     pub fn next_value_from_str<T: FromStr>(&mut self, flag: &str) -> Result<T>
@@ -77,21 +79,19 @@ impl Parser {
         T::Err: fmt::Display,
     {
         match value.into_string() {
-            Ok(str) => {
-                str.parse::<T>().map_err(|err| format_err!("can't parse `{}`, {}", flag, err))
-            }
+            Ok(str) => str.parse::<T>().map_err(|err| format_err!("can't parse `{flag}`, {err}")),
             Err(it) => {
-                bail!("can't parse `{}`, invalid utf8: {:?}", flag, it)
+                bail!("can't parse `{flag}`, invalid utf8: {it:?}")
             }
         }
     }
 
     pub fn unexpected_flag(&self, flag: &str) -> Error {
-        format_err!("unexpected flag: `{}`", flag)
+        format_err!("unexpected flag: `{flag}`")
     }
 
     pub fn unexpected_arg(&self, arg: OsString) -> Error {
-        format_err!("unexpected argument: {:?}", arg)
+        format_err!("unexpected argument: {arg:?}")
     }
 
     pub fn subcommand_required(&self) -> Error {
@@ -104,15 +104,15 @@ impl Parser {
 
     pub fn optional<T>(&self, flag: &str, mut vals: Vec<T>) -> Result<Option<T>> {
         if vals.len() > 1 {
-            bail!("flag specified more than once: `{}`", flag)
+            bail!("flag specified more than once: `{flag}`")
         }
         Ok(vals.pop())
     }
 
     pub fn required<T>(&self, flag: &str, mut vals: Vec<T>) -> Result<T> {
         if vals.len() > 1 {
-            bail!("flag specified more than once: `{}`", flag)
+            bail!("flag specified more than once: `{flag}`")
         }
-        vals.pop().ok_or_else(|| format_err!("flag is required: `{}`", flag))
+        vals.pop().ok_or_else(|| format_err!("flag is required: `{flag}`"))
     }
 }