vendor/syn/tests/test_generics.rs

#[macro_use]
mod macros;

use quote::quote;
use syn::{DeriveInput, ItemFn, TypeParamBound, WhereClause, WherePredicate};

#[test]
fn test_split_for_impl() {
    let input = quote! {
        struct S<'a, 'b: 'a, #[may_dangle] T: 'a = ()> where T: Debug;
    };

    snapshot!(input as DeriveInput, @r###"
    DeriveInput {
        vis: Inherited,
        ident: "S",
        generics: Generics {
            lt_token: Some,
            params: [
                Lifetime(LifetimeDef {
                    lifetime: Lifetime {
                        ident: "a",
                    },
                }),
                Lifetime(LifetimeDef {
                    lifetime: Lifetime {
                        ident: "b",
                    },
                    colon_token: Some,
                    bounds: [
                        Lifetime {
                            ident: "a",
                        },
                    ],
                }),
                Type(TypeParam {
                    attrs: [
                        Attribute {
                            style: Outer,
                            path: Path {
                                segments: [
                                    PathSegment {
                                        ident: "may_dangle",
                                        arguments: None,
                                    },
                                ],
                            },
                            tokens: TokenStream(``),
                        },
                    ],
                    ident: "T",
                    colon_token: Some,
                    bounds: [
                        Lifetime(Lifetime {
                            ident: "a",
                        }),
                    ],
                    eq_token: Some,
                    default: Some(Type::Tuple),
                }),
            ],
            gt_token: Some,
            where_clause: Some(WhereClause {
                predicates: [
                    Type(PredicateType {
                        bounded_ty: Type::Path {
                            path: Path {
                                segments: [
                                    PathSegment {
                                        ident: "T",
                                        arguments: None,
                                    },
                                ],
                            },
                        },
                        bounds: [
                            Trait(TraitBound {
                                modifier: None,
                                path: Path {
                                    segments: [
                                        PathSegment {
                                            ident: "Debug",
                                            arguments: None,
                                        },
                                    ],
                                },
                            }),
                        ],
                    }),
                ],
            }),
        },
        data: Data::Struct {
            fields: Unit,
            semi_token: Some,
        },
    }
    "###);

    let generics = input.generics;
    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();

    let generated = quote! {
        impl #impl_generics MyTrait for Test #ty_generics #where_clause {}
    };
    let expected = quote! {
        impl<'a, 'b: 'a, #[may_dangle] T: 'a> MyTrait
        for Test<'a, 'b, T>
        where
            T: Debug
        {}
    };
    assert_eq!(generated.to_string(), expected.to_string());

    let turbofish = ty_generics.as_turbofish();
    let generated = quote! {
        Test #turbofish
    };
    let expected = quote! {
        Test::<'a, 'b, T>
    };
    assert_eq!(generated.to_string(), expected.to_string());
}

#[test]
fn test_ty_param_bound() {
    let tokens = quote!('a);
    snapshot!(tokens as TypeParamBound, @r###"
    Lifetime(Lifetime {
        ident: "a",
    })
    "###);

    let tokens = quote!('_);
    snapshot!(tokens as TypeParamBound, @r###"
    Lifetime(Lifetime {
        ident: "_",
    })
    "###);

    let tokens = quote!(Debug);
    snapshot!(tokens as TypeParamBound, @r###"
    Trait(TraitBound {
        modifier: None,
        path: Path {
            segments: [
                PathSegment {
                    ident: "Debug",
                    arguments: None,
                },
            ],
        },
    })
    "###);

    let tokens = quote!(?Sized);
    snapshot!(tokens as TypeParamBound, @r###"
    Trait(TraitBound {
        modifier: Maybe,
        path: Path {
            segments: [
                PathSegment {
                    ident: "Sized",
                    arguments: None,
                },
            ],
        },
    })
    "###);
}

#[test]
fn test_fn_precedence_in_where_clause() {
    // This should parse as two separate bounds, `FnOnce() -> i32` and `Send` - not
    // `FnOnce() -> (i32 + Send)`.
    let input = quote! {
        fn f<G>()
        where
            G: FnOnce() -> i32 + Send,
        {
        }
    };

    snapshot!(input as ItemFn, @r###"
    ItemFn {
        vis: Inherited,
        sig: Signature {
            ident: "f",
            generics: Generics {
                lt_token: Some,
                params: [
                    Type(TypeParam {
                        ident: "G",
                    }),
                ],
                gt_token: Some,
                where_clause: Some(WhereClause {
                    predicates: [
                        Type(PredicateType {
                            bounded_ty: Type::Path {
                                path: Path {
                                    segments: [
                                        PathSegment {
                                            ident: "G",
                                            arguments: None,
                                        },
                                    ],
                                },
                            },
                            bounds: [
                                Trait(TraitBound {
                                    modifier: None,
                                    path: Path {
                                        segments: [
                                            PathSegment {
                                                ident: "FnOnce",
                                                arguments: PathArguments::Parenthesized {
                                                    output: Type(
                                                        Type::Path {
                                                            path: Path {
                                                                segments: [
                                                                    PathSegment {
                                                                        ident: "i32",
                                                                        arguments: None,
                                                                    },
                                                                ],
                                                            },
                                                        },
                                                    ),
                                                },
                                            },
                                        ],
                                    },
                                }),
                                Trait(TraitBound {
                                    modifier: None,
                                    path: Path {
                                        segments: [
                                            PathSegment {
                                                ident: "Send",
                                                arguments: None,
                                            },
                                        ],
                                    },
                                }),
                            ],
                        }),
                    ],
                }),
            },
            output: Default,
        },
        block: Block,
    }
    "###);

    let where_clause = input.sig.generics.where_clause.as_ref().unwrap();
    assert_eq!(where_clause.predicates.len(), 1);

    let predicate = match &where_clause.predicates[0] {
        WherePredicate::Type(pred) => pred,
        _ => panic!("wrong predicate kind"),
    };

    assert_eq!(predicate.bounds.len(), 2, "{:#?}", predicate.bounds);

    let first_bound = &predicate.bounds[0];
    assert_eq!(quote!(#first_bound).to_string(), "FnOnce ( ) -> i32");

    let second_bound = &predicate.bounds[1];
    assert_eq!(quote!(#second_bound).to_string(), "Send");
}

#[test]
fn test_where_clause_at_end_of_input() {
    let input = quote! {
        where
    };

    snapshot!(input as WhereClause, @"WhereClause");

    assert_eq!(input.predicates.len(), 0);
}