Hover and autocomplete in show rules

6 files changed, 61 insertions, 39 deletions

diff --git a/library/src/meta/counter.rs b/library/src/meta/counter.rs
index b8f719ac..b61e8913 100644
--- a/library/src/meta/counter.rs
+++ b/library/src/meta/counter.rs
@@ -3,6 +3,7 @@ use std::str::FromStr;
 
 use ecow::{eco_vec, EcoVec};
 use smallvec::{smallvec, SmallVec};
+use typst::eval::Tracer;
 
 use super::{Numbering, NumberingPattern};
 use crate::layout::PageNode;
@@ -125,10 +126,16 @@ impl Show for CounterNode {
                     return counter.resolve(vt, id, &numbering);
                 }
 
-                let sequence = counter.sequence(vt.world, vt.introspector)?;
+                let sequence = counter.sequence(
+                    vt.world,
+                    TrackedMut::reborrow_mut(&mut vt.tracer),
+                    TrackedMut::reborrow_mut(&mut vt.provider),
+                    vt.introspector,
+                )?;
+
                 Ok(match (sequence.single(id), sequence.single(None)) {
                     (Some(current), Some(total)) => {
-                        numbering.apply(vt.world, &[current, total])?.display()
+                        numbering.apply_vt(vt, &[current, total])?.display()
                     }
                     _ => Content::empty(),
                 })
@@ -213,7 +220,7 @@ impl Counter {
     /// id.
     pub fn resolve(
         &self,
-        vt: &Vt,
+        vt: &mut Vt,
         stop: Option<StableId>,
         numbering: &Numbering,
     ) -> SourceResult<Content> {
@@ -221,9 +228,15 @@ impl Counter {
             return Ok(Content::empty());
         }
 
-        let sequence = self.sequence(vt.world, vt.introspector)?;
+        let sequence = self.sequence(
+            vt.world,
+            TrackedMut::reborrow_mut(&mut vt.tracer),
+            TrackedMut::reborrow_mut(&mut vt.provider),
+            vt.introspector,
+        )?;
+
         Ok(match sequence.at(stop) {
-            Some(state) => numbering.apply(vt.world, &state.0)?.display(),
+            Some(state) => numbering.apply_vt(vt, &state.0)?.display(),
             None => Content::empty(),
         })
     }
@@ -236,8 +249,11 @@ impl Counter {
     fn sequence(
         &self,
         world: Tracked<dyn World>,
+        tracer: TrackedMut<Tracer>,
+        provider: TrackedMut<StabilityProvider>,
         introspector: Tracked<Introspector>,
     ) -> SourceResult<CounterSequence> {
+        let mut vt = Vt { world, tracer, provider, introspector };
         let mut search = Selector::Node(
             NodeId::of::<CounterNode>(),
             Some(dict! { "counter" => self.clone() }),
@@ -277,7 +293,7 @@ impl Counter {
                     None => Some(CounterUpdate::Step(NonZeroUsize::ONE)),
                 },
             } {
-                state.update(world, update)?;
+                state.update(&mut vt, update)?;
             }
 
             stops.push((id, state.clone()));
@@ -335,17 +351,15 @@ pub struct CounterState(pub SmallVec<[NonZeroUsize; 3]>);
 
 impl CounterState {
     /// Advance the counter and return the numbers for the given heading.
-    pub fn update(
-        &mut self,
-        world: Tracked<dyn World>,
-        update: CounterUpdate,
-    ) -> SourceResult<()> {
+    pub fn update(&mut self, vt: &mut Vt, update: CounterUpdate) -> SourceResult<()> {
         match update {
             CounterUpdate::Set(state) => *self = state,
             CounterUpdate::Step(level) => self.step(level),
             CounterUpdate::Func(func) => {
-                let args = Args::new(func.span(), self.0.iter().copied().map(Into::into));
-                *self = func.call_detached(world, args)?.cast().at(func.span())?
+                *self = func
+                    .call_vt(vt, self.0.iter().copied().map(Into::into))?
+                    .cast()
+                    .at(func.span())?
             }
         }
         Ok(())
diff --git a/library/src/meta/numbering.rs b/library/src/meta/numbering.rs
index 6febc408..6facb833 100644
--- a/library/src/meta/numbering.rs
+++ b/library/src/meta/numbering.rs
@@ -64,7 +64,7 @@ pub fn numbering(
     #[variadic]
     numbers: Vec<NonZeroUsize>,
 ) -> Value {
-    numbering.apply(vm.world(), &numbers)?
+    numbering.apply_vm(vm, &numbers)?
 }
 
 /// How to number a sequence of things.
@@ -78,11 +78,7 @@ pub enum Numbering {
 
 impl Numbering {
     /// Apply the pattern to the given numbers.
-    pub fn apply(
-        &self,
-        world: Tracked<dyn World>,
-        numbers: &[NonZeroUsize],
-    ) -> SourceResult<Value> {
+    pub fn apply_vm(&self, vm: &mut Vm, numbers: &[NonZeroUsize]) -> SourceResult<Value> {
         Ok(match self {
             Self::Pattern(pattern) => Value::Str(pattern.apply(numbers).into()),
             Self::Func(func) => {
@@ -90,7 +86,17 @@ impl Numbering {
                     func.span(),
                     numbers.iter().map(|n| Value::Int(n.get() as i64)),
                 );
-                func.call_detached(world, args)?
+                func.call_vm(vm, args)?
+            }
+        })
+    }
+
+    /// Apply the pattern to the given numbers.
+    pub fn apply_vt(&self, vt: &mut Vt, numbers: &[NonZeroUsize]) -> SourceResult<Value> {
+        Ok(match self {
+            Self::Pattern(pattern) => Value::Str(pattern.apply(numbers).into()),
+            Self::Func(func) => {
+                func.call_vt(vt, numbers.iter().map(|n| Value::Int(n.get() as i64)))?
             }
         })
     }
diff --git a/library/src/meta/outline.rs b/library/src/meta/outline.rs
index 97611036..7cd26eba 100644
--- a/library/src/meta/outline.rs
+++ b/library/src/meta/outline.rs
@@ -91,10 +91,12 @@ impl Show for OutlineNode {
         let depth = self.depth(styles);
 
         let mut ancestors: Vec<&HeadingNode> = vec![];
-        for node in vt.introspector.query(Selector::Node(
+        let nodes = vt.introspector.query(Selector::Node(
             NodeId::of::<HeadingNode>(),
             Some(dict! { "outlined" => true }),
-        )) {
+        ));
+
+        for node in &nodes {
             let heading = node.to::<HeadingNode>().unwrap();
             let stable_id = heading.0.stable_id().unwrap();
             if !heading.outlined(StyleChain::default()) {
diff --git a/library/src/meta/query.rs b/library/src/meta/query.rs
index c91f0d1a..bab8ed7c 100644
--- a/library/src/meta/query.rs
+++ b/library/src/meta/query.rs
@@ -59,11 +59,6 @@ impl Show for QueryNode {
         let target = self.target();
         let (before, after) = vt.introspector.query_split(target, id);
         let func = self.format();
-        let args = Args::new(func.span(), [encode(before), encode(after)]);
-        Ok(func.call_detached(vt.world, args)?.display())
+        Ok(func.call_vt(vt, [before.into(), after.into()])?.display())
     }
 }
-
-fn encode(list: Vec<&Content>) -> Value {
-    Value::Array(list.into_iter().cloned().map(Value::Content).collect())
-}
diff --git a/library/src/meta/reference.rs b/library/src/meta/reference.rs
index f05692dd..0603ee4e 100644
--- a/library/src/meta/reference.rs
+++ b/library/src/meta/reference.rs
@@ -80,7 +80,7 @@ impl Show for RefNode {
             return self.to_citation(styles).show(vt, styles);
         }
 
-        let &[node] = matches.as_slice() else {
+        let [node] = matches.as_slice() else {
             bail!(self.span(), if matches.is_empty() {
                 "label does not exist in the document"
             } else {
@@ -102,8 +102,7 @@ impl Show for RefNode {
             Smart::Custom(None) => Content::empty(),
             Smart::Custom(Some(Supplement::Content(content))) => content.clone(),
             Smart::Custom(Some(Supplement::Func(func))) => {
-                let args = Args::new(func.span(), [node.clone().into()]);
-                func.call_detached(vt.world, args)?.display()
+                func.call_vt(vt, [node.clone().into()])?.display()
             }
         };
 
diff --git a/library/src/meta/state.rs b/library/src/meta/state.rs
index 8b0a0aa6..6b521301 100644
--- a/library/src/meta/state.rs
+++ b/library/src/meta/state.rs
@@ -1,6 +1,7 @@
 use std::fmt::{self, Debug, Formatter, Write};
 
 use ecow::EcoVec;
+use typst::eval::Tracer;
 
 use crate::prelude::*;
 
@@ -118,7 +119,7 @@ impl State {
     /// Display the state at the postition of the given stable id.
     fn resolve(
         &self,
-        vt: &Vt,
+        vt: &mut Vt,
         stop: Option<StableId>,
         func: Option<Func>,
     ) -> SourceResult<Content> {
@@ -126,12 +127,17 @@ impl State {
             return Ok(Content::empty());
         }
 
-        let sequence = self.sequence(vt.world, vt.introspector)?;
+        let sequence = self.sequence(
+            vt.world,
+            TrackedMut::reborrow_mut(&mut vt.tracer),
+            TrackedMut::reborrow_mut(&mut vt.provider),
+            vt.introspector,
+        )?;
+
         Ok(match sequence.at(stop) {
             Some(value) => {
                 if let Some(func) = func {
-                    let args = Args::new(func.span(), [value]);
-                    func.call_detached(vt.world, args)?.display()
+                    func.call_vt(vt, [value])?.display()
                 } else {
                     value.display()
                 }
@@ -148,8 +154,11 @@ impl State {
     fn sequence(
         &self,
         world: Tracked<dyn World>,
+        tracer: TrackedMut<Tracer>,
+        provider: TrackedMut<StabilityProvider>,
         introspector: Tracked<Introspector>,
     ) -> SourceResult<StateSequence> {
+        let mut vt = Vt { world, tracer, provider, introspector };
         let search = Selector::Node(
             NodeId::of::<StateNode>(),
             Some(dict! { "state" => self.clone() }),
@@ -165,10 +174,7 @@ impl State {
             if let StateAction::Update(update) = node.action() {
                 match update {
                     StateUpdate::Set(value) => state = value,
-                    StateUpdate::Func(func) => {
-                        let args = Args::new(func.span(), [state]);
-                        state = func.call_detached(world, args)?;
-                    }
+                    StateUpdate::Func(func) => state = func.call_vt(&mut vt, [state])?,
                 }
             }