refactor(formatter): change mutable reference to immutable reference and remove global !clippy::needless_pass_by_ref_mut (#15940)

Author: Dunqing

crates/oxc_formatter/src/formatter/builders.rs

@@ -2365,7 +2365,7 @@ where
     }
 
     /// Finishes the output and returns any error encountered.
-    pub fn finish(&mut self) -> FormatResult<()> {
+    pub fn finish(&self) -> FormatResult<()> {
         self.result
     }
 }
@@ -2444,7 +2444,7 @@ where
         self
     }
 
-    pub fn finish(&mut self) -> FormatResult<()> {
+    pub fn finish(&self) -> FormatResult<()> {
         self.result
     }
 

crates/oxc_formatter/src/formatter/format_element/document.rs

@@ -34,7 +34,7 @@ impl Document<'_> {
     /// [`BestFitting`]'s content expands is not propagated past the [`BestFitting`] element.
     ///
     /// [`BestFitting`]: FormatElement::BestFitting
-    pub(crate) fn propagate_expand(&mut self) {
+    pub(crate) fn propagate_expand(&self) {
         #[derive(Debug)]
         enum Enclosing<'a> {
             Group(&'a tag::Group),

crates/oxc_formatter/src/formatter/format_extensions.rs

@@ -134,7 +134,7 @@ where
     /// # }
     ///
     /// ```
-    pub fn inspect(&mut self, f: &mut Formatter<'_, 'ast>) -> FormatResult<&[FormatElement<'ast>]> {
+    pub fn inspect(&self, f: &mut Formatter<'_, 'ast>) -> FormatResult<&[FormatElement<'ast>]> {
         let result = self.memory.get_or_init(|| f.intern(&self.inner));
 
         match result.as_ref() {

crates/oxc_formatter/src/formatter/formatter.rs

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

crates/oxc_formatter/src/lib.rs

@@ -1,9 +1,4 @@
-#![allow(
-    unused,
-    clippy::inline_always,
-    clippy::missing_panics_doc,
-    clippy::needless_pass_by_ref_mut
-)] // FIXME: all these needs to be fixed.
+#![allow(unused, clippy::inline_always, clippy::missing_panics_doc)] // FIXME: all these needs to be fixed.
 
 mod ast_nodes;
 #[cfg(feature = "detect_code_removal")]

crates/oxc_formatter/src/utils/assignment_like.rs

@@ -366,7 +366,7 @@ impl<'a> AssignmentLike<'a, '_> {
         &self,
         is_left_short: bool,
         left_may_break: bool,
-        f: &mut Formatter<'_, 'a>,
+        f: &Formatter<'_, 'a>,
     ) -> AssignmentLikeLayout {
         if self.has_only_left_hand_side() {
             return AssignmentLikeLayout::OnlyLeft;

crates/oxc_formatter/src/utils/conditional.rs

@@ -167,7 +167,7 @@ fn format_trailing_comments<'a>(
 
 impl<'a> FormatConditionalLike<'a, '_> {
     /// Determines the layout of this conditional based on its parent
-    fn layout(&self, f: &mut Formatter<'_, 'a>) -> ConditionalLayout {
+    fn layout(&self, f: &Formatter<'_, 'a>) -> ConditionalLayout {
         let self_span = self.span();
 
         match self.parent() {

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

@@ -100,7 +100,7 @@ impl<'a, 'b> TailChainGroups<'a, 'b> {
     }
 
     /// Test if any group except the last group [break](FormatElements::will_break).
-    pub(super) fn any_except_last_will_break(&self, f: &mut Formatter<'_, 'a>) -> bool {
+    pub(super) fn any_except_last_will_break(&self, f: &Formatter<'_, 'a>) -> bool {
         for group in &self.groups[..self.groups.len().saturating_sub(1)] {
             if group.will_break(f) {
                 return true;
@@ -170,7 +170,7 @@ impl<'a, 'b> MemberChainGroup<'a, 'b> {
     }
 
     /// Tests if the formatted result of this group results in a [break](FormatElements::will_break).
-    pub(super) fn will_break(&self, f: &mut Formatter<'_, 'a>) -> bool {
+    pub(super) fn will_break(&self, f: &Formatter<'_, 'a>) -> bool {
         let mut cell = self.formatted.borrow_mut();
         if let Some(formatted) = cell.as_ref() {
             formatted.will_break()

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

@@ -122,7 +122,7 @@ impl<'a, 'b> MemberChain<'a, 'b> {
     }
 
     /// It tells if the groups should break on multiple lines
-    fn groups_should_break(&self, f: &mut Formatter<'_, 'a>) -> bool {
+    fn groups_should_break(&self, f: &Formatter<'_, 'a>) -> bool {
         let mut call_expressions = self
             .members()
             .filter_map(|member| match member {
@@ -163,7 +163,7 @@ impl<'a, 'b> MemberChain<'a, 'b> {
 
     /// We retrieve all the call expressions inside the group and we check if
     /// their arguments are not simple.
-    fn last_call_breaks(&self, f: &mut Formatter<'_, 'a>) -> bool {
+    fn last_call_breaks(&self, f: &Formatter<'_, 'a>) -> bool {
         let last_group = self.last_group();
 
         if matches!(last_group.members().last(), Some(ChainMember::CallExpression { .. })) {

crates/oxc_formatter/src/utils/string.rs

@@ -195,7 +195,7 @@ impl<'a> LiteralStringNormalizer<'a> {
         Self { token, chosen_quote_style, chosen_quote_properties }
     }
 
-    fn normalize_text(&mut self, source_type: SourceType) -> Cow<'a, str> {
+    fn normalize_text(&self, source_type: SourceType) -> Cow<'a, str> {
         let str_info = self.token.compute_string_information(self.chosen_quote_style);
         match self.token.parent_kind {
             StringLiteralParentKind::Expression => self.normalize_string_literal(str_info),
@@ -205,10 +205,7 @@ impl<'a> LiteralStringNormalizer<'a> {
         }
     }
 
-    fn normalize_import_attribute(
-        &mut self,
-        string_information: StringInformation,
-    ) -> Cow<'a, str> {
+    fn normalize_import_attribute(&self, string_information: StringInformation) -> Cow<'a, str> {
         let quoteless = self.raw_content();
         let can_remove_quotes =
             !self.is_preserve_quote_properties() && is_identifier_name(quoteless);
@@ -219,7 +216,7 @@ impl<'a> LiteralStringNormalizer<'a> {
         }
     }
 
-    fn normalize_directive(&mut self, string_information: StringInformation) -> Cow<'a, str> {
+    fn normalize_directive(&self, string_information: StringInformation) -> Cow<'a, str> {
         // In diretcives, unnecessary escapes should be preserved.
         // See https://github.com/prettier/prettier/issues/1555
         // Thus we don't normalize the string.
@@ -261,7 +258,7 @@ impl<'a> LiteralStringNormalizer<'a> {
     }
 
     fn normalize_type_member(
-        &mut self,
+        &self,
         string_information: StringInformation,
         source_type: SourceType,
     ) -> Cow<'a, str> {