Add buggy diagnostics

6 files changed, 134 insertions, 91 deletions

diff --git a/src/analyze.rs b/src/analyze.rs
index 7debb0d..b8a7012 100644
--- a/src/analyze.rs
+++ b/src/analyze.rs
@@ -1,7 +1,4 @@
-use std::{
-	collections::HashMap,
-	sync::atomic::{AtomicUsize, Ordering::Relaxed},
-};
+use std::{collections::HashMap, sync::atomic::AtomicUsize};
 
 use bumpalo::Bump;
 
@@ -12,10 +9,12 @@ use crate::{
 
 static NEXT_ID: AtomicUsize = AtomicUsize::new(0);
 
+#[derive(Debug, Default)]
 pub struct SymbolTableSet<'a> {
 	symbol_tables: HashMap<SymbolTableId, ScopedSymbolTable<'a>>,
 }
 
+#[derive(Debug, Default)]
 pub struct ScopedSymbolTable<'a> {
 	pub modules: HashMap<ModuleSymbolId, ModuleSymbol<'a>>,
 	pub constants: HashMap<ConstantSymbolId, ConstantSymbol<'a>>,
@@ -32,6 +31,7 @@ pub struct ConstantSymbolId(pub usize);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct HeadSymbolId(pub usize);
 
+#[derive(Debug)]
 pub struct ModuleSymbol<'a> {
 	pub id: ModuleSymbolId,
 	pub name: Option<&'a str>,
@@ -39,6 +39,7 @@ pub struct ModuleSymbol<'a> {
 	pub definition_site: Option<Element<'a>>,
 }
 
+#[derive(Debug)]
 pub struct ConstantSymbol<'a> {
 	pub id: ConstantSymbolId,
 	pub name: Option<&'a str>,
@@ -47,12 +48,14 @@ pub struct ConstantSymbol<'a> {
 	pub definition_site: Option<Element<'a>>,
 }
 
+#[derive(Debug)]
 pub struct HeadSymbol<'a> {
 	pub id: HeadSymbolId,
 	pub contents: Option<ConstantSymbolId>,
 	pub definition_site: Option<Element<'a>>,
 }
 
+#[derive(Debug)]
 pub enum ConstantType<'a> {
 	String,
 	Block {
@@ -61,10 +64,12 @@ pub enum ConstantType<'a> {
 	},
 }
 
+#[derive(Debug)]
 pub enum ConstantValue<'a> {
 	String(&'a str),
 }
 
+#[derive(Debug)]
 pub enum ConstantExpression<'a> {
 	Name(&'a str),
 	Value(ConstantValue<'a>),
@@ -77,7 +82,7 @@ pub enum ConstantExpression<'a> {
 }
 
 fn next_id() -> usize {
-	NEXT_ID.fetch_add(1, Relaxed)
+	NEXT_ID.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
 }
 
 fn element_attributes<'a>(
@@ -273,7 +278,7 @@ fn add_block<'a>(
 		ConstantSymbol {
 			id,
 			name,
-			// fill this in
+			// TODO fill this in
 			ty: None,
 			value: Some(fragment),
 			definition_site: Some(*element),
diff --git a/src/compile.rs b/src/compile.rs
index ccbf6f0..9e19b18 100644
--- a/src/compile.rs
+++ b/src/compile.rs
@@ -8,16 +8,12 @@ fn symbol_table_from_path<'a>(
 ) -> Option<&'a ScopedSymbolTable<'a>> {
 	let mut symbol_table = symbol_table;
 	for component in path.split("::") {
-		if let Some(module) = symbol_table
+		let module = symbol_table
 			.modules
 			.values()
 			.find(|module| module.name == Some(component))
-			.and_then(|module| module.symbol_table)
-		{
-			symbol_table = module;
-		} else {
-			return None;
-		}
+			.and_then(|module| module.symbol_table)?;
+		symbol_table = module;
 	}
 
 	Some(symbol_table)
diff --git a/src/diagnostics.rs b/src/diagnostics.rs
index 514818a..d2db96b 100644
--- a/src/diagnostics.rs
+++ b/src/diagnostics.rs
@@ -13,7 +13,7 @@ mod forbidden_top_level_tag;
 mod html_tag;
 mod image_tag;
 mod non_alphabetic_attribute_name;
-mod non_alphabetic_tag_name;
+mod non_alphanumeric_tag_name;
 mod non_self_closing_void_tag;
 mod non_void_self_closing_tag;
 mod self_closing_end_tag;
@@ -27,7 +27,7 @@ mod unterminated_tag;
 
 const VOID_TAGS: &[&str] = &[
 	"area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source",
-	"track", "wbr",
+	"track", "wbr", "import",
 ];
 const ALLOWED_TOP_LEVEL_TAGS: &[&str] = &["import", "const", "block", "head", "body"];
 
@@ -35,6 +35,12 @@ pub struct DiagnosticsContext {
 	source_code: &'static str,
 }
 
+impl DiagnosticsContext {
+	pub fn new(source_code: &'static str) -> Self {
+		Self { source_code }
+	}
+}
+
 trait TokenDiagnostic: Sized + Send + Sync + 'static {
 	fn handle_token(_: &Token<'_>) -> Option<Self> {
 		None
@@ -66,13 +72,16 @@ trait AstDiagnostic: Sized + Send + Sync + 'static {
 fn maybe_print_diagnostic<D: Diagnostic + Send + Sync + 'static>(
 	ctx: &DiagnosticsContext,
 	diagnostic: Option<D>,
-) {
+) -> Option<()> {
 	if let Some(diagnostic) = diagnostic {
 		eprintln!(
-			"{}",
+			"{:?}",
 			Error::new(diagnostic).with_source_code(ctx.source_code)
 		);
+		return None;
 	}
+
+	Some(())
 }
 
 #[derive(Debug, Error, Diagnostic)]
@@ -119,9 +128,10 @@ pub fn run_character_diagnostics(source: &'static [u8]) -> Option<&'static str>
 fn run_token_diagnostic<D: Diagnostic + TokenDiagnostic>(
 	ctx: &DiagnosticsContext,
 	tokens: &[Token<'_>],
-) {
+) -> Option<()> {
+	let mut has_failed = false;
 	for token in tokens {
-		maybe_print_diagnostic(ctx, D::handle_token(token));
+		has_failed |= maybe_print_diagnostic(ctx, D::handle_token(token)).is_none();
 
 		let TokenType::Tag {
 			attribute_tokens, ..
@@ -131,53 +141,82 @@ fn run_token_diagnostic<D: Diagnostic + TokenDiagnostic>(
 		};
 
 		for token in attribute_tokens {
-			maybe_print_diagnostic(ctx, D::handle_attribute_token(token));
+			has_failed |= maybe_print_diagnostic(ctx, D::handle_attribute_token(token)).is_none();
 		}
 	}
+
+	(!has_failed).then_some(())
 }
 
 fn run_ast_diagnostic<D: AstDiagnostic + Diagnostic>(
 	ctx: &DiagnosticsContext,
 	document: &Document<'_>,
-) {
-	maybe_print_diagnostic(ctx, D::handle_document(document));
+) -> Option<()> {
+	let mut has_failed = maybe_print_diagnostic(ctx, D::handle_document(document)).is_none();
 	for node in document.children {
-		maybe_print_diagnostic(ctx, D::handle_node(node));
+		has_failed |= maybe_print_diagnostic(ctx, D::handle_node(node)).is_none();
 
 		let Node::Element(element) = node else {
 			continue;
 		};
-		maybe_print_diagnostic(ctx, D::handle_element(element));
+		has_failed |= maybe_print_diagnostic(ctx, D::handle_element(element)).is_none();
 
 		for attribute in element.attributes {
-			maybe_print_diagnostic(ctx, D::handle_attribute(attribute));
+			has_failed |= maybe_print_diagnostic(ctx, D::handle_attribute(attribute)).is_none();
 		}
 	}
+
+	(!has_failed).then_some(())
 }
 
-pub fn run_token_diagnostics(ctx: &DiagnosticsContext, tokens: &[Token<'_>]) {
-	run_token_diagnostic::<non_void_self_closing_tag::NonVoidSelfClosingTag>(ctx, tokens);
-	run_token_diagnostic::<non_self_closing_void_tag::NonSelfClosingVoidTag>(ctx, tokens);
-	run_token_diagnostic::<end_tag_with_attributes::EndTagWithAttributes>(ctx, tokens);
-	run_token_diagnostic::<self_closing_end_tag::SelfClosingEndTag>(ctx, tokens);
-	run_token_diagnostic::<non_alphabetic_tag_name::NonAlphabeticTagName>(ctx, tokens);
-	run_token_diagnostic::<empty_tag_name::EmptyTagName>(ctx, tokens);
-	run_token_diagnostic::<unterminated_tag::UnterminatedTag>(ctx, tokens);
-	run_token_diagnostic::<unterminated_comment::UnterminatedComment>(ctx, tokens);
-	run_token_diagnostic::<non_alphabetic_attribute_name::NonAlphabeticAttributeName>(ctx, tokens);
+pub fn run_token_diagnostics(ctx: &DiagnosticsContext, tokens: &[Token<'_>]) -> Option<()> {
+	let mut has_failed = false;
+	has_failed |=
+		run_token_diagnostic::<non_void_self_closing_tag::NonVoidSelfClosingTag>(ctx, tokens)
+			.is_none();
+	has_failed |=
+		run_token_diagnostic::<non_self_closing_void_tag::NonSelfClosingVoidTag>(ctx, tokens)
+			.is_none();
+	has_failed |=
+		run_token_diagnostic::<end_tag_with_attributes::EndTagWithAttributes>(ctx, tokens)
+			.is_none();
+	has_failed |=
+		run_token_diagnostic::<self_closing_end_tag::SelfClosingEndTag>(ctx, tokens).is_none();
+	has_failed |=
+		run_token_diagnostic::<non_alphanumeric_tag_name::NonAlphaNumericTagName>(ctx, tokens)
+			.is_none();
+	has_failed |= run_token_diagnostic::<empty_tag_name::EmptyTagName>(ctx, tokens).is_none();
+	has_failed |= run_token_diagnostic::<unterminated_tag::UnterminatedTag>(ctx, tokens).is_none();
+	has_failed |=
+		run_token_diagnostic::<unterminated_comment::UnterminatedComment>(ctx, tokens).is_none();
+	has_failed |=
+		run_token_diagnostic::<non_alphabetic_attribute_name::NonAlphabeticAttributeName>(
+			ctx, tokens,
+		)
+		.is_none();
 	// TODO invalid character reference
+	(!has_failed).then_some(())
 }
 
-pub fn run_ast_diagnostics(ctx: &DiagnosticsContext, document: &Document<'_>) {
-	run_ast_diagnostic::<stray_equal_sign::StrayEqualSign>(ctx, document);
-	run_ast_diagnostic::<too_many_equal_signs::TooManyEqualSigns>(ctx, document);
-	run_ast_diagnostic::<duplicate_attribute_names::DuplicateAttributeNames>(ctx, document);
-	run_ast_diagnostic::<top_level_character_data::TopLevelCharacterData>(ctx, document);
-	run_ast_diagnostic::<forbidden_top_level_tag::ForbiddenTopLevelTag>(ctx, document);
-	run_ast_diagnostic::<stray_end_tag::StrayEndTag>(ctx, document);
-	run_ast_diagnostic::<unclosed_start_tag::UnclosedStartTag>(ctx, document);
-	run_ast_diagnostic::<html_tag::HtmlTag>(ctx, document);
-	run_ast_diagnostic::<image_tag::ImageTag>(ctx, document);
+pub fn run_ast_diagnostics(ctx: &DiagnosticsContext, document: &Document<'_>) -> Option<()> {
+	let mut has_failed = false;
+	has_failed |= run_ast_diagnostic::<stray_equal_sign::StrayEqualSign>(ctx, document).is_none();
+	has_failed |=
+		run_ast_diagnostic::<too_many_equal_signs::TooManyEqualSigns>(ctx, document).is_none();
+	has_failed |=
+		run_ast_diagnostic::<duplicate_attribute_names::DuplicateAttributeNames>(ctx, document)
+			.is_none();
+	has_failed |=
+		run_ast_diagnostic::<top_level_character_data::TopLevelCharacterData>(ctx, document)
+			.is_none();
+	has_failed |=
+		run_ast_diagnostic::<forbidden_top_level_tag::ForbiddenTopLevelTag>(ctx, document)
+			.is_none();
+	has_failed |= run_ast_diagnostic::<stray_end_tag::StrayEndTag>(ctx, document).is_none();
+	has_failed |=
+		run_ast_diagnostic::<unclosed_start_tag::UnclosedStartTag>(ctx, document).is_none();
+	has_failed |= run_ast_diagnostic::<html_tag::HtmlTag>(ctx, document).is_none();
+	has_failed |= run_ast_diagnostic::<image_tag::ImageTag>(ctx, document).is_none();
 	// TODO invalid <kuht-var />
 	// TODO invalid <import />
 	// TODO invalid <const />
@@ -214,4 +253,5 @@ pub fn run_ast_diagnostics(ctx: &DiagnosticsContext, document: &Document<'_>) {
 	// TODO aria tags don't match tag semantics
 	// TODO empty or missing image src
 	// TODO missing alt text for image (unless inside figure with caption, or has title, or meta name = "generator")
+	(!has_failed).then_some(())
 }
diff --git a/src/diagnostics/non_alphabetic_tag_name.rs b/src/diagnostics/non_alphabetic_tag_name.rs
deleted file mode 100644
index b36cb75..0000000
--- a/src/diagnostics/non_alphabetic_tag_name.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-use miette::Diagnostic;
-use thiserror::Error;
-
-use crate::{
-	diagnostics::TokenDiagnostic,
-	tokenize::{Span, Token, TokenType},
-};
-
-#[derive(Error, Debug, Diagnostic)]
-#[error("Tag names must be alphabetic")]
-#[diagnostic(code(NonAlphabeticTagName), severity(Error))]
-pub struct NonAlphabeticTagName {
-	#[label(primary, "tag names must only contain uppercase and lowercase letters")]
-	tag: Span,
-}
-
-impl TokenDiagnostic for NonAlphabeticTagName {
-	fn handle_token(token: &Token<'_>) -> Option<Self> {
-		let TokenType::Tag {
-			is_end,
-			lowercase_tag_name,
-			..
-		} = token.ty
-		else {
-			return None;
-		};
-
-		if is_end
-			|| lowercase_tag_name
-				.chars()
-				.all(|char| char.is_ascii_alphabetic())
-		{
-			return None;
-		}
-
-		Some(Self { tag: token.span })
-	}
-}
diff --git a/src/main.rs b/src/main.rs
index 1ac5a54..dcfd81b 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -2,7 +2,13 @@ use std::collections::HashMap;
 
 use bpaf::{Bpaf, Parser};
 use bumpalo::Bump;
-use kuht::{analyze::symbol_table, compile::compile, parse::parse_document, tokenize::tokenize};
+use kuht::{
+	analyze::symbol_table,
+	compile::compile,
+	diagnostics::{self, DiagnosticsContext},
+	parse::parse_document,
+	tokenize::tokenize,
+};
 
 #[derive(Debug, Clone, Bpaf)]
 struct Options {
@@ -21,39 +27,73 @@ struct Options {
 
 fn main() {
 	let options = options().run();
+	let mut has_failed = false;
+
 	let sources = options
 		.files
 		.into_iter()
 		.map(|filename| {
-			let source = match std::fs::read_to_string(&filename) {
+			let source = match std::fs::read(&filename) {
 				Ok(source) => source,
 				Err(error) => {
-					eprintln!("{error}");
+					eprintln!("Error: {error}");
 					std::process::exit(1);
 				}
 			};
 			(filename, source)
 		})
+		.filter_map(|(filename, source)| {
+			let source: &'static [u8] = Vec::leak(source);
+			let Some(source) = diagnostics::run_character_diagnostics(source) else {
+				has_failed = true;
+				return None;
+			};
+			Some((filename, source))
+		})
 		.collect::<HashMap<_, _>>();
 
 	let arena = Bump::new();
 	let tokens = sources
 		.into_iter()
-		.map(|(filename, source)| (filename, tokenize(&source, &arena)))
+		.map(|(filename, source)| {
+			(
+				filename,
+				(DiagnosticsContext::new(source), tokenize(source, &arena)),
+			)
+		})
+		.filter(|(_, (ctx, tokens))| {
+			let failed = diagnostics::run_token_diagnostics(ctx, tokens).is_none();
+			has_failed |= failed;
+			failed
+		})
 		.collect::<HashMap<_, _>>();
 
 	let asts = tokens
 		.into_iter()
-		.map(|(filename, tokens)| (filename, parse_document(tokens, &arena)))
+		.map(|(filename, (ctx, tokens))| (filename, (ctx, parse_document(tokens, &arena))))
+		.filter(|(_, (ctx, document))| {
+			let failed = diagnostics::run_ast_diagnostics(ctx, document).is_none();
+			has_failed |= failed;
+			failed
+		})
 		.collect::<HashMap<_, _>>();
 
+	if has_failed {
+		std::process::exit(1);
+	}
+
 	let symbol_tables = asts
 		.into_iter()
-		.map(|(filename, document)| (filename, symbol_table(&arena, document)))
+		.map(|(filename, (ctx, document))| (filename, (ctx, symbol_table(&arena, document))))
 		.collect::<HashMap<_, _>>();
 
 	if !options.dry {
-		let output = compile(&symbol_tables.into_values().collect::<Box<_>>());
+		let output = compile(
+			&symbol_tables
+				.into_values()
+				.map(|(_, document)| document)
+				.collect::<Box<_>>(),
+		);
 		if let Err(e) = std::fs::write(options.out, output.as_bytes()) {
 			eprintln!("{e}");
 			std::process::exit(1);
diff --git a/src/tokenize.rs b/src/tokenize.rs
index 43ad305..a8e83c8 100644
--- a/src/tokenize.rs
+++ b/src/tokenize.rs
@@ -52,7 +52,7 @@ pub enum AttributeTokenType<'a> {
 
 impl From<Span> for miette::SourceSpan {
 	fn from(value: Span) -> Self {
-		miette::SourceSpan::from((value.start, value.start - value.end))
+		miette::SourceSpan::from((value.start, value.end - value.start))
 	}
 }