//! `angular-html-parser` 10.12: `ml_parser/parser.ts`. use super::ast::{Attribute, Id, Kind, Node, Span, StartTagComment, Tree}; use super::data::{self, TagDefinition}; use super::error::{ErrorKind, SyntaxError}; use super::lexer::{self, ContentType, GetTagContentType, LexedAttribute, Parts, Token, TokenType}; use rustc_hash::FxHashMap; use std::borrow::Cow; #[derive(Copy, Clone)] pub(crate) struct Options<'f> { pub(crate) lexer: lexer::Options, pub(crate) is_tag_name_case_sensitive: bool, /// Prettier's `shouldParseAsRawText(tagName, prefix, hasParent, attrs)` pub(crate) should_parse_as_raw_text: Option<&'f dyn Fn(&[u8], bool, &[LexedAttribute<'_>]) -> bool>, } pub(crate) struct ParseResult<'a> { /// Its children are the `rootNodes`. pub(crate) root: Id, pub(crate) errors: Vec>, pub(crate) is_nested_too_deeply: bool, } struct TreeBuilder<'a, 't, 'k> { text: &'a [u8], tree: &'t mut Tree<'a>, tokens: &'k [Token], index: usize, /// The index where this builder's tokens end, and the token it sees there instead. end: usize, eof: Token, container_stack: Vec, /// The parent of nodes that aren't in any container. root: Id, errors: Vec>, can_self_close: bool, allow_htm_component_closing_tags: bool, is_tag_name_case_sensitive: bool, is_nested_too_deeply: bool, depth: u32, /// Ends of the nested ICU cases that were passed while scanning for the end of an outer one: maps the index of a /// case's first token to the index of the token that ends it. case_ends: FxHashMap, } /// A name with its namespace: `:namespace:name`. #[derive(Copy, Clone, PartialEq, Eq)] struct FullName<'a> { prefix: &'a [u8], name: &'a [u8], } pub(crate) fn definition_of(name: &[u8], is_case_sensitive: bool) -> &'static TagDefinition { match is_case_sensitive || !name.iter().any(u8::is_ascii_uppercase) { true => data::tag_definition(name), false => data::tag_definition(&name.to_ascii_lowercase()), } } impl<'a> TreeBuilder<'a, '_, '_> { fn peek(&self) -> Token { match self.index < self.end { true => self.tokens.get(self.index).copied().unwrap_or(self.eof), false => self.eof, } } fn advance(&mut self) -> Token { let token = self.peek(); if self.index < self.end { self.index += 1; } token } fn advance_if(&mut self, kind: TokenType) -> Option { (self.peek().kind == kind).then(|| self.advance()) } /// `_getTagDefinition(node)` fn definition_of_node(&self, id: Id) -> Option<&'static TagDefinition> { let node = &self.tree[id]; (node.kind == Kind::Element).then_some(node.tag_definition) } /// While the tree is being built, an element's name and namespace are substrings of the text. fn full_name_of(&self, id: Id) -> FullName<'a> { let node = &self.tree[id]; FullName { prefix: node.namespace, name: match &node.name { Cow::Borrowed(name) => name, Cow::Owned(_) => b"", }, } } /// `this.errors.push(TreeError.create(..))` fn error(&mut self, at: u32, kind: ErrorKind, name: &'a [u8]) { self.errors.push(SyntaxError::new(at, kind, name)); } /// The same, for a message that includes an element's name. fn error_about(&mut self, at: u32, kind: ErrorKind, name: FullName<'a>) { self.errors.push(SyntaxError { prefix: name.prefix, ..SyntaxError::new(at, kind, name.name) }); } fn build(&mut self) { use TokenType::*; while self.peek().kind != Eof && !self.is_nested_too_deeply { let kind = self.peek().kind; if matches!( kind, TagClose | CdataStart | CommentStart | Text | RawText | EscapableRawText | BlockOpenStart | BlockClose | IncompleteBlockOpen | LetStart | IncompleteLet ) { self.close_void_element(); } let token = self.advance(); match kind { TagOpenStart | IncompleteTagOpen => self.consume_element_start_tag(token), TagClose => self.consume_element_end_tag(token), CdataStart => self.consume_cdata(token), CommentStart => self.consume_comment(token), Text | RawText | EscapableRawText => self.consume_text(token), ExpansionFormStart => self.consume_expansion(token), BlockOpenStart => self.consume_block_open(token), BlockClose => self.consume_block_close(token), IncompleteBlockOpen => self.consume_incomplete_block(token), LetStart => self.consume_let(token), DocTypeStart => self.consume_doc_type(token), IncompleteLet => { let name = match token.parts { Parts::Value(name) => name.of(self.text), _ => b"", }; self.error(token.span.start, ErrorKind::IncompleteLet, name); } _ => {} } } for index in 0..self.container_stack.len() { let container = self.container_stack[index]; if self.tree[container].kind == Kind::AngularControlFlowBlock { let name = self.full_name_of(container).name; self.error(self.tree[container].span.start, ErrorKind::UnclosedBlock, name); } } } fn container(&self) -> Option { self.container_stack.last().copied() } fn closest_element_like_parent(&self) -> Option { self.container_stack.iter().rev().copied().find(|&id| self.tree[id].kind == Kind::Element) } fn add_to_parent(&mut self, node: Node<'a>) -> Id { let id = self.tree.add(node); self.tree.append_child(self.container().unwrap_or(self.root), id); id } /// True if a line feed at the start of a text in `parent` is ignored. fn ignores_first_lf(&self, parent: Option) -> bool { parent.is_some_and(|parent| { !self.tree.has_children(parent) && self.definition_of_node(parent).is_some_and(|it| it.ignore_first_lf) }) } fn consume_cdata(&mut self, start_token: Token) { let text = self.advance(); let mut value = text.span.of(self.text); if value.first() == Some(&b'\n') && self.ignores_first_lf(self.closest_element_like_parent()) { value = &value[1..]; } let end_token = self.advance_if(TokenType::CdataEnd); let mut node = Node::new(Kind::Cdata, Span::new(start_token.span.start, end_token.unwrap_or(text).span.end)); node.value = Cow::Borrowed(value); self.add_to_parent(node); } fn consume_comment(&mut self, token: Token) { self.advance_if(TokenType::RawText); let end_token = self.advance_if(TokenType::CommentEnd); let span = Span::new(token.span.start, end_token.unwrap_or(token).span.end); self.add_to_parent(Node::new(Kind::Comment, span)); } fn consume_doc_type(&mut self, start_token: Token) { let text = self.advance_if(TokenType::RawText); let end_token = self.advance_if(TokenType::DocTypeEnd); let end = end_token.or(text).unwrap_or(start_token).span.end; let mut node = Node::new(Kind::DocType, Span::new(start_token.span.start, end)); node.value = Cow::Borrowed( text.map_or(&b""[..], |text| super::strings::trim_js_whitespace(text.span.of(self.text))), ); self.add_to_parent(node); } fn value_of(&self, token: Token) -> &'a [u8] { match token.parts { Parts::Value(span) => span.of(self.text), Parts::ElseIf => b"else if", Parts::DefaultNever => b"default never", _ => token.span.of(self.text), } } fn consume_expansion(&mut self, token: Token) { let switch_value = self.advance(); let kind = self.advance(); let expansion = self.tree.add(Node::new(Kind::AngularIcuExpression, token.span)); while self.peek().kind == TokenType::ExpansionCaseValue { match self.parse_expansion_case() { Some(case) => self.tree.append_child(expansion, case), None => return, } } if self.peek().kind != TokenType::ExpansionFormEnd { self.error(self.peek().span.start, ErrorKind::IcuWithoutClosingBrace, b""); return; } let end = self.advance().span.end; let node = &mut self.tree[expansion]; node.span.end = end; node.value = Cow::Borrowed(switch_value.span.of(self.text)); node.name = Cow::Borrowed(kind.span.of(self.text)); self.tree.append_child(self.container().unwrap_or(self.root), expansion); } fn parse_expansion_case(&mut self) -> Option { let value = self.advance(); if self.peek().kind != TokenType::ExpansionCaseExpStart { self.error(self.peek().span.start, ErrorKind::IcuWithoutOpeningBrace, b""); return None; } let start = self.advance(); let first = self.index; self.skip_expansion_exp_tokens(start)?; let last = self.index; let end = self.advance(); if self.depth >= super::MAX_DEPTH { self.is_nested_too_deeply = true; return None; } let mut node = Node::new(Kind::AngularIcuCase, Span::new(value.span.start, end.span.end)); node.value = Cow::Borrowed(self.value_of(value)); let case = self.tree.add(node); let mut builder = TreeBuilder { text: self.text, tree: &mut *self.tree, tokens: self.tokens, index: first, end: last, eof: Token { kind: TokenType::Eof, span: end.span, parts: Parts::None }, container_stack: Vec::new(), root: case, errors: Vec::new(), can_self_close: self.can_self_close, allow_htm_component_closing_tags: self.allow_htm_component_closing_tags, is_tag_name_case_sensitive: self.is_tag_name_case_sensitive, is_nested_too_deeply: false, depth: self.depth + 1, case_ends: std::mem::take(&mut self.case_ends), }; builder.build(); let (errors, is_nested_too_deeply) = (builder.errors, builder.is_nested_too_deeply); self.case_ends = builder.case_ends; self.is_nested_too_deeply |= is_nested_too_deeply; if !errors.is_empty() { self.errors.extend(errors); return None; } Some(case) } /// `_collectExpansionExpTokens`: skips to the token that ends the case. fn skip_expansion_exp_tokens(&mut self, start: Token) -> Option<()> { use TokenType::{ Eof, ExpansionCaseExpEnd, ExpansionCaseExpStart, ExpansionFormEnd, ExpansionFormStart, }; // This case is nested in one that was already scanned without errors. if let Some(&end) = self.case_ends.get(&self.index) { self.index = end; return Some(()); } // The open forms and cases, each with the index of its first token. let mut stack = vec![(ExpansionCaseExpStart, self.index)]; loop { let kind = self.peek().kind; if matches!(kind, ExpansionFormStart | ExpansionCaseExpStart) { stack.push((kind, self.index + 1)); } if kind == ExpansionCaseExpEnd { let Some(&(ExpansionCaseExpStart, first)) = stack.last() else { self.error(start.span.start, ErrorKind::IcuWithoutClosingBrace, b""); return None; }; self.case_ends.insert(first, self.index); stack.pop(); if stack.is_empty() { return Some(()); } } if kind == ExpansionFormEnd { if !matches!(stack.last(), Some((ExpansionFormStart, _))) { self.error(start.span.start, ErrorKind::IcuWithoutClosingBrace, b""); return None; } stack.pop(); } if kind == Eof { self.error(start.span.start, ErrorKind::IcuWithoutClosingBrace, b""); return None; } self.advance(); } } fn consume_text(&mut self, token: Token) { let start = token.span.start; let mut end = token.span.end; let mut len = token.span.len(); if token.span.of(self.text).first() == Some(&b'\n') && self.ignores_first_lf(self.container()) { len -= 1; } while matches!( self.peek().kind, TokenType::Interpolation | TokenType::Text | TokenType::EncodedEntity ) { let token = self.advance(); len += token.span.len(); end = token.span.end; } if len > 0 { self.add_to_parent(Node::new(Kind::Text, Span::new(start, end))); } } fn close_void_element(&mut self) { if self.container().and_then(|it| self.definition_of_node(it)).is_some_and(|it| it.is_void) { self.container_stack.pop(); } } /// `_getElementFullName`, plus the definition for that name. With a namespace, the parser looks up `:prefix:name`. /// No definition has a colon in its name, so that's the default definition. fn full_name(&self, token: Token, parent: Option) -> (FullName<'a>, &'static TagDefinition) { let Parts::Name(prefix, name) = token.parts else { let (prefix, name) = (&b""[..], &b""[..]); return (FullName { prefix, name }, &data::DEFAULT_TAG_DEFINITION); }; let (prefix, name) = (prefix.of(self.text), name.of(self.text)); if !prefix.is_empty() { return (FullName { prefix, name }, &data::DEFAULT_TAG_DEFINITION); } let definition = definition_of(name, self.is_tag_name_case_sensitive); let mut prefix = definition.implicit_namespace_prefix.unwrap_or_default(); if prefix.is_empty() && let Some(parent) = parent.map(|parent| self.full_name_of(parent)) && !parent.prefix.is_empty() && !definition_of(parent.name, self.is_tag_name_case_sensitive).prevent_namespace_inheritance { prefix = parent.prefix; } match prefix { b"" => (FullName { prefix, name }, definition), _ => (FullName { prefix, name }, &data::DEFAULT_TAG_DEFINITION), } } fn consume_element_start_tag(&mut self, start_tag_token: Token) { let first_attr = self.tree.attrs.len() as u32; let first_comment = self.tree.start_tag_comments.len() as u32; loop { match self.peek().kind { TokenType::AttrName => { let name = self.advance(); let attr = self.consume_attr(name); self.tree.attrs.push(attr); } TokenType::InElementComment => { let token = self.advance(); if let Parts::Comment(content, is_single_line) = token.parts { self.tree.start_tag_comments.push(StartTagComment { span: token.span, value: content.of(self.text), is_single_line, }); } } _ => break, } } let (full_name, definition) = self.full_name(start_tag_token, self.closest_element_like_parent()); let mut is_self_closing = false; if self.peek().kind == TokenType::TagOpenEndVoid { self.advance(); is_self_closing = true; if !(self.can_self_close || definition.can_self_close || !full_name.prefix.is_empty() || definition.is_void) { self.error(start_tag_token.span.start, ErrorKind::SelfClosed, full_name.name); } } else if self.peek().kind == TokenType::TagOpenEnd { self.advance(); } let span = Span::new(start_tag_token.span.start, self.peek().span.start); let mut node = Node::new(Kind::Element, span); node.set_start_span(span); node.name_span = Span::new(start_tag_token.span.start + 1, start_tag_token.span.end); node.name = Cow::Borrowed(full_name.name); node.namespace = full_name.prefix; node.tag_definition = definition; node.attrs = (first_attr, self.tree.attrs.len() as u32); node.start_tag_comments = (first_comment, self.tree.start_tag_comments.len() as u32); let is_closed_by_child = self.container().and_then(|it| self.definition_of_node(it)).is_some_and(|it| { // The lookup uses the child's full name, and no list has a name with a namespace. it.is_void || (full_name.prefix.is_empty() && it.is_closed_by_child(full_name.name)) }); self.push_container(node, is_closed_by_child); if is_self_closing { self.pop_container(Some(full_name), Kind::Element, Some(span)); } else if start_tag_token.kind == TokenType::IncompleteTagOpen { self.pop_container(Some(full_name), Kind::Element, None); self.error_about(span.start, ErrorKind::OpeningTagNotTerminated, full_name); } } fn push_container(&mut self, node: Node<'a>, is_closed_by_child: bool) { if is_closed_by_child { self.container_stack.pop(); } let id = self.add_to_parent(node); self.container_stack.push(id); } fn consume_element_end_tag(&mut self, end_tag_token: Token) { let full_name = match self.allow_htm_component_closing_tags && end_tag_token.parts == Parts::None { true => None, false => Some(self.full_name(end_tag_token, self.closest_element_like_parent())), }; let at = end_tag_token.span.start; let name = full_name.map(|(name, _)| name); if let Some((name, _)) = full_name.filter(|(_, definition)| definition.is_void) { self.error(at, ErrorKind::EndTagOfVoidElement, name.name); } else if !self.pop_container(name, Kind::Element, Some(end_tag_token.span)) { let (prefix, name) = (&b""[..], &b"null"[..]); let name = full_name.map_or(FullName { prefix, name }, |(name, _)| name); self.error_about(at, ErrorKind::UnexpectedClosingTag, name); } } /// `_popContainer` fn pop_container( &mut self, expected_name: Option>, expected_kind: Kind, end_span: Option, ) -> bool { let mut unexpected_close_tag_detected = false; for stack_index in (0..self.container_stack.len()).rev() { let id = self.container_stack[stack_index]; let kind = self.tree[id].kind; // A block's name has no namespace and is never compared. let name = self.full_name_of(id); let is_expected = match kind == Kind::Element && !name.prefix.is_empty() { true => Some(name) == expected_name, false => { expected_name.is_none_or(|expected| kind == Kind::Element && expected == name) && kind == expected_kind } }; if is_expected { let node = &mut self.tree[id]; node.set_end_span(end_span); if let Some(end_span) = end_span { node.span.end = end_span.end; } self.container_stack.truncate(stack_index); return !unexpected_close_tag_detected; } if kind == Kind::AngularControlFlowBlock || !self.definition_of_node(id).is_some_and(|it| it.closed_by_parent) { unexpected_close_tag_detected = true; } } false } fn consume_attr(&mut self, attr_name: Token) -> Attribute<'a> { let mut attr_end = attr_name.span.end; let start_quote = self.advance_if(TokenType::AttrQuote); let mut value_start = None; let mut value_end = None; if self.peek().kind == TokenType::AttrValueText { value_start = Some(self.peek().span.start); value_end = Some(self.peek().span.end); while matches!( self.peek().kind, TokenType::AttrValueText | TokenType::AttrValueInterpolation | TokenType::EncodedEntity ) { attr_end = self.advance().span.end; value_end = Some(attr_end); } } if let Some(quote) = self.advance_if(TokenType::AttrQuote) { attr_end = quote.span.end; value_end = Some(attr_end); } let (prefix, name) = match attr_name.parts { Parts::Name(prefix, name) => (prefix.of(self.text), name.of(self.text)), _ => (&b""[..], &b""[..]), }; Attribute { span: Span::new(attr_name.span.start, attr_end), name_span: attr_name.span, value_span: value_start .zip(value_end) .map(|(start, end)| Span::new(start_quote.map_or(start, |it| it.span.start), end)), name: Cow::Borrowed(name), namespace: prefix, has_explicit_namespace: false, value: None, } } /// Makes a block, with its parameters, whose start span ends where the next token starts. fn block(&mut self, token: Token, has_end: bool) -> (Node<'a>, Option) { // Prettier's `normalizeAngularControlFlowBlock`. let mut parameters = None; while let Some(token) = self.advance_if(TokenType::BlockParameter) { let mut node = Node::new(Kind::AngularControlFlowBlockParameter, token.span); node.value = Cow::Borrowed(token.span.of(self.text)); let parameter = self.tree.add(node); let list = *parameters.get_or_insert_with(|| { self.tree.add(Node::new(Kind::AngularControlFlowBlockParameters, token.span)) }); self.tree[list].span.end = token.span.end; self.tree.append_child(list, parameter); } if has_end { self.advance_if(TokenType::BlockOpenEnd); } let span = Span::new(token.span.start, self.peek().span.start); let mut node = Node::new(Kind::AngularControlFlowBlock, span); node.set_start_span(span); node.name_span = token.span; node.name = Cow::Borrowed(self.value_of(token)); (node, parameters) } fn push_block(&mut self, (block, parameters): (Node<'a>, Option)) { self.push_container(block, false); if let (Some(block), Some(parameters)) = (self.container(), parameters) { self.tree.set_parameters(block, parameters); } } fn consume_block_open(&mut self, token: Token) { let block = self.block(token, true); self.push_block(block); } fn consume_block_close(&mut self, token: Token) { let (depth, top) = (self.container_stack.len(), self.container()); if !self.pop_container(None, Kind::AngularControlFlowBlock, Some(token.span)) { // An open element was closed along the way. let (prefix, name) = (&b""[..], &b""[..]); let name = (top.filter(|_| self.container_stack.len() < depth)) .map_or(FullName { prefix, name }, |top| self.full_name_of(top)); self.error_about(token.span.start, ErrorKind::UnexpectedClosingBlock, name); } } fn consume_incomplete_block(&mut self, token: Token) { let block = self.block(token, false); let start = block.0.span.start; self.push_block(block); self.pop_container(None, Kind::AngularControlFlowBlock, None); self.error(start, ErrorKind::IncompleteBlock, self.value_of(token)); } fn consume_let(&mut self, start_token: Token) { let (at, name) = (start_token.span.start, self.value_of(start_token)); let Some(value_token) = self.advance_if(TokenType::LetValue) else { self.error(at, ErrorKind::LetWithoutValue, name); return; }; let Some(end_token) = self.advance_if(TokenType::LetEnd) else { self.error(at, ErrorKind::LetNotTerminated, name); return; }; // Prettier's `normalizeAngularLetDeclaration`. let mut node = Node::new(Kind::AngularLetDeclaration, Span::new(start_token.span.start, end_token.span.end)); node.name = Cow::Borrowed(self.value_of(start_token)); node.name_span = value_token.span; node.value = Cow::Borrowed(value_token.span.of(self.text)); self.add_to_parent(node); } } /// `new HtmlParser().parse(..)`, for the part of `text` from `start` on. pub(crate) fn parse<'a>( tree: &mut Tree<'a>, text: &'a [u8], start: usize, options: Options<'_>, ) -> ParseResult<'a> { let is_case_sensitive = options.is_tag_name_case_sensitive; let get_tag_content_type = |name: &[u8], has_parent: bool, attrs: &[LexedAttribute<'_>]| { let is_raw = options.should_parse_as_raw_text.is_some_and(|should| match is_case_sensitive { true => should(name, has_parent, attrs), false => should(&name.to_ascii_lowercase(), has_parent, attrs), }); if is_raw { ContentType::RawText } else { definition_of(name, is_case_sensitive).content_type } }; let get_tag_content_type: GetTagContentType<'_> = &get_tag_content_type; let (tokens, mut errors) = lexer::tokenize(text, start, get_tag_content_type, options.lexer); // A node is typically three or four tokens. tree.nodes.reserve(tokens.len() / 3); let root = tree.add(Node::new(Kind::Root, Span::new(0, text.len() as u32))); let end = tokens.len().saturating_sub(1); let mut builder = TreeBuilder { text, tree, tokens: &tokens, index: 0, end, eof: tokens.last().copied().unwrap_or_else(|| Token { kind: TokenType::Eof, span: Span::new(text.len() as u32, text.len() as u32), parts: Parts::None, }), container_stack: Vec::new(), root, errors: Vec::new(), can_self_close: options.lexer.can_self_close, allow_htm_component_closing_tags: options.lexer.allow_htm_component_closing_tags, is_tag_name_case_sensitive: is_case_sensitive, is_nested_too_deeply: false, depth: 0, case_ends: FxHashMap::default(), }; builder.build(); errors.append(&mut builder.errors); let ended = builder.eof.span.start; if (ended as usize) < text.len() { errors.push(SyntaxError::new(ended, ErrorKind::TextAfterNul, b"")); } ParseResult { root, errors, is_nested_too_deeply: builder.is_nested_too_deeply } }