module: Make functions and methods work with generics

Summary:
Like it says in the title, at this point just thread it through

Unfortunately, this whole thing with generics is not actually going to work out. I wanted to use this for something like an alternative to the `internal_provider` macro (though not on providers, but enums instead) - currently, we use a macro to generate a `#[starlark_module]`, but I instead wanted to write something like

```
impl<P: InternalProvider> StarlarkValue<'v> for P
```

and then generate impls of `InternalProvider`.

The problem is that even with the things so far done, it turns out that getting the lifetimes right across the type and trait definitions, `StarlarkValue` impl, and `MethodsBuilder`, is really, really hard. I got to the point where I was pretty close, but am now calling it because:

 1. The amount of type system knowledge needed to be able to maintain the result is extreme
 2. Some of the patterns I was using were getting pretty close to known unsoundnesses in the language, specifically #84366

This is not without hope though - actually doing the work of getting rid of the `Value`/`FrozenValue` impls would make this a lot more feasible because we wouldn't have the `V` flying around too, saving a bunch of HRTBs and such things

I'm submitting the stack anyway since, on balance, I think it's probably better to have than not

Reviewed By: Nero5023

Differential Revision: D73726001

fbshipit-source-id: 014678dbdfc18a2ef5404cd7bc5548521a2a104a

Author: JakobDegen

starlark/src/tests/derive/module/generic.rs

@@ -69,9 +69,24 @@ where
     }
 }
 
+#[starlark_module]
+fn global_builder_for_func<T: Default, U>(globals: &mut GlobalsBuilder)
+where
+    U: std::fmt::Display + Default,
+{
+    fn make_my_str() -> starlark::Result<String> {
+        let _t = T::default();
+        Ok(U::default().to_string())
+    }
+}
+
 #[test]
 fn test_generic_builder() {
     let mut a = Assert::new();
-    a.globals_add(global_builder::<u8, u8>);
+    a.globals_add(|g| {
+        global_builder::<u8, u8>(g);
+        global_builder_for_func::<u8, u8>(g);
+    });
     a.eq("\"0\"", "MY_STR");
+    a.eq("\"0\"", "make_my_str()");
 }

starlark_derive/src/module/render.rs

@@ -82,7 +82,7 @@ fn render_stmt(x: StarStmt, generics: &StarGenerics) -> syn::Result<syn::Stmt> {
     match x {
         StarStmt::Const(x) => Ok(render_const(x)),
         StarStmt::Attr(x) => Ok(render_attr(x, generics)),
-        StarStmt::Fun(x) => render_fun(x),
+        StarStmt::Fun(x) => render_fun(x, generics),
     }
 }
 

starlark_derive/src/module/render/fun.rs

@@ -33,6 +33,7 @@ use crate::module::typ::StarArg;
 use crate::module::typ::StarArgSource;
 use crate::module::typ::StarFun;
 use crate::module::typ::StarFunSource;
+use crate::module::typ::StarGenerics;
 use crate::module::util::ident_string;
 
 impl StarFun {
@@ -143,11 +144,13 @@ impl StarFun {
     }
 
     /// Globals builder call to register the function.
-    fn builder_set(&self) -> syn::Result<syn::Stmt> {
+    fn builder_set(&self, generics: &StarGenerics) -> syn::Result<syn::Stmt> {
         let name_str = self.name_str();
-        let components = render_native_callable_components(self)?;
+        let components = render_native_callable_components(self, generics)?;
         let param_spec = render_signature(self)?;
 
+        let turbofish = generics.turbofish();
+
         let special_builtin_function = self.special_builtin_function_expr();
 
         if self.is_method() {
@@ -169,7 +172,7 @@ impl StarFun {
                     #name_str,
                     #components,
                     #param_spec,
-                    __starlark_invoke_outer,
+                    __starlark_invoke_outer #turbofish,
                 );
             })
         } else {
@@ -184,20 +187,24 @@ impl StarFun {
                     #as_type,
                     #ty_custom,
                     #special_builtin_function,
-                    __starlark_invoke_outer,
+                    __starlark_invoke_outer #turbofish,
                 );
             })
         }
     }
 }
 
-pub(crate) fn render_fun(x: StarFun) -> syn::Result<syn::Stmt> {
+pub(crate) fn render_fun(x: StarFun, generics: &StarGenerics) -> syn::Result<syn::Stmt> {
+    let generic_decls = generics.decls();
+    let where_clause = generics.where_clause();
+    let turbofish = generics.turbofish();
+
     let (this_outer_param, this_inner_param, this_prepare, this_arg) = x.this_param_arg();
     let (eval_param, eval_arg) = x.eval_param_arg();
     let (heap_param, heap_arg) = x.heap_param_arg();
     let (binding_params, prepare, binding_args) = x.binding_params_arg()?;
 
-    let builder_set = x.builder_set()?;
+    let builder_set = x.builder_set(generics)?;
 
     let StarFun {
         attrs,
@@ -228,9 +235,9 @@ pub(crate) fn render_fun(x: StarFun) -> syn::Result<syn::Stmt> {
         //   so the warning would be precise.
         #[allow(clippy::extra_unused_lifetimes)]
         #( #attrs )*
-        fn __starlark_invoke_impl<'v>(
+        fn __starlark_invoke_impl #generic_decls(
             #( #invoke_params, )*
-        ) -> #return_type {
+        ) -> #return_type #where_clause {
             #body
         }
     };
@@ -242,29 +249,29 @@ pub(crate) fn render_fun(x: StarFun) -> syn::Result<syn::Stmt> {
         // https://github.com/rust-lang/rfcs/pull/2515
         // Until then we use this hack as a workaround.
         #[allow(dead_code)] // Function is not used when return type is specified explicitly.
-        fn __starlark_return_type_starlark_type_repr() -> starlark::typing::Ty {
+        fn __starlark_return_type_starlark_type_repr #generic_decls () -> starlark::typing::Ty #where_clause {
             fn get_impl<'v, T: starlark::values::AllocValue<'v>, E>(
                 _f: fn(
                     #( #param_types, )*
                 ) -> std::result::Result<T, E>,
             ) -> starlark::typing::Ty {
                 <T as starlark::values::type_repr::StarlarkTypeRepr>::starlark_type_repr()
             }
-            get_impl(__starlark_invoke_impl)
+            get_impl(__starlark_invoke_impl #turbofish)
         }
     };
 
     let impl_invoke_outer: syn::ItemFn = syn::parse_quote! {
         #[allow(non_snake_case)] // Starlark doesn't have this convention
-        fn __starlark_invoke_outer<'v>(
+        fn __starlark_invoke_outer #generic_decls (
             eval: &mut starlark::eval::Evaluator<'v, '_, '_>,
             #(#this_outer_param,)*
             signature: &starlark::eval::ParametersSpec<starlark::values::FrozenValue>,
             parameters: &starlark::eval::Arguments<'v, '_>,
-        ) -> starlark::Result<starlark::values::Value<'v>> {
+        ) -> starlark::Result<starlark::values::Value<'v>> #where_clause {
             #this_prepare
             #prepare
-            match __starlark_invoke_impl(#( #invoke_args, )*) {
+            match __starlark_invoke_impl #turbofish (#( #invoke_args, )*) {
                 Ok(v) => Ok(eval.heap().alloc(v)),
                 Err(e) => Err(starlark::__derive_refs::invoke_macro_error::InvokeMacroError::into_starlark_error(e)),
             }
@@ -486,20 +493,26 @@ fn render_option(expr: Option<syn::Expr>) -> syn::Expr {
     }
 }
 
-fn render_starlark_type(typ: &syn::Type) -> syn::Expr {
+fn render_starlark_type(typ: &syn::Type, generics: &StarGenerics) -> syn::Expr {
+    let decls = generics.decls();
+    let turbofish = generics.turbofish();
+    let where_clause = generics.where_clause();
     syn::parse_quote! {
         {
             #[allow(clippy::extra_unused_lifetimes)]
-            fn get_type_string<'v>() -> starlark::typing::Ty {
+            fn get_type_string #decls () -> starlark::typing::Ty #where_clause {
                 <#typ as starlark::values::type_repr::StarlarkTypeRepr>::starlark_type_repr()
             }
-            get_type_string()
+            get_type_string #turbofish ()
         }
     }
 }
 
-fn render_regular_native_callable_param(arg: &StarArg) -> syn::Result<syn::Expr> {
-    let ty = render_starlark_type(arg.without_option());
+fn render_regular_native_callable_param(
+    arg: &StarArg,
+    generics: &StarGenerics,
+) -> syn::Result<syn::Expr> {
+    let ty = render_starlark_type(arg.without_option(), generics);
     let name_str = ident_string(&arg.param.ident);
     let required: syn::Expr = match (&arg.default, arg.is_option()) {
         (Some(_), true) => {
@@ -541,7 +554,10 @@ fn render_regular_native_callable_param(arg: &StarArg) -> syn::Result<syn::Expr>
     })
 }
 
-fn render_native_callable_components(x: &StarFun) -> syn::Result<TokenStream> {
+fn render_native_callable_components(
+    x: &StarFun,
+    generics: &StarGenerics,
+) -> syn::Result<TokenStream> {
     let docs = match x.docstring.as_ref() {
         Some(d) => quote!(Some(#d)),
         None => quote!(None),
@@ -565,28 +581,28 @@ fn render_native_callable_components(x: &StarFun) -> syn::Result<TokenStream> {
             let pos_only: Vec<syn::Expr> = pos_only
                 .iter()
                 .copied()
-                .map(render_regular_native_callable_param)
+                .map(|a| render_regular_native_callable_param(a, generics))
                 .collect::<syn::Result<Vec<_>>>()?;
             let pos_or_named: Vec<syn::Expr> = pos_or_named
                 .iter()
                 .copied()
-                .map(render_regular_native_callable_param)
+                .map(|a| render_regular_native_callable_param(a, generics))
                 .collect::<syn::Result<Vec<_>>>()?;
             let args: Option<syn::Expr> = args.map(|arg| {
                 let name_str = ident_string(&arg.param.ident);
-                let ty = render_starlark_type(&arg.param.ty);
+                let ty = render_starlark_type(&arg.param.ty, generics);
                 syn::parse_quote! {
                     starlark::__derive_refs::param_spec::NativeCallableParam::args(#name_str, #ty)
                 }
             });
             let named_only: Vec<syn::Expr> = named_only
                 .iter()
                 .copied()
-                .map(render_regular_native_callable_param)
+                .map(|a| render_regular_native_callable_param(a, generics))
                 .collect::<syn::Result<Vec<_>>>()?;
             let kwargs: Option<syn::Expr> = kwargs.map(|arg| {
                 let name_str = ident_string(&arg.param.ident);
-                let ty = render_starlark_type(&arg.param.ty);
+                let ty = render_starlark_type(&arg.param.ty, generics);
                 syn::parse_quote! {
                     starlark::__derive_refs::param_spec::NativeCallableParam::kwargs(#name_str, #ty)
                 }
@@ -606,6 +622,8 @@ fn render_native_callable_components(x: &StarFun) -> syn::Result<TokenStream> {
         }
     };
 
+    let turbofish = generics.turbofish();
+
     let speculative_exec_safe = x.speculative_exec_safe;
     Ok(quote!(
         {
@@ -614,7 +632,7 @@ fn render_native_callable_components(x: &StarFun) -> syn::Result<TokenStream> {
                 speculative_exec_safe: #speculative_exec_safe,
                 rust_docstring: #docs,
                 param_spec,
-                return_type: __starlark_return_type_starlark_type_repr(),
+                return_type: __starlark_return_type_starlark_type_repr #turbofish(),
             }
         }
     ))