Add type parameter (generics) support to trait_alias crate

Summary:
As part of my attempt to use this in D40870195 (abandoned for reasons mentioned in that diff), I extended the `trait_alias` macro to support type parameters.

**I no longer have use for this, but I'm publishing the diff just in case anyone else might want it.**

There is also some prior art for this in the OSS community, and at some point, it could make sense to just switch to that: https://github.com/popzxc/trait-set (but there is some value in reducing third-party dependencies).

Reviewed By: markbt

Differential Revision: D40825641

fbshipit-source-id: 3299a3b74f419d4d20c76a6ec599c7474c7bef51

Author: Benjamin Woodruff

shed/trait_alias/src/lib.rs

@@ -11,11 +11,15 @@
 
 extern crate proc_macro;
 
+use proc_macro2::Ident;
+use proc_macro2::Span;
 use proc_macro2::TokenStream;
 use quote::quote;
 use syn::parse_macro_input;
 use syn::Error;
+use syn::GenericParam;
 use syn::ItemTraitAlias;
+use syn::TypeParam;
 
 /// Implement a trait alias using a subtrait and blanket definition.
 ///
@@ -66,9 +70,26 @@ fn gen_trait_alias(trait_alias: ItemTraitAlias) -> Result<TokenStream, Error> {
     let vis = trait_alias.vis;
     let ident = trait_alias.ident;
     let bounds = trait_alias.bounds;
+    let generics = trait_alias.generics;
+
+    // Pick a unique name. Ideally this would use `Span::def_site`, but it isn't stable.
+    let blanket_type_ident = Ident::new("_TraitAliasImplBlanketType", Span::mixed_site());
+    let mut blanket_type_param = TypeParam::from(blanket_type_ident.clone());
+    blanket_type_param.bounds = bounds.clone();
+
+    // Append the blanket type to the end of the generic params of our `impl` block.
+    // We'll implement our alias over that blanket type.
+    let mut generics_with_blanket_type = generics.clone();
+    generics_with_blanket_type
+        .params
+        .push(GenericParam::Type(blanket_type_param));
+
+    // declare all the bits needed by quote
+    let (trait_generics, ty_generics, where_clause) = generics.split_for_impl();
+    let (impl_generics, _, _) = generics_with_blanket_type.split_for_impl();
 
     Ok(quote! {
-        #vis trait #ident : #bounds {}
-        impl<T> #ident for T where T: #bounds {}
+        #vis trait #ident #trait_generics : #bounds #where_clause {}
+        impl #impl_generics #ident #ty_generics for #blanket_type_ident #where_clause {}
     })
 }

shed/trait_alias/test/trait_alias_test.rs

@@ -32,12 +32,24 @@ impl Two for Impl {
     }
 }
 
-fn test(both: &impl Both) {
+#[trait_alias::trait_alias]
+trait GenericFn<T: Both> = Fn() -> T;
+
+fn test_both(both: &impl Both) {
     assert_eq!(both.one(), 1);
     assert_eq!(both.two(), 2);
 }
 
+fn test_generic_fn<B>(generic_fn: impl GenericFn<B>)
+where
+    B: Both,
+{
+    assert_eq!((generic_fn)().one(), 1);
+    assert_eq!((generic_fn)().two(), 2);
+}
+
 #[test]
 fn main() {
-    test(&Impl);
+    test_both(&Impl);
+    test_generic_fn(|| Impl);
 }