Merge branch 'godot-rust:master' into disconnect-typed-signal

Author: andersgaustad

godot-core/src/builtin/color.rs

@@ -22,6 +22,8 @@ use sys::{ffi_methods, GodotFfi};
 ///
 /// To access its [**HSVA**](ColorHsv) representation, use [`Color::to_hsv`].
 ///
+/// Predefined colors are available as constants, see the corresponding [`impl` block](#impl-Color-1).
+///
 /// # Godot docs
 ///
 /// [`Color` (stable)](https://docs.godotengine.org/en/stable/classes/class_color.html)
@@ -58,28 +60,29 @@ impl Color {
     /// mapped to 1.0.
     ///
     /// _Godot equivalent: the global `Color8` function_
-    pub fn from_rgba8(r: u8, g: u8, b: u8, a: u8) -> Self {
+    pub const fn from_rgba8(r: u8, g: u8, b: u8, a: u8) -> Self {
         Self::from_rgba(from_u8(r), from_u8(g), from_u8(b), from_u8(a))
     }
 
-    /// Constructs a new `Color` with the given components as `u16` words. 0 is mapped to 0.0,
-    /// 65535 (`0xffff`) is mapped to 1.0.
-    pub fn from_rgba16(r: u16, g: u16, b: u16, a: u16) -> Self {
+    /// Constructs a new `Color` with the given components as `u16` words.
+    ///
+    /// 0 is mapped to 0.0, 65535 (`0xFFFF`) is mapped to 1.0.
+    pub const fn from_rgba16(r: u16, g: u16, b: u16, a: u16) -> Self {
         Self::from_rgba(from_u16(r), from_u16(g), from_u16(b), from_u16(a))
     }
 
     /// Constructs a new `Color` from a 32-bits value with the given channel `order`.
     ///
     /// _Godot equivalent: `Color.hex`, if `ColorChannelOrder::Rgba` is used_
-    pub fn from_u32_rgba(u: u32, order: ColorChannelOrder) -> Self {
+    pub const fn from_u32_rgba(u: u32, order: ColorChannelOrder) -> Self {
         let [r, g, b, a] = order.unpack(u.to_be_bytes());
         Color::from_rgba8(r, g, b, a)
     }
 
     /// Constructs a new `Color` from a 64-bits value with the given channel `order`.
     ///
     /// _Godot equivalent: `Color.hex64`, if `ColorChannelOrder::Rgba` is used_
-    pub fn from_u64_rgba(u: u64, order: ColorChannelOrder) -> Self {
+    pub const fn from_u64_rgba(u: u64, order: ColorChannelOrder) -> Self {
         let [r, g, b, a] = order.unpack(to_be_words(u));
         Color::from_rgba16(r, g, b, a)
     }
@@ -383,7 +386,7 @@ pub enum ColorChannelOrder {
 }
 
 impl ColorChannelOrder {
-    fn pack<T>(self, rgba: [T; 4]) -> [T; 4] {
+    const fn pack<T: Copy>(self, rgba: [T; 4]) -> [T; 4] {
         let [r, g, b, a] = rgba;
         match self {
             ColorChannelOrder::RGBA => [r, g, b, a],
@@ -392,7 +395,7 @@ impl ColorChannelOrder {
         }
     }
 
-    fn unpack<T>(self, xyzw: [T; 4]) -> [T; 4] {
+    const fn unpack<T: Copy>(self, xyzw: [T; 4]) -> [T; 4] {
         let [x, y, z, w] = xyzw;
         match self {
             ColorChannelOrder::RGBA => [x, y, z, w],
@@ -510,12 +513,12 @@ impl ops::Neg for Color {
 }
 
 /// Converts a single channel byte to a float in the range 0 to 1.
-fn from_u8(byte: u8) -> f32 {
+const fn from_u8(byte: u8) -> f32 {
     byte as f32 / 255.0
 }
 
 /// Converts a single channel `u16` word to a float in the range 0 to 1.
-fn from_u16(byte: u16) -> f32 {
+const fn from_u16(byte: u16) -> f32 {
     byte as f32 / 65535.0
 }
 
@@ -542,7 +545,7 @@ fn from_be_words(words: [u16; 4]) -> u64 {
 }
 
 /// Unpacks a `u64` into four `u16` words in big-endian order.
-fn to_be_words(mut u: u64) -> [u16; 4] {
+const fn to_be_words(mut u: u64) -> [u16; 4] {
     let w = (u & 0xffff) as u16;
     u >>= 16;
     let z = (u & 0xffff) as u16;

godot-core/src/builtin/color_constants.rs

@@ -227,8 +227,12 @@ fn handle_init<'a>(
         godot_init_impl, ..
     } = decls;
 
+    // If #[class(init)] or #[class(no_init)] is provided, deny overriding manual init().
+    let deny_manual_init_macro = util::format_class_deny_manual_init_macro(class_name);
+
     *godot_init_impl = quote! {
         #godot_init_impl
+        #deny_manual_init_macro!();
 
         #(#cfg_attrs)*
         impl ::godot::obj::cap::GodotDefault for #class_name {

godot-macros/src/class/data_models/interface_trait_impl.rs

@@ -148,6 +148,7 @@ pub fn derive_godot_class(item: venial::Item) -> ParseResult<TokenStream> {
     // Note: one limitation is that macros don't work for `impl nested::MyClass` blocks.
     let visibility_macro = make_visibility_macro(class_name, class.vis_marker.as_ref());
     let base_field_macro = make_base_field_macro(class_name, fields.base_field.is_some());
+    let deny_manual_init_macro = make_deny_manual_init_macro(class_name, struct_cfg.init_strategy);
 
     Ok(quote! {
         impl ::godot::obj::GodotClass for #class_name {
@@ -180,6 +181,7 @@ pub fn derive_godot_class(item: venial::Item) -> ParseResult<TokenStream> {
         #init_expecter
         #visibility_macro
         #base_field_macro
+        #deny_manual_init_macro
         #( #deprecations )*
         #( #errors )*
 
@@ -236,6 +238,35 @@ fn make_base_field_macro(class_name: &Ident, has_base_field: bool) -> TokenStrea
     }
 }
 
+/// Generates code for a decl-macro that prevents manual `init()` for incompatible init strategies.
+fn make_deny_manual_init_macro(class_name: &Ident, init_strategy: InitStrategy) -> TokenStream {
+    let macro_name = util::format_class_deny_manual_init_macro(class_name);
+
+    let class_attr = match init_strategy {
+        InitStrategy::Absent => "#[class(no_init)]",
+        InitStrategy::Generated => "#[class(init)]",
+        InitStrategy::UserDefined => {
+            // For classes that expect manual init, do nothing.
+            return quote! {
+                macro_rules! #macro_name {
+                    () => {};
+                }
+            };
+        }
+    };
+
+    let error_message =
+        format!("Class `{class_name}` is marked with {class_attr} but provides an init() method.");
+
+    quote! {
+        macro_rules! #macro_name {
+            () => {
+                compile_error!(#error_message);
+            };
+        }
+    }
+}
+
 /// Checks at compile time that a function with the given name exists on `Self`.
 #[must_use]
 pub fn make_existence_check(ident: &Ident) -> TokenStream {

godot-macros/src/class/derive_godot_class.rs

@@ -418,3 +418,8 @@ pub fn format_class_visibility_macro(class_name: &Ident) -> Ident {
 pub fn format_class_base_field_macro(class_name: &Ident) -> Ident {
     format_ident!("__godot_{class_name}_has_base_field_macro")
 }
+
+/// Returns the name of the macro used to deny manual `init()` for incompatible init strategies.
+pub fn format_class_deny_manual_init_macro(class_name: &Ident) -> Ident {
+    format_ident!("__deny_manual_init_{class_name}")
+}

godot-macros/src/util/mod.rs

@@ -198,3 +198,17 @@ fn color_hsv_multi_roundtrip() {
         assert_eq_approx!(original, c_back);
     }
 }
+
+// Check that color constants match their Godot value exactly.
+//
+// Occasionally, this can be manually cross-checked against extension_api.json. We currently don't codegen those constants, and the values
+// there are in float, so may not match exactly.
+#[itest]
+fn color_constants() {
+    for (name, rust_color) in Color::ALL_GODOT_COLORS.iter().copied() {
+        let godot_color = Color::from_string(name)
+            .unwrap_or_else(|| panic!("Color constant {name} not found in Godot"));
+
+        assert_eq!(rust_color, godot_color, "Color mismatch for {name}");
+    }
+}

itest/rust/src/builtin_tests/color_test.rs

@@ -142,7 +142,7 @@ impl CodegenTest2 {
 macro_rules! make_class {
     ($ClassName:ident, $BaseName:ident) => {
         #[derive(GodotClass)]
-        #[class(no_init, base=$BaseName)]
+        #[class(base=$BaseName)]
         pub struct $ClassName {
             base: Base<godot::classes::$BaseName>,
         }