rune: Remove distinction in dynamic variants

crates/rune-macros/src/context.rs

@@ -775,7 +775,6 @@ impl Context {
             value_mut_guard: path(m, ["runtime", "ValueMutGuard"]),
             value_ref_guard: path(m, ["runtime", "ValueRefGuard"]),
             value: path(m, ["runtime", "Value"]),
-            variant_data: path(m, ["runtime", "VariantData"]),
             vec: path(m, ["alloc", "Vec"]),
             vm_result: path(m, ["runtime", "VmResult"]),
             vm_try: path(m, ["vm_try"]),
@@ -870,7 +869,6 @@ pub(crate) struct Tokens {
     pub(crate) value_mut_guard: syn::Path,
     pub(crate) value_ref_guard: syn::Path,
     pub(crate) value: syn::Path,
-    pub(crate) variant_data: syn::Path,
     pub(crate) vec: syn::Path,
     pub(crate) vm_result: syn::Path,
     pub(crate) vm_try: syn::Path,

crates/rune-macros/src/from_value.rs

@@ -104,7 +104,6 @@ impl Expander<'_> {
         let Tokens {
             type_value,
             from_value,
-            variant_data,
             value,
             result,
             runtime_error,
@@ -145,27 +144,37 @@ impl Expander<'_> {
         };
 
         let variant = quote! {
-            #type_value::Variant(variant) => {
-                let mut it = variant.rtti().item.iter();
+            #type_value::EmptyStruct(data) => {
+                let mut it = data.rtti().item.iter();
 
                 let Some(name) = it.next_back_str() else {
                     return #result::Err(#runtime_error::__rune_macros__missing_variant_name());
                 };
 
-                match variant.data() {
-                    #variant_data::Empty => match name {
-                        #(#unit_matches,)* #missing,
-                    },
-                    #variant_data::Tuple(tuple) => match name {
-                        #(#unnamed_matches,)* #missing,
-                    },
-                    #variant_data::Struct(data) => {
-                        let object = variant.accessor(data);
-
-                        match name {
-                            #(#named_matches,)* #missing,
-                        }
-                    }
+                match name {
+                    #(#unit_matches,)* #missing,
+                }
+            }
+            #type_value::TupleStruct(tuple) => {
+                let mut it = tuple.rtti().item.iter();
+
+                let Some(name) = it.next_back_str() else {
+                    return #result::Err(#runtime_error::__rune_macros__missing_variant_name());
+                };
+
+                match name {
+                    #(#unnamed_matches,)* #missing,
+                }
+            }
+            #type_value::Struct(object) => {
+                let mut it = object.rtti().item.iter();
+
+                let Some(name) = it.next_back_str() else {
+                    return #result::Err(#runtime_error::__rune_macros__missing_variant_name());
+                };
+
+                match name {
+                    #(#named_matches,)* #missing,
                 }
             }
         };

crates/rune/src/compile/context.rs

@@ -771,7 +771,7 @@ impl Context {
                             item: item.try_clone()?,
                             hash,
                             type_check: None,
-                            type_info: TypeInfo::typed(Arc::new(Rtti {
+                            type_info: TypeInfo::rtti(Arc::new(Rtti {
                                 hash: ty.hash,
                                 variant_hash: hash,
                                 item: item.try_clone()?,

crates/rune/src/compile/unit_builder.rs

@@ -496,7 +496,7 @@ impl UnitBuilder {
                     ));
                 }
 
-                let info = UnitFn::UnitVariant { hash: meta.hash };
+                let info = UnitFn::EmptyStruct { hash: meta.hash };
 
                 let signature = DebugSignature::new(
                     pool.item(meta.item_meta.item).try_to_owned()?,
@@ -545,7 +545,7 @@ impl UnitBuilder {
                     ));
                 }
 
-                let info = UnitFn::TupleVariant {
+                let info = UnitFn::TupleStruct {
                     hash: meta.hash,
                     args,
                 };

crates/rune/src/compile/v1/assemble.rs

@@ -2527,7 +2527,7 @@ fn expr_object<'a, 'hir>(
                     span,
                 )?;
             }
-            hir::ExprObjectKind::Struct { hash } => {
+            hir::ExprObjectKind::Struct { hash } | hir::ExprObjectKind::StructVariant { hash } => {
                 cx.asm.push(
                     Inst::Struct {
                         addr: linear.addr(),
@@ -2537,16 +2537,6 @@ fn expr_object<'a, 'hir>(
                     span,
                 )?;
             }
-            hir::ExprObjectKind::StructVariant { hash } => {
-                cx.asm.push(
-                    Inst::StructVariant {
-                        addr: linear.addr(),
-                        hash,
-                        out: needs.alloc_output()?,
-                    },
-                    span,
-                )?;
-            }
             hir::ExprObjectKind::ExternalType { hash, args } => {
                 reorder_field_assignments(cx, hir, linear.addr(), span)?;
 

crates/rune/src/runtime/function.rs

@@ -16,8 +16,8 @@ use crate::Hash;
 
 use super::{
     Args, Call, ConstValue, Formatter, FromValue, FunctionHandler, GuardedArgs, InstAddress,
-    Output, OwnedTuple, Rtti, RuntimeContext, RuntimeError, Stack, Unit, Value, Vm, VmCall,
-    VmErrorKind, VmHalt, VmResult,
+    Output, OwnedTuple, Rtti, RuntimeContext, RuntimeError, Stack, TupleStruct, Unit, Value, Vm,
+    VmCall, VmErrorKind, VmHalt, VmResult,
 };
 
 /// The type of a function in Rune.
@@ -255,16 +255,6 @@ impl Function {
         Self(FunctionImpl::from_tuple_struct(rtti, args))
     }
 
-    /// Create a function pointer that constructs a empty variant.
-    pub(crate) fn from_unit_variant(rtti: Arc<Rtti>) -> Self {
-        Self(FunctionImpl::from_unit_variant(rtti))
-    }
-
-    /// Create a function pointer that constructs a tuple variant.
-    pub(crate) fn from_tuple_variant(rtti: Arc<Rtti>, args: usize) -> Self {
-        Self(FunctionImpl::from_tuple_variant(rtti, args))
-    }
-
     /// Type [Hash][struct@Hash] of the underlying function.
     ///
     /// # Examples
@@ -581,16 +571,6 @@ where
                 let (args, _guard) = vm_try!(unsafe { args.guarded_into_vec() });
                 vm_try!(Value::tuple_struct(tuple.rtti.clone(), args))
             }
-            Inner::FnUnitVariant(unit) => {
-                vm_try!(check_args(args.count(), 0));
-                vm_try!(Value::unit_variant(unit.rtti.clone()))
-            }
-            Inner::FnTupleVariant(tuple) => {
-                vm_try!(check_args(args.count(), tuple.args));
-                // SAFETY: We don't let the guard outlive the value.
-                let (args, _guard) = vm_try!(unsafe { args.guarded_into_vec() });
-                vm_try!(Value::tuple_variant(tuple.rtti.clone(), args))
-            }
         };
 
         VmResult::Ok(vm_try!(T::from_value(value)))
@@ -667,30 +647,13 @@ where
                 vm_try!(check_args(args, tuple.args));
 
                 let seq = vm_try!(vm.stack().slice_at(addr, args));
-                let seq = vm_try!(seq.iter().cloned().try_collect());
+                let data = vm_try!(seq.iter().cloned().try_collect());
 
-                vm_try!(out.store(vm.stack_mut(), || {
-                    Value::tuple_struct(tuple.rtti.clone(), seq)
+                vm_try!(out.store(vm.stack_mut(), || TupleStruct {
+                    rtti: tuple.rtti.clone(),
+                    data
                 }));
 
-                None
-            }
-            Inner::FnUnitVariant(tuple) => {
-                vm_try!(check_args(args, 0));
-                vm_try!(out.store(vm.stack_mut(), || Value::unit_variant(tuple.rtti.clone())));
-                None
-            }
-            Inner::FnTupleVariant(tuple) => {
-                vm_try!(check_args(args, tuple.args));
-
-                let seq = vm_try!(vm.stack().slice_at(addr, args));
-                let seq = vm_try!(seq.iter().cloned().try_collect());
-
-                vm_try!(out.store(vm.stack_mut(), || Value::tuple_variant(
-                    tuple.rtti.clone(),
-                    seq
-                )));
-
                 None
             }
         };
@@ -765,31 +728,15 @@ where
         }
     }
 
-    /// Create a function pointer that constructs a empty variant.
-    pub(crate) fn from_unit_variant(rtti: Arc<Rtti>) -> Self {
-        Self {
-            inner: Inner::FnUnitVariant(FnUnitVariant { rtti }),
-        }
-    }
-
-    /// Create a function pointer that constructs a tuple variant.
-    pub(crate) fn from_tuple_variant(rtti: Arc<Rtti>, args: usize) -> Self {
-        Self {
-            inner: Inner::FnTupleVariant(FnTupleVariant { rtti, args }),
-        }
-    }
-
     #[inline]
     fn type_hash(&self) -> Hash {
         match &self.inner {
             Inner::FnHandler(FnHandler { hash, .. }) | Inner::FnOffset(FnOffset { hash, .. }) => {
                 *hash
             }
             Inner::FnClosureOffset(fco) => fco.fn_offset.hash,
-            Inner::FnUnitStruct(func) => func.rtti.hash,
-            Inner::FnTupleStruct(func) => func.rtti.hash,
-            Inner::FnUnitVariant(func) => func.rtti.hash,
-            Inner::FnTupleVariant(func) => func.rtti.hash,
+            Inner::FnUnitStruct(func) => func.rtti.type_hash(),
+            Inner::FnTupleStruct(func) => func.rtti.type_hash(),
         }
     }
 }
@@ -814,8 +761,6 @@ impl FunctionImpl<Value> {
             Inner::FnOffset(inner) => Inner::FnOffset(inner),
             Inner::FnUnitStruct(inner) => Inner::FnUnitStruct(inner),
             Inner::FnTupleStruct(inner) => Inner::FnTupleStruct(inner),
-            Inner::FnUnitVariant(inner) => Inner::FnUnitVariant(inner),
-            Inner::FnTupleVariant(inner) => Inner::FnTupleVariant(inner),
         };
 
         Ok(FunctionImpl { inner })
@@ -844,12 +789,6 @@ impl fmt::Debug for Function {
             Inner::FnTupleStruct(tuple) => {
                 write!(f, "tuple {}", tuple.rtti.item)?;
             }
-            Inner::FnUnitVariant(empty) => {
-                write!(f, "variant empty {}", empty.rtti.item)?;
-            }
-            Inner::FnTupleVariant(tuple) => {
-                write!(f, "variant tuple {}", tuple.rtti.item)?;
-            }
         }
 
         Ok(())
@@ -875,10 +814,6 @@ enum Inner<V> {
     FnUnitStruct(FnUnitStruct),
     /// Constructor for a tuple.
     FnTupleStruct(FnTupleStruct),
-    /// Constructor for an empty variant.
-    FnUnitVariant(FnUnitVariant),
-    /// Constructor for a tuple variant.
-    FnTupleVariant(FnTupleVariant),
 }
 
 impl<V> TryClone for Inner<V>
@@ -892,8 +827,6 @@ where
             Inner::FnClosureOffset(inner) => Inner::FnClosureOffset(inner.try_clone()?),
             Inner::FnUnitStruct(inner) => Inner::FnUnitStruct(inner.clone()),
             Inner::FnTupleStruct(inner) => Inner::FnTupleStruct(inner.clone()),
-            Inner::FnUnitVariant(inner) => Inner::FnUnitVariant(inner.clone()),
-            Inner::FnTupleVariant(inner) => Inner::FnTupleVariant(inner.clone()),
         })
     }
 }
@@ -1029,20 +962,6 @@ struct FnTupleStruct {
     args: usize,
 }
 
-#[derive(Debug, Clone, TryClone)]
-struct FnUnitVariant {
-    /// Runtime information fo variant.
-    rtti: Arc<Rtti>,
-}
-
-#[derive(Debug, Clone, TryClone)]
-struct FnTupleVariant {
-    /// Runtime information fo variant.
-    rtti: Arc<Rtti>,
-    /// The number of arguments the tuple takes.
-    args: usize,
-}
-
 impl FromValue for SyncFunction {
     #[inline]
     fn from_value(value: Value) -> Result<Self, RuntimeError> {

crates/rune/src/runtime/inst.rs

@@ -664,27 +664,6 @@ pub enum Inst {
         /// Where to write the constructed struct.
         out: Output,
     },
-    /// Construct a push an object variant of the given type onto the stack. The
-    /// number of elements in the object are determined the slot of the object
-    /// keys `slot` and are popped from the stack.
-    ///
-    /// For each element, a value is popped corresponding to the object key.
-    ///
-    /// # Operation
-    ///
-    /// ```text
-    /// <value..>
-    /// => <object>
-    /// ```
-    #[musli(packed)]
-    StructVariant {
-        /// The address to load fields from.
-        addr: InstAddress,
-        /// The type hash of the object variant to construct.
-        hash: Hash,
-        /// Where to write the constructed variant.
-        out: Output,
-    },
     /// Load a literal string from a static string slot.
     ///
     /// # Operation

crates/rune/src/runtime/mod.rs

@@ -165,10 +165,7 @@ pub use self::value::{
     Accessor, EmptyStruct, Inline, RawValueGuard, Rtti, Struct, TupleStruct, TypeValue, Value,
     ValueMutGuard, ValueRefGuard,
 };
-pub(crate) use self::value::{Mutable, ReprMut, ReprOwned, ReprRef};
-
-mod variant;
-pub use self::variant::{Variant, VariantData};
+pub(crate) use self::value::{Mutable, ReprMut, ReprRef};
 
 pub mod slice;
 

crates/rune/src/runtime/stack.rs

@@ -609,6 +609,7 @@ impl TryClone for Stack {
 }
 
 impl TryFromIteratorIn<Value, Global> for Stack {
+    #[inline]
     fn try_from_iter_in<T: IntoIterator<Item = Value>>(
         iter: T,
         alloc: Global,

crates/rune/src/runtime/tuple.rs

@@ -8,6 +8,7 @@ use crate::alloc::alloc::Global;
 use crate::alloc::borrow::TryToOwned;
 use crate::alloc::clone::TryClone;
 use crate::alloc::fmt::TryWrite;
+use crate::alloc::iter::{IteratorExt, TryFromIteratorIn};
 use crate::alloc::{self, Box};
 use crate::Any;
 
@@ -345,6 +346,18 @@ impl TryFrom<::rust_alloc::boxed::Box<[ConstValue]>> for OwnedTuple {
     }
 }
 
+impl TryFromIteratorIn<Value, Global> for OwnedTuple {
+    #[inline]
+    fn try_from_iter_in<T: IntoIterator<Item = Value>>(
+        iter: T,
+        alloc: Global,
+    ) -> alloc::Result<Self> {
+        Ok(Self {
+            inner: iter.into_iter().try_collect_in(alloc)?,
+        })
+    }
+}
+
 macro_rules! impl_tuple {
     // Skip conflicting implementation with `()`.
     (0) => {