rune: Move type of implementations to one place

rune-rs · Nov 2, 2024 · 8a74413 · 8a74413
1 parent b56f04d
commit 8a74413
Show file tree

Hide file tree

Showing 16 changed files with 168 additions and 332 deletions.
diff --git a/crates/rune-macros/src/any.rs b/crates/rune-macros/src/any.rs
@@ -128,7 +128,7 @@ impl Derive {
     ) -> Result<TypeBuilder<'a, syn::Ident>, ()> {
         let mut installers = Vec::new();
 
-        expand_install_with(cx, &self.input, &tokens, &attr, &mut installers)?;
+        expand_install_with(cx, &self.input, tokens, attr, &mut installers)?;
 
         if matches!(&self.input.data, syn::Data::Enum(..)) {
             if let Some(span) = attr.constructor {
@@ -576,7 +576,7 @@ where
             non_null,
             raw_value_guard,
             result,
-            static_type_info,
+            any_type_info,
             type_hash_t,
             type_of,
             unsafe_to_mut,
@@ -680,7 +680,7 @@ where
             #(#attrs)*
             impl #impl_generics #type_of for #ident #type_generics #where_clause {
                 const PARAMETERS: #hash = #type_parameters;
-                const STATIC_TYPE_INFO: #static_type_info = #static_type_info::any_type_info(<Self as #any_t>::ANY_TYPE_INFO);
+                const STATIC_TYPE_INFO: #any_type_info = <Self as #any_t>::ANY_TYPE_INFO;
             }
 
             #[automatically_derived]

diff --git a/crates/rune-macros/src/context.rs b/crates/rune-macros/src/context.rs
@@ -720,8 +720,9 @@ impl Context {
 
         Tokens {
             alloc: path(m, ["alloc"]),
-            any_t: path(m, ["Any"]),
             any_from_t: path(m, ["__private", "AnyFrom"]),
+            any_t: path(m, ["Any"]),
+            any_type_info: path(m, ["runtime", "AnyTypeInfo"]),
             arc: path(m, ["__private", "Arc"]),
             compile_error: path(m, ["compile", "Error"]),
             const_construct_t: path(m, ["runtime", "ConstConstruct"]),
@@ -756,7 +757,6 @@ impl Context {
             runtime_error: path(m, ["runtime", "RuntimeError"]),
             span: path(m, ["ast", "Span"]),
             spanned: path(m, ["ast", "Spanned"]),
-            static_type_info: path(m, ["runtime", "StaticTypeInfo"]),
             string: path(m, ["alloc", "String"]),
             to_const_value_t: path(m, ["runtime", "ToConstValue"]),
             to_tokens: path(m, ["macros", "ToTokens"]),
@@ -817,6 +817,7 @@ pub(crate) struct Tokens {
     pub(crate) alloc: syn::Path,
     pub(crate) any_from_t: syn::Path,
     pub(crate) any_t: syn::Path,
+    pub(crate) any_type_info: syn::Path,
     pub(crate) arc: syn::Path,
     pub(crate) compile_error: syn::Path,
     pub(crate) const_construct_t: syn::Path,
@@ -851,7 +852,6 @@ pub(crate) struct Tokens {
     pub(crate) runtime_error: syn::Path,
     pub(crate) span: syn::Path,
     pub(crate) spanned: syn::Path,
-    pub(crate) static_type_info: syn::Path,
     pub(crate) string: syn::Path,
     pub(crate) to_const_value_t: syn::Path,
     pub(crate) to_tokens: syn::Path,

diff --git a/crates/rune-macros/src/lib.rs b/crates/rune-macros/src/lib.rs
@@ -42,6 +42,7 @@ mod macro_;
 mod module;
 mod opaque;
 mod parse;
+mod path_in;
 mod quote;
 mod spanned;
 mod to_tokens;
@@ -215,6 +216,20 @@ pub fn hash(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     stream.into()
 }
 
+#[doc(hidden)]
+#[proc_macro]
+pub fn hash_in(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let path_in::PathIn { in_crate, item, .. } =
+        syn::parse_macro_input!(input as path_in::PathIn<self::hash::Arguments>);
+
+    let stream = Context::build(|cx| {
+        let value = item.build_type_hash(cx)?.into_inner();
+        Ok(::quote::quote!(#in_crate::Hash(#value)))
+    });
+
+    stream.into()
+}
+
 /// Calculate an item reference at compile time.
 ///
 /// # Examples
@@ -246,6 +261,21 @@ pub fn item(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     stream.into()
 }
 
+#[proc_macro]
+#[doc(hidden)]
+pub fn item_in(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let path_in::PathIn { in_crate, item, .. } = syn::parse_macro_input!(input as path_in::PathIn);
+
+    let stream = match self::item::build_item(&item) {
+        Ok(hash) => {
+            ::quote::quote!(unsafe { #in_crate::Item::from_bytes(&#hash) })
+        }
+        Err(error) => to_compile_errors([error]),
+    };
+
+    stream.into()
+}
+
 /// Helper to generate bindings for an external type.
 ///
 /// This can *only* be used inside of the `rune` crate itself.

diff --git a/crates/rune-macros/src/path_in.rs b/crates/rune-macros/src/path_in.rs
@@ -0,0 +1,23 @@
+use syn::parse::{Parse, ParseStream};
+use syn::Token;
+
+pub(super) struct PathIn<T = syn::Path> {
+    pub(super) in_crate: syn::Path,
+    #[allow(unused)]
+    pub(super) comma_token: Token![,],
+    pub(super) item: T,
+}
+
+impl<T> Parse for PathIn<T>
+where
+    T: Parse,
+{
+    #[inline]
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        Ok(Self {
+            in_crate: input.parse()?,
+            comma_token: input.parse()?,
+            item: input.parse()?,
+        })
+    }
+}
diff --git a/crates/rune/src/compile/context.rs b/crates/rune/src/compile/context.rs
@@ -20,8 +20,8 @@ use crate::module::{
     TypeSpecification,
 };
 use crate::runtime::{
-    ConstConstruct, ConstContext, ConstValue, FunctionHandler, InstAddress, Memory, Output,
-    Protocol, RuntimeContext, StaticTypeInfo, TypeCheck, TypeInfo, VariantRtti, VmResult,
+    AnyTypeInfo, ConstConstruct, ConstContext, ConstValue, FunctionHandler, InstAddress, Memory,
+    Output, Protocol, RuntimeContext, TypeCheck, TypeInfo, VariantRtti, VmResult,
 };
 use crate::{Hash, Item, ItemBuf};
 
@@ -969,7 +969,7 @@ impl Context {
     fn install_construct(
         &mut self,
         hash: Hash,
-        type_info: &StaticTypeInfo,
+        type_info: &AnyTypeInfo,
         construct: &Arc<dyn ConstConstruct>,
     ) -> Result<(), ContextError> {
         let old = self.construct.try_insert(hash, construct.clone())?;

diff --git a/crates/rune/src/function/mod.rs b/crates/rune/src/function/mod.rs
@@ -8,7 +8,7 @@ use crate::alloc;
 use crate::compile::meta;
 use crate::hash::Hash;
 use crate::runtime::{
-    self, FromValue, InstAddress, MaybeTypeOf, Memory, Output, StaticTypeInfo, ToReturn, TypeHash,
+    self, AnyTypeInfo, FromValue, InstAddress, MaybeTypeOf, Memory, Output, ToReturn, TypeHash,
     TypeOf, UnsafeToMut, UnsafeToRef, Value, VmErrorKind, VmResult,
 };
 
@@ -161,7 +161,7 @@ where
     T: ?Sized + TypeOf,
 {
     const PARAMETERS: Hash = T::PARAMETERS;
-    const STATIC_TYPE_INFO: StaticTypeInfo = T::STATIC_TYPE_INFO;
+    const STATIC_TYPE_INFO: AnyTypeInfo = T::STATIC_TYPE_INFO;
 }
 
 /// Zero-sized marker struct for mutable references.
@@ -189,7 +189,7 @@ where
     T: ?Sized + TypeOf,
 {
     const PARAMETERS: Hash = T::PARAMETERS;
-    const STATIC_TYPE_INFO: StaticTypeInfo = T::STATIC_TYPE_INFO;
+    const STATIC_TYPE_INFO: AnyTypeInfo = T::STATIC_TYPE_INFO;
 }
 
 // Fake guard for owned values.

diff --git a/crates/rune/src/internal_macros.rs b/crates/rune/src/internal_macros.rs
@@ -8,27 +8,25 @@ macro_rules! resolve_context {
     };
 }
 
-macro_rules! impl_any_type {
-    (impl $(<$($p:ident),*>)? for $ty:ty, $path:path) => {
+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!($path);
+            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::StaticTypeInfo = $crate::runtime::StaticTypeInfo::any_type_info(
-                $crate::runtime::AnyTypeInfo::new(
-                    {
-                        fn full_name(f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-                            write!(f, "{}", ::rune_macros::item!($path))
-                        }
+            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,
-                )
+                    full_name
+                },
+                <Self as $crate::TypeHash>::HASH,
             );
         }
 
@@ -44,39 +42,6 @@ macro_rules! impl_any_type {
     }
 }
 
-/// Build an implementation of `TypeOf` basic of a static type.
-macro_rules! impl_static_type {
-    (impl $(<$($p:ident),*>)? for $ty:ty, $name:ident, $hash:ident) => {
-        impl $(<$($p,)*>)* $crate::TypeHash for $ty {
-            const HASH: $crate::Hash = $crate::runtime::static_type::$hash;
-        }
-
-        impl $(<$($p,)*>)* $crate::runtime::TypeOf for $ty
-        where
-            $(
-                $($p: $crate::runtime::MaybeTypeOf,)*
-            )*
-        {
-            const STATIC_TYPE_INFO: $crate::runtime::StaticTypeInfo = $crate::runtime::StaticTypeInfo::static_type($crate::runtime::static_type::$name);
-        }
-
-        impl $(<$($p,)*>)* $crate::runtime::MaybeTypeOf for $ty
-        where
-            $(
-                $($p: $crate::runtime::MaybeTypeOf,)*
-            )*
-        {
-            #[inline]
-            fn maybe_type_of() -> $crate::alloc::Result<$crate::compile::meta::DocType> {
-                $crate::compile::meta::DocType::with_generics(
-                    <$ty as $crate::TypeHash>::HASH,
-                    [$($(<$p as $crate::runtime::MaybeTypeOf>::maybe_type_of()?),*)*]
-                )
-            }
-        }
-    };
-}
-
 /// Call the given macro with repeated type arguments and counts.
 macro_rules! repeat_macro {
     ($macro:ident) => {
@@ -163,3 +128,17 @@ macro_rules! from_value_ref {
         }
     };
 }
+
+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);
+        )*
+    }
+}
diff --git a/crates/rune/src/lib.rs b/crates/rune/src/lib.rs
@@ -705,5 +705,64 @@ rune_macros::binding! {
     impl ::std::string::Utf8Error for core::str::Utf8Error;
 }
 
+impl_builtin_type_of! {
+    impl<T, E> ::std::result::Result, core::result::Result<T, E>;
+    impl<T> ::std::option::Option, core::option::Option<T>;
+
+    impl ::std::bool, bool;
+    impl ::std::char, char;
+
+    impl ::std::i64, i8;
+    impl ::std::i64, i16;
+    impl ::std::i64, i32;
+    impl ::std::i64, i64;
+    impl ::std::i64, i128;
+    impl ::std::i64, isize;
+    impl ::std::u64, u8;
+    impl ::std::u64, u16;
+    impl ::std::u64, u32;
+    impl ::std::u64, u64;
+    impl ::std::u64, u128;
+    impl ::std::u64, usize;
+
+    impl ::std::f64, f32;
+    impl ::std::f64, f64;
+
+    impl<C, B> ::std::ops::ControlFlow, core::ops::ControlFlow<C, B>;
+
+    impl ::std::bytes::Bytes, [u8];
+
+    impl ::std::cmp::Ordering, core::cmp::Ordering;
+
+    #[cfg(feature = "alloc")]
+    #[cfg_attr(rune_docsrs, doc(cfg(feature = "alloc")))]
+    impl ::std::string::String, ::rust_alloc::string::String;
+    impl ::std::string::String, crate::alloc::Box<str>;
+    impl ::std::string::String, str;
+
+    impl ::std::vec::Vec, [Value];
+    #[cfg(feature = "alloc")]
+    #[cfg_attr(rune_docsrs, doc(cfg(feature = "alloc")))]
+    impl<T> ::std::vec::Vec, ::rust_alloc::vec::Vec<T>;
+    impl<T> ::std::vec::Vec, crate::alloc::Vec<T>;
+    impl<T> ::std::vec::Vec, crate::runtime::VecTuple<T>;
+
+    impl ::std::tuple::Tuple, crate::runtime::Tuple;
+
+    impl ::std::object::Object, crate::runtime::Struct;
+    impl<T> ::std::object::Object, crate::alloc::HashMap<::rust_alloc::string::String, T>;
+    impl<T> ::std::object::Object, crate::alloc::HashMap<alloc::String, T>;
+
+    #[cfg(feature = "std")]
+    #[cfg_attr(rune_docsrs, doc(cfg(feature = "std")))]
+    impl<T> ::std::object::Object, std::collections::HashMap<::rust_alloc::string::String, T>;
+
+    #[cfg(feature = "std")]
+    #[cfg_attr(rune_docsrs, doc(cfg(feature = "std")))]
+    impl<T> ::std::object::Object, std::collections::HashMap<alloc::String, T>;
+
+    impl ::std::any::Type, crate::runtime::Type;
+}
+
 from_value_ref!(Result<Value, Value>, into_result_ref, into_result_mut);
 from_value_ref!(Option<Value>, into_option_ref, into_option_mut);
diff --git a/crates/rune/src/module/module.rs b/crates/rune/src/module/module.rs
@@ -17,8 +17,8 @@ use crate::item::IntoComponent;
 use crate::macros::{MacroContext, TokenStream};
 use crate::module::DocFunction;
 use crate::runtime::{
-    ConstConstruct, InstAddress, MaybeTypeOf, Memory, Output, Protocol, StaticTypeInfo,
-    ToConstValue, TypeHash, TypeOf, VmResult,
+    AnyTypeInfo, ConstConstruct, InstAddress, MaybeTypeOf, Memory, Output, Protocol, ToConstValue,
+    TypeHash, TypeOf, VmResult,
 };
 use crate::{Hash, Item, ItemBuf};
 
@@ -71,7 +71,7 @@ pub struct Module {
     /// A re-export in the current module.
     pub(crate) reexports: Vec<ModuleReexport>,
     /// Constant constructors.
-    pub(crate) construct: Vec<(Hash, StaticTypeInfo, Arc<dyn ConstConstruct>)>,
+    pub(crate) construct: Vec<(Hash, AnyTypeInfo, Arc<dyn ConstConstruct>)>,
     /// Defines construct hashes.
     pub(crate) construct_hash: HashSet<Hash>,
     /// Module level metadata.

diff --git a/crates/rune/src/runtime/mod.rs b/crates/rune/src/runtime/mod.rs
@@ -141,9 +141,6 @@ pub use self::stack::{Memory, SliceError, Stack, StackError};
 mod static_string;
 pub use self::static_string::StaticString;
 
-pub(crate) mod static_type;
-pub use self::static_type::StaticType;
-
 mod stream;
 pub use self::stream::Stream;
 
@@ -157,8 +154,7 @@ mod type_info;
 pub use self::type_info::{AnyTypeInfo, TypeInfo};
 
 mod type_of;
-use self::type_of::StaticTypeInfoKind;
-pub use self::type_of::{MaybeTypeOf, StaticTypeInfo, TypeHash, TypeOf};
+pub use self::type_of::{MaybeTypeOf, TypeHash, TypeOf};
 
 pub mod unit;
 pub(crate) use self::unit::UnitFn;