Split out four new crates (#5302)

6 files changed, 31 insertions, 22 deletions

diff --git a/crates/typst-macros/src/cast.rs b/crates/typst-macros/src/cast.rs
index c732ce6b..9254cdb9 100644
--- a/crates/typst-macros/src/cast.rs
+++ b/crates/typst-macros/src/cast.rs
@@ -108,7 +108,7 @@ pub fn cast(stream: TokenStream) -> Result<TokenStream> {
     let from_value = (!input.from_value.is_empty() || input.dynamic).then(|| {
         quote! {
             impl #foundations::FromValue for #ty {
-                fn from_value(value: #foundations::Value) -> ::typst::diag::HintedStrResult<Self> {
+                fn from_value(value: #foundations::Value) -> ::typst_library::diag::HintedStrResult<Self> {
                     #from_value_body
                 }
             }
diff --git a/crates/typst-macros/src/elem.rs b/crates/typst-macros/src/elem.rs
index a3666e1d..3b968f76 100644
--- a/crates/typst-macros/src/elem.rs
+++ b/crates/typst-macros/src/elem.rs
@@ -314,6 +314,7 @@ fn create(element: &Elem) -> Result<TokenStream> {
     let fields_impl = create_fields_impl(element);
     let repr_impl = element.cannot("Repr").then(|| create_repr_impl(element));
     let locatable_impl = element.can("Locatable").then(|| create_locatable_impl(element));
+    let mathy_impl = element.can("Mathy").then(|| create_mathy_impl(element));
     let into_value_impl = create_into_value_impl(element);
 
     // We use a const block to create an anonymous scope, as to not leak any
@@ -333,6 +334,7 @@ fn create(element: &Elem) -> Result<TokenStream> {
             #partial_eq_impl
             #repr_impl
             #locatable_impl
+            #mathy_impl
             #into_value_impl
         };
     })
@@ -632,7 +634,7 @@ fn create_native_elem_impl(element: &Elem) -> TokenStream {
     let Elem { name, ident, title, scope, keywords, docs, .. } = element;
 
     let local_name = if element.can("LocalName") {
-        quote! { Some(<#foundations::Packed<#ident> as ::typst::text::LocalName>::local_name) }
+        quote! { Some(<#foundations::Packed<#ident> as ::typst_library::text::LocalName>::local_name) }
     } else {
         quote! { None }
     };
@@ -761,9 +763,9 @@ fn create_construct_impl(element: &Elem) -> TokenStream {
     quote! {
         impl #foundations::Construct for #ident {
             fn construct(
-                engine: &mut ::typst::engine::Engine,
+                engine: &mut ::typst_library::engine::Engine,
                 args: &mut #foundations::Args,
-            ) -> ::typst::diag::SourceResult<#foundations::Content> {
+            ) -> ::typst_library::diag::SourceResult<#foundations::Content> {
                 #(#setup)*
                 Ok(#foundations::Content::new(Self { #(#fields),* }))
             }
@@ -788,9 +790,9 @@ fn create_set_impl(element: &Elem) -> TokenStream {
     quote! {
         impl #foundations::Set for #ident {
             fn set(
-                engine: &mut ::typst::engine::Engine,
+                engine: &mut ::typst_library::engine::Engine,
                 args: &mut #foundations::Args,
-            ) -> ::typst::diag::SourceResult<#foundations::Styles> {
+            ) -> ::typst_library::diag::SourceResult<#foundations::Styles> {
                 let mut styles = #foundations::Styles::new();
                 #(#handlers)*
                 Ok(styles)
@@ -837,7 +839,7 @@ fn create_capable_impl(element: &Elem) -> TokenStream {
                 // Safety: The vtable function doesn't require initialized
                 // data, so it's fine to use a dangling pointer.
                 return Some(unsafe {
-                    ::typst::utils::fat::vtable(dangling as *const dyn #capability)
+                    ::typst_utils::fat::vtable(dangling as *const dyn #capability)
                 });
             }
         }
@@ -1047,7 +1049,13 @@ fn create_repr_impl(element: &Elem) -> TokenStream {
 /// Creates the element's `Locatable` implementation.
 fn create_locatable_impl(element: &Elem) -> TokenStream {
     let ident = &element.ident;
-    quote! { impl ::typst::introspection::Locatable for #foundations::Packed<#ident> {} }
+    quote! { impl ::typst_library::introspection::Locatable for #foundations::Packed<#ident> {} }
+}
+
+/// Creates the element's `Mathy` implementation.
+fn create_mathy_impl(element: &Elem) -> TokenStream {
+    let ident = &element.ident;
+    quote! { impl ::typst_library::math::Mathy for #foundations::Packed<#ident> {} }
 }
 
 /// Creates the element's `IntoValue` implementation.
diff --git a/crates/typst-macros/src/func.rs b/crates/typst-macros/src/func.rs
index 8d3fd439..d402efd9 100644
--- a/crates/typst-macros/src/func.rs
+++ b/crates/typst-macros/src/func.rs
@@ -262,6 +262,7 @@ fn create(func: &Func, item: &syn::ItemFn) -> TokenStream {
         let ident_data = quote::format_ident!("{ident}_data");
         quote! {
             #[doc(hidden)]
+            #[allow(non_snake_case)]
             #vis fn #ident_data() -> &'static #foundations::NativeFuncData {
                 static DATA: #foundations::NativeFuncData = #data;
                 &DATA
diff --git a/crates/typst-macros/src/symbols.rs b/crates/typst-macros/src/symbols.rs
index 6b35f87f..9917f436 100644
--- a/crates/typst-macros/src/symbols.rs
+++ b/crates/typst-macros/src/symbols.rs
@@ -5,6 +5,8 @@ use syn::parse::{Parse, ParseStream, Parser};
 use syn::punctuated::Punctuated;
 use syn::{Ident, LitChar, Path, Result, Token};
 
+use crate::util::foundations;
+
 /// Expand the `symbols!` macro.
 pub fn symbols(stream: TokenStream) -> Result<TokenStream> {
     let list: Punctuated<Symbol, Token![,]> =
@@ -14,7 +16,7 @@ pub fn symbols(stream: TokenStream) -> Result<TokenStream> {
         let kind = match &symbol.kind {
             Kind::Single(c, h) => {
                 let symbol = construct_sym_char(c, h);
-                quote! { ::typst::symbols::Symbol::single(#symbol), }
+                quote! { #foundations::Symbol::single(#symbol), }
             }
             Kind::Multiple(variants) => {
                 let variants = variants.iter().map(|variant| {
@@ -24,7 +26,7 @@ pub fn symbols(stream: TokenStream) -> Result<TokenStream> {
                     quote! { (#name, #symbol) }
                 });
                 quote! {
-                    ::typst::symbols::Symbol::list(&[#(#variants),*])
+                    #foundations::Symbol::list(&[#(#variants),*])
                 }
             }
         };
@@ -35,11 +37,11 @@ pub fn symbols(stream: TokenStream) -> Result<TokenStream> {
 
 fn construct_sym_char(ch: &LitChar, handler: &Handler) -> TokenStream {
     match &handler.0 {
-        None => quote! { ::typst::symbols::SymChar::pure(#ch), },
+        None => quote! {  #foundations::SymChar::pure(#ch), },
         Some(path) => quote! {
-            ::typst::symbols::SymChar::with_func(
+             #foundations::SymChar::with_func(
                 #ch,
-                <#path as ::typst::foundations::NativeFunc>::func,
+                <#path as ::typst_library::foundations::NativeFunc>::func,
             ),
         },
     }
diff --git a/crates/typst-macros/src/time.rs b/crates/typst-macros/src/time.rs
index b0758dc2..94fa4e5b 100644
--- a/crates/typst-macros/src/time.rs
+++ b/crates/typst-macros/src/time.rs
@@ -28,17 +28,15 @@ impl Parse for Meta {
 
 fn create(meta: Meta, mut item: syn::ItemFn) -> TokenStream {
     let name = meta.name.unwrap_or_else(|| item.sig.ident.to_string());
-    let span = meta
-        .span
-        .as_ref()
-        .map(|span| quote! { Some(#span) })
-        .unwrap_or_else(|| quote! { None });
+    let construct = match meta.span.as_ref() {
+        Some(span) => quote! { with_span(#name, Some(#span.into_raw())) },
+        None => quote! { new(#name) },
+    };
 
     item.block.stmts.insert(
         0,
         parse_quote! {
-            #[cfg(not(target_arch = "wasm32"))]
-            let __scope = ::typst_timing::TimingScope::new(#name, #span);
+            let __scope = ::typst_timing::TimingScope::#construct;
         },
     );
 
diff --git a/crates/typst-macros/src/util.rs b/crates/typst-macros/src/util.rs
index 4d8255e0..e8c0910b 100644
--- a/crates/typst-macros/src/util.rs
+++ b/crates/typst-macros/src/util.rs
@@ -200,13 +200,13 @@ impl<T: Parse> Parse for Array<T> {
     }
 }
 
-/// Shorthand for `::typst::foundations`.
+/// Shorthand for `::typst_library::foundations`.
 #[allow(non_camel_case_types)]
 pub struct foundations;
 
 impl quote::ToTokens for foundations {
     fn to_tokens(&self, tokens: &mut TokenStream) {
-        quote! { ::typst::foundations }.to_tokens(tokens);
+        quote! { ::typst_library::foundations }.to_tokens(tokens);
     }
 }