fix template analysis after semantic crate refactor (#225)

Author: joshuadavidthomas

crates/djls-semantic/src/db.rs

@@ -2,12 +2,27 @@ use std::sync::Arc;
 
 use djls_templates::Db as TemplateDb;
 use djls_workspace::Db as WorkspaceDb;
+use tower_lsp_server::lsp_types;
 
 use crate::specs::TagSpecs;
 
-/// Semantic database trait extending the template and workspace databases
 #[salsa::db]
 pub trait SemanticDb: TemplateDb + WorkspaceDb {
     /// Get the Django tag specifications for semantic analysis
     fn tag_specs(&self) -> Arc<TagSpecs>;
 }
+
+#[salsa::accumulator]
+pub struct SemanticDiagnostic(pub lsp_types::Diagnostic);
+
+impl From<SemanticDiagnostic> for lsp_types::Diagnostic {
+    fn from(diagnostic: SemanticDiagnostic) -> Self {
+        diagnostic.0
+    }
+}
+
+impl From<&SemanticDiagnostic> for lsp_types::Diagnostic {
+    fn from(diagnostic: &SemanticDiagnostic) -> Self {
+        diagnostic.0.clone()
+    }
+}

crates/djls-semantic/src/lib.rs

@@ -6,6 +6,8 @@ pub mod validation;
 
 pub use builtins::django_builtin_specs;
 pub use db::SemanticDb;
+pub use db::SemanticDiagnostic;
+use salsa::Accumulator;
 pub use snippets::generate_partial_snippet;
 pub use snippets::generate_snippet_for_tag;
 pub use snippets::generate_snippet_for_tag_with_end;
@@ -17,6 +19,7 @@ pub use specs::SimpleArgType;
 pub use specs::TagArg;
 pub use specs::TagSpec;
 pub use specs::TagSpecs;
+use tower_lsp_server::lsp_types;
 pub use validation::TagValidator;
 
 pub enum TagType {
@@ -40,3 +43,46 @@ impl TagType {
         }
     }
 }
+
+/// Validate a Django template node list and return validation errors.
+///
+/// This function runs the TagValidator on the parsed node list to check for:
+/// - Unclosed block tags
+/// - Mismatched tag pairs
+/// - Orphaned intermediate tags
+/// - Invalid argument counts
+/// - Unmatched block names
+#[salsa::tracked]
+pub fn validate_nodelist(db: &dyn SemanticDb, nodelist: djls_templates::NodeList<'_>) {
+    if nodelist.nodelist(db).is_empty() {
+        return;
+    }
+
+    let validation_errors = TagValidator::new(db, nodelist).validate();
+
+    let line_offsets = nodelist.line_offsets(db);
+    for error in validation_errors {
+        let code = error.diagnostic_code();
+        let range = error
+            .span()
+            .map(|(start, length)| {
+                let span = djls_templates::nodelist::Span::new(start, length);
+                span.to_lsp_range(line_offsets)
+            })
+            .unwrap_or_default();
+
+        let diagnostic = lsp_types::Diagnostic {
+            range,
+            severity: Some(lsp_types::DiagnosticSeverity::ERROR),
+            code: Some(lsp_types::NumberOrString::String(code.to_string())),
+            code_description: None,
+            source: Some("Django Language Server".to_string()),
+            message: error.to_string(),
+            related_information: None,
+            tags: None,
+            data: None,
+        };
+
+        SemanticDiagnostic(diagnostic).accumulate(db);
+    }
+}

crates/djls-semantic/src/validation.rs

@@ -15,13 +15,13 @@
 //! ## Architecture
 //!
 //! The `TagValidator` follows the same pattern as the Parser and Lexer,
-//! maintaining minimal state and walking through the AST to accumulate errors.
+//! maintaining minimal state and walking through the node list to accumulate errors.
 
-use djls_templates::ast::Node;
-use djls_templates::ast::NodeListError;
-use djls_templates::ast::Span;
-use djls_templates::ast::TagBit;
-use djls_templates::ast::TagName;
+use djls_templates::nodelist::Node;
+use djls_templates::nodelist::NodeListError;
+use djls_templates::nodelist::Span;
+use djls_templates::nodelist::TagBit;
+use djls_templates::nodelist::TagName;
 use djls_templates::NodeList;
 
 use crate::db::SemanticDb;

crates/djls-server/src/server.rs

@@ -2,7 +2,9 @@ use std::future::Future;
 use std::sync::Arc;
 
 use djls_project::Db as ProjectDb;
-use djls_templates::analyze_template;
+use djls_semantic::validate_nodelist;
+use djls_semantic::SemanticDiagnostic;
+use djls_templates::parse_template;
 use djls_templates::TemplateDiagnostic;
 use djls_workspace::paths;
 use djls_workspace::FileKind;
@@ -96,14 +98,26 @@ impl DjangoLanguageServer {
                 let file = session.get_or_create_file(&path);
 
                 session.with_db(|db| {
-                    // Parse and validate the template (triggers accumulation)
-                    // This should be a cheap call since salsa should cache the function
-                    // call, but we may need to revisit if that assumption is incorrect
-                    let _ast = analyze_template(db, file);
+                    let Some(nodelist) = parse_template(db, file) else {
+                        // If parsing failed completely, just return syntax errors
+                        return parse_template::accumulated::<TemplateDiagnostic>(db, file)
+                            .into_iter()
+                            .map(Into::into)
+                            .collect();
+                    };
+
+                    validate_nodelist(db, nodelist);
 
-                    let diagnostics = analyze_template::accumulated::<TemplateDiagnostic>(db, file);
+                    let syntax_diagnostics =
+                        parse_template::accumulated::<TemplateDiagnostic>(db, file);
+                    let semantic_diagnostics =
+                        validate_nodelist::accumulated::<SemanticDiagnostic>(db, nodelist);
 
-                    diagnostics.into_iter().map(Into::into).collect()
+                    syntax_diagnostics
+                        .into_iter()
+                        .map(Into::into)
+                        .chain(semantic_diagnostics.into_iter().map(Into::into))
+                        .collect()
                 })
             })
             .await;
@@ -240,7 +254,6 @@ impl LanguageServer for DjangoLanguageServer {
             })
             .await;
 
-        // Publish diagnostics for template files
         if let Some((url, version)) = url_version {
             self.publish_diagnostics(&url, Some(version)).await;
         }
@@ -262,7 +275,6 @@ impl LanguageServer for DjangoLanguageServer {
             })
             .await;
 
-        // Publish diagnostics for template files
         if let Some((url, version)) = url_version {
             self.publish_diagnostics(&url, version).await;
         }
@@ -426,14 +438,25 @@ impl LanguageServer for DjangoLanguageServer {
                         return vec![];
                     };
 
-                    // Parse and validate the template (triggers accumulation)
-                    let _ast = analyze_template(db, file);
+                    let Some(nodelist) = parse_template(db, file) else {
+                        return parse_template::accumulated::<TemplateDiagnostic>(db, file)
+                            .into_iter()
+                            .map(Into::into)
+                            .collect();
+                    };
+
+                    validate_nodelist(db, nodelist);
 
-                    // Get accumulated diagnostics directly - they're already LSP diagnostics!
-                    let diagnostics = analyze_template::accumulated::<TemplateDiagnostic>(db, file);
+                    let syntax_diagnostics =
+                        parse_template::accumulated::<TemplateDiagnostic>(db, file);
+                    let semantic_diagnostics =
+                        validate_nodelist::accumulated::<SemanticDiagnostic>(db, nodelist);
 
-                    // Convert from TemplateDiagnostic wrapper to lsp_types::Diagnostic
-                    diagnostics.into_iter().map(Into::into).collect()
+                    syntax_diagnostics
+                        .into_iter()
+                        .map(Into::into)
+                        .chain(semantic_diagnostics.into_iter().map(Into::into))
+                        .collect()
                 })
             })
             .await;

crates/djls-templates/src/db.rs

@@ -14,30 +14,30 @@
 //! ## Key Components
 //!
 //! - [`Db`]: Database trait extending the workspace database
-//! - [`analyze_template`]: Main entry point for template analysis
+//! - [`parse_template`]: Main entry point for template parsing
 //! - [`TemplateDiagnostic`]: Accumulator for collecting LSP diagnostics
 //!
 //! ## Incremental Computation
 //!
 //! When a template file changes:
 //! 1. Salsa invalidates the cached AST for that file
-//! 2. Next access to `analyze_template` triggers reparse
+//! 2. Next access to `parse_template` triggers reparse
 //! 3. Diagnostics are accumulated during parse/validation
 //! 4. Other files remain cached unless they also changed
 //!
 //! ## Example
 //!
 //! ```ignore
-//! // Analyze a template and get its AST
-//! let ast = analyze_template(db, file);
+//! // Parse a template and get its AST
+//! let nodelist = parse_template(db, file);
 //!
 //! // Retrieve accumulated diagnostics
-//! let diagnostics = analyze_template::accumulated::<TemplateDiagnostic>(db, file);
+//! let diagnostics = parse_template::accumulated::<TemplateDiagnostic>(db, file);
 //!
 //! // Get diagnostics for all workspace files
 //! for file in workspace.files() {
-//!     let _ = analyze_template(db, file); // Trigger analysis
-//!     let diags = analyze_template::accumulated::<TemplateDiagnostic>(db, file);
+//!     let _ = parse_template(db, file); // Trigger parsing
+//!     let diags = parse_template::accumulated::<TemplateDiagnostic>(db, file);
 //!     // Process diagnostics...
 //! }
 //! ```

crates/djls-templates/src/error.rs

@@ -1,7 +1,7 @@
 use serde::Serialize;
 use thiserror::Error;
 
-use crate::ast::NodeListError;
+use crate::nodelist::NodeListError;
 use crate::parser::ParserError;
 
 #[derive(Clone, Debug, Error, PartialEq, Eq, Serialize)]

crates/djls-templates/src/lexer.rs

@@ -1,5 +1,5 @@
-use crate::ast::LineOffsets;
 use crate::db::Db as TemplateDb;
+use crate::nodelist::LineOffsets;
 use crate::tokens::Token;
 use crate::tokens::TokenContent;