added warning messages for when negative bitfields are encountered

Author: TCROC

godot-codegen/src/context.rs

@@ -28,6 +28,7 @@ pub struct Context<'a> {
     notification_enum_names_by_class: HashMap<TyName, NotificationEnum>,
     method_table_indices: HashMap<MethodTableKey, usize>,
     method_table_next_index: HashMap<String, usize>,
+    warnings: Vec<String>,
 }
 
 impl<'a> Context<'a> {
@@ -269,6 +270,14 @@ impl<'a> Context<'a> {
         let prev = self.cached_rust_types.insert(godot_ty, resolved);
         assert!(prev.is_none(), "no overwrites of RustTy");
     }
+
+    pub fn warnings(&self) -> &Vec<String> {
+        &self.warnings
+    }
+
+    pub fn warnings_mut(&mut self) -> &mut Vec<String> {
+        &mut self.warnings
+    }
 }
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------

godot-codegen/src/generator/builtins.rs

@@ -101,7 +101,7 @@ fn make_builtin_class(class: &BuiltinClass, ctx: &mut Context) -> GeneratedBuilt
     } = make_builtin_methods(class, &class.methods, ctx);
 
     let imports = util::make_imports();
-    let enums = enums::make_enums(&class.enums);
+    let enums = enums::make_enums(&class.enums, ctx);
     let special_constructors = make_special_builtin_methods(class.name(), ctx);
 
     // mod re_export needed, because class should not appear inside the file module, and we can't re-export private struct as pub

godot-codegen/src/generator/central_files.rs

@@ -108,7 +108,7 @@ pub fn make_core_central_code(api: &ExtensionApi, ctx: &mut Context) -> TokenStr
         ..
     } = make_variant_enums(api, ctx);
 
-    let global_enum_defs = make_global_enums(api);
+    let global_enum_defs = make_global_enums(api, ctx);
 
     // TODO impl Clone, Debug, PartialEq, PartialOrd, Hash for VariantDispatch
     // TODO could use try_to().unwrap_unchecked(), since type is already verified. Also directly overload from_variant().
@@ -256,7 +256,7 @@ fn make_variant_enums(api: &ExtensionApi, ctx: &mut Context) -> VariantEnums {
     result
 }
 
-fn make_global_enums(api: &ExtensionApi) -> Vec<TokenStream> {
+fn make_global_enums(api: &ExtensionApi, ctx: &mut Context) -> Vec<TokenStream> {
     let mut global_enum_defs = vec![];
 
     for enum_ in api.global_enums.iter() {
@@ -265,7 +265,7 @@ fn make_global_enums(api: &ExtensionApi) -> Vec<TokenStream> {
             continue;
         }
 
-        let def = enums::make_enum_definition(enum_);
+        let def = enums::make_enum_definition(enum_, ctx);
         global_enum_defs.push(def);
     }
 

godot-codegen/src/generator/classes.rs

@@ -98,7 +98,7 @@ fn make_class(class: &Class, ctx: &mut Context, view: &ApiView) -> GeneratedClas
         builders,
     } = make_class_methods(class, &class.methods, ctx);
 
-    let enums = enums::make_enums(&class.enums);
+    let enums = enums::make_enums(&class.enums, ctx);
     let constants = constants::make_constants(&class.constants);
     let inherits_macro = format_ident!("unsafe_inherits_transitive_{}", class_name.rust_ty);
     let deref_impl = make_deref_impl(class_name, &base_ty);

godot-codegen/src/generator/enums.rs

@@ -5,20 +5,21 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
+use crate::context::Context;
 use crate::models::domain::{Enum, Enumerator, EnumeratorValue};
 use crate::util;
 use proc_macro2::{Literal, TokenStream};
 use quote::quote;
 
-pub fn make_enums(enums: &[Enum]) -> TokenStream {
-    let definitions = enums.iter().map(make_enum_definition);
+pub fn make_enums(enums: &[Enum], ctx: &mut Context) -> TokenStream {
+    let definitions = enums.iter().map(|enum_| make_enum_definition(enum_, ctx));
 
     quote! {
         #( #definitions )*
     }
 }
 
-pub fn make_enum_definition(enum_: &Enum) -> TokenStream {
+pub fn make_enum_definition(enum_: &Enum, ctx: &mut Context) -> TokenStream {
     // TODO enums which have unique ords could be represented as Rust enums
     // This would allow exhaustive matches (or at least auto-completed matches + #[non_exhaustive]). But even without #[non_exhaustive],
     // this might be a forward compatibility hazard, if Godot deprecates enumerators and adds new ones with existing ords.
@@ -39,7 +40,7 @@ pub fn make_enum_definition(enum_: &Enum) -> TokenStream {
     let mut unique_ords = Vec::with_capacity(rust_enumerators.len());
 
     for enumerator in rust_enumerators.iter() {
-        let def = make_enumerator_definition(enumerator);
+        let def = make_enumerator_definition(enumerator, ctx);
         enumerators.push(def);
 
         if let EnumeratorValue::Enum(ord) = enumerator.value {
@@ -176,10 +177,20 @@ fn make_bitfield_flag_ord(ord: i64) -> Literal {
     Literal::i64_suffixed(ord)
 }
 
-fn make_enumerator_definition(enumerator: &Enumerator) -> TokenStream {
+fn make_enumerator_definition(enumerator: &Enumerator, ctx: &mut Context) -> TokenStream {
     let ordinal_lit = match enumerator.value {
         EnumeratorValue::Enum(ord) => make_enumerator_ord(ord),
-        EnumeratorValue::Bitfield(ord) => make_bitfield_flag_ord(ord),
+        EnumeratorValue::Bitfield(ord) => {
+            if ord < 0 {
+                ctx.warnings_mut().push(format!(
+                    "Encountered negative bitfield. {} = {}. This is currently being discussed in the following issues: https://github.com/godotengine/godot/issues/88962, https://github.com/CoaguCo-Industries/GodotSteam/issues/424", 
+                    enumerator.godot_name,
+                    ord
+                ))
+            }
+
+            make_bitfield_flag_ord(ord)
+        }
     };
 
     let rust_ident = &enumerator.name;

godot-codegen/src/generator/mod.rs

@@ -100,6 +100,7 @@ pub fn generate_core_mod_file(gen_path: &Path, submit_fn: &mut SubmitFn) {
         pub mod builtin_classes;
         pub mod utilities;
         pub mod native;
+        pub mod warn;
     };
 
     submit_fn(gen_path.join("mod.rs"), code);
@@ -115,3 +116,15 @@ pub fn generate_core_central_file(
 
     submit_fn(gen_path.join("central.rs"), core_code);
 }
+
+pub fn generate_core_warn_file(ctx: &mut Context, gen_path: &Path, submit_fn: &mut SubmitFn) {
+    // When invoked by another crate during unit-test (not integration test), don't run generator.
+
+    let warnings = ctx.warnings();
+
+    let code = quote! {
+        pub fn warnings() -> Vec<&'static str> { vec![#(#warnings),*] }
+    };
+
+    submit_fn(gen_path.join("warn.rs"), code);
+}

godot-codegen/src/lib.rs

@@ -25,9 +25,9 @@ use crate::generator::extension_interface::generate_sys_interface_file;
 use crate::generator::native_structures::generate_native_structures_files;
 use crate::generator::utility_functions::generate_utilities_file;
 use crate::generator::{
-    generate_core_central_file, generate_core_mod_file, generate_sys_builtin_lifecycle_file,
-    generate_sys_builtin_methods_file, generate_sys_central_file, generate_sys_classes_file,
-    generate_sys_utilities_file,
+    generate_core_central_file, generate_core_mod_file, generate_core_warn_file,
+    generate_sys_builtin_lifecycle_file, generate_sys_builtin_methods_file,
+    generate_sys_central_file, generate_sys_classes_file, generate_sys_utilities_file,
 };
 use crate::models::domain::{ApiView, ExtensionApi};
 use crate::models::json::{load_extension_api, JsonExtensionApi};
@@ -142,5 +142,8 @@ pub fn generate_core_files(core_gen_path: &Path) {
     );
     watch.record("generate_native_structures_files");
 
+    generate_core_warn_file(&mut ctx, core_gen_path, &mut submit_fn);
+    watch.record("generate_warn_file");
+
     watch.write_stats_to(&core_gen_path.join("codegen-stats.txt"));
 }

godot-core/src/init/mod.rs

@@ -10,7 +10,8 @@ use godot_ffi as sys;
 use sys::GodotFfi;
 
 use crate::builtin::{GString, StringName};
-use crate::out;
+use crate::gen::warn;
+use crate::{godot_warn, out};
 
 pub use sys::GdextBuild;
 
@@ -44,6 +45,12 @@ pub unsafe fn __gdext_load_library<E: ExtensionLibrary>(
 
         *init = godot_init_params;
 
+        if !E::ignore_codegen_warnings() {
+            for warning in warn::warnings() {
+                godot_warn!("{warning}");
+            }
+        }
+
         success as u8
     };
 
@@ -168,6 +175,8 @@ pub unsafe trait ExtensionLibrary {
     fn on_level_deinit(_level: InitLevel) {
         // Nothing by default.
     }
+
+    fn ignore_codegen_warnings() -> bool { false }
 }
 
 /// Determines if and how an extension's code is run in the editor.