Add ExtVariantType: distinguish between Variant/Nil types

Author: Bromeon

godot-core/src/builtin/aabb.rs

@@ -6,7 +6,7 @@
  */
 
 use godot_ffi as sys;
-use sys::{ffi_methods, GodotFfi};
+use sys::{ffi_methods, ExtVariantType, GodotFfi};
 
 use crate::builtin::math::ApproxEq;
 use crate::builtin::{real, Plane, Vector3, Vector3Axis};
@@ -448,7 +448,7 @@ impl std::fmt::Display for Aabb {
 // SAFETY:
 // This type is represented as `Self` in Godot, so `*mut Self` is sound.
 unsafe impl GodotFfi for Aabb {
-    const VARIANT_TYPE: sys::VariantType = sys::VariantType::AABB;
+    const VARIANT_TYPE: ExtVariantType = ExtVariantType::Concrete(sys::VariantType::AABB);
 
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }

godot-core/src/builtin/basis.rs

@@ -6,7 +6,7 @@
  */
 
 use godot_ffi as sys;
-use sys::{ffi_methods, GodotFfi};
+use sys::{ffi_methods, ExtVariantType, GodotFfi};
 
 use crate::builtin::math::{ApproxEq, FloatExt, GlamConv, GlamType, XformInv};
 use crate::builtin::real_consts::FRAC_PI_2;
@@ -631,7 +631,7 @@ impl XformInv<Vector3> for Basis {
 // SAFETY:
 // This type is represented as `Self` in Godot, so `*mut Self` is sound.
 unsafe impl GodotFfi for Basis {
-    const VARIANT_TYPE: sys::VariantType = sys::VariantType::BASIS;
+    const VARIANT_TYPE: ExtVariantType = ExtVariantType::Concrete(sys::VariantType::BASIS);
 
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }

godot-core/src/builtin/callable.rs

@@ -14,7 +14,7 @@ use crate::obj::bounds::DynMemory;
 use crate::obj::Bounds;
 use crate::obj::{Gd, GodotClass, InstanceId};
 use std::{fmt, ptr};
-use sys::{ffi_methods, GodotFfi};
+use sys::{ffi_methods, ExtVariantType, GodotFfi};
 
 #[cfg(all(since_api = "4.2", before_api = "4.3"))]
 type CallableCustomInfo = sys::GDExtensionCallableCustomInfo;
@@ -441,7 +441,7 @@ impl_builtin_traits! {
 // The `opaque` in `Callable` is just a pair of pointers, and requires no special initialization or cleanup
 // beyond what is done in `from_opaque` and `drop`. So using `*mut Opaque` is safe.
 unsafe impl GodotFfi for Callable {
-    const VARIANT_TYPE: sys::VariantType = sys::VariantType::CALLABLE;
+    const VARIANT_TYPE: ExtVariantType = ExtVariantType::Concrete(sys::VariantType::CALLABLE);
 
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Opaque;
         fn new_from_sys;

godot-core/src/builtin/collections/array.rs

@@ -13,8 +13,8 @@ use crate::meta;
 use crate::meta::error::{ConvertError, FromGodotError, FromVariantError};
 use crate::meta::{
     element_godot_type_name, element_variant_type, ArrayElement, ArrayTypeInfo, AsArg, ClassName,
-    CowArg, FromGodot, GodotConvert, GodotFfiVariant, GodotType, ParamType, PropertyHintInfo,
-    RefArg, ToGodot,
+    CowArg, ExtVariantType, FromGodot, GodotConvert, GodotFfiVariant, GodotType, ParamType,
+    PropertyHintInfo, RefArg, ToGodot,
 };
 use crate::obj::{bounds, Bounds, DynGd, Gd, GodotClass};
 use crate::registry::property::{BuiltinExport, Export, Var};
@@ -1110,7 +1110,7 @@ impl VariantArray {
 //   Arrays are properly initialized through a `from_sys` call, but the ref-count should be incremented
 //   as that is the callee's responsibility. Which we do by calling `std::mem::forget(array.clone())`.
 unsafe impl<T: ArrayElement> GodotFfi for Array<T> {
-    const VARIANT_TYPE: VariantType = VariantType::ARRAY;
+    const VARIANT_TYPE: ExtVariantType = ExtVariantType::Concrete(VariantType::ARRAY);
 
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Opaque; .. }
 }
@@ -1371,9 +1371,9 @@ impl<T: ArrayElement> GodotFfiVariant for Array<T> {
 
     fn ffi_from_variant(variant: &Variant) -> Result<Self, ConvertError> {
         // First check if the variant is an array. The array conversion shouldn't be called otherwise.
-        if variant.get_type() != Self::VARIANT_TYPE {
+        if variant.get_type() != Self::VARIANT_TYPE.variant_as_nil() {
             return Err(FromVariantError::BadType {
-                expected: Self::VARIANT_TYPE,
+                expected: Self::VARIANT_TYPE.variant_as_nil(),
                 actual: variant.get_type(),
             }
             .into_error(variant.clone()));

godot-core/src/builtin/collections/dictionary.rs

@@ -8,7 +8,7 @@
 use godot_ffi as sys;
 
 use crate::builtin::{inner, Variant, VariantArray};
-use crate::meta::{FromGodot, ToGodot};
+use crate::meta::{ExtVariantType, FromGodot, ToGodot};
 use sys::types::OpaqueDictionary;
 use sys::{ffi_methods, interface_fn, GodotFfi};
 
@@ -394,7 +394,7 @@ impl Dictionary {
 //   incremented as that is the callee's responsibility. Which we do by calling
 //   `std::mem::forget(dictionary.clone())`.
 unsafe impl GodotFfi for Dictionary {
-    const VARIANT_TYPE: sys::VariantType = sys::VariantType::DICTIONARY;
+    const VARIANT_TYPE: ExtVariantType = ExtVariantType::Concrete(sys::VariantType::DICTIONARY);
 
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Opaque; .. }
 }

godot-core/src/builtin/collections/packed_array.rs

@@ -17,7 +17,7 @@ use crate::meta::{AsArg, ToGodot};
 use std::mem::size_of;
 use std::{fmt, ops, ptr};
 use sys::types::*;
-use sys::{ffi_methods, interface_fn, GodotFfi};
+use sys::{ffi_methods, interface_fn, ExtVariantType, GodotFfi};
 
 use crate::classes::file_access::CompressionMode;
 use crate::meta;
@@ -625,7 +625,7 @@ macro_rules! impl_packed_array {
         }
 
         unsafe impl GodotFfi for $PackedArray {
-            const VARIANT_TYPE: sys::VariantType = sys::VariantType::$VariantType;
+            const VARIANT_TYPE: ExtVariantType = ExtVariantType::Concrete(sys::VariantType::$VariantType);
 
             ffi_methods! { type sys::GDExtensionTypePtr = *mut Opaque; .. }
         }

godot-core/src/builtin/color.rs

@@ -13,7 +13,7 @@ use crate::builtin::{ColorHsv, GString};
 use crate::meta::{arg_into_ref, AsArg};
 use godot_ffi as sys;
 use std::ops;
-use sys::{ffi_methods, GodotFfi};
+use sys::{ffi_methods, ExtVariantType, GodotFfi};
 
 /// Color built-in type, in floating-point RGBA format.
 ///
@@ -358,7 +358,7 @@ impl Color {
 // SAFETY:
 // This type is represented as `Self` in Godot, so `*mut Self` is sound.
 unsafe impl GodotFfi for Color {
-    const VARIANT_TYPE: sys::VariantType = sys::VariantType::COLOR;
+    const VARIANT_TYPE: ExtVariantType = ExtVariantType::Concrete(sys::VariantType::COLOR);
 
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }

godot-core/src/builtin/plane.rs

@@ -6,7 +6,7 @@
  */
 
 use godot_ffi as sys;
-use sys::{ffi_methods, GodotFfi};
+use sys::{ffi_methods, ExtVariantType, GodotFfi};
 
 use crate::builtin::math::{ApproxEq, FloatExt};
 use crate::builtin::{real, Vector3};
@@ -265,7 +265,7 @@ impl Neg for Plane {
 // SAFETY:
 // This type is represented as `Self` in Godot, so `*mut Self` is sound.
 unsafe impl GodotFfi for Plane {
-    const VARIANT_TYPE: sys::VariantType = sys::VariantType::PLANE;
+    const VARIANT_TYPE: ExtVariantType = ExtVariantType::Concrete(sys::VariantType::PLANE);
 
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self;
         fn new_from_sys;

godot-core/src/builtin/projection.rs

@@ -6,7 +6,7 @@
  */
 
 use godot_ffi as sys;
-use sys::{ffi_methods, GodotFfi};
+use sys::{ffi_methods, ExtVariantType, GodotFfi};
 
 use crate::builtin::inner::InnerProjection;
 use crate::builtin::math::{ApproxEq, GlamConv, GlamType};
@@ -557,7 +557,7 @@ impl GlamConv for Projection {
 
 // SAFETY: This type is represented as `Self` in Godot, so `*mut Self` is sound.
 unsafe impl GodotFfi for Projection {
-    const VARIANT_TYPE: sys::VariantType = sys::VariantType::PROJECTION;
+    const VARIANT_TYPE: ExtVariantType = ExtVariantType::Concrete(sys::VariantType::PROJECTION);
 
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }

godot-core/src/builtin/quaternion.rs

@@ -6,7 +6,7 @@
  */
 
 use godot_ffi as sys;
-use sys::{ffi_methods, GodotFfi};
+use sys::{ffi_methods, ExtVariantType, GodotFfi};
 
 use crate::builtin::math::{ApproxEq, FloatExt, GlamConv, GlamType};
 use crate::builtin::{inner, real, Basis, EulerOrder, RQuat, RealConv, Vector3};
@@ -337,7 +337,7 @@ impl Mul<Vector3> for Quaternion {
 // SAFETY:
 // This type is represented as `Self` in Godot, so `*mut Self` is sound.
 unsafe impl GodotFfi for Quaternion {
-    const VARIANT_TYPE: sys::VariantType = sys::VariantType::QUATERNION;
+    const VARIANT_TYPE: ExtVariantType = ExtVariantType::Concrete(sys::VariantType::QUATERNION);
 
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }