| #![allow(clippy::too_many_lines)] |
| |
| #[macro_use] |
| mod macros; |
| |
| use quote::quote; |
| use syn::{Data, DeriveInput}; |
| |
| #[test] |
| fn test_unit() { |
| let input = quote! { |
| struct Unit; |
| }; |
| |
| snapshot!(input as DeriveInput, @r###" |
| DeriveInput { |
| vis: Inherited, |
| ident: "Unit", |
| generics: Generics, |
| data: Data::Struct { |
| fields: Unit, |
| semi_token: Some, |
| }, |
| } |
| "###); |
| } |
| |
| #[test] |
| fn test_struct() { |
| let input = quote! { |
| #[derive(Debug, Clone)] |
| pub struct Item { |
| pub ident: Ident, |
| pub attrs: Vec<Attribute> |
| } |
| }; |
| |
| snapshot!(input as DeriveInput, @r###" |
| DeriveInput { |
| attrs: [ |
| Attribute { |
| style: Outer, |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "derive", |
| arguments: None, |
| }, |
| ], |
| }, |
| tokens: TokenStream(`(Debug , Clone)`), |
| }, |
| ], |
| vis: Visibility::Public, |
| ident: "Item", |
| generics: Generics, |
| data: Data::Struct { |
| fields: Fields::Named { |
| named: [ |
| Field { |
| vis: Visibility::Public, |
| ident: Some("ident"), |
| colon_token: Some, |
| ty: Type::Path { |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "Ident", |
| arguments: None, |
| }, |
| ], |
| }, |
| }, |
| }, |
| Field { |
| vis: Visibility::Public, |
| ident: Some("attrs"), |
| colon_token: Some, |
| ty: Type::Path { |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "Vec", |
| arguments: PathArguments::AngleBracketed { |
| args: [ |
| Type(Type::Path { |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "Attribute", |
| arguments: None, |
| }, |
| ], |
| }, |
| }), |
| ], |
| }, |
| }, |
| ], |
| }, |
| }, |
| }, |
| ], |
| }, |
| }, |
| } |
| "###); |
| |
| snapshot!(input.attrs[0].parse_meta().unwrap(), @r###" |
| Meta::List { |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "derive", |
| arguments: None, |
| }, |
| ], |
| }, |
| nested: [ |
| Meta(Path(Path { |
| segments: [ |
| PathSegment { |
| ident: "Debug", |
| arguments: None, |
| }, |
| ], |
| })), |
| Meta(Path(Path { |
| segments: [ |
| PathSegment { |
| ident: "Clone", |
| arguments: None, |
| }, |
| ], |
| })), |
| ], |
| } |
| "###); |
| } |
| |
| #[test] |
| fn test_union() { |
| let input = quote! { |
| union MaybeUninit<T> { |
| uninit: (), |
| value: T |
| } |
| }; |
| |
| snapshot!(input as DeriveInput, @r###" |
| DeriveInput { |
| vis: Inherited, |
| ident: "MaybeUninit", |
| generics: Generics { |
| lt_token: Some, |
| params: [ |
| Type(TypeParam { |
| ident: "T", |
| }), |
| ], |
| gt_token: Some, |
| }, |
| data: Data::Union { |
| fields: FieldsNamed { |
| named: [ |
| Field { |
| vis: Inherited, |
| ident: Some("uninit"), |
| colon_token: Some, |
| ty: Type::Tuple, |
| }, |
| Field { |
| vis: Inherited, |
| ident: Some("value"), |
| colon_token: Some, |
| ty: Type::Path { |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "T", |
| arguments: None, |
| }, |
| ], |
| }, |
| }, |
| }, |
| ], |
| }, |
| }, |
| } |
| "###); |
| } |
| |
| #[test] |
| #[cfg(feature = "full")] |
| fn test_enum() { |
| let input = quote! { |
| /// See the std::result module documentation for details. |
| #[must_use] |
| pub enum Result<T, E> { |
| Ok(T), |
| Err(E), |
| Surprise = 0isize, |
| |
| // Smuggling data into a proc_macro_derive, |
| // in the style of https://github.com/dtolnay/proc-macro-hack |
| ProcMacroHack = (0, "data").0 |
| } |
| }; |
| |
| snapshot!(input as DeriveInput, @r###" |
| DeriveInput { |
| attrs: [ |
| Attribute { |
| style: Outer, |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "doc", |
| arguments: None, |
| }, |
| ], |
| }, |
| tokens: TokenStream(`= r" See the std::result module documentation for details."`), |
| }, |
| Attribute { |
| style: Outer, |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "must_use", |
| arguments: None, |
| }, |
| ], |
| }, |
| tokens: TokenStream(``), |
| }, |
| ], |
| vis: Visibility::Public, |
| ident: "Result", |
| generics: Generics { |
| lt_token: Some, |
| params: [ |
| Type(TypeParam { |
| ident: "T", |
| }), |
| Type(TypeParam { |
| ident: "E", |
| }), |
| ], |
| gt_token: Some, |
| }, |
| data: Data::Enum { |
| variants: [ |
| Variant { |
| ident: "Ok", |
| fields: Fields::Unnamed { |
| unnamed: [ |
| Field { |
| vis: Inherited, |
| ty: Type::Path { |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "T", |
| arguments: None, |
| }, |
| ], |
| }, |
| }, |
| }, |
| ], |
| }, |
| }, |
| Variant { |
| ident: "Err", |
| fields: Fields::Unnamed { |
| unnamed: [ |
| Field { |
| vis: Inherited, |
| ty: Type::Path { |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "E", |
| arguments: None, |
| }, |
| ], |
| }, |
| }, |
| }, |
| ], |
| }, |
| }, |
| Variant { |
| ident: "Surprise", |
| fields: Unit, |
| discriminant: Some(Expr::Lit { |
| lit: 0isize, |
| }), |
| }, |
| Variant { |
| ident: "ProcMacroHack", |
| fields: Unit, |
| discriminant: Some(Expr::Field { |
| base: Expr::Tuple { |
| elems: [ |
| Expr::Lit { |
| lit: 0, |
| }, |
| Expr::Lit { |
| lit: "data", |
| }, |
| ], |
| }, |
| member: Unnamed(Index { |
| index: 0, |
| }), |
| }), |
| }, |
| ], |
| }, |
| } |
| "###); |
| |
| let meta_items: Vec<_> = input |
| .attrs |
| .into_iter() |
| .map(|attr| attr.parse_meta().unwrap()) |
| .collect(); |
| |
| snapshot!(meta_items, @r###" |
| [ |
| Meta::NameValue { |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "doc", |
| arguments: None, |
| }, |
| ], |
| }, |
| lit: " See the std::result module documentation for details.", |
| }, |
| Path(Path { |
| segments: [ |
| PathSegment { |
| ident: "must_use", |
| arguments: None, |
| }, |
| ], |
| }), |
| ] |
| "###); |
| } |
| |
| #[test] |
| fn test_attr_with_path() { |
| let input = quote! { |
| #[::attr_args::identity |
| fn main() { assert_eq!(foo(), "Hello, world!"); }] |
| struct Dummy; |
| }; |
| |
| snapshot!(input as DeriveInput, @r###" |
| DeriveInput { |
| attrs: [ |
| Attribute { |
| style: Outer, |
| path: Path { |
| leading_colon: Some, |
| segments: [ |
| PathSegment { |
| ident: "attr_args", |
| arguments: None, |
| }, |
| PathSegment { |
| ident: "identity", |
| arguments: None, |
| }, |
| ], |
| }, |
| tokens: TokenStream(`fn main () { assert_eq ! (foo () , "Hello, world!") ; }`), |
| }, |
| ], |
| vis: Inherited, |
| ident: "Dummy", |
| generics: Generics, |
| data: Data::Struct { |
| fields: Unit, |
| semi_token: Some, |
| }, |
| } |
| "###); |
| |
| assert!(input.attrs[0].parse_meta().is_err()); |
| } |
| |
| #[test] |
| fn test_attr_with_non_mod_style_path() { |
| let input = quote! { |
| #[inert <T>] |
| struct S; |
| }; |
| |
| snapshot!(input as DeriveInput, @r###" |
| DeriveInput { |
| attrs: [ |
| Attribute { |
| style: Outer, |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "inert", |
| arguments: None, |
| }, |
| ], |
| }, |
| tokens: TokenStream(`< T >`), |
| }, |
| ], |
| vis: Inherited, |
| ident: "S", |
| generics: Generics, |
| data: Data::Struct { |
| fields: Unit, |
| semi_token: Some, |
| }, |
| } |
| "###); |
| |
| assert!(input.attrs[0].parse_meta().is_err()); |
| } |
| |
| #[test] |
| fn test_attr_with_mod_style_path_with_self() { |
| let input = quote! { |
| #[foo::self] |
| struct S; |
| }; |
| |
| snapshot!(input as DeriveInput, @r###" |
| DeriveInput { |
| attrs: [ |
| Attribute { |
| style: Outer, |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "foo", |
| arguments: None, |
| }, |
| PathSegment { |
| ident: "self", |
| arguments: None, |
| }, |
| ], |
| }, |
| tokens: TokenStream(``), |
| }, |
| ], |
| vis: Inherited, |
| ident: "S", |
| generics: Generics, |
| data: Data::Struct { |
| fields: Unit, |
| semi_token: Some, |
| }, |
| } |
| "###); |
| |
| snapshot!(input.attrs[0].parse_meta().unwrap(), @r###" |
| Path(Path { |
| segments: [ |
| PathSegment { |
| ident: "foo", |
| arguments: None, |
| }, |
| PathSegment { |
| ident: "self", |
| arguments: None, |
| }, |
| ], |
| }) |
| "###); |
| } |
| |
| #[test] |
| fn test_pub_restricted() { |
| // Taken from tests/rust/src/test/ui/resolve/auxiliary/privacy-struct-ctor.rs |
| let input = quote! { |
| pub(in m) struct Z(pub(in m::n) u8); |
| }; |
| |
| snapshot!(input as DeriveInput, @r###" |
| DeriveInput { |
| vis: Visibility::Restricted { |
| in_token: Some, |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "m", |
| arguments: None, |
| }, |
| ], |
| }, |
| }, |
| ident: "Z", |
| generics: Generics, |
| data: Data::Struct { |
| fields: Fields::Unnamed { |
| unnamed: [ |
| Field { |
| vis: Visibility::Restricted { |
| in_token: Some, |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "m", |
| arguments: None, |
| }, |
| PathSegment { |
| ident: "n", |
| arguments: None, |
| }, |
| ], |
| }, |
| }, |
| ty: Type::Path { |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "u8", |
| arguments: None, |
| }, |
| ], |
| }, |
| }, |
| }, |
| ], |
| }, |
| semi_token: Some, |
| }, |
| } |
| "###); |
| } |
| |
| #[test] |
| fn test_vis_crate() { |
| let input = quote! { |
| crate struct S; |
| }; |
| |
| snapshot!(input as DeriveInput, @r###" |
| DeriveInput { |
| vis: Visibility::Crate, |
| ident: "S", |
| generics: Generics, |
| data: Data::Struct { |
| fields: Unit, |
| semi_token: Some, |
| }, |
| } |
| "###); |
| } |
| |
| #[test] |
| fn test_pub_restricted_crate() { |
| let input = quote! { |
| pub(crate) struct S; |
| }; |
| |
| snapshot!(input as DeriveInput, @r###" |
| DeriveInput { |
| vis: Visibility::Restricted { |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "crate", |
| arguments: None, |
| }, |
| ], |
| }, |
| }, |
| ident: "S", |
| generics: Generics, |
| data: Data::Struct { |
| fields: Unit, |
| semi_token: Some, |
| }, |
| } |
| "###); |
| } |
| |
| #[test] |
| fn test_pub_restricted_super() { |
| let input = quote! { |
| pub(super) struct S; |
| }; |
| |
| snapshot!(input as DeriveInput, @r###" |
| DeriveInput { |
| vis: Visibility::Restricted { |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "super", |
| arguments: None, |
| }, |
| ], |
| }, |
| }, |
| ident: "S", |
| generics: Generics, |
| data: Data::Struct { |
| fields: Unit, |
| semi_token: Some, |
| }, |
| } |
| "###); |
| } |
| |
| #[test] |
| fn test_pub_restricted_in_super() { |
| let input = quote! { |
| pub(in super) struct S; |
| }; |
| |
| snapshot!(input as DeriveInput, @r###" |
| DeriveInput { |
| vis: Visibility::Restricted { |
| in_token: Some, |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "super", |
| arguments: None, |
| }, |
| ], |
| }, |
| }, |
| ident: "S", |
| generics: Generics, |
| data: Data::Struct { |
| fields: Unit, |
| semi_token: Some, |
| }, |
| } |
| "###); |
| } |
| |
| #[test] |
| fn test_fields_on_unit_struct() { |
| let input = quote! { |
| struct S; |
| }; |
| |
| snapshot!(input as DeriveInput, @r###" |
| DeriveInput { |
| vis: Inherited, |
| ident: "S", |
| generics: Generics, |
| data: Data::Struct { |
| fields: Unit, |
| semi_token: Some, |
| }, |
| } |
| "###); |
| |
| let data = match input.data { |
| Data::Struct(data) => data, |
| _ => panic!("expected a struct"), |
| }; |
| |
| assert_eq!(0, data.fields.iter().count()); |
| } |
| |
| #[test] |
| fn test_fields_on_named_struct() { |
| let input = quote! { |
| struct S { |
| foo: i32, |
| pub bar: String, |
| } |
| }; |
| |
| snapshot!(input as DeriveInput, @r###" |
| DeriveInput { |
| vis: Inherited, |
| ident: "S", |
| generics: Generics, |
| data: Data::Struct { |
| fields: Fields::Named { |
| named: [ |
| Field { |
| vis: Inherited, |
| ident: Some("foo"), |
| colon_token: Some, |
| ty: Type::Path { |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "i32", |
| arguments: None, |
| }, |
| ], |
| }, |
| }, |
| }, |
| Field { |
| vis: Visibility::Public, |
| ident: Some("bar"), |
| colon_token: Some, |
| ty: Type::Path { |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "String", |
| arguments: None, |
| }, |
| ], |
| }, |
| }, |
| }, |
| ], |
| }, |
| }, |
| } |
| "###); |
| |
| let data = match input.data { |
| Data::Struct(data) => data, |
| _ => panic!("expected a struct"), |
| }; |
| |
| snapshot!(data.fields.into_iter().collect::<Vec<_>>(), @r###" |
| [ |
| Field { |
| vis: Inherited, |
| ident: Some("foo"), |
| colon_token: Some, |
| ty: Type::Path { |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "i32", |
| arguments: None, |
| }, |
| ], |
| }, |
| }, |
| }, |
| Field { |
| vis: Visibility::Public, |
| ident: Some("bar"), |
| colon_token: Some, |
| ty: Type::Path { |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "String", |
| arguments: None, |
| }, |
| ], |
| }, |
| }, |
| }, |
| ] |
| "###); |
| } |
| |
| #[test] |
| fn test_fields_on_tuple_struct() { |
| let input = quote! { |
| struct S(i32, pub String); |
| }; |
| |
| snapshot!(input as DeriveInput, @r###" |
| DeriveInput { |
| vis: Inherited, |
| ident: "S", |
| generics: Generics, |
| data: Data::Struct { |
| fields: Fields::Unnamed { |
| unnamed: [ |
| Field { |
| vis: Inherited, |
| ty: Type::Path { |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "i32", |
| arguments: None, |
| }, |
| ], |
| }, |
| }, |
| }, |
| Field { |
| vis: Visibility::Public, |
| ty: Type::Path { |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "String", |
| arguments: None, |
| }, |
| ], |
| }, |
| }, |
| }, |
| ], |
| }, |
| semi_token: Some, |
| }, |
| } |
| "###); |
| |
| let data = match input.data { |
| Data::Struct(data) => data, |
| _ => panic!("expected a struct"), |
| }; |
| |
| snapshot!(data.fields.iter().collect::<Vec<_>>(), @r###" |
| [ |
| Field { |
| vis: Inherited, |
| ty: Type::Path { |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "i32", |
| arguments: None, |
| }, |
| ], |
| }, |
| }, |
| }, |
| Field { |
| vis: Visibility::Public, |
| ty: Type::Path { |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "String", |
| arguments: None, |
| }, |
| ], |
| }, |
| }, |
| }, |
| ] |
| "###); |
| } |
| |
| #[test] |
| fn test_ambiguous_crate() { |
| let input = quote! { |
| // The field type is `(crate::X)` not `crate (::X)`. |
| struct S(crate::X); |
| }; |
| |
| snapshot!(input as DeriveInput, @r###" |
| DeriveInput { |
| vis: Inherited, |
| ident: "S", |
| generics: Generics, |
| data: Data::Struct { |
| fields: Fields::Unnamed { |
| unnamed: [ |
| Field { |
| vis: Inherited, |
| ty: Type::Path { |
| path: Path { |
| segments: [ |
| PathSegment { |
| ident: "crate", |
| arguments: None, |
| }, |
| PathSegment { |
| ident: "X", |
| arguments: None, |
| }, |
| ], |
| }, |
| }, |
| }, |
| ], |
| }, |
| semi_token: Some, |
| }, |
| } |
| "###); |
| } |
