Add integration tests and benchmarks for variant marshalling

Tests roundtrip via public API and direct `RustVariant` view for all `RustMarshal` types.
Benches: `Array::extend` size-hint fast path, packed-to-typed conversion.

Author: Bromeon

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

@@ -111,6 +111,9 @@ impl RustVariant {
     ///
     /// This is safe even for variants holding ref-counted types: `&mut Variant` guarantees exclusive access to the handle itself.
     /// The guarded `set_value()` method prevents overwriting such types without proper destruction.
+    ///
+    /// Gated on `trace` because mutable views (and the `set_value`/`SetError` machinery below) are only used by integration tests
+    /// in `itest/`. They are not part of the production fast path and would otherwise widen the internal API surface unnecessarily.
     #[cfg(feature = "trace")]
     pub fn view_mut(variant: &mut Variant) -> &mut Self {
         // SAFETY: OpaqueVariant and RustVariant have the same size/alignment (verified at compile time).

itest/rust/src/benchmarks/array.rs

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) godot-rust; Bromeon and contributors.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+use std::hint::black_box;
+
+use godot::builtin::{Array, GString};
+
+use crate::framework::{BenchResult, bench, bench_measure};
+
+#[bench(manual)]
+fn array_extend_i64() -> BenchResult {
+    bench_measure(1, || {
+        let mut arr = Array::new();
+        arr.extend((10_000i64..20_000).map(black_box));
+        black_box(arr)
+    })
+}
+
+#[bench(manual)]
+fn array_extend_gstring() -> BenchResult {
+    bench_measure(1, || {
+        let mut arr = Array::new();
+        arr.extend(
+            (10_000..20_000).map(|i| black_box(GString::from(format!("str_{}", i).as_str()))),
+        );
+        black_box(arr)
+    })
+}

itest/rust/src/benchmarks/mod.rs

@@ -10,15 +10,17 @@
 use std::hint::black_box;
 
 use godot::builtin::inner::InnerRect2i;
-use godot::builtin::{GString, PackedInt32Array, Rect2i, StringName, Vector2i};
+use godot::builtin::{GString, PackedFloat32Array, PackedInt32Array, Rect2i, StringName, Vector2i};
 use godot::classes::{Node3D, Os, RefCounted};
 use godot::obj::{Gd, InstanceId, NewAlloc, NewGd, Singleton};
 use godot::register::GodotClass;
 
-use crate::framework::bench;
+use crate::framework::{BenchResult, bench, bench_measure};
 
+mod array;
 mod callable;
 mod color;
+mod variant;
 
 #[bench]
 fn builtin_string_ctor() -> GString {
@@ -110,6 +112,30 @@ fn packed_array_from_iter_unknown_size() -> PackedInt32Array {
     }))
 }
 
+#[bench(manual)]
+fn packed_f32_to_array() -> BenchResult {
+    let packed = PackedFloat32Array::from_iter((0..10_000).map(|v: i32| v as f32));
+    bench_measure(1, || packed.to_typed_array())
+}
+
+#[bench(manual)]
+fn packed_f32_to_var_array() -> BenchResult {
+    let packed = PackedFloat32Array::from_iter((0..10_000).map(|v: i32| v as f32));
+    bench_measure(1, || packed.to_var_array())
+}
+
+#[bench(manual)]
+fn packed_f32_to_array_small() -> BenchResult {
+    let packed = PackedFloat32Array::from_iter((0..100).map(|v: i32| v as f32));
+    bench_measure(1, || packed.to_typed_array())
+}
+
+#[bench(manual)]
+fn packed_f32_to_var_array_small() -> BenchResult {
+    let packed = PackedFloat32Array::from_iter((0..100).map(|v: i32| v as f32));
+    bench_measure(1, || packed.to_var_array())
+}
+
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Helpers for benchmarks above
 

itest/rust/src/benchmarks/variant.rs

@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) godot-rust; Bromeon and contributors.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+use std::hint::black_box;
+
+use godot::builtin::{Color, Rid, Variant, Vector2i, Vector3};
+use godot::meta::{FromGodot, ToGodot};
+
+use crate::framework::{BenchResult, bench, bench_measure};
+
+// Scalar types.
+
+#[bench]
+fn variant_from_bool() -> Variant {
+    black_box(true).to_variant()
+}
+
+#[bench]
+fn variant_to_bool() -> bool {
+    bool::from_variant(black_box(&true.to_variant()))
+}
+
+#[bench]
+fn variant_from_i64() -> Variant {
+    black_box(12345_i64).to_variant()
+}
+
+#[bench]
+fn variant_to_i64() -> i64 {
+    i64::from_variant(black_box(&12345_i64.to_variant()))
+}
+
+#[bench]
+fn variant_from_f64() -> Variant {
+    black_box(1.234_f64).to_variant()
+}
+
+#[bench]
+fn variant_to_f64() -> f64 {
+    f64::from_variant(black_box(&1.234_f64.to_variant()))
+}
+
+// Vector types.
+
+#[bench]
+fn variant_from_vector2i() -> Variant {
+    black_box(Vector2i::new(100, 200)).to_variant()
+}
+
+#[bench]
+fn variant_to_vector2i() -> Vector2i {
+    Vector2i::from_variant(black_box(&Vector2i::new(100, 200).to_variant()))
+}
+
+#[bench]
+fn variant_from_vector3() -> Variant {
+    black_box(Vector3::new(1.5, 2.5, 3.5)).to_variant()
+}
+
+#[bench]
+fn variant_to_vector3() -> Vector3 {
+    Vector3::from_variant(black_box(&Vector3::new(1.5, 2.5, 3.5).to_variant()))
+}
+
+// Other POD types.
+
+#[bench]
+fn variant_from_color() -> Variant {
+    black_box(Color::from_rgba(0.5, 0.3, 0.8, 1.0)).to_variant()
+}
+
+#[bench]
+fn variant_to_color() -> Color {
+    Color::from_variant(black_box(
+        &Color::from_rgba(0.5, 0.3, 0.8, 1.0).to_variant(),
+    ))
+}
+
+#[bench]
+fn variant_from_rid() -> Variant {
+    black_box(Rid::new(12345)).to_variant()
+}
+
+#[bench]
+fn variant_to_rid() -> Rid {
+    Rid::from_variant(black_box(&Rid::new(12345).to_variant()))
+}
+
+// Lifecycle: nil construction, clone, drop.
+
+#[bench]
+fn variant_nil_ctor() -> Variant {
+    Variant::nil()
+}
+
+#[bench]
+fn variant_clone_i64() -> Variant {
+    let v = black_box(12345_i64).to_variant();
+    black_box(&v).clone()
+}
+
+#[bench]
+fn variant_clone_vector3() -> Variant {
+    let v = black_box(Vector3::new(1.0, 2.0, 3.0)).to_variant();
+    black_box(&v).clone()
+}
+
+#[bench(manual)]
+fn variant_drop_i64_x1000() -> BenchResult {
+    bench_measure(1, || {
+        let mut count = 0_i64;
+        for i in 0..1000_i64 {
+            let v = black_box(i).to_variant();
+            count += 1;
+            drop(black_box(v));
+        }
+        black_box(count)
+    })
+}
+
+#[bench(manual)]
+fn variant_drop_vector3_x1000() -> BenchResult {
+    bench_measure(1, || {
+        let mut count = 0_i32;
+        for i in 0..1000_i32 {
+            let v = black_box(Vector3::new(i as f32, i as f32, i as f32)).to_variant();
+            count += 1;
+            drop(black_box(v));
+        }
+        black_box(count)
+    })
+}
+
+// Bulk round-trips (representative of real use: many values through variants).
+
+#[bench(manual)]
+fn variant_roundtrip_i64_x1000() -> BenchResult {
+    bench_measure(1, || {
+        let mut sum = 0i64;
+        for i in 0..1000_i64 {
+            let v = black_box(i).to_variant();
+            sum = sum.wrapping_add(i64::from_variant(black_box(&v)));
+        }
+        black_box(sum)
+    })
+}
+
+#[bench(manual)]
+fn variant_roundtrip_vector3_x1000() -> BenchResult {
+    bench_measure(1, || {
+        let mut result = Vector3::ZERO;
+        for i in 0..1000_i32 {
+            let v = black_box(Vector3::new(i as f32, i as f32 * 2.0, i as f32 * 3.0)).to_variant();
+            result += Vector3::from_variant(black_box(&v));
+        }
+        black_box(result)
+    })
+}