From 698f8c2f01ea549d77d7dc3338a12e04c11057b9 Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Wed, 17 Apr 2024 14:02:58 +0200
Subject: Adding upstream version 1.64.0+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 vendor/xflags-macros/tests/it/subcommands.rs | 225 +++++++++++++++++++++++++++
 1 file changed, 225 insertions(+)
 create mode 100644 vendor/xflags-macros/tests/it/subcommands.rs

(limited to 'vendor/xflags-macros/tests/it/subcommands.rs')

diff --git a/vendor/xflags-macros/tests/it/subcommands.rs b/vendor/xflags-macros/tests/it/subcommands.rs
new file mode 100644
index 000000000..7941a395d
--- /dev/null
+++ b/vendor/xflags-macros/tests/it/subcommands.rs
@@ -0,0 +1,225 @@
+#![allow(unused)]
+use std::{ffi::OsString, path::PathBuf};
+
+#[derive(Debug)]
+pub struct RustAnalyzer {
+    pub verbose: u32,
+    pub subcommand: RustAnalyzerCmd,
+}
+
+#[derive(Debug)]
+pub enum RustAnalyzerCmd {
+    Server(Server),
+    AnalysisStats(AnalysisStats),
+}
+
+#[derive(Debug)]
+pub struct Server {
+    pub dir: Option<PathBuf>,
+    pub subcommand: ServerCmd,
+}
+
+#[derive(Debug)]
+pub enum ServerCmd {
+    Launch(Launch),
+    Watch(Watch),
+}
+
+#[derive(Debug)]
+pub struct Launch {
+    pub log: bool,
+}
+
+#[derive(Debug)]
+pub struct Watch;
+
+#[derive(Debug)]
+pub struct AnalysisStats {
+    pub path: PathBuf,
+
+    pub parallel: bool,
+}
+
+impl RustAnalyzer {
+    pub const HELP: &'static str = Self::HELP_;
+
+    #[allow(dead_code)]
+    pub fn from_env() -> xflags::Result<Self> {
+        Self::from_env_()
+    }
+
+    #[allow(dead_code)]
+    pub fn from_vec(args: Vec<std::ffi::OsString>) -> xflags::Result<Self> {
+        Self::from_vec_(args)
+    }
+}
+
+impl RustAnalyzer {
+    fn from_env_() -> xflags::Result<Self> {
+        let mut p = xflags::rt::Parser::new_from_env();
+        Self::parse_(&mut p)
+    }
+    fn from_vec_(args: Vec<std::ffi::OsString>) -> xflags::Result<Self> {
+        let mut p = xflags::rt::Parser::new(args);
+        Self::parse_(&mut p)
+    }
+}
+
+impl RustAnalyzer {
+    fn parse_(p_: &mut xflags::rt::Parser) -> xflags::Result<Self> {
+        let mut verbose = Vec::new();
+
+        let mut sub_ = None;
+        while let Some(arg_) = p_.pop_flag() {
+            match arg_ {
+                Ok(flag_) => match flag_.as_str() {
+                    "--verbose" | "-v" => verbose.push(()),
+                    _ => return Err(p_.unexpected_flag(&flag_)),
+                },
+                Err(arg_) => {
+                    match arg_.to_str().unwrap_or("") {
+                        "server" => {
+                            sub_ = Some(RustAnalyzerCmd::Server(Server::parse_(p_)?));
+                            break;
+                        }
+                        "analysis-stats" => {
+                            sub_ = Some(RustAnalyzerCmd::AnalysisStats(AnalysisStats::parse_(p_)?));
+                            break;
+                        }
+                        _ => (),
+                    }
+                    return Err(p_.unexpected_arg(arg_));
+                }
+            }
+        }
+        Ok(Self { verbose: verbose.len() as u32, subcommand: p_.subcommand(sub_)? })
+    }
+}
+
+impl Server {
+    fn parse_(p_: &mut xflags::rt::Parser) -> xflags::Result<Self> {
+        let mut dir = Vec::new();
+
+        let mut sub_ = None;
+        while let Some(arg_) = p_.pop_flag() {
+            match arg_ {
+                Ok(flag_) => match flag_.as_str() {
+                    "--dir" => dir.push(p_.next_value(&flag_)?.into()),
+                    _ => {
+                        p_.push_back(Ok(flag_));
+                        break;
+                    }
+                },
+                Err(arg_) => {
+                    match arg_.to_str().unwrap_or("") {
+                        "watch" => {
+                            sub_ = Some(ServerCmd::Watch(Watch::parse_(p_)?));
+                            break;
+                        }
+                        _ => (),
+                    }
+                    p_.push_back(Err(arg_));
+                    break;
+                }
+            }
+        }
+        if sub_.is_none() {
+            sub_ = Some(ServerCmd::Launch(Launch::parse_(p_)?));
+        }
+        Ok(Self { dir: p_.optional("--dir", dir)?, subcommand: p_.subcommand(sub_)? })
+    }
+}
+
+impl Launch {
+    fn parse_(p_: &mut xflags::rt::Parser) -> xflags::Result<Self> {
+        let mut log = Vec::new();
+
+        while let Some(arg_) = p_.pop_flag() {
+            match arg_ {
+                Ok(flag_) => match flag_.as_str() {
+                    "--log" => log.push(()),
+                    _ => return Err(p_.unexpected_flag(&flag_)),
+                },
+                Err(arg_) => {
+                    return Err(p_.unexpected_arg(arg_));
+                }
+            }
+        }
+        Ok(Self { log: p_.optional("--log", log)?.is_some() })
+    }
+}
+
+impl Watch {
+    fn parse_(p_: &mut xflags::rt::Parser) -> xflags::Result<Self> {
+        while let Some(arg_) = p_.pop_flag() {
+            match arg_ {
+                Ok(flag_) => match flag_.as_str() {
+                    _ => return Err(p_.unexpected_flag(&flag_)),
+                },
+                Err(arg_) => {
+                    return Err(p_.unexpected_arg(arg_));
+                }
+            }
+        }
+        Ok(Self {})
+    }
+}
+
+impl AnalysisStats {
+    fn parse_(p_: &mut xflags::rt::Parser) -> xflags::Result<Self> {
+        let mut parallel = Vec::new();
+
+        let mut path = (false, Vec::new());
+
+        while let Some(arg_) = p_.pop_flag() {
+            match arg_ {
+                Ok(flag_) => match flag_.as_str() {
+                    "--parallel" => parallel.push(()),
+                    _ => return Err(p_.unexpected_flag(&flag_)),
+                },
+                Err(arg_) => {
+                    if let (done_ @ false, buf_) = &mut path {
+                        buf_.push(arg_.into());
+                        *done_ = true;
+                        continue;
+                    }
+                    return Err(p_.unexpected_arg(arg_));
+                }
+            }
+        }
+        Ok(Self {
+            path: p_.required("path", path.1)?,
+
+            parallel: p_.optional("--parallel", parallel)?.is_some(),
+        })
+    }
+}
+impl RustAnalyzer {
+    const HELP_: &'static str = "\
+rust-analyzer
+
+OPTIONS:
+    -v, --verbose
+
+SUBCOMMANDS:
+
+rust-analyzer server
+
+  OPTIONS:
+    --dir <path>
+
+    --log
+
+
+rust-analyzer server watch
+
+
+rust-analyzer analysis-stats
+
+  ARGS:
+    <path>
+
+  OPTIONS:
+    --parallel
+";
+}
-- 
cgit v1.2.3