feat(linter): implement class sorting rule (first pass)

crates/biome_diagnostics_categories/src/categories.rs

@@ -128,6 +128,7 @@ define_categories! {
     "lint/nursery/useNodejsImportProtocol": "https://biomejs.dev/linter/rules/use-nodejs-import-protocol",
     "lint/nursery/useNumberNamespace": "https://biomejs.dev/linter/rules/use-number-namespace",
     "lint/nursery/useShorthandFunctionType": "https://biomejs.dev/linter/rules/use-shorthand-function-type",
+    "lint/nursery/useSortedClasses": "https://biomejs.dev/linter/rules/use-sorted-classes",
     "lint/performance/noAccumulatingSpread": "https://biomejs.dev/linter/rules/no-accumulating-spread",
     "lint/performance/noDelete": "https://biomejs.dev/linter/rules/no-delete",
     "lint/security/noDangerouslySetInnerHtml": "https://biomejs.dev/linter/rules/no-dangerously-set-inner-html",

crates/biome_js_analyze/src/semantic_analyzers/nursery/use_sorted_classes.rs

@@ -0,0 +1,122 @@
+mod any_class_string_like;
+mod class_info;
+mod class_lexer;
+mod options;
+mod presets;
+mod sort;
+mod sort_config;
+
+use biome_analyze::{
+    context::RuleContext, declare_rule, ActionCategory, Ast, FixKind, Rule, RuleDiagnostic,
+};
+use biome_console::markup;
+use biome_diagnostics::Applicability;
+use biome_js_factory::make::{js_string_literal, js_string_literal_expression, jsx_string};
+use biome_rowan::{AstNode, BatchMutationExt};
+
+use crate::JsRuleAction;
+
+pub use self::options::UseSortedClassesOptions;
+use self::{
+    any_class_string_like::AnyClassStringLike,
+    presets::{get_utilities_preset, UseSortedClassesPreset},
+    sort::sort_class_name,
+    sort_config::SortConfig,
+};
+
+declare_rule! {
+    /// Enforce the sorting of CSS classes.
+    ///
+    /// TODO: description
+    ///
+    /// ## Examples
+    ///
+    /// ### Invalid
+    ///
+    /// ```jsx,expect_diagnostic
+    /// <div class="px-2 foo px-4 bar" />;
+    /// ```
+    ///
+    /// ## Valid
+    ///
+    /// ```js
+    /// // TODO: examples
+    /// ```
+    ///
+    pub(crate) UseSortedClasses {
+        version: "next",
+        name: "useSortedClasses",
+        recommended: false,
+        fix_kind: FixKind::Safe,
+    }
+}
+
+impl Rule for UseSortedClasses {
+    type Query = Ast<AnyClassStringLike>;
+    type State = String;
+    type Signals = Option<Self::State>;
+    type Options = UseSortedClassesOptions;
+
+    fn run(ctx: &RuleContext<Self>) -> Option<Self::State> {
+        // TODO: unsure if options are needed here. The sort config should ideally be created once
+        // from the options and then reused for all queries.
+        // let options = &ctx.options();
+        // TODO: the sort config should already exist at this point, and be generated from the options,
+        // including the preset and extended options as well.
+        let sort_config = SortConfig::new(
+            get_utilities_preset(&UseSortedClassesPreset::default()),
+            Vec::new(),
+        );
+
+        let value = ctx.query().value()?;
+        let sorted_value = sort_class_name(value.as_str(), &sort_config);
+        if value != sorted_value {
+            Some(sorted_value)
+        } else {
+            None
+        }
+    }
+
+    fn diagnostic(ctx: &RuleContext<Self>, _: &Self::State) -> Option<RuleDiagnostic> {
+        Some(
+            RuleDiagnostic::new(rule_category!(), ctx.query().range(), "TODO: title").note(
+                markup! {
+                    "TODO: description."
+                },
+            ),
+        )
+    }
+
+    fn action(ctx: &RuleContext<Self>, state: &Self::State) -> Option<JsRuleAction> {
+        let mut mutation = ctx.root().begin();
+        match ctx.query() {
+            AnyClassStringLike::JsStringLiteralExpression(string_literal) => {
+                let replacement = js_string_literal_expression(js_string_literal(state));
+                mutation.replace_node(string_literal.clone(), replacement);
+                Some(JsRuleAction {
+                    category: ActionCategory::QuickFix,
+                    applicability: Applicability::Always,
+                    message: markup! {
+                        "TODO: message."
+                    }
+                    .to_owned(),
+                    mutation,
+                })
+            }
+            AnyClassStringLike::JsxString(jsx_string_node) => {
+                let replacement = jsx_string(js_string_literal(state));
+                mutation.replace_node(jsx_string_node.clone(), replacement);
+                Some(JsRuleAction {
+                    category: ActionCategory::QuickFix,
+                    applicability: Applicability::Always,
+                    message: markup! {
+                        "TODO: message."
+                    }
+                    .to_owned(),
+                    mutation,
+                })
+            }
+            _ => None,
+        }
+    }
+}

crates/biome_js_analyze/src/semantic_analyzers/nursery/use_sorted_classes/any_class_string_like.rs

@@ -0,0 +1,226 @@
+use biome_analyze::{
+    AddVisitor, AnalyzerOptions, Phases, QueryMatch, Queryable, RuleKey, ServiceBag, Visitor,
+    VisitorContext,
+};
+use biome_js_syntax::{
+    JsCallArguments, JsCallExpression, JsLanguage, JsStringLiteralExpression,
+    JsTemplateChunkElement, JsxAttribute, JsxString,
+};
+use biome_rowan::{declare_node_union, AstNode, Language, SyntaxNode, TextRange, WalkEvent};
+
+use super::UseSortedClassesOptions;
+
+// utils
+// -----
+
+fn get_options_from_analyzer(analyzer_options: &AnalyzerOptions) -> UseSortedClassesOptions {
+    match analyzer_options
+        .configuration
+        .rules
+        .get_rule_options::<UseSortedClassesOptions>(&RuleKey::new("nursery", "useSortedClasses"))
+    {
+        Some(options) => options.clone(),
+        None => UseSortedClassesOptions::default(),
+    }
+}
+
+fn get_callee_name(call_expression: &JsCallExpression) -> Option<String> {
+    Some(
+        call_expression
+            .callee()
+            .ok()?
+            .as_js_identifier_expression()?
+            .name()
+            .ok()?
+            .name()
+            .ok()?
+            .to_string(),
+    )
+}
+
+fn is_call_expression_of_target_function(
+    call_expression: &JsCallExpression,
+    target_functions: &[String],
+) -> bool {
+    match get_callee_name(call_expression) {
+        Some(name) => target_functions.contains(&name.to_string()),
+        None => false,
+    }
+}
+
+fn get_attribute_name(attribute: &JsxAttribute) -> Option<String> {
+    Some(attribute.name().ok()?.as_jsx_name()?.to_string())
+}
+
+fn is_target_attribute(attribute: &JsxAttribute, target_attributes: &[String]) -> bool {
+    match get_attribute_name(attribute) {
+        Some(name) => target_attributes.contains(&name.to_string()),
+        None => false,
+    }
+}
+
+// attributes visitor
+// ------------------
+
+#[derive(Default)]
+struct StringLiteralInAttributeVisitor {
+    in_target_attribute: bool,
+}
+
+// Finds class-like strings in JSX attributes, including class, className, and others defined in the options.
+impl Visitor for StringLiteralInAttributeVisitor {
+    type Language = JsLanguage;
+    fn visit(
+        &mut self,
+        event: &WalkEvent<SyntaxNode<Self::Language>>,
+        mut ctx: VisitorContext<Self::Language>,
+    ) {
+        let options = get_options_from_analyzer(ctx.options);
+        match event {
+            WalkEvent::Enter(node) => {
+                // When entering an attribute node, track if we are in a target attribute.
+                if let Some(attribute) = JsxAttribute::cast_ref(node) {
+                    self.in_target_attribute = is_target_attribute(&attribute, &options.attributes);
+                }
+
+                // When entering a JSX string node, and we are in a target attribute, emit.
+                if let Some(jsx_string) = JsxString::cast_ref(node) {
+                    if self.in_target_attribute {
+                        ctx.match_query(AnyClassStringLike::JsxString(jsx_string));
+                    }
+                }
+
+                // When entering a string literal node, and we are in a target attribute, emit.
+                if let Some(string_literal) = JsStringLiteralExpression::cast_ref(node) {
+                    if self.in_target_attribute {
+                        ctx.match_query(AnyClassStringLike::JsStringLiteralExpression(
+                            string_literal,
+                        ));
+                    }
+                }
+            }
+            WalkEvent::Leave(node) => {
+                // When leaving an attribute node, reset in_target_attribute.
+                if JsxAttribute::cast_ref(node).is_some() {
+                    self.in_target_attribute = false;
+                }
+            }
+        }
+    }
+}
+
+// functions (call expression) visitor
+// -----------------------------------
+
+#[derive(Default)]
+struct StringLiteralInCallExpressionVisitor {
+    in_target_function: bool,
+    in_arguments: bool,
+}
+
+// Finds class-like strings inside function calls defined in the options, e.g. clsx(classes).
+impl Visitor for StringLiteralInCallExpressionVisitor {
+    type Language = JsLanguage;
+
+    fn visit(
+        &mut self,
+        event: &WalkEvent<SyntaxNode<Self::Language>>,
+        mut ctx: VisitorContext<Self::Language>,
+    ) {
+        let options = get_options_from_analyzer(ctx.options);
+        if options.functions.is_empty() {
+            return;
+        }
+        match event {
+            WalkEvent::Enter(node) => {
+                // When entering a call expression node, track if we are in a target function and reset
+                // in_arguments.
+                if let Some(call_expression) = JsCallExpression::cast_ref(node) {
+                    self.in_target_function =
+                        is_call_expression_of_target_function(&call_expression, &options.functions);
+                    self.in_arguments = false;
+                }
+
+                // When entering a call arguments node, set in_arguments.
+                if JsCallArguments::cast_ref(node).is_some() {
+                    self.in_arguments = true;
+                }
+
+                // When entering a string literal node, and we are in a target function and in arguments, emit.
+                if let Some(string_literal) = JsStringLiteralExpression::cast_ref(node) {
+                    if self.in_target_function && self.in_arguments {
+                        ctx.match_query(AnyClassStringLike::JsStringLiteralExpression(
+                            string_literal,
+                        ));
+                    }
+                }
+            }
+            WalkEvent::Leave(node) => {
+                // When leaving a call arguments node, reset in_arguments.
+                if JsCallArguments::cast_ref(node).is_some() {
+                    self.in_arguments = false;
+                }
+            }
+        }
+    }
+}
+
+// functions (template chunk) visitor
+// ----------------------------------
+
+// Finds class-like template chunks in tagged template calls defined in the options, e.g. tw`classes`.
+// TODO: template chunk visitor
+
+// query
+// -----
+
+declare_node_union! {
+    /// A string literal, JSX string, or template chunk representing a CSS class string.
+    pub AnyClassStringLike = JsStringLiteralExpression | JsxString | JsTemplateChunkElement
+}
+
+impl AnyClassStringLike {
+    /// Returns the value of the string literal, JSX string, or template chunk.
+    pub fn value(&self) -> Option<String> {
+        match self {
+            AnyClassStringLike::JsStringLiteralExpression(string_literal) => {
+                Some(string_literal.inner_string_text().ok()?.to_string())
+            }
+            AnyClassStringLike::JsxString(jsx_string) => {
+                Some(jsx_string.inner_string_text().ok()?.to_string())
+            }
+            AnyClassStringLike::JsTemplateChunkElement(template_chunk) => {
+                Some(template_chunk.to_string())
+            }
+        }
+    }
+}
+
+impl QueryMatch for AnyClassStringLike {
+    fn text_range(&self) -> TextRange {
+        self.range()
+    }
+}
+
+impl Queryable for AnyClassStringLike {
+    type Input = Self;
+    type Language = JsLanguage;
+    type Output = AnyClassStringLike;
+    type Services = ();
+
+    fn build_visitor(
+        analyzer: &mut impl AddVisitor<Self::Language>,
+        _: &<Self::Language as Language>::Root,
+    ) {
+        analyzer.add_visitor(Phases::Syntax, || {
+            StringLiteralInAttributeVisitor::default()
+        });
+        analyzer.add_visitor(Phases::Syntax, || {
+            StringLiteralInCallExpressionVisitor::default()
+        });
+    }
+
+    fn unwrap_match(_: &ServiceBag, query: &Self::Input) -> Self::Output {
+        query.clone()
+    }
+}