refactor(formatter): remove global !clippy::unused_self (#15939)

Author: Dunqing

crates/oxc_formatter/src/formatter/formatter.rs

@@ -241,6 +241,7 @@ impl<'buf, 'ast> Formatter<'buf, 'ast> {
         Ok(self.intern_vec(elements))
     }
 
+    #[expect(clippy::unused_self)] // Keep `self` the same as the original source
     pub fn intern_vec(
         &mut self,
         mut elements: ArenaVec<'ast, FormatElement<'ast>>,

crates/oxc_formatter/src/formatter/token/number.rs

@@ -17,7 +17,7 @@ pub struct NumberFormatOptions {
 }
 
 impl NumberFormatOptions {
-    pub fn keep_one_trailing_decimal_zero(self) -> Self {
+    pub fn keep_one_trailing_decimal_zero() -> Self {
         Self { keep_one_trailing_decimal_zero: true }
     }
 }

crates/oxc_formatter/src/lib.rs

@@ -2,8 +2,7 @@
     unused,
     clippy::inline_always,
     clippy::missing_panics_doc,
-    clippy::needless_pass_by_ref_mut,
-    clippy::unused_self
+    clippy::needless_pass_by_ref_mut
 )] // FIXME: all these needs to be fixed.
 
 mod ast_nodes;

crates/oxc_formatter/src/utils/conditional.rs

@@ -355,7 +355,7 @@ impl<'a> FormatConditionalLike<'a, '_> {
 
     /// Checks if any part of the conditional has multiline comments
     #[inline]
-    fn has_multiline_comment(&self, _f: &Formatter<'_, 'a>) -> bool {
+    fn has_multiline_comment(_f: &Formatter<'_, 'a>) -> bool {
         // TODO: Implement multiline comment detection
         false
     }
@@ -518,7 +518,7 @@ impl<'a> Format<'a> for FormatConditionalLike<'a, '_> {
     fn fmt(&self, f: &mut Formatter<'_, 'a>) -> FormatResult<()> {
         let layout = self.layout(f);
         let should_extra_indent = self.should_extra_indent(layout);
-        let has_multiline_comment = self.has_multiline_comment(f);
+        let has_multiline_comment = Self::has_multiline_comment(f);
         let is_jsx_chain = self.options.jsx_chain || layout.is_jsx_chain();
 
         let format_inner = format_with(|f| {

crates/oxc_formatter/src/utils/member_chain/simple_argument.rs

@@ -77,8 +77,8 @@ impl<'a, 'b> SimpleArgument<'a, 'b> {
                 Expression::TaggedTemplateExpression(template) => {
                     is_simple_template_literal(&template.quasi, depth + 1)
                 }
-                Expression::ObjectExpression(object) => self.is_simple_object(object, depth),
-                Expression::ArrayExpression(array) => self.is_simple_array(array, depth),
+                Expression::ObjectExpression(object) => Self::is_simple_object(object, depth),
+                Expression::ArrayExpression(array) => Self::is_simple_array(array, depth),
                 Expression::UnaryExpression(unary_expression) => {
                     matches!(
                         unary_expression.operator,
@@ -102,14 +102,14 @@ impl<'a, 'b> SimpleArgument<'a, 'b> {
                         && Self::from(&computed_expression.object).is_simple_impl(depth)
                 }
                 Expression::NewExpression(expr) => {
-                    self.is_simple_call_like(&expr.callee, &expr.arguments, depth)
+                    Self::is_simple_call_like(&expr.callee, &expr.arguments, depth)
                 }
                 Expression::CallExpression(expr) => {
-                    self.is_simple_call_like(&expr.callee, &expr.arguments, depth)
+                    Self::is_simple_call_like(&expr.callee, &expr.arguments, depth)
                 }
                 Expression::ImportExpression(expr) => depth < 2 && expr.options.is_none(),
                 Expression::ChainExpression(chain) => {
-                    self.is_simple_chain_element(&chain.expression, depth)
+                    Self::is_simple_chain_element(&chain.expression, depth)
                 }
                 _ => false,
             },
@@ -119,7 +119,7 @@ impl<'a, 'b> SimpleArgument<'a, 'b> {
     }
 
     #[inline]
-    fn is_simple_object(&self, object: &'b ObjectExpression<'a>, depth: u8) -> bool {
+    fn is_simple_object(object: &'b ObjectExpression<'a>, depth: u8) -> bool {
         object.properties.iter().all(|member| {
             if let ObjectPropertyKind::ObjectProperty(property) = member {
                 if property.method {
@@ -138,7 +138,7 @@ impl<'a, 'b> SimpleArgument<'a, 'b> {
     }
 
     #[inline]
-    fn is_simple_array(&self, array: &'b ArrayExpression<'a>, depth: u8) -> bool {
+    fn is_simple_array(array: &'b ArrayExpression<'a>, depth: u8) -> bool {
         array.elements.iter().all(|element| match element {
             match_expression!(ArrayExpressionElement) => {
                 Self::from(element.to_expression()).is_simple_impl(depth + 1)
@@ -150,7 +150,6 @@ impl<'a, 'b> SimpleArgument<'a, 'b> {
 
     #[inline]
     fn is_simple_call_like(
-        &self,
         callee: &'b Expression<'a>,
         arguments: &'b [Argument<'a>],
         depth: u8,
@@ -161,10 +160,10 @@ impl<'a, 'b> SimpleArgument<'a, 'b> {
     }
 
     #[inline]
-    fn is_simple_chain_element(&self, element: &'b ChainElement<'a>, depth: u8) -> bool {
+    fn is_simple_chain_element(element: &'b ChainElement<'a>, depth: u8) -> bool {
         match element {
             ChainElement::CallExpression(call) => {
-                self.is_simple_call_like(&call.callee, &call.arguments, depth)
+                Self::is_simple_call_like(&call.callee, &call.arguments, depth)
             }
             ChainElement::TSNonNullExpression(assertion) => {
                 Self::from(&assertion.expression).is_simple_impl(depth)

crates/oxc_formatter/src/write/jsx/child_list.rs

@@ -38,7 +38,7 @@ impl FormatJsxChildList {
         f: &mut Formatter<'_, 'a>,
     ) -> FormatResult<FormatChildrenResult<'a>> {
         // Use Biome's exact approach - no need for jsx_split_children at this stage
-        let children_meta = self.children_meta(children, f.context().comments());
+        let children_meta = Self::children_meta(children, f.context().comments());
         let layout = self.layout(children_meta);
 
         let multiline_layout = if children_meta.meaningful_text {
@@ -349,7 +349,6 @@ impl FormatJsxChildList {
     }
 
     fn children_meta(
-        &self,
         children: &AstNode<'_, ArenaVec<'_, JSXChild<'_>>>,
         comments: &Comments<'_>,
     ) -> ChildrenMeta {
@@ -392,23 +391,6 @@ impl FormatJsxChildList {
             JsxChildListLayout::Multiline => JsxChildListLayout::Multiline,
         }
     }
-
-    /// Determine if we should use Biome's Fill layout pattern
-    fn should_use_fill_layout(&self, jsx_children: &[JsxChild<'_, '_>]) -> bool {
-        let mut has_text = false;
-        let mut has_elements = false;
-
-        for child in jsx_children {
-            match child {
-                JsxChild::Word(_) => has_text = true,
-                JsxChild::NonText(_) => has_elements = true,
-                _ => {}
-            }
-        }
-
-        // Fill layout is needed for mixed text and elements
-        has_text && has_elements && jsx_children.len() > 2
-    }
 }
 
 /// The result of formatting the children of a JSX child list.

crates/oxc_formatter/src/write/mod.rs

@@ -1053,7 +1053,7 @@ impl<'a> FormatWrite<'a> for AstNode<'a, NumericLiteral<'a>> {
         format_number_token(
             f.source_text().text_for(self),
             self.span(),
-            NumberFormatOptions::default().keep_one_trailing_decimal_zero(),
+            NumberFormatOptions::keep_one_trailing_decimal_zero(),
         )
         .fmt(f)
     }