remove salsa from the inner workings of the template crate (#259)

Author: joshuadavidthomas

crates/djls-bench/benches/parser.rs

@@ -8,56 +8,18 @@ fn main() {
 }
 
 #[divan::bench(args = template_fixtures())]
-fn parse_template(bencher: Bencher, fixture: &TemplateFixture) {
-    let db = std::cell::RefCell::new(Db::new());
-
-    let counter = std::cell::Cell::new(0_usize);
-
-    bencher
-        .with_inputs(|| {
-            let i = counter.get();
-            counter.set(i + 1);
-            let path = format!("{}.bench{}", fixture.path.clone(), i);
-            db.borrow_mut()
-                .file_with_contents(path.into(), &fixture.source.clone())
-        })
-        .bench_local_values(|file| {
-            let db = db.borrow();
-            if let Some(nodelist) = djls_templates::parse_template(&*db, file) {
-                divan::black_box(nodelist.nodelist(&*db).len());
-            }
-        });
+fn parse_template(fixture: &TemplateFixture) {
+    let _ = djls_templates::parse_template_impl(&fixture.source);
 }
 
 #[divan::bench]
 fn parse_all_templates(bencher: Bencher) {
     let fixtures = template_fixtures();
-    let db = std::cell::RefCell::new(Db::new());
-
-    let counter = std::cell::Cell::new(0_usize);
-
-    bencher
-        .with_inputs(|| {
-            let i = counter.get();
-            counter.set(i + 1);
-
-            let mut db = db.borrow_mut();
-            fixtures
-                .iter()
-                .map(|fixture| {
-                    let path = format!("{}.bench{}", fixture.path, i);
-                    db.file_with_contents(path.into(), &fixture.source)
-                })
-                .collect::<Vec<_>>()
-        })
-        .bench_local_values(|files| {
-            let db = db.borrow();
-            for file in files {
-                if let Some(nodelist) = djls_templates::parse_template(&*db, file) {
-                    divan::black_box(nodelist.nodelist(&*db).len());
-                }
-            }
-        });
+    bencher.bench_local(move || {
+        for fixture in fixtures {
+            let _ = djls_templates::parse_template_impl(&fixture.source);
+        }
+    });
 }
 
 #[divan::bench(args = template_fixtures())]

crates/djls-semantic/src/blocks/builder.rs

@@ -1,6 +1,4 @@
 use djls_source::Span;
-use djls_templates::nodelist::TagBit;
-use djls_templates::nodelist::TagName;
 use djls_templates::tokens::TagDelimiter;
 use djls_templates::Node;
 
@@ -49,7 +47,7 @@ enum BlockSemanticOp {
 pub struct BlockTreeBuilder<'db> {
     db: &'db dyn Db,
     index: &'db TagIndex,
-    stack: Vec<TreeFrame<'db>>,
+    stack: Vec<TreeFrame>,
     block_allocs: Vec<(Span, Option<BlockId>)>,
     semantic_ops: Vec<BlockSemanticOp>,
 }
@@ -136,9 +134,9 @@ impl<'db> BlockTreeBuilder<'db> {
         tree
     }
 
-    fn handle_tag(&mut self, name: TagName<'db>, bits: Vec<TagBit<'db>>, span: Span) {
-        let tag_name = name.text(self.db);
-        match self.index.classify(&tag_name) {
+    fn handle_tag(&mut self, name: &str, bits: &[String], span: Span) {
+        let tag_name = name;
+        match self.index.classify(tag_name) {
             TagClass::Opener => {
                 let parent = get_active_segment(&self.stack);
 
@@ -152,14 +150,14 @@ impl<'db> BlockTreeBuilder<'db> {
                     // Nested block
                     self.semantic_ops.push(BlockSemanticOp::AddBranchNode {
                         target: parent_id,
-                        tag: tag_name.clone(),
+                        tag: tag_name.to_string(),
                         marker_span: span,
                         body: container,
                         kind: BranchKind::Opener,
                     });
                     self.semantic_ops.push(BlockSemanticOp::AddBranchNode {
                         target: container,
-                        tag: tag_name.clone(),
+                        tag: tag_name.to_string(),
                         marker_span: span,
                         body: segment,
                         kind: BranchKind::Segment,
@@ -170,41 +168,41 @@ impl<'db> BlockTreeBuilder<'db> {
                         .push(BlockSemanticOp::AddRoot { id: container });
                     self.semantic_ops.push(BlockSemanticOp::AddBranchNode {
                         target: container,
-                        tag: tag_name.clone(),
+                        tag: tag_name.to_string(),
                         marker_span: span,
                         body: segment,
                         kind: BranchKind::Segment,
                     });
                 }
 
                 self.stack.push(TreeFrame {
-                    opener_name: tag_name,
-                    opener_bits: bits,
+                    opener_name: tag_name.to_string(),
+                    opener_bits: bits.to_vec(),
                     opener_span: span,
                     container_body: container,
                     segment_body: segment,
                     parent_body: parent,
                 });
             }
             TagClass::Closer { opener_name } => {
-                self.close_block(&opener_name, &bits, span);
+                self.close_block(&opener_name, bits, span);
             }
             TagClass::Intermediate { possible_openers } => {
-                self.add_intermediate(&tag_name, &possible_openers, span);
+                self.add_intermediate(tag_name, &possible_openers, span);
             }
             TagClass::Unknown => {
                 if let Some(segment) = get_active_segment(&self.stack) {
                     self.semantic_ops.push(BlockSemanticOp::AddLeafNode {
                         target: segment,
-                        label: tag_name,
+                        label: tag_name.to_string(),
                         span,
                     });
                 }
             }
         }
     }
 
-    fn close_block(&mut self, opener_name: &str, closer_bits: &[TagBit<'db>], span: Span) {
+    fn close_block(&mut self, opener_name: &str, closer_bits: &[String], span: Span) {
         if let Some(frame_idx) = find_frame_from_opener(&self.stack, opener_name) {
             // Pop any unclosed blocks above this one
             while self.stack.len() > frame_idx + 1 {
@@ -349,7 +347,7 @@ impl<'db> BlockTreeBuilder<'db> {
     }
 }
 
-type TreeStack<'db> = Vec<TreeFrame<'db>>;
+type TreeStack = Vec<TreeFrame>;
 
 /// Get the currently active segment (the innermost block we're in)
 fn get_active_segment(stack: &TreeStack) -> Option<BlockId> {
@@ -361,9 +359,9 @@ fn find_frame_from_opener(stack: &TreeStack, opener_name: &str) -> Option<usize>
     stack.iter().rposition(|f| f.opener_name == opener_name)
 }
 
-struct TreeFrame<'db> {
+struct TreeFrame {
     opener_name: String,
-    opener_bits: Vec<TagBit<'db>>,
+    opener_bits: Vec<String>,
     opener_span: Span,
     container_body: BlockId,
     segment_body: BlockId,
@@ -373,10 +371,10 @@ struct TreeFrame<'db> {
 impl<'db> SemanticModel<'db> for BlockTreeBuilder<'db> {
     type Model = BlockTree;
 
-    fn observe(&mut self, node: Node<'db>) {
+    fn observe(&mut self, node: Node) {
         match node {
             Node::Tag { name, bits, span } => {
-                self.handle_tag(name, bits, span);
+                self.handle_tag(&name, &bits, span);
             }
             Node::Comment { span, .. } => {
                 if let Some(parent) = get_active_segment(&self.stack) {

crates/djls-semantic/src/blocks/grammar.rs

@@ -1,4 +1,3 @@
-use djls_templates::nodelist::TagBit;
 use rustc_hash::FxHashMap;
 
 use crate::templatetags::TagSpecs;
@@ -52,12 +51,12 @@ impl TagIndex {
             .is_some_and(|meta| meta.optional)
     }
 
-    pub fn validate_close<'db>(
+    pub fn validate_close(
         &self,
         opener_name: &str,
-        opener_bits: &[TagBit<'db>],
-        closer_bits: &[TagBit<'db>],
-        db: &'db dyn crate::db::Db,
+        opener_bits: &[String],
+        closer_bits: &[String],
+        _db: &dyn crate::db::Db,
     ) -> CloseValidation {
         let Some(meta) = self.openers.get(opener_name) else {
             return CloseValidation::NotABlock;
@@ -69,8 +68,8 @@ impl TagIndex {
         }
 
         for match_arg in &meta.match_args {
-            let opener_val = extract_arg_value(opener_bits, match_arg.position, db);
-            let closer_val = extract_arg_value(closer_bits, match_arg.position, db);
+            let opener_val = extract_arg_value(opener_bits, match_arg.position);
+            let closer_val = extract_arg_value(closer_bits, match_arg.position);
 
             match (opener_val, closer_val, match_arg.required) {
                 (Some(o), Some(c), _) if o != c => {
@@ -185,13 +184,9 @@ pub enum CloseValidation {
     },
 }
 
-fn extract_arg_value<'db>(
-    bits: &[TagBit<'db>],
-    position: usize,
-    db: &'db dyn crate::db::Db,
-) -> Option<String> {
+fn extract_arg_value(bits: &[String], position: usize) -> Option<String> {
     if position < bits.len() {
-        Some(bits[position].text(db).to_string())
+        Some(bits[position].clone())
     } else {
         None
     }

crates/djls-semantic/src/blocks/tree.rs

@@ -347,13 +347,13 @@ mod tests {
                 .iter()
                 .map(|n| match n {
                     Node::Tag { name, bits, span } => NodeView::Tag {
-                        name: name.text(&db).to_string(),
-                        bits: bits.iter().map(|b| b.text(&db).to_string()).collect(),
+                        name: name.clone(),
+                        bits: bits.clone(),
                         span: *span,
                     },
                     Node::Variable { var, filters, span } => NodeView::Variable {
-                        var: var.text(&db).to_string(),
-                        filters: filters.iter().map(|f| f.text(&db).to_string()).collect(),
+                        var: var.clone(),
+                        filters: filters.clone(),
                         span: *span,
                     },
                     Node::Comment { content, span } => NodeView::Comment {

crates/djls-semantic/src/traits.rs

@@ -25,7 +25,7 @@ pub trait SemanticModel<'db> {
 
     /// Observe a single node during traversal and extract semantic information
     #[allow(dead_code)] // use is gated behind cfg(test) for now
-    fn observe(&mut self, node: Node<'db>);
+    fn observe(&mut self, node: Node);
 
     /// Construct the final semantic model from observed semantics
     #[allow(dead_code)] // use is gated behind cfg(test) for now