fix broken stylerule parsing

Author: keithamus

crates/hdx_ast/src/css/selector/mod.rs

@@ -1,7 +1,7 @@
 use hdx_atom::Atom;
 use hdx_lexer::Token;
 use hdx_parser::{
-	diagnostics, expect, unexpected, unexpected_ident, Parse, Parser, Result as ParserResult, Span, Spanned,
+	diagnostics, discard, expect, unexpected, unexpected_ident, Parse, Parser, Result as ParserResult, Span, Spanned,
 };
 use hdx_writer::{CssWriter, Result as WriterResult, WriteCss};
 #[cfg(feature = "serde")]
@@ -72,6 +72,9 @@ impl<'a> Parse<'a> for Selector<'a> {
 				}
 			}
 		}
+		// Given selector parsing is Whitespace sensitive, trailing whitespace should be
+		// discarded before moving onto the next parser which is likely a block parser
+		discard!(parser, Token::Whitespace);
 		Ok(Self { components: parser.boxup(components) }.spanned(span.end(parser.pos())))
 	}
 }

crates/hdx_ast/src/css/stylerule.rs

@@ -57,11 +57,15 @@ impl<'a> Parse<'a> for StyleDeclaration<'a> {
 	fn parse(parser: &mut Parser<'a>) -> ParserResult<Spanned<Self>> {
 		let span = parser.span();
 		expect!(parser, Token::LeftCurly);
+		parser.advance();
 		let mut declarations = parser.new_vec();
 		let mut rules = parser.new_vec();
 		loop {
 			match parser.cur() {
-				Token::RightCurly => break,
+				Token::RightCurly => {
+					parser.advance();
+					break;
+				}
 				t @ Token::Eof => unexpected!(parser, t),
 				_ => {
 					let checkpoint = parser.checkpoint();
@@ -96,13 +100,21 @@ impl<'a> WriteCss<'a> for StyleDeclaration<'a> {
 }
 
 #[cfg(test)]
-mod tests {
+mod test {
+	use oxc_allocator::Allocator;
 
 	use super::*;
+	use crate::test_helpers::test_write;
 
 	#[test]
 	fn size_test() {
 		use std::mem::size_of;
 		assert_eq!(size_of::<StyleRule>(), 16);
 	}
+
+	#[test]
+	fn test_writes() {
+		let allocator = Allocator::default();
+		test_write::<StyleRule>(&allocator, "body {}", "body{}");
+	}
 }

crates/hdx_parser/src/traits.rs

@@ -83,7 +83,6 @@ pub trait QualifiedRule<'a>: Sized + Parse<'a> {
 	// https://drafts.csswg.org/css-syntax-3/#consume-a-qualified-rule
 	fn parse_qualified_rule(parser: &mut Parser<'a>) -> Result<(Spanned<Self::Prelude>, Spanned<Self::Block>)> {
 		let prelude = Self::parse_prelude(parser)?;
-		expect!(parser, Token::LeftCurly);
 		Ok((prelude, Self::parse_block(parser)?))
 	}
 }