Update several moved paths

Bromeon · Bromeon · commit 510eef252159 · 2024-05-26T23:37:59.000+02:00
diff --git a/godot-codegen/src/conv/type_conversions.rs b/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,
             }
         };
diff --git a/godot-core/src/builtin/array.rs b/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(),
         }
     }
diff --git a/godot-core/src/builtin/basis.rs b/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};
diff --git a/godot-core/src/builtin/meta/registration/method.rs b/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 {
diff --git a/godot-core/src/builtin/packed_array.rs b/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 {
diff --git a/godot-core/src/builtin/quaternion.rs b/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;
diff --git a/godot-core/src/builtin/rect2.rs b/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;
 
diff --git a/godot-core/src/builtin/rect2i.rs b/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
diff --git a/godot-core/src/builtin/signal.rs b/godot-core/src/builtin/signal.rs
@@ -10,10 +10,10 @@ use std::ptr;
 
 use godot_ffi as sys;
 
-use super::meta::{impl_godot_as_self, FromGodot, GodotType};
-use crate::builtin::meta::ToGodot;
+use crate::builtin::meta::{impl_godot_as_self, FromGodot, GodotType, ToGodot};
 use crate::builtin::{inner, Array, Callable, Dictionary, StringName, Variant};
-use crate::engine::{global::Error, Object};
+use crate::engine::Object;
+use crate::global::Error;
 use crate::obj::bounds::DynMemory;
 use crate::obj::{Bounds, Gd, GodotClass, InstanceId};
 use sys::{ffi_methods, GodotFfi};
diff --git a/godot-core/src/engine/mod.rs b/godot-core/src/engine/mod.rs
@@ -39,34 +39,34 @@ pub mod native {
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Deprecations
 
-// #[deprecated = "Enums have been moved to `godot::global`."]
-// pub mod global {
-//     pub use crate::builtin::{Corner, EulerOrder, Side};
-//     pub use crate::global::*;
-// }
-//
-// #[deprecated = "Utility functions have been moved to `godot::global`."]
-// pub mod utilities {
-//     pub use crate::global::*;
-// }
-//
-// #[deprecated = "`GFile` has been moved to `godot::extras`."]
-// pub use crate::extras::GFile;
-//
-// #[deprecated = "`IoError` has been moved to `godot::extras`."]
-// pub use crate::extras::IoError;
-//
-// #[deprecated = "`save` has been moved to `godot::global`."]
-// pub use crate::global::save;
-//
-// #[deprecated = "`try_save` has been moved to `godot::global`."]
-// pub use crate::global::try_save;
-//
-// #[deprecated = "`load` has been moved to `godot::global`."]
-// pub use crate::global::load;
-//
-// #[deprecated = "`try_load` has been moved to `godot::global`."]
-// pub use crate::global::try_load;
+#[deprecated = "Enums have been moved to `godot::global`."]
+pub mod global {
+    pub use crate::builtin::{Corner, EulerOrder, Side};
+    pub use crate::global::*;
+}
+
+#[deprecated = "Utility functions have been moved to `godot::global`."]
+pub mod utilities {
+    pub use crate::global::*;
+}
+
+#[deprecated = "`GFile` has been moved to `godot::extras`."]
+pub use crate::extras::GFile;
+
+#[deprecated = "`IoError` has been moved to `godot::extras`."]
+pub use crate::extras::IoError;
+
+#[deprecated = "`save` has been moved to `godot::global`."]
+pub use crate::global::save;
+
+#[deprecated = "`try_save` has been moved to `godot::global`."]
+pub use crate::global::try_save;
+
+#[deprecated = "`load` has been moved to `godot::global`."]
+pub use crate::global::load;
+
+#[deprecated = "`try_load` has been moved to `godot::global`."]
+pub use crate::global::try_load;
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Utilities for crate
diff --git a/godot-core/src/global/mod.rs b/godot-core/src/global/mod.rs
@@ -32,3 +32,7 @@ pub use crate::gen::central::global_enums::*;
 pub use crate::gen::utilities::*;
 
 pub use save_load::*;
+
+// This is needed for generated classes to find symbols, even those that have been moved to crate::builtin.
+#[allow(unused_imports)] // micromanaging imports for generated code is not fun
+pub(crate) use crate::builtin::{Corner, EulerOrder, Side};
diff --git a/godot-core/src/obj/gd.rs b/godot-core/src/obj/gd.rs
@@ -17,12 +17,14 @@ use crate::builtin::meta::{
     ToGodot,
 };
 use crate::builtin::{Callable, NodePath, StringName, Variant};
+use crate::global::PropertyHint;
 use crate::obj::raw::RawGd;
 use crate::obj::{
     bounds, cap, Bounds, EngineEnum, GdDerefTarget, GdMut, GdRef, GodotClass, Inherits, InstanceId,
 };
+use crate::private::callbacks;
 use crate::property::{Export, PropertyHintInfo, TypeStringHint, Var};
-use crate::{callbacks, engine, out};
+use crate::{engine, out};
 
 /// Smart pointer to objects owned by the Godot engine.
 ///
@@ -649,7 +651,7 @@ impl<T: GodotClass> Clone for Gd<T> {
 
 impl<T: GodotClass> TypeStringHint for Gd<T> {
     fn type_string() -> String {
-        use engine::global::PropertyHint;
+        use crate::global::PropertyHint;
 
         match Self::default_export_info().hint {
             hint @ (PropertyHint::RESOURCE_TYPE | PropertyHint::NODE_TYPE) => {
@@ -680,11 +682,11 @@ impl<T: GodotClass> Var for Gd<T> {
 impl<T: GodotClass> Export for Gd<T> {
     fn default_export_info() -> PropertyHintInfo {
         let hint = if T::inherits::<engine::Resource>() {
-            engine::global::PropertyHint::RESOURCE_TYPE
+            PropertyHint::RESOURCE_TYPE
         } else if T::inherits::<engine::Node>() {
-            engine::global::PropertyHint::NODE_TYPE
+            PropertyHint::NODE_TYPE
         } else {
-            engine::global::PropertyHint::NONE
+            PropertyHint::NONE
         };
 
         // Godot does this by default too; the hint is needed when the class is a resource/node,
diff --git a/godot-core/src/obj/raw.rs b/godot-core/src/obj/raw.rs
@@ -19,7 +19,7 @@ use crate::obj::bounds::DynMemory as _;
 use crate::obj::rtti::ObjectRtti;
 use crate::obj::{bounds, Bounds, GdDerefTarget, GdMut, GdRef, GodotClass, InstanceId};
 use crate::storage::{InstanceStorage, Storage};
-use crate::{engine, out};
+use crate::{engine, global, out};
 
 /// Low-level bindings for object pointers in Godot.
 ///
@@ -105,7 +105,7 @@ impl<T: GodotClass> RawGd<T> {
     pub(crate) fn is_instance_valid(&self) -> bool {
         self.cached_rtti
             .as_ref()
-            .map(|rtti| engine::utilities::is_instance_id_valid(rtti.instance_id().to_i64()))
+            .map(|rtti| global::is_instance_id_valid(rtti.instance_id().to_i64()))
             .unwrap_or(false)
     }
 
diff --git a/godot-macros/src/class/data_models/func.rs b/godot-macros/src/class/data_models/func.rs
@@ -379,7 +379,7 @@ fn make_method_flags(
     method_type: ReceiverType,
     is_script_virtual: bool,
 ) -> Result<TokenStream, String> {
-    let flags = quote! { ::godot::engine::global::MethodFlags };
+    let flags = quote! { ::godot::global::MethodFlags };
 
     let base_flags = match method_type {
         ReceiverType::Ref => {
diff --git a/godot-macros/src/class/data_models/property.rs b/godot-macros/src/class/data_models/property.rs
@@ -89,14 +89,14 @@ pub fn make_property_impl(class_name: &Ident, fields: &Fields) -> TokenStream {
 
         let usage_flags = match usage_flags {
             UsageFlags::Inferred => {
-                quote! { ::godot::engine::global::PropertyUsageFlags::NONE }
+                quote! { ::godot::global::PropertyUsageFlags::NONE }
             }
             UsageFlags::InferredExport => {
-                quote! { ::godot::engine::global::PropertyUsageFlags::DEFAULT }
+                quote! { ::godot::global::PropertyUsageFlags::DEFAULT }
             }
             UsageFlags::Custom(flags) => quote! {
                 #(
-                    ::godot::engine::global::PropertyUsageFlags::#flags
+                    ::godot::global::PropertyUsageFlags::#flags
                 )|*
             },
         };
@@ -135,14 +135,14 @@ pub fn make_property_impl(class_name: &Ident, fields: &Fields) -> TokenStream {
 
                 quote! {
                     (
-                        ::godot::engine::global::PropertyHint::#hint,
+                        ::godot::global::PropertyHint::#hint,
                         #hint_string
                     )
                 }
             }
             FieldHint::HintWithString { hint, hint_string } => quote! {
                 (
-                    ::godot::engine::global::PropertyHint::#hint,
+                    ::godot::global::PropertyHint::#hint,
                     ::godot::builtin::GString::from(#hint_string)
                 )
             },
diff --git a/godot-macros/src/derive/derive_var.rs b/godot-macros/src/derive/derive_var.rs
@@ -61,7 +61,7 @@ fn create_property_hint_impl(convert: &GodotConvert) -> TokenStream {
 
             quote! {
                 ::godot::register::property::PropertyHintInfo {
-                    hint: ::godot::engine::global::PropertyHint::ENUM,
+                    hint: ::godot::global::PropertyHint::ENUM,
                     hint_string: #hint_string.into(),
                 }
             }
diff --git a/itest/rust/build.rs b/itest/rust/build.rs
@@ -216,7 +216,7 @@ fn main() {
         use godot::builtin::meta::*;
         use godot::log::godot_error;
         use godot::obj::{Gd, InstanceId};
-        use godot::engine::global::Error;
+        use godot::global::Error;
         use godot::engine::{Node, Resource};
 
         #[derive(godot::register::GodotClass)]
diff --git a/itest/rust/src/benchmarks/mod.rs b/itest/rust/src/benchmarks/mod.rs
@@ -74,7 +74,7 @@ fn class_singleton_access() -> Gd<Os> {
 
 #[bench]
 fn utilities_allocate_rid() -> i64 {
-    godot::engine::utilities::rid_allocate_id()
+    godot::global::rid_allocate_id()
 }
 
 #[bench]
@@ -90,7 +90,7 @@ fn utilities_ffi_call() -> f64 {
     let base = black_box(5.678);
     let exponent = black_box(3.456);
 
-    godot::engine::utilities::pow(base, exponent)
+    godot::global::pow(base, exponent)
 }
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/itest/rust/src/builtin_tests/containers/array_test.rs b/itest/rust/src/builtin_tests/containers/array_test.rs
@@ -406,9 +406,9 @@ fn untyped_array_return_from_godot_func() {
 // ancestors in the list.
 #[itest]
 fn typed_array_pass_to_godot_func() {
-    use godot::engine::global::Error;
     use godot::engine::image::Format;
     use godot::engine::{Image, Texture2DArray};
+    use godot::global::Error;
 
     let mut image = Image::new_gd();
     image.set_data(
diff --git a/itest/rust/src/builtin_tests/geometry/basis_test.rs b/itest/rust/src/builtin_tests/geometry/basis_test.rs
@@ -8,8 +8,7 @@
 use godot::builtin::inner::InnerBasis;
 use godot::builtin::math::assert_eq_approx;
 use godot::builtin::meta::ToGodot;
-use godot::builtin::{real, Basis, RealConv, VariantOperator, Vector3};
-use godot::engine::global::EulerOrder;
+use godot::builtin::{real, Basis, EulerOrder, RealConv, VariantOperator, Vector3};
 
 use crate::framework::itest;
 
diff --git a/itest/rust/src/builtin_tests/geometry/rect2_test.rs b/itest/rust/src/builtin_tests/geometry/rect2_test.rs
@@ -9,8 +9,7 @@ use crate::framework::itest;
 
 use godot::builtin::inner::InnerRect2;
 use godot::builtin::math::assert_eq_approx;
-use godot::builtin::{real, reals, RealConv, Rect2, Vector2};
-use godot::engine::global::Side;
+use godot::builtin::{real, reals, RealConv, Rect2, Side, Vector2};
 
 #[itest]
 fn rect2_inner_equivalence() {
diff --git a/itest/rust/src/builtin_tests/geometry/rect2i_test.rs b/itest/rust/src/builtin_tests/geometry/rect2i_test.rs
@@ -9,8 +9,7 @@ use std::fmt::Debug;
 
 use crate::framework::itest;
 use godot::builtin::inner::InnerRect2i;
-use godot::builtin::{Rect2i, Vector2i};
-use godot::engine::global::Side;
+use godot::builtin::{Rect2i, Side, Vector2i};
 use godot::obj::EngineEnum;
 
 #[itest]
diff --git a/itest/rust/src/builtin_tests/script/script_instance_tests.rs b/itest/rust/src/builtin_tests/script/script_instance_tests.rs
@@ -9,11 +9,11 @@ use std::ffi::c_void;
 
 use godot::builtin::meta::{ClassName, FromGodot, MethodInfo, PropertyInfo, ToGodot};
 use godot::builtin::{GString, StringName, Variant, VariantType};
-use godot::engine::global::{MethodFlags, PropertyHint, PropertyUsageFlags};
 use godot::engine::{
     create_script_instance, IScriptExtension, Object, Script, ScriptExtension, ScriptInstance,
     ScriptLanguage, SiMut,
 };
+use godot::global::{MethodFlags, PropertyHint, PropertyUsageFlags};
 use godot::obj::{Base, Gd, WithBaseField};
 use godot::register::{godot_api, GodotClass};
 use godot::sys;
diff --git a/itest/rust/src/engine_tests/save_load_test.rs b/itest/rust/src/engine_tests/save_load_test.rs
@@ -5,7 +5,7 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use godot::engine::{load, save, try_load, try_save};
+use godot::global::{load, save, try_load, try_save};
 use godot::obj::NewGd;
 use godot::register::GodotClass;
 
diff --git a/itest/rust/src/object_tests/get_property_list_test.rs b/itest/rust/src/object_tests/get_property_list_test.rs
@@ -9,8 +9,8 @@ use std::collections::HashMap;
 
 use godot::builtin::meta::PropertyInfo;
 use godot::builtin::{Dictionary, GString, StringName, VariantType, Vector2, Vector3};
-use godot::engine::global::{PropertyHint, PropertyUsageFlags};
 use godot::engine::{IObject, Node};
+use godot::global::{PropertyHint, PropertyUsageFlags};
 use godot::obj::{Gd, NewAlloc};
 use godot::register::{godot_api, GodotClass};
 use godot::test::itest;
diff --git a/itest/rust/src/object_tests/object_test.rs b/itest/rust/src/object_tests/object_test.rs
diff --git a/itest/rust/src/object_tests/property_template_test.rs b/itest/rust/src/object_tests/property_template_test.rs
diff --git a/itest/rust/src/object_tests/property_test.rs b/itest/rust/src/object_tests/property_test.rs

Original file line number	Diff line number	Diff line change
`@@ -870,7 +870,7 @@ impl<T: ArrayElement> Var for Array<T> {`
`870`	`870`	`}`
`871`	`871`
`872`	`872`	`PropertyHintInfo {`
`873`		`- hint: crate::engine::global::PropertyHint::ARRAY_TYPE,`
	`873`	`+ hint: crate::global::PropertyHint::ARRAY_TYPE,`
`874`	`874`	`hint_string: T::godot_type_name().into(),`
`875`	`875`	`}`
`876`	`876`	`}`
`@@ -879,7 +879,7 @@ impl<T: ArrayElement> Var for Array<T> {`
`879`	`879`	`impl<T: ArrayElement + TypeStringHint> Export for Array<T> {`
`880`	`880`	`fn default_export_info() -> PropertyHintInfo {`
`881`	`881`	`PropertyHintInfo {`
`882`		`- hint: crate::engine::global::PropertyHint::TYPE_STRING,`
	`882`	`+ hint: crate::global::PropertyHint::TYPE_STRING,`
`883`	`883`	`hint_string: T::type_string().into(),`
`884`	`884`	`}`
`885`	`885`	`}`
Original file line number	Diff line number	Diff line change
`@@ -514,7 +514,7 @@ macro_rules! impl_packed_array {`
`514`	`514`	`// In 4.3 Godot can (and does) use type hint strings for packed arrays, see https://github.com/godotengine/godot/pull/82952.`
`515`	`515`	`if sys::GdextBuild::since_api("4.3") {`
`516`	`516`	`$crate::property::PropertyHintInfo {`
`517`		`- hint: $crate::engine::global::PropertyHint::TYPE_STRING,`
	`517`	`+ hint: $crate::global::PropertyHint::TYPE_STRING,`
`518`	`518`	`hint_string: <$Element as $crate::property::TypeStringHint>::type_string().into(),`
`519`	`519`	`}`
`520`	`520`	`} else {`