Merge pull request #884 from godot-rust/qol/redundant-class-attrs

`#[class]` attribute: rename `hidden` -> `internal`, deprecate `editor_plugin`

Author: Bromeon

godot-core/src/deprecated.rs

@@ -41,6 +41,14 @@ pub use crate::emit_deprecated_warning;
 	More information on https://github.com/godot-rust/gdext/pull/844."]
 pub const fn init_default() {}
 
+#[deprecated = "\nThe attribute key #[class(editor_plugin)] is now implied by #[class(base = EditorPlugin)]. It is ignored.\n\
+	More information on https://github.com/godot-rust/gdext/pull/884."]
+pub const fn class_editor_plugin() {}
+
+#[deprecated = "\nThe attribute key #[class(hidden)] has been renamed to #[class(internal)], following Godot terminology.\n\
+    More information on https://github.com/godot-rust/gdext/pull/884."]
+pub const fn class_hidden() {}
+
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Godot-side deprecations
 

godot-core/src/registry/class.rs

@@ -229,7 +229,7 @@ fn fill_class_info(item: PluginItem, c: &mut ClassRegistrationInfo) {
             default_get_virtual_fn,
             is_tool,
             is_editor_plugin,
-            is_hidden,
+            is_internal,
             is_instantiable,
             #[cfg(all(since_api = "4.3", feature = "docs"))]
                 docs: _,
@@ -257,7 +257,7 @@ fn fill_class_info(item: PluginItem, c: &mut ClassRegistrationInfo) {
             .expect("duplicate: create_instance_func (def)");
 
             #[cfg(before_api = "4.2")]
-            let _ = is_hidden; // mark used
+            let _ = is_internal; // mark used
             #[cfg(since_api = "4.2")]
             {
                 fill_into(
@@ -266,7 +266,7 @@ fn fill_class_info(item: PluginItem, c: &mut ClassRegistrationInfo) {
                 )
                 .expect("duplicate: recreate_instance_func (def)");
 
-                c.godot_params.is_exposed = sys::conv::bool_to_sys(!is_hidden);
+                c.godot_params.is_exposed = sys::conv::bool_to_sys(!is_internal);
             }
 
             #[cfg(before_api = "4.2")]

godot-core/src/registry/plugin.rs

@@ -89,11 +89,11 @@ pub enum PluginItem {
         /// Whether `#[class(tool)]` was used.
         is_tool: bool,
 
-        /// Whether `#[class(editor_plugin)]` was used.
+        /// Whether the base class is an `EditorPlugin`.
         is_editor_plugin: bool,
 
-        /// Whether `#[class(hidden)]` was used.
-        is_hidden: bool,
+        /// Whether `#[class(internal)]` was used.
+        is_internal: bool,
 
         /// Whether the class has a default constructor.
         is_instantiable: bool,

godot-macros/src/class/derive_godot_class.rs

@@ -21,8 +21,12 @@ pub fn derive_godot_class(item: venial::Item) -> ParseResult<TokenStream> {
         .ok_or_else(|| venial::Error::new("Not a valid struct"))?;
 
     let named_fields = named_fields(class)?;
-    let struct_cfg = parse_struct_attributes(class)?;
-    let fields = parse_fields(named_fields, struct_cfg.init_strategy)?;
+    let mut struct_cfg = parse_struct_attributes(class)?;
+    let mut fields = parse_fields(named_fields, struct_cfg.init_strategy)?;
+    let is_editor_plugin = struct_cfg.is_editor_plugin();
+
+    let mut deprecations = std::mem::take(&mut struct_cfg.deprecations);
+    deprecations.append(&mut fields.deprecations);
 
     let class_name = &class.name;
     let class_name_str: String = struct_cfg
@@ -33,8 +37,7 @@ pub fn derive_godot_class(item: venial::Item) -> ParseResult<TokenStream> {
     let class_name_cstr = util::c_str(&class_name_str);
     let class_name_obj = util::class_name_obj(class_name);
 
-    let is_editor_plugin = struct_cfg.is_editor_plugin;
-    let is_hidden = struct_cfg.is_hidden;
+    let is_internal = struct_cfg.is_internal;
     let base_ty = &struct_cfg.base_ty;
     #[cfg(all(feature = "docs", since_api = "4.3"))]
     let docs = crate::docs::make_definition_docs(
@@ -75,7 +78,6 @@ pub fn derive_godot_class(item: venial::Item) -> ParseResult<TokenStream> {
     let mut create_fn = quote! { None };
     let mut recreate_fn = quote! { None };
     let mut is_instantiable = true;
-    let deprecations = &fields.deprecations;
 
     match struct_cfg.init_strategy {
         InitStrategy::Generated => {
@@ -153,7 +155,7 @@ pub fn derive_godot_class(item: venial::Item) -> ParseResult<TokenStream> {
                 default_get_virtual_fn: #default_get_virtual_fn,
                 is_tool: #is_tool,
                 is_editor_plugin: #is_editor_plugin,
-                is_hidden: #is_hidden,
+                is_internal: #is_internal,
                 is_instantiable: #is_instantiable,
                 #docs
             },
@@ -201,9 +203,15 @@ struct ClassAttributes {
     base_ty: Ident,
     init_strategy: InitStrategy,
     is_tool: bool,
-    is_editor_plugin: bool,
-    is_hidden: bool,
+    is_internal: bool,
     rename: Option<Ident>,
+    deprecations: Vec<TokenStream>,
+}
+
+impl ClassAttributes {
+    fn is_editor_plugin(&self) -> bool {
+        self.base_ty == ident("EditorPlugin")
+    }
 }
 
 fn make_godot_init_impl(class_name: &Ident, fields: &Fields) -> TokenStream {
@@ -310,9 +318,9 @@ fn parse_struct_attributes(class: &venial::Struct) -> ParseResult<ClassAttribute
     let mut base_ty = ident("RefCounted");
     let mut init_strategy = InitStrategy::UserDefined;
     let mut is_tool = false;
-    let mut is_editor_plugin = false;
-    let mut is_hidden = false;
+    let mut is_internal = false;
     let mut rename: Option<Ident> = None;
+    let mut deprecations = vec![];
 
     // #[class] attribute on struct
     if let Some(mut parser) = KvParser::parse(&class.attributes, "class")? {
@@ -333,50 +341,45 @@ fn parse_struct_attributes(class: &venial::Struct) -> ParseResult<ClassAttribute
             is_tool = true;
         }
 
-        // #[class(editor_plugin)]
-        if let Some(attr_key) = parser.handle_alone_with_span("editor_plugin")? {
-            is_editor_plugin = true;
-
-            // Requires #[class(tool, base=EditorPlugin)].
-            // The base=EditorPlugin check should come first to create the best compile errors since it's more complex to resolve.
-            // See https://github.com/godot-rust/gdext/pull/773
-            if base_ty != ident("EditorPlugin") {
-                return bail!(
-                    attr_key,
-                    "#[class(editor_plugin)] requires additional key-value `base=EditorPlugin`"
-                );
-            }
-            if !is_tool {
-                return bail!(
-                    attr_key,
-                    "#[class(editor_plugin)] requires additional key `tool`"
-                );
-            }
+        // Deprecated #[class(editor_plugin)]
+        if let Some(_attr_key) = parser.handle_alone_with_span("editor_plugin")? {
+            deprecations.push(quote! {
+                ::godot::__deprecated::emit_deprecated_warning!(class_editor_plugin);
+            });
         }
 
         // #[class(rename = NewName)]
         rename = parser.handle_ident("rename")?;
 
-        // #[class(hidden)]
-        // TODO consider naming this "internal"; godot-cpp uses that terminology:
-        // https://github.com/godotengine/godot-cpp/blob/master/include/godot_cpp/core/class_db.hpp#L327
+        // #[class(internal)]
+        // Named "internal" following Godot terminology: https://github.com/godotengine/godot-cpp/blob/master/include/godot_cpp/core/class_db.hpp#L327
+        if let Some(span) = parser.handle_alone_with_span("internal")? {
+            require_api_version!("4.2", span, "#[class(internal)]")?;
+            is_internal = true;
+        }
+
+        // Deprecated #[class(hidden)]
         if let Some(span) = parser.handle_alone_with_span("hidden")? {
             require_api_version!("4.2", span, "#[class(hidden)]")?;
-            is_hidden = true;
+            is_internal = true;
+
+            deprecations.push(quote! {
+                ::godot::__deprecated::emit_deprecated_warning!(class_hidden);
+            });
         }
 
         parser.finish()?;
     }
 
-    post_validate(&base_ty, is_tool, is_editor_plugin)?;
+    post_validate(&base_ty, is_tool)?;
 
     Ok(ClassAttributes {
         base_ty,
         init_strategy,
         is_tool,
-        is_editor_plugin,
-        is_hidden,
+        is_internal,
         rename,
+        deprecations,
     })
 }
 
@@ -561,7 +564,7 @@ fn handle_opposite_keys(
 }
 
 /// Checks more logical combinations of attributes.
-fn post_validate(base_ty: &Ident, is_tool: bool, is_editor_plugin: bool) -> ParseResult<()> {
+fn post_validate(base_ty: &Ident, is_tool: bool) -> ParseResult<()> {
     // TODO: this should be delegated to either:
     // a) the type system: have a trait IsTool which is implemented when #[class(tool)] is set.
     //    Then, for certain base classes, require a tool bound (e.g. generate method `fn type_check<T: IsTool>()`).
@@ -579,12 +582,6 @@ fn post_validate(base_ty: &Ident, is_tool: bool, is_editor_plugin: bool) -> Pars
             "Base class `{}` is a virtual extension class, which runs in the editor and thus requires #[class(tool)].",
             base_ty
         );
-    } else if class_name == "EditorPlugin" && !is_editor_plugin {
-        return bail!(
-            base_ty,
-            "Classes extending `{}` require #[class(editor_plugin)] to get registered as a plugin in the editor. See: https://godot-rust.github.io/book/recipes/editor-plugin/index.html", 
-            base_ty
-        );
     } else if is_class_editor && !is_tool {
         return bail!(
             base_ty,

godot-macros/src/lib.rs

@@ -400,12 +400,12 @@ use crate::util::ident;
 ///
 /// ## Class hiding
 ///
-/// If you want to register a class with Godot, but not have it show up in the editor then you can use `#[class(hidden)]`.
+/// If you want to register a class with Godot, but not have it show up in the editor then you can use `#[class(internal)]`.
 ///
 /// ```
 /// # use godot::prelude::*;
 /// #[derive(GodotClass)]
-/// #[class(base=Node, init, hidden)]
+/// #[class(base=Node, init, internal)]
 /// pub struct Foo {}
 /// ```
 ///

itest/rust/src/object_tests/virtual_methods_test.rs

@@ -779,7 +779,7 @@ impl GetSetTest {
 // There isn't a good way to test editor plugins, but we can at least declare one to ensure that the macro
 // compiles.
 #[derive(GodotClass)]
-#[class(no_init, base = EditorPlugin, editor_plugin, tool)]
+#[class(no_init, base = EditorPlugin, tool)]
 struct CustomEditorPlugin;
 
 // Just override EditorPlugin::edit() to verify method is declared with Option<T>.