[WIP] Replace eval with bytecode-based VM

.cargo/config.toml

@@ -0,0 +1 @@
+[target.x86_64-unknown-linux-gnu]

Cargo.toml

@@ -29,7 +29,7 @@ typst-timing = { path = "crates/typst-timing" }
 az = "1.2"
 base64 = "0.21.2"
 bitflags = { version = "2", features = ["serde"] }
-bytemuck = "1"
+bytemuck = { version = "1.14", features = [ "derive" ] }
 chinese-number = { version = "0.7.2", default-features = false, features = ["number-to-chinese"] }
 chrono = { version = "0.4.24", default-features = false, features = ["clock", "std"] }
 ciborium = "0.2.1"
@@ -121,16 +121,18 @@ xmp-writer = "0.2"
 xz2 = "0.1"
 yaml-front-matter = "0.1"
 zip = { version = "0.6", default-features = false, features = ["deflate"] }
+atomic = "0.6.0"
 
 [profile.dev.package."*"]
 opt-level = 2
 
 [profile.release]
 lto = "thin"
 codegen-units = 1
+debug = true
 
 [profile.release.package."typst-cli"]
-strip = true
+strip = false
 
 [workspace.lints.clippy]
 uninlined_format_args = "warn"

crates/typst-cli/src/compile.rs

@@ -8,12 +8,13 @@ use ecow::{eco_format, EcoString};
 use parking_lot::RwLock;
 use rayon::iter::{IndexedParallelIterator, IntoParallelRefIterator, ParallelIterator};
 use typst::diag::{bail, At, Severity, SourceDiagnostic, StrResult};
-use typst::eval::Tracer;
 use typst::foundations::Datetime;
 use typst::layout::Frame;
 use typst::model::Document;
 use typst::syntax::{FileId, Source, Span};
+use typst::util::{HITS, MISSES};
 use typst::visualize::Color;
+use typst::vm::Tracer;
 use typst::{World, WorldExt};
 
 use crate::args::{CompileCommand, DiagnosticFormat, OutputFormat};
@@ -68,7 +69,7 @@ pub fn compile(mut timer: Timer, mut command: CompileCommand) -> StrResult<()> {
 /// Compile a single time.
 ///
 /// Returns whether it compiled without errors.
-#[typst_macros::time(name = "compile once")]
+#[typst_macros::time(name = "compile document once")]
 pub fn compile_once(
     world: &mut SystemWorld,
     command: &mut CompileCommand,
@@ -136,6 +137,10 @@ pub fn compile_once(
         }
     }
 
+    let hits = HITS.load(std::sync::atomic::Ordering::SeqCst);
+    let misses = MISSES.load(std::sync::atomic::Ordering::SeqCst);
+    eprintln!("Hit rate: {}% ({} / {})", hits as f64 * 100.0 / (hits as f64 + misses as f64), hits, hits + misses);
+
     Ok(())
 }
 

crates/typst-cli/src/query.rs

@@ -2,10 +2,10 @@ use comemo::Track;
 use ecow::{eco_format, EcoString};
 use serde::Serialize;
 use typst::diag::{bail, StrResult};
-use typst::eval::{eval_string, EvalMode, Tracer};
 use typst::foundations::{Content, IntoValue, LocatableSelector, Scope};
 use typst::model::Document;
 use typst::syntax::Span;
+use typst::vm::{eval_string, EvalMode, Tracer};
 use typst::World;
 
 use crate::args::{QueryCommand, SerializationFormat};
@@ -77,7 +77,6 @@ fn retrieve(
         .introspector
         .query(&selector.0)
         .into_iter()
-        .map(|x| x.into_inner())
         .collect::<Vec<_>>())
 }
 

crates/typst-docs/src/html.rs

@@ -8,11 +8,11 @@ use pulldown_cmark as md;
 use serde::{Deserialize, Serialize};
 use typed_arena::Arena;
 use typst::diag::{FileResult, StrResult};
-use typst::eval::Tracer;
 use typst::foundations::{Bytes, Datetime};
 use typst::layout::{Abs, Point, Size};
 use typst::syntax::{FileId, Source, VirtualPath};
 use typst::text::{Font, FontBook};
+use typst::vm::Tracer;
 use typst::{Library, World};
 use unscanny::Scanner;
 use yaml_front_matter::YamlFrontMatter;

crates/typst-docs/src/lib.rs

@@ -30,6 +30,7 @@ use typst::loading::DATA_LOADING;
 use typst::math::MATH;
 use typst::model::Document;
 use typst::model::MODEL;
+use typst::pico;
 use typst::symbols::SYMBOLS;
 use typst::text::{Font, FontBook, TEXT};
 use typst::visualize::VISUALIZE;
@@ -48,7 +49,7 @@ static GROUPS: Lazy<Vec<GroupData>> = Lazy::new(|| {
                 .scope()
                 .iter()
                 .filter(|(_, v)| matches!(v, Value::Func(_)))
-                .map(|(k, _)| k.clone())
+                .map(|(k, _)| k.to_owned())
                 .collect();
         }
     }
@@ -241,19 +242,20 @@ fn category_page(resolver: &dyn Resolver, category: Category) -> PageModel {
 
     // Add functions.
     let scope = module.scope();
-    for (name, value) in scope.iter() {
+    for (name, value) in scope.iter_pico() {
         if scope.get_category(name) != Some(category) {
             continue;
         }
 
         if category == MATH {
             // Skip grouped functions.
-            if GROUPS.iter().flat_map(|group| &group.filter).any(|f| f == name) {
+            let resolved = name.resolve();
+            if GROUPS.iter().flat_map(|group| &group.filter).any(|f| *f == resolved) {
                 continue;
             }
 
             // Already documented in the text category.
-            if name == "text" {
+            if name == pico!("text") {
                 continue;
             }
         }
@@ -532,7 +534,7 @@ fn group_page(
 
     let mut outline_items = vec![];
     for name in &group.filter {
-        let value = group.module().scope().get(name).unwrap();
+        let value = group.module().scope().get(name as &str).unwrap();
         let Value::Func(func) = value else { panic!("not a function") };
         let func = func_model(resolver, func, &path, true);
         let id_base = urlify(&eco_format!("functions-{}", func.name));
@@ -644,7 +646,7 @@ fn symbols_model(resolver: &dyn Resolver, group: &GroupData) -> SymbolsModel {
         let Value::Symbol(symbol) = value else { continue };
         let complete = |variant: &str| {
             if variant.is_empty() {
-                name.clone()
+                EcoString::from(name)
             } else {
                 eco_format!("{}.{}", name, variant)
             }
@@ -760,7 +762,7 @@ struct GroupData {
     #[serde(default)]
     path: Vec<EcoString>,
     #[serde(default)]
-    filter: Vec<EcoString>,
+    filter: Vec<String>,
     details: EcoString,
 }
 

crates/typst-docs/src/link.rs

@@ -59,7 +59,7 @@ fn resolve_definition(head: &str) -> StrResult<String> {
 
     while let Some(name) = parts.peek() {
         if category.is_none() {
-            category = focus.scope().get_category(name);
+            category = focus.scope().get_category(*name);
         }
         let Ok(module) = get_module(focus, name) else { break };
         focus = module;
@@ -73,7 +73,7 @@ fn resolve_definition(head: &str) -> StrResult<String> {
 
     // Handle grouped functions.
     if let Some(group) = GROUPS.iter().find(|group| {
-        group.category == category.name() && group.filter.iter().any(|func| func == name)
+        group.category == category.name() && group.filter.iter().any(|func| *func == name)
     }) {
         let mut route = format!(
             "/docs/reference/{}/{}/#functions-{}",

crates/typst-ide/src/analyze.rs

@@ -1,11 +1,11 @@
 use comemo::Track;
 use ecow::{eco_vec, EcoString, EcoVec};
 use typst::engine::{Engine, Route};
-use typst::eval::{Tracer, Vm};
 use typst::foundations::{Label, Scopes, Value};
 use typst::introspection::{Introspector, Locator};
 use typst::model::{BibliographyElem, Document};
 use typst::syntax::{ast, LinkedNode, Span, SyntaxKind};
+use typst::vm::Tracer;
 use typst::World;
 
 /// Try to determine a set of possible values for an expression.
@@ -23,7 +23,7 @@ pub fn analyze_expr(world: &dyn World, node: &LinkedNode) -> EcoVec<Value> {
             let Some(child) = node.children().next() else { return eco_vec![] };
             analyze_expr(world, &child)
                 .into_iter()
-                .filter_map(|target| target.field(&access.field()).ok())
+                .filter_map(|target| target.field(access.field().get()).ok())
                 .collect()
         }
 
@@ -62,10 +62,11 @@ pub fn analyze_import(world: &dyn World, source: &LinkedNode) -> Option<Value> {
         tracer: tracer.track_mut(),
     };
 
-    let mut vm = Vm::new(engine, Scopes::new(Some(world.library())), Span::detached());
+    /*let mut vm = Vm::new(engine, Scopes::new(Some(world.library())), Span::detached());
     typst::eval::import(&mut vm, source, Span::detached(), true)
         .ok()
-        .map(Value::Module)
+        .map(Value::Module)*/
+    todo!()
 }
 
 /// Find all labels and details for them.

crates/typst-ide/src/complete.rs

@@ -362,12 +362,12 @@ fn complete_field_accesses(ctx: &mut CompletionContext) -> bool {
 /// Add completions for all fields on a value.
 fn field_access_completions(ctx: &mut CompletionContext, value: &Value) {
     for (name, value) in value.ty().scope().iter() {
-        ctx.value_completion(Some(name.clone()), value, true, None);
+        ctx.value_completion(Some(name.into()), value, true, None);
     }
 
     if let Some(scope) = value.scope() {
         for (name, value) in scope.iter() {
-            ctx.value_completion(Some(name.clone()), value, true, None);
+            ctx.value_completion(Some(name.into()), value, true, None);
         }
     }
 
@@ -517,7 +517,7 @@ fn import_item_completions<'a>(
 
     for (name, value) in scope.iter() {
         if existing.iter().all(|item| item.original_name().as_str() != name) {
-            ctx.value_completion(Some(name.clone()), value, false, None);
+            ctx.value_completion(Some(name.into()), value, false, None);
         }
     }
 }
@@ -760,11 +760,11 @@ fn resolve_global_callee<'a>(
     callee: ast::Expr<'a>,
 ) -> Option<&'a Func> {
     let value = match callee {
-        ast::Expr::Ident(ident) => ctx.global.get(&ident)?,
+        ast::Expr::Ident(ident) => ctx.global.get(ident.get())?,
         ast::Expr::FieldAccess(access) => match access.target() {
-            ast::Expr::Ident(target) => match ctx.global.get(&target)? {
-                Value::Module(module) => module.field(&access.field()).ok()?,
-                Value::Func(func) => func.field(&access.field()).ok()?,
+            ast::Expr::Ident(target) => match ctx.global.get(target.get())? {
+                Value::Module(module) => module.field(access.field().get()).ok()?,
+                Value::Func(func) => func.field(access.field().get()).ok()?,
                 _ => return None,
             },
             _ => return None,
@@ -1303,7 +1303,7 @@ impl<'a> CompletionContext<'a> {
                                     defined.extend(value.name().map(Into::into));
                                 } else if let Some(scope) = value.scope() {
                                     for (name, _) in scope.iter() {
-                                        defined.insert(name.clone());
+                                        defined.insert(name.into());
                                     }
                                 }
                             }
@@ -1347,7 +1347,7 @@ impl<'a> CompletionContext<'a> {
         let scope = if in_math { self.math } else { self.global };
         for (name, value) in scope.iter() {
             if filter(value) && !defined.contains(name) {
-                self.value_completion(Some(name.clone()), value, parens, None);
+                self.value_completion(Some(name.into()), value, parens, None);
             }
         }
 

crates/typst-ide/src/tooltip.rs

@@ -2,12 +2,12 @@ use std::fmt::Write;
 
 use ecow::{eco_format, EcoString};
 use if_chain::if_chain;
-use typst::eval::{CapturesVisitor, Tracer};
 use typst::foundations::{repr, CastInfo, Repr, Value};
 use typst::layout::Length;
 use typst::model::Document;
 use typst::syntax::{ast, LinkedNode, Source, SyntaxKind};
 use typst::util::{round_2, Numeric};
+use typst::vm::Tracer;
 use typst::World;
 
 use crate::analyze::{analyze_expr, analyze_labels};
@@ -119,7 +119,7 @@ fn closure_tooltip(leaf: &LinkedNode) -> Option<Tooltip> {
         return None;
     }
 
-    // Analyze the closure's captures.
+    /*// Analyze the closure's captures.
     let mut visitor = CapturesVisitor::new(None);
     visitor.visit(parent);
 
@@ -133,7 +133,8 @@ fn closure_tooltip(leaf: &LinkedNode) -> Option<Tooltip> {
     names.sort();
 
     let tooltip = repr::separated_list(&names, "and");
-    Some(Tooltip::Text(eco_format!("This closure captures {tooltip}.")))
+    Some(Tooltip::Text(eco_format!("This closure captures {tooltip}.")))*/
+    None
 }
 
 /// Tooltip text for a hovered length.
@@ -184,7 +185,7 @@ fn named_param_tooltip(world: &dyn World, leaf: &LinkedNode) -> Option<Tooltip>
         };
 
         // Find metadata about the function.
-        if let Some(Value::Func(func)) = world.library().global.scope().get(&callee);
+        if let Some(Value::Func(func)) = world.library().global.scope().get(callee.get());
         then { (func, named) }
         else { return None; }
     };