Merge RectSide -> Side enum

Author: Bromeon

godot-core/src/builtin/mod.rs

@@ -88,6 +88,8 @@ pub mod strings {
     pub use super::string::TransientStringNameOrd;
 }
 
+use crate::engine::global::Side;
+
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Implementation
 
@@ -151,14 +153,22 @@ pub(crate) fn u8_to_bool(u: u8) -> bool {
 /// The side of a [`Rect2`] or [`Rect2i`].
 ///
 /// _Godot equivalent: `@GlobalScope.Side`_
-#[doc(alias = "Side")]
-#[derive(Copy, Clone, Debug)]
-#[repr(C)]
-pub enum RectSide {
-    Left = 0,
-    Top = 1,
-    Right = 2,
-    Bottom = 3,
+#[deprecated(note = "Merged with `godot::global::Side`.")]
+pub type RectSide = Side;
+
+#[allow(non_upper_case_globals)]
+impl Side {
+    #[deprecated(note = "Renamed to `Side::LEFT`.")]
+    pub const Left: Side = Side::LEFT;
+
+    #[deprecated(note = "Renamed to `Side::TOP`.")]
+    pub const Top: Side = Side::TOP;
+
+    #[deprecated(note = "Renamed to `Side::RIGHT`.")]
+    pub const Right: Side = Side::RIGHT;
+
+    #[deprecated(note = "Renamed to `Side::BOTTOM`.")]
+    pub const Bottom: Side = Side::BOTTOM;
 }
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------

godot-core/src/builtin/rect2.rs

@@ -9,7 +9,8 @@ use godot_ffi as sys;
 use sys::{ffi_methods, GodotFfi};
 
 use crate::builtin::math::ApproxEq;
-use crate::builtin::{real, Rect2i, RectSide, Vector2};
+use crate::builtin::{real, Rect2i, Vector2};
+use crate::engine::global::Side;
 
 use super::meta::impl_godot_as_self;
 
@@ -147,12 +148,12 @@ impl Rect2 {
     /// `amount` may be negative, but care must be taken: If the resulting `size` has
     /// negative components the computation may be incorrect.
     #[inline]
-    pub fn grow_side(&self, side: RectSide, amount: real) -> Self {
+    pub fn grow_side(&self, side: Side, amount: real) -> Self {
         match side {
-            RectSide::Left => self.grow_individual(amount, 0.0, 0.0, 0.0),
-            RectSide::Top => self.grow_individual(0.0, amount, 0.0, 0.0),
-            RectSide::Right => self.grow_individual(0.0, 0.0, amount, 0.0),
-            RectSide::Bottom => self.grow_individual(0.0, 0.0, 0.0, amount),
+            Side::LEFT => self.grow_individual(amount, 0.0, 0.0, 0.0),
+            Side::TOP => self.grow_individual(0.0, amount, 0.0, 0.0),
+            Side::RIGHT => self.grow_individual(0.0, 0.0, amount, 0.0),
+            Side::BOTTOM => self.grow_individual(0.0, 0.0, 0.0, amount),
         }
     }
 

godot-core/src/builtin/rect2i.rs

@@ -7,10 +7,11 @@
 
 use std::cmp;
 
+use crate::engine::global::Side;
 use godot_ffi as sys;
 use sys::{ffi_methods, GodotFfi};
 
-use super::{meta::impl_godot_as_self, Rect2, RectSide, Vector2i};
+use super::{meta::impl_godot_as_self, Rect2, Vector2i};
 
 /// 2D axis-aligned integer bounding box.
 ///
@@ -164,12 +165,12 @@ impl Rect2i {
     /// `amount` may be negative, but care must be taken: If the resulting `size` has
     /// negative components the computation may be incorrect.
     #[inline]
-    pub fn grow_side(self, side: RectSide, amount: i32) -> Self {
+    pub fn grow_side(self, side: Side, amount: i32) -> Self {
         match side {
-            RectSide::Left => self.grow_individual(amount, 0, 0, 0),
-            RectSide::Top => self.grow_individual(0, amount, 0, 0),
-            RectSide::Right => self.grow_individual(0, 0, amount, 0),
-            RectSide::Bottom => self.grow_individual(0, 0, 0, amount),
+            Side::LEFT => self.grow_individual(amount, 0, 0, 0),
+            Side::TOP => self.grow_individual(0, amount, 0, 0),
+            Side::RIGHT => self.grow_individual(0, 0, amount, 0),
+            Side::BOTTOM => self.grow_individual(0, 0, 0, amount),
         }
     }
 
@@ -502,25 +503,25 @@ mod test {
         assert!(end.encloses(begin));
 
         let now = begin.grow_individual(3, 0, 0, 0);
-        let now_side = begin.grow_side(RectSide::Left, 3);
+        let now_side = begin.grow_side(Side::LEFT, 3);
         assert_ne!(now, end);
         assert_eq!(now, now_side);
         assert!(end.encloses(now));
 
         let now = now.grow_individual(0, 3, 0, 0);
-        let now_side = now_side.grow_side(RectSide::Top, 3);
+        let now_side = now_side.grow_side(Side::TOP, 3);
         assert_ne!(now, end);
         assert_eq!(now, now_side);
         assert!(end.encloses(now));
 
         let now = now.grow_individual(0, 0, 3, 0);
-        let now_side = now_side.grow_side(RectSide::Right, 3);
+        let now_side = now_side.grow_side(Side::RIGHT, 3);
         assert_ne!(now, end);
         assert_eq!(now, now_side);
         assert!(end.encloses(now));
 
         let now = now.grow_individual(0, 0, 0, 3);
-        let now_side = now_side.grow_side(RectSide::Bottom, 3);
+        let now_side = now_side.grow_side(Side::BOTTOM, 3);
         assert_eq!(now, end);
         assert_eq!(now, now_side);
     }

itest/rust/src/builtin_tests/geometry/rect2_test.rs

@@ -9,7 +9,8 @@ use crate::framework::itest;
 
 use godot::builtin::inner::InnerRect2;
 use godot::builtin::math::assert_eq_approx;
-use godot::builtin::{real, reals, RealConv, Rect2, RectSide, Vector2};
+use godot::builtin::{real, reals, RealConv, Rect2, Vector2};
+use godot::engine::global::Side;
 
 #[itest]
 fn rect2_inner_equivalence() {
@@ -29,12 +30,7 @@ fn rect2_inner_equivalence() {
     ];
     let reals = reals![0.0, 1.0, 32.0];
     let grow_values = reals![-1.0, 0.0, 7.0];
-    let sides = [
-        RectSide::Left,
-        RectSide::Top,
-        RectSide::Right,
-        RectSide::Bottom,
-    ];
+    let sides = [Side::LEFT, Side::TOP, Side::RIGHT, Side::BOTTOM];
 
     for rect in rects {
         let inner_rect = InnerRect2::from_outer(&rect);

itest/rust/src/builtin_tests/geometry/rect2i_test.rs

@@ -9,7 +9,9 @@ use std::fmt::Debug;
 
 use crate::framework::itest;
 use godot::builtin::inner::InnerRect2i;
-use godot::builtin::{Rect2i, RectSide, Vector2i};
+use godot::builtin::{Rect2i, Vector2i};
+use godot::engine::global::Side;
+use godot::obj::EngineEnum;
 
 #[itest]
 fn rect2i_equiv_unary() {
@@ -28,12 +30,7 @@ fn rect2i_equiv_unary() {
         Vector2i::new(10, 10),
     ];
     let test_ints = [0, 1, 10, 32];
-    let test_sides = [
-        RectSide::Left,
-        RectSide::Top,
-        RectSide::Right,
-        RectSide::Bottom,
-    ];
+    let test_sides = [Side::LEFT, Side::TOP, Side::RIGHT, Side::BOTTOM];
 
     fn evaluate_mappings<T>(key: &str, a: T, b: T)
     where
@@ -87,7 +84,7 @@ fn rect2i_equiv_unary() {
                 evaluate_mappings(
                     "grow_side",
                     a.grow_side(b, c),
-                    inner_a.grow_side(b as i64, c as i64),
+                    inner_a.grow_side(b.ord() as i64, c as i64),
                 );
             }
         }