Deny manual init() if #[class(init|no_init)] is present

Update one test that failed under this rule.

Author: Bromeon

godot-macros/src/class/data_models/interface_trait_impl.rs

@@ -227,8 +227,12 @@ fn handle_init<'a>(
         godot_init_impl, ..
     } = decls;
 
+    // If #[class(init)] or #[class(no_init)] is provided, deny overriding manual init().
+    let deny_manual_init_macro = util::format_class_deny_manual_init_macro(class_name);
+
     *godot_init_impl = quote! {
         #godot_init_impl
+        #deny_manual_init_macro!();
 
         #(#cfg_attrs)*
         impl ::godot::obj::cap::GodotDefault for #class_name {

godot-macros/src/class/derive_godot_class.rs

@@ -148,6 +148,7 @@ pub fn derive_godot_class(item: venial::Item) -> ParseResult<TokenStream> {
     // Note: one limitation is that macros don't work for `impl nested::MyClass` blocks.
     let visibility_macro = make_visibility_macro(class_name, class.vis_marker.as_ref());
     let base_field_macro = make_base_field_macro(class_name, fields.base_field.is_some());
+    let deny_manual_init_macro = make_deny_manual_init_macro(class_name, struct_cfg.init_strategy);
 
     Ok(quote! {
         impl ::godot::obj::GodotClass for #class_name {
@@ -180,6 +181,7 @@ pub fn derive_godot_class(item: venial::Item) -> ParseResult<TokenStream> {
         #init_expecter
         #visibility_macro
         #base_field_macro
+        #deny_manual_init_macro
         #( #deprecations )*
         #( #errors )*
 
@@ -236,6 +238,35 @@ fn make_base_field_macro(class_name: &Ident, has_base_field: bool) -> TokenStrea
     }
 }
 
+/// Generates code for a decl-macro that prevents manual `init()` for incompatible init strategies.
+fn make_deny_manual_init_macro(class_name: &Ident, init_strategy: InitStrategy) -> TokenStream {
+    let macro_name = util::format_class_deny_manual_init_macro(class_name);
+
+    let class_attr = match init_strategy {
+        InitStrategy::Absent => "#[class(no_init)]",
+        InitStrategy::Generated => "#[class(init)]",
+        InitStrategy::UserDefined => {
+            // For classes that expect manual init, do nothing.
+            return quote! {
+                macro_rules! #macro_name {
+                    () => {};
+                }
+            };
+        }
+    };
+
+    let error_message =
+        format!("Class `{class_name}` is marked with {class_attr} but provides an init() method.");
+
+    quote! {
+        macro_rules! #macro_name {
+            () => {
+                compile_error!(#error_message);
+            };
+        }
+    }
+}
+
 /// Checks at compile time that a function with the given name exists on `Self`.
 #[must_use]
 pub fn make_existence_check(ident: &Ident) -> TokenStream {

godot-macros/src/util/mod.rs

@@ -418,3 +418,8 @@ pub fn format_class_visibility_macro(class_name: &Ident) -> Ident {
 pub fn format_class_base_field_macro(class_name: &Ident) -> Ident {
     format_ident!("__godot_{class_name}_has_base_field_macro")
 }
+
+/// Returns the name of the macro used to deny manual `init()` for incompatible init strategies.
+pub fn format_class_deny_manual_init_macro(class_name: &Ident) -> Ident {
+    format_ident!("__deny_manual_init_{class_name}")
+}

itest/rust/src/engine_tests/codegen_test.rs

@@ -142,7 +142,7 @@ impl CodegenTest2 {
 macro_rules! make_class {
     ($ClassName:ident, $BaseName:ident) => {
         #[derive(GodotClass)]
-        #[class(no_init, base=$BaseName)]
+        #[class(base=$BaseName)]
         pub struct $ClassName {
             base: Base<godot::classes::$BaseName>,
         }