Simplify how variants are handled (#877)

crates/rune-alloc/src/error.rs

@@ -1,5 +1,6 @@
 //! Error types used by rune alloc.
 
+use core::alloc::LayoutError;
 use core::convert::Infallible;
 use core::fmt;
 
@@ -65,6 +66,13 @@ impl From<Infallible> for Error {
     }
 }
 
+impl From<LayoutError> for Error {
+    #[inline]
+    fn from(_: LayoutError) -> Self {
+        Error::LayoutError
+    }
+}
+
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {

crates/rune-core/src/item/component_ref.rs

@@ -22,9 +22,7 @@ pub enum ComponentRef<'a> {
 }
 
 impl<'a> ComponentRef<'a> {
-    /// Get the component as a string.
-    #[cfg(feature = "doc")]
-    #[doc(hidden)]
+    /// Get the component as a `&str` reference.
     pub fn as_str(&self) -> Option<&'a str> {
         match self {
             ComponentRef::Str(string) => Some(string),

crates/rune-core/src/item/item.rs

@@ -211,6 +211,14 @@ impl Item {
         self.iter().next_back()
     }
 
+    /// Access the base name of the item if available.
+    ///
+    /// The base name is the last string component of the item.
+    #[inline]
+    pub fn base_name(&self) -> Option<&str> {
+        self.iter().next_back()?.as_str()
+    }
+
     /// An iterator over the [Component]s that constitute this item.
     ///
     /// # Examples

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

@@ -78,7 +78,7 @@ impl Expander<'_> {
             #[automatically_derived]
             impl #from_value for #ident {
                 fn from_value(value: #value) -> #result<Self, #runtime_error> {
-                    match #value::into_type_value(value)? {
+                    match #value::as_type_value(&value)? {
                         #expanded
                         actual => {
                             #result::Err(#runtime_error::expected::<#expected>(#type_value::type_info(&actual)))
@@ -104,7 +104,6 @@ impl Expander<'_> {
         let Tokens {
             type_value,
             from_value,
-            variant_data,
             value,
             result,
             runtime_error,
@@ -145,27 +144,31 @@ impl Expander<'_> {
         };
 
         let variant = quote! {
-            #type_value::Variant(variant) => {
-                let mut it = variant.rtti().item.iter();
+            #type_value::EmptyStruct(data) => {
+                let Some(name) = data.rtti().item().base_name() else {
+                    return #result::Err(#runtime_error::__rune_macros__missing_variant_name());
+                };
 
-                let Some(name) = it.next_back_str() else {
+                match name {
+                    #(#unit_matches,)* #missing,
+                }
+            }
+            #type_value::TupleStruct(tuple) => {
+                let Some(name) = tuple.rtti().item().base_name() 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 {
+                    #(#unnamed_matches,)* #missing,
+                }
+            }
+            #type_value::Struct(object) => {
+                let Some(name) = object.rtti().item().base_name() else {
+                    return #result::Err(#runtime_error::__rune_macros__missing_variant_name());
+                };
+
+                match name {
+                    #(#named_matches,)* #missing,
                 }
             }
         };
@@ -174,7 +177,7 @@ impl Expander<'_> {
             #[automatically_derived]
             impl #from_value for #ident {
                 fn from_value(value: #value) -> #result<Self, #runtime_error> {
-                    match #value::into_type_value(value)? {
+                    match #value::as_type_value(&value)? {
                         #variant,
                         actual => {
                             #result::Err(#runtime_error::__rune_macros__expected_variant(#type_value::type_info(&actual)))

crates/rune/benches/bf.rn

@@ -0,0 +1,116 @@
+enum Op {
+    Inc(v),
+    Move(v),
+    Loop(ops),
+    Input,
+    Print,
+}
+
+struct Tape {
+    pos,
+    tape,
+}
+
+impl Tape {
+    fn new() {
+        Tape { pos: 0, tape: [0] }
+    }
+
+    fn get(self) {
+        self.tape[self.pos]
+    }
+
+    fn inc(self, x) {
+        self.tape[self.pos] = (self.tape[self.pos] + x) % 256;
+
+        if self.tape[self.pos] < 0 {
+            self.tape[self.pos] = self.tape[self.pos] + 256;
+        }
+    }
+
+    fn mov(self, x) {
+        self.pos += x;
+
+        while self.pos >= self.tape.len() {
+            self.tape.push(0);
+        }
+    }
+
+    fn set(self, v) {
+        self.tape[self.pos] = v;
+    }
+}
+
+fn run(program, tape, inputs) {
+    for op in program {
+        match op {
+            Op::Inc(x) => tape.inc(x),
+            Op::Move(x) => tape.mov(x),
+            Op::Loop(program) => while tape.get() != 0 {
+                run(program, tape, inputs);
+            },
+            Op::Print => {
+                let c = char::from_i64(tape.get()).expect("A valid char");
+                print!("{c}");
+            }
+            Op::Input => {
+                tape.set(0)
+            }
+        }
+    }
+}
+
+fn parse(it) {
+    let buf = Vec::new();
+
+    while let Some(c) = it.next() {
+        let op = match c {
+            '+' => Op::Inc(1),
+            '-' => Op::Inc(-1),
+            '>' => Op::Move(1),
+            '<' => Op::Move(-1),
+            '.' => Op::Print,
+            '[' => Op::Loop(parse(it)),
+            ',' => Op::Input,
+            ']' => break,
+            _ => continue,
+        };
+
+        buf.push(op);
+    }
+
+    buf
+}
+
+struct Program {
+    ops,
+    inputs,
+}
+
+impl Program {
+    fn new(code, inputs) {
+        Program { ops: parse(code), inputs }
+    }
+
+    fn run(self) {
+        let tape = Tape::new();
+        run(self.ops, tape, self.inputs);
+    }
+}
+
+fn bf(s, i) {
+    let program = Program::new(s.chars(), i);
+    program.run();
+}
+
+#[bench]
+pub fn bf_hello_world(b) {
+    b.iter(
+        || {
+            bf(
+                "++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.",
+                0,
+            )
+        },
+    )
+}

crates/rune/benches/fib.rn

@@ -0,0 +1,17 @@
+fn fib(n) {
+    if n <= 1 {
+        n
+    } else {
+        fib(n - 2) + fib(n - 1)
+    }
+}
+
+#[bench]
+pub fn fib15(b) {
+    b.iter(|| fib(15));
+}
+
+#[bench]
+pub fn fib20(b) {
+    b.iter(|| fib(20));
+}

crates/rune/benches/primes.rn

@@ -0,0 +1,31 @@
+const MAX_NUMBER_TO_CHECK = 10_000;
+
+#[bench]
+pub fn primes(b) {
+    b.iter(
+        || {
+            let prime_mask = [];
+
+            prime_mask.resize(MAX_NUMBER_TO_CHECK, true);
+
+            prime_mask[0] = false;
+            prime_mask[1] = false;
+
+            let total_primes_found = 0;
+
+            for p in 2..MAX_NUMBER_TO_CHECK {
+                if prime_mask[p] {
+                    total_primes_found += 1;
+                    let i = 2 * p;
+
+                    while i < MAX_NUMBER_TO_CHECK {
+                        prime_mask[i] = false;
+                        i += p;
+                    }
+                }
+            }
+
+            total_primes_found
+        },
+    );
+}