xtask/codegen/src/js_kinds_src.rs (1)

661-664: Correctness: wrong names for shift-assign tokens

The names for <<=/>>= are swapped. This can generate misleading accessors.

Apply this fix:

-                    (">>=", _) => "left_shift_assign",
-                    ("<<=", _) => "right_shift_assign",
+                    ("<<=", _) => "left_shift_assign",
+                    (">>=", _) => "right_shift_assign",

crates/biome_css_formatter/src/tailwind/auxiliary/simple_utility_name.rs (1)

1-11: Add missing module registration

Our check didn’t find simple_utility_name in crates/biome_css_formatter/src/tailwind/auxiliary/mod.rs, so the new formatter won’t be picked up. Please add:

--- a/crates/biome_css_formatter/src/tailwind/auxiliary/mod.rs
+++ b/crates/biome_css_formatter/src/tailwind/auxiliary/mod.rs
+mod simple_utility_name;

xtask/codegen/src/formatter.rs (1)

573-584: Missing Tailwind in NodeDialect::all().

The Tailwind variant is not included in the all() method, which could prevent proper module generation for Tailwind formatters.

 fn all() -> &'static [Self] {
     &[
         Self::Js,
         Self::Ts,
         Self::Jsx,
         Self::Json,
         Self::Css,
         Self::Grit,
         Self::Graphql,
         Self::Html,
+        Self::Tailwind,
     ]
 }

crates/biome_css_parser/src/lexer/mod.rs (1)

834-834: Typo in viewport height unit mapping.

The "svh" keyword is incorrectly mapped to SVW_KW instead of SVH_KW.

-            b"svh" => SVW_KW,
+            b"svh" => SVH_KW,

crates/biome_service/src/file_handlers/css.rs (1)

379-396: Critical: Tailwind directives always disabled in parser

The tailwind_directives option is hardcoded to false instead of reading from settings. This prevents the feature from working even when enabled in configuration.

Apply this fix:

     let mut options = CssParserOptions {
         allow_wrong_line_comments: settings
             .languages
             .css
             .parser
             .allow_wrong_line_comments
             .unwrap_or_default()
             .into(),
         css_modules: settings
             .languages
             .css
             .parser
             .css_modules_enabled
             .unwrap_or_default()
             .into(),
         grit_metavariables: false,
-        tailwind_directives: false,
+        tailwind_directives: settings
+            .languages
+            .css
+            .parser
+            .tailwind_directives_enabled(),
     };

crates/biome_css_formatter/src/tailwind/auxiliary/mod.rs (1)

1-6: Missing auxiliary module declarations in mod.rs

The generated mod.rs only exports three modules, but there are ten .rs files in crates/biome_css_formatter/src/tailwind/auxiliary/. Please update the code generator (or re-run it) so that all of the following modules are declared:

• alpha_function
• helper_function
• modifier_function
• simple_utility_name
• spacing_function
• value_arbitrary_type
• value_function

This will ensure the auxiliary folder’s contents are fully exposed.

crates/biome_css_parser/tests/css_test_suite/ok/tailwind/utility/value-literals.css (1)

2-2: Add complementary cases for --value wildcards and identifiers

This covers multi-arg strings. Consider adding:

• A wildcard variant: --value([], "inherit") to exercise the [] path mentioned in the PR.
• An identifiers variant (if allowed): --value(inherit, initial, unset) to ensure both token forms parse as intended.

Happy to draft the extra fixtures under ok/tailwind/utility and a disabled/diagnostics counterpart if you want parity tests.

crates/biome_css_parser/tests/css_test_suite/ok/tailwind/reference.css (2)

18-20: Add variants for quoting and whitespace robustness.

Consider extending with single quotes and extra whitespace to harden parsing around trivia and different string delimiters.

Proposed additions:

 /* @reference without file extension */
 @reference "./mixins";
 
+/* @reference with single quotes */
+@reference './single-quotes.css';
+
+/* @reference with additional whitespace */
+@reference     "./spaced.css"   ;
+
+/* @reference with escaped characters in string */
+@reference "./with\\ spaces.css";

---

10-14: Optional: add a bare package name and a deeper scoped path.

If the grammar accepts any string, adding these helps ensure we don’t accidentally special-case only paths with slashes or extensions.

Proposed additions:

 /* @reference with scoped package */
 @reference "../node_modules/@company/design-tokens/index.css";
 
+/* @reference with bare package name */
+@reference "normalize.css";
+
+/* @reference with deeper scoped package path */
+@reference "@company/design-tokens/tokens/colors.css";

crates/biome_css_formatter/src/tailwind/auxiliary/spacing_function.rs (1)

1-10: Add a formatter round-trip test to lock behaviour

Given this prints verbatim, a simple golden/round-trip test would guard against accidental normalisation later (e.g., spacing between tokens, comments, empty args).

Would you like me to draft a formatter test fixture mirroring the parser one?

crates/biome_css_parser/tests/css_test_suite/ok/tailwind/spacing_function.css (1)

1-75: Consider a formatter snapshot/round-trip for spacing()

A companion formatter test (enabled mode) would help ensure spacing() survives formatting unchanged across the variety of contexts covered here.

crates/biome_css_formatter/src/tailwind/auxiliary/modifier_function.rs (1)

4-5: Nit: derive Copy and add a brief rustdoc for intent

Zero-sized rule types typically derive Copy in this codebase. A short rustdoc helps future readers understand why this is verbatim.

Apply:

-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Copy, Default)]
-pub(crate) struct FormatTwModifierFunction;
+/// Tailwind v4 (experimental): format modifier functions verbatim until rules stabilise.
+pub(crate) struct FormatTwModifierFunction;

crates/biome_css_parser/tests/css_test_suite/error/tailwind/when-disabled/source.css (1)

1-1: Good negative test; consider one more variant

Nice addition for the disabled-path. Consider adding a second case with a url() form or spaces around the string to ensure the diagnostic triggers consistently across argument forms.

crates/biome_css_parser/tests/css_test_suite/error/tailwind/when-disabled/utility.css (1)

1-1: Solid disabled-path check; widen coverage

Add a second utility using parameters or modifiers (e.g. with brackets or slash modifiers) to assert the same diagnostic fires for complex names too.

crates/biome_css_parser/tests/css_test_suite/error/tailwind/when-disabled/theme.css (1)

1-3: Nice; also test nested content under disabled

Consider an additional disabled test where @theme contains nested at-rules (e.g. keyframes) to confirm the gate triggers regardless of inner content.

crates/biome_css_parser/tests/css_test_suite/ok/tailwind/theme/theme-with-keyframes.css (1)

1-11: Great nested-case coverage

Good call testing keyframes inside theme. A sibling nested rule (e.g. @font-face) would further exercise nesting, but this is already valuable.

crates/biome_css_parser/tests/css_test_suite/error/tailwind/when-disabled/apply.css (1)

1-3: Good failure path; consider syntax edge variants

Add a case without the trailing semicolon or multiple @apply lines to confirm diagnostics aren’t sensitive to minor syntax variations.

crates/biome_css_parser/tests/css_test_suite/ok/tailwind/theme/theme-with-name.css (1)

1-3: Looks good: named @theme parses cleanly

Solid positive path. Consider adding a companion test for a quoted name (e.g. "@theme "foo"") or anonymous theme to harden coverage.

crates/biome_css_parser/tests/css_test_suite/error/tailwind/when-disabled/reference.css (1)

1-1: Good negative case for disabled Tailwind directives

This should trigger the expected “tailwind disabled” diagnostic. You might also add variants using single quotes and url() to broaden coverage.

crates/biome_css_parser/tests/css_test_suite/ok/tailwind/utility/simple-utility.css (1)

1-5: Comprehensive utility parsing smoke tests

Nice coverage, including an empty @Utility. As a follow-up, a test with multiple utilities back-to-back without blank lines could help assert formatter spacing decisions.

Also applies to: 7-17, 19-21, 23-23

crates/biome_css_parser/tests/css_test_suite/ok/tailwind/utility/arbitrary-star.css (1)

1-3: Arbitrary utility + [*] value placeholder covered

This squarely hits the new grammar. Consider an extra case with whitespace inside the brackets or quoting to ensure tokenisation remains stable.

crates/biome_css_parser/tests/css_test_suite/ok/tailwind/source.css (1)

1-1: @source happy path looks right

Good addition. A sibling test with url("../...") could ensure both string and url() are accepted as expected.

crates/biome_css_parser/tests/css_test_suite/ok/tailwind/utility/modifier.css (1)

1-3: Modifier function parsing exercised

Great. Adding a companion test for --modifier([*], [length]) would cover the arbitrary-value placeholder within modifier as well.

crates/biome_css_parser/tests/css_test_suite/error/tailwind/when-enabled/value-incomplete.css (1)

1-3: Nice negative: incomplete --value()

Good case to validate recovery and a crisp diagnostic. Suggest adding a sibling for --modifier( with a missing closing parenthesis to cover both paths.

crates/biome_css_parser/tests/css_test_suite/error/tailwind/when-disabled/plugin.css (1)

1-1: LGTM: disabled @plugin is exercised

Solid. Consider adding single-quoted and unquoted variants (if allowed) to ensure consistent diagnostics across argument forms.

crates/biome_css_parser/tests/css_test_suite/ok/tailwind/config.css (1)

1-1: LGTM: enabled @config happy-path

Complements the disabled test nicely. As a follow-up, a relative vs absolute path pair could help ensure we don’t over-constrain string values.

crates/biome_css_parser/tests/css_test_suite/ok/tailwind/utility/with-param.css (1)

1-3: Good coverage for parameterised utility and star propagation

This exercises both selector tab-* and --value(--tab-size-*). Consider adding:

• A case with multiple parameters, e.g. foo-*-*
• A value using [*] bracketed usage to mirror the docs

crates/biome_css_parser/tests/css_test_suite/ok/tailwind/theme/theme-with-star-vars.css (1)

1-4: LGTM: star-suffixed custom properties in @theme

Neat. It would be useful to add a negative where * is in the middle (e.g. --color-re*d) to ensure we only allow the documented trailing form.

crates/biome_css_parser/tests/css_test_suite/ok/tailwind/variant.css (1)

1-14: Great: nested @variant coverage

Covers nesting depth and typical variants. Consider an error-suite counterpart for an unknown variant to validate diagnostics, plus a mixed-content block (rules + nested @variant) to exercise list parsing.

xtask/codegen/src/js_kinds_src.rs (1)

713-715: Keyword ident sanitising is fine; consider guarding empty idents

Trimming underscores after hyphen replacement avoids awkward leading/trailing _. Edge‑case guard (debug assert) would help catch accidental empty idents during codegen.

-                if kind_source.keywords.contains(&name) {
-                    format_ident!("{}_token", name.replace('-', "_").trim_matches('_'))
+                if kind_source.keywords.contains(&name) {
+                    let sanitized = name.replace('-', "_");
+                    let trimmed = sanitized.trim_matches('_');
+                    debug_assert!(
+                        !trimmed.is_empty(),
+                        "sanitised keyword produced an empty ident: {name:?}"
+                    );
+                    format_ident!("{}_token", trimmed)

xtask/codegen/src/css_kinds_src.rs (1)

503-517: Mind the 512 SyntaxKind cap – CSS kinds now at 497 entries
After adding 13 TW_* nodes, the CSS kinds list stands at 497 variants (42 punct, 189 keywords, 11 literals, 7 tokens, 248 nodes), leaving just 15 slots before we hit the hard cap.

• Short-term: see if any TW_* entries can reuse existing generic kinds (verbatim handling in the formatter).
• Mid-term: consider bumping the kind-space limit in codegen/rowan or partitioning “feature namespaces” to avoid this ceiling.

crates/biome_css_parser/src/syntax/parse_error.rs (1)

235-240: Tune the diagnostic phrasing and markup for consistency.

• Prefer “CSS parser options” casing.
• Consider using Code markup for the option name.

-    p.err_builder(markup! { "Tailwind-specific syntax is disabled."}, range)
+    p.err_builder(markup! { "Tailwind-specific syntax is disabled." }, range)
         .with_hint(markup! {
-            "Enable "<Emphasis>"`tailwind_directives`"</Emphasis>" in the css parser options."
+            "Enable "<Code>"tailwind_directives"</Code>" in the CSS parser options."
         })

crates/biome_css_formatter/src/tailwind/lists/apply_class_list.rs (1)

1-10: Avoid dropping/merging separators; prefer verbatim or explicit spacing.

f.join().entries(...).finish() uses no separator; if entries don’t render trailing trivia, classes may be concatenated.

Option A (consistent with other Tw formatters; preserves comments/spacing):

-    fn fmt(&self, node: &TwApplyClassList, f: &mut CssFormatter) -> FormatResult<()> {
-        f.join().entries(node.iter().formatted()).finish()
-    }
+    fn fmt(&self, node: &TwApplyClassList, f: &mut CssFormatter) -> FormatResult<()> {
+        format_css_verbatim_node(node.syntax()).fmt(f)
+    }

Option B (normalise to single spaces):

-    fn fmt(&self, node: &TwApplyClassList, f: &mut CssFormatter) -> FormatResult<()> {
-        f.join().entries(node.iter().formatted()).finish()
-    }
+    fn fmt(&self, node: &TwApplyClassList, f: &mut CssFormatter) -> FormatResult<()> {
+        let mut join = f.join_with(space());
+        for item in node.iter() {
+            join.entry(item.format());
+        }
+        join.finish()
+    }

crates/biome_css_parser/src/syntax/property/mod.rs (1)

175-184: DRY: reuse the theme-reference helper to wrap the dashed ident.

This avoids duplicating the token consumption logic and keeps the behaviour consistent with value parsing.

-    if is_at_dashed_identifier(p) {
-        let ident = parse_dashed_identifier(p).ok();
-        if let Some(ident) = ident
-            && p.options().is_tailwind_directives_enabled()
-            && p.at(T![-])
-        {
-            let m = ident.precede(p);
-            p.expect(T![-]);
-            p.expect(T![*]);
-            m.complete(p, TW_VALUE_THEME_REFERENCE);
-        }
+    if is_at_dashed_identifier(p) {
+        let ident = parse_dashed_identifier(p).ok();
+        if p.options().is_tailwind_directives_enabled() {
+            // Only attempt wrapping when the -* tail is present
+            if p.at(T![-]) && p.nth_at(1, T![*]) {
+                if let Some(ident) = ident {
+                    let m = ident.precede(p);
+                    p.expect(T![-]);
+                    p.expect(T![*]);
+                    m.complete(p, TW_VALUE_THEME_REFERENCE);
+                }
+            }
+        }

If you prefer, import and call parse_tailwind_value_theme_reference(...) here and use its Present/Absent to decide whether to wrap (may require a small API adjustment).

crates/biome_css_formatter/src/tailwind/lists/value_list.rs (1)

1-11: Uses FormatRule instead of FormatNodeRule pattern

This formatter uses FormatRule<TwValueList> rather than the FormatNodeRule<TwValueList> pattern used by other Tailwind formatters. While both approaches work, consider aligning with the FormatNodeRule pattern for consistency across the Tailwind formatter modules.

crates/biome_css_parser/src/syntax/mod.rs (1)

590-600: Bracketed * handling is now robust.

Using the exclusive gate here avoids cascades and keeps recovery local. Thanks for addressing the earlier feedback.

crates/biome_css_parser/src/syntax/at_rule/mod.rs (1)

117-164: Solid feature-gated dispatch for Tailwind at-rules; consider a tiny DRY helper.

The repeated pattern:

• feature.gate(parse_fn, tailwind_disabled).or_else(parse_unknown)

is clear but verbose. A small helper would reduce noise and keep all Tailwind at-rule gating consistent.

For example (add near the top of this module):

#[inline]
fn parse_tailwind_exclusive(
    p: &mut CssParser,
    f: fn(&mut CssParser) -> ParsedSyntax,
) -> ParsedSyntax {
    CssSyntaxFeatures::Tailwind
        .parse_exclusive_syntax(p, f, |p, m| tailwind_disabled(p, m.range(p)))
        .or_else(|| parse_unknown_at_rule(p))
}

Then each arm becomes:

T![theme] => parse_tailwind_exclusive(p, parse_theme_at_rule),

Follow-up: parse_source_at_rule currently self-gates on options (see tailwind.rs Lines 216-218). Relying solely on this dispatcher avoids duplicated checks and guarantees the same diagnostic path. See inline suggestion there.

crates/biome_css_parser/src/syntax/at_rule/tailwind.rs (2)

57-72: Functional utility detection should use is_at_identifier (not just T![ident]).

Contextual keywords can also lex as identifiers in this parser. Use the higher-level predicate for consistency with the earlier guard and other parsers.

Apply this diff:

 fn parse_utility_name(p: &mut CssParser) -> ParsedSyntax {
     // Check if this is a functional utility (ends with -*)
-    if p.at(T![ident]) && p.nth_at(1, T![-]) && p.nth_at(2, T![*]) {
+    if is_at_identifier(p) && p.nth_at(1, T![-]) && p.nth_at(2, T![*]) {
         // Functional utility: tab-*
         let m = p.start();

         parse_regular_identifier(p).ok();
         p.expect(T![-]);
         p.expect(T![*]);

         Present(m.complete(p, TW_FUNCTIONAL_UTILITY_NAME))
     } else {
         // Simple utility: center-flex
         parse_regular_identifier(p)
     }
 }

---

214-226: Remove in-function Tailwind option check; let the feature gate drive diagnostics.

This function currently short-circuits on !is_tailwind_directives_enabled(), duplicating the gate handled in at_rule/mod.rs. Keeping gating in one place guarantees consistent diagnostics and avoids silent Absent returns if this is ever called elsewhere.

Apply this diff:

 pub(crate) fn parse_source_at_rule(p: &mut CssParser) -> ParsedSyntax {
-    if !p.options().is_tailwind_directives_enabled() || !p.at(T![source]) {
+    if !p.at(T![source]) {
         return Absent;
     }

     let m = p.start();
     p.bump(T![source]);
     parse_string(p).or_add_diagnostic(p, expected_string);
     p.expect(T![;]);

     Present(m.complete(p, TW_SOURCE_AT_RULE))
 }

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled
• Linear integration is disabled

You can enable these sources in your CodeRabbit configuration.

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_parser/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:57:34.726Z
Learning: Parse rules should return ParsedSyntax; return Present only if tokens were consumed, otherwise return Absent without advancing the parser or emitting errors

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_parser/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:57:34.726Z
Learning: Use conditional syntax handling (e.g., StrictMode.excluding_syntax and or_invalid_to_bogus) to diagnose unsupported constructs and attach parsed tokens

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:27.774Z
Learning: Applies to crates/biome_formatter/biome_html_formatter/src/cst.rs : Define FormatHtmlSyntaxNode in cst.rs and implement FormatRule<HtmlSyntaxNode>, plus AsFormat and IntoFormat for HtmlSyntaxNode using the provided mapping code

crates/biome_css_parser/src/syntax/at_rule/mod.rs (1)

117-165: Tailwind dispatch looks correct; consider DRYing the repeated pattern

Each branch repeats the same “exclusive syntax or unknown” flow. Consider a small helper to reduce boilerplate and future copy/paste churn.

Here’s a minimal helper and usage:

// Place near the top of this module
fn parse_tw_or_unknown(
    p: &mut CssParser,
    f: fn(&mut CssParser) -> ParsedSyntax,
) -> ParsedSyntax {
    CssSyntaxFeatures::Tailwind
        .parse_exclusive_syntax(p, f, |p, m| tailwind_disabled(p, m.range(p)))
        .or_else(|| parse_unknown_at_rule(p))
}

Then in the match:

-        T![theme] => CssSyntaxFeatures::Tailwind
-            .parse_exclusive_syntax(p, parse_theme_at_rule, |p, m| {
-                tailwind_disabled(p, m.range(p))
-            })
-            .or_else(|| parse_unknown_at_rule(p)),
+        T![theme] => parse_tw_or_unknown(p, parse_theme_at_rule),

Repeat similarly for utility, variant, custom_variant, apply, source, reference, config, plugin.

crates/biome_css_parser/src/syntax/mod.rs (1)

590-600: When Tailwind is disabled, confirm we don’t cascade errors on leading “*”

This branch remaps “” to an ident only when the Tailwind feature is enabled. If disabled, parse_exclusive_syntax will emit the diagnostic, but won’t consume “” unless it also wraps it in a bogus node. If it returns Absent, the “*” remains and can cascade errors.

• Please confirm parse_exclusive_syntax consumes the “*” (e.g., by attaching a bogus node) when the feature is disabled. If it doesn’t, consider consuming it locally to avoid cascades:

-        if p.at(T![*]) {
-            return CssSyntaxFeatures::Tailwind.parse_exclusive_syntax(
-                p,
-                |p| {
-                    let m = p.start();
-                    p.bump_remap(T![ident]);
-                    return Present(m.complete(p, CSS_CUSTOM_IDENTIFIER));
-                },
-                |p, m| tailwind_disabled(p, m.range(p)),
-            );
-        }
+        if p.at(T![*]) {
+            return CssSyntaxFeatures::Tailwind
+                .parse_exclusive_syntax(
+                    p,
+                    |p| {
+                        let m = p.start();
+                        p.bump_remap(T![ident]);
+                        Present(m.complete(p, CSS_CUSTOM_IDENTIFIER))
+                    },
+                    |p, m| tailwind_disabled(p, m.range(p)),
+                )
+                .or_else(|| {
+                    // Fallback when disabled: consume `*` to prevent cascading errors.
+                    let m = p.start();
+                    p.bump(T![*]);
+                    Present(m.complete(p, CSS_BOGUS_CUSTOM_IDENTIFIER))
+                });
+        }

To verify the behaviour without changing code, run the error-suite tests for “when tailwind disabled” (if available) and inspect whether only a single diagnostic appears for a bracketed list starting with “*”.

crates/biome_css_parser/src/syntax/at_rule/tailwind.rs (1)

214-226: Redundant Tailwind option check; make it consistent with the others

This is the only Tailwind at-rule that checks the feature flag internally. It’s redundant because at_rule/mod.rs already gates via CssSyntaxFeatures::Tailwind. Keeping it can prevent the tailwind_disabled diagnostic from firing in the exclusive path.

Apply this diff to align it with the others:

 pub(crate) fn parse_source_at_rule(p: &mut CssParser) -> ParsedSyntax {
-    if !p.options().is_tailwind_directives_enabled() || !p.at(T![source]) {
+    if !p.at(T![source]) {
         return Absent;
     }
 
     let m = p.start();
     p.bump(T![source]);
     parse_string(p).or_add_diagnostic(p, expected_string);
     p.expect(T![;]);
 
     Present(m.complete(p, TW_SOURCE_AT_RULE))
 }

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled
• Linear integration is disabled

You can enable these sources in your CodeRabbit configuration.

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_parser/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:57:34.726Z
Learning: Parse rules should return ParsedSyntax; return Present only if tokens were consumed, otherwise return Absent without advancing the parser or emitting errors

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_parser/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:57:34.726Z
Learning: Use conditional syntax handling (e.g., StrictMode.excluding_syntax and or_invalid_to_bogus) to diagnose unsupported constructs and attach parsed tokens

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:27.774Z
Learning: Applies to crates/biome_formatter/biome_html_formatter/src/cst.rs : Define FormatHtmlSyntaxNode in cst.rs and implement FormatRule<HtmlSyntaxNode>, plus AsFormat and IntoFormat for HtmlSyntaxNode using the provided mapping code

crates/biome_css_parser/src/syntax/mod.rs (1)

590-600: Two nits: improve error range, and please confirm the disabled path consumes *.

• As above, prefer p.cur_range() for clearer diagnostics.
• When Tailwind is disabled, make sure the * token is consumed to avoid cascades. There was a prior report about this; if parse_exclusive_syntax doesn’t eat the token on the unsupported path, we’ll regress.

-            return CssSyntaxFeatures::Tailwind.parse_exclusive_syntax(
+            return CssSyntaxFeatures::Tailwind.parse_exclusive_syntax(
                 p,
                 |p| {
                     let m = p.start();
                     p.bump_remap(T![ident]);
                     Present(m.complete(p, CSS_CUSTOM_IDENTIFIER))
                 },
-                |p, m| tailwind_disabled(p, m.range(p)),
+                |p, _| tailwind_disabled(p, p.cur_range()),
             );

If parse_exclusive_syntax does not consume on the unsupported path, consider this fallback to avoid cascades:

-                |p, _| tailwind_disabled(p, p.cur_range()),
+                |p, _| {
+                    let range = p.cur_range();
+                    p.error(tailwind_disabled(p, range));
+                    // Consume the token to avoid cascading errors.
+                    let m = p.start();
+                    p.bump(T![*]);
+                    Present(m.complete(p, CSS_BOGUS_CUSTOM_IDENTIFIER))
+                },

To double-check, please run the error tests to ensure only a single diagnostic is emitted and the parser recovers:

#!/usr/bin/env bash
# Inspect tests that exercise Tailwind-in-brackets when disabled and confirm they pass.
# Also search for tests covering `--foo-*` when disabled.
rg -nC2 --type=rust 'when-disabled' crates/biome_css_parser/tests
rg -nC2 -g 'crates/biome_css_parser/tests/**' --type-not=rust '\-\-[a-zA-Z0-9_-]+\-\*'

.changeset/tasty-hairs-shop.md (1)

5-7: Tighten the wording and add the “experimental/default-off” note.

Small grammar/clarity tweak and call out that the support is experimental and disabled by default.

-Added a new CSS parser option `tailwindDirectives`. Enabling this option will allow all of Tailwind v4's syntax additions to be parsed by Biome.
+Added a new CSS parser option `tailwindDirectives`. Enabling this option allows Biome to parse all Tailwind CSS v4 syntax additions.
+
+This support is experimental and disabled by default.

crates/biome_css_parser/src/syntax/mod.rs (1)

340-348: Use p.cur_range() for better diagnostics when the feature is disabled.

m.range(p) may be zero-length here, making the error highlight less useful. Use the current token range instead.

-            CssSyntaxFeatures::Tailwind.parse_exclusive_syntax(
-                p,
-                parse_tailwind_value_theme_reference,
-                |p, m| tailwind_disabled(p, m.range(p)),
-            )
+            CssSyntaxFeatures::Tailwind.parse_exclusive_syntax(
+                p,
+                parse_tailwind_value_theme_reference,
+                |p, _| tailwind_disabled(p, p.cur_range()),
+            )

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled
• Linear integration is disabled

You can enable these sources in your CodeRabbit configuration.

crates/biome_css_parser/src/syntax/at_rule/tailwind.rs (4)

26-28: Drop the redundant pre-check for the optional identifier

parse_regular_identifier(p).ok() already no-ops if no identifier is present. The extra p.at(T![ident]) guard is unnecessary noise.

Apply this diff:

-    if p.at(T![ident]) {
-        parse_regular_identifier(p).ok();
-    }
+    parse_regular_identifier(p).ok();

---

59-59: Use is_at_identifier for robustness

Align with the rest of the parser and prefer is_at_identifier(p) over checking the raw token. It handles edge cases (escapes, vendor prefixes) consistently.

-    if p.at(T![ident]) && p.nth_at(1, T![-]) && p.nth_at(2, T![*]) {
+    if is_at_identifier(p) && p.nth_at(1, T![-]) && p.nth_at(2, T![*]) {

---

168-171: End-of-file should also terminate the list

Lists should terminate on EOF to avoid runaway recovery when the semicolon is missing. You already include EOF in the recovery set; reflect it here too.

-    fn is_at_list_end(&self, p: &mut Self::Parser<'_>) -> bool {
-        p.at(T![;])
-    }
+    fn is_at_list_end(&self, p: &mut Self::Parser<'_>) -> bool {
+        p.at(T![;]) || p.at(EOF)
+    }

---

188-198: DRY the string+semicolon at-rules

@config, @plugin, @source, and @reference share identical structure. Consider a tiny helper to reduce repetition and centralise diagnostics.

Apply this pattern (helper shown outside the selected ranges):

// helper (place near the top of the module)
fn parse_string_terminated_at_rule(
    p: &mut CssParser,
    at_token: SyntaxTokenSetToken, // e.g. T![config]
    kind: CssSyntaxKind,           // e.g. TW_CONFIG_AT_RULE
) -> ParsedSyntax {
    let m = p.start();
    p.bump(at_token);
    parse_string(p).or_add_diagnostic(p, expected_string);
    p.expect(T![;]);
    Present(m.complete(p, kind))
}

Then simplify each:

 pub(crate) fn parse_config_at_rule(p: &mut CssParser) -> ParsedSyntax {
     if !p.at(T![config]) {
         return Absent;
     }
-
-    let m = p.start();
-    p.bump(T![config]);
-    parse_string(p).or_add_diagnostic(p, expected_string);
-    p.expect(T![;]);
-
-    Present(m.complete(p, TW_CONFIG_AT_RULE))
+    parse_string_terminated_at_rule(p, T![config], TW_CONFIG_AT_RULE)
 }

Repeat similarly for plugin, source, and reference.

Also applies to: 200-212, 215-226, 229-240

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled
• Linear integration is disabled

You can enable these sources in your CodeRabbit configuration.

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_parser/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:57:34.751Z
Learning: Use conditional syntax handling (e.g., StrictMode.excluding_syntax and or_invalid_to_bogus) to diagnose unsupported constructs and attach parsed tokens

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:27.774Z
Learning: Applies to crates/biome_formatter/biome_html_formatter/src/cst.rs : Define FormatHtmlSyntaxNode in cst.rs and implement FormatRule<HtmlSyntaxNode>, plus AsFormat and IntoFormat for HtmlSyntaxNode using the provided mapping code

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_parser/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:57:34.751Z
Learning: When parsing optional nodes, use parse_node(p).ok(); for required nodes, use .or_add_diagnostic(...) to add errors and missing markers

crates/biome_css_parser/src/syntax/at_rule/tailwind.rs (1)

212-224: Thanks for removing the redundant enablement check on @source

This now cleanly checks the token and parses; gating belongs at the dispatcher. All good.

crates/biome_css_parser/src/syntax/at_rule/tailwind.rs (5)

42-53: Prefer or_add_diagnostic over pre-check to keep a missing name node

Instead of manually checking is_at_identifier and bailing with CSS_BOGUS_AT_RULE, let the name parser add the diagnostic and a missing node. This keeps the AST shape stable and aligns with parser guidelines.

Apply this diff:

-    // Parse utility name - can be simple or functional
-    if !is_at_identifier(p) {
-        p.error(expected_identifier(p, p.cur_range()));
-        return Present(m.complete(p, CSS_BOGUS_AT_RULE));
-    }
-
-    parse_utility_name(p).ok();
+    // Parse utility name - can be simple or functional
+    parse_utility_name(p).or_add_diagnostic(p, expected_identifier);

---

72-91: Same here: rely on .or_add_diagnostic for the required identifier

Mirror the approach suggested for @Utility to avoid early CSS_BOGUS_AT_RULE and preserve structure when the name is missing.

-    if !is_at_identifier(p) {
-        p.error(expected_identifier(p, p.cur_range()));
-        return Present(m.complete(p, CSS_BOGUS_AT_RULE));
-    }
-
-    parse_regular_identifier(p).ok();
+    parse_regular_identifier(p).or_add_diagnostic(p, expected_identifier);

---

93-124: @custom-variant: use .or_add_diagnostic for the variant name

Same rationale: better recovery and a consistent AST when the ident is missing.

-    if !is_at_identifier(p) {
-        p.error(expected_identifier(p, p.cur_range()));
-        return Present(m.complete(p, CSS_BOGUS_AT_RULE));
-    }
-
-    parse_regular_identifier(p).ok();
+    parse_regular_identifier(p).or_add_diagnostic(p, expected_identifier);

---

166-169: Terminate @apply class list on EOF as well

ParseNodeList typically should treat EOF as a list terminator to avoid pathological loops on unterminated input. You’re already recovering on EOF; let’s also end the list there.

-        p.at(T![;])
+        p.at(T![;]) || p.at(EOF)

---

184-239: Minor DRY: four identical “string + ;” at-rules

@config, @plugin, @source, @reference share the same body shape. If you fancy trimming repetition, a tiny helper or macro can reduce boilerplate. Not a blocker.

For example, you could introduce a small macro:

// outside the impls in this module
macro_rules! parse_string_terminated_at_rule {
    ($p:expr, $tok:tt, $kind:ident) => {{
        let m = $p.start();
        $p.bump(T![$tok]);
        parse_string($p).or_add_diagnostic($p, expected_string);
        $p.expect(T![;]);
        Present(m.complete($p, $kind))
    }};
}

Then use:

pub(crate) fn parse_config_at_rule(p: &mut CssParser) -> ParsedSyntax {
    if !p.at(T![config]) { return Absent; }
    parse_string_terminated_at_rule!(p, config, TW_CONFIG_AT_RULE)
}

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled
• Linear integration is disabled

You can enable these sources in your CodeRabbit configuration.

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_parser/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:57:34.751Z
Learning: Use conditional syntax handling (e.g., StrictMode.excluding_syntax and or_invalid_to_bogus) to diagnose unsupported constructs and attach parsed tokens

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:27.774Z
Learning: Applies to crates/biome_formatter/biome_html_formatter/src/cst.rs : Define FormatHtmlSyntaxNode in cst.rs and implement FormatRule<HtmlSyntaxNode>, plus AsFormat and IntoFormat for HtmlSyntaxNode using the provided mapping code

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_parser/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:57:34.751Z
Learning: When parsing optional nodes, use parse_node(p).ok(); for required nodes, use .or_add_diagnostic(...) to add errors and missing markers

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_parser/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:57:34.751Z
Learning: Do not progress the parser when a parse_* rule returns Absent, especially inside loops

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_parser/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:57:34.751Z
Learning: Parse rules should return ParsedSyntax; return Present only if tokens were consumed, otherwise return Absent without advancing the parser or emitting errors