Classes without init break hot reloading

[Bromeon]

It seems like a single class that is declared as something like:

#[derive(GodotClass)]
#[class(base=Node2D)]
struct MyClass {}

-- that is, no #[class(init)] and no manual override of fn init() -- is enough to break hot reloading.

The Godot error message is not helpful:

ERROR: Extension marked as reloadable, but attempted to register class 'MyClass' which doesn't support reloading. Perhaps your language binding don't support it? Reloading disabled for this extension.

---

There are several measures we can take:

1. Prioritize the already planned init-refactoring (it's also easy to forget; maybe something like no_init could work?)
2. Make sure that classes without init method are registered properly in GDExtension, meaning they are without a default constructor but otherwise functional.
   • Maybe the recreate_fn is needed.
3. If having a constructor is a hard requirement for hot reloading in GDExtension, we can either:
   • Enforce that all classes have one, if hot reloading is enabled (if we can detect reloadable=true at startup)
   • Supply a "dummy" one just for this case, although that might come with follow-up issues

Long-term, we could probably expose something like a reinit() constructor that is invoked on hot reloads, and by default calls init. But before working on more features, I'd like to get the base robust.

[zaddok]

This explains half of the problems I was having.

[Bromeon]

I think absence of a constructor should be explicit. It's the exceptional case, and it's very easy to forget init. Apart from this problem, it can also cause other issues (e.g. in the editor or in scenes where classes are attempted to be default-constructed).

My current idea:

#[derive(GodotClass)]
struct MyClass { ... }

should still be allowed even with a missing #[class(init)], but it would require an accompanying

#[godot_api]
impl MyClass {
    fn init(base: Base<RefCounted>) -> Self { ... }
}

This can be statically enforced: #[derive(GodotClass)] generates a function that requires GodotInit as a bound. In other words, such code without the impl block would not compile anymore.

Classes that are deliberately not default-constructible could be annotated with #[class(no_init)], or this could become an alternative like #[class(init=disabled)] / #[class(init=default)].

[MarkWilds]

Same issue here. but hot reloading is not working all the time even with init for me...

[MartinVacheron]

Same here too.

[MartinVacheron]

Same here too.

Adding reloadable = true in the "{lib-name}.gdextension" file solved the problem. Saw that on Discord msg.