fix clippy

Author: ShuiRuTian

crates/oxc_ast/src/ast_builder_impl.rs

@@ -215,12 +215,7 @@ impl<'a> AstBuilder<'a> {
     /// `0`
     #[inline]
     pub fn number_0(self) -> Expression<'a> {
-        self.expression_numeric_literal(
-            Span::default(),
-            0.0,
-            None,
-            NumberBase::Decimal,
-        )
+        self.expression_numeric_literal(Span::default(), 0.0, None, NumberBase::Decimal)
     }
 
     /// `void 0`

crates/oxc_ast/src/ast_impl/literal.rs

@@ -75,17 +75,8 @@ impl NumericLiteral<'_> {
     /// Provide a fallback for converting NumericLiteral's value to a string if `raw` is None
     pub fn raw_str(&self) -> Cow<str> {
         match self.raw.as_ref() {
-            Some(raw) => return Cow::Borrowed(raw),
-            None => {
-                let value = self.value;
-                let s = match self.base {
-                    NumberBase::Binary => format!("{:#b}", value as i64),
-                    NumberBase::Decimal | NumberBase::Float =>  format!("{}", value),
-                    NumberBase::Hex => format!("{:#x}", value as i64),
-                    NumberBase::Octal => format!("{:#o}", value as i64),
-                };
-                Cow::Owned(s)
-            }
+            Some(raw) => Cow::Borrowed(raw),
+            None => Cow::Owned(format!("{}", self.value)),
         }
     }
 }

crates/oxc_ast/src/ast_kind_impl.rs

@@ -236,7 +236,7 @@ impl AstKind<'_> {
             Self::StringLiteral(s) => format!("StringLiteral({})", s.value).into(),
             Self::BooleanLiteral(b) => format!("BooleanLiteral({})", b.value).into(),
             Self::NullLiteral(_) => "NullLiteral".into(),
-            Self::BigIntLiteral(b) => format!("BigIntLiteral({:?})", b.raw).into(),
+            Self::BigIntLiteral(b) => format!("BigIntLiteral({})", b.raw).into(),
             Self::RegExpLiteral(r) => format!("RegExpLiteral({})", r.regex).into(),
             Self::TemplateLiteral(t) => format!(
                 "TemplateLiteral({})",

crates/oxc_ast/src/serialize.rs

@@ -52,7 +52,7 @@ impl<'a> From<&'a NumericLiteral<'a>> for ESTreeLiteral<'a, f64> {
         Self {
             span: value.span,
             value: value.value,
-            raw: value.raw.as_ref().map(|raw| raw.as_str()),
+            raw: value.raw.as_ref().map(oxc_span::Atom::as_str),
             bigint: None,
             regex: None,
         }
@@ -64,7 +64,7 @@ impl<'a> From<&'a StringLiteral<'a>> for ESTreeLiteral<'a, &'a str> {
         Self {
             span: value.span,
             value: &value.value,
-            raw: value.raw.as_ref().map(|raw| raw.as_str()),
+            raw: value.raw.as_ref().map(oxc_span::Atom::as_str),
             bigint: None,
             regex: None,
         }
@@ -73,7 +73,7 @@ impl<'a> From<&'a StringLiteral<'a>> for ESTreeLiteral<'a, &'a str> {
 
 impl<'a> From<&'a BigIntLiteral<'a>> for ESTreeLiteral<'a, ()> {
     fn from(value: &'a BigIntLiteral) -> Self {
-        let src = &value.raw.as_str().strip_suffix('n').unwrap().cow_replace('_', "");
+        let src = &value.raw.strip_suffix('n').unwrap().cow_replace('_', "");
 
         let src = match value.base {
             BigintBase::Decimal => src,
@@ -113,7 +113,7 @@ impl<'a> From<&'a RegExpLiteral<'a>> for ESTreeLiteral<'a, Option<EmptyObject>>
     fn from(value: &'a RegExpLiteral) -> Self {
         Self {
             span: value.span,
-            raw: value.raw.as_ref().map(|raw| raw.as_str()),
+            raw: value.raw.as_ref().map(oxc_span::Atom::as_str),
             value: match &value.regex.pattern {
                 RegExpPattern::Pattern(_) => Some(EmptyObject {}),
                 _ => None,

crates/oxc_ecmascript/src/to_big_int.rs

@@ -68,7 +68,7 @@ impl<'a> ToBigInt<'a> for Expression<'a> {
 impl<'a> ToBigInt<'a> for BigIntLiteral<'a> {
     fn to_big_int(&self) -> Option<BigInt> {
         let value = self.raw.as_str().trim_end_matches('n').string_to_big_int();
-        debug_assert!(value.is_some(), "Failed to parse {:?}", self.raw);
+        debug_assert!(value.is_some(), "Failed to parse {}", self.raw);
         value
     }
 }

crates/oxc_isolated_declarations/src/enum.rs

@@ -1,6 +1,6 @@
 use rustc_hash::FxHashMap;
 
-use oxc_allocator::{CloneIn, IntoIn};
+use oxc_allocator::CloneIn;
 use oxc_ast::ast::*;
 use oxc_ecmascript::ToInt32;
 use oxc_span::{Atom, GetSpan, SPAN};

crates/oxc_linter/src/rules/eslint/func_names.rs

@@ -241,9 +241,7 @@ fn get_property_key_name<'a>(key: &PropertyKey<'a>) -> Option<Cow<'a, str>> {
         PropertyKey::RegExpLiteral(regex) => {
             Some(Cow::Owned(format!("/{}/{}", regex.regex.pattern, regex.regex.flags)))
         }
-        PropertyKey::BigIntLiteral(bigint) => {
-            Some(Cow::Borrowed(bigint.raw.as_str()))
-        }
+        PropertyKey::BigIntLiteral(bigint) => Some(Cow::Borrowed(bigint.raw.as_str())),
         PropertyKey::TemplateLiteral(template) => {
             if template.expressions.len() == 0 && template.quasis.len() == 1 {
                 if let Some(cooked) = &template.quasis[0].value.cooked {

crates/oxc_minifier/src/ast_passes/peephole_replace_known_methods.rs

@@ -124,12 +124,7 @@ impl PeepholeReplaceKnownMethods {
         };
 
         #[expect(clippy::cast_precision_loss)]
-        Some(ctx.ast.expression_numeric_literal(
-            span,
-            result as f64,
-            None,
-            NumberBase::Decimal,
-        ))
+        Some(ctx.ast.expression_numeric_literal(span, result as f64, None, NumberBase::Decimal))
     }
 
     fn try_fold_string_substring_or_slice<'a>(
@@ -219,12 +214,7 @@ impl PeepholeReplaceKnownMethods {
         let result = string_lit.value.as_str().char_code_at(Some(char_at_index))?;
 
         #[expect(clippy::cast_lossless)]
-        Some(ctx.ast.expression_numeric_literal(
-            span,
-            result as f64,
-            None,
-            NumberBase::Decimal,
-        ))
+        Some(ctx.ast.expression_numeric_literal(span, result as f64, None, NumberBase::Decimal))
     }
     fn try_fold_string_replace_or_string_replace_all<'a>(
         span: Span,

crates/oxc_minifier/src/node_util/mod.rs

@@ -1,6 +1,5 @@
 use std::ops::Deref;
 
-use oxc_allocator::IntoIn;
 use oxc_ast::ast::*;
 use oxc_ecmascript::constant_evaluation::{ConstantEvaluation, ConstantValue};
 use oxc_semantic::{IsGlobalReference, SymbolTable};
@@ -39,8 +38,7 @@ impl<'a> Ctx<'a, '_> {
                 self.ast.expression_numeric_literal(span, n, None, number_base)
             }
             ConstantValue::BigInt(n) => {
-                let raw: &str = (n.to_string() + "n").into_in(&self.ast.allocator);
-                self.ast.expression_big_int_literal(span, raw, BigintBase::Decimal)
+                self.ast.expression_big_int_literal(span, n.to_string() + "n", BigintBase::Decimal)
             }
             ConstantValue::String(s) => self.ast.expression_string_literal(span, s, None),
             ConstantValue::Boolean(b) => self.ast.expression_boolean_literal(span, b),

crates/oxc_minifier/tests/ecmascript/array_join.rs

@@ -13,7 +13,7 @@ fn test() {
     elements.push(ArrayExpressionElement::NumericLiteral(ast.alloc(ast.numeric_literal(
         SPAN,
         42f64,
-        "42",
+        None,
         NumberBase::Decimal,
     ))));
     elements.push(ArrayExpressionElement::StringLiteral(