macros: Cleaner macros (#880)

crates/rune-macros/src/lib.rs

@@ -24,19 +24,13 @@
 
 #![allow(clippy::manual_map)]
 
-use ::quote::format_ident;
-use syn::{Generics, Path};
-
-extern crate proc_macro;
-
 mod any;
 mod const_value;
 mod context;
 mod from_value;
 mod function;
 mod hash;
 mod inst_display;
-mod internals;
 mod item;
 mod macro_;
 mod module;
@@ -49,7 +43,12 @@ mod to_tokens;
 mod to_value;
 
 use self::context::{Context, Tokens};
+
+use ::quote::format_ident;
 use proc_macro2::TokenStream;
+use syn::{Generics, Path};
+
+const RUNE: &str = "rune";
 
 #[proc_macro]
 pub fn quote(input: proc_macro::TokenStream) -> proc_macro::TokenStream {

crates/rune-macros/src/parse.rs

@@ -128,11 +128,8 @@ impl Expander<'_> {
             if i - skipped != meta_fields.len() {
                 self.cx.error(syn::Error::new_spanned(
                     field,
-                    format!(
-                        "The first sequence of fields may have `#[rune({})]`, \
+                    "The first sequence of fields may have `#[rune(meta)]`, \
                         but field is outside of that sequence.",
-                        crate::internals::META,
-                    ),
                 ));
                 return Err(());
             }

crates/rune-macros/src/quote/inner.rs

@@ -1,10 +1,10 @@
 use proc_macro2 as p;
 
 pub(crate) const S: Punct = Punct::new("::");
-pub(crate) const RUNE: &str = "rune";
 pub(crate) const MACROS: RuneModule = RuneModule("macros");
 pub(crate) const AST: RuneModule = RuneModule("ast");
 
+use crate::RUNE;
 pub(crate) trait ToTokens {
     fn to_tokens(self, stream: &mut p::TokenStream, span: p::Span);
 }

crates/rune/src/function/mod.rs

@@ -8,8 +8,8 @@ use crate::alloc;
 use crate::compile::meta;
 use crate::hash::Hash;
 use crate::runtime::{
-    self, AnyTypeInfo, FromValue, InstAddress, MaybeTypeOf, Memory, Output, ToReturn, TypeHash,
-    TypeOf, UnsafeToMut, UnsafeToRef, Value, VmErrorKind, VmResult,
+    self, AnyTypeInfo, FromValue, InstAddress, MaybeTypeOf, Memory, Output, RuntimeError, ToReturn,
+    TypeHash, TypeOf, UnsafeToMut, UnsafeToRef, Value, VmErrorKind, VmResult,
 };
 
 // Expand to function variable bindings.
@@ -29,9 +29,14 @@ macro_rules! access_memory {
         $(let $var = replace($var, Value::empty());)*
 
         $(
-            let $var = vm_try!($from_fn($var).with_error(|| VmErrorKind::BadArgument {
-                arg: $num,
-            }));
+            let $var = match $from_fn($var) {
+                Ok($var) => $var,
+                Err(error) => {
+                    return VmResult::err(error).with_error(|| VmErrorKind::BadArgument {
+                        arg: $num,
+                    });
+                }
+            };
         )*
     };
 }
@@ -195,14 +200,16 @@ where
 // Fake guard for owned values.
 struct Guard;
 
-fn from_value<T>(value: Value) -> VmResult<(T, Guard)>
+#[inline(always)]
+fn from_value<T>(value: Value) -> Result<(T, Guard), RuntimeError>
 where
     T: FromValue,
 {
-    VmResult::Ok((vm_try!(T::from_value(value)), Guard))
+    Ok((T::from_value(value)?, Guard))
 }
 
-fn unsafe_to_ref<'a, T>(value: Value) -> VmResult<(&'a T, T::Guard)>
+#[inline(always)]
+fn unsafe_to_ref<'a, T>(value: Value) -> Result<(&'a T, T::Guard), RuntimeError>
 where
     T: ?Sized + UnsafeToRef,
 {
@@ -211,7 +218,8 @@ where
     unsafe { T::unsafe_to_ref(value) }
 }
 
-fn unsafe_to_mut<'a, T>(value: Value) -> VmResult<(&'a mut T, T::Guard)>
+#[inline(always)]
+fn unsafe_to_mut<'a, T>(value: Value) -> Result<(&'a mut T, T::Guard), RuntimeError>
 where
     T: ?Sized + UnsafeToMut,
 {

crates/rune/src/internal_macros.rs

@@ -8,40 +8,6 @@ macro_rules! resolve_context {
     };
 }
 
-macro_rules! impl_one_builtin_type_of {
-    (impl $(<$($p:ident),*>)? $path:path, $ty:ty) => {
-        impl $(<$($p,)*>)* $crate::TypeHash for $ty {
-            const HASH: $crate::Hash = ::rune_macros::hash_in!(crate, $path);
-        }
-
-        impl $(<$($p,)*>)* $crate::runtime::TypeOf for $ty
-        where
-            $($($p: $crate::runtime::MaybeTypeOf,)*)*
-        {
-            const STATIC_TYPE_INFO: $crate::runtime::AnyTypeInfo = $crate::runtime::AnyTypeInfo::new(
-                {
-                    fn full_name(f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-                        write!(f, "{}", ::rune_macros::item_in!(crate, $path))
-                    }
-
-                    full_name
-                },
-                <Self as $crate::TypeHash>::HASH,
-            );
-        }
-
-        impl $(<$($p,)*>)* $crate::runtime::MaybeTypeOf for $ty
-        where
-            $($($p: $crate::runtime::MaybeTypeOf,)*)*
-        {
-            #[inline]
-            fn maybe_type_of() -> $crate::alloc::Result<$crate::compile::meta::DocType> {
-                Ok($crate::compile::meta::DocType::new(<$ty as $crate::TypeHash>::HASH))
-            }
-        }
-    }
-}
-
 /// Call the given macro with repeated type arguments and counts.
 macro_rules! repeat_macro {
     ($macro:ident) => {
@@ -86,17 +52,3 @@ macro_rules! cfg_std {
         )*
     }
 }
-
-macro_rules! impl_builtin_type_of {
-    (
-        $(
-            $(#[$($impl_meta:meta)*])*
-            impl $(<$($p:ident),*>)? $path:path, $ty:ty;
-        )*
-    ) => {
-        $(
-            $(#[$($impl_meta)*])*
-            impl_one_builtin_type_of!(impl $(<$($p),*>)* $path, $ty);
-        )*
-    }
-}