css_parse/syntax/

block.rs

use super::prelude::*;
use crate::{BadDeclaration, Declaration, DeclarationGroup, DeclarationOrBad, RuleVariants, token_macros};

/// This trait provides an implementation for ["consuming a blocks contents"][1].
///
/// ```md
/// <block>
///
///  │├─ "{" ─╭──╮─╭─ <ws-*> ─╮─╭─╮─╭─ ";" ─╮─╭─╮─ <R> ─╭─╮─ "}" ─┤│
///           │  │ ╰──────────╯ │ │ ╰───────╯ │ ├─ <D> ─┤ │
///           │  ╰──────────────╯ ╰───────────╯ ╰───────╯ │
///           ╰───────────────────────────────────────────╯
/// ```
///
/// [1]: https://drafts.csswg.org/css-syntax-3/#consume-block-contents
#[node]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
#[cfg_attr(feature = "serde", serde(bound(serialize = "D: serde::Serialize, R: serde::Serialize")))]
pub struct Block<'a, D, R, M>
where
	D: DeclarationValue<'a, M>,
	M: NodeMetadata,
{
	pub open_curly: token_macros::LeftCurly,
	pub declarations: Vec<'a, Declaration<'a, D, M>>,
	pub rules: Vec<'a, R>,
	pub close_curly: Option<token_macros::RightCurly>,
	#[cfg_attr(feature = "serde", serde(skip))]
	pub meta: M,
}

impl<'a, D, R, M> NodeWithMetadata<M> for Block<'a, D, R, M>
where
	D: DeclarationValue<'a, M>,
	M: NodeMetadata,
{
	fn metadata(&self) -> M {
		self.meta
	}
}

impl<'a, D, R, M> Peek<'a> for Block<'a, D, R, M>
where
	D: DeclarationValue<'a, M>,
	M: NodeMetadata,
{
	const PEEK_KINDSET: KindSet = KindSet::new(&[Kind::LeftCurly]);
}

impl<'a, D, R, M> Parse<'a> for Block<'a, D, R, M>
where
	D: DeclarationValue<'a, M>,
	R: Parse<'a> + NodeWithMetadata<M> + RuleVariants<'a, DeclarationValue = D, Metadata = M>,
	M: NodeMetadata,
{
	fn parse<Iter>(p: &mut Parser<'a, Iter>) -> Result<Self>
	where
		Iter: Iterator<Item = crate::Cursor> + Clone,
	{
		let nested = p.is(State::Nested);
		let open_curly = p.parse::<T!['{']>()?;
		let mut declarations = Vec::new_in(p.alloc());
		let mut rules = Vec::new_in(p.alloc());
		let mut meta = if nested { M::default().with_nested() } else { M::default() };

		// Per CSS Syntax spec: maintain a buffer of declarations to flush when we encounter rules.
		// This enables proper interleaving of declarations and rules.
		let mut decls: Vec<'a, DeclarationOrBad<'a, D, M>> = Vec::new_in(p.alloc());

		// Flush the decls buffer into the rules list as a DeclarationGroup.
		// Per spec: "If decls is not empty, append it to rules, and set decls to a fresh empty list"
		macro_rules! flush_decls {
			() => {
				if !decls.is_empty() {
					let group =
						DeclarationGroup { declarations: std::mem::replace(&mut decls, Vec::new_in(p.alloc())) };
					if let Some(rule) = R::from_declaration_group(group) {
						meta = meta.merge(rule.metadata());
						rules.push(rule);
					}
				}
			};
		}

		loop {
			// While by default the parser will skip whitespace, the Declaration or Rule type may be a whitespace sensitive
			// node, for example `ComponentValues`. As such whitespace needs to be consumed here, before Declarations and
			// Rules are parsed.
			// Additional tokens, such as CDC (`-->`) and CDO (`<!--`), Semicolon, RightParen, RightSquare are not valid
			// component values and are not consumed by the declaration/rule/bad-declaration recovery paths below. Left
			// unconsumed they cause a zero-progress loop and unbounded allocation. Per CSS Syntax they are only meaningful
			// at the stylesheet top level, so discard them here, mirroring the stylesheet top-level loop.
			p.consume_trivia_as_leading();
			const ERROR_KINDS: KindSet = KindSet::new(&[
				Kind::CdcOrCdo,
				Kind::Semicolon,
				Kind::RightParen,
				Kind::RightSquare,
				Kind::BadString,
				Kind::BadUrl,
			]);
			let c = p.peek_n(1);
			if c == ERROR_KINDS {
				let old_skip = p.set_skip(ERROR_KINDS);
				p.consume_trivia_as_leading();
				p.set_skip(old_skip);
				continue;
			}
			if p.at_end() {
				break;
			}
			let c = p.peek_n(1);
			if <T!['}']>::peek(p, c) {
				break;
			}
			let old_state = p.set_state(State::Nested);
			let checkpoint = p.checkpoint();
			if <T![AtKeyword]>::peek(p, c) {
				let rule = p.parse::<R>();
				p.set_state(old_state);
				match rule {
					Ok(rule) => {
						flush_decls!();
						meta = meta.merge(rule.metadata());
						rules.push(rule);
					}
					// An at-rule that cannot be parsed, even as an unknown at-rule, is not an error for the block that
					// contains it. Consume it as a bad declaration to avoid propagating it.
					Err(_) => {
						p.rewind(checkpoint);
						p.set_state(State::Nested);
						if let Ok(bad_decl) = p.parse::<BadDeclaration>() {
							p.set_state(old_state);
							decls.push(DeclarationOrBad::Bad(bad_decl));
						}
					}
				}
			} else if let Ok(Some(decl)) = p.try_parse_if_peek::<Declaration<'a, D, M>>() {
				// https://drafts.csswg.org/css-syntax-3/#consume-a-blocks-contents
				// Parsing a declaration can result in an error, at which point the parser must be rewound and a Rule parse
				// must be attempted. The CSS spec allows parsers to discard unknown rules as syntax errors, but this parser
				// needs to retain them as unknown declarations, which creates some ambiguity as a Declaration may successfully
				// parse as an unknown. In these cases attempting to parse as a Rule should also be tried so that valid Rules
				// are not accidentally parsed as Unknown Declarations.
				//
				// Only reparse as a rule if:
				// 1. The declaration is unknown (not recognized property/value)
				// 2. The declaration name is invalid (not a known CSS property name)
				// 3. Re-parsing as a rule succeeds AND produces a known rule (not UnknownQualifiedRule/UnknownAtRule)
				//
				// This ensures:
				// - `background: var(--bg);` stays as declaration (valid name, even if unknown value)
				// - `.foo {...}` becomes a rule (invalid declaration name, parses as known StyleRule)
				// - `bad-prop: value;` stays as declaration (both unknown, prefer declaration)
				if decl.is_unknown() && !D::valid_declaration_name(p, decl.name.into()) {
					p.rewind(checkpoint.clone());
					if let Ok(rule) = p.parse::<R>()
						&& !rule.is_unknown()
					{
						// Successfully parsed as a known rule, use it instead of the unknown declaration
						flush_decls!();
						p.set_state(old_state);
						meta = meta.merge(rule.metadata());
						rules.push(rule);
						continue;
					}
					// Failed to parse as rule or rule was also unknown, re-parse as declaration
					p.rewind(checkpoint);
					p.parse::<Declaration<'a, D, M>>().ok();
				}
				p.set_state(old_state);
				meta = meta.merge(decl.metadata());
				declarations.push(decl);
			} else {
				// Not an at-rule, not a declaration - try parsing as a qualified rule
				let result = p.parse::<R>();
				p.set_state(old_state);
				match result {
					Ok(rule) => {
						flush_decls!();
						meta = meta.merge(rule.metadata());
						rules.push(rule);
					}
					Err(_) => {
						// Failed as both declaration and rule - consume as bad declaration for error recovery
						p.rewind(checkpoint);
						p.set_state(State::Nested);
						if let Ok(bad_decl) = p.parse::<BadDeclaration>() {
							p.set_state(old_state);
							decls.push(DeclarationOrBad::Bad(bad_decl));
						}
					}
				}
			}
		}

		// Flush any remaining declarations to rules
		flush_decls!();
		let close_curly = p.parse_if_peek::<T!['}']>()?;
		Ok(Self { open_curly, declarations, rules, close_curly, meta })
	}
}

impl<'a, D, R, M> ToCursors for Block<'a, D, R, M>
where
	D: DeclarationValue<'a, M> + ToCursors,
	R: ToCursors,
	M: NodeMetadata,
{
	fn to_cursors(&self, s: &mut impl CursorSink) {
		ToCursors::to_cursors(&self.open_curly, s);
		ToCursors::to_cursors(&self.declarations, s);
		ToCursors::to_cursors(&self.rules, s);
		ToCursors::to_cursors(&self.close_curly, s);
	}
}

impl<'a, D, R, M> ToSpan for Block<'a, D, R, M>
where
	D: DeclarationValue<'a, M> + ToSpan,
	R: ToSpan,
	M: NodeMetadata,
{
	fn to_span(&self) -> Span {
		self.open_curly.to_span()
			+ if self.close_curly.is_some() {
				self.close_curly.to_span()
			} else {
				self.declarations.to_span() + self.rules.to_span() + self.close_curly.to_span()
			}
	}
}

impl<'a, D, R, M> SemanticEq for Block<'a, D, R, M>
where
	D: DeclarationValue<'a, M>,
	R: SemanticEq,
	M: NodeMetadata,
{
	fn semantic_eq(&self, other: &Self, source_text: &str) -> bool {
		self.open_curly.semantic_eq(&other.open_curly, source_text)
			&& self.close_curly.semantic_eq(&other.close_curly, source_text)
			&& self.declarations.semantic_eq(&other.declarations, source_text)
			&& self.rules.semantic_eq(&other.rules, source_text)
	}
}

#[cfg(test)]
mod tests {
	use super::*;
	use crate::EmptyAtomSet;
	use crate::{Cursor, test_helpers::*};

	#[derive(Debug)]
	struct Decl(T![Ident]);

	impl<M: NodeMetadata> NodeWithMetadata<M> for Decl {
		fn metadata(&self) -> M {
			M::default()
		}
	}

	impl<'a, M: NodeMetadata> DeclarationValue<'a, M> for Decl {
		fn parse_specified_declaration_value<Iter>(p: &mut Parser<'a, Iter>, _: Cursor) -> Result<Self>
		where
			Iter: Iterator<Item = crate::Cursor> + Clone,
		{
			p.parse::<T![Ident]>().map(Self)
		}
	}

	impl ToCursors for Decl {
		fn to_cursors(&self, s: &mut impl CursorSink) {
			ToCursors::to_cursors(&self.0, s);
		}
	}

	impl ToSpan for Decl {
		fn to_span(&self) -> Span {
			self.0.to_span()
		}
	}

	impl SemanticEq for Decl {
		fn semantic_eq(&self, other: &Self, source_text: &str) -> bool {
			self.0.semantic_eq(&other.0, source_text)
		}
	}

	impl NodeWithMetadata<()> for T![Ident] {
		fn metadata(&self) {}
	}

	#[derive(Debug)]
	struct Rule(T![Ident]);

	impl<'a> Parse<'a> for Rule {
		fn parse<I>(p: &mut Parser<'a, I>) -> Result<Self>
		where
			I: Iterator<Item = Cursor> + Clone,
		{
			Ok(Self(p.parse::<T![Ident]>()?))
		}
	}

	impl ToCursors for Rule {
		fn to_cursors(&self, s: &mut impl CursorSink) {
			ToCursors::to_cursors(&self.0, s);
		}
	}

	impl ToSpan for Rule {
		fn to_span(&self) -> Span {
			self.0.to_span()
		}
	}

	impl NodeWithMetadata<()> for Rule {
		fn metadata(&self) {}
	}

	impl<'a> crate::RuleVariants<'a> for Rule {
		type DeclarationValue = Decl;
		type Metadata = ();
	}

	#[test]
	fn test_writes() {
		assert_parse!(EmptyAtomSet::ATOMS, Block<Decl, Rule, ()>, "{color:black}");
	}

	#[test]
	fn test_bad_string_in_block_does_not_hang() {
		let alloc = crate::Arena::new();
		for src in
			[":{\".\n", "am:{\"\n", "alm:{\"\n", "alm:{\";.\n", "alm:{\"; }.\n", "alm:s {\n \x16\x00\x00:\";\n }\n"]
		{
			let lexer = css_lexer::Lexer::new(&EmptyAtomSet::ATOMS, src);
			let mut parser = crate::Parser::new(&alloc, src, lexer);
			let _ = parser.parse::<Block<Decl, Rule, ()>>();
		}
	}

	#[test]
	fn test_trailing_error_kinds_do_not_oom() {
		let alloc = crate::Arena::new();
		for src in ["{)))))))))))))", "{))))))))))))))", "{\r)))))))))))))"] {
			let lexer = css_lexer::Lexer::new(&EmptyAtomSet::ATOMS, src);
			let mut parser = crate::Parser::new(&alloc, src, lexer);
			let _ = parser.parse::<Block<Decl, Rule, ()>>();
		}
	}

	#[test]
	fn test_unparseable_at_rule_does_not_fail_the_block() {
		let alloc = crate::Arena::new();
		for src in ["{@x}", "{@x (}", "{a:b;@x (}", "{@x (", "{@x{a:b}}"] {
			let lexer = css_lexer::Lexer::new(&EmptyAtomSet::ATOMS, src);
			let mut parser = crate::Parser::new(&alloc, src, lexer);
			assert!(parser.parse::<Block<Decl, Rule, ()>>().is_ok(), "{src:?} should parse as a Block");
		}
	}
}