feat(tailwind): plumbing for tailwind analyze crate

Author: dyc3

Cargo.lock

@@ -97,6 +97,7 @@ biome_ruledoc_utils          = { path = "./crates/biome_ruledoc_utils" }
 biome_service                = { path = "./crates/biome_service" }
 biome_string_case            = { path = "./crates/biome_string_case", version = "0.5.7", features = ["biome_rowan"] }
 biome_suppression            = { path = "./crates/biome_suppression", version = "0.5.7" }
+biome_tailwind_analyze       = { path = "./crates/biome_tailwind_analyze", version = "0.0.1" }
 biome_tailwind_factory       = { path = "./crates/biome_tailwind_factory", version = "0.0.1" }
 biome_tailwind_parser        = { path = "./crates/biome_tailwind_parser", version = "0.0.1" }
 biome_tailwind_syntax        = { path = "./crates/biome_tailwind_syntax", version = "0.0.1" }

Cargo.toml

@@ -68,7 +68,8 @@ fn generate_group_code(category: &str, group: &str) -> Result<TokenStream> {
     // Use CARGO_MANIFEST_DIR to get the base path since proc_macro::Span::source_file
     // is not available on stable Rust
     let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").context("CARGO_MANIFEST_DIR not set")?;
-    let base_path = Utf8PathBuf::from(manifest_dir).join("src").join(category);
+    let manifest_path = Utf8PathBuf::from(&manifest_dir);
+    let base_path = manifest_path.join("src").join(category);
 
     // Discover all rules in the group directory
     let group_dir = base_path.join(group);
@@ -116,11 +117,37 @@ fn generate_group_code(category: &str, group: &str) -> Result<TokenStream> {
         );
     }
 
+    let group_name = format_ident!("{}", Case::Pascal.convert(group));
+
     if rules.is_empty() {
-        bail!("No rules found in directory: {}", group_dir);
-    }
+        // fallback, if there are no rules, still generate the group anyway to avoid breaking the build
+        let crate_name = manifest_path
+            .file_name()
+            .context("Failed to determine analyzer crate name")?;
+        let language = analyzer_language(crate_name)?;
 
-    let group_name = format_ident!("{}", Case::Pascal.convert(group));
+        let tokens = quote! {
+            pub enum #group_name {}
+
+            impl biome_analyze::RuleGroup for #group_name {
+                type Language = #language;
+                type Category = super::Category;
+
+                const NAME: &'static str = #group;
+
+                fn record_rules<V: biome_analyze::RegistryVisitor<Self::Language> + ?Sized>(_: &mut V) {}
+            }
+
+            pub(self) use #group_name as Group;
+        };
+
+        let formatted = format_code(tokens)?;
+        let token_stream = formatted
+            .parse::<proc_macro2::TokenStream>()
+            .map_err(|e| anyhow::anyhow!("Failed to parse formatted code as TokenStream: {}", e))?;
+
+        return Ok(token_stream.into());
+    }
 
     let (rule_imports, rule_names): (Vec<_>, Vec<_>) = rules.into_values().unzip();
 
@@ -174,6 +201,18 @@ fn generate_group_code(category: &str, group: &str) -> Result<TokenStream> {
     Ok(token_stream.into())
 }
 
+fn analyzer_language(crate_name: &str) -> Result<proc_macro2::TokenStream> {
+    Ok(match crate_name {
+        "biome_css_analyze" => quote!(biome_css_syntax::CssLanguage),
+        "biome_graphql_analyze" => quote!(biome_graphql_syntax::GraphqlLanguage),
+        "biome_html_analyze" => quote!(biome_html_syntax::HtmlLanguage),
+        "biome_js_analyze" => quote!(biome_js_syntax::JsLanguage),
+        "biome_json_analyze" => quote!(biome_json_syntax::JsonLanguage),
+        "biome_tailwind_analyze" => quote!(biome_tailwind_syntax::TailwindLanguage),
+        _ => bail!("Unsupported analyzer crate: {}", crate_name),
+    })
+}
+
 fn format_code(tokens: proc_macro2::TokenStream) -> Result<String> {
     // Parse the token stream into a syn file
     let file = syn::parse2::<syn::File>(tokens).context("Failed to parse tokens as syn::File")?;

crates/biome_analyze_macros/src/group_macro.rs

@@ -13,21 +13,23 @@ categories.workspace = true
 proc-macro = true
 
 [dependencies]
-biome_analyze         = { workspace = true }
-biome_css_analyze     = { workspace = true }
-biome_css_syntax      = { workspace = true }
-biome_graphql_analyze = { workspace = true }
-biome_graphql_syntax  = { workspace = true }
-biome_html_analyze    = { workspace = true }
-biome_html_syntax     = { workspace = true }
-biome_js_analyze      = { workspace = true }
-biome_js_syntax       = { workspace = true }
-biome_json_analyze    = { workspace = true }
-biome_json_syntax     = { workspace = true }
-biome_string_case     = { workspace = true }
-proc-macro2           = { workspace = true }
-pulldown-cmark        = { version = "0.13.0" }
-quote                 = { workspace = true }
+biome_analyze          = { workspace = true }
+biome_css_analyze      = { workspace = true }
+biome_css_syntax       = { workspace = true }
+biome_graphql_analyze  = { workspace = true }
+biome_graphql_syntax   = { workspace = true }
+biome_html_analyze     = { workspace = true }
+biome_html_syntax      = { workspace = true }
+biome_js_analyze       = { workspace = true }
+biome_js_syntax        = { workspace = true }
+biome_json_analyze     = { workspace = true }
+biome_json_syntax      = { workspace = true }
+biome_string_case      = { workspace = true }
+biome_tailwind_analyze = { workspace = true }
+biome_tailwind_syntax  = { workspace = true }
+proc-macro2            = { workspace = true }
+pulldown-cmark         = { version = "0.13.0" }
+quote                  = { workspace = true }
 
 [lints]
 workspace = true

crates/biome_configuration_macros/Cargo.toml

@@ -46,6 +46,7 @@ fn collect_lint_rules() -> LintRulesVisitor {
     biome_css_analyze::visit_registry(&mut lint_visitor);
     biome_graphql_analyze::visit_registry(&mut lint_visitor);
     biome_html_analyze::visit_registry(&mut lint_visitor);
+    biome_tailwind_analyze::visit_registry(&mut lint_visitor);
 
     lint_visitor
 }

crates/biome_configuration_macros/src/lib.rs

@@ -8,6 +8,7 @@ use biome_graphql_syntax::GraphqlLanguage;
 use biome_html_syntax::HtmlLanguage;
 use biome_js_syntax::JsLanguage;
 use biome_json_syntax::JsonLanguage;
+use biome_tailwind_syntax::TailwindLanguage;
 
 // ======= LINT ======
 #[derive(Default)]
@@ -119,6 +120,25 @@ impl RegistryVisitor<HtmlLanguage> for LintRulesVisitor {
     }
 }
 
+impl RegistryVisitor<TailwindLanguage> for LintRulesVisitor {
+    fn record_category<C: GroupCategory<Language = TailwindLanguage>>(&mut self) {
+        if matches!(C::CATEGORY, RuleCategory::Lint) {
+            C::record_groups(self);
+        }
+    }
+
+    fn record_rule<R>(&mut self)
+    where
+        R: Rule<Options: Default, Query: Queryable<Language = TailwindLanguage, Output: Clone>>
+            + 'static,
+    {
+        self.groups
+            .entry(<R::Group as RuleGroup>::NAME)
+            .or_default()
+            .insert(R::METADATA.name, R::METADATA);
+    }
+}
+
 // ======= ASSIST ======
 #[derive(Default)]
 pub struct AssistActionsVisitor {

crates/biome_configuration_macros/src/visitors.rs

@@ -63,6 +63,9 @@ biome_project_layout     = { workspace = true }
 biome_resolver           = { workspace = true }
 biome_rowan              = { workspace = true, features = ["serde"] }
 biome_string_case        = { workspace = true }
+biome_tailwind_analyze   = { workspace = true }
+biome_tailwind_parser    = { workspace = true }
+biome_tailwind_syntax    = { workspace = true }
 biome_text_edit          = { workspace = true }
 boxcar                   = { workspace = true }
 bpaf                     = { workspace = true }

crates/biome_service/Cargo.toml

@@ -1,5 +1,4 @@
-use crate::embed::types::{EmbedCandidate, GuestLanguage, TemplateTagKind};
-use crate::workspace::DocumentFileSource;
+use crate::embed::types::{EmbedCandidate, EmbedDetectionContext, GuestLanguage, TemplateTagKind};
 
 /// A single embed detector. Entirely const-constructible.
 ///
@@ -38,6 +37,12 @@ pub(crate) enum EmbedDetector {
     /// Matches `EmbedCandidate::Directive`. Always matches (no pattern).
     /// The guest language depends on the host framework.
     Directive { target: EmbedTarget },
+
+    /// Matches `EmbedCandidate::AttributeValue` by attribute name.
+    AttributeValue { target: EmbedTarget },
+
+    /// Matches `EmbedCandidate::CallArgument` by callee name.
+    CallArgument { target: EmbedTarget },
 }
 
 impl EmbedDetector {
@@ -47,21 +52,21 @@ impl EmbedDetector {
     pub fn try_match(
         &self,
         candidate: &EmbedCandidate,
-        file_source: &DocumentFileSource,
+        context: &EmbedDetectionContext,
     ) -> Option<GuestLanguage> {
         match (self, candidate) {
             // Element detector VS an Element candidate: match by tag name
             (Self::Element { tag, target }, EmbedCandidate::Element { tag_name, .. }) => {
                 if tag_name.text().eq_ignore_ascii_case(tag) {
-                    target.resolve(candidate, file_source)
+                    target.resolve(candidate, context)
                 } else {
                     None
                 }
             }
 
             // Frontmatter detector + Frontmatter candidate: always matches
             (Self::Frontmatter { target }, EmbedCandidate::Frontmatter { .. }) => {
-                target.resolve(candidate, file_source)
+                target.resolve(candidate, context)
             }
 
             // TemplateTag detector + TaggedTemplate candidate with Identifier tag
@@ -73,7 +78,7 @@ impl EmbedDetector {
                 },
             ) => {
                 if name.text() == *tag {
-                    target.resolve(candidate, file_source)
+                    target.resolve(candidate, context)
                 } else {
                     None
                 }
@@ -87,14 +92,14 @@ impl EmbedDetector {
             ) => match tag {
                 TemplateTagKind::MemberExpression { object: obj, .. } => {
                     if obj.text() == *object {
-                        target.resolve(candidate, file_source)
+                        target.resolve(candidate, context)
                     } else {
                         None
                     }
                 }
                 TemplateTagKind::CallExpression { callee } => {
                     if callee.text() == *object {
-                        target.resolve(candidate, file_source)
+                        target.resolve(candidate, context)
                     } else {
                         None
                     }
@@ -104,12 +109,20 @@ impl EmbedDetector {
 
             // TextExpression detector + TextExpression candidate: always matches
             (Self::TextExpression { target }, EmbedCandidate::TextExpression { .. }) => {
-                target.resolve(candidate, file_source)
+                target.resolve(candidate, context)
             }
 
             // Directive detector + Directive candidate: always matches
             (Self::Directive { target }, EmbedCandidate::Directive { .. }) => {
-                target.resolve(candidate, file_source)
+                target.resolve(candidate, context)
+            }
+
+            (Self::AttributeValue { target }, EmbedCandidate::AttributeValue { .. }) => {
+                target.resolve(candidate, context)
+            }
+
+            (Self::CallArgument { target }, EmbedCandidate::CallArgument { .. }) => {
+                target.resolve(candidate, context)
             }
 
             // Mismatched variant — no match
@@ -126,7 +139,7 @@ pub(crate) enum EmbedTarget {
     /// Guest language depends on element attributes / host file source.
     Dynamic {
         /// Function that is used to determine the guest language.
-        resolver: fn(&EmbedCandidate, &DocumentFileSource) -> Option<GuestLanguage>,
+        resolver: fn(&EmbedCandidate, &EmbedDetectionContext) -> Option<GuestLanguage>,
         /// Possible fallback. Use `None` to tell the matcher to ignore the snippet
         fallback: Option<GuestLanguage>,
     },
@@ -137,11 +150,11 @@ impl EmbedTarget {
     fn resolve(
         &self,
         candidate: &EmbedCandidate,
-        file_source: &DocumentFileSource,
+        context: &EmbedDetectionContext,
     ) -> Option<GuestLanguage> {
         match self {
             Self::Static(g) => Some(*g),
-            Self::Dynamic { resolver, fallback } => resolver(candidate, file_source).or(*fallback),
+            Self::Dynamic { resolver, fallback } => resolver(candidate, context).or(*fallback),
         }
     }
 }