Update all use sites to new SHOUT_CASE convention

Author: Bromeon

godot-codegen/src/generator/central_files.rs

@@ -54,6 +54,7 @@ pub fn make_sys_central_code(api: &ExtensionApi) -> TokenStream {
 pub fn make_core_central_code(api: &ExtensionApi, ctx: &mut Context) -> TokenStream {
     let VariantEnums {
         variant_ty_enumerators_pascal,
+        variant_ty_enumerators_shout,
         variant_ty_enumerators_rust,
         ..
     } = make_variant_enums(api, ctx);
@@ -83,9 +84,9 @@ pub fn make_core_central_code(api: &ExtensionApi, ctx: &mut Context) -> TokenStr
         impl VariantDispatch {
             pub fn from_variant(variant: &Variant) -> Self {
                 match variant.get_type() {
-                    VariantType::Nil => Self::Nil,
+                    VariantType::NIL => Self::Nil,
                     #(
-                        VariantType::#variant_ty_enumerators_pascal
+                        VariantType::#variant_ty_enumerators_shout
                             => Self::#variant_ty_enumerators_pascal(variant.to::<#variant_ty_enumerators_rust>()),
                     )*
 
@@ -124,6 +125,7 @@ pub fn make_core_central_code(api: &ExtensionApi, ctx: &mut Context) -> TokenStr
 
 struct VariantEnums {
     variant_ty_enumerators_pascal: Vec<Ident>,
+    variant_ty_enumerators_shout: Vec<Ident>,
     variant_ty_enumerators_rust: Vec<TokenStream>,
 }
 
@@ -158,18 +160,21 @@ fn make_variant_enums(api: &ExtensionApi, ctx: &mut Context) -> VariantEnums {
 
     let mut result = VariantEnums {
         variant_ty_enumerators_pascal: Vec::with_capacity(len),
+        variant_ty_enumerators_shout: Vec::with_capacity(len),
         variant_ty_enumerators_rust: Vec::with_capacity(len),
     };
 
     // Note: NIL is not part of this iteration, it will be added manually.
     for builtin in api.builtins.iter() {
         let original_name = builtin.godot_original_name();
+        let shout_case = builtin.godot_shout_name();
         let rust_ty = conv::to_rust_type(original_name, None, ctx);
         let pascal_case = conv::to_pascal_case(original_name);
 
         result
             .variant_ty_enumerators_pascal
             .push(ident(&pascal_case));
+        result.variant_ty_enumerators_shout.push(ident(shout_case));
         result
             .variant_ty_enumerators_rust
             .push(rust_ty.to_token_stream());

godot-core/src/builtin/aabb.rs

@@ -400,7 +400,7 @@ impl std::fmt::Display for Aabb {
 // This type is represented as `Self` in Godot, so `*mut Self` is sound.
 unsafe impl GodotFfi for Aabb {
     fn variant_type() -> sys::VariantType {
-        sys::VariantType::Aabb
+        sys::VariantType::AABB
     }
 
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }

godot-core/src/builtin/array.rs

@@ -865,7 +865,7 @@ impl<T: ArrayElement> Var for Array<T> {
 
     #[cfg(since_api = "4.2")]
     fn property_hint() -> PropertyHintInfo {
-        if T::Ffi::variant_type() == VariantType::Nil {
+        if T::Ffi::variant_type() == VariantType::NIL {
             return PropertyHintInfo::with_hint_none("");
         }
 
@@ -1196,7 +1196,7 @@ impl TypeInfo {
     }
 
     pub fn is_typed(&self) -> bool {
-        self.variant_type != VariantType::Nil
+        self.variant_type != VariantType::NIL
     }
 
     pub fn variant_type(&self) -> VariantType {

godot-core/src/builtin/basis.rs

@@ -598,7 +598,7 @@ impl Mul<Vector3> for Basis {
 // This type is represented as `Self` in Godot, so `*mut Self` is sound.
 unsafe impl GodotFfi for Basis {
     fn variant_type() -> sys::VariantType {
-        sys::VariantType::Basis
+        sys::VariantType::BASIS
     }
 
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }

godot-core/src/builtin/callable.rs

@@ -291,7 +291,7 @@ impl_builtin_traits! {
 // beyond what is done in `from_opaque` and `drop`. So using `*mut Opaque` is safe.
 unsafe impl GodotFfi for Callable {
     fn variant_type() -> sys::VariantType {
-        sys::VariantType::Callable
+        sys::VariantType::CALLABLE
     }
 
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Opaque;

godot-core/src/builtin/color.rs

@@ -350,7 +350,7 @@ impl Color {
 // This type is represented as `Self` in Godot, so `*mut Self` is sound.
 unsafe impl GodotFfi for Color {
     fn variant_type() -> sys::VariantType {
-        sys::VariantType::Color
+        sys::VariantType::COLOR
     }
 
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }

godot-core/src/builtin/dictionary.rs

@@ -288,7 +288,7 @@ impl Dictionary {
 //   `std::mem::forget(dictionary.clone())`.
 unsafe impl GodotFfi for Dictionary {
     fn variant_type() -> sys::VariantType {
-        sys::VariantType::Dictionary
+        sys::VariantType::DICTIONARY
     }
 
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Opaque; .. }

godot-core/src/builtin/meta/mod.rs

@@ -156,9 +156,9 @@ pub trait GodotType:
             variant_type: Self::Ffi::variant_type(),
             class_name: Self::class_name(),
             property_name: StringName::from(property_name),
-            hint: global::PropertyHint::NONE,
+            hint: PropertyHint::NONE,
             hint_string: GString::new(),
-            usage: global::PropertyUsageFlags::DEFAULT,
+            usage: PropertyUsageFlags::DEFAULT,
         }
     }
 
@@ -272,9 +272,9 @@ pub trait ArrayElement: GodotType {}
 pub struct PropertyInfo {
     /// Which type this property has.
     ///
-    /// For objects this should be set to [`VariantType::Object`], and the `class_name` field to the actual name of the class.
+    /// For objects this should be set to [`VariantType::OBJECT`], and the `class_name` field to the actual name of the class.
     ///
-    /// For [`Variant`] this should be set to [`VariantType::Nil`].
+    /// For [`Variant`] this should be set to [`VariantType::NIL`].
     pub variant_type: VariantType,
 
     /// Which class this property is.
@@ -289,15 +289,15 @@ pub struct PropertyInfo {
     /// How the property is meant to be edited. See also [`PropertyHint`] in the Godot docs.
     ///
     /// [`PropertyHint`]: https://docs.godotengine.org/en/latest/classes/class_%40globalscope.html#enum-globalscope-propertyhint
-    pub hint: global::PropertyHint,
+    pub hint: PropertyHint,
 
     /// Extra information passed to Godot for this property, what this means depends on the `hint` value.
     pub hint_string: GString,
 
     /// How this property should be used. See [`PropertyUsageFlags`] in Godot for the meaning.
     ///
     /// [`PropertyUsageFlags`]: https://docs.godotengine.org/en/latest/classes/class_%40globalscope.html#enum-globalscope-propertyusageflags
-    pub usage: global::PropertyUsageFlags,
+    pub usage: PropertyUsageFlags,
 }
 
 impl PropertyInfo {
@@ -359,7 +359,7 @@ impl PropertyInfo {
     /// more information.
     pub fn new_group(group_name: &str, group_prefix: &str) -> Self {
         Self {
-            variant_type: VariantType::Nil,
+            variant_type: VariantType::NIL,
             class_name: ClassName::none(),
             property_name: group_name.into(),
             hint: PropertyHint::NONE,
@@ -374,7 +374,7 @@ impl PropertyInfo {
     /// more information.
     pub fn new_subgroup(subgroup_name: &str, subgroup_prefix: &str) -> Self {
         Self {
-            variant_type: VariantType::Nil,
+            variant_type: VariantType::NIL,
             class_name: ClassName::none(),
             property_name: subgroup_name.into(),
             hint: PropertyHint::NONE,
@@ -403,12 +403,12 @@ impl PropertyInfo {
         use crate::obj::EngineEnum as _;
 
         sys::GDExtensionPropertyInfo {
-            type_: VariantType::Nil.sys(),
+            type_: VariantType::NIL.sys(),
             name: std::ptr::null_mut(),
             class_name: std::ptr::null_mut(),
-            hint: global::PropertyHint::NONE.ord() as u32,
+            hint: PropertyHint::NONE.ord() as u32,
             hint_string: std::ptr::null_mut(),
-            usage: global::PropertyUsageFlags::NONE.ord() as u32,
+            usage: PropertyUsageFlags::NONE.ord() as u32,
         }
     }
 

godot-core/src/builtin/packed_array.rs

@@ -26,6 +26,8 @@ macro_rules! impl_packed_array {
     (
         // Name of the type to define, e.g. `PackedByteArray`.
         type_name: $PackedArray:ident,
+        // Name of the VariantType constant, e.g. `PACKED_BYTE_ARRAY`.
+        variant_type: $VariantType:ident,
         // Type of elements contained in the array, e.g. `u8`.
         element_type: $Element:ty,
         // Name of wrapped opaque type, e.g. `OpaquePackedByteArray`.
@@ -499,7 +501,7 @@ macro_rules! impl_packed_array {
 
         unsafe impl GodotFfi for $PackedArray {
             fn variant_type() -> sys::VariantType {
-                sys::VariantType::$PackedArray
+                sys::VariantType::$VariantType
             }
 
             ffi_methods! { type sys::GDExtensionTypePtr = *mut Opaque; .. }
@@ -574,6 +576,7 @@ macro_rules! impl_specific_packed_array_functions {
 
 impl_packed_array!(
     type_name: PackedByteArray,
+    variant_type: PACKED_BYTE_ARRAY,
     element_type: u8,
     opaque_type: OpaquePackedByteArray,
     inner_type: InnerPackedByteArray,
@@ -592,6 +595,7 @@ impl_packed_array!(
 
 impl_packed_array!(
     type_name: PackedInt32Array,
+    variant_type: PACKED_INT32_ARRAY,
     element_type: i32,
     opaque_type: OpaquePackedInt32Array,
     inner_type: InnerPackedInt32Array,
@@ -610,6 +614,7 @@ impl_packed_array!(
 
 impl_packed_array!(
     type_name: PackedInt64Array,
+    variant_type: PACKED_INT64_ARRAY,
     element_type: i64,
     opaque_type: OpaquePackedInt64Array,
     inner_type: InnerPackedInt64Array,
@@ -628,6 +633,7 @@ impl_packed_array!(
 
 impl_packed_array!(
     type_name: PackedFloat32Array,
+    variant_type: PACKED_FLOAT32_ARRAY,
     element_type: f32,
     opaque_type: OpaquePackedFloat32Array,
     inner_type: InnerPackedFloat32Array,
@@ -646,6 +652,7 @@ impl_packed_array!(
 
 impl_packed_array!(
     type_name: PackedFloat64Array,
+    variant_type: PACKED_FLOAT64_ARRAY,
     element_type: f64,
     opaque_type: OpaquePackedFloat64Array,
     inner_type: InnerPackedFloat64Array,
@@ -664,6 +671,7 @@ impl_packed_array!(
 
 impl_packed_array!(
     type_name: PackedStringArray,
+    variant_type: PACKED_STRING_ARRAY,
     element_type: GString,
     opaque_type: OpaquePackedStringArray,
     inner_type: InnerPackedStringArray,
@@ -682,6 +690,7 @@ impl_packed_array!(
 
 impl_packed_array!(
     type_name: PackedVector2Array,
+    variant_type: PACKED_VECTOR2_ARRAY,
     element_type: Vector2,
     opaque_type: OpaquePackedVector2Array,
     inner_type: InnerPackedVector2Array,
@@ -700,6 +709,7 @@ impl_packed_array!(
 
 impl_packed_array!(
     type_name: PackedVector3Array,
+    variant_type: PACKED_VECTOR3_ARRAY,
     element_type: Vector3,
     opaque_type: OpaquePackedVector3Array,
     inner_type: InnerPackedVector3Array,
@@ -719,6 +729,7 @@ impl_packed_array!(
 #[cfg(since_api = "4.3")]
 impl_packed_array!(
     type_name: PackedVector4Array,
+    variant_type: PACKED_VECTOR4_ARRAY,
     element_type: Vector4,
     opaque_type: OpaquePackedVector4Array,
     inner_type: InnerPackedVector4Array,
@@ -737,6 +748,7 @@ impl_packed_array!(
 
 impl_packed_array!(
     type_name: PackedColorArray,
+    variant_type: PACKED_COLOR_ARRAY,
     element_type: Color,
     opaque_type: OpaquePackedColorArray,
     inner_type: InnerPackedColorArray,

godot-core/src/builtin/plane.rs

@@ -264,7 +264,7 @@ impl Neg for Plane {
 // This type is represented as `Self` in Godot, so `*mut Self` is sound.
 unsafe impl GodotFfi for Plane {
     fn variant_type() -> sys::VariantType {
-        sys::VariantType::Plane
+        sys::VariantType::PLANE
     }
 
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self;