Merge pull request #732 from godot-rust/qol/streamlined-modules-2

Streamline modules - part II: `godot::extra`, notifications

Author: Bromeon

godot-codegen/src/conv/name_conversions.rs

@@ -77,6 +77,7 @@ pub fn to_pascal_case(ty_name: &str) -> String {
         .replace("Sdfgiy", "SdfgiY")
 }
 
+#[allow(dead_code)] // Keep around in case we need it later.
 pub fn shout_to_pascal(shout_case: &str) -> String {
     // TODO use heck?
 

godot-codegen/src/conv/type_conversions.rs

@@ -172,7 +172,7 @@ fn to_rust_type_uncached(full_ty: &GodotTy, ctx: &mut Context) -> RustTy {
             let bitfield_ty = conv::make_enum_name(bitfield);
 
             RustTy::EngineBitfield {
-                tokens: quote! { crate::engine::global::#bitfield_ty },
+                tokens: quote! { crate::global::#bitfield_ty },
                 surrounding_class: None,
             }
         };
@@ -193,7 +193,7 @@ fn to_rust_type_uncached(full_ty: &GodotTy, ctx: &mut Context) -> RustTy {
             let enum_ty = conv::make_enum_name(qualified_enum);
 
             RustTy::EngineEnum {
-                tokens: quote! { crate::engine::global::#enum_ty },
+                tokens: quote! { crate::global::#enum_ty },
                 surrounding_class: None,
             }
         };

godot-codegen/src/generator/notifications.rs

@@ -8,9 +8,9 @@
 use crate::context::Context;
 use crate::models::domain::TyName;
 use crate::models::json::JsonClassConstant;
-use crate::{conv, util};
+use crate::util;
 use proc_macro2::{Ident, TokenStream};
-use quote::{format_ident, quote};
+use quote::quote;
 
 pub fn make_notify_methods(class_name: &TyName, ctx: &mut Context) -> TokenStream {
     // Note: there are two more methods, but only from Node downwards, not from Object:
@@ -85,10 +85,10 @@ pub fn make_notification_enum(
         c = class_name.rust_ty
     );
 
-    let mut notification_enumerators_pascal = Vec::new();
+    let mut notification_enumerators_shout = Vec::new();
     let mut notification_enumerators_ord = Vec::new();
     for (constant_ident, constant_value) in all_constants {
-        notification_enumerators_pascal.push(constant_ident);
+        notification_enumerators_shout.push(constant_ident);
         notification_enumerators_ord.push(constant_value);
     }
 
@@ -97,16 +97,22 @@ pub fn make_notification_enum(
         ///
         /// Makes it easier to keep an overview all possible notification variants for a given class, including
         /// notifications defined in base classes.
+        ///
+        /// Contains the [`Unknown`][Self::Unknown] variant for forward compatibility.
         #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
         #[repr(i32)]
+        #[allow(non_camel_case_types)]
         #cfg_attributes
         pub enum #enum_name {
             #(
-                #notification_enumerators_pascal = #notification_enumerators_ord,
+                #notification_enumerators_shout = #notification_enumerators_ord,
             )*
 
             /// Since Godot represents notifications as integers, it's always possible that a notification outside the known types
             /// is received. For example, the user can manually issue notifications through `Object::notify()`.
+            ///
+            /// This is also necessary if you develop an extension on a Godot version and want to be forward-compatible with newer
+            /// versions. If Godot adds new notifications, they will be unknown to your extension, but you can still handle them.
             Unknown(i32),
         }
 
@@ -115,7 +121,7 @@ pub fn make_notification_enum(
             fn from(enumerator: i32) -> Self {
                 match enumerator {
                     #(
-                        #notification_enumerators_ord => Self::#notification_enumerators_pascal,
+                        #notification_enumerators_ord => Self::#notification_enumerators_shout,
                     )*
                     other_int => Self::Unknown(other_int),
                 }
@@ -126,7 +132,7 @@ pub fn make_notification_enum(
             fn from(notification: #enum_name) -> i32 {
                 match notification {
                     #(
-                        #enum_name::#notification_enumerators_pascal => #notification_enumerators_ord,
+                        #enum_name::#notification_enumerators_shout => #notification_enumerators_ord,
                     )*
                     #enum_name::Unknown(int) => int,
                 }
@@ -139,27 +145,20 @@ pub fn make_notification_enum(
 
 /// Tries to interpret the constant as a notification one, and transforms it to a Rust identifier on success.
 pub fn try_to_notification(constant: &JsonClassConstant) -> Option<Ident> {
-    constant
-        .name
-        .strip_prefix("NOTIFICATION_")
-        .map(|s| util::ident(&conv::shout_to_pascal(s)))
+    constant.name.strip_prefix("NOTIFICATION_").map(util::ident) // used to be conv::shout_to_pascal(s)
 }
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Implementation
 
-/// Workaround for Godot bug https://github.com/godotengine/godot/issues/75839
+/// Workaround for Godot bug https://github.com/godotengine/godot/issues/75839, fixed in 4.2.
 ///
 /// Godot has a collision for two notification constants (DRAW, NODE_CACHE_REQUESTED) in the same inheritance branch (as of 4.0.2).
 /// This cannot be represented in a Rust enum, so we merge the two constants into a single enumerator.
 fn workaround_constant_collision(all_constants: &mut Vec<(Ident, i32)>) {
-    for first in ["Draw", "VisibilityChanged"] {
-        if let Some(index_of_draw) = all_constants
-            .iter()
-            .position(|(constant_name, _)| constant_name == first)
-        {
-            all_constants[index_of_draw].0 = format_ident!("{first}OrNodeRecacheRequested");
-            all_constants.retain(|(constant_name, _)| constant_name != "NodeRecacheRequested");
-        }
-    }
+    // This constant has never been used by the engine.
+    #[cfg(before_api = "4.2")]
+    all_constants.retain(|(constant_name, _)| constant_name != "NODE_RECACHE_REQUESTED");
+
+    let _ = &all_constants; // unused warning
 }

godot-core/src/builtin/array.rs

@@ -870,7 +870,7 @@ impl<T: ArrayElement> Var for Array<T> {
         }
 
         PropertyHintInfo {
-            hint: crate::engine::global::PropertyHint::ARRAY_TYPE,
+            hint: crate::global::PropertyHint::ARRAY_TYPE,
             hint_string: T::godot_type_name().into(),
         }
     }
@@ -879,7 +879,7 @@ impl<T: ArrayElement> Var for Array<T> {
 impl<T: ArrayElement + TypeStringHint> Export for Array<T> {
     fn default_export_info() -> PropertyHintInfo {
         PropertyHintInfo {
-            hint: crate::engine::global::PropertyHint::TYPE_STRING,
+            hint: crate::global::PropertyHint::TYPE_STRING,
             hint_string: T::type_string().into(),
         }
     }

godot-core/src/builtin/basis.rs

@@ -10,9 +10,7 @@ use sys::{ffi_methods, GodotFfi};
 
 use crate::builtin::math::{ApproxEq, FloatExt, GlamConv, GlamType};
 use crate::builtin::real_consts::FRAC_PI_2;
-use crate::builtin::{real, Quaternion, RMat3, RQuat, RVec2, RVec3, Vector3};
-
-use crate::engine::global::EulerOrder;
+use crate::builtin::{real, EulerOrder, Quaternion, RMat3, RQuat, RVec2, RVec3, Vector3};
 use std::cmp::Ordering;
 use std::fmt::Display;
 use std::ops::{Mul, MulAssign};

godot-core/src/builtin/meta/registration/method.rs

@@ -10,7 +10,7 @@ use sys::interface_fn;
 
 use crate::builtin::meta::{ClassName, PropertyInfo, VarcallSignatureTuple};
 use crate::builtin::{StringName, Variant};
-use crate::engine::global::MethodFlags;
+use crate::global::MethodFlags;
 
 /// Info relating to an argument or return type in a method.
 pub struct MethodParamOrReturnInfo {

godot-core/src/builtin/packed_array.rs

@@ -514,7 +514,7 @@ macro_rules! impl_packed_array {
                 // In 4.3 Godot can (and does) use type hint strings for packed arrays, see https://github.com/godotengine/godot/pull/82952.
                 if sys::GdextBuild::since_api("4.3") {
                     $crate::property::PropertyHintInfo {
-                        hint: $crate::engine::global::PropertyHint::TYPE_STRING,
+                        hint: $crate::global::PropertyHint::TYPE_STRING,
                         hint_string: <$Element as $crate::property::TypeStringHint>::type_string().into(),
                     }
                 } else {

godot-core/src/builtin/quaternion.rs

@@ -9,9 +9,7 @@ use godot_ffi as sys;
 use sys::{ffi_methods, GodotFfi};
 
 use crate::builtin::math::{ApproxEq, FloatExt, GlamConv, GlamType};
-use crate::builtin::{inner, real, Basis, RQuat, RealConv, Vector3};
-
-use crate::engine::global::EulerOrder;
+use crate::builtin::{inner, real, Basis, EulerOrder, RQuat, RealConv, Vector3};
 use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
 
 use super::meta::impl_godot_as_self;

godot-core/src/builtin/rect2.rs

@@ -9,8 +9,7 @@ use godot_ffi as sys;
 use sys::{ffi_methods, GodotFfi};
 
 use crate::builtin::math::ApproxEq;
-use crate::builtin::{real, Rect2i, Vector2};
-use crate::engine::global::Side;
+use crate::builtin::{real, Rect2i, Side, Vector2};
 
 use super::meta::impl_godot_as_self;
 

godot-core/src/builtin/rect2i.rs

@@ -7,12 +7,11 @@
 
 use std::cmp;
 
-use crate::engine::global::Side;
+use crate::builtin::meta::impl_godot_as_self;
+use crate::builtin::{Rect2, Side, Vector2i};
 use godot_ffi as sys;
 use sys::{ffi_methods, GodotFfi};
 
-use super::{meta::impl_godot_as_self, Rect2, Vector2i};
-
 /// 2D axis-aligned integer bounding box.
 ///
 /// `Rect2i` consists of a position, a size, and several utility functions. It is typically used for