Add XyNotification enums that accumulate all notification constants in scope

Author: Bromeon

godot-codegen/src/class_generator.rs

@@ -177,6 +177,7 @@ fn make_class(class: &Class, class_name: &TyName, ctx: &mut Context) -> Generate
     let inherits_macro = format_ident!("inherits_transitive_{}", class_name.rust_ty);
     let all_bases = ctx.inheritance_tree().collect_all_bases(class_name);
     let virtual_trait = make_virtual_methods_trait(class, &all_bases, &virtual_trait_str, ctx);
+    let notification_enum = make_notification_enum(class_name, &all_bases, ctx);
 
     let memory = if class_name.rust_ty == "Object" {
         ident("DynamicRefCount")
@@ -203,6 +204,7 @@ fn make_class(class: &Class, class_name: &TyName, ctx: &mut Context) -> Generate
                 object_ptr: sys::GDExtensionObjectPtr,
             }
             #virtual_trait
+            #notification_enum
             impl #class_name {
                 #constructor
                 #methods
@@ -264,6 +266,91 @@ fn make_class(class: &Class, class_name: &TyName, ctx: &mut Context) -> Generate
     }
 }
 
+fn make_notification_enum(
+    class_name: &TyName,
+    all_bases: &Vec<TyName>,
+    ctx: &mut Context,
+) -> TokenStream {
+    let Some(all_constants) = ctx.notification_constants(class_name) else  {
+        // Class has no notification constants: reuse (direct/indirect) base enum
+        return TokenStream::new();
+    };
+
+    // Collect all notification constants from current and base classes
+    let mut all_constants = all_constants.clone();
+    for base_name in all_bases {
+        if let Some(constants) = ctx.notification_constants(base_name) {
+            all_constants.extend(constants.iter().cloned());
+        }
+    }
+
+    workaround_constant_collision(&mut all_constants);
+
+    let enum_name = ctx.notification_enum_name(class_name);
+
+    let mut notification_enumerators_pascal = Vec::new();
+    let mut notification_enumerators_ord = Vec::new();
+    for (constant_ident, constant_value) in all_constants {
+        notification_enumerators_pascal.push(constant_ident);
+        notification_enumerators_ord.push(constant_value);
+    }
+
+    quote! {
+        /// Notification type for class `#class_name`.
+        ///
+        /// Makes it easier to keep an overview all possible notification variants for a given class, including
+        /// notifications defined in base classes.
+        #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
+        #[repr(i32)]
+        pub enum #enum_name {
+            #(
+                #notification_enumerators_pascal = #notification_enumerators_ord,
+            )*
+
+            /// Since Godot represents notifications as integers, it's always possible that a notification outside the known types
+            /// is received. For example, the user can manually issue notifications through `Object.notification()`.
+            Unknown(i32),
+        }
+
+        impl #enum_name {
+            /// Always succeeds, mapping unknown integers to the `Unknown` variant.
+            pub fn from_i32(enumerator: i32) -> Self {
+                match enumerator {
+                    #(
+                        #notification_enumerators_ord => Self::#notification_enumerators_pascal,
+                    )*
+                    other_int => Self::Unknown(other_int),
+                }
+            }
+
+            pub fn to_i32(self) -> i32 {
+                match self {
+                    #(
+                        Self::#notification_enumerators_pascal => #notification_enumerators_ord,
+                    )*
+                    Self::Unknown(int) => int,
+                }
+            }
+        }
+    }
+}
+
+/// Workaround for Godot bug https://github.com/godotengine/godot/issues/75839
+///
+/// Godot has a collision for two notification constants (DRAW, NODE_CACHE_REQUESTED) in the same inheritance branch (as of 4.0.2).
+/// This cannot be represented in a Rust enum, so we merge the two constants into a single enumerator.
+fn workaround_constant_collision(all_constants: &mut Vec<(Ident, i32)>) {
+    for first in ["Draw", "VisibilityChanged"] {
+        if let Some(index_of_draw) = all_constants
+            .iter()
+            .position(|(constant_name, _)| constant_name == first)
+        {
+            all_constants[index_of_draw].0 = format_ident!("{first}OrNodeRecacheRequested");
+            all_constants.retain(|(constant_name, _)| constant_name != "NodeRecacheRequested");
+        }
+    }
+}
+
 fn make_builtin_class(
     class: &BuiltinClass,
     class_name: &TyName,

godot-codegen/src/context.rs

@@ -5,7 +5,9 @@
  */
 
 use crate::api_parser::Class;
-use crate::{ExtensionApi, RustTy, TyName};
+use crate::{util, ExtensionApi, RustTy, TyName};
+use proc_macro2::Ident;
+use quote::format_ident;
 use std::collections::{HashMap, HashSet};
 
 #[derive(Default)]
@@ -15,6 +17,8 @@ pub(crate) struct Context<'a> {
     singletons: HashSet<&'a str>,
     inheritance_tree: InheritanceTree,
     cached_rust_types: HashMap<String, RustTy>,
+    notifications_by_class: HashMap<TyName, Vec<(Ident, i32)>>,
+    notification_enum_names_by_class: HashMap<TyName, Ident>,
 }
 
 impl<'a> Context<'a> {
@@ -39,15 +43,76 @@ impl<'a> Context<'a> {
                 continue;
             }
 
+            // Populate class lookup by name
             println!("-- add engine class {}", class_name.description());
             ctx.engine_classes.insert(class_name.clone(), class);
 
+            // Populate derived-to-base relations
             if let Some(base) = class.inherits.as_ref() {
                 let base_name = TyName::from_godot(base);
                 println!("  -- inherits {}", base_name.description());
-                ctx.inheritance_tree.insert(class_name, base_name);
+                ctx.inheritance_tree.insert(class_name.clone(), base_name);
+            }
+
+            // Populate notification constants
+            if let Some(constants) = class.constants.as_ref() {
+                let mut has_notifications = false;
+
+                for constant in constants.iter() {
+                    if let Some(rust_constant) = util::try_to_notification(&constant) {
+                        // First time
+                        if !has_notifications {
+                            ctx.notifications_by_class
+                                .insert(class_name.clone(), Vec::new());
+                            ctx.notification_enum_names_by_class.insert(
+                                class_name.clone(),
+                                make_notification_enum_name(&class_name),
+                            );
+                            has_notifications = true;
+                        }
+
+                        ctx.notifications_by_class
+                            .get_mut(&class_name)
+                            .expect("just inserted constants; must be present")
+                            .push((rust_constant, constant.value));
+                    }
+                }
             }
         }
+
+        // Populate remaining notification enum names, by copying the one to nearest base class that has at least 1 notification.
+        // At this point all classes with notifications are registered.
+        // (Used to avoid re-generating the same notification enum for multiple base classes).
+        for class_name in ctx.engine_classes.keys() {
+            if ctx
+                .notification_enum_names_by_class
+                .contains_key(class_name)
+            {
+                continue;
+            }
+
+            let all_bases = ctx.inheritance_tree.collect_all_bases(class_name);
+
+            let mut nearest = None;
+            for i in 0..all_bases.len() {
+                if let Some(nearest_enum_name) =
+                    ctx.notification_enum_names_by_class.get(&all_bases[i])
+                {
+                    nearest = Some((i, nearest_enum_name.clone()));
+                    break;
+                }
+            }
+            let (nearest_index, nearest_enum_name) =
+                nearest.expect("at least one base must have notifications");
+
+            // For all bases inheriting most-derived base that has notification constants, reuse the type name.
+            for i in (0..nearest_index).rev() {
+                let base_name = &all_bases[i];
+                ctx.notification_enum_names_by_class
+                    .insert(base_name.clone(), nearest_enum_name.clone());
+            }
+        }
+
         ctx
     }
 
@@ -78,6 +143,17 @@ impl<'a> Context<'a> {
         self.cached_rust_types.get(ty)
     }
 
+    pub fn notification_constants(&'a self, class_name: &TyName) -> Option<&Vec<(Ident, i32)>> {
+        self.notifications_by_class.get(class_name)
+    }
+
+    pub fn notification_enum_name(&self, class_name: &TyName) -> Ident {
+        self.notification_enum_names_by_class
+            .get(class_name)
+            .expect("every class must have a notification enum name")
+            .clone()
+    }
+
     pub fn insert_rust_type(&mut self, ty: &str, resolved: RustTy) {
         let prev = self.cached_rust_types.insert(ty.to_string(), resolved);
         assert!(prev.is_none(), "no overwrites of RustTy");
@@ -96,6 +172,7 @@ impl InheritanceTree {
         assert!(existing.is_none(), "Duplicate inheritance insert");
     }
 
+    /// Returns all base classes, without the class itself, in order from nearest to furthest (object).
     pub fn collect_all_bases(&self, derived_name: &TyName) -> Vec<TyName> {
         let mut maybe_base = derived_name;
         let mut result = vec![];
@@ -107,3 +184,7 @@ impl InheritanceTree {
         result
     }
 }
+
+fn make_notification_enum_name(class_name: &TyName) -> Ident {
+    format_ident!("{}Notification", class_name.rust_ty)
+}

godot-codegen/src/util.rs

@@ -115,6 +115,14 @@ pub fn make_constant_definition(constant: &ClassConstant) -> TokenStream {
     }
 }
 
+/// Tries to interpret the constant as a notification one, and transforms it to a Rust identifier on success.
+pub fn try_to_notification(constant: &ClassConstant) -> Option<Ident> {
+    constant
+        .name
+        .strip_prefix("NOTIFICATION_")
+        .map(|s| ident(&shout_to_pascal(s)))
+}
+
 fn make_enum_name(enum_name: &str) -> Ident {
     // TODO clean up enum name
 
@@ -162,6 +170,27 @@ pub fn to_pascal_case(class_name: &str) -> String {
         .replace("GdNative", "GDNative")
 }
 
+pub fn shout_to_pascal(shout_case: &str) -> String {
+    // TODO use heck?
+
+    let mut result = String::with_capacity(shout_case.len());
+    let mut next_upper = true;
+
+    for ch in shout_case.chars() {
+        if next_upper {
+            assert_ne!(ch, '_'); // no double underscore
+            result.push(ch); // unchanged
+            next_upper = false;
+        } else if ch == '_' {
+            next_upper = true;
+        } else {
+            result.push(ch.to_ascii_lowercase());
+        }
+    }
+
+    result
+}
+
 pub fn ident(s: &str) -> Ident {
     format_ident!("{}", s)
 }