Merge b463dc9f6dbeb3ddb16234a6d1033c24eb93c463 into 0264534928864c7aed0466d670824ac0ce5ca1a8

Cargo.lock

@@ -3247,7 +3247,7 @@ dependencies = [
 name = "typst-timing"
 version = "0.13.1"
 dependencies = [
- "ecow",
+ "indexmap 2.7.1",
  "parking_lot",
  "serde",
  "serde_json",

crates/typst-library/src/foundations/int.rs

@@ -46,7 +46,7 @@ impl i64 {
     /// or smaller than the minimum 64-bit signed integer.
     ///
     /// - Booleans are converted to `0` or `1`.
-    /// - Floats and decimals are rounded to the next 64-bit integer towards zero.
+    /// - Floats and decimals are truncated to the next 64-bit integer.
     /// - Strings are parsed in base 10.
     ///
     /// ```example

crates/typst-library/src/math/equation.rs

@@ -20,8 +20,8 @@ use crate::text::{FontFamily, FontList, FontWeight, LocalName, TextElem};
 /// A mathematical equation.
 ///
 /// Can be displayed inline with text or as a separate block. An equation
-/// becomes block-level through the presence of whitespace after the opening
-/// dollar sign and whitespace before the closing dollar sign.
+/// becomes block-level through the presence of at least one space after the
+/// opening dollar sign and one space before the closing dollar sign.
 ///
 /// # Example
 /// ```example
@@ -41,9 +41,9 @@ use crate::text::{FontFamily, FontList, FontWeight, LocalName, TextElem};
 ///
 /// # Syntax
 /// This function also has dedicated syntax: Write mathematical markup within
-/// dollar signs to create an equation. Starting and ending the equation with
-/// whitespace lifts it into a separate block that is centered horizontally.
-/// For more details about math syntax, see the
+/// dollar signs to create an equation. Starting and ending the equation with at
+/// least one space lifts it into a separate block that is centered
+/// horizontally. For more details about math syntax, see the
 /// [main math page]($category/math).
 #[elem(Locatable, Synthesize, ShowSet, Count, LocalName, Refable, Outlinable)]
 pub struct EquationElem {

crates/typst-library/src/text/mod.rs

@@ -92,7 +92,7 @@ pub(super) fn define(global: &mut Scope) {
 /// ```
 #[elem(Debug, Construct, PlainText, Repr)]
 pub struct TextElem {
-    /// A font family descriptor or priority list of font family descriptors.
+    /// A font family descriptor or priority list of font family descriptor.
     ///
     /// A font family descriptor can be a plain string representing the family
     /// name or a dictionary with the following keys:

crates/typst-macros/src/time.rs

@@ -1,5 +1,3 @@
-use std::collections::HashSet;
-
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote, ToTokens};
 use syn::parse::{Parse, ParseStream};
@@ -19,12 +17,12 @@ pub struct Meta {
     pub span: Option<syn::Expr>,
     pub callsite: Option<syn::Expr>,
     pub func: Option<syn::Expr>,
-    pub extras: Vec<(syn::Ident, Mode, syn::Expr)>,
+    pub extras: Vec<(String, Mode, syn::Expr)>,
 }
 
 impl Parse for Meta {
     fn parse(input: ParseStream) -> Result<Self> {
-        let out = Self {
+        Ok(Self {
             name: parse_string::<kw::name>(input)?,
             span: parse_key_value::<kw::span, syn::Expr>(input)?,
             callsite: parse_key_value::<kw::callsite, syn::Expr>(input)?,
@@ -41,26 +39,11 @@ impl Parse for Meta {
                     let value = input.parse()?;
                     eat_comma(input);
 
-                    pairs.push((key, mode, value));
+                    pairs.push((key.to_string(), mode, value));
                 }
                 pairs
             },
-        };
-
-        let mut keys = HashSet::new();
-        keys.insert("name".to_string());
-        keys.insert("span".to_string());
-        keys.insert("callsite".to_string());
-        keys.insert("func".to_string());
-
-        // Check that the keys are unique.
-        for (key, _, _) in &out.extras {
-            if !keys.insert(key.to_string()) {
-                bail!(key, "Duplicate key in #[time(..)]: `{}`", key);
-            }
-        }
-
-        Ok(out)
+        })
     }
 }
 
@@ -115,7 +98,6 @@ fn create(meta: Meta, mut item: syn::ItemFn) -> Result<TokenStream> {
             Mode::Serialize => (format_ident!("with_arg"), None),
         };
 
-        let key = key.to_string();
         extras.push(quote! { .#method(#key, (#value) #transform) });
         if matches!(mode, Mode::Serialize) {
             let error_msg = format!("failed to serialize {key}");

crates/typst-timing/Cargo.toml

@@ -13,7 +13,7 @@ keywords = { workspace = true }
 readme = { workspace = true }
 
 [dependencies]
-ecow = { workspace = true }
+indexmap = { workspace = true }
 parking_lot = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }

crates/typst-timing/src/lib.rs

@@ -6,10 +6,11 @@ use std::io::Write;
 use std::num::NonZeroU64;
 use std::ops::Not;
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+use std::sync::Arc;
 
-use ecow::EcoVec;
+use indexmap::IndexMap;
 use parking_lot::Mutex;
-use serde::ser::{SerializeMap, SerializeSeq};
+use serde::ser::SerializeSeq;
 use serde::{Serialize, Serializer};
 
 /// Creates a timing scope around an expression.
@@ -104,11 +105,8 @@ pub fn export_json<W: Write>(
         ts: f64,
         pid: u64,
         tid: u64,
-        #[serde(
-            skip_serializing_if = "Option::is_none",
-            serialize_with = "serialize_vec_as_map"
-        )]
-        args: Option<EcoVec<(Cow<'a, str>, Cow<'a, serde_json::Value>)>>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        args: Option<IndexMap<Cow<'a, str>, Cow<'a, serde_json::Value>>>,
     }
 
     let lock = EVENTS.lock();
@@ -120,9 +118,9 @@ pub fn export_json<W: Write>(
         .map_err(|e| format!("failed to serialize events: {e}"))?;
 
     for event in events.iter() {
-        let mut args = EcoVec::with_capacity(event.arguments.len() * 2 + 1);
+        let mut args = IndexMap::new();
         if let Some(func) = event.func.as_ref() {
-            args.push(("func".into(), Cow::Owned(serde_json::json!(func))));
+            args.insert("func".into(), Cow::Owned(serde_json::json!(func)));
         }
 
         for (key, arg) in event.arguments.iter() {
@@ -145,7 +143,7 @@ pub fn export_json<W: Write>(
         .map_err(|e| format!("failed to serialize event: {e}"))?;
     }
 
-    SerializeSeq::end(seq).map_err(|e| format!("failed to serialize events: {e}"))?;
+    seq.end().map_err(|e| format!("failed to serialize events: {e}"))?;
 
     Ok(())
 }
@@ -155,7 +153,7 @@ pub fn export_json<W: Write>(
 pub struct TimingScope {
     name: &'static str,
     func: Option<String>,
-    args: EcoVec<(&'static str, EventArgument)>,
+    args: IndexMap<&'static str, EventArgument>,
 }
 
 impl TimingScope {
@@ -163,7 +161,7 @@ impl TimingScope {
     #[inline]
     pub fn new(name: &'static str) -> Option<Self> {
         if is_enabled() {
-            Some(Self { name, func: None, args: EcoVec::new() })
+            Some(Self { name, func: None, args: IndexMap::new() })
         } else {
             None
         }
@@ -175,17 +173,17 @@ impl TimingScope {
     }
 
     pub fn with_span(mut self, span: NonZeroU64) -> Self {
-        self.args.push(("span", EventArgument::Span(span)));
+        self.args.insert("span", EventArgument::Span(span));
         self
     }
 
     pub fn with_callsite(mut self, callsite: NonZeroU64) -> Self {
-        self.args.push(("callsite", EventArgument::Span(callsite)));
+        self.args.insert("callsite", EventArgument::Span(callsite));
         self
     }
 
     pub fn with_named_span(mut self, name: &'static str, span: NonZeroU64) -> Self {
-        self.args.push((name, EventArgument::Span(span)));
+        self.args.insert(name, EventArgument::Span(span));
         self
     }
 
@@ -205,7 +203,7 @@ impl TimingScope {
         value: impl Serialize,
     ) -> Result<Self, serde_json::Error> {
         let value = serde_json::to_value(value)?;
-        self.args.push((arg, EventArgument::Value(value)));
+        self.args.insert(arg, EventArgument::Value(value));
         Ok(self)
     }
 
@@ -219,7 +217,7 @@ impl TimingScope {
             name: self.name,
             func: self.func.clone(),
             thread_id,
-            arguments: self.args.clone(),
+            arguments: Arc::new(self.args),
         };
         EVENTS.lock().push(event.clone());
         TimingScopeGuard { scope: Some(event) }
@@ -242,7 +240,6 @@ impl Drop for TimingScopeGuard {
     }
 }
 
-#[derive(Clone)]
 enum EventArgument {
     Span(NonZeroU64),
     Value(serde_json::Value),
@@ -253,45 +250,45 @@ impl EventArgument {
         &'a self,
         mut source: impl FnMut(NonZeroU64) -> (String, u32),
         key: &'static str,
-        out: &mut EcoVec<(Cow<'static, str>, Cow<'a, serde_json::Value>)>,
+        out: &mut IndexMap<Cow<'static, str>, Cow<'a, serde_json::Value>>,
     ) -> Result<(), serde_json::Error> {
         match self {
             EventArgument::Span(span) => {
                 let (file, line) = source(*span);
                 // Insert file and line information for the span
                 if key == "span" {
-                    out.push(("file".into(), Cow::Owned(serde_json::json!(file))));
-                    out.push(("line".into(), Cow::Owned(serde_json::json!(line))));
+                    out.insert("file".into(), Cow::Owned(serde_json::json!(file)));
+                    out.insert("line".into(), Cow::Owned(serde_json::json!(line)));
 
                     return Ok(());
                 }
 
                 // Small optimization for callsite
                 if key == "callsite" {
-                    out.push((
+                    out.insert(
                         "callsite_file".into(),
                         Cow::Owned(serde_json::json!(file)),
-                    ));
-                    out.push((
+                    );
+                    out.insert(
                         "callsite_line".into(),
                         Cow::Owned(serde_json::json!(line)),
-                    ));
+                    );
 
                     return Ok(());
                 }
 
-                out.push((
+                out.insert(
                     format!("{key}_file").into(),
                     Cow::Owned(serde_json::json!(file)),
-                ));
+                );
 
-                out.push((
+                out.insert(
                     format!("{key}_line").into(),
                     Cow::Owned(serde_json::json!(line)),
-                ));
+                );
             }
             EventArgument::Value(value) => {
-                out.push((key.into(), Cow::Borrowed(value)));
+                out.insert(key.into(), Cow::Borrowed(value));
             }
         }
 
@@ -309,7 +306,7 @@ struct Event {
     /// The name of this event.
     name: &'static str,
     /// The additional arguments of this event.
-    arguments: EcoVec<(&'static str, EventArgument)>,
+    arguments: Arc<IndexMap<&'static str, EventArgument>>,
     /// The function being called (if any).
     func: Option<String>,
     /// The thread ID of this event.
@@ -416,24 +413,3 @@ impl WasmTimer {
         self.time_origin + self.perf.now()
     }
 }
-
-// Custom serialization function for handling `EcoVec` as a map in JSON.
-fn serialize_vec_as_map<S>(
-    data: &Option<EcoVec<(Cow<str>, Cow<serde_json::Value>)>>,
-    serializer: S,
-) -> Result<S::Ok, S::Error>
-where
-    S: Serializer,
-{
-    let Some(data) = data.as_deref() else {
-        // Should not happen, but if it does, we turn it into a `null` value.
-        return serializer.serialize_none();
-    };
-
-    let mut map = serializer.serialize_map(Some(data.len()))?;
-    for (key, value) in data {
-        map.serialize_entry(key, value)?;
-    }
-
-    map.end()
-}