Fix Variant::evaluate to work with both 4.0 and 4.1

Fix impl_variant_traits macro's FromVariant impl to work with both 4.0 and 4.1

Author: lilizoey

godot-bindings/src/lib.rs

@@ -103,7 +103,10 @@ mod prebuilt {
             full_string: godot4_prebuilt::GODOT_VERSION.into(),
             major: version[0].parse().unwrap(),
             minor: version[1].parse().unwrap(),
-            patch: version[2].parse().unwrap(),
+            patch: version
+                .get(2)
+                .and_then(|patch| patch.parse().ok())
+                .unwrap_or(0),
             status: "stable".into(),
             custom_rev: None,
         }
@@ -132,12 +135,12 @@ pub fn emit_godot_version_cfg() {
         ..
     } = get_godot_version();
 
-    println!(r#"cargo:rustc-cfg=gdextension_api_version="{major}.{minor}""#);
+    println!(r#"cargo:rustc-cfg=gdextension_api="{major}.{minor}""#);
 
     // Godot drops the patch version if it is 0.
     if patch != 0 {
-        println!(r#"cargo:rustc-cfg=gdextension_api_version_full="{major}.{minor}.{patch}""#);
+        println!(r#"cargo:rustc-cfg=gdextension_exact_api="{major}.{minor}.{patch}""#);
     } else {
-        println!(r#"cargo:rustc-cfg=gdextension_api_version_full="{major}.{minor}""#);
+        println!(r#"cargo:rustc-cfg=gdextension_exact_api="{major}.{minor}""#);
     }
 }

godot-core/src/builtin/basis.rs

@@ -143,12 +143,12 @@ impl Basis {
     /// orthonormalized. The `target` and `up` vectors cannot be zero, and
     /// cannot be parallel to each other.
     ///
-    #[cfg(gdextension_api_version = "4.0")]
+    #[cfg(gdextension_api = "4.0")]
     /// _Godot equivalent: `Basis.looking_at()`_
     pub fn new_looking_at(target: Vector3, up: Vector3) -> Self {
         super::inner::InnerBasis::looking_at(target, up)
     }
-    #[cfg(not(gdextension_api_version = "4.0"))]
+    #[cfg(not(gdextension_api = "4.0"))]
     /// If `use_model_front` is true, the +Z axis (asset front) is treated as forward (implies +X is left)
     /// and points toward the target position. By default, the -Z axis (camera forward) is treated as forward
     /// (implies +X is right).

godot-core/src/builtin/transform3d.rs

@@ -145,15 +145,15 @@ impl Transform3D {
     /// See [`Basis::new_looking_at()`] for more information.
     ///
     /// _Godot equivalent: Transform3D.looking_at()_
-    #[cfg(gdextension_api_version = "4.0")]
+    #[cfg(gdextension_api = "4.0")]
     #[must_use]
     pub fn looking_at(self, target: Vector3, up: Vector3) -> Self {
         Self {
             basis: Basis::new_looking_at(target - self.origin, up),
             origin: self.origin,
         }
     }
-    #[cfg(not(gdextension_api_version = "4.0"))]
+    #[cfg(not(gdextension_api = "4.0"))]
     #[must_use]
     pub fn looking_at(self, target: Vector3, up: Vector3, use_model_front: bool) -> Self {
         Self {

godot-core/src/builtin/variant/impls.rs

@@ -61,13 +61,21 @@ macro_rules! impl_variant_traits {
                     return Err(VariantConversionError::BadType)
                 }
 
+                // For 4.0:
                 // In contrast to T -> Variant, the conversion Variant -> T assumes
                 // that the destination is initialized (at least for some T). For example:
                 // void String::operator=(const String &p_str) { _cowdata._ref(p_str._cowdata); }
                 // does a copy-on-write and explodes if this->_cowdata is not initialized.
                 // We can thus NOT use Self::from_sys_init().
+                //
+                // This was changed in 4.1.
                 let result = unsafe {
-                    Self::from_sys_init(|self_ptr| {
+                    #[cfg(gdextension_api = "4.0")]
+                    let from_sys_init = Self::from_sys_init_default;
+                    #[cfg(not(gdextension_api = "4.0"))]
+                    let from_sys_init = Self::from_sys_init;
+
+                    from_sys_init(|self_ptr| {
                         let converter = sys::builtin_fn!($to_fn);
                         converter(self_ptr, variant.var_sys());
                     })

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

@@ -132,6 +132,22 @@ impl Variant {
         let op_sys = op.sys();
         let mut is_valid = false as u8;
 
+        #[cfg(gdextension_api = "4.0")]
+        let result = {
+            #[allow(unused_mut)]
+            let mut result = Variant::nil();
+            unsafe {
+                interface_fn!(variant_evaluate)(
+                    op_sys,
+                    self.var_sys(),
+                    rhs.var_sys(),
+                    result.var_sys(),
+                    ptr::addr_of_mut!(is_valid),
+                )
+            };
+            result
+        };
+        #[cfg(not(gdextension_api = "4.0"))]
         let result = unsafe {
             Variant::from_var_sys_init(|variant_ptr| {
                 interface_fn!(variant_evaluate)(

godot-core/src/lib.rs

@@ -152,14 +152,14 @@ pub mod private {
 macro_rules! generate_gdextension_api_version {
     (
         $(
-            $name:ident => {
+            ($name:ident, $gdextension_api:ident) => {
                 $($version:literal, )*
             }
         ),* $(,)?
     ) => {
         $(
             $(
-                #[cfg(gdextension_api_version = $version)]
+                #[cfg($gdextension_api = $version)]
                 #[allow(dead_code)]
                 const $name: &str = $version;
             )*
@@ -172,14 +172,14 @@ macro_rules! generate_gdextension_api_version {
 //
 // This includes all versions we're developing for, including unreleased future versions.
 generate_gdextension_api_version!(
-    GDEXTENSION_API_VERSION_FULL => {
+    (GDEXTENSION_API_VERSION_FULL, gdextension_exact_api) => {
         "4.0",
         "4.0.1",
         "4.0.2",
         "4.0.3",
         "4.1",
     },
-    GDEXTENSION_API_VERSION => {
+    (GDEXTENSION_API_VERSION, gdextension_api) => {
         "4.0",
         "4.1",
     },