chore(scss): cherry-picks

crates/biome_css_analyze/src/assist/source/use_sorted_properties.rs

@@ -243,6 +243,7 @@ impl RecessOrderMember {
             AnyCssDeclarationOrRule::CssBogus(_) => NodeKindOrder::UnknownKind,
             AnyCssDeclarationOrRule::CssMetavariable(_) => NodeKindOrder::UnknownKind,
             AnyCssDeclarationOrRule::ScssDeclaration(_) => NodeKindOrder::UnknownKind,
+            AnyCssDeclarationOrRule::ScssNestingDeclaration(_) => NodeKindOrder::UnknownKind,
             AnyCssDeclarationOrRule::AnyCssRule(rule) => match rule {
                 AnyCssRule::CssAtRule(_) => NodeKindOrder::NestedRuleOrAtRule,
                 AnyCssRule::CssBogusRule(_) => NodeKindOrder::UnknownKind,

crates/biome_css_analyze/src/lint/correctness/no_unknown_function.rs

@@ -78,7 +78,10 @@ impl Rule for NoUnknownFunction {
 
     fn run(ctx: &RuleContext<Self>) -> Option<Self::State> {
         let node = ctx.query();
-        let binding = node.name().ok()?.value_token().ok()?;
+        let binding = node.name().ok().and_then(|name| {
+            name.as_css_identifier()
+                .and_then(|name| name.value_token().ok())
+        })?;
         let function_name = binding.text_trimmed();
 
         // We don't have a semantic model yet, so we can't determine if functions are defined elsewhere.

crates/biome_css_analyze/src/lint/correctness/no_unknown_unit.rs

@@ -115,11 +115,11 @@ impl Rule for NoUnknownUnit {
                                 match ancestor.kind() {
                                     CssSyntaxKind::CSS_FUNCTION => {
                                         let function_name_token = ancestor
-                                            .cast::<CssFunction>()?
-                                            .name()
-                                            .ok()?
-                                            .value_token()
-                                            .ok()?;
+                                    .cast::<CssFunction>()?
+                                    .name()
+                                    .ok()?
+                                    .as_css_identifier()
+                                    .and_then(|name| name.value_token().ok())?;
                                         let function_name = function_name_token
                                             .text_trimmed()
                                             .to_ascii_lowercase_cow();

crates/biome_css_formatter/Cargo.toml

@@ -32,6 +32,7 @@ biome_suppression = { workspace = true }
 [dev-dependencies]
 biome_configuration  = { path = "../biome_configuration" }
 biome_css_parser     = { path = "../biome_css_parser" }
+biome_css_syntax     = { path = "../biome_css_syntax", features = ["scss"] }
 biome_formatter      = { workspace = true, features = ["countme"] }
 biome_formatter_test = { path = "../biome_formatter_test" }
 biome_fs             = { path = "../biome_fs" }

crates/biome_css_formatter/src/css/any/bracketed_value_item.rs

@@ -0,0 +1,15 @@
+//! This is a generated file. Don't modify it by hand! Run 'cargo codegen formatter' to re-generate the file.
+
+use crate::prelude::*;
+use biome_css_syntax::AnyCssBracketedValueItem;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatAnyCssBracketedValueItem;
+impl FormatRule<AnyCssBracketedValueItem> for FormatAnyCssBracketedValueItem {
+    type Context = CssFormatContext;
+    fn fmt(&self, node: &AnyCssBracketedValueItem, f: &mut CssFormatter) -> FormatResult<()> {
+        match node {
+            AnyCssBracketedValueItem::AnyCssCustomIdentifier(node) => node.format().fmt(f),
+            AnyCssBracketedValueItem::CssGenericDelimiter(node) => node.format().fmt(f),
+        }
+    }
+}

crates/biome_css_formatter/src/css/any/declaration.rs

@@ -11,6 +11,7 @@ impl FormatRule<AnyCssDeclaration> for FormatAnyCssDeclaration {
             AnyCssDeclaration::CssDeclarationWithSemicolon(node) => node.format().fmt(f),
             AnyCssDeclaration::CssEmptyDeclaration(node) => node.format().fmt(f),
             AnyCssDeclaration::ScssDeclaration(node) => node.format().fmt(f),
+            AnyCssDeclaration::ScssNestingDeclaration(node) => node.format().fmt(f),
         }
     }
 }

crates/biome_css_formatter/src/css/any/declaration_or_at_rule.rs

@@ -12,6 +12,7 @@ impl FormatRule<AnyCssDeclarationOrAtRule> for FormatAnyCssDeclarationOrAtRule {
             AnyCssDeclarationOrAtRule::CssDeclarationWithSemicolon(node) => node.format().fmt(f),
             AnyCssDeclarationOrAtRule::CssEmptyDeclaration(node) => node.format().fmt(f),
             AnyCssDeclarationOrAtRule::ScssDeclaration(node) => node.format().fmt(f),
+            AnyCssDeclarationOrAtRule::ScssNestingDeclaration(node) => node.format().fmt(f),
         }
     }
 }

crates/biome_css_formatter/src/css/any/declaration_or_rule.rs

@@ -14,6 +14,7 @@ impl FormatRule<AnyCssDeclarationOrRule> for FormatAnyCssDeclarationOrRule {
             AnyCssDeclarationOrRule::CssEmptyDeclaration(node) => node.format().fmt(f),
             AnyCssDeclarationOrRule::CssMetavariable(node) => node.format().fmt(f),
             AnyCssDeclarationOrRule::ScssDeclaration(node) => node.format().fmt(f),
+            AnyCssDeclarationOrRule::ScssNestingDeclaration(node) => node.format().fmt(f),
         }
     }
 }

crates/biome_css_formatter/src/css/any/expression.rs

@@ -12,6 +12,7 @@ impl FormatRule<AnyCssExpression> for FormatAnyCssExpression {
             AnyCssExpression::CssCommaSeparatedValue(node) => node.format().fmt(f),
             AnyCssExpression::CssListOfComponentValuesExpression(node) => node.format().fmt(f),
             AnyCssExpression::CssParenthesizedExpression(node) => node.format().fmt(f),
+            AnyCssExpression::CssUnaryExpression(node) => node.format().fmt(f),
         }
     }
 }

crates/biome_css_formatter/src/css/any/function_name.rs

@@ -0,0 +1,15 @@
+//! This is a generated file. Don't modify it by hand! Run 'cargo codegen formatter' to re-generate the file.
+
+use crate::prelude::*;
+use biome_css_syntax::AnyCssFunctionName;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatAnyCssFunctionName;
+impl FormatRule<AnyCssFunctionName> for FormatAnyCssFunctionName {
+    type Context = CssFormatContext;
+    fn fmt(&self, node: &AnyCssFunctionName, f: &mut CssFormatter) -> FormatResult<()> {
+        match node {
+            AnyCssFunctionName::CssIdentifier(node) => node.format().fmt(f),
+            AnyCssFunctionName::ScssQualifiedName(node) => node.format().fmt(f),
+        }
+    }
+}

crates/biome_css_formatter/src/css/any/mod.rs

@@ -6,6 +6,7 @@ pub(crate) mod attr_name;
 pub(crate) mod attr_type;
 pub(crate) mod attr_unit;
 pub(crate) mod attribute_matcher_value;
+pub(crate) mod bracketed_value_item;
 pub(crate) mod composes_import_source;
 pub(crate) mod compound_selector;
 pub(crate) mod conditional_block;
@@ -32,6 +33,7 @@ pub(crate) mod font_family_name;
 pub(crate) mod font_feature_values_block;
 pub(crate) mod font_feature_values_item;
 pub(crate) mod function;
+pub(crate) mod function_name;
 pub(crate) mod function_parameter;
 pub(crate) mod generic_component_value;
 pub(crate) mod if_branch;

crates/biome_css_formatter/src/css/any/page_at_rule_item.rs

@@ -13,6 +13,8 @@ impl FormatRule<AnyCssPageAtRuleItem> for FormatAnyCssPageAtRuleItem {
             AnyCssPageAtRuleItem::CssDeclarationWithSemicolon(node) => node.format().fmt(f),
             AnyCssPageAtRuleItem::CssEmptyDeclaration(node) => node.format().fmt(f),
             AnyCssPageAtRuleItem::CssMarginAtRule(node) => node.format().fmt(f),
+            AnyCssPageAtRuleItem::ScssDeclaration(node) => node.format().fmt(f),
+            AnyCssPageAtRuleItem::ScssNestingDeclaration(node) => node.format().fmt(f),
         }
     }
 }

crates/biome_css_formatter/src/css/any/value.rs

@@ -21,6 +21,7 @@ impl FormatRule<AnyCssValue> for FormatAnyCssValue {
             AnyCssValue::CssString(node) => node.format().fmt(f),
             AnyCssValue::CssUnicodeRange(node) => node.format().fmt(f),
             AnyCssValue::ScssIdentifier(node) => node.format().fmt(f),
+            AnyCssValue::ScssQualifiedName(node) => node.format().fmt(f),
             AnyCssValue::TwValueThemeReference(node) => node.format().fmt(f),
         }
     }

crates/biome_css_formatter/src/css/auxiliary/mod.rs

@@ -116,6 +116,7 @@ pub(crate) mod syntax_component_without_multiplier;
 pub(crate) mod syntax_multiplier;
 pub(crate) mod syntax_type;
 pub(crate) mod type_function;
+pub(crate) mod unary_expression;
 pub(crate) mod unicode_codepoint;
 pub(crate) mod unicode_range;
 pub(crate) mod unicode_range_interval;

crates/biome_css_formatter/src/css/auxiliary/unary_expression.rs

@@ -0,0 +1,18 @@
+use crate::prelude::*;
+use biome_css_syntax::{CssUnaryExpression, CssUnaryExpressionFields};
+use biome_formatter::write;
+
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatCssUnaryExpression;
+impl FormatNodeRule<CssUnaryExpression> for FormatCssUnaryExpression {
+    fn fmt_fields(&self, node: &CssUnaryExpression, f: &mut CssFormatter) -> FormatResult<()> {
+        let CssUnaryExpressionFields {
+            operator,
+            expression,
+        } = node.as_fields();
+        let operator = operator?;
+        let expression = expression?;
+
+        write!(f, [operator.format(), expression.format()])
+    }
+}

crates/biome_css_formatter/src/css/lists/bracketed_value_list.rs

@@ -1,12 +1,11 @@
 use crate::prelude::*;
+use crate::utils::component_value_list::write_component_value_list;
 use biome_css_syntax::CssBracketedValueList;
 #[derive(Debug, Clone, Default)]
 pub(crate) struct FormatCssBracketedValueList;
 impl FormatRule<CssBracketedValueList> for FormatCssBracketedValueList {
     type Context = CssFormatContext;
     fn fmt(&self, node: &CssBracketedValueList, f: &mut CssFormatter) -> FormatResult<()> {
-        f.join_with(&space())
-            .entries(node.iter().formatted())
-            .finish()
+        write_component_value_list(node, f)
     }
 }