Refactor #[init(...)] shared code

Author: Bromeon

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

@@ -6,9 +6,9 @@
  */
 
 use crate::class::{FieldExport, FieldVar};
-use crate::util::error;
+use crate::util::{error, KvParser};
 use proc_macro2::{Ident, Span, TokenStream};
-use quote::ToTokens;
+use quote::{quote, ToTokens};
 
 pub struct Field {
     pub name: Ident,
@@ -39,10 +39,37 @@ impl Field {
         }
     }
 
-    #[must_use]
-    pub fn ensure_preconditions(
+    /// For a previously performed check, either pastes the generated code, or a syntactically valid fallback.
+    ///
+    /// In case of incorrect proc-macro usage, it's nice if the resulting generated code is still syntactically valid, to not trip over
+    /// IDEs and static analysis tools. So, in case of errors, a syntactically valid placeholder is generated.
+    pub fn set_default_val_if(
+        &mut self,
+        default_expr: impl FnOnce() -> TokenStream,
+        precondition: FieldCond,
+        parser: &KvParser,
+        errors: &mut Vec<venial::Error>,
+    ) {
+        debug_assert!(
+            self.default_val.is_none(),
+            "default already set; check precondition"
+        );
+
+        let span = parser.span();
+        let is_well_formed = self.ensure_preconditions(precondition, span, errors);
+
+        let default_val = if is_well_formed {
+            default_expr()
+        } else {
+            quote! { todo!() }
+        };
+
+        self.default_val = Some(FieldDefault { default_val, span });
+    }
+
+    fn ensure_preconditions(
         &self,
-        cond: Option<FieldCond>,
+        cond: FieldCond,
         span: Span,
         errors: &mut Vec<venial::Error>,
     ) -> bool {
@@ -56,14 +83,14 @@ impl Field {
         }
 
         match cond {
-            Some(FieldCond::IsOnReady) if !self.is_onready => {
+            FieldCond::IsOnReady if !self.is_onready => {
                 errors.push(error!(
                     span,
                     "used #[init(…)] pattern requires field type `OnReady<T>`"
                 ));
             }
 
-            Some(FieldCond::IsOnEditor) if !self.is_oneditor => {
+            FieldCond::IsOnEditor if !self.is_oneditor => {
                 errors.push(error!(
                     span,
                     "used #[init(…)] pattern requires field type `OnEditor<T>`"
@@ -78,6 +105,7 @@ impl Field {
 }
 
 pub enum FieldCond {
+    // None, - enable once needed.
     IsOnReady,
     IsOnEditor,
 }

godot-macros/src/class/derive_godot_class.rs

@@ -557,62 +557,32 @@ fn parse_fields(
 
             // #[init(node = "PATH")]
             if let Some(node_path) = parser.handle_expr("node")? {
-                let is_well_formed = field.ensure_preconditions(
-                    Some(FieldCond::IsOnReady),
-                    parser.span(),
+                field.set_default_val_if(
+                    || quote! { OnReady::from_node(#node_path) },
+                    FieldCond::IsOnReady,
+                    &parser,
                     &mut errors,
                 );
-
-                let default_val = if is_well_formed {
-                    quote! { OnReady::from_node(#node_path) }
-                } else {
-                    quote! { todo!() }
-                };
-
-                field.default_val = Some(FieldDefault {
-                    default_val,
-                    span: parser.span(),
-                });
             }
 
             // #[init(load = "PATH")]
             if let Some(resource_path) = parser.handle_expr("load")? {
-                let is_well_formed = field.ensure_preconditions(
-                    Some(FieldCond::IsOnReady),
-                    parser.span(),
+                field.set_default_val_if(
+                    || quote! { OnReady::from_loaded(#resource_path) },
+                    FieldCond::IsOnReady,
+                    &parser,
                     &mut errors,
                 );
-
-                let default_val = if is_well_formed {
-                    quote! { OnReady::from_loaded(#resource_path) }
-                } else {
-                    quote! { todo!() }
-                };
-
-                field.default_val = Some(FieldDefault {
-                    default_val,
-                    span: parser.span(),
-                });
             }
 
             // #[init(sentinel = EXPR)]
             if let Some(sentinel_value) = parser.handle_expr("sentinel")? {
-                let is_well_formed = field.ensure_preconditions(
-                    Some(FieldCond::IsOnEditor),
-                    parser.span(),
+                field.set_default_val_if(
+                    || quote! { OnEditor::from_sentinel(#sentinel_value) },
+                    FieldCond::IsOnEditor,
+                    &parser,
                     &mut errors,
                 );
-
-                let default_val = if is_well_formed {
-                    quote! { OnEditor::from_sentinel(#sentinel_value) }
-                } else {
-                    quote! { todo!() }
-                };
-
-                field.default_val = Some(FieldDefault {
-                    default_val,
-                    span: parser.span(),
-                });
             }
 
             parser.finish()?;