test: Test FromStr::Err: !Send+!Sync

Cargo.toml

@@ -330,6 +330,11 @@ name = "04_02_parse_derive"
 path = "examples/tutorial_derive/04_02_parse.rs"
 required-features = ["derive"]
 
+[[example]]
+name = "04_02_01_parse_from_str"
+path = "examples/tutorial_derive/04_02_01_parse_from_str.rs"
+required-features = ["derive"]
+
 [[example]]
 name = "04_02_validate_derive"
 path = "examples/tutorial_derive/04_02_validate.rs"

examples/tutorial_derive/04_02_01_parse_from_str.rs

@@ -0,0 +1,47 @@
+use std::fmt::{Display, Formatter};
+use std::marker::PhantomData;
+
+#[derive(Clone, Debug)]
+struct Foo {
+    v: u32
+}
+
+impl std::str::FromStr for Foo {
+    type Err = NotSendSyncError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if s=="error" {
+            Err(NotSendSyncError{_pd: PhantomData })
+        } else {
+            Ok(Foo{v: 42})
+        }
+    }
+}
+
+#[derive(Debug)]
+struct NotSendSyncError {
+    _pd: PhantomData<std::cell::RefCell<()>>,
+}
+
+impl Display for NotSendSyncError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "{:?}", self)
+    }
+}
+
+impl std::error::Error for NotSendSyncError {
+
+}
+
+#[derive(clap::Parser, Debug, Clone)]
+#[structopt(name = "use FromStr")]
+struct Config {
+    //#[arg(long, value_parser=clap::value_parser!(Foo))]
+    #[arg(long)]
+    foo: Foo
+}
+
+fn main() {
+    let config = <Config as clap::Parser>::parse();
+    println!("foo.v={}", config.foo.v);
+}

examples/typed-derive.rs

@@ -45,12 +45,12 @@ struct Args {
 }
 
 /// Parse a single key-value pair
-fn parse_key_val<T, U>(s: &str) -> Result<(T, U), Box<dyn Error + Send + Sync + 'static>>
+fn parse_key_val<T, U>(s: &str) -> Result<(T, U), Box<dyn Error>>
 where
     T: std::str::FromStr,
-    T::Err: Error + Send + Sync + 'static,
+    T::Err: Error,
     U: std::str::FromStr,
-    U::Err: Error + Send + Sync + 'static,
+    U::Err: Error,
 {
     let pos = s
         .find('=')