feat!(ltk_ritobin): AST

.vscode/settings.json

@@ -1,3 +1,4 @@
 {
-    "rust-analyzer.cargo.allTargets": true
+    "rust-analyzer.cargo.allTargets": true,
+    "nixEnvSelector.suggestion": false
 }

Cargo.toml

@@ -43,6 +43,7 @@ insta = { version = "1.39.0", features = ["ron"] }
 camino = "1.2.1"
 
 pretty_assertions = "1.4.1"
+proptest = "1.5.0"
 
 criterion = {version = "0.8",  features = ["html_reports"] }
 

crates/ltk_meta/src/property/kind.rs

@@ -85,7 +85,7 @@ impl Kind {
     /// Whether this property kind is a primitive type. (i8, u8, .. u32, u64, f32, Vector2, Vector3, Vector4, Matrix44, Color, String, Hash, WadChunkLink),
     #[inline(always)]
     #[must_use]
-    pub fn is_primitive(&self) -> bool {
+    pub const fn is_primitive(&self) -> bool {
         use Kind::*;
         matches!(
             self,
@@ -123,7 +123,7 @@ impl Kind {
     /// shipped bin in the client keys a map on any of them.
     #[inline(always)]
     #[must_use]
-    pub fn is_valid_map_key(&self) -> bool {
+    pub const fn is_valid_map_key(&self) -> bool {
         use Kind::*;
         matches!(
             self,
@@ -151,13 +151,13 @@ impl Kind {
     /// Whether this property kind is a container type (container, unordered container, optional, map).
     #[inline(always)]
     #[must_use]
-    pub fn is_container(&self) -> bool {
+    pub const fn is_container(&self) -> bool {
         self.subtype_count() > 0
     }
 
     #[inline(always)]
     #[must_use]
-    pub fn subtype_count(&self) -> u8 {
+    pub const fn subtype_count(&self) -> u8 {
         use Kind::*;
         match self {
             Container | UnorderedContainer | Optional => 1,

crates/ltk_ritobin/Cargo.toml

@@ -21,13 +21,18 @@ harness = false
 name = "e2e"
 harness = false
 
+[[bench]]
+name = "ast"
+harness = false
+
 [lints]
 workspace = true
 
 [features]
 default = []
 debug = []
 serde = ["dep:serde", "ltk_meta/serde"]
+salsa = ["dep:salsa"]
 
 [dependencies]
 nom = "7.1"
@@ -46,11 +51,12 @@ ltk_hash = { version = "0.4.0", path = "../ltk_hash" }
 ltk_primitives = { version = "0.3.5", path = "../ltk_primitives" }
 
 serde = { workspace = true, optional = true }
-salsa = "0.22.0"
+salsa = { version = "0.22.0", optional = true }
 
 [dev-dependencies]
 insta.workspace = true
 pretty_assertions.workspace = true
+proptest.workspace = true
 serde.workspace = true
 criterion.workspace = true
 ltk_ritobin = { path = ".", features = ["serde"] }

crates/ltk_ritobin/benches/ast.rs

@@ -0,0 +1,86 @@
+//! Compares the two typecheckers' phases against the same parsed input: `typecheck::walk`
+//! (`Cst::build_bin`, CST -> `Bin` in one pass) vs. the new `ast` engine's two halves
+//! (`Cst::build_ast`, CST -> `Ast`; and `Ast::to_bin`, `Ast` -> `Bin`) - see the crate's design
+//! notes for why `ast` is a second, independent implementation rather than a shared pipeline.
+//!
+//! Parsing itself is excluded (see `benches/parse.rs`): the `Cst` (and, for the `ast_to_bin`
+//! group, the `Ast`) is built once outside every timed closure, so each group measures only the
+//! one phase it names.
+
+use std::fs::read_to_string;
+
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use ltk_ritobin::Cst;
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let dir = env!("CARGO_MANIFEST_DIR");
+    let samples = [
+        read_to_string(format!("{dir}/samples/aatrox.rito")).unwrap(),
+        read_to_string(format!("{dir}/samples/azirultsoldier.rito")).unwrap(),
+        read_to_string(format!("{dir}/samples/big.rito")).unwrap(),
+        read_to_string(format!("{dir}/samples/skin38.rito")).unwrap(),
+        read_to_string(format!("{dir}/samples/test.rito")).unwrap(),
+        read_to_string(format!("{dir}/samples/zaahen.rito")).unwrap(),
+    ];
+
+    {
+        let mut group = c.benchmark_group("cst_to_bin");
+        for sample in &samples {
+            let size = sample.len();
+            let cst = Cst::parse(sample);
+
+            group.throughput(Throughput::Bytes(size.try_into().unwrap()));
+            group.bench_with_input(
+                BenchmarkId::from_parameter(size),
+                &(cst, sample),
+                |b, (cst, sample)| {
+                    b.iter(|| {
+                        let _partial = std::hint::black_box(cst.build_bin(sample));
+                    })
+                },
+            );
+        }
+    }
+
+    {
+        let mut group = c.benchmark_group("cst_to_ast");
+        for sample in &samples {
+            let size = sample.len();
+            let cst = Cst::parse(sample);
+
+            group.throughput(Throughput::Bytes(size.try_into().unwrap()));
+            group.bench_with_input(
+                BenchmarkId::from_parameter(size),
+                &(cst, sample),
+                |b, (cst, sample)| {
+                    b.iter(|| {
+                        let _ast = std::hint::black_box(cst.build_ast(sample));
+                    })
+                },
+            );
+        }
+    }
+
+    {
+        let mut group = c.benchmark_group("ast_to_bin");
+        for sample in &samples {
+            let size = sample.len();
+            let cst = Cst::parse(sample);
+            let ast = cst.build_ast(sample);
+
+            group.throughput(Throughput::Bytes(size.try_into().unwrap()));
+            group.bench_with_input(
+                BenchmarkId::from_parameter(size),
+                &(ast, sample),
+                |b, (ast, sample)| {
+                    b.iter(|| {
+                        let _bin = std::hint::black_box(ast.to_bin(sample));
+                    })
+                },
+            );
+        }
+    }
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

crates/ltk_ritobin/benches/e2e.rs

@@ -33,9 +33,9 @@ fn criterion_benchmark(c: &mut Criterion) {
 
 fn e2e(txt: &str) -> Cst {
     let cst = Cst::parse(txt);
-    let (bin, _errs) = cst.build_bin(txt);
+    let partial = cst.build_bin(txt);
     let mut str = String::new();
-    bin.print_to_writer(&mut str).unwrap();
+    partial.bin.print_to_writer(&mut str).unwrap();
     cst
 }
 

crates/ltk_ritobin/benches/parse.rs

@@ -40,7 +40,7 @@ fn criterion_benchmark(c: &mut Criterion) {
                 &(cst, sample),
                 |b, (cst, sample)| {
                     b.iter(|| {
-                        let (_bin, _errs) = black_box(cst.build_bin(sample));
+                        let _partial = black_box(cst.build_bin(sample));
                     })
                 },
             );

crates/ltk_ritobin/benches/print.rs

@@ -20,7 +20,7 @@ fn criterion_benchmark(c: &mut Criterion) {
         for sample in &samples {
             let size = sample.len();
             let cst = Cst::parse(sample);
-            let (bin, _errs) = cst.build_bin(sample);
+            let bin = cst.build_bin(sample).bin;
 
             group.throughput(Throughput::Bytes(size.try_into().unwrap()));
             group.bench_with_input(BenchmarkId::from_parameter(size), &bin, |b, bin| {

crates/ltk_ritobin/examples/rito_to_bin.rs

@@ -23,14 +23,16 @@ fn main() {
         return;
     }
 
-    let (bin, errors) = cst.build_bin(&text);
-    if !errors.is_empty() {
-        eprintln!("Errors while converting to bin:");
-        for err in errors {
-            eprintln!("- {err:#?}");
+    let bin = match cst.build_bin(&text).into_result() {
+        Ok(bin) => bin,
+        Err(partial) => {
+            eprintln!("Errors while converting to bin:");
+            for diag in &partial.diagnostics {
+                eprintln!("- {diag:#?}");
+            }
+            return;
         }
-        return;
-    }
+    };
 
     let mut file = File::create(output_path).unwrap();
     bin.to_writer(&mut file).unwrap();

crates/ltk_ritobin/src/ast.rs

@@ -0,0 +1,44 @@
+pub mod builder;
+pub mod diagnostics;
+pub mod hash;
+pub mod node;
+pub mod query;
+pub mod resolve;
+pub mod visitor;
+
+mod to_bin;
+
+#[cfg(test)]
+mod tests;
+
+pub use crate::Spanned;
+pub use node::{Object, Property, RootEntry, Value};
+pub use to_bin::PartialBin;
+
+use crate::{
+    ast::{diagnostics::DiagnosticWithSpan, node::roots::Roots},
+    Cst,
+};
+
+#[cfg(not(feature = "salsa"))]
+pub(crate) type Ptr<T> = Box<T>;
+#[cfg(feature = "salsa")]
+pub(crate) type Ptr<T> = std::sync::Arc<T>;
+
+#[derive(Debug, Clone)]
+pub struct Ast {
+    pub roots: Roots,
+    pub diagnostics: Vec<DiagnosticWithSpan>,
+}
+
+impl Ast {
+    pub fn root_entries(&self) -> impl Iterator<Item = &RootEntry> {
+        self.roots.entries().unwrap_or_default().iter()
+    }
+}
+
+impl Cst {
+    pub fn build_ast(&self, text: &str) -> crate::ast::Ast {
+        crate::ast::Ast::from_cst(self, text)
+    }
+}

crates/ltk_ritobin/src/ast/builder.rs

@@ -0,0 +1,35 @@
+use crate::{
+    ast::{diagnostics::DiagnosticWithSpan, Ast},
+    cst::Cst,
+};
+
+mod root_entry;
+pub use root_entry::*;
+
+impl Ast {
+    pub fn from_cst(cst: &Cst, text: &str) -> Self {
+        let ctx = Builder {
+            cst,
+            text,
+            diagnostics: Vec::new(),
+        };
+        ctx.build()
+    }
+}
+
+#[derive(Debug, Clone)]
+pub(super) struct Builder<'a> {
+    pub cst: &'a Cst,
+    pub text: &'a str,
+    pub diagnostics: Vec<DiagnosticWithSpan>,
+}
+
+impl<'a> Builder<'a> {
+    pub(super) fn cst(&self) -> &'a Cst {
+        self.cst
+    }
+
+    pub(super) fn push(&mut self, d: DiagnosticWithSpan) {
+        self.diagnostics.push(d);
+    }
+}