rename Ast to NodeList to reflect flat strucutre (#217)

Author: joshuadavidthomas

crates/djls-templates/src/ast.rs

@@ -4,7 +4,7 @@ use thiserror::Error;
 use crate::tokens::Token;
 
 #[salsa::tracked(debug)]
-pub struct Ast<'db> {
+pub struct NodeList<'db> {
     #[tracked]
     #[returns(ref)]
     pub nodelist: Vec<Node<'db>>,
@@ -144,9 +144,9 @@ impl Span {
 }
 
 #[derive(Clone, Debug, Error, PartialEq, Eq, Serialize)]
-pub enum AstError {
-    #[error("Empty AST")]
-    EmptyAst,
+pub enum NodeListError {
+    #[error("Empty NodeList")]
+    EmptyNodeList,
     #[error("Invalid tag '{tag}' structure: {reason}")]
     InvalidTagStructure {
         tag: String,
@@ -182,38 +182,38 @@ pub enum AstError {
     TooManyArguments { tag: String, max: usize, span: Span },
 }
 
-impl AstError {
+impl NodeListError {
     /// Get the span start and length of this error, if available
     #[must_use]
     pub fn span(&self) -> Option<(u32, u32)> {
         match self {
-            AstError::UnbalancedStructure { opening_span, .. } => {
+            NodeListError::UnbalancedStructure { opening_span, .. } => {
                 Some((opening_span.start, opening_span.length))
             }
-            AstError::InvalidTagStructure { span, .. }
-            | AstError::InvalidNode { span, .. }
-            | AstError::UnclosedTag { span, .. }
-            | AstError::OrphanedTag { span, .. }
-            | AstError::UnmatchedBlockName { span, .. }
-            | AstError::MissingRequiredArguments { span, .. }
-            | AstError::TooManyArguments { span, .. } => Some((span.start, span.length)),
-            AstError::EmptyAst => None,
+            NodeListError::InvalidTagStructure { span, .. }
+            | NodeListError::InvalidNode { span, .. }
+            | NodeListError::UnclosedTag { span, .. }
+            | NodeListError::OrphanedTag { span, .. }
+            | NodeListError::UnmatchedBlockName { span, .. }
+            | NodeListError::MissingRequiredArguments { span, .. }
+            | NodeListError::TooManyArguments { span, .. } => Some((span.start, span.length)),
+            NodeListError::EmptyNodeList => None,
         }
     }
 
     /// Get a diagnostic code string for this error type
     #[must_use]
     pub fn diagnostic_code(&self) -> &'static str {
         match self {
-            AstError::EmptyAst => "T001",
-            AstError::InvalidTagStructure { .. } => "T002",
-            AstError::UnbalancedStructure { .. } => "T003",
-            AstError::InvalidNode { .. } => "T004",
-            AstError::UnclosedTag { .. } => "T005",
-            AstError::OrphanedTag { .. } => "T006",
-            AstError::UnmatchedBlockName { .. } => "T007",
-            AstError::MissingRequiredArguments { .. } => "T008",
-            AstError::TooManyArguments { .. } => "T009",
+            NodeListError::EmptyNodeList => "T001",
+            NodeListError::InvalidTagStructure { .. } => "T002",
+            NodeListError::UnbalancedStructure { .. } => "T003",
+            NodeListError::InvalidNode { .. } => "T004",
+            NodeListError::UnclosedTag { .. } => "T005",
+            NodeListError::OrphanedTag { .. } => "T006",
+            NodeListError::UnmatchedBlockName { .. } => "T007",
+            NodeListError::MissingRequiredArguments { .. } => "T008",
+            NodeListError::TooManyArguments { .. } => "T009",
         }
     }
 }

crates/djls-templates/src/error.rs

@@ -1,7 +1,7 @@
 use serde::Serialize;
 use thiserror::Error;
 
-use crate::ast::AstError;
+use crate::ast::NodeListError;
 use crate::lexer::LexerError;
 use crate::parser::ParserError;
 
@@ -14,7 +14,7 @@ pub enum TemplateError {
     Parser(String),
 
     #[error("{0}")]
-    Validation(#[from] AstError),
+    Validation(#[from] NodeListError),
 
     #[error("IO error: {0}")]
     Io(String),
@@ -45,7 +45,7 @@ impl TemplateError {
     #[must_use]
     pub fn span(&self) -> Option<(u32, u32)> {
         match self {
-            TemplateError::Validation(ast_error) => ast_error.span(),
+            TemplateError::Validation(nodelist_error) => nodelist_error.span(),
             _ => None,
         }
     }
@@ -55,7 +55,7 @@ impl TemplateError {
         match self {
             TemplateError::Lexer(_) => "T200",
             TemplateError::Parser(_) => "T100",
-            TemplateError::Validation(ast_error) => ast_error.diagnostic_code(),
+            TemplateError::Validation(nodelist_error) => nodelist_error.diagnostic_code(),
             TemplateError::Io(_) => "T900",
             TemplateError::Config(_) => "T901",
         }

crates/djls-templates/src/lib.rs

@@ -54,8 +54,8 @@ pub mod templatetags;
 mod tokens;
 pub mod validation;
 
-pub use ast::Ast;
 use ast::LineOffsets;
+pub use ast::NodeList;
 pub use db::Db;
 pub use db::TemplateDiagnostic;
 use djls_workspace::db::SourceFile;
@@ -100,15 +100,15 @@ fn lex_template(db: &dyn Db, file: SourceFile) -> TokenStream<'_> {
 /// This is the second phase of template processing. It takes the token stream
 /// from lexing and builds an Abstract Syntax Tree.
 #[salsa::tracked]
-fn parse_template(db: &dyn Db, file: SourceFile) -> Ast<'_> {
+fn parse_template(db: &dyn Db, file: SourceFile) -> NodeList<'_> {
     let token_stream = lex_template(db, file);
 
     // Check if lexing produced no tokens (likely due to an error)
     if token_stream.stream(db).is_empty() {
         // Return empty AST for error recovery
         let empty_nodelist = Vec::new();
         let empty_offsets = LineOffsets::default();
-        return Ast::new(db, empty_nodelist, empty_offsets);
+        return NodeList::new(db, empty_nodelist, empty_offsets);
     }
 
     // Parser needs the TokenStream<'db>
@@ -130,7 +130,7 @@ fn parse_template(db: &dyn Db, file: SourceFile) -> Ast<'_> {
             // Return empty AST
             let empty_nodelist = Vec::new();
             let empty_offsets = LineOffsets::default();
-            Ast::new(db, empty_nodelist, empty_offsets)
+            NodeList::new(db, empty_nodelist, empty_offsets)
         }
     }
 }
@@ -207,7 +207,7 @@ fn accumulate_error(db: &dyn Db, error: &TemplateError, line_offsets: &LineOffse
 ///     analyze_template::accumulated::<TemplateDiagnostic>(db, file);
 /// ```
 #[salsa::tracked]
-pub fn analyze_template(db: &dyn Db, file: SourceFile) -> Option<Ast<'_>> {
+pub fn analyze_template(db: &dyn Db, file: SourceFile) -> Option<NodeList<'_>> {
     if file.kind(db) != FileKind::Template {
         return None;
     }

crates/djls-templates/src/parser.rs

@@ -1,10 +1,10 @@
 use thiserror::Error;
 
-use crate::ast::Ast;
-use crate::ast::AstError;
 use crate::ast::CommentNode;
 use crate::ast::FilterName;
 use crate::ast::Node;
+use crate::ast::NodeList;
+use crate::ast::NodeListError;
 use crate::ast::Span;
 use crate::ast::TagName;
 use crate::ast::TagNode;
@@ -35,7 +35,7 @@ impl<'db> Parser<'db> {
         }
     }
 
-    pub fn parse(&mut self) -> Result<(Ast<'db>, Vec<ParserError>), ParserError> {
+    pub fn parse(&mut self) -> Result<(NodeList<'db>, Vec<ParserError>), ParserError> {
         let mut nodelist = Vec::new();
         let mut line_offsets = crate::ast::LineOffsets::default();
 
@@ -64,8 +64,8 @@ impl<'db> Parser<'db> {
             }
         }
 
-        // Create the tracked Ast struct
-        let ast = Ast::new(self.db, nodelist, line_offsets);
+        // Create the tracked NodeList struct
+        let ast = NodeList::new(self.db, nodelist, line_offsets);
 
         Ok((ast, std::mem::take(&mut self.errors)))
     }
@@ -297,7 +297,7 @@ pub enum ParserError {
     #[error("Stream error: {kind:?}")]
     StreamError { kind: StreamError },
     #[error("AST error: {0}")]
-    Ast(#[from] AstError),
+    NodeList(#[from] NodeListError),
 }
 
 impl ParserError {
@@ -360,7 +360,7 @@ mod tests {
     }
 
     #[salsa::tracked]
-    fn parse_test_template(db: &dyn TemplateDb, template: TestTemplate) -> Ast<'_> {
+    fn parse_test_template(db: &dyn TemplateDb, template: TestTemplate) -> NodeList<'_> {
         let source = template.source(db);
         let tokens = Lexer::new(source).tokenize().unwrap();
         let token_stream = TokenStream::new(db, tokens);
@@ -423,7 +423,7 @@ mod tests {
         }
     }
 
-    fn convert_ast_for_testing(ast: Ast<'_>, db: &dyn crate::db::Db) -> TestAst {
+    fn convert_ast_for_testing(ast: NodeList<'_>, db: &dyn crate::db::Db) -> TestAst {
         TestAst {
             nodelist: convert_nodelist_for_testing(ast.nodelist(db), db),
             line_offsets: ast.line_offsets(db).0.clone(),