[WIP] Replace eval with bytecode-based VM

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"

crates/typst-syntax/Cargo.toml

@@ -16,6 +16,7 @@ doctest = false
 bench = false
 
 [dependencies]
+bytemuck = { workspace = true }
 comemo = { workspace = true }
 ecow = { workspace = true }
 once_cell = { workspace = true }

crates/typst-syntax/src/file.rs

@@ -6,6 +6,7 @@ use std::path::{Component, Path, PathBuf};
 use std::str::FromStr;
 use std::sync::RwLock;
 
+use bytemuck::{Pod, Zeroable};
 use ecow::{eco_format, EcoString};
 use once_cell::sync::Lazy;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
@@ -28,7 +29,8 @@ type Pair = &'static (Option<PackageSpec>, VirtualPath);
 /// Identifies a file in a project or package.
 ///
 /// This type is globally interned and thus cheap to copy, compare, and hash.
-#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Pod, Zeroable)]
+#[repr(transparent)]
 pub struct FileId(u16);
 
 impl FileId {

crates/typst-syntax/src/span.rs

@@ -26,6 +26,7 @@ use crate::FileId;
 /// This type takes up 8 bytes and is null-optimized (i.e. `Option<Span>` also
 /// takes 8 bytes).
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+#[repr(transparent)]
 pub struct Span(NonZeroU64);
 
 impl Span {
@@ -54,6 +55,20 @@ impl Span {
         }
     }
 
+    /// Create a new span from its raw representation.
+    ///
+    /// # Safety
+    ///
+    /// The raw representation must be a valid span.
+    pub const unsafe fn new_unchecked(number: NonZeroU64) -> Self {
+        Self(number)
+    }
+
+    /// Get the raw representation of this span.
+    pub const fn as_raw(self) -> NonZeroU64 {
+        self.0
+    }
+
     /// Create a span that does not point into any source file.
     pub const fn detached() -> Self {
         match NonZeroU64::new(Self::DETACHED) {

crates/typst/Cargo.toml

@@ -21,6 +21,7 @@ typst-syntax = { workspace = true }
 typst-timing = { workspace = true }
 az = { workspace = true }
 bitflags = { workspace = true }
+bytemuck = { workspace = true }
 chinese-number = { workspace = true }
 ciborium = { workspace = true }
 comemo = { workspace = true }

crates/typst/src/compiler/access.rs

@@ -0,0 +1,166 @@
+use std::sync::Arc;
+
+use ecow::EcoString;
+use typst_syntax::ast::{self, AstNode};
+
+use super::{Compile, Compiler, ReadableGuard, WritableGuard};
+use crate::diag::{bail, At, SourceResult};
+use crate::engine::Engine;
+use crate::vm::Access as VmAccess;
+
+#[derive(Debug, Clone)]
+pub enum AccessPattern {
+    /// Access this value through a readable.
+    Readable(ReadableGuard),
+
+    /// Access this value through a writeable.
+    Writable(WritableGuard),
+
+    /// Access this value through a chained access.
+    Chained(Arc<Self>, EcoString),
+
+    /// Access this value through an accessor method.
+    AccessorMethod(Arc<Self>, EcoString, ReadableGuard),
+}
+
+impl AccessPattern {
+    pub fn as_vm_access(&self) -> VmAccess {
+        match self {
+            AccessPattern::Readable(r) => VmAccess::Readable(r.as_readable()),
+            AccessPattern::Writable(w) => VmAccess::Writable(w.as_writable()),
+            AccessPattern::Chained(other, v) => {
+                VmAccess::Chained(Arc::new(other.as_vm_access()), v.clone())
+            }
+            AccessPattern::AccessorMethod(other, v, r) => VmAccess::AccessorMethod(
+                Arc::new(other.as_vm_access()),
+                v.clone(),
+                r.as_readable(),
+            ),
+        }
+    }
+}
+
+pub trait Access {
+    /// Generate an access to the value.
+    fn access<'a>(
+        self,
+        engine: &mut Engine,
+        compiler: &'a mut Compiler,
+        mutable: bool,
+    ) -> SourceResult<AccessPattern>;
+}
+
+impl Access for ast::Expr<'_> {
+    fn access<'a>(
+        self,
+        engine: &mut Engine,
+        compiler: &'a mut Compiler,
+        mutable: bool,
+    ) -> SourceResult<AccessPattern> {
+        match self {
+            Self::Ident(v) => v.access(engine, compiler, mutable),
+            Self::Parenthesized(v) => v.access(engine, compiler, mutable),
+            Self::FieldAccess(v) => v.access(engine, compiler, mutable),
+            Self::FuncCall(v) => v.access(engine, compiler, mutable),
+            _ if mutable => {
+                bail!(self.span(), "cannot mutate a temporary value");
+            }
+            other => {
+                let value = other.compile(engine, compiler)?;
+                Ok(AccessPattern::Readable(value))
+            }
+        }
+    }
+}
+
+impl Access for ast::Ident<'_> {
+    fn access<'a>(
+        self,
+        _: &mut Engine,
+        compiler: &'a mut Compiler,
+        mutable: bool,
+    ) -> SourceResult<AccessPattern> {
+        match compiler.read(self.span(), self.get()).at(self.span())? {
+            Some(ReadableGuard::Register(reg)) => {
+                if mutable {
+                    Ok(AccessPattern::Writable(reg.into()))
+                } else {
+                    Ok(AccessPattern::Readable(reg.into()))
+                }
+            }
+            Some(ReadableGuard::Parent(parent)) => {
+                if mutable {
+                    Ok(AccessPattern::Writable(parent.into()))
+                } else {
+                    Ok(AccessPattern::Readable(parent.into()))
+                }
+            }
+            Some(ReadableGuard::Captured(cap)) => {
+                if mutable {
+                    bail!(self.span(), "cannot mutate a captured value")
+                } else {
+                    Ok(AccessPattern::Readable(cap.into()))
+                }
+            }
+            Some(ReadableGuard::Global(global)) => {
+                if mutable {
+                    bail!(self.span(), "cannot mutate a global value")
+                } else {
+                    Ok(AccessPattern::Readable(global.into()))
+                }
+            }
+            None => bail!(self.span(), "could not find `{}` in scope", self.get()),
+            _ => unreachable!(),
+        }
+    }
+}
+
+impl Access for ast::Parenthesized<'_> {
+    fn access<'a>(
+        self,
+        engine: &mut Engine,
+        compiler: &'a mut Compiler,
+        mutable: bool,
+    ) -> SourceResult<AccessPattern> {
+        self.expr().access(engine, compiler, mutable)
+    }
+}
+
+impl Access for ast::FieldAccess<'_> {
+    fn access<'a>(
+        self,
+        engine: &mut Engine,
+        compiler: &'a mut Compiler,
+        mutable: bool,
+    ) -> SourceResult<AccessPattern> {
+        let left = self.target().access(engine, compiler, mutable)?;
+        Ok(AccessPattern::Chained(Arc::new(left), self.field().get().clone()))
+    }
+}
+
+impl Access for ast::FuncCall<'_> {
+    fn access<'a>(
+        self,
+        engine: &mut Engine,
+        compiler: &'a mut Compiler,
+        mutable: bool,
+    ) -> SourceResult<AccessPattern> {
+        if !mutable {
+            // Compile the function call.
+            let call = self.compile(engine, compiler)?;
+            Ok(AccessPattern::Readable(call))
+        } else if let ast::Expr::FieldAccess(access) = self.callee() {
+            // Compile the arguments.
+            let args = self.args();
+            let args = args.compile(engine, compiler)?;
+
+            // Ensure that the arguments live long enough.
+            let left = access.target().access(engine, compiler, mutable)?;
+
+            let method = access.field();
+            Ok(AccessPattern::AccessorMethod(Arc::new(left), method.get().clone(), args))
+        } else {
+            bail!(self.span(), "cannot mutate a temporary value")
+        }
+    }
+}