vendor/darling/tests/from_type_param.rs

   1 #[macro_use]
   2 extern crate darling;
   3 #[macro_use]
   4 extern crate syn;
   5 #[macro_use]
   6 extern crate quote;
   7
   8 use darling::FromTypeParam;
   9 use syn::{DeriveInput, GenericParam, Ident, TypeParam};
  10
  11 #[darling(attributes(lorem), from_ident)]
  12 #[derive(FromTypeParam)]
  13 struct Lorem {
  14     ident: Ident,
  15     bounds: Vec<syn::TypeParamBound>,
  16     foo: bool,
  17     bar: Option<String>,
  18 }
  19
  20 impl From<Ident> for Lorem {
  21     fn from(ident: Ident) -> Self {
  22         Lorem {
  23             ident,
  24             foo: false,
  25             bar: None,
  26             bounds: Default::default(),
  27         }
  28     }
  29 }
  30
  31 fn extract_type(param: &GenericParam) -> &TypeParam {
  32     match *param {
  33         GenericParam::Type(ref ty) => ty,
  34         _ => unreachable!("Not a type param"),
  35     }
  36 }
  37
  38 #[test]
  39 fn expand_many() {
  40     let di: DeriveInput = parse_quote! {
  41         struct Baz<
  42             #[lorem(foo)] T,
  43             #[lorem(bar = "x")] U: Eq + ?Sized
  44         >(T, U);
  45     };
  46
  47     let params = di.generics.params;
  48
  49     {
  50         let ty = extract_type(&params[0]);
  51         let lorem = Lorem::from_type_param(ty).unwrap();
  52         assert_eq!(lorem.ident, "T");
  53         assert_eq!(lorem.foo, true);
  54         assert_eq!(lorem.bar, None);
  55     }
  56
  57     {
  58         let ty = extract_type(&params[1]);
  59         let lorem = Lorem::from_type_param(ty).unwrap();
  60         assert_eq!(lorem.ident, "U");
  61         assert_eq!(lorem.foo, false);
  62         assert_eq!(lorem.bar, Some("x".to_string()));
  63         assert_eq!(lorem.bounds.len(), 2);
  64     }
  65 }