refactor(formatter): remove all unused code (#15941)

This PR aims to remove the global `#![allow(unused)]`.

There are a few main things that were done:
1. Removed all unused imports
2. Renamed the unused variable to add a `_` prefix
3. Removed unused statements
4. Marked `#[expect(unused)]` for some structs that are not sure if they would be used in the future

Author: Dunqing

crates/oxc_formatter/src/ast_nodes/generated/ast_nodes.rs

@@ -1,25 +1,21 @@
 // Auto-generated code, DO NOT EDIT DIRECTLY!
 // To edit this generated file you have to edit `tasks/ast_tools/src/generators/formatter/ast_nodes.rs`.
 
-use std::{fmt, mem::transmute, ops::Deref};
+use std::mem::transmute;
 
-use oxc_allocator::{Allocator, Box, Vec};
+use oxc_allocator::Vec;
 use oxc_ast::ast::*;
-use oxc_span::{GetSpan, SPAN};
+use oxc_span::GetSpan;
 
 use crate::ast_nodes::AstNode;
-use crate::{
-    formatter::{
-        Buffer, Format, FormatResult, Formatter,
-        trivia::{format_leading_comments, format_trailing_comments},
-    },
-    parentheses::NeedsParentheses,
-    write::FormatWrite,
+use crate::formatter::{
+    Format, FormatResult, Formatter,
+    trivia::{format_leading_comments, format_trailing_comments},
 };
 
 #[inline]
 pub(super) fn transmute_self<'a, T>(s: &AstNode<'a, T>) -> &'a AstNode<'a, T> {
-    /// * SAFETY: `s` is already allocated in Arena, so transmute from `&` to `&'a` is safe.
+    #[expect(clippy::undocumented_unsafe_blocks)]
     unsafe {
         transmute(s)
     }
@@ -2166,7 +2162,8 @@ impl<'a> AstNode<'a, AssignmentTarget<'a>> {
     #[inline]
     pub fn as_ast_nodes(&self) -> &AstNodes<'a> {
         let parent = self.parent;
-        let node = match self.inner {
+        #[expect(clippy::needless_return)]
+        match self.inner {
             it @ match_simple_assignment_target!(AssignmentTarget) => {
                 return self
                     .allocator
@@ -2189,8 +2186,7 @@ impl<'a> AstNode<'a, AssignmentTarget<'a>> {
                     })
                     .as_ast_nodes();
             }
-        };
-        self.allocator.alloc(node)
+        }
     }
 }
 

crates/oxc_formatter/src/ast_nodes/generated/format.rs

@@ -5,10 +5,9 @@
 use oxc_ast::ast::*;
 use oxc_span::GetSpan;
 
-use super::ast_nodes::transmute_self;
 use crate::{
-    ast_nodes::{AstNode, AstNodes},
-    formatter::{Buffer, Format, FormatResult, Formatter, trivia::FormatTrailingComments},
+    ast_nodes::AstNode,
+    formatter::{Format, FormatResult, Formatter},
     parentheses::NeedsParentheses,
     utils::{suppressed::FormatSuppressedNode, typecast::format_type_cast_comment_node},
     write::{FormatFunctionOptions, FormatJsArrowFunctionExpressionOptions, FormatWrite},

crates/oxc_formatter/src/ast_nodes/node.rs

@@ -176,7 +176,7 @@ impl<'a> AstNode<'a, ImportExpression<'a>> {
             inner: arguments_ref,
             allocator: self.allocator,
             parent: self.allocator.alloc(AstNodes::ImportExpression({
-                /// * SAFETY: `self` is already allocated in Arena, so transmute from `&` to `&'a` is safe.
+                // SAFETY: `self` is already allocated in Arena, so transmute from `&` to `&'a` is safe.
                 unsafe {
                     transmute::<
                         &AstNode<'_, ImportExpression<'_>>,

crates/oxc_formatter/src/detect_code_removal/mod.rs

@@ -2,7 +2,7 @@ use rustc_hash::{FxHashMap, FxHashSet};
 
 use oxc_allocator::Allocator;
 use oxc_ast::{AstKind, ast};
-use oxc_parser::{ParseOptions, Parser, ParserReturn};
+use oxc_parser::{Parser, ParserReturn};
 use oxc_semantic::{AstNode, Semantic, SemanticBuilder};
 use oxc_span::SourceType;
 

crates/oxc_formatter/src/formatter/buffer.rs

@@ -331,11 +331,13 @@ pub struct PreambleBuffer<'a, 'buf, Preamble> {
 }
 
 impl<'ast, 'buf, Preamble> PreambleBuffer<'ast, 'buf, Preamble> {
+    #[expect(unused)]
     pub fn new(inner: &'buf mut dyn Buffer<'ast>, preamble: Preamble) -> Self {
         Self { inner, preamble, empty: true }
     }
 
     /// Returns `true` if the preamble has been written, `false` otherwise.
+    #[expect(unused)]
     pub fn did_write_preamble(&self) -> bool {
         !self.empty
     }
@@ -531,8 +533,7 @@ fn clean_interned<'ast>(
             FormatElement::Line(LineMode::Soft | LineMode::SoftOrSpace)
             | FormatElement::Tag(Tag::StartConditionalContent(_) | Tag::EndConditionalContent)
             | FormatElement::BestFitting(_) => {
-                let mut cleaned =
-                    ArenaVec::from_iter_in(interned[..index].iter().cloned(), allocator);
+                let cleaned = ArenaVec::from_iter_in(interned[..index].iter().cloned(), allocator);
                 Some((cleaned, &interned[index..]))
             }
             FormatElement::Interned(inner) => {
@@ -667,6 +668,7 @@ impl<'ast> Buffer<'ast> for RemoveSoftLinesBuffer<'_, 'ast> {
 pub trait BufferExtensions<'ast>: Buffer<'ast> + Sized {
     /// Returns a new buffer that calls the passed inspector for every element that gets written to the output
     #[must_use]
+    #[expect(unused)]
     fn inspect<'inner, F>(&'inner mut self, inspector: F) -> Inspect<'ast, 'inner, F>
     where
         F: FnMut(&FormatElement),
@@ -751,6 +753,7 @@ where
     }
 
     #[inline(always)]
+    #[expect(unused)]
     pub fn write_element(&mut self, element: FormatElement<'ast>) -> FormatResult<()> {
         self.buffer.write_element(element)
     }

crates/oxc_formatter/src/formatter/builders.rs

@@ -1,4 +1,4 @@
-use std::{backtrace, cell::Cell, num::NonZeroU8};
+use std::{cell::Cell, num::NonZeroU8};
 
 use Tag::{
     EndAlign, EndConditionalContent, EndDedent, EndEntry, EndFill, EndGroup, EndIndent,
@@ -8,10 +8,9 @@ use Tag::{
 };
 use oxc_allocator::Vec as ArenaVec;
 use oxc_span::{GetSpan, Span};
-use oxc_syntax::identifier::{is_identifier_name, is_line_terminator, is_white_space_single_line};
 
 use super::{
-    Argument, Arguments, Buffer, Comments, GroupId, TextSize, VecBuffer,
+    Argument, Arguments, Buffer, GroupId, VecBuffer,
     format_element::{
         self, TextWidth,
         tag::{Condition, Tag},
@@ -336,6 +335,7 @@ impl std::fmt::Debug for Text<'_> {
 }
 
 #[track_caller]
+#[expect(unused)]
 fn debug_assert_no_newlines(text: &str) {
     debug_assert!(
         !text.contains('\r'),

crates/oxc_formatter/src/formatter/comments.rs

@@ -97,19 +97,10 @@
 //! ## References
 //! - [Prettier handles special comments](https://github.com/prettier/prettier/blob/7584432401a47a26943dd7a9ca9a8e032ead7285/src/language-js/comments/handle-comments.js)
 //! - [Prettier pre-processes comments](https://github.com/prettier/prettier/blob/7584432401a47a26943dd7a9ca9a8e032ead7285/src/main/comments/attach.js)
-use std::ops::{ControlFlow, Deref};
-
-use oxc_allocator::Vec;
-use oxc_ast::{
-    Comment, CommentContent, CommentKind,
-    ast::{self, CallExpression, NewExpression},
-};
+use oxc_ast::{Comment, CommentContent};
 use oxc_span::{GetSpan, Span};
 
-use crate::{
-    Format, FormatResult,
-    formatter::{Formatter, SourceText},
-};
+use crate::formatter::SourceText;
 
 #[derive(Debug, Clone)]
 pub struct Comments<'a> {
@@ -292,7 +283,7 @@ impl<'a> Comments<'a> {
         &self,
         enclosing_span: Span,
         preceding_span: Span,
-        mut following_span: Option<Span>,
+        following_span: Option<Span>,
     ) -> &'a [Comment] {
         let comments = self.unprinted_comments();
         if comments.is_empty() {

crates/oxc_formatter/src/formatter/context.rs

@@ -1,16 +1,10 @@
-use std::cell::RefCell;
-
 use oxc_allocator::Allocator;
-use oxc_ast::{
-    Comment,
-    ast::{FunctionBody, Program},
-};
+use oxc_ast::Comment;
 use oxc_span::{GetSpan, SourceType, Span};
 use rustc_hash::FxHashMap;
 
 use crate::{
-    ast_nodes::AstNode, embedded_formatter::EmbeddedFormatter, formatter::FormatElement,
-    options::FormatOptions,
+    embedded_formatter::EmbeddedFormatter, formatter::FormatElement, options::FormatOptions,
 };
 
 use super::{Comments, SourceText};

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

@@ -3,18 +3,12 @@ use cow_utils::CowUtils;
 use std::ops::Deref;
 
 use oxc_allocator::{Allocator, Vec as ArenaVec};
-use oxc_ast::Comment;
-use oxc_span::SourceType;
 use rustc_hash::FxHashMap;
 
 use super::super::prelude::*;
 use super::tag::Tag;
-use crate::formatter::TextSize;
 use crate::formatter::prelude::tag::{DedentMode, GroupMode};
-use crate::{
-    Format, FormatOptions, FormatResult, IndentStyle, IndentWidth, LineEnding, LineWidth,
-    formatter::FormatContext, formatter::Formatter,
-};
+use crate::{Format, FormatResult, formatter::FormatContext, formatter::Formatter};
 
 use crate::{format, write};
 
@@ -119,7 +113,7 @@ impl Document<'_> {
                         false
                     }
                     // `FormatElement::Token` cannot contain line breaks
-                    FormatElement::Text { text, width } => width.is_multiline(),
+                    FormatElement::Text { text: _, width } => width.is_multiline(),
                     FormatElement::ExpandParent
                     | FormatElement::Line(LineMode::Hard | LineMode::Empty) => true,
                     _ => false,
@@ -210,7 +204,7 @@ impl<'a> Format<'a> for &[FormatElement<'a>] {
                             let new_element = match element {
                                 // except for static text because source_position is unknown
                                 FormatElement::Token { .. } => element.clone(),
-                                FormatElement::Text { text, width } => {
+                                FormatElement::Text { text, width: _ } => {
                                     let text = text.cow_replace('"', "\\\"");
                                     FormatElement::Text {
                                         text: f.context().allocator().alloc_str(&text),
@@ -277,7 +271,7 @@ impl<'a> Format<'a> for &[FormatElement<'a>] {
                 }
 
                 FormatElement::Interned(interned) => {
-                    let mut interned_elements = f.state_mut().printed_interned_elements();
+                    let interned_elements = f.state_mut().printed_interned_elements();
                     match interned_elements.get(interned).copied() {
                         None => {
                             let index = interned_elements.len();

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

@@ -5,16 +5,16 @@ pub mod tag;
 // use biome_rowan::static_assert;
 use std::hash::{Hash, Hasher};
 use std::ptr;
-use std::{borrow::Cow, ops::Deref, rc::Rc};
+use std::{borrow::Cow, ops::Deref};
 
 use unicode_width::{UnicodeWidthChar, UnicodeWidthStr};
 
-use oxc_allocator::{Address, Box as ArenaBox, Vec as ArenaVec};
+use oxc_allocator::Vec as ArenaVec;
 
-use crate::{IndentWidth, TabWidth};
+use crate::IndentWidth;
 
 use super::{
-    TagKind, TextSize,
+    TagKind,
     format_element::tag::{LabelId, Tag},
 };
 
@@ -185,11 +185,15 @@ impl<'a> Deref for Interned<'a> {
 }
 
 const LINE_SEPARATOR: char = '\u{2028}';
+
 const PARAGRAPH_SEPARATOR: char = '\u{2029}';
+
+#[expect(unused)]
 pub const LINE_TERMINATORS: [char; 3] = ['\r', LINE_SEPARATOR, PARAGRAPH_SEPARATOR];
 
 /// Replace the line terminators matching the provided list with "\n"
 /// since its the only line break type supported by the printer
+#[expect(unused)]
 pub fn normalize_newlines<const N: usize>(text: &str, terminators: [char; N]) -> Cow<'_, str> {
     let mut result = String::new();
     let mut last_end = 0;
@@ -257,7 +261,7 @@ impl FormatElements for FormatElement<'_> {
             FormatElement::ExpandParent => true,
             FormatElement::Tag(Tag::StartGroup(group)) => !group.mode().is_flat(),
             FormatElement::Line(line_mode) => line_mode.will_break(),
-            FormatElement::Text { text, width } => width.is_multiline(),
+            FormatElement::Text { text: _, width } => width.is_multiline(),
             FormatElement::Interned(interned) => interned.will_break(),
             // Traverse into the most flat version because the content is guaranteed to expand when even
             // the most flat version contains some content that forces a break.
@@ -376,10 +380,12 @@ pub trait FormatElements {
     /// Returns the start tag of `kind` if:
     /// * the last element is an end tag of `kind`.
     /// * there's a matching start tag in this document (may not be true if this slice is an interned element and the `start` is in the document storing the interned element).
+    #[expect(unused)]
     fn start_tag(&self, kind: TagKind) -> Option<&Tag>;
 
     /// Returns the end tag if:
     /// * the last element is an end tag of `kind`
+    #[expect(unused)]
     fn end_tag(&self, kind: TagKind) -> Option<&Tag>;
 }