当使用syn时，我如何从Option<T>中获取T？

Question

我正在使用 syn 解析 Rust 代码。当我使用 field.ty 读取命名字段的类型时，我得到了一个 syn::Type。当我使用 quote!{#ty}.to_string() 进行打印时，我得到了 "Option<String>"。

我该如何才能得到仅为 "String"？ 我想在 quote！ 中使用 #ty 来打印出 "String" 而不是 "Option<String>"。

我想生成以下代码：

impl Foo {
    pub set_bar(&mut self, v: String) {
        self.bar = Some(v);
    }
}

从开始

struct Foo {
    bar: Option<String>
}

我的尝试：

let ast: DeriveInput = parse_macro_input!(input as DeriveInput);

let data: Data = ast.data;

match data {
    Data::Struct(ref data) => match data.fields {
        Fields::Named(ref fields) => {

            fields.named.iter().for_each(|field| {
                let name = &field.ident.clone().unwrap();

                let ty = &field.ty;
                quote!{
                    impl Foo {
                        pub set_bar(&mut self, v: #ty) {
                            self.bar = Some(v);
                        }
                    }
                };      
            });
        }
        _ => {}
    },
    _ => panic!("You can derive it only from struct"),
}

- Đorđe Zeljić

---

通过依赖实际类型系统来实现类似效果的一种方法可能是使用特质将 Option<T> 连接回到 T，例如：impl<T> MyTrait for Option<T> { type Assoc = T; }。然后，您的宏可以扩展为 set_bar(&mut self, v: <Option<String> as MyTrait>::Assoc)。 - trent

Answer 1

我更新了@Boiethios的回答，并在公共板条箱中使用和测试了它，支持多种Option语法：

• Option
• std::option::Option
• ::std::option::Option
• core::option::Option
• ::core::option::Option

fn extract_type_from_option(ty: &syn::Type) -> Option<&syn::Type> {
    use syn::{GenericArgument, Path, PathArguments, PathSegment};

    fn extract_type_path(ty: &syn::Type) -> Option<&Path> {
        match *ty {
            syn::Type::Path(ref typepath) if typepath.qself.is_none() => Some(&typepath.path),
            _ => None,
        }
    }

    // TODO store (with lazy static) the vec of string
    // TODO maybe optimization, reverse the order of segments
    fn extract_option_segment(path: &Path) -> Option<&PathSegment> {
        let idents_of_path = path
            .segments
            .iter()
            .into_iter()
            .fold(String::new(), |mut acc, v| {
                acc.push_str(&v.ident.to_string());
                acc.push('|');
                acc
            });
        vec!["Option|", "std|option|Option|", "core|option|Option|"]
            .into_iter()
            .find(|s| &idents_of_path == *s)
            .and_then(|_| path.segments.last())
    }

    extract_type_path(ty)
        .and_then(|path| extract_option_segment(path))
        .and_then(|path_seg| {
            let type_params = &path_seg.arguments;
            // It should have only on angle-bracketed param ("<String>"):
            match *type_params {
                PathArguments::AngleBracketed(ref params) => params.args.first(),
                _ => None,
            }
        })
        .and_then(|generic_arg| match *generic_arg {
            GenericArgument::Type(ref ty) => Some(ty),
            _ => None,
        })
}

- David Bernard

---

这就是我所说的省时工具！非常感谢@David。 - Rom's

我认为不需要 vec!。切片也可以转换为迭代器。 - Campbell He

Answer 2

你应该像这个未经测试的示例一样做：

use syn::{GenericArgument, PathArguments, Type};

fn extract_type_from_option(ty: &Type) -> Type {
    fn path_is_option(path: &Path) -> bool {
        leading_colon.is_none()
            && path.segments.len() == 1
            && path.segments.iter().next().unwrap().ident == "Option"
    }

    match ty {
        Type::Path(typepath) if typepath.qself.is_none() && path_is_option(typepath.path) => {
            // Get the first segment of the path (there is only one, in fact: "Option"):
            let type_params = typepath.path.segments.iter().first().unwrap().arguments;
            // It should have only on angle-bracketed param ("<String>"):
            let generic_arg = match type_params {
                PathArguments::AngleBracketed(params) => params.args.iter().first().unwrap(),
                _ => panic!("TODO: error handling"),
            };
            // This argument must be a type:
            match generic_arg {
                GenericArgument::Type(ty) => ty,
                _ => panic!("TODO: error handling"),
            }
        }
        _ => panic!("TODO: error handling"),
    }
}

没有太多需要解释的，它只是“展开”类型的各个组件：

Type -> TypePath -> Path -> PathSegment -> PathArguments -> AngleBracketedGenericArguments -> GenericArgument -> Type。

如果有更简便的方法，请告诉我，我会很高兴知道。

---

请注意，由于syn是一个解析器，它使用标记来工作。你不能确定这是一个Option。例如，用户可能输入std :: option :: Option，或者写type MaybeString = std :: option :: Option<String>;。你无法处理这些任意名称。

- Boiethios

---

谢谢，但我想说typepath.path.is_ident("Option")是false。is_ident检查self.leading_colon.is_none() && self.segments.len() == 1 && self.segments[0].arguments.is_none() && self.segments[0].ident == ident，而且self.segments[0].arguments.is_none()是false。 - Đorđe Zeljić

@ĐorđeZeljić 我认为现在更好了。再次说明，我现在无法测试它。此外，这可以重构得更好，但我给你一个大致的想法如何做到这一点。 - Boiethios

你无法处理那些任意的名称 - 这才是真正的关键。 - Shepmaster

@Boiethios，使用syn::visit会更容易吗？ - zino