Split function table initializations into one method per class

Reduces the number of local variables and expressions needed, which seems to cause problems for certain compilations
(WASM or release mode in general), taking a long time and using a lot of RAM.

Author: Bromeon

godot-codegen/src/central_generator.rs

@@ -46,7 +46,8 @@ struct IndexedMethodTable {
     ctor_parameters: TokenStream,
     pre_init_code: TokenStream,
     fptr_type: TokenStream,
-    method_inits: Vec<MethodInit>,
+    fetch_fptr_type: TokenStream,
+    method_init_groups: Vec<MethodInitGroup>,
     lazy_key_type: TokenStream,
     lazy_method_init: TokenStream,
     named_accessors: Vec<AccessorMethod>,
@@ -70,6 +71,38 @@ impl ToTokens for MethodInit {
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 
+#[cfg_attr(feature = "codegen-lazy-fptrs", allow(dead_code))]
+struct MethodInitGroup {
+    class_name: Ident,
+    class_var_init: Option<TokenStream>,
+    method_inits: Vec<MethodInit>,
+}
+
+impl MethodInitGroup {
+    fn new(class_godot_name: &str, class_var: Ident, method_inits: Vec<MethodInit>) -> Self {
+        Self {
+            class_name: ident(class_godot_name),
+            // Only create class variable if any methods have been added.
+            class_var_init: if method_inits.is_empty() {
+                None
+            } else {
+                let initializer_expr = util::make_sname_ptr(class_godot_name);
+                Some(quote! {
+                    let #class_var = #initializer_expr;
+                })
+            },
+            method_inits,
+        }
+    }
+
+    #[cfg(not(feature = "codegen-lazy-fptrs"))]
+    fn function_name(&self) -> Ident {
+        format_ident!("load_{}_methods", self.class_name)
+    }
+}
+
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+
 struct AccessorMethod {
     name: Ident,
     index: usize,
@@ -273,7 +306,8 @@ fn make_method_table(info: IndexedMethodTable) -> TokenStream {
         ctor_parameters,
         pre_init_code,
         fptr_type,
-        mut method_inits,
+        fetch_fptr_type,
+        method_init_groups,
         lazy_key_type: _,
         lazy_method_init: _,
         named_accessors,
@@ -287,27 +321,59 @@ fn make_method_table(info: IndexedMethodTable) -> TokenStream {
 
     // Make sure methods are complete and in order of index.
     assert_eq!(
-        method_inits.len(),
+        method_init_groups
+            .iter()
+            .map(|group| group.method_inits.len())
+            .sum::<usize>(),
         method_count,
         "number of methods does not match count"
     );
-    method_inits.sort_by_key(|init| init.index);
+    // method_inits.sort_by_key(|init| init.index);
 
-    if let Some(last) = method_inits.last() {
+    if let Some(last) = method_init_groups.last() {
         assert_eq!(
-            last.index,
+            last.method_inits.last().unwrap().index,
             method_count - 1,
             "last method should have highest index"
         );
     } else {
         assert_eq!(method_count, 0, "empty method table should have count 0");
     }
 
+    let method_load_inits = method_init_groups.iter().map(|group| {
+        let func = group.function_name();
+        quote! {
+            #func(&mut function_pointers, string_names, fetch_fptr);
+        }
+    });
+
+    let method_load_decls = method_init_groups.iter().map(|group| {
+        let func = group.function_name();
+        let method_inits = &group.method_inits;
+        let class_var_init = &group.class_var_init;
+
+        quote! {
+            fn #func(
+                function_pointers: &mut Vec<#fptr_type>,
+                string_names: &mut crate::StringCache,
+                fetch_fptr: FetchFn,
+            ) {
+                #class_var_init
+
+                #(
+                    function_pointers.push(#method_inits);
+                )*
+            }
+        }
+    });
+
     // Assumes that inits already have a trailing comma.
     // This is necessary because some generators emit multiple lines (statements) per element.
     quote! {
         #imports
 
+        type FetchFn = <#fetch_fptr_type as crate::Inner>::FnPtr;
+
         pub struct #table_name {
             function_pointers: Vec<#fptr_type>,
         }
@@ -322,11 +388,10 @@ fn make_method_table(info: IndexedMethodTable) -> TokenStream {
             ) -> Self {
                 #pre_init_code
 
-                Self {
-                    function_pointers: vec![
-                        #( #method_inits )*
-                    ]
-                }
+                let mut function_pointers = Vec::with_capacity(#method_count);
+                #( #method_load_inits )*
+
+                Self { function_pointers }
             }
 
             #[inline(always)]
@@ -339,6 +404,8 @@ fn make_method_table(info: IndexedMethodTable) -> TokenStream {
 
             #named_method_api
         }
+
+        #( #method_load_decls )*
     }
 }
 
@@ -350,7 +417,8 @@ fn make_method_table(info: IndexedMethodTable) -> TokenStream {
         ctor_parameters: _,
         pre_init_code: _,
         fptr_type,
-        method_inits: _,
+        fetch_fptr_type: _,
+        method_init_groups: _,
         lazy_key_type,
         lazy_method_init,
         named_accessors,
@@ -819,7 +887,8 @@ fn make_class_method_table(
         },
         pre_init_code: TokenStream::new(), // late-init, depends on class string names
         fptr_type: quote! { crate::ClassMethodBind },
-        method_inits: vec![],
+        fetch_fptr_type: quote! { crate::GDExtensionInterfaceClassdbGetMethodBind },
+        method_init_groups: vec![],
         lazy_key_type: quote! { crate::lazy_keys::ClassMethodKey },
         lazy_method_init: quote! {
             let get_method_bind = crate::interface_fn!(classdb_get_method_bind);
@@ -837,7 +906,6 @@ fn make_class_method_table(
         method_count: 0,
     };
 
-    let mut class_sname_decls = Vec::new();
     for class in api.classes.iter() {
         let class_ty = TyName::from_godot(&class.name);
         if special_cases::is_class_deleted(&class_ty)
@@ -847,25 +915,11 @@ fn make_class_method_table(
             continue;
         }
 
-        let class_var = format_ident!("sname_{}", &class.name);
-        let initializer_expr = util::make_sname_ptr(&class.name);
-
-        let prev_method_count = table.method_count;
-        populate_class_methods(&mut table, class, &class_ty, &class_var, ctx);
-        if table.method_count > prev_method_count {
-            // Only create class variable if any methods have been added.
-            class_sname_decls.push(quote! {
-                let #class_var = #initializer_expr;
-            });
-        }
-
-        table.class_count += 1;
+        populate_class_methods(&mut table, class, &class_ty, ctx);
     }
 
     table.pre_init_code = quote! {
-        let get_method_bind = interface.classdb_get_method_bind.expect("classdb_get_method_bind absent");
-
-        #( #class_sname_decls )*
+        let fetch_fptr = interface.classdb_get_method_bind.expect("classdb_get_method_bind absent");
     };
 
     make_method_table(table)
@@ -916,16 +970,16 @@ fn make_builtin_method_table(
             string_names: &mut crate::StringCache,
         },
         pre_init_code: quote! {
-            use crate as sys;
-            let get_builtin_method = interface.variant_get_ptr_builtin_method.expect("variant_get_ptr_builtin_method absent");
+            let fetch_fptr = interface.variant_get_ptr_builtin_method.expect("variant_get_ptr_builtin_method absent");
         },
         fptr_type: quote! { crate::BuiltinMethodBind },
-        method_inits: vec![],
+        fetch_fptr_type: quote! { crate::GDExtensionInterfaceVariantGetPtrBuiltinMethod },
+        method_init_groups: vec![],
         lazy_key_type: quote! { crate::lazy_keys::BuiltinMethodKey },
         lazy_method_init: quote! {
-            let get_builtin_method = crate::interface_fn!(variant_get_ptr_builtin_method);
+            let fetch_fptr = crate::interface_fn!(variant_get_ptr_builtin_method);
             crate::load_builtin_method(
-                get_builtin_method,
+                fetch_fptr,
                 &mut inner.string_cache,
                 key.variant_type.sys(),
                 key.variant_type_str,
@@ -945,7 +999,6 @@ fn make_builtin_method_table(
         };
 
         populate_builtin_methods(&mut table, builtin, &builtin_type.type_names, ctx);
-        table.class_count += 1;
     }
 
     make_method_table(table)
@@ -955,9 +1008,11 @@ fn populate_class_methods(
     table: &mut IndexedMethodTable,
     class: &Class,
     class_ty: &TyName,
-    class_var: &Ident,
     ctx: &mut Context,
 ) {
+    let class_var = format_ident!("sname_{}", &class.name);
+    let mut method_inits = vec![];
+
     for method in option_as_slice(&class.methods) {
         if special_cases::is_deleted(class_ty, method, ctx) {
             continue;
@@ -969,9 +1024,9 @@ fn populate_class_methods(
             class_ty: class_ty.clone(),
             method_name: method.name.clone(),
         });
-        let method_init = make_class_method_init(method, class_var, class_ty);
 
-        table.method_inits.push(MethodInit { method_init, index });
+        let method_init = make_class_method_init(method, &class_var, class_ty);
+        method_inits.push(MethodInit { method_init, index });
         table.method_count += 1;
 
         // If requested, add a named accessor for this method.
@@ -993,6 +1048,13 @@ fn populate_class_methods(
             });
         }
     }
+
+    table.method_init_groups.push(MethodInitGroup::new(
+        &class_ty.godot_ty,
+        class_var,
+        method_inits,
+    ));
+    table.class_count += 1;
 }
 
 fn populate_builtin_methods(
@@ -1001,6 +1063,9 @@ fn populate_builtin_methods(
     builtin_name: &TypeNames,
     ctx: &mut Context,
 ) {
+    let class_var = format_ident!("sname_{}", &builtin_class.name);
+    let mut method_inits = vec![];
+
     for method in option_as_slice(&builtin_class.methods) {
         let builtin_ty = TyName::from_godot(&builtin_class.name);
         if special_cases::is_builtin_deleted(&builtin_ty, method) {
@@ -1013,8 +1078,7 @@ fn populate_builtin_methods(
         });
 
         let method_init = make_builtin_method_init(method, builtin_name, index);
-
-        table.method_inits.push(MethodInit { method_init, index });
+        method_inits.push(MethodInit { method_init, index });
         table.method_count += 1;
 
         // If requested, add a named accessor for this method.
@@ -1038,6 +1102,13 @@ fn populate_builtin_methods(
             });
         }
     }
+
+    table.method_init_groups.push(MethodInitGroup::new(
+        &builtin_class.name,
+        class_var,
+        method_inits,
+    ));
+    table.class_count += 1;
 }
 
 fn make_class_method_init(
@@ -1057,7 +1128,14 @@ fn make_class_method_init(
 
     // Could reuse lazy key, but less code like this -> faster parsing.
     quote! {
-        crate::load_class_method(get_method_bind, string_names, Some(#class_var), #class_name_str, #method_name_str, #hash),
+        crate::load_class_method(
+            fetch_fptr,
+            string_names,
+            Some(#class_var),
+            #class_name_str,
+            #method_name_str,
+            #hash
+        ),
     }
 }
 
@@ -1083,9 +1161,9 @@ fn make_builtin_method_init(
         {
             let _ = #index;
             crate::load_builtin_method(
-                get_builtin_method,
+                fetch_fptr,
                 string_names,
-                sys::#variant_type,
+                crate::#variant_type,
                 #variant_type_str,
                 #method_name_str,
                 #hash