Make GodotClass::INIT_LEVEL more user-friendly (remove Option + document)

Author: Bromeon

godot-codegen/src/class_generator.rs

@@ -651,11 +651,12 @@ fn make_class(class: &Class, class_name: &TyName, ctx: &mut Context) -> Generate
             }
             impl crate::obj::GodotClass for #class_name {
                 type Base = #base_ty;
-                const INIT_LEVEL: Option<crate::init::InitLevel> = #init_level;
 
                 fn class_name() -> ClassName {
                     ClassName::from_ascii_cstr(#class_name_cstr)
                 }
+
+                const INIT_LEVEL: crate::init::InitLevel = #init_level;
             }
             unsafe impl crate::obj::Bounds for #class_name {
                 type Memory = crate::obj::bounds::#assoc_memory;

godot-codegen/src/util.rs

@@ -65,9 +65,9 @@ impl ClassCodegenLevel {
 
     pub fn to_init_level(self) -> TokenStream {
         match self {
-            Self::Servers => quote! { Some(crate::init::InitLevel::Servers) },
-            Self::Scene => quote! { Some(crate::init::InitLevel::Scene) },
-            Self::Editor => quote! { Some(crate::init::InitLevel::Editor) },
+            Self::Servers => quote! { crate::init::InitLevel::Servers },
+            Self::Scene => quote! { crate::init::InitLevel::Scene },
+            Self::Editor => quote! { crate::init::InitLevel::Editor },
         }
     }
 }

godot-core/src/obj/bounds.rs

@@ -108,7 +108,6 @@ pub(super) mod private {
     /// impl GodotClass for MyClass {
     ///     type Base = Node;
     ///
-    /// # const INIT_LEVEL: Option<InitLevel> = None;
     ///     fn class_name() -> ClassName {
     ///         ClassName::from_ascii_cstr(b"MyClass\0")
     ///     }

godot-core/src/obj/traits.rs

@@ -25,17 +25,17 @@ where
     /// The immediate superclass of `T`. This is always a Godot engine class.
     type Base: GodotClass; // not EngineClass because it can be ()
 
-    /// During which initialization level this class is available/should be initialized with Godot.
-    ///
-    /// Is `None` if the class has complicated initialization requirements, and generally cannot be inherited
-    /// from (currently only for `()`, the "base" of `Object`).
-    const INIT_LEVEL: Option<InitLevel>;
-
     /// The name of the class, under which it is registered in Godot.
     ///
     /// This may deviate from the Rust struct name: `HttpRequest::class_name().as_str() == "HTTPRequest"`.
     fn class_name() -> ClassName;
 
+    /// Initialization level, during which this class should be initialized with Godot.
+    ///
+    /// The default is a good choice in most cases; override only if you have very specific initialization requirements.
+    /// It must not be less than `Base::INIT_LEVEL`.
+    const INIT_LEVEL: InitLevel = <Self::Base as GodotClass>::INIT_LEVEL;
+
     /// Returns whether `Self` inherits from `U`.
     ///
     /// This is reflexive, i.e `Self` inherits from itself.
@@ -55,11 +55,12 @@ where
 /// Unit impl only exists to represent "no base", and is used for exactly one class: `Object`.
 impl GodotClass for () {
     type Base = ();
-    const INIT_LEVEL: Option<InitLevel> = None;
 
     fn class_name() -> ClassName {
         ClassName::none()
     }
+
+    const INIT_LEVEL: InitLevel = InitLevel::Core; // arbitrary; never read.
 }
 
 /// Unit impl only exists to represent "no base", and is used for exactly one class: `Object`.

godot-core/src/registry.rs

@@ -8,7 +8,6 @@
 use crate::builtin::meta::ClassName;
 use crate::builtin::StringName;
 use crate::init::InitLevel;
-use crate::log;
 use crate::obj::*;
 use crate::out;
 use crate::private::as_storage;
@@ -39,7 +38,7 @@ pub struct ClassPlugin {
 
     // Init-level is per ClassPlugin and not per PluginComponent, because all components of all classes are mixed together in one
     // huge linker list. There is no per-class aggregation going on, so this allows to easily filter relevant classes.
-    pub init_level: Option<InitLevel>,
+    pub init_level: InitLevel,
 }
 
 /// Type-erased function object, holding a `register_class` function.
@@ -224,6 +223,11 @@ pub fn register_class<
         ..default_creation_info()
     };
 
+    assert!(
+        !T::class_name().as_str().is_empty(),
+        "cannot register () or unnamed class"
+    );
+
     register_class_raw(ClassRegistrationInfo {
         class_name: T::class_name(),
         parent_class_name: Some(T::Base::class_name()),
@@ -235,9 +239,7 @@ pub fn register_class<
         user_virtual_fn: None,
         default_virtual_fn: None,
         godot_params,
-        init_level: T::INIT_LEVEL.unwrap_or_else(|| {
-            panic!("Unknown initialization level for class {}", T::class_name())
-        }),
+        init_level: T::INIT_LEVEL,
         is_editor_plugin: false,
     });
 }
@@ -256,13 +258,8 @@ pub fn auto_register_classes(init_level: InitLevel) {
         //out!("* Plugin: {elem:#?}");
 
         // Filter per ClassPlugin and not PluginComponent, because all components of all classes are mixed together in one huge list.
-        match elem.init_level {
-            None => {
-                log::godot_error!("Unknown initialization level for class {}", elem.class_name);
-                return;
-            }
-            Some(elem_init_level) if elem_init_level != init_level => return,
-            _ => { /* Nothing */ }
+        if elem.init_level != init_level {
+            return;
         }
 
         let name = elem.class_name;

godot-macros/src/class/derive_godot_class.rs

@@ -97,7 +97,6 @@ pub fn derive_godot_class(decl: Declaration) -> ParseResult<TokenStream> {
     Ok(quote! {
         impl ::godot::obj::GodotClass for #class_name {
             type Base = #base_class;
-            const INIT_LEVEL: Option<::godot::init::InitLevel> = <#base_class as ::godot::obj::GodotClass>::INIT_LEVEL;
 
             fn class_name() -> ::godot::builtin::meta::ClassName {
                 ::godot::builtin::meta::ClassName::from_ascii_cstr(#class_name_cstr)
@@ -127,7 +126,21 @@ pub fn derive_godot_class(decl: Declaration) -> ParseResult<TokenStream> {
                 free_fn: #prv::callbacks::free::<#class_name>,
                 default_get_virtual_fn: #default_get_virtual_fn,
             },
-            init_level: <#class_name as ::godot::obj::GodotClass>::INIT_LEVEL,
+            init_level: {
+                let level = <#class_name as ::godot::obj::GodotClass>::INIT_LEVEL;
+                let base_level = <#base_class as ::godot::obj::GodotClass>::INIT_LEVEL;
+
+                // Sanity check for init levels. Note that this does not cover cases where GodotClass is manually defined;
+                // might make sense to add a run-time check during class registration.
+                assert!(
+                    level >= base_level,
+                    "Class `{class}` has init level `{level:?}`, but its base class has init level `{base_level:?}`.\n\
+                    A class cannot be registered before its base class.",
+                    class = #class_name_str,
+                );
+
+                level
+            }
         });
 
         #editor_plugin