More efficient introspection

Switches from a mutable locator to one based on tracked chains and optimizes query performance.

2 files changed, 37 insertions, 21 deletions

diff --git a/src/eval/func.rs b/src/eval/func.rs
index 060e72cf..a8afa36d 100644
--- a/src/eval/func.rs
+++ b/src/eval/func.rs
@@ -12,7 +12,7 @@ use super::{
     cast_to_value, Args, CastInfo, Eval, Flow, Route, Scope, Scopes, Tracer, Value, Vm,
 };
 use crate::diag::{bail, SourceResult, StrResult};
-use crate::model::{ElemFunc, Introspector, StabilityProvider, Vt};
+use crate::model::{ElemFunc, Introspector, Locator, Vt};
 use crate::syntax::ast::{self, AstNode, Expr, Ident};
 use crate::syntax::{SourceId, Span, SyntaxNode};
 use crate::World;
@@ -104,7 +104,7 @@ impl Func {
                     vm.world(),
                     route,
                     TrackedMut::reborrow_mut(&mut vm.vt.tracer),
-                    TrackedMut::reborrow_mut(&mut vm.vt.provider),
+                    vm.vt.locator.track(),
                     vm.vt.introspector,
                     vm.depth + 1,
                     args,
@@ -127,7 +127,14 @@ impl Func {
         let route = Route::default();
         let id = SourceId::detached();
         let scopes = Scopes::new(None);
-        let mut vm = Vm::new(vt.reborrow_mut(), route.track(), id, scopes);
+        let mut locator = Locator::chained(vt.locator.track());
+        let vt = Vt {
+            world: vt.world,
+            tracer: TrackedMut::reborrow_mut(&mut vt.tracer),
+            locator: &mut locator,
+            introspector: vt.introspector,
+        };
+        let mut vm = Vm::new(vt, route.track(), id, scopes);
         let args = Args::new(self.span(), args);
         self.call_vm(&mut vm, args)
     }
@@ -320,7 +327,7 @@ impl Closure {
         world: Tracked<dyn World + '_>,
         route: Tracked<Route>,
         tracer: TrackedMut<Tracer>,
-        provider: TrackedMut<StabilityProvider>,
+        locator: Tracked<Locator>,
         introspector: Tracked<Introspector>,
         depth: usize,
         mut args: Args,
@@ -335,8 +342,11 @@ impl Closure {
         let mut scopes = Scopes::new(None);
         scopes.top = closure.captured.clone();
 
-        // Evaluate the body.
-        let vt = Vt { world, tracer, provider, introspector };
+        // Prepare VT.
+        let mut locator = Locator::chained(locator);
+        let vt = Vt { world, tracer, locator: &mut locator, introspector };
+
+        // Prepare VM.
         let mut vm = Vm::new(vt, route, closure.location, scopes);
         vm.depth = depth;
 
diff --git a/src/eval/mod.rs b/src/eval/mod.rs
index 95822530..ba9628c4 100644
--- a/src/eval/mod.rs
+++ b/src/eval/mod.rs
@@ -48,9 +48,8 @@ use unicode_segmentation::UnicodeSegmentation;
 use crate::diag::{
     bail, error, At, SourceError, SourceResult, StrResult, Trace, Tracepoint,
 };
-use crate::model::ShowableSelector;
 use crate::model::{
-    Content, Introspector, Label, Recipe, StabilityProvider, Styles, Transform,
+    Content, Introspector, Label, Locator, Recipe, ShowableSelector, Styles, Transform,
     Unlabellable, Vt,
 };
 use crate::syntax::ast::AstNode;
@@ -83,23 +82,26 @@ pub fn eval(
     let library = world.library();
     set_lang_items(library.items.clone());
 
-    // Evaluate the module.
-    let route = Route::insert(route, id);
-    let scopes = Scopes::new(Some(library));
-    let mut provider = StabilityProvider::new();
-    let introspector = Introspector::new(&[]);
+    // Prepare VT.
+    let mut locator = Locator::default();
+    let introspector = Introspector::default();
     let vt = Vt {
         world,
         tracer,
-        provider: provider.track_mut(),
+        locator: &mut locator,
         introspector: introspector.track(),
     };
+
+    // Prepare VM.
+    let route = Route::insert(route, id);
+    let scopes = Scopes::new(Some(library));
     let mut vm = Vm::new(vt, route.track(), id, scopes);
     let root = match source.root().cast::<ast::Markup>() {
         Some(markup) if vm.traced.is_some() => markup,
         _ => source.ast()?,
     };
 
+    // Evaluate the module.
     let result = root.eval(&mut vm);
 
     // Handle control flow.
@@ -129,20 +131,24 @@ pub fn eval_string(
         return Err(Box::new(errors));
     }
 
-    let id = SourceId::detached();
-    let library = world.library();
-    let scopes = Scopes::new(Some(library));
-    let route = Route::default();
+    // Prepare VT.
     let mut tracer = Tracer::default();
-    let mut provider = StabilityProvider::new();
-    let introspector = Introspector::new(&[]);
+    let mut locator = Locator::default();
+    let introspector = Introspector::default();
     let vt = Vt {
         world,
         tracer: tracer.track_mut(),
-        provider: provider.track_mut(),
+        locator: &mut locator,
         introspector: introspector.track(),
     };
+
+    // Prepare VM.
+    let route = Route::default();
+    let id = SourceId::detached();
+    let scopes = Scopes::new(Some(world.library()));
     let mut vm = Vm::new(vt, route.track(), id, scopes);
+
+    // Evaluate the code.
     let code = root.cast::<ast::Code>().unwrap();
     let result = code.eval(&mut vm);