refactor(allocator, formatter): use std crate over core (#15472)

Pure refactor. Oxc is not no-std, and we use `std` crate everywhere. But a few references to `core` crate existed. Improve consistency by using `std` instead.

Author: overlookmotel

crates/oxc_allocator/src/vec2/mod.rs

@@ -92,19 +92,23 @@
     clippy::undocumented_unsafe_blocks
 )]
 
-use core::borrow::{Borrow, BorrowMut};
-use core::cmp::Ordering;
-use core::fmt;
-use core::hash::{self, Hash};
-use core::iter::FusedIterator;
-use core::marker::PhantomData;
-use core::mem;
-use core::ops;
-use core::ops::Bound::{Excluded, Included, Unbounded};
-use core::ops::{Index, IndexMut, RangeBounds};
-use core::ptr;
-use core::ptr::NonNull;
-use core::slice;
+use std::{
+    borrow::{Borrow, BorrowMut},
+    cmp::Ordering,
+    fmt,
+    hash::{self, Hash},
+    hint,
+    iter::FusedIterator,
+    marker::PhantomData,
+    mem,
+    ops::{
+        self,
+        Bound::{Excluded, Included, Unbounded},
+        Index, IndexMut, RangeBounds,
+    },
+    ptr::{self, NonNull},
+    slice::{self, SliceIndex},
+};
 
 // #[cfg(feature = "std")]
 // use std::io;
@@ -1031,9 +1035,12 @@ impl<'a, T: 'a, A: Alloc> Vec<'a, T, A> {
         // We shadow the slice method of the same name to avoid going through
         // `deref`, which creates an intermediate reference.
         let ptr = self.buf.ptr();
+        // Note: We could use `assert_unchecked!` here, but that would introduce a debug assertion
+        // for a trivially satisfied invariant.
+        // This is a hot path, so that could measurably slow down debug builds.
         unsafe {
             if ptr.is_null() {
-                core::hint::unreachable_unchecked();
+                hint::unreachable_unchecked();
             }
         }
         ptr
@@ -1073,9 +1080,12 @@ impl<'a, T: 'a, A: Alloc> Vec<'a, T, A> {
         // We shadow the slice method of the same name to avoid going through
         // `deref_mut`, which creates an intermediate reference.
         let ptr = self.buf.ptr();
+        // Note: We could use `assert_unchecked!` here, but that would introduce a debug assertion
+        // for a trivially satisfied invariant.
+        // This is a hot path, so that could measurably slow down debug builds.
         unsafe {
             if ptr.is_null() {
-                core::hint::unreachable_unchecked();
+                hint::unreachable_unchecked();
             }
         }
         ptr
@@ -2057,10 +2067,7 @@ impl<'a, T: 'a + Hash, A: Alloc> Hash for Vec<'a, T, A> {
     }
 }
 
-impl<T, A: Alloc, I> Index<I> for Vec<'_, T, A>
-where
-    I: ::core::slice::SliceIndex<[T]>,
-{
+impl<T, A: Alloc, I: SliceIndex<[T]>> Index<I> for Vec<'_, T, A> {
     type Output = I::Output;
 
     #[inline]
@@ -2069,10 +2076,7 @@ where
     }
 }
 
-impl<T, A: Alloc, I> IndexMut<I> for Vec<'_, T, A>
-where
-    I: ::core::slice::SliceIndex<[T]>,
-{
+impl<T, A: Alloc, I: SliceIndex<[T]>> IndexMut<I> for Vec<'_, T, A> {
     #[inline]
     fn index_mut(&mut self, index: I) -> &mut Self::Output {
         IndexMut::index_mut(&mut **self, index)

crates/oxc_allocator/src/vec2/raw_vec.rs

@@ -23,9 +23,11 @@
 #![allow(unstable_name_collisions)]
 #![allow(dead_code)]
 
-use core::alloc::Layout;
-use core::cmp;
-use core::ptr::{self, NonNull};
+use std::{
+    alloc::Layout,
+    cmp,
+    ptr::{self, NonNull},
+};
 
 use crate::alloc::Alloc;
 
@@ -676,7 +678,7 @@ impl<'a, T> RawVec<'a, T> {
         use crate::boxed::Box;
 
         // NOTE: not calling `cap()` here; actually using the real `cap` field!
-        let slice = core::slice::from_raw_parts_mut(self.ptr(), self.cap);
+        let slice = std::slice::from_raw_parts_mut(self.ptr(), self.cap);
         let output: Box<'a, [T]> = Box::from_raw(slice);
         mem::forget(self);
         output
@@ -839,7 +841,7 @@ impl<T, A: Alloc> RawVec<'_, T, A> {
 #[inline]
 fn alloc_guard(alloc_size: usize) -> Result<(), AllocError> {
     if size_of::<usize>() < 8 {
-        if alloc_size > ::core::isize::MAX as usize {
+        if alloc_size > isize::MAX as usize {
             return Err(AllocError::CapacityOverflow);
         }
     } else if alloc_size > u32::MAX as usize {

crates/oxc_formatter/src/ast_nodes/node.rs

@@ -1,5 +1,5 @@
-use core::fmt;
 use std::{
+    fmt,
     mem::{transmute, transmute_copy},
     ops::Deref,
 };

crates/oxc_formatter/src/parentheses/expression.rs

@@ -125,7 +125,7 @@ impl NeedsParentheses<'_> for AstNode<'_, IdentifierReference<'_>> {
                 }
 
                 // Early return if the parent isn't a `TSSatisfiesExpression` or `TSAsExpression`
-                if core::ptr::eq(self.parent, parent) {
+                if ptr::eq(self.parent, parent) {
                     return false;
                 }
 

crates/oxc_formatter/src/utils/jsx.rs

@@ -1,5 +1,8 @@
-use std::iter::{FusedIterator, Peekable};
-use std::str::Chars;
+use std::{
+    iter::{FusedIterator, Peekable},
+    mem,
+    str::Chars,
+};
 
 use oxc_allocator::Vec as ArenaVec;
 use oxc_ast::ast::*;
@@ -215,7 +218,7 @@ impl PartialEq for JsxChild<'_, '_> {
         match (self, other) {
             (Self::Word(l0), Self::Word(r0)) => l0 == r0,
             (Self::NonText(_), Self::NonText(_)) => false, // Never equal by structural comparison
-            _ => core::mem::discriminant(self) == core::mem::discriminant(other),
+            _ => mem::discriminant(self) == mem::discriminant(other),
         }
     }
 }