Deprecate #[class(editor_plugin)]; implied by #[class(base=EditorPlugin)]

Author: Bromeon

godot-core/src/deprecated.rs

@@ -41,6 +41,10 @@ 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 editor_plugin() {}
+
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Godot-side deprecations
 

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.extend(fields.deprecations.drain(..));
 
     let class_name = &class.name;
     let class_name_str: String = struct_cfg
@@ -33,7 +37,6 @@ 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 base_ty = &struct_cfg.base_ty;
     #[cfg(all(feature = "docs", since_api = "4.3"))]
@@ -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 => {
@@ -201,9 +203,15 @@ struct ClassAttributes {
     base_ty: Ident,
     init_strategy: InitStrategy,
     is_tool: bool,
-    is_editor_plugin: bool,
     is_hidden: 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 rename: Option<Ident> = None;
+    let mut deprecations = vec![];
 
     // #[class] attribute on struct
     if let Some(mut parser) = KvParser::parse(&class.attributes, "class")? {
@@ -334,24 +342,10 @@ fn parse_struct_attributes(class: &venial::Struct) -> ParseResult<ClassAttribute
         }
 
         // #[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`"
-                );
-            }
+        if let Some(_attr_key) = parser.handle_alone_with_span("editor_plugin")? {
+            deprecations.push(quote! {
+                ::godot::__deprecated::emit_deprecated_warning!(editor_plugin);
+            });
         }
 
         // #[class(rename = NewName)]
@@ -368,15 +362,15 @@ fn parse_struct_attributes(class: &venial::Struct) -> ParseResult<ClassAttribute
         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,
         rename,
+        deprecations,
     })
 }
 
@@ -561,7 +555,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 +573,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,

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>.