refactor(formatter): remove global !clippy::enum_variant_names and !clippy::struct_field_names (#15938)

Author: Dunqing

crates/oxc_formatter/src/formatter/builders.rs

@@ -1669,6 +1669,7 @@ pub fn group<'ast>(content: &impl Format<'ast>) -> Group<'_, 'ast> {
 #[derive(Copy, Clone)]
 pub struct Group<'fmt, 'ast> {
     content: Argument<'fmt, 'ast>,
+    #[expect(clippy::struct_field_names)] // Keep the name the same as it is in the original source
     group_id: Option<GroupId>,
     should_expand: bool,
 }

crates/oxc_formatter/src/formatter/comments.rs

@@ -114,7 +114,7 @@ use crate::{
 #[derive(Debug, Clone)]
 pub struct Comments<'a> {
     source_text: SourceText<'a>,
-    comments: &'a [Comment],
+    inner: &'a [Comment],
     /// **Critical state field**: Tracks how many comments have been processed.
     ///
     /// This acts as a cursor dividing the comments array into two sections:
@@ -139,7 +139,7 @@ impl<'a> Comments<'a> {
     pub fn new(source_text: SourceText<'a>, comments: &'a [Comment]) -> Self {
         Comments {
             source_text,
-            comments,
+            inner: comments,
             printed_count: 0,
             last_handled_type_cast_comment: 0,
             type_cast_node_span: Span::default(),
@@ -150,14 +150,14 @@ impl<'a> Comments<'a> {
     /// Returns comments that have not been printed yet.
     #[inline]
     pub fn unprinted_comments(&self) -> &'a [Comment] {
-        let end = self.view_limit.unwrap_or(self.comments.len());
-        &self.comments[self.printed_count..end]
+        let end = self.view_limit.unwrap_or(self.inner.len());
+        &self.inner[self.printed_count..end]
     }
 
     /// Returns comments that have already been printed.
     #[inline]
     pub fn printed_comments(&self) -> &'a [Comment] {
-        &self.comments[..self.printed_count]
+        &self.inner[..self.printed_count]
     }
 
     /// Returns an iterator over comments that end before or at the given position.
@@ -458,13 +458,13 @@ impl<'a> Comments<'a> {
 
         // Find the index of the first comment that starts at or after end_pos
         // Using binary search would be more efficient for large comment arrays
-        let limit_index = self.comments[self.printed_count..]
+        let limit_index = self.inner[self.printed_count..]
             .iter()
             .position(|c| c.span.start >= end_pos)
-            .map_or(self.comments.len(), |idx| self.printed_count + idx);
+            .map_or(self.inner.len(), |idx| self.printed_count + idx);
 
         // Only update if we're actually limiting the view
-        if limit_index < self.comments.len() {
+        if limit_index < self.inner.len() {
             self.view_limit = Some(limit_index);
         }
 

crates/oxc_formatter/src/lib.rs

@@ -3,9 +3,7 @@
     clippy::inline_always,
     clippy::missing_panics_doc,
     clippy::needless_pass_by_ref_mut,
-    clippy::unused_self,
-    clippy::enum_variant_names,
-    clippy::struct_field_names
+    clippy::unused_self
 )] // FIXME: all these needs to be fixed.
 
 mod ast_nodes;

crates/oxc_formatter/src/options.rs

@@ -326,6 +326,7 @@ impl fmt::Debug for LineWidth {
 }
 
 /// Error type returned when parsing a [LineWidth] or [IndentWidth] from a string fails
+#[expect(clippy::enum_variant_names)]
 pub enum ParseFormatNumberError {
     /// The string could not be parsed to a number
     ParseError(ParseIntError),

crates/oxc_formatter/src/write/parameters.rs

@@ -138,15 +138,15 @@ impl<'a> FormatWrite<'a> for AstNode<'a, TSThisParameter<'a>> {
 
 enum Parameter<'a, 'b> {
     This(&'b AstNode<'a, TSThisParameter<'a>>),
-    FormalParameter(&'b AstNode<'a, FormalParameter<'a>>),
+    Formal(&'b AstNode<'a, FormalParameter<'a>>),
     Rest(&'b AstNode<'a, BindingRestElement<'a>>),
 }
 
 impl GetSpan for Parameter<'_, '_> {
     fn span(&self) -> Span {
         match self {
             Self::This(param) => param.span(),
-            Self::FormalParameter(param) => param.span(),
+            Self::Formal(param) => param.span(),
             Self::Rest(e) => e.span(),
         }
     }
@@ -156,7 +156,7 @@ impl<'a> Format<'a> for Parameter<'a, '_> {
     fn fmt(&self, f: &mut Formatter<'_, 'a>) -> FormatResult<()> {
         match self {
             Self::This(param) => param.fmt(f),
-            Self::FormalParameter(param) => param.fmt(f),
+            Self::Formal(param) => param.fmt(f),
             Self::Rest(e) => e.fmt(f),
         }
     }
@@ -181,7 +181,7 @@ impl<'a, 'b> Iterator for FormalParametersIter<'a, 'b> {
         self.this.take().map(Parameter::This).or_else(|| {
             self.params
                 .next()
-                .map(Parameter::FormalParameter)
+                .map(Parameter::Formal)
                 .or_else(|| self.rest.take().map(Parameter::Rest))
         })
     }