use miette::{Diagnostic, Error};
use thiserror::Error;
use crate::{
parse::{Attribute, Document, Element, Node},
tokenize::{AttributeToken, Token, TokenType},
};
mod duplicate_attribute_names;
mod empty_tag_name;
mod end_tag_with_attributes;
mod forbidden_top_level_tag;
mod html_tag;
mod image_tag;
mod non_alphabetic_attribute_name;
mod non_alphabetic_tag_name;
mod non_self_closing_void_tag;
mod non_void_self_closing_tag;
mod self_closing_end_tag;
mod stray_end_tag;
mod stray_equal_sign;
mod too_many_equal_signs;
mod top_level_character_data;
mod unclosed_start_tag;
mod unterminated_comment;
mod unterminated_tag;
const VOID_TAGS: &[&str] = &[
"area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source",
"track", "wbr",
];
const ALLOWED_TOP_LEVEL_TAGS: &[&str] = &["import", "const", "block", "head", "body"];
pub struct DiagnosticsContext {
source_code: &'static str,
}
trait TokenDiagnostic: Sized + Send + Sync + 'static {
fn handle_token(_: &Token<'_>) -> Option<Self> {
None
}
fn handle_attribute_token(_: &AttributeToken<'_>) -> Option<Self> {
None
}
}
trait AstDiagnostic: Sized + Send + Sync + 'static {
fn handle_document(_: &Document<'_>) -> Option<Self> {
None
}
fn handle_node(_: &Node<'_>) -> Option<Self> {
None
}
fn handle_element(_: &Element<'_>) -> Option<Self> {
None
}
fn handle_attribute(_: &Attribute<'_>) -> Option<Self> {
None
}
}
fn maybe_print_diagnostic<D: Diagnostic + Send + Sync + 'static>(
ctx: &DiagnosticsContext,
diagnostic: Option<D>,
) {
if let Some(diagnostic) = diagnostic {
eprintln!(
"{}",
Error::new(diagnostic).with_source_code(ctx.source_code)
);
}
}
#[derive(Debug, Error, Diagnostic)]
#[error("This file is not valid UTF-8")]
#[diagnostic(code(NonUtf8), severity(Error))]
struct NonUtf8;
#[derive(Debug, Error, Diagnostic)]
#[error("Forbidden NUL character found")]
#[diagnostic(code(NonUtf8), severity(Error))]
struct NulCharacter {
#[label("Forbidden NUL byte found here")]
location: usize,
}
#[derive(Debug, Error, Diagnostic)]
#[error("Forbidden control character found")]
#[diagnostic(code(NonUtf8), severity(Error))]
struct ControlCharacter {
#[label("Control character found")]
location: usize,
}
pub fn run_character_diagnostics(source: &'static [u8]) -> Option<&'static str> {
let Ok(source) = str::from_utf8(source) else {
eprintln!("{}", Error::new(NonUtf8));
return None;
};
let ctx = DiagnosticsContext {
source_code: source,
};
for (i, char) in source.char_indices() {
maybe_print_diagnostic(&ctx, (char == '\0').then_some(NulCharacter { location: i }));
maybe_print_diagnostic(
&ctx,
(char.is_control() && !char.is_ascii_whitespace())
.then_some(ControlCharacter { location: i }),
);
}
Some(source)
}
fn run_token_diagnostic<D: Diagnostic + TokenDiagnostic>(
ctx: &DiagnosticsContext,
tokens: &[Token<'_>],
) {
for token in tokens {
maybe_print_diagnostic(ctx, D::handle_token(token));
let TokenType::Tag {
attribute_tokens, ..
} = token.ty
else {
continue;
};
for token in attribute_tokens {
maybe_print_diagnostic(ctx, D::handle_attribute_token(token));
}
}
}
fn run_ast_diagnostic<D: AstDiagnostic + Diagnostic>(
ctx: &DiagnosticsContext,
document: &Document<'_>,
) {
maybe_print_diagnostic(ctx, D::handle_document(document));
for node in document.children {
maybe_print_diagnostic(ctx, D::handle_node(node));
let Node::Element(element) = node else {
continue;
};
maybe_print_diagnostic(ctx, D::handle_element(element));
for attribute in element.attributes {
maybe_print_diagnostic(ctx, D::handle_attribute(attribute));
}
}
}
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);
// TODO invalid character reference
}
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);
// TODO invalid <kuht-var />
// TODO invalid <import />
// TODO invalid <const />
// TODO invalid <block />
// TODO deprecated tag
// TODO deprecated tag attribute
//
// TODO forbidden tag in noscript
// TODO head tag outside head
// TODO html tag in body
// TODO heading inside heading
// TODO form inside form
// TODO button inside button
// TODO anchor inside anchor
// TODO head inside body
// TODO caption, col, colgroup, tbody, tfoot, thead, tr outside table
// TODO table inside table
// TODO non-hidden input inside table
// TODO form inside table
// TODO body inside body
// TODO col, colgroup, tbody, tfoot, thead, tr inside caption
// TODO th, td outside tr
// TODO caption, col, colgroup, tr in tbody
// TODO caption, col, colgroup, tbody, td, tfoot, th, thead, tr inside table cell
// TODO select inside select
// TODO input, keygen, textarea inside select
// TODO caption, table, tbody, tfoot, thread, tr, td, th inside select
//
// TODO anchor with invalid href
// TODO dt or dd outside dl
// TODO li outside ul, ol, menu
// TODO invalid dl, ul, menu
// TODO invalid attribute values (see microsyntaxes)
// 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")
}
|
