diff --git a/Cargo.lock b/Cargo.lock
index 50126c7269c44..bb015e3ac1ce1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2311,6 +2311,7 @@ dependencies = [
 name = "oxc_semantic"
 version = "0.101.0"
 dependencies = [
+ "hashbrown 0.16.0",
  "insta",
  "itertools",
  "oxc_allocator",
@@ -2356,6 +2357,7 @@ dependencies = [
  "oxc_allocator",
  "oxc_ast_macros",
  "oxc_estree",
+ "rustc-hash",
  "serde",
 ]
 
diff --git a/apps/oxlint/src-js/generated/deserialize.js b/apps/oxlint/src-js/generated/deserialize.js
index eeb50e6b2d993..3df6d419c65a1 100644
--- a/apps/oxlint/src-js/generated/deserialize.js
+++ b/apps/oxlint/src-js/generated/deserialize.js
@@ -201,7 +201,7 @@ function deserializeIdentifierName(pos) {
       __proto__: NodeProto,
       type: "Identifier",
       decorators: null,
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       optional: null,
       typeAnnotation: null,
       start,
@@ -223,7 +223,7 @@ function deserializeIdentifierReference(pos) {
       __proto__: NodeProto,
       type: "Identifier",
       decorators: null,
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       optional: null,
       typeAnnotation: null,
       start,
@@ -245,7 +245,7 @@ function deserializeBindingIdentifier(pos) {
       __proto__: NodeProto,
       type: "Identifier",
       decorators: null,
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       optional: null,
       typeAnnotation: null,
       start,
@@ -267,7 +267,7 @@ function deserializeLabelIdentifier(pos) {
       __proto__: NodeProto,
       type: "Identifier",
       decorators: null,
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       optional: null,
       typeAnnotation: null,
       start,
@@ -2649,7 +2649,7 @@ function deserializePrivateIdentifier(pos) {
   return {
     __proto__: NodeProto,
     type: "PrivateIdentifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
     range: [start, end],
@@ -3685,7 +3685,7 @@ function deserializeJSXIdentifier(pos) {
   return {
     __proto__: NodeProto,
     type: "JSXIdentifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
     range: [start, end],
diff --git a/crates/oxc_allocator/src/clone_in.rs b/crates/oxc_allocator/src/clone_in.rs
index 99914c777a10f..812b436b89f6b 100644
--- a/crates/oxc_allocator/src/clone_in.rs
+++ b/crates/oxc_allocator/src/clone_in.rs
@@ -1,6 +1,12 @@
-use std::{alloc::Layout, cell::Cell, hash::Hash, ptr::NonNull, slice};
+use std::{
+    alloc::Layout,
+    cell::Cell,
+    hash::{BuildHasher, Hash},
+    ptr::NonNull,
+    slice,
+};
 
-use crate::{Allocator, Box, HashMap, Vec};
+use crate::{Allocator, Box, HashMapImpl, Vec};
 
 /// A trait to explicitly clone an object into an arena allocator.
 ///
@@ -207,13 +213,14 @@ where
     }
 }
 
-impl<'new_alloc, K, V, CK, CV> CloneIn<'new_alloc> for HashMap<'_, K, V>
+impl<'new_alloc, K, V, CK, CV, H> CloneIn<'new_alloc> for HashMapImpl<'_, K, V, H>
 where
     K: CloneIn<'new_alloc, Cloned = CK>,
     V: CloneIn<'new_alloc, Cloned = CV>,
     CK: Hash + Eq,
+    H: BuildHasher + Default,
 {
-    type Cloned = HashMap<'new_alloc, CK, CV>;
+    type Cloned = HashMapImpl<'new_alloc, CK, CV, H>;
 
     fn clone_in(&self, allocator: &'new_alloc Allocator) -> Self::Cloned {
         // Keys in original hash map are guaranteed to be unique.
@@ -223,7 +230,7 @@ where
         // `hashbrown::HashMap` also has a faster cloning method in its `Clone` implementation,
         // but those APIs are not exposed, and `Clone` doesn't support custom allocators.
         // So sadly this is a lot slower than it could be, especially for `Copy` types.
-        let mut cloned = HashMap::with_capacity_in(self.len(), allocator);
+        let mut cloned = HashMapImpl::with_capacity_in(self.len(), allocator);
         for (key, value) in self {
             cloned.insert(key.clone_in(allocator), value.clone_in(allocator));
         }
@@ -231,7 +238,7 @@ where
     }
 
     fn clone_in_with_semantic_ids(&self, allocator: &'new_alloc Allocator) -> Self::Cloned {
-        let mut cloned = HashMap::with_capacity_in(self.len(), allocator);
+        let mut cloned = HashMapImpl::with_capacity_in(self.len(), allocator);
         for (key, value) in self {
             cloned.insert(
                 key.clone_in_with_semantic_ids(allocator),
@@ -281,7 +288,8 @@ impl_clone_in! {
 
 #[cfg(test)]
 mod test {
-    use super::{Allocator, CloneIn, HashMap, Vec};
+    use super::{Allocator, CloneIn, Vec};
+    use crate::HashMap;
 
     #[test]
     fn clone_in_boxed_slice() {
diff --git a/crates/oxc_allocator/src/hash_map.rs b/crates/oxc_allocator/src/hash_map.rs
index 06dac053acd6f..251c292c0ee89 100644
--- a/crates/oxc_allocator/src/hash_map.rs
+++ b/crates/oxc_allocator/src/hash_map.rs
@@ -8,13 +8,12 @@
 #![expect(clippy::inline_always)]
 
 use std::{
-    hash::Hash,
+    hash::{BuildHasher, Hash},
     mem::ManuallyDrop,
     ops::{Deref, DerefMut},
 };
 
 use bumpalo::Bump;
-use rustc_hash::FxBuildHasher;
 
 // Re-export additional types from `hashbrown`
 pub use hashbrown::{
@@ -27,7 +26,7 @@ pub use hashbrown::{
 
 use crate::Allocator;
 
-type FxHashMap<'alloc, K, V> = hashbrown::HashMap<K, V, FxBuildHasher, &'alloc Bump>;
+type InternalHashMap<'alloc, K, V, H> = hashbrown::HashMap<K, V, H, &'alloc Bump>;
 
 /// A hash map without `Drop`, that uses [`FxHasher`] to hash keys, and stores data in arena allocator.
 ///
@@ -49,7 +48,26 @@ type FxHashMap<'alloc, K, V> = hashbrown::HashMap<K, V, FxBuildHasher, &'alloc B
 ///
 /// [`FxHasher`]: rustc_hash::FxHasher
 #[derive(Debug)]
-pub struct HashMap<'alloc, K, V>(pub(crate) ManuallyDrop<FxHashMap<'alloc, K, V>>);
+pub struct HashMapImpl<'alloc, K, V, H: BuildHasher>(
+    pub(crate) ManuallyDrop<InternalHashMap<'alloc, K, V, H>>,
+);
+
+// Workaround for `FxBuildHasher` not implementing `Debug`.
+#[derive(Default, Debug)]
+#[expect(missing_docs)] // TODO
+pub struct FxBuildHasher;
+
+impl BuildHasher for FxBuildHasher {
+    type Hasher = rustc_hash::FxHasher;
+
+    #[inline(always)]
+    fn build_hasher(&self) -> Self::Hasher {
+        rustc_hash::FxHasher::default()
+    }
+}
+
+#[expect(missing_docs)] // TODO
+pub type HashMap<'alloc, K, V> = HashMapImpl<'alloc, K, V, FxBuildHasher>;
 
 /// SAFETY: Even though `Bump` is not `Sync`, we can make `HashMap<K, V>` `Sync` if both `K` and `V`
 /// are `Sync` because:
@@ -85,12 +103,12 @@ pub struct HashMap<'alloc, K, V>(pub(crate) ManuallyDrop<FxHashMap<'alloc, K, V>
 ///
 /// TODO: Fix these holes.
 /// TODO: Remove any other methods that currently allow performing allocations with only a `&self` reference.
-unsafe impl<K: Sync, V: Sync> Sync for HashMap<'_, K, V> {}
+unsafe impl<K: Sync, V: Sync, H: BuildHasher> Sync for HashMapImpl<'_, K, V, H> {}
 
 // TODO: `IntoIter`, `Drain`, and other consuming iterators provided by `hashbrown` are `Drop`.
 // Wrap them in `ManuallyDrop` to prevent that.
 
-impl<'alloc, K, V> HashMap<'alloc, K, V> {
+impl<'alloc, K, V, H: BuildHasher + Default> HashMapImpl<'alloc, K, V, H> {
     /// Const assertions that `K` and `V` are not `Drop`.
     /// Must be referenced in all methods which create a `HashMap`.
     const ASSERT_K_AND_V_ARE_NOT_DROP: () = {
@@ -112,7 +130,7 @@ impl<'alloc, K, V> HashMap<'alloc, K, V> {
     pub fn new_in(allocator: &'alloc Allocator) -> Self {
         const { Self::ASSERT_K_AND_V_ARE_NOT_DROP };
 
-        let inner = FxHashMap::with_hasher_in(FxBuildHasher, allocator.bump());
+        let inner = InternalHashMap::with_hasher_in(H::default(), allocator.bump());
         Self(ManuallyDrop::new(inner))
     }
 
@@ -125,7 +143,7 @@ impl<'alloc, K, V> HashMap<'alloc, K, V> {
         const { Self::ASSERT_K_AND_V_ARE_NOT_DROP };
 
         let inner =
-            FxHashMap::with_capacity_and_hasher_in(capacity, FxBuildHasher, allocator.bump());
+            InternalHashMap::with_capacity_and_hasher_in(capacity, H::default(), allocator.bump());
         Self(ManuallyDrop::new(inner))
     }
 
@@ -153,7 +171,8 @@ impl<'alloc, K, V> HashMap<'alloc, K, V> {
         // * Positive: Avoids potential large over-allocation for iterators where upper bound may be a large over-estimate
         //   e.g. filter iterators.
         let capacity = iter.size_hint().0;
-        let map = FxHashMap::with_capacity_and_hasher_in(capacity, FxBuildHasher, allocator.bump());
+        let map =
+            InternalHashMap::with_capacity_and_hasher_in(capacity, H::default(), allocator.bump());
         // Wrap in `ManuallyDrop` *before* calling `for_each`, so compiler doesn't insert unnecessary code
         // to drop the `FxHashMap` in case of a panic in iterator's `next` method
         let mut map = ManuallyDrop::new(map);
@@ -202,8 +221,8 @@ impl<'alloc, K, V> HashMap<'alloc, K, V> {
 }
 
 // Provide access to all `hashbrown::HashMap`'s methods via deref
-impl<'alloc, K, V> Deref for HashMap<'alloc, K, V> {
-    type Target = FxHashMap<'alloc, K, V>;
+impl<'alloc, K, V, H: BuildHasher> Deref for HashMapImpl<'alloc, K, V, H> {
+    type Target = InternalHashMap<'alloc, K, V, H>;
 
     #[inline]
     fn deref(&self) -> &Self::Target {
@@ -211,14 +230,14 @@ impl<'alloc, K, V> Deref for HashMap<'alloc, K, V> {
     }
 }
 
-impl<'alloc, K, V> DerefMut for HashMap<'alloc, K, V> {
+impl<'alloc, K, V, H: BuildHasher> DerefMut for HashMapImpl<'alloc, K, V, H> {
     #[inline]
-    fn deref_mut(&mut self) -> &mut FxHashMap<'alloc, K, V> {
+    fn deref_mut(&mut self) -> &mut InternalHashMap<'alloc, K, V, H> {
         &mut self.0
     }
 }
 
-impl<'alloc, K, V> IntoIterator for HashMap<'alloc, K, V> {
+impl<'alloc, K, V, H: BuildHasher> IntoIterator for HashMapImpl<'alloc, K, V, H> {
     type IntoIter = IntoIter<K, V, &'alloc Bump>;
     type Item = (K, V);
 
@@ -235,8 +254,8 @@ impl<'alloc, K, V> IntoIterator for HashMap<'alloc, K, V> {
     }
 }
 
-impl<'alloc, 'i, K, V> IntoIterator for &'i HashMap<'alloc, K, V> {
-    type IntoIter = <&'i FxHashMap<'alloc, K, V> as IntoIterator>::IntoIter;
+impl<'alloc, 'i, K, V, H: BuildHasher> IntoIterator for &'i HashMapImpl<'alloc, K, V, H> {
+    type IntoIter = <&'i InternalHashMap<'alloc, K, V, H> as IntoIterator>::IntoIter;
     type Item = (&'i K, &'i V);
 
     /// Creates an iterator over the entries of a `HashMap` in arbitrary order.
@@ -250,8 +269,8 @@ impl<'alloc, 'i, K, V> IntoIterator for &'i HashMap<'alloc, K, V> {
     }
 }
 
-impl<'alloc, 'i, K, V> IntoIterator for &'i mut HashMap<'alloc, K, V> {
-    type IntoIter = <&'i mut FxHashMap<'alloc, K, V> as IntoIterator>::IntoIter;
+impl<'alloc, 'i, K, V, H: BuildHasher> IntoIterator for &'i mut HashMapImpl<'alloc, K, V, H> {
+    type IntoIter = <&'i mut InternalHashMap<'alloc, K, V, H> as IntoIterator>::IntoIter;
     type Item = (&'i K, &'i mut V);
 
     /// Creates an iterator over the entries of a `HashMap` in arbitrary order
@@ -266,10 +285,11 @@ impl<'alloc, 'i, K, V> IntoIterator for &'i mut HashMap<'alloc, K, V> {
     }
 }
 
-impl<K, V> PartialEq for HashMap<'_, K, V>
+impl<K, V, H> PartialEq for HashMapImpl<'_, K, V, H>
 where
     K: Eq + Hash,
     V: PartialEq,
+    H: BuildHasher,
 {
     #[inline(always)]
     fn eq(&self, other: &Self) -> bool {
@@ -277,10 +297,11 @@ where
     }
 }
 
-impl<K, V> Eq for HashMap<'_, K, V>
+impl<K, V, H> Eq for HashMapImpl<'_, K, V, H>
 where
     K: Eq + Hash,
     V: Eq,
+    H: BuildHasher,
 {
 }
 
diff --git a/crates/oxc_allocator/src/hash_set.rs b/crates/oxc_allocator/src/hash_set.rs
index 4b0721ac5174f..f14e744535d00 100644
--- a/crates/oxc_allocator/src/hash_set.rs
+++ b/crates/oxc_allocator/src/hash_set.rs
@@ -14,14 +14,13 @@ use std::{
 };
 
 use bumpalo::Bump;
-use rustc_hash::FxBuildHasher;
 
 // Re-export additional types from `hashbrown`
 pub use hashbrown::hash_set::{
     Difference, Drain, Entry, ExtractIf, Intersection, IntoIter, Iter, SymmetricDifference, Union,
 };
 
-use crate::{Allocator, HashMap};
+use crate::{Allocator, HashMap, hash_map::FxBuildHasher};
 
 type FxHashSet<'alloc, T> = hashbrown::HashSet<T, FxBuildHasher, &'alloc Bump>;
 
diff --git a/crates/oxc_allocator/src/lib.rs b/crates/oxc_allocator/src/lib.rs
index 5ca3a798db4a9..7c6fdd3ef58ad 100644
--- a/crates/oxc_allocator/src/lib.rs
+++ b/crates/oxc_allocator/src/lib.rs
@@ -69,7 +69,7 @@ pub use bitset::BitSet;
 pub use boxed::Box;
 pub use clone_in::CloneIn;
 pub use convert::{FromIn, IntoIn};
-pub use hash_map::HashMap;
+pub use hash_map::{FxBuildHasher, HashMap, HashMapImpl};
 pub use hash_set::HashSet;
 #[cfg(feature = "pool")]
 pub use pool::*;
diff --git a/crates/oxc_ast/src/ast/js.rs b/crates/oxc_ast/src/ast/js.rs
index 2fcac614cfb66..c43e806fc2488 100644
--- a/crates/oxc_ast/src/ast/js.rs
+++ b/crates/oxc_ast/src/ast/js.rs
@@ -25,7 +25,7 @@ use std::cell::Cell;
 use oxc_allocator::{Box, CloneIn, Dummy, GetAddress, TakeIn, UnstableAddress, Vec};
 use oxc_ast_macros::ast;
 use oxc_estree::ESTree;
-use oxc_span::{Atom, ContentEq, GetSpan, GetSpanMut, SourceType, Span};
+use oxc_span::{Atom, ContentEq, GetSpan, GetSpanMut, Ident, SourceType, Span};
 use oxc_syntax::{
     operator::{
         AssignmentOperator, BinaryOperator, LogicalOperator, UnaryOperator, UpdateOperator,
@@ -234,7 +234,7 @@ pub use match_expression;
 pub struct IdentifierName<'a> {
     pub span: Span,
     #[estree(json_safe)]
-    pub name: Atom<'a>,
+    pub name: Ident<'a>,
 }
 
 /// `x` inside `func` in `const x = 0; function func() { console.log(x); }`
@@ -253,8 +253,9 @@ pub struct IdentifierName<'a> {
 pub struct IdentifierReference<'a> {
     pub span: Span,
     /// The name of the identifier being referenced.
+    // pub name: Atom<'a>,
     #[estree(json_safe)]
-    pub name: Atom<'a>,
+    pub name: Ident<'a>,
     /// Reference ID
     ///
     /// Identifies what identifier this refers to, and how it is used. This is
@@ -283,7 +284,7 @@ pub struct BindingIdentifier<'a> {
     pub span: Span,
     /// The identifier name being bound.
     #[estree(json_safe)]
-    pub name: Atom<'a>,
+    pub name: Ident<'a>,
     /// Unique identifier for this binding.
     ///
     /// This gets initialized during [`semantic analysis`] in the bind step. If
@@ -309,7 +310,7 @@ pub struct BindingIdentifier<'a> {
 pub struct LabelIdentifier<'a> {
     pub span: Span,
     #[estree(json_safe)]
-    pub name: Atom<'a>,
+    pub name: Ident<'a>,
 }
 
 /// `this` in `return this.prop;`
@@ -2285,7 +2286,7 @@ pub enum MethodDefinitionKind {
 #[generate_derive(CloneIn, Dummy, TakeIn, GetSpan, GetSpanMut, ContentEq, ESTree, UnstableAddress)]
 pub struct PrivateIdentifier<'a> {
     pub span: Span,
-    pub name: Atom<'a>,
+    pub name: Ident<'a>,
 }
 
 /// Class Static Block
diff --git a/crates/oxc_ast/src/ast/jsx.rs b/crates/oxc_ast/src/ast/jsx.rs
index b5109a2c66476..1fbe5c99af1f3 100644
--- a/crates/oxc_ast/src/ast/jsx.rs
+++ b/crates/oxc_ast/src/ast/jsx.rs
@@ -7,7 +7,7 @@
 use oxc_allocator::{Box, CloneIn, Dummy, GetAddress, TakeIn, UnstableAddress, Vec};
 use oxc_ast_macros::ast;
 use oxc_estree::ESTree;
-use oxc_span::{Atom, ContentEq, GetSpan, GetSpanMut, Span};
+use oxc_span::{Atom, ContentEq, GetSpan, GetSpanMut, Ident, Span};
 
 use super::{inherit_variants, js::*, literal::*, ts::*};
 
@@ -424,7 +424,7 @@ pub struct JSXIdentifier<'a> {
     pub span: Span,
     /// The name of the identifier.
     #[estree(json_safe)]
-    pub name: Atom<'a>,
+    pub name: Ident<'a>,
 }
 
 // 1.4 JSX Children
diff --git a/crates/oxc_ast/src/ast_builder_impl.rs b/crates/oxc_ast/src/ast_builder_impl.rs
index 738367f02b195..00c738fac8f96 100644
--- a/crates/oxc_ast/src/ast_builder_impl.rs
+++ b/crates/oxc_ast/src/ast_builder_impl.rs
@@ -3,7 +3,7 @@
 use std::borrow::Cow;
 
 use oxc_allocator::{Allocator, AllocatorAccessor, Box, FromIn, IntoIn, Vec};
-use oxc_span::{Atom, SPAN, Span};
+use oxc_span::{Atom, Ident, SPAN, Span};
 use oxc_syntax::{
     comment_node::CommentNodeId, number::NumberBase, operator::UnaryOperator, scope::ScopeId,
 };
@@ -98,6 +98,18 @@ impl<'a> AstBuilder<'a> {
         self.allocator.alloc_str(value)
     }
 
+    /// Allocate an [`Ident`] from a string slice.
+    #[inline]
+    pub fn ident(self, value: &str) -> Ident<'a> {
+        Ident::from_in(value, self.allocator)
+    }
+
+    /// Allocate an [`Ident`] from an array of string slices.
+    #[inline]
+    pub fn ident_from_strs_array<const N: usize>(self, strings: [&str; N]) -> Ident<'a> {
+        Ident::from_strs_array_in(strings, self.allocator)
+    }
+
     /// Allocate an [`Atom`] from a string slice.
     #[inline]
     pub fn atom(self, value: &str) -> Atom<'a> {
diff --git a/crates/oxc_ast/src/ast_impl/js.rs b/crates/oxc_ast/src/ast_impl/js.rs
index 1a9d1d3f5e0ea..a1b03a673d785 100644
--- a/crates/oxc_ast/src/ast_impl/js.rs
+++ b/crates/oxc_ast/src/ast_impl/js.rs
@@ -4,7 +4,7 @@ use std::{
     fmt::{self, Display},
 };
 
-use oxc_span::{Atom, GetSpan, Span};
+use oxc_span::{Atom, GetSpan, Ident, Span};
 use oxc_syntax::{operator::UnaryOperator, scope::ScopeFlags};
 
 use crate::ast::*;
@@ -504,7 +504,7 @@ impl<'a> PropertyKey<'a> {
     /// - `a: 1` in `{ a: 1 }` would return `None`
     pub fn private_name(&self) -> Option<Atom<'a>> {
         match self {
-            Self::PrivateIdentifier(ident) => Some(ident.name),
+            Self::PrivateIdentifier(ident) => Some(ident.name.as_atom()),
             _ => None,
         }
     }
@@ -1259,7 +1259,7 @@ impl<'a> BindingPattern<'a> {
     /// - calling on `a = 1` in `let a = 1` would return `Some("a")`
     /// - calling on `a = 1` in `let {a = 1} = c` would return `Some("a")`
     /// - calling on `a: b` in `let {a: b} = c` would return `None`
-    pub fn get_identifier_name(&self) -> Option<Atom<'a>> {
+    pub fn get_identifier_name(&self) -> Option<Ident<'a>> {
         self.kind.get_identifier_name()
     }
 
@@ -1296,7 +1296,7 @@ impl<'a> BindingPatternKind<'a> {
     /// - calling on `a = 1` in `let a = 1` would return `Some("a")`
     /// - calling on `a = 1` in `let {a = 1} = c` would return `Some("a")`
     /// - calling on `a: b` in `let {a: b} = c` would return `None`
-    pub fn get_identifier_name(&self) -> Option<Atom<'a>> {
+    pub fn get_identifier_name(&self) -> Option<Ident<'a>> {
         match self {
             Self::BindingIdentifier(ident) => Some(ident.name),
             Self::AssignmentPattern(assign) => assign.left.get_identifier_name(),
@@ -1426,7 +1426,7 @@ impl ArrayPattern<'_> {
 impl<'a> Function<'a> {
     /// Returns this [`Function`]'s name, if it has one.
     #[inline]
-    pub fn name(&self) -> Option<Atom<'a>> {
+    pub fn name(&self) -> Option<Ident<'a>> {
         self.id.as_ref().map(|id| id.name)
     }
 
@@ -1582,7 +1582,7 @@ impl<'a> ArrowFunctionExpression<'a> {
 impl<'a> Class<'a> {
     /// Returns this [`Class`]'s name, if it has one.
     #[inline]
-    pub fn name(&self) -> Option<Atom<'a>> {
+    pub fn name(&self) -> Option<Ident<'a>> {
         self.id.as_ref().map(|id| id.name)
     }
 
@@ -1929,7 +1929,7 @@ impl<'a> ImportAttributeKey<'a> {
     /// Returns the string value of this import attribute key.
     pub fn as_atom(&self) -> Atom<'a> {
         match self {
-            Self::Identifier(identifier) => identifier.name,
+            Self::Identifier(identifier) => identifier.name.as_atom(),
             Self::StringLiteral(literal) => literal.value,
         }
     }
@@ -1988,11 +1988,11 @@ impl<'a> ModuleExportName<'a> {
     /// - `export { foo }` => `"foo"`
     /// - `export { foo as bar }` => `"bar"`
     /// - `export { foo as "anything" }` => `"anything"`
-    pub fn name(&self) -> Atom<'a> {
+    pub fn name(&self) -> Ident<'a> {
         match self {
             Self::IdentifierName(identifier) => identifier.name,
             Self::IdentifierReference(identifier) => identifier.name,
-            Self::StringLiteral(literal) => literal.value,
+            Self::StringLiteral(literal) => Ident::from(literal.value),
         }
     }
 
@@ -2003,7 +2003,7 @@ impl<'a> ModuleExportName<'a> {
     /// - `export { foo }` => `Some("foo")`
     /// - `export { foo as bar }` => `Some("bar")`
     /// - `export { foo as "anything" }` => `None`
-    pub fn identifier_name(&self) -> Option<Atom<'a>> {
+    pub fn identifier_name(&self) -> Option<Ident<'a>> {
         match self {
             Self::IdentifierName(identifier) => Some(identifier.name),
             Self::IdentifierReference(identifier) => Some(identifier.name),
diff --git a/crates/oxc_ast/src/ast_impl/jsx.rs b/crates/oxc_ast/src/ast_impl/jsx.rs
index adfa1e7b8e73f..85b2483ef9d9f 100644
--- a/crates/oxc_ast/src/ast_impl/jsx.rs
+++ b/crates/oxc_ast/src/ast_impl/jsx.rs
@@ -2,7 +2,7 @@
 
 use std::fmt::{self, Display};
 
-use oxc_span::Atom;
+use oxc_span::Ident;
 
 use crate::ast::*;
 
@@ -50,7 +50,7 @@ impl<'a> JSXElementName<'a> {
     /// * `<this>`
     /// * `<Foo.bar>`
     /// * `<Foo:Bar>` - [namespaced identifiers](JSXElementName::NamespacedName)
-    pub fn get_identifier_name(&self) -> Option<Atom<'a>> {
+    pub fn get_identifier_name(&self) -> Option<Ident<'a>> {
         match self {
             Self::Identifier(id) => Some(id.as_ref().name),
             Self::IdentifierReference(id) => Some(id.as_ref().name),
diff --git a/crates/oxc_ast/src/ast_impl/ts.rs b/crates/oxc_ast/src/ast_impl/ts.rs
index 7ced1cd1a6310..91f5b4652c405 100644
--- a/crates/oxc_ast/src/ast_impl/ts.rs
+++ b/crates/oxc_ast/src/ast_impl/ts.rs
@@ -6,7 +6,7 @@
 
 use std::fmt;
 
-use oxc_span::Atom;
+use oxc_span::{Atom, Ident};
 
 use crate::ast::*;
 
@@ -14,13 +14,13 @@ impl<'a> TSEnumMemberName<'a> {
     /// Get the name of this enum member.
     /// # Panics
     /// Panics if `self` is a `TemplateString` with no quasi.
-    pub fn static_name(&self) -> Atom<'a> {
+    pub fn static_name(&self) -> Ident<'a> {
         match self {
             Self::Identifier(ident) => ident.name,
-            Self::String(lit) | Self::ComputedString(lit) => lit.value,
-            Self::ComputedTemplateString(template) => template
+            Self::String(lit) | Self::ComputedString(lit) => Ident::from(lit.value),
+            Self::ComputedTemplateString(template) => Ident::from(template
                 .single_quasi()
-                .expect("`TSEnumMemberName::TemplateString` should have no substitution and at least one quasi"),
+                .expect("`TSEnumMemberName::TemplateString` should have no substitution and at least one quasi")),
         }
     }
 }
@@ -218,7 +218,7 @@ impl<'a> TSModuleDeclarationName<'a> {
     /// Get the static name of this module declaration name.
     pub fn name(&self) -> Atom<'a> {
         match self {
-            Self::Identifier(ident) => ident.name,
+            Self::Identifier(ident) => ident.name.as_atom(),
             Self::StringLiteral(lit) => lit.value,
         }
     }
diff --git a/crates/oxc_ast/src/ast_kind_impl.rs b/crates/oxc_ast/src/ast_kind_impl.rs
index 1057eaed7ab73..3a9a652ed9158 100644
--- a/crates/oxc_ast/src/ast_kind_impl.rs
+++ b/crates/oxc_ast/src/ast_kind_impl.rs
@@ -4,7 +4,7 @@
 //! including type checking, conversions, and tree traversal helpers.
 
 use oxc_allocator::{Address, GetAddress, UnstableAddress};
-use oxc_span::{Atom, GetSpan};
+use oxc_span::{Atom, GetSpan, Ident};
 
 use super::{AstKind, ast::*};
 
@@ -174,7 +174,7 @@ impl<'a> AstKind<'a> {
     ///
     /// Returns the identifier name if this is any kind of identifier node,
     /// `None` otherwise.
-    pub fn identifier_name(self) -> Option<Atom<'a>> {
+    pub fn identifier_name(self) -> Option<Ident<'a>> {
         match self {
             Self::BindingIdentifier(ident) => Some(ident.name),
             Self::IdentifierReference(ident) => Some(ident.name),
@@ -392,7 +392,7 @@ impl AstKind<'_> {
             Self::VariableDeclaration(_) => "VariableDeclaration".into(),
             Self::VariableDeclarator(v) => format!(
                 "VariableDeclarator({})",
-                v.id.get_identifier_name().unwrap_or(Atom::from(DESTRUCTURE.as_ref()))
+                v.id.get_identifier_name().unwrap_or(Ident::from(DESTRUCTURE.as_ref()))
             )
             .into(),
 
@@ -474,7 +474,7 @@ impl AstKind<'_> {
             Self::FormalParameters(_) => "FormalParameters".into(),
             Self::FormalParameter(p) => format!(
                 "FormalParameter({})",
-                p.pattern.get_identifier_name().unwrap_or(Atom::from(DESTRUCTURE.as_ref()))
+                p.pattern.get_identifier_name().unwrap_or(Ident::from(DESTRUCTURE.as_ref()))
             )
             .into(),
             Self::CatchParameter(_) => "CatchParameter".into(),
@@ -628,7 +628,7 @@ impl<'a> MemberExpressionKind<'a> {
     pub fn static_property_name(&self) -> Option<Atom<'a>> {
         match self {
             Self::Computed(member_expr) => member_expr.static_property_name(),
-            Self::Static(member_expr) => Some(member_expr.property.name),
+            Self::Static(member_expr) => Some(member_expr.property.name.as_atom()),
             Self::PrivateField(_) => None,
         }
     }
diff --git a/crates/oxc_ast/src/generated/ast_builder.rs b/crates/oxc_ast/src/generated/ast_builder.rs
index 3a4a1c090aea8..b930cdffc8d30 100644
--- a/crates/oxc_ast/src/generated/ast_builder.rs
+++ b/crates/oxc_ast/src/generated/ast_builder.rs
@@ -13,6 +13,7 @@
 use std::cell::Cell;
 
 use oxc_allocator::{Allocator, Box, IntoIn, Vec};
+use oxc_span::Ident;
 use oxc_syntax::{
     comment_node::CommentNodeId, reference::ReferenceId, scope::ScopeId, symbol::SymbolId,
 };
@@ -247,10 +248,7 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: The [`Span`] covering this node
     /// * `name`: The name of the identifier being referenced.
     #[inline]
-    pub fn expression_identifier<A1>(self, span: Span, name: A1) -> Expression<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
+    pub fn expression_identifier(self, span: Span, name: Ident<'a>) -> Expression<'a> {
         Expression::Identifier(self.alloc_identifier_reference(span, name))
     }
 
@@ -263,15 +261,12 @@ impl<'a> AstBuilder<'a> {
     /// * `name`: The name of the identifier being referenced.
     /// * `reference_id`: Reference ID
     #[inline]
-    pub fn expression_identifier_with_reference_id<A1>(
+    pub fn expression_identifier_with_reference_id(
         self,
         span: Span,
-        name: A1,
+        name: Ident<'a>,
         reference_id: ReferenceId,
-    ) -> Expression<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
+    ) -> Expression<'a> {
         Expression::Identifier(self.alloc_identifier_reference_with_reference_id(
             span,
             name,
@@ -1226,11 +1221,8 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: The [`Span`] covering this node
     /// * `name`
     #[inline]
-    pub fn identifier_name<A1>(self, span: Span, name: A1) -> IdentifierName<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
-        IdentifierName { span, name: name.into() }
+    pub fn identifier_name(self, span: Span, name: Ident<'a>) -> IdentifierName<'a> {
+        IdentifierName { span, name }
     }
 
     /// Build an [`IdentifierName`], and store it in the memory arena.
@@ -1242,10 +1234,7 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: The [`Span`] covering this node
     /// * `name`
     #[inline]
-    pub fn alloc_identifier_name<A1>(self, span: Span, name: A1) -> Box<'a, IdentifierName<'a>>
-    where
-        A1: Into<Atom<'a>>,
-    {
+    pub fn alloc_identifier_name(self, span: Span, name: Ident<'a>) -> Box<'a, IdentifierName<'a>> {
         Box::new_in(self.identifier_name(span, name), self.allocator)
     }
 
@@ -1258,11 +1247,8 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: The [`Span`] covering this node
     /// * `name`: The name of the identifier being referenced.
     #[inline]
-    pub fn identifier_reference<A1>(self, span: Span, name: A1) -> IdentifierReference<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
-        IdentifierReference { span, name: name.into(), reference_id: Default::default() }
+    pub fn identifier_reference(self, span: Span, name: Ident<'a>) -> IdentifierReference<'a> {
+        IdentifierReference { span, name, reference_id: Default::default() }
     }
 
     /// Build an [`IdentifierReference`], and store it in the memory arena.
@@ -1274,14 +1260,11 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: The [`Span`] covering this node
     /// * `name`: The name of the identifier being referenced.
     #[inline]
-    pub fn alloc_identifier_reference<A1>(
+    pub fn alloc_identifier_reference(
         self,
         span: Span,
-        name: A1,
-    ) -> Box<'a, IdentifierReference<'a>>
-    where
-        A1: Into<Atom<'a>>,
-    {
+        name: Ident<'a>,
+    ) -> Box<'a, IdentifierReference<'a>> {
         Box::new_in(self.identifier_reference(span, name), self.allocator)
     }
 
@@ -1295,16 +1278,13 @@ impl<'a> AstBuilder<'a> {
     /// * `name`: The name of the identifier being referenced.
     /// * `reference_id`: Reference ID
     #[inline]
-    pub fn identifier_reference_with_reference_id<A1>(
+    pub fn identifier_reference_with_reference_id(
         self,
         span: Span,
-        name: A1,
+        name: Ident<'a>,
         reference_id: ReferenceId,
-    ) -> IdentifierReference<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
-        IdentifierReference { span, name: name.into(), reference_id: Cell::new(Some(reference_id)) }
+    ) -> IdentifierReference<'a> {
+        IdentifierReference { span, name, reference_id: Cell::new(Some(reference_id)) }
     }
 
     /// Build an [`IdentifierReference`] with `reference_id`, and store it in the memory arena.
@@ -1317,15 +1297,12 @@ impl<'a> AstBuilder<'a> {
     /// * `name`: The name of the identifier being referenced.
     /// * `reference_id`: Reference ID
     #[inline]
-    pub fn alloc_identifier_reference_with_reference_id<A1>(
+    pub fn alloc_identifier_reference_with_reference_id(
         self,
         span: Span,
-        name: A1,
+        name: Ident<'a>,
         reference_id: ReferenceId,
-    ) -> Box<'a, IdentifierReference<'a>>
-    where
-        A1: Into<Atom<'a>>,
-    {
+    ) -> Box<'a, IdentifierReference<'a>> {
         Box::new_in(
             self.identifier_reference_with_reference_id(span, name, reference_id),
             self.allocator,
@@ -1341,11 +1318,8 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: The [`Span`] covering this node
     /// * `name`: The identifier name being bound.
     #[inline]
-    pub fn binding_identifier<A1>(self, span: Span, name: A1) -> BindingIdentifier<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
-        BindingIdentifier { span, name: name.into(), symbol_id: Default::default() }
+    pub fn binding_identifier(self, span: Span, name: Ident<'a>) -> BindingIdentifier<'a> {
+        BindingIdentifier { span, name, symbol_id: Default::default() }
     }
 
     /// Build a [`BindingIdentifier`], and store it in the memory arena.
@@ -1357,14 +1331,11 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: The [`Span`] covering this node
     /// * `name`: The identifier name being bound.
     #[inline]
-    pub fn alloc_binding_identifier<A1>(
+    pub fn alloc_binding_identifier(
         self,
         span: Span,
-        name: A1,
-    ) -> Box<'a, BindingIdentifier<'a>>
-    where
-        A1: Into<Atom<'a>>,
-    {
+        name: Ident<'a>,
+    ) -> Box<'a, BindingIdentifier<'a>> {
         Box::new_in(self.binding_identifier(span, name), self.allocator)
     }
 
@@ -1378,16 +1349,13 @@ impl<'a> AstBuilder<'a> {
     /// * `name`: The identifier name being bound.
     /// * `symbol_id`: Unique identifier for this binding.
     #[inline]
-    pub fn binding_identifier_with_symbol_id<A1>(
+    pub fn binding_identifier_with_symbol_id(
         self,
         span: Span,
-        name: A1,
+        name: Ident<'a>,
         symbol_id: SymbolId,
-    ) -> BindingIdentifier<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
-        BindingIdentifier { span, name: name.into(), symbol_id: Cell::new(Some(symbol_id)) }
+    ) -> BindingIdentifier<'a> {
+        BindingIdentifier { span, name, symbol_id: Cell::new(Some(symbol_id)) }
     }
 
     /// Build a [`BindingIdentifier`] with `symbol_id`, and store it in the memory arena.
@@ -1400,15 +1368,12 @@ impl<'a> AstBuilder<'a> {
     /// * `name`: The identifier name being bound.
     /// * `symbol_id`: Unique identifier for this binding.
     #[inline]
-    pub fn alloc_binding_identifier_with_symbol_id<A1>(
+    pub fn alloc_binding_identifier_with_symbol_id(
         self,
         span: Span,
-        name: A1,
+        name: Ident<'a>,
         symbol_id: SymbolId,
-    ) -> Box<'a, BindingIdentifier<'a>>
-    where
-        A1: Into<Atom<'a>>,
-    {
+    ) -> Box<'a, BindingIdentifier<'a>> {
         Box::new_in(self.binding_identifier_with_symbol_id(span, name, symbol_id), self.allocator)
     }
 
@@ -1418,11 +1383,8 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: The [`Span`] covering this node
     /// * `name`
     #[inline]
-    pub fn label_identifier<A1>(self, span: Span, name: A1) -> LabelIdentifier<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
-        LabelIdentifier { span, name: name.into() }
+    pub fn label_identifier(self, span: Span, name: Ident<'a>) -> LabelIdentifier<'a> {
+        LabelIdentifier { span, name }
     }
 
     /// Build a [`ThisExpression`].
@@ -1660,10 +1622,7 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: The [`Span`] covering this node
     /// * `name`
     #[inline]
-    pub fn property_key_static_identifier<A1>(self, span: Span, name: A1) -> PropertyKey<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
+    pub fn property_key_static_identifier(self, span: Span, name: Ident<'a>) -> PropertyKey<'a> {
         PropertyKey::StaticIdentifier(self.alloc_identifier_name(span, name))
     }
 
@@ -1675,10 +1634,7 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: The [`Span`] covering this node
     /// * `name`
     #[inline]
-    pub fn property_key_private_identifier<A1>(self, span: Span, name: A1) -> PropertyKey<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
+    pub fn property_key_private_identifier(self, span: Span, name: Ident<'a>) -> PropertyKey<'a> {
         PropertyKey::PrivateIdentifier(self.alloc_private_identifier(span, name))
     }
 
@@ -2622,14 +2578,11 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: The [`Span`] covering this node
     /// * `name`: The name of the identifier being referenced.
     #[inline]
-    pub fn simple_assignment_target_assignment_target_identifier<A1>(
+    pub fn simple_assignment_target_assignment_target_identifier(
         self,
         span: Span,
-        name: A1,
-    ) -> SimpleAssignmentTarget<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
+        name: Ident<'a>,
+    ) -> SimpleAssignmentTarget<'a> {
         SimpleAssignmentTarget::AssignmentTargetIdentifier(
             self.alloc_identifier_reference(span, name),
         )
@@ -2644,15 +2597,12 @@ impl<'a> AstBuilder<'a> {
     /// * `name`: The name of the identifier being referenced.
     /// * `reference_id`: Reference ID
     #[inline]
-    pub fn simple_assignment_target_assignment_target_identifier_with_reference_id<A1>(
+    pub fn simple_assignment_target_assignment_target_identifier_with_reference_id(
         self,
         span: Span,
-        name: A1,
+        name: Ident<'a>,
         reference_id: ReferenceId,
-    ) -> SimpleAssignmentTarget<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
+    ) -> SimpleAssignmentTarget<'a> {
         SimpleAssignmentTarget::AssignmentTargetIdentifier(
             self.alloc_identifier_reference_with_reference_id(span, name, reference_id),
         )
@@ -5573,14 +5523,11 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: The [`Span`] covering this node
     /// * `name`: The identifier name being bound.
     #[inline]
-    pub fn binding_pattern_kind_binding_identifier<A1>(
+    pub fn binding_pattern_kind_binding_identifier(
         self,
         span: Span,
-        name: A1,
-    ) -> BindingPatternKind<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
+        name: Ident<'a>,
+    ) -> BindingPatternKind<'a> {
         BindingPatternKind::BindingIdentifier(self.alloc_binding_identifier(span, name))
     }
 
@@ -5593,15 +5540,12 @@ impl<'a> AstBuilder<'a> {
     /// * `name`: The identifier name being bound.
     /// * `symbol_id`: Unique identifier for this binding.
     #[inline]
-    pub fn binding_pattern_kind_binding_identifier_with_symbol_id<A1>(
+    pub fn binding_pattern_kind_binding_identifier_with_symbol_id(
         self,
         span: Span,
-        name: A1,
+        name: Ident<'a>,
         symbol_id: SymbolId,
-    ) -> BindingPatternKind<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
+    ) -> BindingPatternKind<'a> {
         BindingPatternKind::BindingIdentifier(
             self.alloc_binding_identifier_with_symbol_id(span, name, symbol_id),
         )
@@ -7132,11 +7076,8 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: The [`Span`] covering this node
     /// * `name`
     #[inline]
-    pub fn private_identifier<A1>(self, span: Span, name: A1) -> PrivateIdentifier<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
-        PrivateIdentifier { span, name: name.into() }
+    pub fn private_identifier(self, span: Span, name: Ident<'a>) -> PrivateIdentifier<'a> {
+        PrivateIdentifier { span, name }
     }
 
     /// Build a [`PrivateIdentifier`], and store it in the memory arena.
@@ -7148,14 +7089,11 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: The [`Span`] covering this node
     /// * `name`
     #[inline]
-    pub fn alloc_private_identifier<A1>(
+    pub fn alloc_private_identifier(
         self,
         span: Span,
-        name: A1,
-    ) -> Box<'a, PrivateIdentifier<'a>>
-    where
-        A1: Into<Atom<'a>>,
-    {
+        name: Ident<'a>,
+    ) -> Box<'a, PrivateIdentifier<'a>> {
         Box::new_in(self.private_identifier(span, name), self.allocator)
     }
 
@@ -7820,10 +7758,11 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: The [`Span`] covering this node
     /// * `name`
     #[inline]
-    pub fn import_attribute_key_identifier<A1>(self, span: Span, name: A1) -> ImportAttributeKey<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
+    pub fn import_attribute_key_identifier(
+        self,
+        span: Span,
+        name: Ident<'a>,
+    ) -> ImportAttributeKey<'a> {
         ImportAttributeKey::Identifier(self.identifier_name(span, name))
     }
 
@@ -8367,14 +8306,11 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: The [`Span`] covering this node
     /// * `name`
     #[inline]
-    pub fn module_export_name_identifier_name<A1>(
+    pub fn module_export_name_identifier_name(
         self,
         span: Span,
-        name: A1,
-    ) -> ModuleExportName<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
+        name: Ident<'a>,
+    ) -> ModuleExportName<'a> {
         ModuleExportName::IdentifierName(self.identifier_name(span, name))
     }
 
@@ -8384,14 +8320,11 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: The [`Span`] covering this node
     /// * `name`: The name of the identifier being referenced.
     #[inline]
-    pub fn module_export_name_identifier_reference<A1>(
+    pub fn module_export_name_identifier_reference(
         self,
         span: Span,
-        name: A1,
-    ) -> ModuleExportName<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
+        name: Ident<'a>,
+    ) -> ModuleExportName<'a> {
         ModuleExportName::IdentifierReference(self.identifier_reference(span, name))
     }
 
@@ -8402,15 +8335,12 @@ impl<'a> AstBuilder<'a> {
     /// * `name`: The name of the identifier being referenced.
     /// * `reference_id`: Reference ID
     #[inline]
-    pub fn module_export_name_identifier_reference_with_reference_id<A1>(
+    pub fn module_export_name_identifier_reference_with_reference_id(
         self,
         span: Span,
-        name: A1,
+        name: Ident<'a>,
         reference_id: ReferenceId,
-    ) -> ModuleExportName<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
+    ) -> ModuleExportName<'a> {
         ModuleExportName::IdentifierReference(self.identifier_reference_with_reference_id(
             span,
             name,
@@ -8993,10 +8923,7 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: Node location in source code
     /// * `name`: The name of the identifier.
     #[inline]
-    pub fn jsx_element_name_identifier<A1>(self, span: Span, name: A1) -> JSXElementName<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
+    pub fn jsx_element_name_identifier(self, span: Span, name: Ident<'a>) -> JSXElementName<'a> {
         JSXElementName::Identifier(self.alloc_jsx_identifier(span, name))
     }
 
@@ -9008,14 +8935,11 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: The [`Span`] covering this node
     /// * `name`: The name of the identifier being referenced.
     #[inline]
-    pub fn jsx_element_name_identifier_reference<A1>(
+    pub fn jsx_element_name_identifier_reference(
         self,
         span: Span,
-        name: A1,
-    ) -> JSXElementName<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
+        name: Ident<'a>,
+    ) -> JSXElementName<'a> {
         JSXElementName::IdentifierReference(self.alloc_identifier_reference(span, name))
     }
 
@@ -9028,15 +8952,12 @@ impl<'a> AstBuilder<'a> {
     /// * `name`: The name of the identifier being referenced.
     /// * `reference_id`: Reference ID
     #[inline]
-    pub fn jsx_element_name_identifier_reference_with_reference_id<A1>(
+    pub fn jsx_element_name_identifier_reference_with_reference_id(
         self,
         span: Span,
-        name: A1,
+        name: Ident<'a>,
         reference_id: ReferenceId,
-    ) -> JSXElementName<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
+    ) -> JSXElementName<'a> {
         JSXElementName::IdentifierReference(self.alloc_identifier_reference_with_reference_id(
             span,
             name,
@@ -9175,14 +9096,11 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: The [`Span`] covering this node
     /// * `name`: The name of the identifier being referenced.
     #[inline]
-    pub fn jsx_member_expression_object_identifier_reference<A1>(
+    pub fn jsx_member_expression_object_identifier_reference(
         self,
         span: Span,
-        name: A1,
-    ) -> JSXMemberExpressionObject<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
+        name: Ident<'a>,
+    ) -> JSXMemberExpressionObject<'a> {
         JSXMemberExpressionObject::IdentifierReference(self.alloc_identifier_reference(span, name))
     }
 
@@ -9195,15 +9113,12 @@ impl<'a> AstBuilder<'a> {
     /// * `name`: The name of the identifier being referenced.
     /// * `reference_id`: Reference ID
     #[inline]
-    pub fn jsx_member_expression_object_identifier_reference_with_reference_id<A1>(
+    pub fn jsx_member_expression_object_identifier_reference_with_reference_id(
         self,
         span: Span,
-        name: A1,
+        name: Ident<'a>,
         reference_id: ReferenceId,
-    ) -> JSXMemberExpressionObject<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
+    ) -> JSXMemberExpressionObject<'a> {
         JSXMemberExpressionObject::IdentifierReference(
             self.alloc_identifier_reference_with_reference_id(span, name, reference_id),
         )
@@ -9409,10 +9324,11 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: Node location in source code
     /// * `name`: The name of the identifier.
     #[inline]
-    pub fn jsx_attribute_name_identifier<A1>(self, span: Span, name: A1) -> JSXAttributeName<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
+    pub fn jsx_attribute_name_identifier(
+        self,
+        span: Span,
+        name: Ident<'a>,
+    ) -> JSXAttributeName<'a> {
         JSXAttributeName::Identifier(self.alloc_jsx_identifier(span, name))
     }
 
@@ -9564,11 +9480,8 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: Node location in source code
     /// * `name`: The name of the identifier.
     #[inline]
-    pub fn jsx_identifier<A1>(self, span: Span, name: A1) -> JSXIdentifier<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
-        JSXIdentifier { span, name: name.into() }
+    pub fn jsx_identifier(self, span: Span, name: Ident<'a>) -> JSXIdentifier<'a> {
+        JSXIdentifier { span, name }
     }
 
     /// Build a [`JSXIdentifier`], and store it in the memory arena.
@@ -9580,10 +9493,7 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: Node location in source code
     /// * `name`: The name of the identifier.
     #[inline]
-    pub fn alloc_jsx_identifier<A1>(self, span: Span, name: A1) -> Box<'a, JSXIdentifier<'a>>
-    where
-        A1: Into<Atom<'a>>,
-    {
+    pub fn alloc_jsx_identifier(self, span: Span, name: Ident<'a>) -> Box<'a, JSXIdentifier<'a>> {
         Box::new_in(self.jsx_identifier(span, name), self.allocator)
     }
 
@@ -9930,10 +9840,11 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: The [`Span`] covering this node
     /// * `name`
     #[inline]
-    pub fn ts_enum_member_name_identifier<A1>(self, span: Span, name: A1) -> TSEnumMemberName<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
+    pub fn ts_enum_member_name_identifier(
+        self,
+        span: Span,
+        name: Ident<'a>,
+    ) -> TSEnumMemberName<'a> {
         TSEnumMemberName::Identifier(self.alloc_identifier_name(span, name))
     }
 
@@ -11907,10 +11818,7 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: The [`Span`] covering this node
     /// * `name`: The name of the identifier being referenced.
     #[inline]
-    pub fn ts_type_name_identifier_reference<A1>(self, span: Span, name: A1) -> TSTypeName<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
+    pub fn ts_type_name_identifier_reference(self, span: Span, name: Ident<'a>) -> TSTypeName<'a> {
         TSTypeName::IdentifierReference(self.alloc_identifier_reference(span, name))
     }
 
@@ -11923,15 +11831,12 @@ impl<'a> AstBuilder<'a> {
     /// * `name`: The name of the identifier being referenced.
     /// * `reference_id`: Reference ID
     #[inline]
-    pub fn ts_type_name_identifier_reference_with_reference_id<A1>(
+    pub fn ts_type_name_identifier_reference_with_reference_id(
         self,
         span: Span,
-        name: A1,
+        name: Ident<'a>,
         reference_id: ReferenceId,
-    ) -> TSTypeName<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
+    ) -> TSTypeName<'a> {
         TSTypeName::IdentifierReference(self.alloc_identifier_reference_with_reference_id(
             span,
             name,
@@ -13495,14 +13400,11 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: The [`Span`] covering this node
     /// * `name`
     #[inline]
-    pub fn ts_type_predicate_name_identifier<A1>(
+    pub fn ts_type_predicate_name_identifier(
         self,
         span: Span,
-        name: A1,
-    ) -> TSTypePredicateName<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
+        name: Ident<'a>,
+    ) -> TSTypePredicateName<'a> {
         TSTypePredicateName::Identifier(self.alloc_identifier_name(span, name))
     }
 
@@ -13620,14 +13522,11 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: The [`Span`] covering this node
     /// * `name`: The identifier name being bound.
     #[inline]
-    pub fn ts_module_declaration_name_identifier<A1>(
+    pub fn ts_module_declaration_name_identifier(
         self,
         span: Span,
-        name: A1,
-    ) -> TSModuleDeclarationName<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
+        name: Ident<'a>,
+    ) -> TSModuleDeclarationName<'a> {
         TSModuleDeclarationName::Identifier(self.binding_identifier(span, name))
     }
 
@@ -13638,15 +13537,12 @@ impl<'a> AstBuilder<'a> {
     /// * `name`: The identifier name being bound.
     /// * `symbol_id`: Unique identifier for this binding.
     #[inline]
-    pub fn ts_module_declaration_name_identifier_with_symbol_id<A1>(
+    pub fn ts_module_declaration_name_identifier_with_symbol_id(
         self,
         span: Span,
-        name: A1,
+        name: Ident<'a>,
         symbol_id: SymbolId,
-    ) -> TSModuleDeclarationName<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
+    ) -> TSModuleDeclarationName<'a> {
         TSModuleDeclarationName::Identifier(
             self.binding_identifier_with_symbol_id(span, name, symbol_id),
         )
@@ -14113,14 +14009,11 @@ impl<'a> AstBuilder<'a> {
     /// * `span`: The [`Span`] covering this node
     /// * `name`
     #[inline]
-    pub fn ts_import_type_qualifier_identifier<A1>(
+    pub fn ts_import_type_qualifier_identifier(
         self,
         span: Span,
-        name: A1,
-    ) -> TSImportTypeQualifier<'a>
-    where
-        A1: Into<Atom<'a>>,
-    {
+        name: Ident<'a>,
+    ) -> TSImportTypeQualifier<'a> {
         TSImportTypeQualifier::Identifier(self.alloc_identifier_name(span, name))
     }
 
diff --git a/crates/oxc_ast/src/serialize/jsx.rs b/crates/oxc_ast/src/serialize/jsx.rs
index bc5e6fbe6dc03..905fb9cbe586a 100644
--- a/crates/oxc_ast/src/serialize/jsx.rs
+++ b/crates/oxc_ast/src/serialize/jsx.rs
@@ -1,5 +1,6 @@
 use oxc_ast_macros::ast_meta;
 use oxc_estree::{ESTree, JsonSafeString, Serializer, StructSerializer};
+use oxc_span::Ident;
 
 use crate::ast::*;
 
@@ -82,6 +83,6 @@ pub struct JSXElementThisExpression<'b>(pub &'b ThisExpression);
 
 impl ESTree for JSXElementThisExpression<'_> {
     fn serialize<S: Serializer>(&self, serializer: S) {
-        JSXIdentifier { span: self.0.span, name: Atom::from("this") }.serialize(serializer);
+        JSXIdentifier { span: self.0.span, name: Ident::new("this") }.serialize(serializer);
     }
 }
diff --git a/crates/oxc_ast/src/serialize/ts.rs b/crates/oxc_ast/src/serialize/ts.rs
index 77c786c982607..0c5037bbc92ac 100644
--- a/crates/oxc_ast/src/serialize/ts.rs
+++ b/crates/oxc_ast/src/serialize/ts.rs
@@ -1,5 +1,6 @@
 use oxc_ast_macros::ast_meta;
 use oxc_estree::{Concat2, ESTree, JsonSafeString, Serializer, StructSerializer};
+use oxc_span::Ident;
 
 use crate::ast::*;
 
@@ -275,7 +276,7 @@ pub struct TSGlobalDeclarationId<'a, 'b>(pub &'b TSGlobalDeclaration<'a>);
 
 impl ESTree for TSGlobalDeclarationId<'_, '_> {
     fn serialize<S: Serializer>(&self, serializer: S) {
-        let ident = IdentifierName { span: self.0.global_span, name: Atom::from("global") };
+        let ident = IdentifierName { span: self.0.global_span, name: Ident::new("global") };
         ident.serialize(serializer);
     }
 }
diff --git a/crates/oxc_formatter/src/ast_nodes/generated/ast_nodes.rs b/crates/oxc_formatter/src/ast_nodes/generated/ast_nodes.rs
index f06e0408163ab..4bd8d2c0e7e01 100644
--- a/crates/oxc_formatter/src/ast_nodes/generated/ast_nodes.rs
+++ b/crates/oxc_formatter/src/ast_nodes/generated/ast_nodes.rs
@@ -5,7 +5,7 @@ use std::mem::transmute;
 
 use oxc_allocator::Vec;
 use oxc_ast::ast::*;
-use oxc_span::GetSpan;
+use oxc_span::{GetSpan, Ident};
 
 use crate::ast_nodes::AstNode;
 use crate::formatter::{
@@ -1190,7 +1190,7 @@ impl<'a> AstNode<'a, Expression<'a>> {
 
 impl<'a> AstNode<'a, IdentifierName<'a>> {
     #[inline]
-    pub fn name(&self) -> Atom<'a> {
+    pub fn name(&self) -> Ident<'a> {
         self.inner.name
     }
 
@@ -1205,7 +1205,7 @@ impl<'a> AstNode<'a, IdentifierName<'a>> {
 
 impl<'a> AstNode<'a, IdentifierReference<'a>> {
     #[inline]
-    pub fn name(&self) -> Atom<'a> {
+    pub fn name(&self) -> Ident<'a> {
         self.inner.name
     }
 
@@ -1220,7 +1220,7 @@ impl<'a> AstNode<'a, IdentifierReference<'a>> {
 
 impl<'a> AstNode<'a, BindingIdentifier<'a>> {
     #[inline]
-    pub fn name(&self) -> Atom<'a> {
+    pub fn name(&self) -> Ident<'a> {
         self.inner.name
     }
 
@@ -1235,7 +1235,7 @@ impl<'a> AstNode<'a, BindingIdentifier<'a>> {
 
 impl<'a> AstNode<'a, LabelIdentifier<'a>> {
     #[inline]
-    pub fn name(&self) -> Atom<'a> {
+    pub fn name(&self) -> Ident<'a> {
         self.inner.name
     }
 
@@ -4762,7 +4762,7 @@ impl<'a> AstNode<'a, PropertyDefinition<'a>> {
 
 impl<'a> AstNode<'a, PrivateIdentifier<'a>> {
     #[inline]
-    pub fn name(&self) -> Atom<'a> {
+    pub fn name(&self) -> Ident<'a> {
         self.inner.name
     }
 
@@ -6212,7 +6212,7 @@ impl<'a> AstNode<'a, JSXAttributeValue<'a>> {
 
 impl<'a> AstNode<'a, JSXIdentifier<'a>> {
     #[inline]
-    pub fn name(&self) -> Atom<'a> {
+    pub fn name(&self) -> Ident<'a> {
         self.inner.name
     }
 
diff --git a/crates/oxc_formatter/src/utils/member_chain/mod.rs b/crates/oxc_formatter/src/utils/member_chain/mod.rs
index 4dfe3d5180411..e6f5c5f724d8b 100644
--- a/crates/oxc_formatter/src/utils/member_chain/mod.rs
+++ b/crates/oxc_formatter/src/utils/member_chain/mod.rs
@@ -391,8 +391,8 @@ pub fn is_member_call_chain<'a>(
     MemberChain::from_call_expression(expression, f).tail.is_member_call_chain()
 }
 
-fn has_short_name(name: &Atom, tab_width: u8) -> bool {
-    name.as_str().len() <= tab_width as usize
+fn has_short_name(name: &str, tab_width: u8) -> bool {
+    name.len() <= tab_width as usize
 }
 
 fn chain_members_iter<'a, 'b>(
diff --git a/crates/oxc_isolated_declarations/src/class.rs b/crates/oxc_isolated_declarations/src/class.rs
index 0ce862b1fdffa..f2aba514ce6ae 100644
--- a/crates/oxc_isolated_declarations/src/class.rs
+++ b/crates/oxc_isolated_declarations/src/class.rs
@@ -1,6 +1,6 @@
 use oxc_allocator::{Allocator, Box as ArenaBox, CloneIn, Vec as ArenaVec};
 use oxc_ast::{NONE, ast::*};
-use oxc_span::{ContentEq, GetSpan, SPAN};
+use oxc_span::{ContentEq, GetSpan, Ident, SPAN};
 
 use crate::{
     IsolatedDeclarations,
@@ -270,7 +270,7 @@ impl<'a> IsolatedDeclarations<'a> {
             }
             MethodDefinitionKind::Set => {
                 let params = self.create_formal_parameters(
-                    self.ast.binding_pattern_kind_binding_identifier(SPAN, "value"),
+                    self.ast.binding_pattern_kind_binding_identifier(SPAN, Ident::new("value")),
                 );
                 self.transform_class_method_definition(method, params, None)
             }
@@ -449,7 +449,10 @@ impl<'a> IsolatedDeclarations<'a> {
                             let params = &method.value.params;
                             if params.items.is_empty() {
                                 self.create_formal_parameters(
-                                    self.ast.binding_pattern_kind_binding_identifier(SPAN, "value"),
+                                    self.ast.binding_pattern_kind_binding_identifier(
+                                        SPAN,
+                                        Ident::new("value"),
+                                    ),
                                 )
                             } else {
                                 let mut params = params.clone_in(self.ast.allocator);
@@ -606,7 +609,7 @@ impl<'a> IsolatedDeclarations<'a> {
             // <https://github.com/microsoft/TypeScript/blob/64d2eeea7b9c7f1a79edf42cb99f302535136a2e/src/compiler/transformers/declarations.ts#L1699-L1709>
             // When the class has at least one private identifier, create a unique constant identifier to retain the nominal typing behavior
             // Prevents other classes with the same public members from being used in place of the current class
-            let ident = self.ast.property_key_private_identifier(SPAN, "private");
+            let ident = self.ast.property_key_private_identifier(SPAN, Ident::new("private"));
             let r#type = PropertyDefinitionType::PropertyDefinition;
             let decorators = self.ast.vec();
             let element = self.ast.class_element_property_definition(
diff --git a/crates/oxc_isolated_declarations/src/declaration.rs b/crates/oxc_isolated_declarations/src/declaration.rs
index be23742cb9145..7738c0342d783 100644
--- a/crates/oxc_isolated_declarations/src/declaration.rs
+++ b/crates/oxc_isolated_declarations/src/declaration.rs
@@ -48,7 +48,7 @@ impl<'a> IsolatedDeclarations<'a> {
     ) -> Option<VariableDeclarator<'a>> {
         if decl.id.kind.is_destructuring_pattern() {
             decl.id.bound_names(&mut |id| {
-                if !check_binding || self.scope.has_value_reference(&id.name) {
+                if !check_binding || self.scope.has_value_reference(id.name) {
                     self.error(binding_element_export(id.span));
                 }
             });
@@ -57,7 +57,7 @@ impl<'a> IsolatedDeclarations<'a> {
 
         if check_binding
             && let Some(name) = decl.id.get_identifier_name()
-            && !self.scope.has_value_reference(&name)
+            && !self.scope.has_value_reference(name)
         {
             return None;
         }
@@ -160,7 +160,7 @@ impl<'a> IsolatedDeclarations<'a> {
         match decl {
             Declaration::FunctionDeclaration(func) => {
                 let needs_transform = !check_binding
-                    || func.id.as_ref().is_some_and(|id| self.scope.has_value_reference(&id.name));
+                    || func.id.as_ref().is_some_and(|id| self.scope.has_value_reference(id.name));
                 needs_transform
                     .then(|| Declaration::FunctionDeclaration(self.transform_function(func, None)))
             }
@@ -169,12 +169,12 @@ impl<'a> IsolatedDeclarations<'a> {
                 .map(Declaration::VariableDeclaration),
             Declaration::ClassDeclaration(decl) => {
                 let needs_transform = !check_binding
-                    || decl.id.as_ref().is_some_and(|id| self.scope.has_reference(&id.name));
+                    || decl.id.as_ref().is_some_and(|id| self.scope.has_reference(id.name));
                 needs_transform
                     .then(|| Declaration::ClassDeclaration(self.transform_class(decl, None)))
             }
             Declaration::TSTypeAliasDeclaration(alias_decl) => {
-                if !check_binding || self.scope.has_reference(&alias_decl.id.name) {
+                if !check_binding || self.scope.has_reference(alias_decl.id.name) {
                     let mut decl = decl.clone_in(self.ast.allocator);
                     self.visit_declaration(&mut decl);
                     Some(decl)
@@ -183,7 +183,7 @@ impl<'a> IsolatedDeclarations<'a> {
                 }
             }
             Declaration::TSInterfaceDeclaration(interface_decl) => {
-                if !check_binding || self.scope.has_reference(&interface_decl.id.name) {
+                if !check_binding || self.scope.has_reference(interface_decl.id.name) {
                     let mut decl = decl.clone_in(self.ast.allocator);
                     self.visit_declaration(&mut decl);
                     Some(decl)
@@ -192,7 +192,7 @@ impl<'a> IsolatedDeclarations<'a> {
                 }
             }
             Declaration::TSEnumDeclaration(enum_decl) => {
-                if !check_binding || self.scope.has_reference(&enum_decl.id.name) {
+                if !check_binding || self.scope.has_reference(enum_decl.id.name) {
                     Some(self.transform_ts_enum_declaration(enum_decl))
                 } else {
                     None
@@ -203,7 +203,7 @@ impl<'a> IsolatedDeclarations<'a> {
                     || matches!(
                         &decl.id,
                         TSModuleDeclarationName::Identifier(ident)
-                            if self.scope.has_reference(&ident.name)
+                            if self.scope.has_reference(ident.name)
                     )
                 {
                     Some(Declaration::TSModuleDeclaration(
@@ -217,7 +217,7 @@ impl<'a> IsolatedDeclarations<'a> {
                 Some(Declaration::TSGlobalDeclaration(decl.clone_in(self.ast.allocator)))
             }
             Declaration::TSImportEqualsDeclaration(decl) => {
-                if !check_binding || self.scope.has_reference(&decl.id.name) {
+                if !check_binding || self.scope.has_reference(decl.id.name) {
                     Some(Declaration::TSImportEqualsDeclaration(decl.clone_in(self.ast.allocator)))
                 } else {
                     None
diff --git a/crates/oxc_isolated_declarations/src/enum.rs b/crates/oxc_isolated_declarations/src/enum.rs
index 23c8b9792b64b..23d25ac060f04 100644
--- a/crates/oxc_isolated_declarations/src/enum.rs
+++ b/crates/oxc_isolated_declarations/src/enum.rs
@@ -1,9 +1,7 @@
-use rustc_hash::FxHashMap;
-
 use oxc_allocator::CloneIn;
 use oxc_ast::ast::*;
 use oxc_ecmascript::{ToInt32, ToUint32};
-use oxc_span::{Atom, GetSpan, SPAN};
+use oxc_span::{GetSpan, Ident, IdentHashMap, SPAN};
 use oxc_syntax::{
     number::{NumberBase, ToJsString},
     operator::{BinaryOperator, UnaryOperator},
@@ -21,7 +19,7 @@ impl<'a> IsolatedDeclarations<'a> {
     pub fn transform_ts_enum_declaration(&self, decl: &TSEnumDeclaration<'a>) -> Declaration<'a> {
         let mut members = self.ast.vec();
         let mut prev_initializer_value = Some(ConstantValue::Number(-1.0));
-        let mut prev_members = FxHashMap::default();
+        let mut prev_members = IdentHashMap::default();
         for member in &decl.body.members {
             let value = if let Some(initializer) = &member.initializer {
                 let computed_value =
@@ -54,7 +52,7 @@ impl<'a> IsolatedDeclarations<'a> {
 
                         // Infinity
                         let expr = if v.is_infinite() {
-                            self.ast.expression_identifier(SPAN, "Infinity")
+                            self.ast.expression_identifier(SPAN, Ident::new("Infinity"))
                         } else {
                             let value = if is_negative { -v } else { v };
                             self.ast.expression_numeric_literal(
@@ -95,7 +93,7 @@ impl<'a> IsolatedDeclarations<'a> {
         &self,
         expr: &Expression<'a>,
         enum_name: &str,
-        prev_members: &FxHashMap<Atom<'a>, ConstantValue>,
+        prev_members: &IdentHashMap<'a, ConstantValue>,
     ) -> Option<ConstantValue> {
         self.evaluate(expr, enum_name, prev_members)
     }
@@ -103,7 +101,7 @@ impl<'a> IsolatedDeclarations<'a> {
     fn evaluate_ref(
         expr: &Expression<'a>,
         enum_name: &str,
-        prev_members: &FxHashMap<Atom<'a>, ConstantValue>,
+        prev_members: &IdentHashMap<'a, ConstantValue>,
     ) -> Option<ConstantValue> {
         match expr {
             match_member_expression!(Expression) => {
@@ -111,7 +109,9 @@ impl<'a> IsolatedDeclarations<'a> {
                 let Expression::Identifier(ident) = expr.object() else { return None };
                 if ident.name == enum_name {
                     let property = expr.static_property_name()?;
-                    prev_members.get(property).cloned()
+                    // TODO: do we need to convert to Ident here?
+                    let property = Ident::from(property);
+                    prev_members.get(&property).cloned()
                 } else {
                     None
                 }
@@ -137,7 +137,7 @@ impl<'a> IsolatedDeclarations<'a> {
         &self,
         expr: &Expression<'a>,
         enum_name: &str,
-        prev_members: &FxHashMap<Atom<'a>, ConstantValue>,
+        prev_members: &IdentHashMap<'a, ConstantValue>,
     ) -> Option<ConstantValue> {
         match expr {
             Expression::Identifier(_)
@@ -172,7 +172,7 @@ impl<'a> IsolatedDeclarations<'a> {
         &self,
         expr: &BinaryExpression<'a>,
         enum_name: &str,
-        prev_members: &FxHashMap<Atom<'a>, ConstantValue>,
+        prev_members: &IdentHashMap<'a, ConstantValue>,
     ) -> Option<ConstantValue> {
         let left = self.evaluate(&expr.left, enum_name, prev_members)?;
         let right = self.evaluate(&expr.right, enum_name, prev_members)?;
@@ -237,7 +237,7 @@ impl<'a> IsolatedDeclarations<'a> {
         &self,
         expr: &UnaryExpression<'a>,
         enum_name: &str,
-        prev_members: &FxHashMap<Atom<'a>, ConstantValue>,
+        prev_members: &IdentHashMap<'a, ConstantValue>,
     ) -> Option<ConstantValue> {
         let value = self.evaluate(&expr.argument, enum_name, prev_members)?;
 
diff --git a/crates/oxc_isolated_declarations/src/lib.rs b/crates/oxc_isolated_declarations/src/lib.rs
index 96c5ef9636166..3a61e81fefd71 100644
--- a/crates/oxc_isolated_declarations/src/lib.rs
+++ b/crates/oxc_isolated_declarations/src/lib.rs
@@ -13,7 +13,7 @@ use oxc_allocator::{Allocator, CloneIn, Vec as ArenaVec};
 use oxc_ast::{AstBuilder, NONE, ast::*};
 use oxc_ast_visit::Visit;
 use oxc_diagnostics::OxcDiagnostic;
-use oxc_span::{Atom, GetSpan, SPAN, SourceType};
+use oxc_span::{GetSpan, Ident, SPAN, SourceType};
 
 use crate::{diagnostics::function_with_assigning_properties, scope::ScopeTree};
 
@@ -439,7 +439,7 @@ impl<'a> IsolatedDeclarations<'a> {
     }
 
     fn remove_function_overloads_implementation(stmts: &mut Vec<&Statement<'a>>) {
-        let mut last_function_name: Option<Atom<'a>> = None;
+        let mut last_function_name: Option<Ident<'a>> = None;
         let mut is_export_default_function_overloads = false;
 
         stmts.retain(move |&stmt| match stmt {
@@ -506,7 +506,8 @@ impl<'a> IsolatedDeclarations<'a> {
     fn get_assignable_properties_for_namespaces(
         stmts: &'a ArenaVec<'a, Statement<'a>>,
     ) -> FxHashMap<&'a str, FxHashSet<Atom<'a>>> {
-        let mut assignable_properties_for_namespace = FxHashMap::<&str, FxHashSet<Atom>>::default();
+        let mut assignable_properties_for_namespace =
+            FxHashMap::<&str, FxHashSet<Atom<'a>>>::default();
         for stmt in stmts {
             let decl = match stmt {
                 Statement::ExportNamedDeclaration(decl) => {
@@ -536,7 +537,7 @@ impl<'a> IsolatedDeclarations<'a> {
                                 assignable_properties_for_namespace
                                     .entry(&ident.name)
                                     .or_default()
-                                    .insert(name);
+                                    .insert(name.as_atom());
                             }
                         }
                     }
@@ -545,7 +546,7 @@ impl<'a> IsolatedDeclarations<'a> {
                             assignable_properties_for_namespace
                                 .entry(&ident.name)
                                 .or_default()
-                                .insert(name);
+                                .insert(name.as_atom());
                         }
                     }
                     Some(Declaration::ClassDeclaration(cls)) => {
@@ -553,14 +554,14 @@ impl<'a> IsolatedDeclarations<'a> {
                             assignable_properties_for_namespace
                                 .entry(&ident.name)
                                 .or_default()
-                                .insert(id.name);
+                                .insert(id.name.as_atom());
                         }
                     }
                     Some(Declaration::TSEnumDeclaration(decl)) => {
                         assignable_properties_for_namespace
                             .entry(&ident.name)
                             .or_default()
-                            .insert(decl.id.name);
+                            .insert(decl.id.name.as_atom());
                     }
                     _ => {}
                 }
@@ -608,7 +609,7 @@ impl<'a> IsolatedDeclarations<'a> {
                 Statement::FunctionDeclaration(func) => {
                     if func.body.is_some()
                         && let Some(name) = func.name()
-                        && self.scope.has_value_reference(&name)
+                        && self.scope.has_value_reference(name)
                     {
                         can_expando_function_names.insert(name);
                     }
@@ -618,7 +619,7 @@ impl<'a> IsolatedDeclarations<'a> {
                         if declarator.id.type_annotation.is_none()
                             && declarator.init.as_ref().is_some_and(Expression::is_function)
                             && let Some(name) = declarator.id.get_identifier_name()
-                            && self.scope.has_value_reference(&name)
+                            && self.scope.has_value_reference(name)
                         {
                             can_expando_function_names.insert(name);
                         }
@@ -633,7 +634,7 @@ impl<'a> IsolatedDeclarations<'a> {
                         && !assignable_properties_for_namespace
                             .get(&ident.name.as_str())
                             .is_some_and(|properties| {
-                                properties.contains(&static_member_expr.property.name)
+                                properties.contains(&static_member_expr.property.name.as_atom())
                             })
                     {
                         self.error(function_with_assigning_properties(static_member_expr.span));
diff --git a/crates/oxc_isolated_declarations/src/module.rs b/crates/oxc_isolated_declarations/src/module.rs
index f8af0ef028a58..1af29772a4512 100644
--- a/crates/oxc_isolated_declarations/src/module.rs
+++ b/crates/oxc_isolated_declarations/src/module.rs
@@ -1,6 +1,6 @@
 use oxc_allocator::{Box as ArenaBox, CloneIn, TakeIn, Vec as ArenaVec};
 use oxc_ast::{NONE, ast::*};
-use oxc_span::{Atom, GetSpan, SPAN};
+use oxc_span::{GetSpan, Ident, SPAN};
 
 use crate::{IsolatedDeclarations, diagnostics::default_export_inferred};
 
@@ -21,11 +21,11 @@ impl<'a> IsolatedDeclarations<'a> {
         ))
     }
 
-    pub(crate) fn create_unique_name(&self, name: &str) -> Atom<'a> {
-        let mut binding = self.ast.atom(name);
+    pub(crate) fn create_unique_name(&self, name: &str) -> Ident<'a> {
+        let mut binding = self.ast.ident(name);
         let mut i = 1;
-        while self.scope.has_reference(&binding) {
-            binding = self.ast.atom(format!("{name}_{i}").as_str());
+        while self.scope.has_reference(binding) {
+            binding = self.ast.ident(format!("{name}_{i}").as_str());
             i += 1;
         }
         binding
@@ -141,13 +141,13 @@ impl<'a> IsolatedDeclarations<'a> {
         specifiers.iter().for_each(|specifier| {
             let is_referenced = match specifier {
                 ImportDeclarationSpecifier::ImportSpecifier(specifier) => {
-                    self.scope.has_reference(&specifier.local.name)
+                    self.scope.has_reference(specifier.local.name)
                 }
                 ImportDeclarationSpecifier::ImportDefaultSpecifier(specifier) => {
-                    self.scope.has_reference(&specifier.local.name)
+                    self.scope.has_reference(specifier.local.name)
                 }
-                ImportDeclarationSpecifier::ImportNamespaceSpecifier(_) => {
-                    self.scope.has_reference(&specifier.name())
+                ImportDeclarationSpecifier::ImportNamespaceSpecifier(specifier) => {
+                    self.scope.has_reference(specifier.local.name)
                 }
             };
             if is_referenced {
diff --git a/crates/oxc_isolated_declarations/src/return_type.rs b/crates/oxc_isolated_declarations/src/return_type.rs
index c8bfca4245bee..b28a9abfa880d 100644
--- a/crates/oxc_isolated_declarations/src/return_type.rs
+++ b/crates/oxc_isolated_declarations/src/return_type.rs
@@ -9,7 +9,7 @@ use oxc_ast::{
     },
 };
 use oxc_ast_visit::Visit;
-use oxc_span::{Atom, GetSpan, SPAN};
+use oxc_span::{GetSpan, Ident, SPAN};
 use oxc_syntax::scope::{ScopeFlags, ScopeId};
 
 use crate::{IsolatedDeclarations, diagnostics::type_containing_private_name};
@@ -41,8 +41,8 @@ use crate::{IsolatedDeclarations, diagnostics::type_containing_private_name};
 pub struct FunctionReturnType<'a> {
     ast: AstBuilder<'a>,
     return_expression: Option<Option<Expression<'a>>>,
-    value_bindings: Vec<Atom<'a>>,
-    type_bindings: Vec<Atom<'a>>,
+    value_bindings: Vec<Ident<'a>>,
+    type_bindings: Vec<Ident<'a>>,
     return_statement_count: u8,
     scope_depth: u32,
 }
diff --git a/crates/oxc_isolated_declarations/src/scope.rs b/crates/oxc_isolated_declarations/src/scope.rs
index 84cef4a5d622f..20988f7e35c6b 100644
--- a/crates/oxc_isolated_declarations/src/scope.rs
+++ b/crates/oxc_isolated_declarations/src/scope.rs
@@ -1,11 +1,10 @@
 use std::cell::Cell;
 
 use bitflags::bitflags;
-use rustc_hash::FxHashMap;
 
 use oxc_ast::ast::*;
 use oxc_ast_visit::{Visit, walk::*};
-use oxc_span::Atom;
+use oxc_span::{Ident, IdentHashMap};
 use oxc_syntax::scope::{ScopeFlags, ScopeId};
 
 bitflags! {
@@ -20,14 +19,14 @@ bitflags! {
 /// Declaration scope.
 #[derive(Debug)]
 struct Scope<'a> {
-    bindings: FxHashMap<Atom<'a>, KindFlags>,
-    references: FxHashMap<Atom<'a>, KindFlags>,
+    bindings: IdentHashMap<'a, KindFlags>,
+    references: IdentHashMap<'a, KindFlags>,
     flags: ScopeFlags,
 }
 
 impl Scope<'_> {
     fn new(flags: ScopeFlags) -> Self {
-        Self { bindings: FxHashMap::default(), references: FxHashMap::default(), flags }
+        Self { bindings: IdentHashMap::default(), references: IdentHashMap::default(), flags }
     }
 }
 
@@ -48,23 +47,23 @@ impl<'a> ScopeTree<'a> {
         scope.flags.contains(ScopeFlags::TsModuleBlock)
     }
 
-    pub fn has_reference(&self, name: &str) -> bool {
+    pub fn has_reference(&self, name: Ident) -> bool {
         let scope = self.levels.last().unwrap();
-        scope.references.contains_key(name)
+        scope.references.contains_key(&name)
     }
 
     /// Check if the current scope has a value reference for the given name.
-    pub fn has_value_reference(&self, name: &str) -> bool {
+    pub fn has_value_reference(&self, name: Ident) -> bool {
         let scope = self.levels.last().unwrap();
-        scope.references.get(name).iter().any(|flags| flags.contains(KindFlags::Value))
+        scope.references.get(&name).iter().any(|flags| flags.contains(KindFlags::Value))
     }
 
-    fn add_binding(&mut self, name: Atom<'a>, flags: KindFlags) {
+    fn add_binding(&mut self, name: Ident<'a>, flags: KindFlags) {
         let scope = self.levels.last_mut().unwrap();
         scope.bindings.insert(name, flags);
     }
 
-    fn add_reference(&mut self, name: Atom<'a>, flags: KindFlags) {
+    fn add_reference(&mut self, name: Ident<'a>, flags: KindFlags) {
         let scope = self.levels.last_mut().unwrap();
         scope.references.entry(name).and_modify(|f| *f |= flags).or_insert(flags);
     }
diff --git a/crates/oxc_isolated_declarations/src/types.rs b/crates/oxc_isolated_declarations/src/types.rs
index b4dfcdff615f8..ebe2102054bed 100644
--- a/crates/oxc_isolated_declarations/src/types.rs
+++ b/crates/oxc_isolated_declarations/src/types.rs
@@ -7,7 +7,7 @@ use oxc_ast::{
         TSMethodSignatureKind, TSTupleElement, TSType, TSTypeOperatorOperator,
     },
 };
-use oxc_span::{ContentEq, GetSpan, SPAN, Span};
+use oxc_span::{ContentEq, GetSpan, Ident, SPAN, Span};
 use oxc_syntax::identifier::is_identifier_name;
 
 use crate::{
@@ -71,13 +71,16 @@ impl<'a> IsolatedDeclarations<'a> {
         match key {
             // ["string"] -> string
             PropertyKey::StringLiteral(literal) if is_identifier_name(&literal.value) => {
-                self.ast.property_key_static_identifier(literal.span, literal.value.as_str())
+                self.ast.property_key_static_identifier(literal.span, Ident::from(literal.value))
             }
             // [`string`] -> string
             PropertyKey::TemplateLiteral(literal)
                 if is_identifier_name(&literal.quasis[0].value.raw) =>
             {
-                self.ast.property_key_static_identifier(literal.span, literal.quasis[0].value.raw)
+                self.ast.property_key_static_identifier(
+                    literal.span,
+                    Ident::from(literal.quasis[0].value.raw),
+                )
             }
             // [100] -> 100
             // number literal will be cloned as-is
diff --git a/crates/oxc_linter/src/rules/eslint/block_scoped_var.rs b/crates/oxc_linter/src/rules/eslint/block_scoped_var.rs
index ae65abafcfb68..8ee1325b7a75a 100644
--- a/crates/oxc_linter/src/rules/eslint/block_scoped_var.rs
+++ b/crates/oxc_linter/src/rules/eslint/block_scoped_var.rs
@@ -5,7 +5,7 @@ use oxc_ast::{
 };
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{GetSpan, Span};
+use oxc_span::{GetSpan, Ident, Span};
 use oxc_syntax::{scope::ScopeId, symbol::SymbolId};
 
 fn redeclaration_diagnostic(decl_span: Span, redeclare_span: Span, name: &str) -> OxcDiagnostic {
@@ -199,7 +199,7 @@ fn run_for_declaration(
     // e.g. "var [a, b] = [1, 2]"
     for ident in pattern.get_binding_identifiers() {
         let name = ident.name.as_str();
-        let Some(symbol) = ctx.scoping().find_binding(node.scope_id(), name) else {
+        let Some(symbol) = ctx.scoping().find_binding(node.scope_id(), &Ident::from(name)) else {
             continue;
         };
 
diff --git a/crates/oxc_linter/src/rules/eslint/func_names.rs b/crates/oxc_linter/src/rules/eslint/func_names.rs
index 77cbb1bcf4013..9260dcfcdf802 100644
--- a/crates/oxc_linter/src/rules/eslint/func_names.rs
+++ b/crates/oxc_linter/src/rules/eslint/func_names.rs
@@ -10,7 +10,7 @@ use oxc_ast::{
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::NodeId;
-use oxc_span::{Atom, GetSpan, Span};
+use oxc_span::{GetSpan, Ident, Span};
 use oxc_syntax::{identifier::is_identifier_name, keyword::is_reserved_keyword_or_global_object};
 
 use crate::{
@@ -264,7 +264,7 @@ fn is_recursive_function(func: &Function, func_name: &str, ctx: &LintContext) ->
         return false;
     };
 
-    if let Some(binding) = ctx.scoping().find_binding(func_scope_id, func_name) {
+    if let Some(binding) = ctx.scoping().find_binding(func_scope_id, &Ident::from(func_name)) {
         return ctx.semantic().symbol_references(binding).any(|reference| {
             let parent = ctx.nodes().parent_node(reference.node_id());
             // Check if this reference is the callee of a call expression (direct recursive call)
@@ -431,7 +431,7 @@ fn is_invalid_function(
 
 /// Returns whether it's safe to insert a function name without breaking shadowing rules
 fn can_safely_apply_fix(func: &Function, name: &str, ctx: &LintContext) -> bool {
-    !ctx.scoping().find_binding(func.scope_id(), name).is_some_and(|shadowed_var| {
+    !ctx.scoping().find_binding(func.scope_id(), &Ident::from(name)).is_some_and(|shadowed_var| {
         ctx.semantic().symbol_references(shadowed_var).any(|reference| {
             func.span.contains_inclusive(ctx.nodes().get_node(reference.node_id()).kind().span())
         })
@@ -468,7 +468,7 @@ fn guess_function_name<'a>(ctx: &LintContext<'a>, node_id: NodeId) -> Option<Cow
                     .id
                     .get_identifier_name()
                     .as_ref()
-                    .map(Atom::as_str)
+                    .map(|ident| ident.as_str())
                     .filter(|name| is_valid_identifier_name(name))
                     .map(Cow::Borrowed);
             }
diff --git a/crates/oxc_linter/src/rules/eslint/no_alert.rs b/crates/oxc_linter/src/rules/eslint/no_alert.rs
index 9fb1505a90ef3..44e8f2721e31f 100644
--- a/crates/oxc_linter/src/rules/eslint/no_alert.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_alert.rs
@@ -2,7 +2,7 @@ use oxc_ast::{AstKind, ast::Expression};
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::ScopeId;
-use oxc_span::{GetSpan, Span};
+use oxc_span::{GetSpan, Ident, Span};
 
 use crate::{AstNode, context::LintContext, rule::Rule};
 
@@ -79,13 +79,13 @@ fn is_global_this_ref_or_global_window<'a>(
     if ctx.is_reference_to_global_variable(ident)
         && (expr.is_specific_id(GLOBAL_WINDOW) || (expr.is_specific_id(GLOBAL_THIS)))
     {
-        return !is_shadowed(scope_id, ident.name.as_str(), ctx);
+        return !is_shadowed(scope_id, &ident.name, ctx);
     }
 
     false
 }
 
-fn is_shadowed<'a>(scope_id: ScopeId, name: &'a str, ctx: &LintContext<'a>) -> bool {
+fn is_shadowed(scope_id: ScopeId, name: &Ident, ctx: &LintContext) -> bool {
     ctx.scoping().find_binding(scope_id, name).is_some()
 }
 
@@ -99,8 +99,9 @@ impl Rule for NoAlert {
         let callee = &call_expr.callee;
 
         if let Expression::Identifier(ident) = callee {
-            let name = ident.name.as_str();
-            if !is_shadowed(scope_id, name, ctx) && is_prohibited_identifier(name) {
+            if !is_shadowed(scope_id, &ident.name, ctx)
+                && is_prohibited_identifier(ident.name.as_str())
+            {
                 return ctx.diagnostic(no_alert_diagnostic(ident.span));
             }
 
diff --git a/crates/oxc_linter/src/rules/eslint/no_global_assign.rs b/crates/oxc_linter/src/rules/eslint/no_global_assign.rs
index 436a14c047763..d97069f82a243 100644
--- a/crates/oxc_linter/src/rules/eslint/no_global_assign.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_global_assign.rs
@@ -68,7 +68,7 @@ impl Rule for NoGlobalAssign {
             for &reference_id in reference_id_list {
                 let reference = symbol_table.get_reference(reference_id);
                 if reference.is_write()
-                    && !self.exceptions.iter().any(|n| n == name)
+                    && !self.exceptions.iter().any(|n| n.as_str() == name.as_str())
                     && ctx
                         .get_global_variable_value(name)
                         .is_some_and(|global| global == GlobalValue::Readonly)
diff --git a/crates/oxc_linter/src/rules/eslint/no_unused_vars/fixers/fix_vars.rs b/crates/oxc_linter/src/rules/eslint/no_unused_vars/fixers/fix_vars.rs
index c0f54aaf18b36..d4cbd1cdd1875 100644
--- a/crates/oxc_linter/src/rules/eslint/no_unused_vars/fixers/fix_vars.rs
+++ b/crates/oxc_linter/src/rules/eslint/no_unused_vars/fixers/fix_vars.rs
@@ -138,7 +138,7 @@ impl NoUnusedVars {
         let scope_id = symbol.scope_id();
         let mut i = 0;
         let mut new_name = ignored_name.clone();
-        while scopes.scope_has_binding(scope_id, &new_name) {
+        while scopes.scope_has_binding(scope_id, &oxc_span::Ident::from(new_name.as_str())) {
             new_name = format!("{ignored_name}{i}");
             i += 1;
         }
diff --git a/crates/oxc_linter/src/rules/eslint/prefer_destructuring.rs b/crates/oxc_linter/src/rules/eslint/prefer_destructuring.rs
index 7e9d1502f16ff..8073ac5e5a840 100644
--- a/crates/oxc_linter/src/rules/eslint/prefer_destructuring.rs
+++ b/crates/oxc_linter/src/rules/eslint/prefer_destructuring.rs
@@ -4,7 +4,7 @@ use oxc_ast::{
 };
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{GetSpan, Span};
+use oxc_span::{GetSpan, Ident, Span};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -186,7 +186,7 @@ impl Rule for PreferDestructuring {
                     }
                     let name =
                         if matches!(declarator.id.kind, BindingPatternKind::BindingIdentifier(_)) {
-                            declarator.id.get_identifier_name().map(|v| v.as_str())
+                            declarator.id.get_identifier_name().map(Ident::as_str)
                         } else {
                             None
                         };
diff --git a/crates/oxc_linter/src/rules/eslint/prefer_object_has_own.rs b/crates/oxc_linter/src/rules/eslint/prefer_object_has_own.rs
index 5efdeddc2db0e..3813a0bb84115 100644
--- a/crates/oxc_linter/src/rules/eslint/prefer_object_has_own.rs
+++ b/crates/oxc_linter/src/rules/eslint/prefer_object_has_own.rs
@@ -75,7 +75,8 @@ impl Rule for PreferObjectHasOwn {
 
         let object_property_name = object.static_property_name();
         let is_object = has_left_hand_object(object);
-        let is_global_scope = ctx.scoping().find_binding(node.scope_id(), "Object").is_none();
+        let is_global_scope =
+            ctx.scoping().find_binding(node.scope_id(), &oxc_span::Ident::new("Object")).is_none();
 
         if is_method_call(call_expr, None, Some(&["call"]), Some(2), Some(2))
             && object_property_name == Some("hasOwnProperty")
diff --git a/crates/oxc_linter/src/rules/eslint/prefer_rest_params.rs b/crates/oxc_linter/src/rules/eslint/prefer_rest_params.rs
index 7e2a1fc2c8029..52e1262cc1339 100644
--- a/crates/oxc_linter/src/rules/eslint/prefer_rest_params.rs
+++ b/crates/oxc_linter/src/rules/eslint/prefer_rest_params.rs
@@ -73,7 +73,8 @@ impl Rule for PreferRestParams {
             {
                 return;
             }
-            let binding = ctx.scoping().find_binding(node.scope_id(), "arguments");
+            let binding =
+                ctx.scoping().find_binding(node.scope_id(), &oxc_span::Ident::new("arguments"));
             if binding.is_none() {
                 ctx.diagnostic(prefer_rest_params_diagnostic(node.span()));
             }
diff --git a/crates/oxc_linter/src/rules/import/namespace.rs b/crates/oxc_linter/src/rules/import/namespace.rs
index a4cd7957df7e6..fa2a6331e1d4f 100644
--- a/crates/oxc_linter/src/rules/import/namespace.rs
+++ b/crates/oxc_linter/src/rules/import/namespace.rs
@@ -7,7 +7,7 @@ use oxc_ast::{
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::AstNode;
-use oxc_span::{GetSpan, Span};
+use oxc_span::{GetSpan, Ident, Span};
 use schemars::JsonSchema;
 use serde::Deserialize;
 
@@ -160,7 +160,9 @@ impl Rule for Namespace {
                 return;
             }
 
-            let Some(symbol_id) = ctx.scoping().get_root_binding(entry.local_name.name()) else {
+            let Some(symbol_id) =
+                ctx.scoping().get_root_binding(&Ident::from(entry.local_name.name()))
+            else {
                 return;
             };
 
diff --git a/crates/oxc_linter/src/rules/import/no_commonjs.rs b/crates/oxc_linter/src/rules/import/no_commonjs.rs
index 33201ad6a568f..551f5e6dc88ea 100644
--- a/crates/oxc_linter/src/rules/import/no_commonjs.rs
+++ b/crates/oxc_linter/src/rules/import/no_commonjs.rs
@@ -4,7 +4,7 @@ use oxc_ast::{
 };
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{GetSpan, Span};
+use oxc_span::{GetSpan, Ident, Span};
 use schemars::JsonSchema;
 use serde::Deserialize;
 
@@ -235,7 +235,11 @@ impl Rule for NoCommonjs {
                     return;
                 }
 
-                if ctx.scoping().find_binding(ctx.scoping().root_scope_id(), "require").is_some() {
+                if ctx
+                    .scoping()
+                    .find_binding(ctx.scoping().root_scope_id(), &Ident::from("require"))
+                    .is_some()
+                {
                     return;
                 }
 
diff --git a/crates/oxc_linter/src/rules/import/no_named_as_default_member.rs b/crates/oxc_linter/src/rules/import/no_named_as_default_member.rs
index 737ec6d35364c..3e66fe30c6456 100644
--- a/crates/oxc_linter/src/rules/import/no_named_as_default_member.rs
+++ b/crates/oxc_linter/src/rules/import/no_named_as_default_member.rs
@@ -5,7 +5,7 @@ use oxc_ast::{
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::SymbolId;
-use oxc_span::{GetSpan, Span};
+use oxc_span::{GetSpan, Ident, Span};
 use rustc_hash::FxHashMap;
 
 use crate::{context::LintContext, module_record::ImportImportName, rule::Rule};
@@ -91,7 +91,8 @@ impl Rule for NoNamedAsDefaultMember {
                 continue;
             }
 
-            let Some(symbol_id) = ctx.scoping().get_root_binding(import_entry.local_name.name())
+            let Some(symbol_id) =
+                ctx.scoping().get_root_binding(&Ident::from(import_entry.local_name.name()))
             else {
                 return;
             };
diff --git a/crates/oxc_linter/src/rules/jest/no_jasmine_globals.rs b/crates/oxc_linter/src/rules/jest/no_jasmine_globals.rs
index 41c475a874e46..7c6dc257a762e 100644
--- a/crates/oxc_linter/src/rules/jest/no_jasmine_globals.rs
+++ b/crates/oxc_linter/src/rules/jest/no_jasmine_globals.rs
@@ -79,7 +79,7 @@ impl Rule for NoJasmineGlobals {
             .scoping()
             .root_unresolved_references()
             .iter()
-            .filter(|(key, _)| NON_JASMINE_PROPERTY_NAMES.contains(key));
+            .filter(|(key, _)| NON_JASMINE_PROPERTY_NAMES.contains(&key.as_str()));
 
         for (name, reference_ids) in jasmine_references {
             for &reference_id in reference_ids {
diff --git a/crates/oxc_linter/src/rules/nextjs/inline_script_id.rs b/crates/oxc_linter/src/rules/nextjs/inline_script_id.rs
index b4535fe921c0d..af5cbddea99ab 100644
--- a/crates/oxc_linter/src/rules/nextjs/inline_script_id.rs
+++ b/crates/oxc_linter/src/rules/nextjs/inline_script_id.rs
@@ -4,7 +4,7 @@ use oxc_ast::{
 };
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{GetSpan, Span};
+use oxc_span::{GetSpan, Ident, Span};
 use rustc_hash::FxHashSet;
 
 use crate::{AstNode, context::LintContext, rule::Rule};
@@ -146,12 +146,12 @@ impl Rule for InlineScriptId {
                 }
             }
 
-            if prop_names_hash_set.contains("id") {
+            if prop_names_hash_set.contains(&Ident::new("id")) {
                 continue;
             }
 
             if !jsx_element.children.is_empty()
-                || prop_names_hash_set.contains("dangerouslySetInnerHTML")
+                || prop_names_hash_set.contains(&Ident::new("dangerouslySetInnerHTML"))
             {
                 ctx.diagnostic(inline_script_id_diagnostic(jsx_opening_element.name.span()));
             }
diff --git a/crates/oxc_linter/src/rules/nextjs/no_sync_scripts.rs b/crates/oxc_linter/src/rules/nextjs/no_sync_scripts.rs
index b82391c596ce2..0e2633840c169 100644
--- a/crates/oxc_linter/src/rules/nextjs/no_sync_scripts.rs
+++ b/crates/oxc_linter/src/rules/nextjs/no_sync_scripts.rs
@@ -4,7 +4,7 @@ use oxc_ast::{
 };
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
-use oxc_span::Span;
+use oxc_span::{Ident, Span};
 use rustc_hash::FxHashSet;
 
 use crate::{AstNode, context::LintContext, rule::Rule};
@@ -84,9 +84,9 @@ impl Rule for NoSyncScripts {
                 })
                 .collect::<FxHashSet<_>>();
 
-        if attributes_hs.contains("src")
-            && !attributes_hs.contains("async")
-            && !attributes_hs.contains("defer")
+        if attributes_hs.contains(&Ident::new("src"))
+            && !attributes_hs.contains(&Ident::new("async"))
+            && !attributes_hs.contains(&Ident::new("defer"))
         {
             ctx.diagnostic(no_sync_scripts_diagnostic(jsx_opening_element_name.span));
         }
@@ -99,7 +99,7 @@ fn test() {
 
     let pass = vec![
         r"import {Head} from 'next/document';
-			
+
 			      export class Blah extends Head {
 			        render() {
 			          return (
@@ -111,7 +111,7 @@ fn test() {
 			        }
 			    }",
         r"import {Head} from 'next/document';
-			
+
 			      export class Blah extends Head {
 			        render(props) {
 			          return (
@@ -127,7 +127,7 @@ fn test() {
     let fail = vec![
         r"
 			      import {Head} from 'next/document';
-			
+
 			        export class Blah extends Head {
 			          render() {
 			            return (
@@ -140,7 +140,7 @@ fn test() {
 			      }",
         r"
 			      import {Head} from 'next/document';
-			
+
 			        export class Blah extends Head {
 			          render(props) {
 			            return (
diff --git a/crates/oxc_linter/src/rules/oxc/no_async_endpoint_handlers.rs b/crates/oxc_linter/src/rules/oxc/no_async_endpoint_handlers.rs
index fb6d00bc4a5c7..efc9179a6c21a 100644
--- a/crates/oxc_linter/src/rules/oxc/no_async_endpoint_handlers.rs
+++ b/crates/oxc_linter/src/rules/oxc/no_async_endpoint_handlers.rs
@@ -7,7 +7,7 @@ use oxc_ast::{
 };
 use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{CompactStr, Span};
+use oxc_span::{CompactStr, Ident, Span};
 use rustc_hash::FxHashSet;
 use schemars::JsonSchema;
 use serde_json::Value;
@@ -273,7 +273,7 @@ impl NoAsyncEndpointHandlers {
             return;
         }
 
-        let name = f.name().map(|n| n.as_str()).or(id_name);
+        let name = f.name().map(Ident::as_str).or(id_name);
         if name.is_some_and(|name| self.is_allowed_name(name)) {
             return;
         }
diff --git a/crates/oxc_linter/src/rules/react/exhaustive_deps.rs b/crates/oxc_linter/src/rules/react/exhaustive_deps.rs
index b110ccf742e19..ce59f288fe033 100644
--- a/crates/oxc_linter/src/rules/react/exhaustive_deps.rs
+++ b/crates/oxc_linter/src/rules/react/exhaustive_deps.rs
@@ -20,7 +20,7 @@ use oxc_ast_visit::{Visit, walk::walk_function_body};
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::{ReferenceId, ScopeId, Semantic, SymbolId};
-use oxc_span::{Atom, GetSpan, Span};
+use oxc_span::{Atom, GetSpan, Ident, Span};
 
 use crate::{
     AstNode,
@@ -770,7 +770,9 @@ impl ExhaustiveDeps {
     }
 }
 
-fn get_node_name_without_react_namespace<'a, 'b>(expr: &'b Expression<'a>) -> Option<&'b Atom<'a>> {
+fn get_node_name_without_react_namespace<'a, 'b>(
+    expr: &'b Expression<'a>,
+) -> Option<&'b Ident<'a>> {
     match expr {
         Expression::StaticMemberExpression(member) => {
             if let Expression::Identifier(_ident) = &member.object {
@@ -865,7 +867,7 @@ fn analyze_property_chain<'a, 'b>(
     match expr.get_inner_expression() {
         Expression::Identifier(ident) => Ok(Some(Dependency {
             span: ident.span(),
-            name: ident.name,
+            name: ident.name.as_atom(),
             reference_id: ident.reference_id(),
             chain: vec![],
             symbol_id: semantic.scoping().get_reference(ident.reference_id()).symbol_id(),
@@ -889,7 +891,7 @@ fn concat_members<'a, 'b>(
         return Ok(None);
     };
 
-    let new_chain = Vec::from([member_expr.property.name]);
+    let new_chain = Vec::from([member_expr.property.name.as_atom()]);
 
     Ok(Some(Dependency {
         span: member_expr.span,
@@ -1157,7 +1159,7 @@ fn is_function_stable<'a, 'b>(
 // https://github.com/facebook/react/blob/fee786a057774ab687aff765345dd86fce534ab2/packages/eslint-plugin-react-hooks/src/ExhaustiveDeps.js#L1742
 fn func_call_without_react_namespace<'a>(
     call_expr: &'a CallExpression<'a>,
-) -> Option<&'a Atom<'a>> {
+) -> Option<&'a Ident<'a>> {
     let inner_exp = call_expr.callee.get_inner_expression();
 
     if let Expression::Identifier(ident) = inner_exp {
@@ -1353,7 +1355,7 @@ impl<'a> Visit<'a> for ExhaustiveDepsVisitor<'a, '_> {
                 if is_parent_call_expr {
                     self.found_dependencies.insert(source);
                 } else {
-                    let new_chain = Vec::from([it.property.name]);
+                    let new_chain = Vec::from([it.property.name.as_atom()]);
 
                     let mut destructured_props: Vec<Atom<'a>> = vec![];
                     let mut did_see_ref = false;
@@ -1434,7 +1436,7 @@ impl<'a> Visit<'a> for ExhaustiveDepsVisitor<'a, '_> {
             .unwrap_or(true);
         if needs_full_identifier || (destructured_props.is_empty() && !did_see_ref) {
             self.found_dependencies.insert(Dependency {
-                name: ident.name,
+                name: ident.name.as_atom(),
                 reference_id,
                 span: ident.span,
                 chain: vec![],
@@ -1443,7 +1445,7 @@ impl<'a> Visit<'a> for ExhaustiveDepsVisitor<'a, '_> {
         } else {
             for prop in destructured_props {
                 self.found_dependencies.insert(Dependency {
-                    name: ident.name,
+                    name: ident.name.as_atom(),
                     reference_id,
                     span: ident.span,
                     chain: vec![prop],
@@ -1518,7 +1520,7 @@ mod fix {
         AstBuilder,
         ast::{ArrayExpression, Expression},
     };
-    use oxc_span::{Atom, GetSpan, SPAN};
+    use oxc_span::{GetSpan, Ident, SPAN};
 
     use crate::{
         fixer::{RuleFix, RuleFixer},
@@ -1540,7 +1542,7 @@ mod fix {
         for name in names {
             vec.push(
                 ast_builder
-                    .expression_identifier(SPAN, Atom::from_cow_in(&name.name, &alloc))
+                    .expression_identifier(SPAN, Ident::from_cow_in(&name.name, &alloc))
                     .into(),
             );
         }
diff --git a/crates/oxc_linter/src/rules/react/forbid_elements.rs b/crates/oxc_linter/src/rules/react/forbid_elements.rs
index e817bbb21e93e..6c44d86642383 100644
--- a/crates/oxc_linter/src/rules/react/forbid_elements.rs
+++ b/crates/oxc_linter/src/rules/react/forbid_elements.rs
@@ -108,7 +108,7 @@ impl Rule for ForbidElements {
 
                 match argument {
                     Argument::Identifier(it) => {
-                        if !is_valid_identifier(&it.name) {
+                        if !is_valid_identifier(&it.name.as_atom()) {
                             return;
                         }
                         self.add_diagnostic_if_invalid_element(
diff --git a/crates/oxc_linter/src/rules/react/jsx_no_duplicate_props.rs b/crates/oxc_linter/src/rules/react/jsx_no_duplicate_props.rs
index 86201861d4527..14803cb420087 100644
--- a/crates/oxc_linter/src/rules/react/jsx_no_duplicate_props.rs
+++ b/crates/oxc_linter/src/rules/react/jsx_no_duplicate_props.rs
@@ -69,7 +69,7 @@ impl Rule for JsxNoDuplicateProps {
                 continue;
             };
 
-            if let Some(old_span) = props.insert(ident.name, ident.span) {
+            if let Some(old_span) = props.insert(ident.name.as_atom(), ident.span) {
                 ctx.diagnostic(jsx_no_duplicate_props_diagnostic(
                     ident.name.as_str(),
                     old_span,
diff --git a/crates/oxc_linter/src/rules/react/jsx_props_no_spread_multi.rs b/crates/oxc_linter/src/rules/react/jsx_props_no_spread_multi.rs
index 97a47f881fd7d..c7f03956c124e 100644
--- a/crates/oxc_linter/src/rules/react/jsx_props_no_spread_multi.rs
+++ b/crates/oxc_linter/src/rules/react/jsx_props_no_spread_multi.rs
@@ -81,10 +81,10 @@ impl Rule for JsxPropsNoSpreadMulti {
                     argument_without_parenthesized.get_identifier_reference().map(|arg| arg.name)
                 {
                     identifier_names
-                        .entry(identifier_name)
+                        .entry(identifier_name.as_atom())
                         .and_modify(|first_span| {
                             duplicate_spreads
-                                .entry(identifier_name)
+                                .entry(identifier_name.as_atom())
                                 .or_insert_with(|| vec![*first_span])
                                 .push(spread_attr.span);
                         })
diff --git a/crates/oxc_linter/src/rules/react/no_danger_with_children.rs b/crates/oxc_linter/src/rules/react/no_danger_with_children.rs
index 7c9b33e7f4acf..4d546f352ddeb 100644
--- a/crates/oxc_linter/src/rules/react/no_danger_with_children.rs
+++ b/crates/oxc_linter/src/rules/react/no_danger_with_children.rs
@@ -4,7 +4,7 @@ use oxc_ast::{
 };
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
-use oxc_span::Span;
+use oxc_span::{Ident, Span};
 
 use crate::{AstNode, context::LintContext, rule::Rule};
 
@@ -270,7 +270,7 @@ fn has_jsx_prop(ctx: &LintContext, node: &AstNode, prop_name: &'static str) -> b
             let Some(ident) = attr.argument.get_identifier_reference() else {
                 return false;
             };
-            does_object_var_have_prop_name(ctx, node, ident.name.as_str(), prop_name)
+            does_object_var_have_prop_name(ctx, node, &ident.name, prop_name)
         }
     })
 }
@@ -280,7 +280,7 @@ fn has_jsx_prop(ctx: &LintContext, node: &AstNode, prop_name: &'static str) -> b
 fn does_object_var_have_prop_name(
     ctx: &LintContext,
     node: &AstNode,
-    name: &str,
+    name: &Ident,
     prop_name: &str,
 ) -> bool {
     let Some(symbol) = &find_var_in_scope(ctx, node, name) else {
@@ -309,13 +309,13 @@ fn does_object_var_have_prop_name(
             };
             // If the next symbol is the same as the current symbol, then there is a cycle,
             // for example: `const props = {...props}`, so we will stop searching.
-            if let Some(next_symbol) = find_var_in_scope(ctx, node, ident.name.as_str())
+            if let Some(next_symbol) = find_var_in_scope(ctx, node, &ident.name)
                 && next_symbol.id() == symbol.id()
             {
                 return false;
             }
 
-            does_object_var_have_prop_name(ctx, symbol, ident.name.as_str(), prop_name)
+            does_object_var_have_prop_name(ctx, symbol, &ident.name, prop_name)
         }
     })
 }
@@ -324,7 +324,7 @@ fn does_object_var_have_prop_name(
 fn find_var_in_scope<'c>(
     ctx: &'c LintContext,
     node: &AstNode,
-    name: &str,
+    name: &Ident,
 ) -> Option<&'c AstNode<'c>> {
     ctx.scoping()
         .find_binding(node.scope_id(), name)
diff --git a/crates/oxc_linter/src/rules/react/react_in_jsx_scope.rs b/crates/oxc_linter/src/rules/react/react_in_jsx_scope.rs
index 66181d0b69f6a..643828196819b 100644
--- a/crates/oxc_linter/src/rules/react/react_in_jsx_scope.rs
+++ b/crates/oxc_linter/src/rules/react/react_in_jsx_scope.rs
@@ -1,7 +1,7 @@
 use oxc_ast::AstKind;
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{GetSpan, Span};
+use oxc_span::{GetSpan, Ident, Span};
 
 use crate::{
     AstNode,
@@ -64,7 +64,7 @@ impl Rule for ReactInJsxScope {
             _ => return,
         };
         let scope = ctx.scoping();
-        let react_name = "React";
+        let react_name = &Ident::new("React");
         if scope.get_binding(scope.root_scope_id(), react_name).is_some() {
             return;
         }
diff --git a/crates/oxc_linter/src/rules/typescript/adjacent_overload_signatures.rs b/crates/oxc_linter/src/rules/typescript/adjacent_overload_signatures.rs
index ac93c937f7181..1b8527507b326 100644
--- a/crates/oxc_linter/src/rules/typescript/adjacent_overload_signatures.rs
+++ b/crates/oxc_linter/src/rules/typescript/adjacent_overload_signatures.rs
@@ -188,7 +188,7 @@ impl GetMethod for ModuleDeclaration<'_> {
                             FunctionType::FunctionDeclaration | FunctionType::TSDeclareFunction
                         ) {
                             func_decl.id.as_ref().map(|id| Method {
-                                name: id.name.to_compact_str(),
+                                name: id.name.into(),
                                 r#static: false,
                                 call_signature: false,
                                 kind: MethodKind::Normal,
@@ -204,7 +204,7 @@ impl GetMethod for ModuleDeclaration<'_> {
             ModuleDeclaration::ExportNamedDeclaration(named_decl) => {
                 if let Some(Declaration::FunctionDeclaration(func_decl)) = &named_decl.declaration {
                     return func_decl.id.as_ref().map(|id| Method {
-                        name: id.name.to_compact_str(),
+                        name: id.name.into(),
                         r#static: false,
                         call_signature: false,
                         kind: MethodKind::Normal,
@@ -227,7 +227,7 @@ impl GetMethod for Declaration<'_> {
                     FunctionType::FunctionDeclaration | FunctionType::TSDeclareFunction
                 ) {
                     func_decl.id.as_ref().map(|id| Method {
-                        name: id.name.to_compact_str(),
+                        name: id.name.into(),
                         r#static: false,
                         call_signature: false,
                         kind: MethodKind::Normal,
diff --git a/crates/oxc_linter/src/rules/typescript/explicit_module_boundary_types.rs b/crates/oxc_linter/src/rules/typescript/explicit_module_boundary_types.rs
index 7a26beaa93d30..9f3464bad224b 100644
--- a/crates/oxc_linter/src/rules/typescript/explicit_module_boundary_types.rs
+++ b/crates/oxc_linter/src/rules/typescript/explicit_module_boundary_types.rs
@@ -9,7 +9,7 @@ use oxc_ast_visit::{
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::ScopeFlags;
-use oxc_span::{CompactStr, GetSpan, Span};
+use oxc_span::{CompactStr, GetSpan, Ident, Span};
 use rustc_hash::FxHashMap;
 use schemars::JsonSchema;
 use serde::Deserialize;
@@ -87,8 +87,8 @@ impl ExplicitModuleBoundaryTypesConfig {
         self.allowed_names.iter().any(|n| n == name)
     }
 
-    fn is_some_allowed_name<S: AsRef<str>>(&self, name: Option<S>) -> bool {
-        name.is_some_and(|name| self.is_allowed_name(name.as_ref()))
+    fn is_some_allowed_name(&self, name: Option<&str>) -> bool {
+        name.is_some_and(|name| self.is_allowed_name(name))
     }
 }
 
@@ -341,7 +341,7 @@ impl<'a, 'c> ExplicitTypesChecker<'a, 'c> {
             return false;
         };
         if let Some(Cow::Borrowed(name)) = id.static_name() {
-            self.target_symbol.replace(IdentifierName { name: Atom::from(name), span: id.span() });
+            self.target_symbol.replace(IdentifierName { name: Ident::new(name), span: id.span() });
             true
         } else {
             false
@@ -362,7 +362,7 @@ impl<'a, 'c> ExplicitTypesChecker<'a, 'c> {
         #[expect(clippy::cast_possible_truncation)]
         let span =
             target_span.map_or(Span::sized(func.span.start, "function".len() as u32), |t| t.span);
-        let is_allowed = || self.rule.is_some_allowed_name(func.name().or(target_name));
+        let is_allowed = || self.rule.is_some_allowed_name(func.name().or(target_name).as_deref());
 
         // When allow_overload_functions is enabled, skip return type checking for all functions
         // This is a simplified implementation - a proper implementation would only skip
@@ -399,7 +399,7 @@ impl<'a, 'c> ExplicitTypesChecker<'a, 'c> {
         let target_span = self.target_symbol.as_ref();
         let target_name = target_span.map(|t| t.name);
         let span = target_span.map_or(arrow.params.span, |t| t.span);
-        let is_allowed = || self.rule.is_some_allowed_name(target_name);
+        let is_allowed = || self.rule.is_some_allowed_name(target_name.as_deref());
 
         if !self.rule.allow_higher_order_functions {
             if !is_allowed() {
@@ -581,7 +581,7 @@ impl<'a> Visit<'a> for ExplicitTypesChecker<'a, '_> {
         {
             return;
         }
-        if self.rule.is_some_allowed_name(el.static_name()) {
+        if self.rule.is_some_allowed_name(el.static_name().as_deref()) {
             return;
         }
 
diff --git a/crates/oxc_linter/src/rules/typescript/no_require_imports.rs b/crates/oxc_linter/src/rules/typescript/no_require_imports.rs
index 91c91b6893bbf..b977f5ffc67ac 100644
--- a/crates/oxc_linter/src/rules/typescript/no_require_imports.rs
+++ b/crates/oxc_linter/src/rules/typescript/no_require_imports.rs
@@ -178,7 +178,11 @@ impl Rule for NoRequireImports {
                     }
                 }
 
-                if ctx.scoping().find_binding(ctx.scoping().root_scope_id(), "require").is_some() {
+                if ctx
+                    .scoping()
+                    .find_binding(ctx.scoping().root_scope_id(), &oxc_span::Ident::new("require"))
+                    .is_some()
+                {
                     return;
                 }
 
diff --git a/crates/oxc_linter/src/rules/typescript/no_unnecessary_parameter_property_assignment.rs b/crates/oxc_linter/src/rules/typescript/no_unnecessary_parameter_property_assignment.rs
index 1fef9f0d3b2e1..55e48954d36b5 100644
--- a/crates/oxc_linter/src/rules/typescript/no_unnecessary_parameter_property_assignment.rs
+++ b/crates/oxc_linter/src/rules/typescript/no_unnecessary_parameter_property_assignment.rs
@@ -232,7 +232,7 @@ fn get_property_name<'a>(assignment_target: &AssignmentTarget<'a>) -> Option<Ato
             if matches!(&expr.object, Expression::ThisExpression(_)) =>
         {
             // this.property
-            Some(expr.property.name)
+            Some(expr.property.name.as_atom())
         }
         AssignmentTarget::ComputedMemberExpression(expr)
             if matches!(&expr.object, Expression::ThisExpression(_)) =>
diff --git a/crates/oxc_linter/src/rules/unicorn/consistent_function_scoping.rs b/crates/oxc_linter/src/rules/unicorn/consistent_function_scoping.rs
index 6eaef4929582b..edbf4c5387782 100644
--- a/crates/oxc_linter/src/rules/unicorn/consistent_function_scoping.rs
+++ b/crates/oxc_linter/src/rules/unicorn/consistent_function_scoping.rs
@@ -5,7 +5,7 @@ use oxc_ast_visit::{Visit, walk};
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_semantic::{ReferenceId, ScopeFlags, ScopeId, SymbolId};
-use oxc_span::{Atom, GetSpan, Span};
+use oxc_span::{GetSpan, Ident, Span};
 use schemars::JsonSchema;
 use serde::Deserialize;
 
@@ -21,7 +21,7 @@ fn consistent_function_scoping(
     fn_span: Span,
     parent_scope_span: Option<Span>,
     parent_scope_kind: Option<&'static str>,
-    function_name: Option<Atom<'_>>,
+    function_name: Option<Ident<'_>>,
 ) -> OxcDiagnostic {
     let function_label = if let Some(name) = function_name {
         format!("Function `{name}` does not capture any variables from its parent scope")
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_global_this.rs b/crates/oxc_linter/src/rules/unicorn/prefer_global_this.rs
index beb1f738ec47b..34a063a93fc83 100644
--- a/crates/oxc_linter/src/rules/unicorn/prefer_global_this.rs
+++ b/crates/oxc_linter/src/rules/unicorn/prefer_global_this.rs
@@ -64,7 +64,7 @@ impl Rule for PreferGlobalThis {
 
         if !matches!(ident.name.as_str(), "window" | "self" | "global")
             || is_computed_member_expression_object(node, ctx)
-            || !ctx.scoping().root_unresolved_references().contains_key(&ident.name.as_str())
+            || !ctx.scoping().root_unresolved_references().contains_key(&ident.name)
         {
             return;
         }
diff --git a/crates/oxc_linter/src/rules/vue/no_import_compiler_macros.rs b/crates/oxc_linter/src/rules/vue/no_import_compiler_macros.rs
index 2a1ad4c075328..d86acd8bd5b2f 100644
--- a/crates/oxc_linter/src/rules/vue/no_import_compiler_macros.rs
+++ b/crates/oxc_linter/src/rules/vue/no_import_compiler_macros.rs
@@ -4,17 +4,17 @@ use oxc_ast::{
 };
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
-use oxc_span::{Atom, Span};
+use oxc_span::Span;
 
 use crate::{AstNode, context::LintContext, frameworks::FrameworkOptions, rule::Rule};
 
-fn no_import_compiler_macros_diagnostic(span: Span, name: &Atom) -> OxcDiagnostic {
+fn no_import_compiler_macros_diagnostic(span: Span, name: &str) -> OxcDiagnostic {
     OxcDiagnostic::warn(format!("'{name}' is a compiler macro and doesn't need to be imported."))
         .with_help("Remove the import statement for this macro.")
         .with_label(span)
 }
 
-fn invalid_import_compiler_macros_diagnostic(span: Span, name: &Atom) -> OxcDiagnostic {
+fn invalid_import_compiler_macros_diagnostic(span: Span, name: &str) -> OxcDiagnostic {
     OxcDiagnostic::warn(format!(
         "'{name}' is a compiler macro and can't be imported outside of `<script setup>`."
     ))
diff --git a/crates/oxc_linter/src/utils/jest.rs b/crates/oxc_linter/src/utils/jest.rs
index 2834abef172e7..666b6b3c0fd30 100644
--- a/crates/oxc_linter/src/utils/jest.rs
+++ b/crates/oxc_linter/src/utils/jest.rs
@@ -257,7 +257,7 @@ fn collect_ids_referenced_to_global<'c>(
         .scoping()
         .root_unresolved_references()
         .iter()
-        .filter(|(name, _)| JEST_METHOD_NAMES.contains(name))
+        .filter(|(name, _)| JEST_METHOD_NAMES.contains(&name.as_str()))
         .flat_map(|(_, reference_ids)| reference_ids.iter().copied())
 }
 
diff --git a/crates/oxc_linter/src/utils/react.rs b/crates/oxc_linter/src/utils/react.rs
index 301f59b5632b8..bab1ba863230e 100644
--- a/crates/oxc_linter/src/utils/react.rs
+++ b/crates/oxc_linter/src/utils/react.rs
@@ -355,7 +355,7 @@ mod test {
 
     use oxc_allocator::Allocator;
     use oxc_ast::AstBuilder;
-    use oxc_span::Span;
+    use oxc_span::{Ident, Span};
 
     #[test]
     fn test_is_react_component_name() {
@@ -384,31 +384,31 @@ mod test {
         let ast = AstBuilder::new(&alloc);
 
         // Identifier: useState
-        let use_state = ast.expression_identifier(Span::default(), "useState");
+        let use_state = ast.expression_identifier(Span::default(), Ident::new("useState"));
         assert!(is_react_hook(&use_state));
 
         // Identifier: use
-        let just_use = ast.expression_identifier(Span::default(), "use");
+        let just_use = ast.expression_identifier(Span::default(), Ident::new("use"));
         assert!(is_react_hook(&just_use));
 
         // Identifier: userError, should not be considered a hook despite starting with "use"
-        let user_error = ast.expression_identifier(Span::default(), "userError");
+        let user_error = ast.expression_identifier(Span::default(), Ident::new("userError"));
         assert!(!is_react_hook(&user_error));
 
         // Identifier that's not a hook
-        let not_hook = ast.expression_identifier(Span::default(), "notAHook");
+        let not_hook = ast.expression_identifier(Span::default(), Ident::new("notAHook"));
         assert!(!is_react_hook(&not_hook));
 
         // Static member: React.useEffect -> valid
-        let react_obj = ast.expression_identifier(Span::default(), "React");
-        let prop = ast.identifier_name(Span::default(), "useEffect");
+        let react_obj = ast.expression_identifier(Span::default(), Ident::new("React"));
+        let prop = ast.identifier_name(Span::default(), Ident::new("useEffect"));
         let react_use_effect =
             ast.member_expression_static(Span::default(), react_obj, prop, false).into();
         assert!(is_react_hook(&react_use_effect));
 
         // Static member: react.useEffect -> invalid because namespace isn't PascalCase
-        let react_lower = ast.expression_identifier(Span::default(), "react");
-        let prop2 = ast.identifier_name(Span::default(), "useEffect");
+        let react_lower = ast.expression_identifier(Span::default(), Ident::new("react"));
+        let prop2 = ast.identifier_name(Span::default(), Ident::new("useEffect"));
         let react_lower_use_effect =
             ast.member_expression_static(Span::default(), react_lower, prop2, false).into();
         assert!(!is_react_hook(&react_lower_use_effect));
diff --git a/crates/oxc_linter/src/utils/unicorn.rs b/crates/oxc_linter/src/utils/unicorn.rs
index da6e40e634329..8d4cfa40726a2 100644
--- a/crates/oxc_linter/src/utils/unicorn.rs
+++ b/crates/oxc_linter/src/utils/unicorn.rs
@@ -71,7 +71,7 @@ pub fn is_prototype_property(
     if let Some(member_expr_obj) = member_expr.object().as_member_expression()
         && let Expression::Identifier(iden) = member_expr_obj.object()
         && member_expr_obj.static_property_name().is_some_and(|name| name == "prototype")
-        && object.is_some_and(|val| val == iden.name)
+        && object.is_some_and(|val| iden.name == val)
         && !member_expr.optional()
         && !member_expr_obj.optional()
     {
diff --git a/crates/oxc_mangler/src/lib.rs b/crates/oxc_mangler/src/lib.rs
index 3381b58007d62..d44aee2499120 100644
--- a/crates/oxc_mangler/src/lib.rs
+++ b/crates/oxc_mangler/src/lib.rs
@@ -11,7 +11,7 @@ use oxc_allocator::{Allocator, BitSet, Vec};
 use oxc_ast::ast::{Declaration, Program, Statement};
 use oxc_data_structures::inline_string::InlineString;
 use oxc_semantic::{AstNodes, Scoping, Semantic, SemanticBuilder, SymbolId};
-use oxc_span::{Atom, CompactStr};
+use oxc_span::{Atom, CompactStr, Ident};
 
 pub(crate) mod base54;
 mod keep_names;
@@ -430,7 +430,7 @@ impl<'t> Mangler<'t> {
                 if !oxc_syntax::keyword::is_reserved_keyword(n)
                     && !is_special_name(n)
                     && !root_unresolved_references.contains_key(n)
-                    && !(root_bindings.contains_key(n)
+                    && !(root_bindings.contains_key(&Ident::new(n))
                         && (!self.options.top_level || exported_names.contains(n)))
                         // TODO: only skip the names that are kept in the current scope
                         && !keep_name_names.contains(n)
@@ -550,7 +550,7 @@ impl<'t> Mangler<'t> {
                     itertools::Either::Right(decl.id().into_iter())
                 }
             })
-            .map(|id| (id.name, id.symbol_id()))
+            .map(|id| (id.name.as_atom(), id.symbol_id()))
             .collect()
     }
 
diff --git a/crates/oxc_minifier/src/keep_var.rs b/crates/oxc_minifier/src/keep_var.rs
index a1b19cf358a4e..dc3a1f2936256 100644
--- a/crates/oxc_minifier/src/keep_var.rs
+++ b/crates/oxc_minifier/src/keep_var.rs
@@ -2,7 +2,7 @@ use oxc_allocator::Box as ArenaBox;
 use oxc_ast::{AstBuilder, NONE, ast::*};
 use oxc_ast_visit::Visit;
 use oxc_ecmascript::BoundNames;
-use oxc_span::{Atom, SPAN, Span};
+use oxc_span::{Atom, Ident, SPAN, Span};
 use oxc_syntax::symbol::SymbolId;
 
 pub struct KeepVar<'a> {
@@ -45,7 +45,7 @@ impl<'a> Visit<'a> for KeepVar<'a> {
     fn visit_variable_declaration(&mut self, it: &VariableDeclaration<'a>) {
         if it.kind.is_var() {
             it.bound_names(&mut |ident| {
-                self.vars.push((ident.name, ident.span, ident.symbol_id.get()));
+                self.vars.push((ident.name.as_atom(), ident.span, ident.symbol_id.get()));
             });
             if it.has_init() {
                 self.all_hoisted = false;
@@ -67,10 +67,12 @@ impl<'a> KeepVar<'a> {
         let kind = VariableDeclarationKind::Var;
         let decls = self.ast.vec_from_iter(self.vars.into_iter().map(|(name, span, symbol_id)| {
             let binding_kind = symbol_id.map_or_else(
-                || self.ast.binding_pattern_kind_binding_identifier(span, name),
+                || self.ast.binding_pattern_kind_binding_identifier(span, Ident::from(name)),
                 |symbol_id| {
                     self.ast.binding_pattern_kind_binding_identifier_with_symbol_id(
-                        span, name, symbol_id,
+                        span,
+                        Ident::from(name),
+                        symbol_id,
                     )
                 },
             );
diff --git a/crates/oxc_minifier/src/peephole/convert_to_dotted_properties.rs b/crates/oxc_minifier/src/peephole/convert_to_dotted_properties.rs
index e34e2af48f476..51b680a288bb7 100644
--- a/crates/oxc_minifier/src/peephole/convert_to_dotted_properties.rs
+++ b/crates/oxc_minifier/src/peephole/convert_to_dotted_properties.rs
@@ -1,5 +1,6 @@
 use oxc_allocator::TakeIn;
 use oxc_ast::ast::*;
+use oxc_span::Ident;
 
 use crate::ctx::Ctx;
 
@@ -17,7 +18,7 @@ impl<'a> PeepholeOptimizations {
         let MemberExpression::ComputedMemberExpression(e) = expr else { return };
         let Expression::StringLiteral(s) = &e.expression else { return };
         if Ctx::is_identifier_name_patched(&s.value) {
-            let property = ctx.ast.identifier_name(s.span, s.value);
+            let property = ctx.ast.identifier_name(s.span, Ident::from(s.value));
             *expr =
                 MemberExpression::StaticMemberExpression(ctx.ast.alloc_static_member_expression(
                     e.span,
diff --git a/crates/oxc_minifier/src/peephole/mod.rs b/crates/oxc_minifier/src/peephole/mod.rs
index a5ba67298aacb..96b17965b85d0 100644
--- a/crates/oxc_minifier/src/peephole/mod.rs
+++ b/crates/oxc_minifier/src/peephole/mod.rs
@@ -386,7 +386,9 @@ impl<'a> Traverse<'a, MinifierState<'a>> for PeepholeOptimizations {
         node: &mut PrivateFieldExpression<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) {
-        ctx.state.class_symbols_stack.push_private_member_to_current_class(node.field.name);
+        ctx.state
+            .class_symbols_stack
+            .push_private_member_to_current_class(node.field.name.as_atom());
     }
 
     fn exit_private_in_expression(
@@ -394,7 +396,9 @@ impl<'a> Traverse<'a, MinifierState<'a>> for PeepholeOptimizations {
         node: &mut PrivateInExpression<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) {
-        ctx.state.class_symbols_stack.push_private_member_to_current_class(node.left.name);
+        ctx.state
+            .class_symbols_stack
+            .push_private_member_to_current_class(node.left.name.as_atom());
     }
 }
 
diff --git a/crates/oxc_minifier/src/peephole/remove_unused_private_members.rs b/crates/oxc_minifier/src/peephole/remove_unused_private_members.rs
index ff14e3e2dee4e..948a80d09439f 100644
--- a/crates/oxc_minifier/src/peephole/remove_unused_private_members.rs
+++ b/crates/oxc_minifier/src/peephole/remove_unused_private_members.rs
@@ -24,7 +24,7 @@ impl<'a> PeepholeOptimizations {
                 if ctx
                     .state
                     .class_symbols_stack
-                    .is_private_member_used_in_current_class(&private_id.name)
+                    .is_private_member_used_in_current_class(&private_id.name.as_atom())
                 {
                     return true;
                 }
@@ -36,7 +36,7 @@ impl<'a> PeepholeOptimizations {
                 };
                 ctx.state
                     .class_symbols_stack
-                    .is_private_member_used_in_current_class(&private_id.name)
+                    .is_private_member_used_in_current_class(&private_id.name.as_atom())
             }
             ClassElement::AccessorProperty(accessor) => {
                 let PropertyKey::PrivateIdentifier(private_id) = &accessor.key else {
@@ -45,7 +45,7 @@ impl<'a> PeepholeOptimizations {
                 if ctx
                     .state
                     .class_symbols_stack
-                    .is_private_member_used_in_current_class(&private_id.name)
+                    .is_private_member_used_in_current_class(&private_id.name.as_atom())
                 {
                     return true;
                 }
@@ -67,19 +67,19 @@ impl<'a> PeepholeOptimizations {
                 let PropertyKey::PrivateIdentifier(private_id) = &prop.key else {
                     return None;
                 };
-                Some(private_id.name)
+                Some(private_id.name.as_atom())
             }
             ClassElement::MethodDefinition(method) => {
                 let PropertyKey::PrivateIdentifier(private_id) = &method.key else {
                     return None;
                 };
-                Some(private_id.name)
+                Some(private_id.name.as_atom())
             }
             ClassElement::AccessorProperty(accessor) => {
                 let PropertyKey::PrivateIdentifier(private_id) = &accessor.key else {
                     return None;
                 };
-                Some(private_id.name)
+                Some(private_id.name.as_atom())
             }
             ClassElement::StaticBlock(_) => None,
             ClassElement::TSIndexSignature(_) => {
diff --git a/crates/oxc_minifier/src/peephole/substitute_alternate_syntax.rs b/crates/oxc_minifier/src/peephole/substitute_alternate_syntax.rs
index 7f1683b3a44e3..d5b0e0f8d33b8 100644
--- a/crates/oxc_minifier/src/peephole/substitute_alternate_syntax.rs
+++ b/crates/oxc_minifier/src/peephole/substitute_alternate_syntax.rs
@@ -7,6 +7,7 @@ use oxc_ecmascript::constant_evaluation::{ConstantEvaluation, ConstantValue, Det
 use oxc_ecmascript::{ToJsString, ToNumber, side_effects::MayHaveSideEffects};
 use oxc_semantic::ReferenceFlags;
 use oxc_span::GetSpan;
+use oxc_span::Ident;
 use oxc_span::SPAN;
 use oxc_syntax::precedence::GetPrecedence;
 use oxc_syntax::{
@@ -64,7 +65,7 @@ impl<'a> PeepholeOptimizations {
             let Some(ident) = assign_target_prop_prop.binding.identifier_mut() else {
                 return;
             };
-            if prop_name == ident.name {
+            if ident.name == prop_name {
                 *prop = ctx.ast.assignment_target_property_assignment_target_property_identifier(
                     ident.span,
                     ident.take_in(ctx.ast),
@@ -883,7 +884,7 @@ impl<'a> PeepholeOptimizations {
                 Expression::StaticMemberExpression(ctx.ast.alloc_static_member_expression(
                     SPAN,
                     obj,
-                    ctx.ast.identifier_name(SPAN, "slice"),
+                    ctx.ast.identifier_name(SPAN, Ident::new("slice")),
                     false,
                 ));
             ctx.ast.expression_call(
@@ -1221,10 +1222,11 @@ impl<'a> PeepholeOptimizations {
                     .as_member_expression()
                     .is_some_and(|mem_expr| mem_expr.is_specific_member_access("window", "Object"))
             {
-                let reference_id = ctx.create_unbound_reference("Object", ReferenceFlags::Read);
+                let reference_id =
+                    ctx.create_unbound_reference(&Ident::new("Object"), ReferenceFlags::Read);
                 call_expr.callee = ctx.ast.expression_identifier_with_reference_id(
                     call_expr.callee.span(),
-                    "Object",
+                    Ident::new("Object"),
                     reference_id,
                 );
                 ctx.state.changed = true;
@@ -1256,7 +1258,7 @@ impl<'a> PeepholeOptimizations {
                 if Ctx::is_identifier_name_patched(value) {
                     *computed = false;
                     *key = PropertyKey::StaticIdentifier(
-                        ctx.ast.alloc_identifier_name(s.span, s.value),
+                        ctx.ast.alloc_identifier_name(s.span, Ident::from(s.value)),
                     );
                     ctx.state.changed = true;
                     return;
@@ -1519,7 +1521,7 @@ impl<'a> PeepholeOptimizations {
                     ctx.ast.atom(&concatenated_string),
                     None,
                 ),
-                ctx.ast.identifier_name(expr.span(), "split"),
+                ctx.ast.identifier_name(expr.span(), Ident::new("split")),
                 false,
             )),
             NONE,
diff --git a/crates/oxc_minifier/tests/ecmascript/to_boolean.rs b/crates/oxc_minifier/tests/ecmascript/to_boolean.rs
index f4a21beb716ac..ea2d4921cce5c 100644
--- a/crates/oxc_minifier/tests/ecmascript/to_boolean.rs
+++ b/crates/oxc_minifier/tests/ecmascript/to_boolean.rs
@@ -1,7 +1,7 @@
 use oxc_allocator::Allocator;
 use oxc_ast::AstBuilder;
 use oxc_ecmascript::ToBoolean;
-use oxc_span::SPAN;
+use oxc_span::{Ident, SPAN};
 
 use super::GlobalReferenceInformation;
 
@@ -10,7 +10,7 @@ fn test() {
     let allocator = Allocator::default();
     let ast = AstBuilder::new(&allocator);
 
-    let undefined = ast.expression_identifier(SPAN, "undefined");
+    let undefined = ast.expression_identifier(SPAN, Ident::new("undefined"));
     let shadowed_undefined_bool =
         undefined.to_boolean(&GlobalReferenceInformation { is_undefined_shadowed: true });
     let global_undefined_bool =
diff --git a/crates/oxc_minifier/tests/ecmascript/to_number.rs b/crates/oxc_minifier/tests/ecmascript/to_number.rs
index 35c7d60b60c64..e653653259649 100644
--- a/crates/oxc_minifier/tests/ecmascript/to_number.rs
+++ b/crates/oxc_minifier/tests/ecmascript/to_number.rs
@@ -1,7 +1,7 @@
 use oxc_allocator::Allocator;
 use oxc_ast::{AstBuilder, ast::*};
 use oxc_ecmascript::{ToNumber, WithoutGlobalReferenceInformation};
-use oxc_span::SPAN;
+use oxc_span::{Ident, SPAN};
 
 use super::GlobalReferenceInformation;
 
@@ -10,7 +10,7 @@ fn test() {
     let allocator = Allocator::default();
     let ast = AstBuilder::new(&allocator);
 
-    let undefined = ast.expression_identifier(SPAN, "undefined");
+    let undefined = ast.expression_identifier(SPAN, Ident::new("undefined"));
     let shadowed_undefined_number =
         undefined.to_number(&GlobalReferenceInformation { is_undefined_shadowed: true });
     let global_undefined_number =
@@ -22,7 +22,7 @@ fn test() {
         ast.vec1(ast.object_property_kind_object_property(
             SPAN,
             PropertyKind::Init,
-            ast.property_key_static_identifier(SPAN, "toString"),
+            ast.property_key_static_identifier(SPAN, Ident::new("toString")),
             ast.expression_string_literal(SPAN, "foo", None),
             false,
             false,
diff --git a/crates/oxc_minifier/tests/ecmascript/to_string.rs b/crates/oxc_minifier/tests/ecmascript/to_string.rs
index de1e88e5355e3..3e9942c6e26a4 100644
--- a/crates/oxc_minifier/tests/ecmascript/to_string.rs
+++ b/crates/oxc_minifier/tests/ecmascript/to_string.rs
@@ -1,7 +1,7 @@
 use oxc_allocator::Allocator;
 use oxc_ast::{AstBuilder, ast::*};
 use oxc_ecmascript::{ToJsString, WithoutGlobalReferenceInformation};
-use oxc_span::SPAN;
+use oxc_span::{Ident, SPAN};
 
 use super::GlobalReferenceInformation;
 
@@ -10,7 +10,7 @@ fn test() {
     let allocator = Allocator::default();
     let ast = AstBuilder::new(&allocator);
 
-    let undefined = ast.expression_identifier(SPAN, "undefined");
+    let undefined = ast.expression_identifier(SPAN, Ident::new("undefined"));
     let shadowed_undefined_string =
         undefined.to_js_string(&GlobalReferenceInformation { is_undefined_shadowed: true });
     let global_undefined_string =
@@ -22,7 +22,7 @@ fn test() {
         ast.vec1(ast.object_property_kind_object_property(
             SPAN,
             PropertyKind::Init,
-            ast.property_key_static_identifier(SPAN, "toString"),
+            ast.property_key_static_identifier(SPAN, Ident::new("toString")),
             ast.expression_string_literal(SPAN, "foo", None),
             false,
             false,
diff --git a/crates/oxc_parser/src/js/expression.rs b/crates/oxc_parser/src/js/expression.rs
index 750890e49bb2f..68b0ac22a1d2d 100644
--- a/crates/oxc_parser/src/js/expression.rs
+++ b/crates/oxc_parser/src/js/expression.rs
@@ -3,7 +3,7 @@ use oxc_allocator::{Box, TakeIn, Vec};
 use oxc_ast::ast::*;
 #[cfg(feature = "regular_expression")]
 use oxc_regular_expression::ast::Pattern;
-use oxc_span::{Atom, GetSpan, Span};
+use oxc_span::{Atom, GetSpan, Ident, Span};
 use oxc_syntax::{
     number::{BigintBase, NumberBase},
     precedence::Precedence,
@@ -113,11 +113,11 @@ impl<'a> ParserImpl<'a> {
     }
 
     #[inline]
-    pub(crate) fn parse_identifier_kind(&mut self, kind: Kind) -> (Span, Atom<'a>) {
+    pub(crate) fn parse_identifier_kind(&mut self, kind: Kind) -> (Span, Ident<'a>) {
         let span = self.cur_token().span();
         let name = self.cur_string();
         self.bump_remap(kind);
-        (span, Atom::from(name))
+        (span, Ident::new(name))
     }
 
     pub(crate) fn check_identifier(&mut self, kind: Kind, ctx: Context) {
@@ -141,7 +141,7 @@ impl<'a> ParserImpl<'a> {
     /// # Panics
     pub(crate) fn parse_private_identifier(&mut self) -> PrivateIdentifier<'a> {
         let span = self.cur_token().span();
-        let name = Atom::from(self.cur_string());
+        let name = Ident::new(self.cur_string());
         self.bump_any();
         self.ast.private_identifier(span, name)
     }
diff --git a/crates/oxc_parser/src/js/module.rs b/crates/oxc_parser/src/js/module.rs
index 2b1a5360b2794..7579bbe33d7b3 100644
--- a/crates/oxc_parser/src/js/module.rs
+++ b/crates/oxc_parser/src/js/module.rs
@@ -1,6 +1,6 @@
 use oxc_allocator::{Box, Vec};
 use oxc_ast::{NONE, ast::*};
-use oxc_span::GetSpan;
+use oxc_span::{GetSpan, Ident};
 use rustc_hash::FxHashMap;
 
 use super::FunctionKind;
@@ -531,7 +531,7 @@ impl<'a> ParserImpl<'a> {
 
                         // `local` becomes a reference for `export { local }`.
                         specifier.local = ModuleExportName::IdentifierReference(
-                            self.ast.identifier_reference(ident.span, ident.name.as_str()),
+                            self.ast.identifier_reference(ident.span, ident.name),
                         );
                     }
                     // No prior code path should lead to parsing `ModuleExportName` as `IdentifierReference`.
@@ -818,7 +818,7 @@ impl<'a> ParserImpl<'a> {
                         // { type as as }
                         property_name = Some(self.ast.module_export_name_identifier_name(
                             type_or_name_token.span(),
-                            self.token_source(&type_or_name_token),
+                            Ident::from(self.token_source(&type_or_name_token)),
                         ));
                         name = self
                             .ast
diff --git a/crates/oxc_parser/src/jsx/mod.rs b/crates/oxc_parser/src/jsx/mod.rs
index ec22202b05c5e..0490d7733cdb5 100644
--- a/crates/oxc_parser/src/jsx/mod.rs
+++ b/crates/oxc_parser/src/jsx/mod.rs
@@ -2,7 +2,7 @@
 
 use oxc_allocator::{Box, Dummy, Vec};
 use oxc_ast::ast::*;
-use oxc_span::{Atom, GetSpan, Span};
+use oxc_span::{Atom, GetSpan, Ident, Span};
 
 use crate::{ParserImpl, diagnostics, lexer::Kind};
 
@@ -426,7 +426,7 @@ impl<'a> ParserImpl<'a> {
         self.bump_any();
         let span = self.end_span(span);
         let name = span.source_text(self.source_text);
-        self.ast.jsx_identifier(span, name)
+        self.ast.jsx_identifier(span, Ident::from(name))
     }
 
     fn parse_jsx_text(&mut self) -> Box<'a, JSXText<'a>> {
diff --git a/crates/oxc_parser/src/module_record.rs b/crates/oxc_parser/src/module_record.rs
index 60f0581473aac..b908a9de3790a 100644
--- a/crates/oxc_parser/src/module_record.rs
+++ b/crates/oxc_parser/src/module_record.rs
@@ -2,7 +2,7 @@ use oxc_allocator::{Allocator, Vec};
 use oxc_ast::ast::*;
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_ecmascript::BoundNames;
-use oxc_span::{GetSpan, Span};
+use oxc_span::{GetSpan, Ident, Span};
 use oxc_syntax::module_record::*;
 
 use crate::diagnostics;
@@ -39,7 +39,8 @@ impl<'a> ModuleRecordBuilder<'a> {
 
         // It is a Syntax Error if the ExportedNames of ModuleItemList contains any duplicate entries.
         for name_span in &self.exported_bindings_duplicated {
-            let old_span = module_record.exported_bindings[&name_span.name];
+            let name = name_span.name;
+            let old_span = module_record.exported_bindings[&name];
             errors.push(diagnostics::duplicate_export(&name_span.name, name_span.span, old_span));
         }
 
@@ -93,9 +94,9 @@ impl<'a> ModuleRecordBuilder<'a> {
         self.module_record.star_export_entries.push(entry);
     }
 
-    fn add_export_binding(&mut self, name: Atom<'a>, span: Span) {
-        if let Some(old_node) = self.module_record.exported_bindings.insert(name, span) {
-            self.exported_bindings_duplicated.push(NameSpan::new(name, old_node));
+    fn add_export_binding(&mut self, name: Ident<'a>, span: Span) {
+        if let Some(old_node) = self.module_record.exported_bindings.insert(name.as_atom(), span) {
+            self.exported_bindings_duplicated.push(NameSpan::new(name.as_atom(), old_node));
         }
     }
 
@@ -195,20 +196,20 @@ impl<'a> ModuleRecordBuilder<'a> {
                 let (import_name, local_name, is_type) = match specifier {
                     ImportDeclarationSpecifier::ImportSpecifier(specifier) => (
                         ImportImportName::Name(NameSpan::new(
-                            specifier.imported.name(),
+                            specifier.imported.name().as_atom(),
                             specifier.imported.span(),
                         )),
-                        NameSpan::new(specifier.local.name, specifier.local.span),
+                        NameSpan::new(specifier.local.name.as_atom(), specifier.local.span),
                         decl.import_kind.is_type() || specifier.import_kind.is_type(),
                     ),
                     ImportDeclarationSpecifier::ImportNamespaceSpecifier(specifier) => (
                         ImportImportName::NamespaceObject,
-                        NameSpan::new(specifier.local.name, specifier.local.span),
+                        NameSpan::new(specifier.local.name.as_atom(), specifier.local.span),
                         decl.import_kind.is_type(),
                     ),
                     ImportDeclarationSpecifier::ImportDefaultSpecifier(specifier) => (
                         ImportImportName::Default(specifier.span),
-                        NameSpan::new(specifier.local.name, specifier.local.span),
+                        NameSpan::new(specifier.local.name.as_atom(), specifier.local.span),
                         decl.import_kind.is_type(),
                     ),
                 };
@@ -244,7 +245,10 @@ impl<'a> ModuleRecordBuilder<'a> {
                 .as_ref()
                 .map_or(ExportImportName::AllButDefault, |_| ExportImportName::All),
             export_name: decl.exported.as_ref().map_or(ExportExportName::Null, |exported_name| {
-                ExportExportName::Name(NameSpan::new(exported_name.name(), exported_name.span()))
+                ExportExportName::Name(NameSpan::new(
+                    exported_name.name().as_atom(),
+                    exported_name.span(),
+                ))
             }),
             local_name: ExportLocalName::default(),
             is_type: decl.export_kind.is_type(),
@@ -272,20 +276,20 @@ impl<'a> ModuleRecordBuilder<'a> {
     ) {
         let local_name = match &decl.declaration {
             ExportDefaultDeclarationKind::Identifier(ident) => {
-                ExportLocalName::Default(NameSpan::new(ident.name, ident.span))
+                ExportLocalName::Default(NameSpan::new(ident.name.as_atom(), ident.span))
             }
             ExportDefaultDeclarationKind::FunctionDeclaration(func) => {
                 func.id.as_ref().map_or_else(
                     || ExportLocalName::Null,
-                    |id| ExportLocalName::Name(NameSpan::new(id.name, id.span)),
+                    |id| ExportLocalName::Name(NameSpan::new(id.name.as_atom(), id.span)),
                 )
             }
             ExportDefaultDeclarationKind::ClassDeclaration(class) => class.id.as_ref().map_or_else(
                 || ExportLocalName::Null,
-                |id| ExportLocalName::Name(NameSpan::new(id.name, id.span)),
+                |id| ExportLocalName::Name(NameSpan::new(id.name.as_atom(), id.span)),
             ),
             ExportDefaultDeclarationKind::TSInterfaceDeclaration(t) => {
-                ExportLocalName::Name(NameSpan::new(t.id.name, t.id.span))
+                ExportLocalName::Name(NameSpan::new(t.id.name.as_atom(), t.id.span))
             }
             _ => ExportLocalName::Null,
         };
@@ -320,8 +324,10 @@ impl<'a> ModuleRecordBuilder<'a> {
 
         if let Some(d) = &decl.declaration {
             iter_binding_identifiers_of_declaration(d, &mut |ident| {
-                let export_name = ExportExportName::Name(NameSpan::new(ident.name, ident.span));
-                let local_name = ExportLocalName::Name(NameSpan::new(ident.name, ident.span));
+                let export_name =
+                    ExportExportName::Name(NameSpan::new(ident.name.as_atom(), ident.span));
+                let local_name =
+                    ExportLocalName::Name(NameSpan::new(ident.name.as_atom(), ident.span));
                 let export_entry = ExportEntry {
                     statement_span: decl.span,
                     span: d.span(),
@@ -338,12 +344,12 @@ impl<'a> ModuleRecordBuilder<'a> {
 
         for specifier in &decl.specifiers {
             let export_name = ExportExportName::Name(NameSpan::new(
-                specifier.exported.name(),
+                specifier.exported.name().as_atom(),
                 specifier.exported.span(),
             ));
             let import_name = if module_request.is_some() {
                 ExportImportName::Name(NameSpan::new(
-                    specifier.local.name(),
+                    specifier.local.name().as_atom(),
                     specifier.local.span(),
                 ))
             } else {
@@ -352,7 +358,10 @@ impl<'a> ModuleRecordBuilder<'a> {
             let local_name = if module_request.is_some() {
                 ExportLocalName::Null
             } else {
-                ExportLocalName::Name(NameSpan::new(specifier.local.name(), specifier.local.span()))
+                ExportLocalName::Name(NameSpan::new(
+                    specifier.local.name().as_atom(),
+                    specifier.local.span(),
+                ))
             };
             let export_entry = ExportEntry {
                 statement_span: decl.span,
diff --git a/crates/oxc_parser/src/ts/statement.rs b/crates/oxc_parser/src/ts/statement.rs
index b26a0d757aa10..75064304a94cf 100644
--- a/crates/oxc_parser/src/ts/statement.rs
+++ b/crates/oxc_parser/src/ts/statement.rs
@@ -1,6 +1,6 @@
 use oxc_allocator::{Box, Vec};
 use oxc_ast::ast::*;
-use oxc_span::GetSpan;
+use oxc_span::{GetSpan, Ident};
 
 use crate::{
     ParserImpl, diagnostics,
@@ -139,7 +139,7 @@ impl<'a> ParserImpl<'a> {
                 // `type something = intrinsic. ...`
                 let left_name = self.ast.ts_type_name_identifier_reference(
                     intrinsic_token.span(),
-                    self.token_source(&intrinsic_token),
+                    Ident::from(self.token_source(&intrinsic_token)),
                 );
                 let type_name =
                     self.parse_ts_qualified_type_name(intrinsic_token.start(), left_name);
diff --git a/crates/oxc_semantic/Cargo.toml b/crates/oxc_semantic/Cargo.toml
index da2e61c821523..70831a9b5dc4e 100644
--- a/crates/oxc_semantic/Cargo.toml
+++ b/crates/oxc_semantic/Cargo.toml
@@ -31,6 +31,7 @@ oxc_index = { workspace = true }
 oxc_span = { workspace = true }
 oxc_syntax = { workspace = true }
 
+hashbrown = { workspace = true }
 itertools = { workspace = true }
 phf = { workspace = true, features = ["macros"] }
 rustc-hash = { workspace = true }
diff --git a/crates/oxc_semantic/src/binder.rs b/crates/oxc_semantic/src/binder.rs
index 1dde0beb65974..0785f9d8083fe 100644
--- a/crates/oxc_semantic/src/binder.rs
+++ b/crates/oxc_semantic/src/binder.rs
@@ -39,7 +39,7 @@ impl<'a> Binder<'a> for VariableDeclarator<'a> {
 
         if self.kind.is_lexical() {
             self.id.bound_names(&mut |ident| {
-                let symbol_id = builder.declare_symbol(ident.span, &ident.name, includes, excludes);
+                let symbol_id = builder.declare_symbol(ident.span, ident.name, includes, excludes);
                 ident.symbol_id.set(Some(symbol_id));
             });
         } else {
@@ -64,7 +64,7 @@ impl<'a> Binder<'a> for VariableDeclarator<'a> {
 
                 for &scope_id in &var_scope_ids {
                     if let Some(symbol_id) =
-                        builder.check_redeclaration(scope_id, span, &name, excludes, true)
+                        builder.check_redeclaration(scope_id, span, name, excludes, true)
                     {
                         builder.add_redeclare_variable(symbol_id, includes, span);
                         declared_symbol_id = Some(symbol_id);
@@ -86,13 +86,7 @@ impl<'a> Binder<'a> for VariableDeclarator<'a> {
                 // we don't need to create another symbol with the same name
                 // to make sure they point to the same symbol.
                 let symbol_id = declared_symbol_id.unwrap_or_else(|| {
-                    builder.declare_symbol_on_scope(
-                        span,
-                        &name,
-                        target_scope_id,
-                        includes,
-                        excludes,
-                    )
+                    builder.declare_symbol_on_scope(span, name, target_scope_id, includes, excludes)
                 });
                 ident.symbol_id.set(Some(symbol_id));
 
@@ -128,7 +122,7 @@ impl<'a> Binder<'a> for Class<'a> {
         };
         let Some(ident) = &self.id else { return };
         let symbol_id =
-            builder.declare_symbol(ident.span, &ident.name, includes, SymbolFlags::ClassExcludes);
+            builder.declare_symbol(ident.span, ident.name, includes, SymbolFlags::ClassExcludes);
         ident.symbol_id.set(Some(symbol_id));
     }
 }
@@ -153,7 +147,7 @@ impl<'a> Binder<'a> for Function<'a> {
                 SymbolFlags::FunctionExcludes - SymbolFlags::FunctionScopedVariable
             };
 
-            let symbol_id = builder.declare_symbol(ident.span, &ident.name, includes, excludes);
+            let symbol_id = builder.declare_symbol(ident.span, ident.name, includes, excludes);
             ident.symbol_id.set(Some(symbol_id));
 
             // Save `@__NO_SIDE_EFFECTS__`
@@ -193,7 +187,7 @@ impl<'a> Binder<'a> for BindingRestElement<'a> {
         let excludes =
             SymbolFlags::FunctionScopedVariable | SymbolFlags::FunctionScopedVariableExcludes;
         self.bound_names(&mut |ident| {
-            let symbol_id = builder.declare_symbol(ident.span, &ident.name, includes, excludes);
+            let symbol_id = builder.declare_symbol(ident.span, ident.name, includes, excludes);
             ident.symbol_id.set(Some(symbol_id));
         });
     }
@@ -228,7 +222,7 @@ impl<'a> Binder<'a> for FormalParameter<'a> {
         };
 
         self.bound_names(&mut |ident| {
-            let symbol_id = builder.declare_symbol(ident.span, &ident.name, includes, excludes);
+            let symbol_id = builder.declare_symbol(ident.span, ident.name, includes, excludes);
             ident.symbol_id.set(Some(symbol_id));
         });
     }
@@ -249,7 +243,7 @@ impl<'a> Binder<'a> for CatchParameter<'a> {
             self.pattern.bound_names(&mut |ident| {
                 let symbol_id = builder.declare_symbol(
                     ident.span,
-                    &ident.name,
+                    ident.name,
                     SymbolFlags::BlockScopedVariable | SymbolFlags::CatchVariable,
                     SymbolFlags::BlockScopedVariableExcludes,
                 );
@@ -274,7 +268,7 @@ fn declare_symbol_for_import_specifier(
 
     let symbol_id = builder.declare_symbol(
         ident.span,
-        &ident.name,
+        ident.name,
         includes,
         SymbolFlags::ImportBindingExcludes,
     );
@@ -314,7 +308,7 @@ impl<'a> Binder<'a> for TSTypeAliasDeclaration<'a> {
         };
         let symbol_id = builder.declare_symbol(
             self.id.span,
-            &self.id.name,
+            self.id.name,
             includes,
             SymbolFlags::TypeAliasExcludes,
         );
@@ -331,7 +325,7 @@ impl<'a> Binder<'a> for TSInterfaceDeclaration<'a> {
         };
         let symbol_id = builder.declare_symbol(
             self.id.span,
-            &self.id.name,
+            self.id.name,
             includes,
             SymbolFlags::InterfaceExcludes,
         );
@@ -348,7 +342,7 @@ impl<'a> Binder<'a> for TSEnumDeclaration<'a> {
         } else {
             (SymbolFlags::RegularEnum | includes, SymbolFlags::RegularEnumExcludes)
         };
-        let symbol_id = builder.declare_symbol(self.id.span, &self.id.name, includes, excludes);
+        let symbol_id = builder.declare_symbol(self.id.span, self.id.name, includes, excludes);
         self.id.symbol_id.set(Some(symbol_id));
     }
 }
@@ -357,7 +351,7 @@ impl<'a> Binder<'a> for TSEnumMember<'a> {
     fn bind(&self, builder: &mut SemanticBuilder) {
         builder.declare_symbol(
             self.span,
-            self.id.static_name().as_str(),
+            self.id.static_name(),
             SymbolFlags::EnumMember,
             SymbolFlags::EnumMemberExcludes,
         );
@@ -378,7 +372,7 @@ impl<'a> Binder<'a> for TSModuleDeclaration<'a> {
         if self.declare {
             includes |= SymbolFlags::Ambient;
         }
-        let symbol_id = builder.declare_symbol(id.span, &id.name, includes, excludes);
+        let symbol_id = builder.declare_symbol(id.span, id.name, includes, excludes);
 
         id.set_symbol_id(symbol_id);
     }
@@ -657,7 +651,7 @@ impl<'a> Binder<'a> for TSTypeParameter<'a> {
 
         let symbol_id = builder.declare_symbol_on_scope(
             self.name.span,
-            &self.name.name,
+            self.name.name,
             scope_id.unwrap_or(builder.current_scope_id),
             SymbolFlags::TypeParameter,
             SymbolFlags::TypeParameterExcludes,
diff --git a/crates/oxc_semantic/src/builder.rs b/crates/oxc_semantic/src/builder.rs
index 781702baa3c06..7b250ceea561e 100644
--- a/crates/oxc_semantic/src/builder.rs
+++ b/crates/oxc_semantic/src/builder.rs
@@ -16,7 +16,7 @@ use oxc_cfg::{
     IterationInstructionKind, ReturnInstructionKind,
 };
 use oxc_diagnostics::OxcDiagnostic;
-use oxc_span::{Atom, SourceType, Span};
+use oxc_span::{Ident, IdentHashMap, SourceType, Span};
 use oxc_syntax::{
     node::{NodeFlags, NodeId},
     reference::{Reference, ReferenceFlags, ReferenceId},
@@ -81,7 +81,7 @@ pub struct SemanticBuilder<'a> {
     pub(crate) current_function_node_id: NodeId,
     pub(crate) module_instance_state_cache: FxHashMap<Address, ModuleInstanceState>,
     current_reference_flags: ReferenceFlags,
-    pub(crate) hoisting_variables: FxHashMap<ScopeId, FxHashMap<Atom<'a>, SymbolId>>,
+    pub(crate) hoisting_variables: FxHashMap<ScopeId, IdentHashMap<'a, SymbolId>>,
 
     // builders
     pub(crate) nodes: AstNodes<'a>,
@@ -278,9 +278,8 @@ impl<'a> SemanticBuilder<'a> {
         }
 
         debug_assert_eq!(self.unresolved_references.scope_depth(), 1);
-        self.scoping.set_root_unresolved_references(
-            self.unresolved_references.into_root().into_iter().map(|(k, v)| (k.as_str(), v)),
-        );
+        self.scoping
+            .set_root_unresolved_references(self.unresolved_references.into_root().into_iter());
 
         #[cfg(feature = "linter")]
         let jsdoc = self.jsdoc.build();
@@ -402,7 +401,7 @@ impl<'a> SemanticBuilder<'a> {
     pub(crate) fn declare_symbol_on_scope(
         &mut self,
         span: Span,
-        name: &str,
+        name: Ident<'_>,
         scope_id: ScopeId,
         includes: SymbolFlags,
         excludes: SymbolFlags,
@@ -414,9 +413,9 @@ impl<'a> SemanticBuilder<'a> {
         }
 
         let symbol_id =
-            self.scoping.create_symbol(span, name, includes, scope_id, self.current_node_id);
+            self.scoping.create_symbol(span, &name, includes, scope_id, self.current_node_id);
 
-        self.scoping.add_binding(scope_id, name, symbol_id);
+        self.scoping.add_binding(scope_id, &name, symbol_id);
         symbol_id
     }
 
@@ -424,7 +423,7 @@ impl<'a> SemanticBuilder<'a> {
     pub(crate) fn declare_symbol(
         &mut self,
         span: Span,
-        name: &str,
+        name: Ident<'_>,
         includes: SymbolFlags,
         excludes: SymbolFlags,
     ) -> SymbolId {
@@ -439,12 +438,12 @@ impl<'a> SemanticBuilder<'a> {
         &self,
         scope_id: ScopeId,
         span: Span,
-        name: &str,
+        name: Ident<'_>,
         excludes: SymbolFlags,
         report_error: bool,
     ) -> Option<SymbolId> {
-        let symbol_id = self.scoping.get_binding(scope_id, name).or_else(|| {
-            self.hoisting_variables.get(&scope_id).and_then(|symbols| symbols.get(name).copied())
+        let symbol_id = self.scoping.get_binding(scope_id, &name).or_else(|| {
+            self.hoisting_variables.get(&scope_id).and_then(|symbols| symbols.get(&name).copied())
         })?;
 
         // `(function n(n) {})()`
@@ -467,7 +466,7 @@ impl<'a> SemanticBuilder<'a> {
             let flags = self.scoping.symbol_flags(symbol_id);
             if flags.intersects(excludes) {
                 let symbol_span = self.scoping.symbol_span(symbol_id);
-                self.error(redeclaration(name, symbol_span, span));
+                self.error(redeclaration(&name, symbol_span, span));
             }
         }
 
@@ -479,7 +478,7 @@ impl<'a> SemanticBuilder<'a> {
     /// # Panics
     pub(crate) fn declare_reference(
         &mut self,
-        name: Atom<'a>,
+        name: Ident<'a>,
         reference: Reference,
     ) -> ReferenceId {
         let reference_id = self.scoping.create_reference(reference);
@@ -491,7 +490,7 @@ impl<'a> SemanticBuilder<'a> {
     /// Declares a `Symbol` for the node, shadowing previous declarations in the same scope.
     pub(crate) fn declare_shadow_symbol(
         &mut self,
-        name: &str,
+        name: &Ident,
         span: Span,
         scope_id: ScopeId,
         includes: SymbolFlags,
@@ -518,7 +517,7 @@ impl<'a> SemanticBuilder<'a> {
             // Try to resolve a reference.
             // If unresolved, transfer it to parent scope's unresolved references.
             let bindings = self.scoping.get_bindings(self.current_scope_id);
-            if let Some(symbol_id) = bindings.get(name.as_str()).copied() {
+            if let Some(symbol_id) = bindings.get(&name).copied() {
                 let symbol_flags = self.scoping.symbol_flags(symbol_id);
                 references.retain(|&reference_id| {
                     let reference = &mut self.scoping.references[reference_id];
diff --git a/crates/oxc_semantic/src/checker/typescript.rs b/crates/oxc_semantic/src/checker/typescript.rs
index 8e5601e974be7..f3945a95c1a55 100644
--- a/crates/oxc_semantic/src/checker/typescript.rs
+++ b/crates/oxc_semantic/src/checker/typescript.rs
@@ -1,12 +1,11 @@
 use std::borrow::Cow;
 
 use itertools::Itertools;
-use rustc_hash::FxHashMap;
 
 use oxc_ast::{AstKind, ast::*};
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_ecmascript::BoundNames;
-use oxc_span::{Atom, GetSpan, Span};
+use oxc_span::{GetSpan, IdentHashMap, Span};
 
 use crate::{builder::SemanticBuilder, diagnostics::redeclaration};
 
@@ -126,7 +125,7 @@ pub fn check_formal_parameters(params: &FormalParameters, ctx: &SemanticBuilder<
 }
 
 fn check_duplicate_bound_names<'a, T: BoundNames<'a>>(bound_names: &T, ctx: &SemanticBuilder<'_>) {
-    let mut idents: FxHashMap<Atom<'a>, Span> = FxHashMap::default();
+    let mut idents = IdentHashMap::default();
     bound_names.bound_names(&mut |ident| {
         if let Some(old_span) = idents.insert(ident.name, ident.span) {
             ctx.error(redeclaration(&ident.name, old_span, ident.span));
diff --git a/crates/oxc_semantic/src/class/table.rs b/crates/oxc_semantic/src/class/table.rs
index 13c379a18a331..eb02d49e6d788 100644
--- a/crates/oxc_semantic/src/class/table.rs
+++ b/crates/oxc_semantic/src/class/table.rs
@@ -3,7 +3,7 @@ use std::borrow::Cow;
 use rustc_hash::FxHashMap;
 
 use oxc_index::IndexVec;
-use oxc_span::{Atom, Span};
+use oxc_span::{Ident, Span};
 use oxc_syntax::{
     class::{ClassId, ElementId, ElementKind},
     node::NodeId,
@@ -33,13 +33,13 @@ impl<'a> Element<'a> {
 #[derive(Debug)]
 pub struct PrivateIdentifierReference<'a> {
     pub id: NodeId,
-    pub name: Atom<'a>,
+    pub name: Ident<'a>,
     pub span: Span,
     pub element_ids: Vec<ElementId>,
 }
 
 impl<'a> PrivateIdentifierReference<'a> {
-    pub fn new(id: NodeId, name: Atom<'a>, span: Span, element_ids: Vec<ElementId>) -> Self {
+    pub fn new(id: NodeId, name: Ident<'a>, span: Span, element_ids: Vec<ElementId>) -> Self {
         Self { id, name, span, element_ids }
     }
 }
diff --git a/crates/oxc_semantic/src/lib.rs b/crates/oxc_semantic/src/lib.rs
index b06af0b4c2cb2..85fee9cc683e5 100644
--- a/crates/oxc_semantic/src/lib.rs
+++ b/crates/oxc_semantic/src/lib.rs
@@ -256,7 +256,7 @@ impl<'a> Semantic<'a> {
 mod tests {
     use oxc_allocator::Allocator;
     use oxc_ast::{AstKind, ast::VariableDeclarationKind};
-    use oxc_span::{Atom, SourceType};
+    use oxc_span::{Ident, SourceType};
 
     use super::*;
 
@@ -284,8 +284,10 @@ mod tests {
         let allocator = Allocator::default();
         let semantic = get_semantic(&allocator, source, SourceType::default());
 
-        let top_level_a =
-            semantic.scoping().get_binding(semantic.scoping().root_scope_id(), "a").unwrap();
+        let top_level_a = semantic
+            .scoping()
+            .get_binding(semantic.scoping().root_scope_id(), &Ident::from("a"))
+            .unwrap();
 
         let decl = semantic.symbol_declaration(top_level_a);
         match decl.kind() {
@@ -306,7 +308,7 @@ mod tests {
         let semantic = get_semantic(&allocator, source, SourceType::default());
         let scopes = semantic.scoping();
 
-        assert!(scopes.get_binding(scopes.root_scope_id(), "Fn").is_some());
+        assert!(scopes.get_binding(scopes.root_scope_id(), &Ident::from("Fn")).is_some());
     }
 
     #[test]
@@ -340,7 +342,7 @@ mod tests {
     #[test]
     fn test_reference_resolutions_simple_read_write() {
         let alloc = Allocator::default();
-        let target_symbol_name = Atom::from("a");
+        let target_symbol_name = Ident::from("a");
         let typescript = SourceType::ts();
         let sources = [
             // simple cases
diff --git a/crates/oxc_semantic/src/scoping.rs b/crates/oxc_semantic/src/scoping.rs
index 1ab782a7d8958..393f4daf876e0 100644
--- a/crates/oxc_semantic/src/scoping.rs
+++ b/crates/oxc_semantic/src/scoping.rs
@@ -3,9 +3,9 @@ use std::{collections::hash_map::Entry, fmt, mem};
 use rustc_hash::{FxHashMap, FxHashSet};
 use self_cell::self_cell;
 
-use oxc_allocator::{Allocator, CloneIn, FromIn, HashMap as ArenaHashMap, Vec as ArenaVec};
+use oxc_allocator::{Allocator, CloneIn, FromIn, Vec as ArenaVec};
 use oxc_index::IndexVec;
-use oxc_span::{Atom, Span};
+use oxc_span::{ArenaIdentHashMap, Ident, Span};
 use oxc_syntax::{
     node::NodeId,
     reference::{Reference, ReferenceId},
@@ -13,8 +13,11 @@ use oxc_syntax::{
     symbol::{SymbolFlags, SymbolId},
 };
 
-pub type Bindings<'a> = ArenaHashMap<'a, &'a str, SymbolId>;
-pub type UnresolvedReferences<'a> = ArenaHashMap<'a, &'a str, ArenaVec<'a, ReferenceId>>;
+// pub type Bindings<'a> = ArenaHashMap<'a, &'a str, SymbolId, FxBuildHasher>;
+pub type Bindings<'a> = ArenaIdentHashMap<'a, SymbolId>;
+// pub type UnresolvedReferences<'a> =
+//     ArenaHashMap<'a, &'a str, ArenaVec<'a, ReferenceId>, FxBuildHasher>;
+pub type UnresolvedReferences<'a> = ArenaIdentHashMap<'a, ArenaVec<'a, ReferenceId>>;
 
 #[derive(Clone, Debug)]
 pub struct Redeclaration {
@@ -252,7 +255,7 @@ use scoping_cell::ScopingCell;
 
 pub struct ScopingInner<'cell> {
     /* Symbol Table Fields */
-    symbol_names: ArenaVec<'cell, Atom<'cell>>,
+    symbol_names: ArenaVec<'cell, Ident<'cell>>,
     resolved_references: ArenaVec<'cell, ArenaVec<'cell, ReferenceId>>,
     /// Redeclarations of a symbol.
     ///
@@ -287,8 +290,8 @@ impl Scoping {
         self.symbol_spans.is_empty()
     }
 
-    pub fn symbol_names(&self) -> impl Iterator<Item = &str> + '_ {
-        self.cell.borrow_dependent().symbol_names.iter().map(Atom::as_str)
+    pub fn symbol_names(&self) -> impl Iterator<Item = &Ident<'_>> + '_ {
+        self.cell.borrow_dependent().symbol_names.iter()
     }
 
     pub fn resolved_references(&self) -> impl Iterator<Item = &ArenaVec<'_, ReferenceId>> + '_ {
@@ -325,7 +328,7 @@ impl Scoping {
     #[inline]
     pub fn set_symbol_name(&mut self, symbol_id: SymbolId, name: &str) {
         self.cell.with_dependent_mut(|allocator, cell| {
-            cell.symbol_names[symbol_id.index()] = Atom::from_in(name, allocator);
+            cell.symbol_names[symbol_id.index()] = Ident::from_in(name, allocator);
         });
     }
 
@@ -393,7 +396,7 @@ impl Scoping {
         node_id: NodeId,
     ) -> SymbolId {
         self.cell.with_dependent_mut(|allocator, cell| {
-            cell.symbol_names.push(Atom::from_in(name, allocator));
+            cell.symbol_names.push(Ident::from_in(name, allocator));
             cell.resolved_references.push(ArenaVec::new_in(allocator));
         });
         self.symbol_spans.push(span);
@@ -627,11 +630,11 @@ impl Scoping {
 
     pub(crate) fn set_root_unresolved_references<'a>(
         &mut self,
-        entries: impl Iterator<Item = (&'a str, Vec<ReferenceId>)>,
+        entries: impl Iterator<Item = (Ident<'a>, Vec<ReferenceId>)>,
     ) {
         self.cell.with_dependent_mut(|allocator, cell| {
             for (k, v) in entries {
-                let k = allocator.alloc_str(k);
+                let k = k.clone_in(allocator);
                 let v = ArenaVec::from_iter_in(v, allocator);
                 cell.root_unresolved_references.insert(k, v);
             }
@@ -647,18 +650,20 @@ impl Scoping {
     /// Panics if there is no unresolved reference for provided `name` and `reference_id`.
     #[inline]
     pub fn delete_root_unresolved_reference(&mut self, name: &str, reference_id: ReferenceId) {
-        // It would be better to use `Entry` API to avoid 2 hash table lookups when deleting,
-        // but `map.entry` requires an owned key to be provided. Currently we use `CompactStr`s as keys
-        // which are not cheap to construct, so this is best we can do at present.
-        // TODO: Switch to `Entry` API once we use `&str`s or `Atom`s as keys.
-        self.cell.with_dependent_mut(|_allocator, cell| {
-            let reference_ids = cell.root_unresolved_references.get_mut(name).unwrap();
-            if reference_ids.len() == 1 {
-                assert_eq!(reference_ids[0], reference_id);
-                cell.root_unresolved_references.remove(name);
-            } else {
-                let index = reference_ids.iter().position(|&id| id == reference_id).unwrap();
-                reference_ids.swap_remove(index);
+        self.cell.with_dependent_mut(|allocator, cell| {
+            let name = Ident::from_in(name, allocator);
+            match cell.root_unresolved_references.entry(name) {
+                hashbrown::hash_map::Entry::Occupied(mut occupied) => {
+                    let reference_ids = occupied.get_mut();
+                    let index = reference_ids.iter().position(|&id| id == reference_id).unwrap();
+                    if reference_ids.len() == 1 {
+                        assert_eq!(reference_ids[0], reference_id);
+                        occupied.remove();
+                    } else {
+                        reference_ids.swap_remove(index);
+                    }
+                }
+                hashbrown::hash_map::Entry::Vacant(_) => unreachable!(),
             }
         });
     }
@@ -732,13 +737,13 @@ impl Scoping {
 
     /// Get a variable binding by name that was declared in the top-level scope
     #[inline]
-    pub fn get_root_binding(&self, name: &str) -> Option<SymbolId> {
+    pub fn get_root_binding(&self, name: &Ident) -> Option<SymbolId> {
         self.get_binding(self.root_scope_id(), name)
     }
 
-    pub fn add_root_unresolved_reference(&mut self, name: &str, reference_id: ReferenceId) {
+    pub fn add_root_unresolved_reference(&mut self, name: &Ident, reference_id: ReferenceId) {
         self.cell.with_dependent_mut(|allocator, cell| {
-            let name = allocator.alloc_str(name);
+            let name = name.clone_in(allocator);
             cell.root_unresolved_references
                 .entry(name)
                 .or_insert_with(|| ArenaVec::new_in(allocator))
@@ -747,7 +752,7 @@ impl Scoping {
     }
 
     /// Check if a symbol is declared in a certain scope.
-    pub fn scope_has_binding(&self, scope_id: ScopeId, name: &str) -> bool {
+    pub fn scope_has_binding(&self, scope_id: ScopeId, name: &Ident) -> bool {
         self.cell.borrow_dependent().bindings[scope_id].contains_key(name)
     }
 
@@ -759,7 +764,7 @@ impl Scoping {
     /// binding that might be declared in a parent scope, use [`find_binding`].
     ///
     /// [`find_binding`]: Scoping::find_binding
-    pub fn get_binding(&self, scope_id: ScopeId, name: &str) -> Option<SymbolId> {
+    pub fn get_binding(&self, scope_id: ScopeId, name: &Ident) -> Option<SymbolId> {
         self.cell.borrow_dependent().bindings[scope_id].get(name).copied()
     }
 
@@ -767,7 +772,7 @@ impl Scoping {
     ///
     /// Bindings are resolved by walking up the scope tree until a binding is
     /// found. If no binding is found, [`None`] is returned.
-    pub fn find_binding(&self, scope_id: ScopeId, name: &str) -> Option<SymbolId> {
+    pub fn find_binding(&self, scope_id: ScopeId, name: &Ident) -> Option<SymbolId> {
         for scope_id in self.scope_ancestors(scope_id) {
             if let Some(symbol_id) = self.get_binding(scope_id, name) {
                 return Some(symbol_id);
@@ -806,9 +811,9 @@ impl Scoping {
     }
 
     #[inline]
-    pub(crate) fn insert_binding(&mut self, scope_id: ScopeId, name: &str, symbol_id: SymbolId) {
+    pub(crate) fn insert_binding(&mut self, scope_id: ScopeId, name: &Ident, symbol_id: SymbolId) {
         self.cell.with_dependent_mut(|allocator, cell| {
-            let name = allocator.alloc_str(name);
+            let name = name.clone_in(allocator);
             cell.bindings[scope_id].insert(name, symbol_id);
         });
     }
@@ -890,25 +895,26 @@ impl Scoping {
     }
 
     /// Add a binding to a scope.
-    pub fn add_binding(&mut self, scope_id: ScopeId, name: &str, symbol_id: SymbolId) {
+    pub fn add_binding(&mut self, scope_id: ScopeId, name: &Ident, symbol_id: SymbolId) {
         self.cell.with_dependent_mut(|allocator, cell| {
-            let name = allocator.alloc_str(name);
+            let name = name.clone_in(allocator);
             cell.bindings[scope_id].insert(name, symbol_id);
         });
     }
 
     /// Remove an existing binding from a scope.
-    pub fn remove_binding(&mut self, scope_id: ScopeId, name: &str) {
-        self.cell.with_dependent_mut(|_allocator, cell| {
-            cell.bindings[scope_id].remove(name);
+    pub fn remove_binding(&mut self, scope_id: ScopeId, name: &Ident) {
+        self.cell.with_dependent_mut(|allocator, cell| {
+            let name = name.clone_in(allocator);
+            cell.bindings[scope_id].remove(&name);
         });
     }
 
     /// Move a binding from one scope to another.
-    pub fn move_binding(&mut self, from: ScopeId, to: ScopeId, name: &str) {
-        self.cell.with_dependent_mut(|_allocator, cell| {
-            let from_map = &mut cell.bindings[from];
-            if let Some((name, symbol_id)) = from_map.remove_entry(name) {
+    pub fn move_binding(&mut self, from: ScopeId, to: ScopeId, name: &Ident) {
+        self.cell.with_dependent_mut(|allocator, cell| {
+            let name = name.clone_in(allocator);
+            if let Some(symbol_id) = cell.bindings[from].remove(&name) {
                 cell.bindings[to].insert(name, symbol_id);
             }
         });
@@ -926,14 +932,15 @@ impl Scoping {
         &mut self,
         scope_id: ScopeId,
         symbol_id: SymbolId,
-        old_name: &str,
-        new_name: &str,
+        old_name: &Ident,
+        new_name: &Ident,
     ) {
         self.cell.with_dependent_mut(|allocator, cell| {
+            let old_name = old_name.clone_in(allocator);
             let bindings = &mut cell.bindings[scope_id];
-            let old_symbol_id = bindings.remove(old_name);
+            let old_symbol_id = bindings.remove(&old_name);
             debug_assert_eq!(old_symbol_id, Some(symbol_id));
-            let new_name = allocator.alloc_str(new_name);
+            let new_name = new_name.clone_in(allocator);
             let existing_symbol_id = bindings.insert(new_name, symbol_id);
             debug_assert!(existing_symbol_id.is_none());
         });
@@ -948,16 +955,14 @@ impl Scoping {
     /// Panics in debug mode if either of the above are not satisfied.
     pub fn rename_symbol(&mut self, symbol_id: SymbolId, scope_id: ScopeId, new_name: &str) {
         self.cell.with_dependent_mut(|allocator, cell| {
-            // Rename symbol
-            let new_name = Atom::from_in(new_name, allocator);
-            let old_name = mem::replace(&mut cell.symbol_names[symbol_id.index()], new_name);
-
-            // Rename binding, same as `Self::rename_binding`, we cannot call it directly
-            // because the `old_name` borrowed `cell`.
+            // Get old name before replacing it and clone it into the allocator
+            let old_name = cell.symbol_names[symbol_id.index()].clone_in(allocator);
             let bindings = &mut cell.bindings[scope_id];
-            let old_symbol_id = bindings.remove(old_name.as_str());
+            let old_symbol_id = bindings.remove(&old_name);
             debug_assert_eq!(old_symbol_id, Some(symbol_id));
-            let existing_symbol_id = bindings.insert(new_name.as_str(), symbol_id);
+            let new_name = Ident::from_in(new_name, allocator);
+            cell.symbol_names[symbol_id.index()] = new_name;
+            let existing_symbol_id = bindings.insert(new_name, symbol_id);
             debug_assert!(existing_symbol_id.is_none());
         });
     }
diff --git a/crates/oxc_semantic/src/unresolved_stack.rs b/crates/oxc_semantic/src/unresolved_stack.rs
index afd7070ba9171..0d7b5b2d7eb5f 100644
--- a/crates/oxc_semantic/src/unresolved_stack.rs
+++ b/crates/oxc_semantic/src/unresolved_stack.rs
@@ -1,12 +1,11 @@
-use rustc_hash::FxHashMap;
-
 use oxc_data_structures::assert_unchecked;
-use oxc_span::Atom;
+use oxc_span::IdentHashMap;
 use oxc_syntax::reference::ReferenceId;
 
+// TODO: Update this comment.
 /// Unlike `ScopeTree`'s `UnresolvedReferences`, this type uses `Atom` as the key,
 /// and uses a heap-allocated hashmap (not arena-allocated)
-type TempUnresolvedReferences<'a> = FxHashMap<Atom<'a>, Vec<ReferenceId>>;
+type TempUnresolvedReferences<'a> = IdentHashMap<'a, Vec<ReferenceId>>;
 
 // Stack used to accumulate unresolved refs while traversing scopes.
 // Indexed by scope depth. We recycle `UnresolvedReferences` instances during traversal
diff --git a/crates/oxc_semantic/tests/integration/util/symbol_tester.rs b/crates/oxc_semantic/tests/integration/util/symbol_tester.rs
index 98facda3c95f7..0e9d7d2727091 100644
--- a/crates/oxc_semantic/tests/integration/util/symbol_tester.rs
+++ b/crates/oxc_semantic/tests/integration/util/symbol_tester.rs
@@ -2,6 +2,7 @@ use std::rc::Rc;
 
 use oxc_diagnostics::{Error, OxcDiagnostic};
 use oxc_semantic::{Reference, ScopeFlags, Semantic, SymbolFlags, SymbolId};
+use oxc_span::Ident;
 
 use super::{Expect, SemanticTester};
 
@@ -46,7 +47,9 @@ impl<'a> SymbolTester<'a> {
         semantic: Semantic<'a>,
         target: &str,
     ) -> Self {
-        let decl = semantic.scoping().get_binding(semantic.scoping().root_scope_id(), target);
+        let decl = semantic
+            .scoping()
+            .get_binding(semantic.scoping().root_scope_id(), &Ident::from(target));
         let data = decl.map_or_else(
             || Err(OxcDiagnostic::error(format!("Could not find declaration for {target}"))),
             Ok,
diff --git a/crates/oxc_span/Cargo.toml b/crates/oxc_span/Cargo.toml
index c42fab4023f86..8e34cd483dc84 100644
--- a/crates/oxc_span/Cargo.toml
+++ b/crates/oxc_span/Cargo.toml
@@ -27,6 +27,7 @@ oxc_estree = { workspace = true }
 compact_str = { workspace = true }
 miette = { workspace = true }
 
+rustc-hash = { workspace = true }
 schemars = { workspace = true, optional = true }
 serde = { workspace = true, optional = true }
 
diff --git a/crates/oxc_span/src/atom.rs b/crates/oxc_span/src/atom.rs
index 8b02fc78a5aa5..b5263c2c82bcd 100644
--- a/crates/oxc_span/src/atom.rs
+++ b/crates/oxc_span/src/atom.rs
@@ -10,7 +10,7 @@ use oxc_estree::{ESTree, Serializer as ESTreeSerializer};
 #[cfg(feature = "serialize")]
 use serde::{Serialize, Serializer as SerdeSerializer};
 
-use crate::{CompactStr, ContentEq};
+use crate::{CompactStr, ContentEq, Ident};
 
 /// An inlinable string for oxc_allocator.
 ///
@@ -252,6 +252,13 @@ impl PartialEq<str> for Atom<'_> {
     }
 }
 
+impl PartialEq<Ident<'_>> for Atom<'_> {
+    #[inline]
+    fn eq(&self, other: &Ident<'_>) -> bool {
+        self.as_str() == other.as_str()
+    }
+}
+
 impl PartialEq<Atom<'_>> for Cow<'_, str> {
     #[inline]
     fn eq(&self, other: &Atom<'_>) -> bool {
diff --git a/crates/oxc_span/src/ident.rs b/crates/oxc_span/src/ident.rs
new file mode 100644
index 0000000000000..0d8269acf4b8f
--- /dev/null
+++ b/crates/oxc_span/src/ident.rs
@@ -0,0 +1,410 @@
+#![expect(
+    missing_docs,
+    clippy::cast_possible_truncation,
+    clippy::len_without_is_empty,
+    clippy::undocumented_unsafe_blocks,
+    clippy::cast_lossless
+)] // TODO
+use oxc_allocator::{Allocator, CloneIn, Dummy, FromIn};
+
+use rustc_hash::FxHasher;
+
+use std::{
+    borrow::{Borrow, Cow},
+    hash::{BuildHasher, Hash, Hasher},
+    marker::PhantomData,
+    ops::Deref,
+    ptr::NonNull,
+};
+
+#[cfg(feature = "serialize")]
+use oxc_estree::{ESTree, Serializer as ESTreeSerializer};
+#[cfg(feature = "serialize")]
+use serde::{Serialize, Serializer as SerdeSerializer};
+
+use crate::{Atom, CompactStr, ContentEq};
+
+#[cfg(target_pointer_width = "64")]
+const ROTATE: u32 = 26;
+#[cfg(target_pointer_width = "32")]
+const ROTATE: u32 = 15;
+
+#[derive(Clone, Copy, Eq)]
+pub struct Ident<'a> {
+    ptr: NonNull<u8>,
+    // Length in bottom 32 bits, hash in top 32 bits
+    len_and_hash: u64,
+    _marker: PhantomData<&'a str>,
+}
+
+impl<'a> Ident<'a> {
+    pub fn new(s: &'a str) -> Self {
+        let ptr = NonNull::from(s).cast::<u8>();
+
+        // Produce a hash of the string
+        let hash = {
+            let mut hasher = FxHasher::default();
+            s.hash(&mut hasher);
+            hasher.finish()
+        };
+
+        // `FxHasher::finish` performs a rotation.
+        // That's not what we want as we want the highest entropy bits in top 32 bits.
+        // Undo that rotation here by rotating back in the opposite direction.
+        // This code is the exact reverse of the code in `FxHasher::finish`,
+        // so compiler should see that together they make a no-op, and remove both rotations.
+        let hash = hash.rotate_right(ROTATE);
+
+        // With FxHasher, highest entropy is in top 32 bits. Clear bottom 32 bits.
+        let hash = hash & !(u32::MAX as u64);
+        // We know `s.len()` is <= u32::MAX so don't bother masking it
+        let len = s.len() as u64;
+
+        let len_and_hash = len | hash;
+
+        Self { ptr, len_and_hash, _marker: PhantomData }
+    }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        // Length is in bottom 32 bits
+        self.len_and_hash as u32 as usize
+    }
+
+    pub fn as_str(self) -> &'a str {
+        unsafe {
+            let slice = std::slice::from_raw_parts(self.ptr.as_ptr(), self.len());
+            std::str::from_utf8_unchecked(slice)
+        }
+    }
+
+    #[inline]
+    pub fn as_atom(&self) -> Atom<'a> {
+        Atom::from(self.as_str())
+    }
+
+    #[inline]
+    pub fn from_cow_in(value: &Cow<'a, str>, allocator: &'a Allocator) -> Ident<'a> {
+        match value {
+            Cow::Borrowed(s) => Ident::from(*s),
+            Cow::Owned(s) => Ident::from_in(s, allocator),
+        }
+    }
+
+    #[inline]
+    pub fn into_compact_str(self) -> CompactStr {
+        CompactStr::new(self.as_str())
+    }
+
+    #[expect(clippy::inline_always)]
+    #[inline(always)]
+    pub fn from_strs_array_in<const N: usize>(
+        strings: [&str; N],
+        allocator: &'a Allocator,
+    ) -> Ident<'a> {
+        Self::from(allocator.alloc_concat_strs_array(strings))
+    }
+}
+
+impl PartialEq for Ident<'_> {
+    #[inline]
+    fn eq(&self, other: &Ident<'_>) -> bool {
+        // Skip full string comparison unless *both* length and hash match.
+        // So we get faster `==` as well as faster hashing.
+        self.len_and_hash == other.len_and_hash && self.as_str() == other.as_str()
+    }
+}
+
+impl PartialEq<str> for Ident<'_> {
+    #[inline]
+    fn eq(&self, other: &str) -> bool {
+        self.as_str() == other
+    }
+}
+
+impl PartialEq<Ident<'_>> for Cow<'_, str> {
+    #[inline]
+    fn eq(&self, other: &Ident<'_>) -> bool {
+        self.as_ref() == other.as_str()
+    }
+}
+
+impl<T: AsRef<str>> PartialEq<T> for Ident<'_> {
+    #[inline]
+    fn eq(&self, other: &T) -> bool {
+        self.as_str() == other.as_ref()
+    }
+}
+
+impl ContentEq for Ident<'_> {
+    #[inline]
+    fn content_eq(&self, other: &Self) -> bool {
+        self == other
+    }
+}
+
+impl AsRef<str> for &Ident<'_> {
+    #[expect(clippy::inline_always)]
+    #[inline(always)] // Because this is a no-op
+    fn as_ref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl Deref for Ident<'_> {
+    type Target = str;
+
+    #[expect(clippy::inline_always)]
+    #[inline(always)] // Because this is a no-op
+    fn deref(&self) -> &Self::Target {
+        self.as_str()
+    }
+}
+
+impl Borrow<str> for Ident<'_> {
+    #[expect(clippy::inline_always)]
+    #[inline(always)] // Because this is a no-op
+    fn borrow(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl<'a> From<&'a str> for Ident<'a> {
+    #[expect(clippy::inline_always)]
+    #[inline(always)] // Because this is a no-op
+    fn from(s: &'a str) -> Self {
+        Self::new(s)
+    }
+}
+
+impl<'a> From<Ident<'a>> for Atom<'a> {
+    #[inline]
+    fn from(val: Ident<'a>) -> Self {
+        val.as_atom()
+    }
+}
+
+impl<'a> From<Atom<'a>> for Ident<'a> {
+    #[inline]
+    fn from(atom: Atom<'a>) -> Self {
+        Self::new(atom.as_str())
+    }
+}
+
+impl<'a> From<Ident<'a>> for CompactStr {
+    #[inline]
+    fn from(ident: Ident<'a>) -> Self {
+        ident.into_compact_str()
+    }
+}
+
+impl<'a> From<Ident<'a>> for Cow<'a, str> {
+    #[expect(clippy::inline_always)]
+    #[inline(always)] // Because this is a no-op
+    fn from(ident: Ident<'a>) -> Self {
+        Cow::Borrowed(ident.as_str())
+    }
+}
+
+impl<'alloc> FromIn<'alloc, &Ident<'alloc>> for Ident<'alloc> {
+    #[expect(clippy::inline_always)]
+    #[inline(always)] // Because this is a no-op
+    fn from_in(s: &Ident<'alloc>, _: &'alloc Allocator) -> Self {
+        *s
+    }
+}
+
+impl<'alloc> FromIn<'alloc, &str> for Ident<'alloc> {
+    #[inline]
+    fn from_in(s: &str, allocator: &'alloc Allocator) -> Self {
+        Self::from(allocator.alloc_str(s))
+    }
+}
+
+impl<'alloc> FromIn<'alloc, String> for Ident<'alloc> {
+    #[inline]
+    fn from_in(s: String, allocator: &'alloc Allocator) -> Self {
+        Self::from(allocator.alloc_str(&s))
+    }
+}
+
+impl<'alloc> FromIn<'alloc, &String> for Ident<'alloc> {
+    #[inline]
+    fn from_in(s: &String, allocator: &'alloc Allocator) -> Self {
+        Self::from(allocator.alloc_str(s))
+    }
+}
+
+// TODO: Add rest of `FromIn` impls for `Ident`
+
+impl<'new_alloc> CloneIn<'new_alloc> for Ident<'_> {
+    type Cloned = Ident<'new_alloc>;
+
+    #[inline]
+    fn clone_in(&self, allocator: &'new_alloc Allocator) -> Self::Cloned {
+        let s = allocator.alloc_str(self.as_str());
+        let ptr = NonNull::from(s).cast::<u8>();
+        Ident { ptr, len_and_hash: self.len_and_hash, _marker: PhantomData }
+    }
+}
+
+impl<'a> Dummy<'a> for Ident<'a> {
+    /// Create a dummy [`Ident`].
+    #[expect(clippy::inline_always)]
+    #[inline(always)]
+    fn dummy(_allocator: &'a Allocator) -> Self {
+        Ident::new("")
+    }
+}
+
+// Only use this `Hash` impl with `IdentHashMap`
+impl Hash for Ident<'_> {
+    #[inline]
+    fn hash<H: Hasher>(&self, hasher: &mut H) {
+        // Hash is stored in top 32 bits of `len_and_hash`.
+        // `hashbrown` only uses top 7 bits and bottom N bits of hash,
+        // where N is the exponent of number of buckets in the hash table.
+        // So just rotate by 25 bits, so 32-bit hash occupies top 7 bits
+        // and bottom 25 bits. This gives good entropy as long as HashMap
+        // contains less than 58 million entries ((1 << 25) * 7 / 8).
+        // The bits in the middle have low entropy, but that doesn't matter
+        // because `hashbrown` will ignore them anyway.
+        let hash = self.len_and_hash.rotate_left(32 - 7);
+        hasher.write_u64(hash);
+    }
+}
+
+impl std::fmt::Debug for Ident<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Debug::fmt(self.as_str(), f)
+    }
+}
+
+impl std::fmt::Display for Ident<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+#[cfg(feature = "serialize")]
+impl Serialize for Ident<'_> {
+    #[inline] // Because it just delegates
+    fn serialize<S: SerdeSerializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        Serialize::serialize(self.as_str(), serializer)
+    }
+}
+
+#[cfg(feature = "serialize")]
+impl ESTree for Ident<'_> {
+    #[inline] // Because it just delegates
+    fn serialize<S: ESTreeSerializer>(&self, serializer: S) {
+        ESTree::serialize(self.as_str(), serializer);
+    }
+}
+
+/// Hash map keyed by `Ident`
+#[expect(clippy::disallowed_types)]
+pub type IdentHashMap<'a, V> = std::collections::HashMap<Ident<'a>, V, IdentHasher>;
+
+pub type ArenaIdentHashMap<'alloc, V> =
+    oxc_allocator::hash_map::HashMapImpl<'alloc, Ident<'alloc>, V, IdentHasher>;
+
+/// Hasher to use in hash maps keyed by `Ident`
+pub struct IdentHasher(u64);
+
+impl IdentHasher {
+    #[inline]
+    fn new() -> Self {
+        Self(0)
+    }
+}
+
+impl Hasher for IdentHasher {
+    #[inline]
+    fn write_u64(&mut self, n: u64) {
+        self.0 = n;
+    }
+
+    #[inline]
+    fn write(&mut self, _: &[u8]) {}
+
+    #[inline]
+    fn finish(&self) -> u64 {
+        self.0
+    }
+}
+
+impl BuildHasher for IdentHasher {
+    type Hasher = Self;
+
+    #[inline]
+    fn build_hasher(&self) -> Self::Hasher {
+        Self::new()
+    }
+}
+
+impl Default for IdentHasher {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Clone for IdentHasher {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::Ident;
+
+    #[test]
+    fn ident_eq() {
+        let foo = Ident::new("foo");
+        let foo2 = Ident::new("foo");
+        let bar = Ident::new("bar");
+        assert_eq!(foo, foo2);
+        assert_ne!(foo, bar);
+    }
+
+    #[test]
+    fn ident_as_str() {
+        let s = "hello_world";
+        let ident = Ident::new(s);
+        assert_eq!(ident.as_str(), s);
+    }
+
+    #[test]
+    fn ident_len() {
+        let ident = Ident::new("hello");
+        assert_eq!(ident.len(), 5);
+    }
+
+    // Expect that `Ident::new` will panic on zero-length strings
+    #[test]
+    #[should_panic(expected = "identifiers cannot have zero length")]
+    fn ident_zero_length() {
+        let _ = Ident::new("");
+    }
+
+    #[test]
+    fn ident_hashmap_lookup() {
+        use super::IdentHashMap;
+        let mut map: IdentHashMap<i32> = IdentHashMap::default();
+
+        // Insert with one Ident
+        let foo1 = Ident::new("foo");
+        map.insert(foo1, 42);
+
+        // Look up with a new Ident created from the same string
+        let foo2 = Ident::new("foo");
+        assert_eq!(map.get(&foo2), Some(&42), "lookup with new Ident should find the value");
+
+        // Verify that a different key is not found
+        let bar = Ident::new("bar");
+        assert_eq!(map.get(&bar), None, "lookup with different key should return None");
+    }
+}
diff --git a/crates/oxc_span/src/lib.rs b/crates/oxc_span/src/lib.rs
index b3b2b971f7c22..809f324b4be00 100644
--- a/crates/oxc_span/src/lib.rs
+++ b/crates/oxc_span/src/lib.rs
@@ -7,12 +7,14 @@
 mod atom;
 mod cmp;
 mod compact_str;
+mod ident;
 mod source_type;
 mod span;
 
 pub use atom::Atom;
 pub use cmp::ContentEq;
 pub use compact_str::{CompactStr, MAX_INLINE_LEN as ATOM_MAX_INLINE_LEN};
+pub use ident::{ArenaIdentHashMap, Ident, IdentHashMap, IdentHasher};
 pub use source_type::{
     Language, LanguageVariant, ModuleKind, SourceType, UnknownExtension, VALID_EXTENSIONS,
 };
diff --git a/crates/oxc_transformer/src/common/arrow_function_converter.rs b/crates/oxc_transformer/src/common/arrow_function_converter.rs
index 1915d09663699..7fd25815e0990 100644
--- a/crates/oxc_transformer/src/common/arrow_function_converter.rs
+++ b/crates/oxc_transformer/src/common/arrow_function_converter.rs
@@ -96,7 +96,7 @@ use oxc_ast::{NONE, ast::*};
 use oxc_ast_visit::{VisitMut, walk_mut::walk_expression};
 use oxc_data_structures::stack::{NonEmptyStack, SparseStack};
 use oxc_semantic::{ReferenceFlags, SymbolId};
-use oxc_span::{GetSpan, SPAN};
+use oxc_span::{GetSpan, Ident, SPAN};
 use oxc_syntax::{
     scope::{ScopeFlags, ScopeId},
     symbol::SymbolFlags,
@@ -823,7 +823,7 @@ impl<'a> ArrowFunctionConverter<'a> {
         arguments.push(Argument::from(ctx.ast.expression_this(SPAN)));
         arguments.extend(call.arguments.take_in(ctx.ast));
 
-        let property = ctx.ast.identifier_name(SPAN, "call");
+        let property = ctx.ast.identifier_name(SPAN, Ident::new("call"));
         let callee = ctx.ast.member_expression_static(SPAN, object, property, false);
         let callee = Expression::from(callee);
         Some(ctx.ast.expression_call(SPAN, callee, NONE, arguments, false))
@@ -1040,7 +1040,7 @@ impl<'a> ArrowFunctionConverter<'a> {
                 Self::rename_arguments_symbol(symbol_id, arguments_name, ctx);
                 // Record the symbol ID as a renamed `arguments` variable.
                 self.renamed_arguments_symbol_ids.insert(symbol_id);
-                BoundIdentifier::new(arguments_name, symbol_id)
+                BoundIdentifier::new(Ident::from(arguments_name), symbol_id)
             } else {
                 // We cannot determine the final scope ID of the `arguments` variable insertion,
                 // because the `arguments` variable will be inserted to a new scope which haven't been created yet,
@@ -1078,7 +1078,7 @@ impl<'a> ArrowFunctionConverter<'a> {
 
         self.arguments_var_stack.last_or_init(|| {
             let arguments_name = ctx.generate_uid_name("arguments");
-            ident.name = arguments_name;
+            ident.name = Ident::from(arguments_name);
             let symbol_id = ident.symbol_id();
             Self::rename_arguments_symbol(symbol_id, arguments_name, ctx);
             // Record the symbol ID as a renamed `arguments` variable.
@@ -1104,13 +1104,13 @@ impl<'a> ArrowFunctionConverter<'a> {
         Self::adjust_binding_scope(target_scope_id, &arguments_var, ctx);
 
         let mut init =
-            ctx.create_unbound_ident_expr(SPAN, Atom::from("arguments"), ReferenceFlags::Read);
+            ctx.create_unbound_ident_expr(SPAN, Ident::new("arguments"), ReferenceFlags::Read);
 
         // Top level may not have `arguments`, so we need to check it.
         // `typeof arguments === "undefined" ? void 0 : arguments;`
         if ctx.scoping().root_scope_id() == target_scope_id {
             let argument =
-                ctx.create_unbound_ident_expr(SPAN, Atom::from("arguments"), ReferenceFlags::Read);
+                ctx.create_unbound_ident_expr(SPAN, Ident::new("arguments"), ReferenceFlags::Read);
             let typeof_arguments = ctx.ast.expression_unary(SPAN, UnaryOperator::Typeof, argument);
             let undefined_literal = ctx.ast.expression_string_literal(SPAN, "undefined", None);
             let test = ctx.ast.expression_binary(
diff --git a/crates/oxc_transformer/src/common/helper_loader.rs b/crates/oxc_transformer/src/common/helper_loader.rs
index 5abeec4ff5691..2911259369bfd 100644
--- a/crates/oxc_transformer/src/common/helper_loader.rs
+++ b/crates/oxc_transformer/src/common/helper_loader.rs
@@ -76,7 +76,7 @@ use oxc_ast::{
     ast::{Argument, CallExpression, Expression},
 };
 use oxc_semantic::{ReferenceFlags, SymbolFlags};
-use oxc_span::{Atom, SPAN, Span};
+use oxc_span::{Atom, Ident, SPAN, Span};
 use oxc_traverse::BoundIdentifier;
 
 use crate::context::{TransformCtx, TraverseCtx};
@@ -323,10 +323,11 @@ impl<'a> HelperLoaderStore<'a> {
     fn transform_for_external_helper(helper: Helper, ctx: &mut TraverseCtx<'a>) -> Expression<'a> {
         static HELPER_VAR: &str = "babelHelpers";
 
-        let symbol_id = ctx.scoping().find_binding(ctx.current_scope_id(), HELPER_VAR);
+        let symbol_id =
+            ctx.scoping().find_binding(ctx.current_scope_id(), &Ident::from(HELPER_VAR));
         let object =
-            ctx.create_ident_expr(SPAN, Atom::from(HELPER_VAR), symbol_id, ReferenceFlags::Read);
-        let property = ctx.ast.identifier_name(SPAN, Atom::from(helper.name()));
+            ctx.create_ident_expr(SPAN, Ident::new(HELPER_VAR), symbol_id, ReferenceFlags::Read);
+        let property = ctx.ast.identifier_name(SPAN, Ident::new(helper.name()));
         Expression::from(ctx.ast.member_expression_static(SPAN, object, property, false))
     }
 }
diff --git a/crates/oxc_transformer/src/common/module_imports.rs b/crates/oxc_transformer/src/common/module_imports.rs
index 39042e424e0fa..1a67942ec32a8 100644
--- a/crates/oxc_transformer/src/common/module_imports.rs
+++ b/crates/oxc_transformer/src/common/module_imports.rs
@@ -38,7 +38,7 @@ use indexmap::{IndexMap, map::Entry as IndexMapEntry};
 
 use oxc_ast::{NONE, ast::*};
 use oxc_semantic::ReferenceFlags;
-use oxc_span::{Atom, SPAN};
+use oxc_span::{Atom, Ident, SPAN};
 use oxc_syntax::symbol::SymbolId;
 use oxc_traverse::{BoundIdentifier, Traverse};
 
@@ -182,7 +182,7 @@ impl<'a> ModuleImportsStore<'a> {
             return;
         }
 
-        let require_symbol_id = ctx.scoping().get_root_binding("require");
+        let require_symbol_id = ctx.scoping().get_root_binding(&Ident::from("require"));
         let stmts = imports
             .drain(..)
             .map(|(source, names)| Self::get_require(source, names, require_symbol_id, ctx));
@@ -199,7 +199,7 @@ impl<'a> ModuleImportsStore<'a> {
                 ImportDeclarationSpecifier::ImportSpecifier(ctx.ast.alloc_import_specifier(
                     SPAN,
                     ModuleExportName::IdentifierName(
-                        ctx.ast.identifier_name(SPAN, import.imported),
+                        ctx.ast.identifier_name(SPAN, Ident::from(import.imported)),
                     ),
                     import.local.create_binding_identifier(ctx),
                     ImportOrExportKind::Value,
@@ -228,7 +228,7 @@ impl<'a> ModuleImportsStore<'a> {
     ) -> Statement<'a> {
         let callee = ctx.create_ident_expr(
             SPAN,
-            Atom::from("require"),
+            Ident::new("require"),
             require_symbol_id,
             ReferenceFlags::read(),
         );
diff --git a/crates/oxc_transformer/src/decorator/legacy/metadata.rs b/crates/oxc_transformer/src/decorator/legacy/metadata.rs
index dfbeb17d60c96..e80bf9d9a6362 100644
--- a/crates/oxc_transformer/src/decorator/legacy/metadata.rs
+++ b/crates/oxc_transformer/src/decorator/legacy/metadata.rs
@@ -91,7 +91,7 @@ use oxc_allocator::{Box as ArenaBox, TakeIn};
 use oxc_ast::ast::*;
 use oxc_data_structures::stack::SparseStack;
 use oxc_semantic::{Reference, ReferenceFlags, SymbolId};
-use oxc_span::{ContentEq, SPAN};
+use oxc_span::{ContentEq, Ident, SPAN};
 use oxc_traverse::{MaybeBoundIdentifier, Traverse};
 use rustc_hash::FxHashMap;
 
@@ -698,7 +698,7 @@ impl<'a> LegacyDecoratorMetadata<'a, '_> {
 
     #[inline]
     fn create_global_identifier(ident: &'static str, ctx: &mut TraverseCtx<'a>) -> Expression<'a> {
-        ctx.create_unbound_ident_expr(SPAN, Atom::new_const(ident), ReferenceFlags::Read)
+        ctx.create_unbound_ident_expr(SPAN, Ident::new(ident), ReferenceFlags::Read)
     }
 
     #[inline]
diff --git a/crates/oxc_transformer/src/es2016/exponentiation_operator.rs b/crates/oxc_transformer/src/es2016/exponentiation_operator.rs
index 82f083c7e9f39..b39c306dbf9e7 100644
--- a/crates/oxc_transformer/src/es2016/exponentiation_operator.rs
+++ b/crates/oxc_transformer/src/es2016/exponentiation_operator.rs
@@ -35,7 +35,7 @@
 use oxc_allocator::{CloneIn, TakeIn, Vec as ArenaVec};
 use oxc_ast::{NONE, ast::*};
 use oxc_semantic::ReferenceFlags;
-use oxc_span::SPAN;
+use oxc_span::{Ident, SPAN};
 use oxc_syntax::operator::{AssignmentOperator, BinaryOperator};
 use oxc_traverse::{BoundIdentifier, Traverse};
 
@@ -536,10 +536,11 @@ impl<'a> ExponentiationOperator<'a, '_> {
         right: Expression<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) -> Expression<'a> {
-        let math_symbol_id = ctx.scoping().find_binding(ctx.current_scope_id(), "Math");
+        let math_symbol_id =
+            ctx.scoping().find_binding(ctx.current_scope_id(), &Ident::from("Math"));
         let object =
-            ctx.create_ident_expr(SPAN, Atom::from("Math"), math_symbol_id, ReferenceFlags::Read);
-        let property = ctx.ast.identifier_name(SPAN, "pow");
+            ctx.create_ident_expr(SPAN, Ident::new("Math"), math_symbol_id, ReferenceFlags::Read);
+        let property = ctx.ast.identifier_name(SPAN, Ident::new("pow"));
         let callee =
             Expression::from(ctx.ast.member_expression_static(SPAN, object, property, false));
         let arguments = ctx.ast.vec_from_array([Argument::from(left), Argument::from(right)]);
diff --git a/crates/oxc_transformer/src/es2017/async_to_generator.rs b/crates/oxc_transformer/src/es2017/async_to_generator.rs
index ac638d80b60a9..b10273fc8c3b0 100644
--- a/crates/oxc_transformer/src/es2017/async_to_generator.rs
+++ b/crates/oxc_transformer/src/es2017/async_to_generator.rs
@@ -57,7 +57,7 @@ use oxc_allocator::{Box as ArenaBox, StringBuilder as ArenaStringBuilder, TakeIn
 use oxc_ast::{NONE, ast::*};
 use oxc_ast_visit::Visit;
 use oxc_semantic::{ReferenceFlags, ScopeFlags, ScopeId, SymbolFlags};
-use oxc_span::{Atom, GetSpan, SPAN};
+use oxc_span::{Atom, GetSpan, Ident, SPAN};
 use oxc_syntax::{
     identifier::{is_identifier_name, is_identifier_part, is_identifier_start},
     keyword::is_reserved_keyword,
@@ -269,7 +269,7 @@ impl<'a, 'ctx> AsyncGeneratorExecutor<'a, 'ctx> {
         let callee = self.create_async_to_generator_call(params, body, generator_scope_id, ctx);
         let (callee, arguments) = if needs_move_parameters_to_inner_function {
             // callee.apply(this, arguments)
-            let property = ctx.ast.identifier_name(SPAN, "apply");
+            let property = ctx.ast.identifier_name(SPAN, Ident::new("apply"));
             let callee =
                 Expression::from(ctx.ast.member_expression_static(SPAN, callee, property, false));
 
@@ -277,7 +277,7 @@ impl<'a, 'ctx> AsyncGeneratorExecutor<'a, 'ctx> {
             let this_argument = Argument::from(ctx.ast.expression_this(SPAN));
             let arguments_argument = Argument::from(ctx.create_unbound_ident_expr(
                 SPAN,
-                Atom::new_const("arguments"),
+                Ident::new("arguments"),
                 ReferenceFlags::Read,
             ));
             (callee, ctx.ast.vec_from_array([this_argument, arguments_argument]))
@@ -506,7 +506,7 @@ impl<'a, 'ctx> AsyncGeneratorExecutor<'a, 'ctx> {
             let statements = ctx.ast.vec1(Self::create_apply_call_statement(&bound_ident, ctx));
             let body = ctx.ast.alloc_function_body(SPAN, ctx.ast.vec(), statements);
             let id = function_name.map(|name| {
-                ctx.generate_binding(name, wrapper_scope_id, SymbolFlags::Function)
+                ctx.generate_binding(Ident::from(name), wrapper_scope_id, SymbolFlags::Function)
                     .create_binding_identifier(ctx)
             });
             let function = Self::create_function(id, params, body, scope_id, ctx);
@@ -540,7 +540,7 @@ impl<'a, 'ctx> AsyncGeneratorExecutor<'a, 'ctx> {
     ) -> Option<BindingIdentifier<'a>> {
         let name = Self::infer_function_name_from_parent_node(ctx)?;
         Some(
-            ctx.generate_binding(name, scope_id, SymbolFlags::Function)
+            ctx.generate_binding(Ident::from(name), scope_id, SymbolFlags::Function)
                 .create_binding_identifier(ctx),
         )
     }
@@ -550,7 +550,7 @@ impl<'a, 'ctx> AsyncGeneratorExecutor<'a, 'ctx> {
         match ctx.parent() {
             // infer `foo` from `const foo = async function() {}`
             Ancestor::VariableDeclaratorInit(declarator) => {
-                declarator.id().get_binding_identifier().map(|id| id.name)
+                declarator.id().get_binding_identifier().map(|id| id.name.as_atom())
             }
             // infer `foo` from `({ foo: async function() {} })`
             Ancestor::ObjectPropertyValue(property) if !*property.method() => {
@@ -651,10 +651,11 @@ impl<'a, 'ctx> AsyncGeneratorExecutor<'a, 'ctx> {
         bound_ident: &BoundIdentifier<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) -> Statement<'a> {
-        let symbol_id = ctx.scoping().find_binding(ctx.current_scope_id(), "arguments");
+        let symbol_id =
+            ctx.scoping().find_binding(ctx.current_scope_id(), &Ident::from("arguments"));
         let arguments_ident = Argument::from(ctx.create_ident_expr(
             SPAN,
-            Atom::from("arguments"),
+            Ident::new("arguments"),
             symbol_id,
             ReferenceFlags::Read,
         ));
@@ -666,7 +667,7 @@ impl<'a, 'ctx> AsyncGeneratorExecutor<'a, 'ctx> {
         let callee = Expression::from(ctx.ast.member_expression_static(
             SPAN,
             bound_ident.create_read_expression(ctx),
-            ctx.ast.identifier_name(SPAN, "apply"),
+            ctx.ast.identifier_name(SPAN, Ident::new("apply")),
             false,
         ));
         let argument = ctx.ast.expression_call(SPAN, callee, NONE, arguments, false);
@@ -888,7 +889,7 @@ impl<'a> Visit<'a> for BindingMover<'a, '_> {
         let symbol_id = ident.symbol_id();
         let current_scope_id = symbols.symbol_scope_id(symbol_id);
         let scopes = self.ctx.scoping_mut();
-        scopes.move_binding(current_scope_id, self.target_scope_id, ident.name.as_str());
+        scopes.move_binding(current_scope_id, self.target_scope_id, &ident.name);
         let symbols = self.ctx.scoping_mut();
         symbols.set_symbol_scope_id(symbol_id, self.target_scope_id);
     }
diff --git a/crates/oxc_transformer/src/es2018/async_generator_functions/for_await.rs b/crates/oxc_transformer/src/es2018/async_generator_functions/for_await.rs
index 19fc3705f46e1..c9f93bf1b1fdb 100644
--- a/crates/oxc_transformer/src/es2018/async_generator_functions/for_await.rs
+++ b/crates/oxc_transformer/src/es2018/async_generator_functions/for_await.rs
@@ -3,7 +3,7 @@
 use oxc_allocator::{TakeIn, Vec as ArenaVec};
 use oxc_ast::{NONE, ast::*};
 use oxc_semantic::{ScopeFlags, ScopeId, SymbolFlags};
-use oxc_span::SPAN;
+use oxc_span::{Ident, SPAN};
 use oxc_traverse::{Ancestor, BoundIdentifier};
 
 use crate::{common::helper_loader::Helper, context::TraverseCtx};
@@ -101,7 +101,7 @@ impl<'a> AsyncGeneratorFunctions<'a, '_> {
         let step_value = Expression::from(ctx.ast.member_expression_static(
             SPAN,
             step_key.create_read_expression(ctx),
-            ctx.ast.identifier_name(SPAN, "value"),
+            ctx.ast.identifier_name(SPAN, Ident::new("value")),
             false,
         ));
 
@@ -299,7 +299,7 @@ impl<'a> AsyncGeneratorFunctions<'a, '_> {
                                             Expression::from(ctx.ast.member_expression_static(
                                                 SPAN,
                                                 iterator_key.create_read_expression(ctx),
-                                                ctx.ast.identifier_name(SPAN, "next"),
+                                                ctx.ast.identifier_name(SPAN, Ident::new("next")),
                                                 false,
                                             )),
                                             NONE,
@@ -309,7 +309,7 @@ impl<'a> AsyncGeneratorFunctions<'a, '_> {
                                     ),
                                 ),
                             ),
-                            ctx.ast.identifier_name(SPAN, "done"),
+                            ctx.ast.identifier_name(SPAN, Ident::new("done")),
                             false,
                         )),
                     ),
@@ -342,7 +342,7 @@ impl<'a> AsyncGeneratorFunctions<'a, '_> {
             let catch_scope_id = ctx.create_child_scope(parent_scope_id, ScopeFlags::CatchClause);
             let block_scope_id = ctx.create_child_scope(catch_scope_id, ScopeFlags::empty());
             let err_ident = ctx.generate_binding(
-                Atom::from("err"),
+                Ident::from("err"),
                 block_scope_id,
                 SymbolFlags::CatchVariable | SymbolFlags::FunctionScopedVariable,
             );
@@ -398,7 +398,7 @@ impl<'a> AsyncGeneratorFunctions<'a, '_> {
                                 Expression::from(ctx.ast.member_expression_static(
                                     SPAN,
                                     iterator_key.create_read_expression(ctx),
-                                    ctx.ast.identifier_name(SPAN, "return"),
+                                    ctx.ast.identifier_name(SPAN, Ident::new("return")),
                                     false,
                                 )),
                                 BinaryOperator::Inequality,
@@ -416,7 +416,7 @@ impl<'a> AsyncGeneratorFunctions<'a, '_> {
                                         Expression::from(ctx.ast.member_expression_static(
                                             SPAN,
                                             iterator_key.create_read_expression(ctx),
-                                            ctx.ast.identifier_name(SPAN, "return"),
+                                            ctx.ast.identifier_name(SPAN, Ident::new("return")),
                                             false,
                                         )),
                                         NONE,
diff --git a/crates/oxc_transformer/src/es2018/object_rest_spread.rs b/crates/oxc_transformer/src/es2018/object_rest_spread.rs
index 0aab31f8ef58f..5f0687c00e6df 100644
--- a/crates/oxc_transformer/src/es2018/object_rest_spread.rs
+++ b/crates/oxc_transformer/src/es2018/object_rest_spread.rs
@@ -36,7 +36,7 @@ use oxc_ast::{NONE, ast::*};
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_ecmascript::{BoundNames, ToJsString, WithoutGlobalReferenceInformation};
 use oxc_semantic::{ScopeFlags, ScopeId, SymbolFlags};
-use oxc_span::{GetSpan, SPAN};
+use oxc_span::{GetSpan, Ident, SPAN};
 use oxc_traverse::{Ancestor, MaybeBoundIdentifier, Traverse};
 
 use crate::{
@@ -635,7 +635,7 @@ impl<'a> ObjectRestSpread<'a, '_> {
                 // Move the bindings from the for init scope to scope of the loop body.
                 for ident in bound_names {
                     ctx.scoping_mut().set_symbol_scope_id(ident.symbol_id(), new_scope_id);
-                    ctx.scoping_mut().move_binding(scope_id, new_scope_id, ident.name.into());
+                    ctx.scoping_mut().move_binding(scope_id, new_scope_id, &ident.name);
                 }
             }
         }
@@ -1135,7 +1135,7 @@ impl<'a> SpreadPair<'a> {
             } else if !self.all_primitives {
                 // map to `toPropertyKey` to handle the possible non-string values
                 // `[_ref].map(babelHelpers.toPropertyKey))`
-                let property = ctx.ast.identifier_name(SPAN, "map");
+                let property = ctx.ast.identifier_name(SPAN, Ident::new("map"));
                 let callee = Expression::StaticMemberExpression(
                     ctx.ast.alloc_static_member_expression(SPAN, key_expression, property, false),
                 );
diff --git a/crates/oxc_transformer/src/es2020/optional_chaining.rs b/crates/oxc_transformer/src/es2020/optional_chaining.rs
index 5538169a1796e..ab599cca35ca1 100644
--- a/crates/oxc_transformer/src/es2020/optional_chaining.rs
+++ b/crates/oxc_transformer/src/es2020/optional_chaining.rs
@@ -51,7 +51,7 @@ use std::mem;
 
 use oxc_allocator::{CloneIn, TakeIn};
 use oxc_ast::{NONE, ast::*};
-use oxc_span::SPAN;
+use oxc_span::{Ident, SPAN};
 use oxc_traverse::{Ancestor, BoundIdentifier, MaybeBoundIdentifier, Traverse};
 
 use crate::{
@@ -388,7 +388,7 @@ impl<'a> OptionalChaining<'a, '_> {
 
         // `expr.bind(context)`
         let arguments = ctx.ast.vec1(context);
-        let property = ctx.ast.identifier_name(SPAN, "bind");
+        let property = ctx.ast.identifier_name(SPAN, Ident::new("bind"));
         let callee = ctx.ast.member_expression_static(SPAN, expr, property, false);
         let callee = Expression::from(callee);
         ctx.ast.expression_call(SPAN, callee, NONE, arguments, false)
@@ -492,7 +492,7 @@ impl<'a> OptionalChaining<'a, '_> {
                         {
                             // `foo$bar(...)` -> `foo$bar.call(context, ...)`
                             let callee = callee.take_in(ctx.ast);
-                            let property = ctx.ast.identifier_name(SPAN, "call");
+                            let property = ctx.ast.identifier_name(SPAN, Ident::new("call"));
                             let member =
                                 ctx.ast.member_expression_static(SPAN, callee, property, false);
                             call.callee = Expression::from(member);
diff --git a/crates/oxc_transformer/src/es2022/class_properties/class.rs b/crates/oxc_transformer/src/es2022/class_properties/class.rs
index 4a8b400019c24..3b8beebb39669 100644
--- a/crates/oxc_transformer/src/es2022/class_properties/class.rs
+++ b/crates/oxc_transformer/src/es2022/class_properties/class.rs
@@ -4,7 +4,7 @@
 use indexmap::map::Entry;
 use oxc_allocator::{Address, GetAddress, TakeIn, UnstableAddress};
 use oxc_ast::{NONE, ast::*};
-use oxc_span::SPAN;
+use oxc_span::{Ident, SPAN};
 use oxc_syntax::{
     node::NodeId,
     reference::ReferenceFlags,
@@ -16,11 +16,12 @@ use oxc_traverse::{Ancestor, BoundIdentifier};
 use crate::{
     common::helper_loader::Helper,
     context::{TransformCtx, TraverseCtx},
+    es2022::class_properties::IdentIndexMap,
     utils::ast_builder::create_assignment,
 };
 
 use super::{
-    ClassBindings, ClassDetails, ClassProperties, FxIndexMap, PrivateProp,
+    ClassBindings, ClassDetails, ClassProperties, PrivateProp,
     constructor::InstanceInitsInsertLocation,
     utils::{create_variable_declaration, exprs_into_stmts},
 };
@@ -80,7 +81,7 @@ impl<'a> ClassProperties<'a, '_> {
         let mut has_instance_private_method = false;
         let mut has_static_private_method_or_static_block = false;
         // TODO: Store `FxIndexMap`s in a pool and re-use them
-        let mut private_props = FxIndexMap::default();
+        let mut private_props = IdentIndexMap::default();
         for element in &mut body.body {
             match element {
                 ClassElement::PropertyDefinition(prop) => {
@@ -155,7 +156,7 @@ impl<'a> ClassProperties<'a, '_> {
                     // TODO: Not sure what we should do here.
                     // Only added this to prevent panics in TS conformance tests.
                     if let PropertyKey::PrivateIdentifier(ident) = &prop.key {
-                        let dummy_binding = BoundIdentifier::new(Atom::empty(), SymbolId::new(0));
+                        let dummy_binding = BoundIdentifier::new(Ident::new("x"), SymbolId::new(0));
                         private_props.insert(
                             ident.name,
                             PrivateProp::new(dummy_binding, prop.r#static, None, true),
@@ -851,7 +852,7 @@ impl<'a> ClassProperties<'a, '_> {
 
     /// `_classPrivateFieldLooseKey("prop")`
     fn create_private_prop_key_loose(
-        name: Atom<'a>,
+        name: Ident<'a>,
         transform_ctx: &TransformCtx<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) -> Expression<'a> {
@@ -888,15 +889,16 @@ fn create_new_weakmap<'a>(
     symbol_id: &mut Option<Option<SymbolId>>,
     ctx: &mut TraverseCtx<'a>,
 ) -> Expression<'a> {
-    let symbol_id = *symbol_id
-        .get_or_insert_with(|| ctx.scoping().find_binding(ctx.current_scope_id(), "WeakMap"));
-    let ident = ctx.create_ident_expr(SPAN, Atom::from("WeakMap"), symbol_id, ReferenceFlags::Read);
+    let symbol_id = *symbol_id.get_or_insert_with(|| {
+        ctx.scoping().find_binding(ctx.current_scope_id(), &Ident::from("WeakMap"))
+    });
+    let ident = ctx.create_ident_expr(SPAN, Ident::new("WeakMap"), symbol_id, ReferenceFlags::Read);
     ctx.ast.expression_new_with_pure(SPAN, ident, NONE, ctx.ast.vec(), true)
 }
 
 /// Create `new WeakSet()` expression.
 fn create_new_weakset<'a>(ctx: &mut TraverseCtx<'a>) -> Expression<'a> {
-    let symbol_id = ctx.scoping().find_binding(ctx.current_scope_id(), "WeakSet");
-    let ident = ctx.create_ident_expr(SPAN, Atom::from("WeakSet"), symbol_id, ReferenceFlags::Read);
+    let symbol_id = ctx.scoping().find_binding(ctx.current_scope_id(), &Ident::from("WeakSet"));
+    let ident = ctx.create_ident_expr(SPAN, Ident::new("WeakSet"), symbol_id, ReferenceFlags::Read);
     ctx.ast.expression_new_with_pure(SPAN, ident, NONE, ctx.ast.vec(), true)
 }
diff --git a/crates/oxc_transformer/src/es2022/class_properties/class_details.rs b/crates/oxc_transformer/src/es2022/class_properties/class_details.rs
index b43c294a4ae01..48b31513b3661 100644
--- a/crates/oxc_transformer/src/es2022/class_properties/class_details.rs
+++ b/crates/oxc_transformer/src/es2022/class_properties/class_details.rs
@@ -1,9 +1,8 @@
 use oxc_ast::ast::*;
 use oxc_data_structures::stack::NonEmptyStack;
-use oxc_span::Atom;
 use oxc_traverse::BoundIdentifier;
 
-use super::{ClassBindings, ClassProperties, FxIndexMap};
+use super::{ClassBindings, ClassProperties, IdentIndexMap};
 
 /// Details of a class.
 ///
@@ -17,7 +16,7 @@ pub(super) struct ClassDetails<'a> {
     /// Mapping private prop name to binding for temp var.
     /// This is then used as lookup when transforming e.g. `this.#x`.
     /// `None` if class has no private properties.
-    pub private_props: Option<FxIndexMap<Atom<'a>, PrivateProp<'a>>>,
+    pub private_props: Option<IdentIndexMap<'a, PrivateProp<'a>>>,
     /// Bindings for class name and temp var for class
     pub bindings: ClassBindings<'a>,
 }
diff --git a/crates/oxc_transformer/src/es2022/class_properties/constructor.rs b/crates/oxc_transformer/src/es2022/class_properties/constructor.rs
index 0f9eb37b0c2b5..5f0ecda5a23e5 100644
--- a/crates/oxc_transformer/src/es2022/class_properties/constructor.rs
+++ b/crates/oxc_transformer/src/es2022/class_properties/constructor.rs
@@ -106,7 +106,7 @@ use rustc_hash::FxHashMap;
 
 use oxc_ast::{NONE, ast::*};
 use oxc_ast_visit::{VisitMut, walk_mut};
-use oxc_span::SPAN;
+use oxc_span::{Ident, SPAN};
 use oxc_syntax::{
     node::NodeId,
     scope::{ScopeFlags, ScopeId},
@@ -576,7 +576,7 @@ impl<'a> ConstructorParamsSuperReplacer<'a, '_> {
             Expression::from(ctx.ast.member_expression_static(
                 SPAN,
                 super_binding.create_read_expression(ctx),
-                ctx.ast.identifier_name(SPAN, Atom::from("call")),
+                ctx.ast.identifier_name(SPAN, Ident::new("call")),
                 false,
             )),
             NONE,
@@ -781,7 +781,7 @@ impl<'a> VisitMut<'a> for ConstructorSymbolRenamer<'a, '_> {
     fn visit_binding_identifier(&mut self, ident: &mut BindingIdentifier<'a>) {
         let symbol_id = ident.symbol_id();
         if let Some(new_name) = self.clashing_symbols.get(&symbol_id) {
-            ident.name = *new_name;
+            ident.name = Ident::from(*new_name);
         }
     }
 
@@ -790,7 +790,7 @@ impl<'a> VisitMut<'a> for ConstructorSymbolRenamer<'a, '_> {
         if let Some(symbol_id) = self.ctx.scoping().get_reference(reference_id).symbol_id()
             && let Some(new_name) = self.clashing_symbols.get(&symbol_id)
         {
-            ident.name = *new_name;
+            ident.name = Ident::from(*new_name);
         }
     }
 }
diff --git a/crates/oxc_transformer/src/es2022/class_properties/instance_prop_init.rs b/crates/oxc_transformer/src/es2022/class_properties/instance_prop_init.rs
index 46ee6462e8dd0..487d51f8f75f1 100644
--- a/crates/oxc_transformer/src/es2022/class_properties/instance_prop_init.rs
+++ b/crates/oxc_transformer/src/es2022/class_properties/instance_prop_init.rs
@@ -146,7 +146,7 @@ impl<'a> InstanceInitializerVisitor<'a, '_> {
         }
 
         // Record the symbol clash. Symbol in constructor needs to be renamed.
-        self.clashing_symbols.entry(constructor_symbol_id).or_insert(ident.name);
+        self.clashing_symbols.entry(constructor_symbol_id).or_insert(ident.name.as_atom());
     }
 }
 
diff --git a/crates/oxc_transformer/src/es2022/class_properties/mod.rs b/crates/oxc_transformer/src/es2022/class_properties/mod.rs
index a3e92dac64c16..50eccfd20a737 100644
--- a/crates/oxc_transformer/src/es2022/class_properties/mod.rs
+++ b/crates/oxc_transformer/src/es2022/class_properties/mod.rs
@@ -198,11 +198,11 @@
 //! * Class properties TC39 proposal: <https://github.com/tc39/proposal-class-fields>
 
 use indexmap::IndexMap;
-use rustc_hash::{FxBuildHasher, FxHashMap};
+use rustc_hash::FxHashMap;
 use serde::Deserialize;
 
 use oxc_ast::ast::*;
-use oxc_span::Atom;
+use oxc_span::{Atom, Ident, IdentHasher};
 use oxc_syntax::symbol::SymbolId;
 use oxc_traverse::Traverse;
 
@@ -226,7 +226,7 @@ mod utils;
 use class_bindings::ClassBindings;
 use class_details::{ClassDetails, ClassesStack, PrivateProp, ResolvedPrivateProp};
 
-type FxIndexMap<K, V> = IndexMap<K, V, FxBuildHasher>;
+type IdentIndexMap<'a, V> = IndexMap<Ident<'a>, V, IdentHasher>;
 
 #[derive(Debug, Default, Clone, Copy, Deserialize)]
 #[serde(default, rename_all = "camelCase")]
diff --git a/crates/oxc_transformer/src/es2022/class_properties/private_field.rs b/crates/oxc_transformer/src/es2022/class_properties/private_field.rs
index dde66433ce7ce..31d04347fecb1 100644
--- a/crates/oxc_transformer/src/es2022/class_properties/private_field.rs
+++ b/crates/oxc_transformer/src/es2022/class_properties/private_field.rs
@@ -5,7 +5,7 @@ use std::mem;
 
 use oxc_allocator::{Box as ArenaBox, TakeIn};
 use oxc_ast::{NONE, ast::*};
-use oxc_span::SPAN;
+use oxc_span::{Ident, SPAN};
 use oxc_syntax::{reference::ReferenceId, symbol::SymbolId};
 use oxc_traverse::{Ancestor, BoundIdentifier, ast_operations::get_var_name_from_node};
 
@@ -295,7 +295,7 @@ impl<'a> ClassProperties<'a, '_> {
         call_expr.callee = Expression::from(ctx.ast.member_expression_static(
             SPAN,
             callee,
-            ctx.ast.identifier_name(SPAN, Atom::from("call")),
+            ctx.ast.identifier_name(SPAN, Ident::new("call")),
             // Make sure the `callee` can access `call` safely. i.e `callee?.()` -> `callee?.call()`
             mem::replace(&mut call_expr.optional, false),
         ));
@@ -1776,7 +1776,7 @@ impl<'a> ClassProperties<'a, '_> {
         let callee = Expression::from(ctx.ast.member_expression_static(
             SPAN,
             callee,
-            ctx.ast.identifier_name(SPAN, Atom::from("bind")),
+            ctx.ast.identifier_name(SPAN, Ident::new("bind")),
             false,
         ));
         let arguments = ctx.ast.vec1(Argument::from(context));
diff --git a/crates/oxc_transformer/src/es2022/class_properties/prop_decl.rs b/crates/oxc_transformer/src/es2022/class_properties/prop_decl.rs
index f86f00654ea26..8ee2bcf6122bb 100644
--- a/crates/oxc_transformer/src/es2022/class_properties/prop_decl.rs
+++ b/crates/oxc_transformer/src/es2022/class_properties/prop_decl.rs
@@ -2,7 +2,7 @@
 //! Transform of class property declarations (instance or static properties).
 
 use oxc_ast::{NONE, ast::*};
-use oxc_span::SPAN;
+use oxc_span::{Ident, SPAN};
 use oxc_syntax::reference::ReferenceFlags;
 
 use crate::{
@@ -262,7 +262,7 @@ impl<'a> ClassProperties<'a, '_> {
 
         let left = match &mut prop.key {
             PropertyKey::StaticIdentifier(ident) => {
-                if needs_define(&ident.name) {
+                if needs_define(&ident.name.as_atom()) {
                     return self
                         .create_init_assignment_not_loose(prop, value, assignee, is_static, ctx);
                 }
@@ -341,14 +341,15 @@ impl<'a> ClassProperties<'a, '_> {
         ctx: &mut TraverseCtx<'a>,
     ) -> Expression<'a> {
         // `Object.defineProperty`
-        let object_symbol_id = ctx.scoping().find_binding(ctx.current_scope_id(), "Object");
+        let object_symbol_id =
+            ctx.scoping().find_binding(ctx.current_scope_id(), &Ident::from("Object"));
         let object = ctx.create_ident_expr(
             SPAN,
-            Atom::from("Object"),
+            Ident::new("Object"),
             object_symbol_id,
             ReferenceFlags::Read,
         );
-        let property = ctx.ast.identifier_name(SPAN, "defineProperty");
+        let property = ctx.ast.identifier_name(SPAN, Ident::new("defineProperty"));
         let callee =
             Expression::from(ctx.ast.member_expression_static(SPAN, object, property, false));
 
@@ -359,7 +360,7 @@ impl<'a> ClassProperties<'a, '_> {
                 ctx.ast.object_property_kind_object_property(
                     SPAN,
                     PropertyKind::Init,
-                    ctx.ast.property_key_static_identifier(SPAN, Atom::from("writable")),
+                    ctx.ast.property_key_static_identifier(SPAN, Ident::from("writable")),
                     ctx.ast.expression_boolean_literal(SPAN, true),
                     false,
                     false,
@@ -368,7 +369,7 @@ impl<'a> ClassProperties<'a, '_> {
                 ctx.ast.object_property_kind_object_property(
                     SPAN,
                     PropertyKind::Init,
-                    ctx.ast.property_key_static_identifier(SPAN, Atom::from("value")),
+                    ctx.ast.property_key_static_identifier(SPAN, Ident::from("value")),
                     value,
                     false,
                     false,
diff --git a/crates/oxc_transformer/src/es2022/class_properties/utils.rs b/crates/oxc_transformer/src/es2022/class_properties/utils.rs
index 64973d011e5ec..34bf887effba4 100644
--- a/crates/oxc_transformer/src/es2022/class_properties/utils.rs
+++ b/crates/oxc_transformer/src/es2022/class_properties/utils.rs
@@ -4,7 +4,7 @@
 use std::path::Path;
 
 use oxc_ast::ast::*;
-use oxc_span::SPAN;
+use oxc_span::{Ident, SPAN};
 use oxc_traverse::BoundIdentifier;
 
 use crate::context::TraverseCtx;
@@ -39,7 +39,7 @@ where
 
 /// Create `IdentifierName` for `_`.
 pub(super) fn create_underscore_ident_name<'a>(ctx: &TraverseCtx<'a>) -> IdentifierName<'a> {
-    ctx.ast.identifier_name(SPAN, Atom::from("_"))
+    ctx.ast.identifier_name(SPAN, Ident::from("_"))
 }
 
 /// Debug assert that an `Expression` is not `ParenthesizedExpression` or TS syntax
diff --git a/crates/oxc_transformer/src/es2022/class_static_block.rs b/crates/oxc_transformer/src/es2022/class_static_block.rs
index 1c65eeb3159ae..dfe5bb495a097 100644
--- a/crates/oxc_transformer/src/es2022/class_static_block.rs
+++ b/crates/oxc_transformer/src/es2022/class_static_block.rs
@@ -43,7 +43,7 @@ use itoa::Buffer as ItoaBuffer;
 
 use oxc_allocator::TakeIn;
 use oxc_ast::{NONE, ast::*};
-use oxc_span::SPAN;
+use oxc_span::{Ident, SPAN};
 use oxc_syntax::scope::{ScopeFlags, ScopeId};
 use oxc_traverse::Traverse;
 
@@ -227,11 +227,12 @@ impl<'a> Keys<'a> {
     ///
     /// Returned key will be either `_`, or `_<integer>` starting with `_2`.
     #[inline]
-    fn get_unique(&mut self, ctx: &TraverseCtx<'a>) -> Atom<'a> {
+    fn get_unique(&mut self, ctx: &TraverseCtx<'a>) -> Ident<'a> {
         #[expect(clippy::if_not_else)]
         if !self.underscore {
             self.underscore = true;
-            Atom::from("_")
+            // TODO: return constant Ident for `_`
+            Ident::new("_")
         } else {
             self.get_unique_slow(ctx)
         }
@@ -240,7 +241,7 @@ impl<'a> Keys<'a> {
     // `#[cold]` and `#[inline(never)]` as it should be very rare to need a key other than `#_`.
     #[cold]
     #[inline(never)]
-    fn get_unique_slow(&mut self, ctx: &TraverseCtx<'a>) -> Atom<'a> {
+    fn get_unique_slow(&mut self, ctx: &TraverseCtx<'a>) -> Ident<'a> {
         // Source text length is limited to `u32::MAX` so impossible to have more than `u32::MAX`
         // private keys. So `u32` is sufficient here.
         let mut i = 2u32;
@@ -254,7 +255,7 @@ impl<'a> Keys<'a> {
             i += 1;
         }
 
-        let key = ctx.ast.atom_from_strs_array(["_", num_str]);
+        let key = ctx.ast.ident_from_strs_array(["_", num_str]);
         self.numbered.push(&key.as_str()[1..]);
 
         key
diff --git a/crates/oxc_transformer/src/es2026/explicit_resource_management.rs b/crates/oxc_transformer/src/es2026/explicit_resource_management.rs
index 4f2e04e65da68..7e3b05c9d9828 100644
--- a/crates/oxc_transformer/src/es2026/explicit_resource_management.rs
+++ b/crates/oxc_transformer/src/es2026/explicit_resource_management.rs
@@ -41,7 +41,7 @@ use oxc_allocator::{Address, Box as ArenaBox, GetAddress, TakeIn, Vec as ArenaVe
 use oxc_ast::{NONE, ast::*};
 use oxc_ecmascript::BoundNames;
 use oxc_semantic::{ScopeFlags, ScopeId, SymbolFlags};
-use oxc_span::{Atom, SPAN};
+use oxc_span::{Ident, SPAN};
 use oxc_traverse::{BoundIdentifier, Traverse};
 
 use crate::{
@@ -340,7 +340,7 @@ impl<'a> Traverse<'a, TransformState<'a>> for ExplicitResourceManagement<'a, '_>
                             }
                             _ => (
                                 ctx.generate_binding_in_current_scope(
-                                    Atom::from("_default"),
+                                    Ident::from("_default"),
                                     SymbolFlags::FunctionScopedVariable,
                                 ),
                                 SPAN,
@@ -389,7 +389,10 @@ impl<'a> Traverse<'a, TransformState<'a>> for ExplicitResourceManagement<'a, '_>
                                     ModuleExportName::IdentifierReference(
                                         var_id.create_read_reference(ctx),
                                     ),
-                                    ctx.ast.module_export_name_identifier_name(SPAN, "default"),
+                                    ctx.ast.module_export_name_identifier_name(
+                                        SPAN,
+                                        Ident::new("default"),
+                                    ),
                                     ImportOrExportKind::Value,
                                 )),
                                 None,
@@ -628,7 +631,7 @@ impl<'a> ExplicitResourceManagement<'a, '_> {
                                             .create_read_expression(ctx),
                                         ctx.ast.identifier_name(
                                             SPAN,
-                                            if needs_await { "a" } else { "u" },
+                                            Ident::new(if needs_await { "a" } else { "u" }),
                                         ),
                                         false,
                                     ),
@@ -747,7 +750,10 @@ impl<'a> ExplicitResourceManagement<'a, '_> {
                         Expression::from(ctx.ast.member_expression_static(
                             SPAN,
                             using_ctx.as_ref().unwrap().create_read_expression(ctx),
-                            ctx.ast.identifier_name(SPAN, if is_await_using { "a" } else { "u" }),
+                            ctx.ast.identifier_name(
+                                SPAN,
+                                Ident::new(if is_await_using { "a" } else { "u" }),
+                            ),
                             false,
                         )),
                         NONE,
@@ -808,7 +814,7 @@ impl<'a> ExplicitResourceManagement<'a, '_> {
         // We can skip using `generate_uid` here as no code within the `catch` block which can use a
         // binding called `_`. `using_ctx` is a UID with prefix `_usingCtx`.
         let ident = ctx.generate_binding(
-            Atom::from("_"),
+            Ident::from("_"),
             block_scope_id,
             SymbolFlags::CatchVariable | SymbolFlags::FunctionScopedVariable,
         );
@@ -824,7 +830,7 @@ impl<'a> ExplicitResourceManagement<'a, '_> {
                 AssignmentTarget::from(ctx.ast.member_expression_static(
                     SPAN,
                     using_ctx.create_read_expression(ctx),
-                    ctx.ast.identifier_name(SPAN, "e"),
+                    ctx.ast.identifier_name(SPAN, Ident::new("e")),
                     false,
                 )),
                 ident.create_read_expression(ctx),
@@ -855,7 +861,7 @@ impl<'a> ExplicitResourceManagement<'a, '_> {
             Expression::from(ctx.ast.member_expression_static(
                 SPAN,
                 using_ctx.create_read_expression(ctx),
-                ctx.ast.identifier_name(SPAN, "d"),
+                ctx.ast.identifier_name(SPAN, Ident::new("d")),
                 false,
             )),
             NONE,
diff --git a/crates/oxc_transformer/src/jsx/display_name.rs b/crates/oxc_transformer/src/jsx/display_name.rs
index 439b091271ccd..d1eabc1214898 100644
--- a/crates/oxc_transformer/src/jsx/display_name.rs
+++ b/crates/oxc_transformer/src/jsx/display_name.rs
@@ -46,7 +46,7 @@
 //! * Babel plugin implementation: <https://github.com/babel/babel/blob/v7.26.2/packages/babel-plugin-transform-react-display-name/src/index.ts>
 
 use oxc_ast::ast::*;
-use oxc_span::{Atom, SPAN};
+use oxc_span::{Atom, Ident, SPAN};
 use oxc_traverse::{Ancestor, Traverse};
 
 use crate::{
@@ -84,10 +84,10 @@ impl<'a> Traverse<'a, TransformState<'a>> for ReactDisplayName<'a, '_> {
                 // `foo = React.createClass({})`
                 Ancestor::AssignmentExpressionRight(assign_expr) => match assign_expr.left() {
                     AssignmentTarget::AssignmentTargetIdentifier(ident) => {
-                        break ident.name;
+                        break ident.name.as_atom();
                     }
                     AssignmentTarget::StaticMemberExpression(expr) => {
-                        break expr.property.name;
+                        break expr.property.name.as_atom();
                     }
                     // Babel does not handle computed member expressions e.g. `foo["bar"]`,
                     // so we diverge from Babel here, but that's probably an improvement
@@ -102,7 +102,7 @@ impl<'a> Traverse<'a, TransformState<'a>> for ReactDisplayName<'a, '_> {
                 // `let foo = React.createClass({})`
                 Ancestor::VariableDeclaratorInit(declarator) => {
                     if let BindingPatternKind::BindingIdentifier(ident) = &declarator.id().kind {
-                        break ident.name;
+                        break ident.name.as_atom();
                     }
                     return;
                 }
@@ -175,7 +175,7 @@ impl<'a> ReactDisplayName<'a, '_> {
             ctx.ast.object_property_kind_object_property(
                 SPAN,
                 PropertyKind::Init,
-                ctx.ast.property_key_static_identifier(SPAN, DISPLAY_NAME),
+                ctx.ast.property_key_static_identifier(SPAN, Ident::from(DISPLAY_NAME)),
                 ctx.ast.expression_string_literal(SPAN, name, None),
                 false,
                 false,
diff --git a/crates/oxc_transformer/src/jsx/jsx_impl.rs b/crates/oxc_transformer/src/jsx/jsx_impl.rs
index 146e29b7fed73..3cc28c51ded14 100644
--- a/crates/oxc_transformer/src/jsx/jsx_impl.rs
+++ b/crates/oxc_transformer/src/jsx/jsx_impl.rs
@@ -93,7 +93,7 @@ use oxc_allocator::{
 };
 use oxc_ast::{AstBuilder, NONE, ast::*};
 use oxc_ecmascript::PropName;
-use oxc_span::{Atom, SPAN, Span};
+use oxc_span::{Atom, Ident, SPAN, Span};
 use oxc_syntax::{
     identifier::is_white_space_single_line, line_terminator::is_line_terminator,
     reference::ReferenceFlags, symbol::SymbolFlags, xml_entities::XML_ENTITIES,
@@ -370,7 +370,7 @@ impl<'a> Pragma<'a> {
                 return Expression::from(ctx.ast.member_expression_static(
                     SPAN,
                     object,
-                    ctx.ast.identifier_name(SPAN, *second),
+                    ctx.ast.identifier_name(SPAN, Ident::from(*second)),
                     false,
                 ));
             }
@@ -390,8 +390,8 @@ impl<'a> Pragma<'a> {
             Self::ImportMeta(parts) => {
                 let object = ctx.ast.expression_meta_property(
                     SPAN,
-                    ctx.ast.identifier_name(SPAN, Atom::from("import")),
-                    ctx.ast.identifier_name(SPAN, Atom::from("meta")),
+                    ctx.ast.identifier_name(SPAN, Ident::from("import")),
+                    ctx.ast.identifier_name(SPAN, Ident::from("meta")),
                 );
                 (object, parts.iter())
             }
@@ -399,7 +399,7 @@ impl<'a> Pragma<'a> {
 
         let mut expr = object;
         for &item in parts {
-            let name = ctx.ast.identifier_name(SPAN, item);
+            let name = ctx.ast.identifier_name(SPAN, Ident::from(item));
             expr = ctx.ast.member_expression_static(SPAN, expr, name, false).into();
         }
         expr
@@ -671,7 +671,7 @@ impl<'a> JsxImpl<'a, '_> {
                     let elements = ctx.ast.vec_from_iter(elements);
                     ctx.ast.expression_array(SPAN, elements)
                 };
-                let children = ctx.ast.property_key_static_identifier(SPAN, "children");
+                let children = ctx.ast.property_key_static_identifier(SPAN, Ident::new("children"));
                 let kind = PropertyKind::Init;
                 let property = ctx.ast.object_property_kind_object_property(
                     SPAN, kind, children, value, false, false, false,
@@ -1201,8 +1201,10 @@ fn get_read_identifier_reference<'a>(
     name: Atom<'a>,
     ctx: &mut TraverseCtx<'a>,
 ) -> Expression<'a> {
-    let reference_id = ctx.create_reference_in_current_scope(name.as_str(), ReferenceFlags::Read);
-    let ident = ctx.ast.alloc_identifier_reference_with_reference_id(span, name, reference_id);
+    let reference_id =
+        ctx.create_reference_in_current_scope(&Ident::from(name), ReferenceFlags::Read);
+    let ident =
+        ctx.ast.alloc_identifier_reference_with_reference_id(span, Ident::from(name), reference_id);
     Expression::Identifier(ident)
 }
 
@@ -1212,7 +1214,7 @@ fn create_static_member_expression<'a>(
     ctx: &TraverseCtx<'a>,
 ) -> Expression<'a> {
     let object = Expression::Identifier(ctx.alloc(object_ident));
-    let property = ctx.ast.identifier_name(SPAN, property_name);
+    let property = ctx.ast.identifier_name(SPAN, Ident::from(property_name));
     ctx.ast.member_expression_static(SPAN, object, property, false).into()
 }
 
diff --git a/crates/oxc_transformer/src/jsx/jsx_self.rs b/crates/oxc_transformer/src/jsx/jsx_self.rs
index 667de1b7623b1..ff2cc8f9f4c04 100644
--- a/crates/oxc_transformer/src/jsx/jsx_self.rs
+++ b/crates/oxc_transformer/src/jsx/jsx_self.rs
@@ -30,7 +30,7 @@
 
 use oxc_ast::ast::*;
 use oxc_diagnostics::OxcDiagnostic;
-use oxc_span::{SPAN, Span};
+use oxc_span::{Ident, SPAN, Span};
 use oxc_traverse::{Ancestor, Traverse};
 
 use crate::{
@@ -90,7 +90,7 @@ impl<'a> JsxSelf<'a, '_> {
         ctx: &TraverseCtx<'a>,
     ) -> ObjectPropertyKind<'a> {
         let kind = PropertyKind::Init;
-        let key = ctx.ast.property_key_static_identifier(SPAN, SELF);
+        let key = ctx.ast.property_key_static_identifier(SPAN, Ident::new(SELF));
         let value = ctx.ast.expression_this(SPAN);
         ctx.ast.object_property_kind_object_property(SPAN, kind, key, value, false, false, false)
     }
@@ -113,7 +113,7 @@ impl<'a> JsxSelf<'a, '_> {
             }
         }
 
-        let name = ctx.ast.jsx_attribute_name_identifier(SPAN, SELF);
+        let name = ctx.ast.jsx_attribute_name_identifier(SPAN, Ident::new(SELF));
         let value = {
             let jsx_expr = JSXExpression::from(ctx.ast.expression_this(SPAN));
             ctx.ast.jsx_attribute_value_expression_container(SPAN, jsx_expr)
diff --git a/crates/oxc_transformer/src/jsx/jsx_source.rs b/crates/oxc_transformer/src/jsx/jsx_source.rs
index f47a784931a1b..abd100412c6dd 100644
--- a/crates/oxc_transformer/src/jsx/jsx_source.rs
+++ b/crates/oxc_transformer/src/jsx/jsx_source.rs
@@ -36,7 +36,7 @@
 use oxc_ast::ast::*;
 use oxc_data_structures::rope::{Rope, get_line_column};
 use oxc_diagnostics::OxcDiagnostic;
-use oxc_span::{SPAN, Span};
+use oxc_span::{Ident, SPAN, Span};
 use oxc_syntax::{number::NumberBase, symbol::SymbolFlags};
 use oxc_traverse::{BoundIdentifier, Traverse};
 
@@ -98,7 +98,7 @@ impl<'a> JsxSource<'a, '_> {
         ctx: &mut TraverseCtx<'a>,
     ) -> ObjectPropertyKind<'a> {
         let kind = PropertyKind::Init;
-        let key = ctx.ast.property_key_static_identifier(SPAN, SOURCE);
+        let key = ctx.ast.property_key_static_identifier(SPAN, Ident::new(SOURCE));
         let value = self.get_source_object(line, column, ctx);
         ctx.ast.object_property_kind_object_property(SPAN, kind, key, value, false, false, false)
     }
@@ -131,7 +131,7 @@ impl<'a> JsxSource<'a, '_> {
             }
         }
 
-        let key = ctx.ast.jsx_attribute_name_identifier(SPAN, SOURCE);
+        let key = ctx.ast.jsx_attribute_name_identifier(SPAN, Ident::new(SOURCE));
         // TODO: We shouldn't calculate line + column from scratch each time as it's expensive.
         // Build a table of byte indexes of each line's start on first usage, and save it.
         // Then calculate line and column from that.
@@ -153,14 +153,14 @@ impl<'a> JsxSource<'a, '_> {
         let kind = PropertyKind::Init;
 
         let filename = {
-            let key = ctx.ast.property_key_static_identifier(SPAN, "fileName");
+            let key = ctx.ast.property_key_static_identifier(SPAN, Ident::new("fileName"));
             let value = self.get_filename_var(ctx).create_read_expression(ctx);
             ctx.ast
                 .object_property_kind_object_property(SPAN, kind, key, value, false, false, false)
         };
 
         let line_number = {
-            let key = ctx.ast.property_key_static_identifier(SPAN, "lineNumber");
+            let key = ctx.ast.property_key_static_identifier(SPAN, Ident::new("lineNumber"));
             let value =
                 ctx.ast.expression_numeric_literal(SPAN, line as f64, None, NumberBase::Decimal);
             ctx.ast
@@ -168,7 +168,7 @@ impl<'a> JsxSource<'a, '_> {
         };
 
         let column_number = {
-            let key = ctx.ast.property_key_static_identifier(SPAN, "columnNumber");
+            let key = ctx.ast.property_key_static_identifier(SPAN, Ident::new("columnNumber"));
             let value =
                 ctx.ast.expression_numeric_literal(SPAN, column as f64, None, NumberBase::Decimal);
             ctx.ast
diff --git a/crates/oxc_transformer/src/jsx/refresh.rs b/crates/oxc_transformer/src/jsx/refresh.rs
index 43499f2f3c755..7c073a0257308 100644
--- a/crates/oxc_transformer/src/jsx/refresh.rs
+++ b/crates/oxc_transformer/src/jsx/refresh.rs
@@ -17,7 +17,7 @@ use oxc_ast_visit::{
     walk::{walk_call_expression, walk_declaration},
 };
 use oxc_semantic::{ReferenceFlags, ScopeFlags, ScopeId, SymbolFlags, SymbolId};
-use oxc_span::{Atom, GetSpan, SPAN};
+use oxc_span::{Atom, GetSpan, Ident, SPAN};
 use oxc_syntax::operator::AssignmentOperator;
 use oxc_traverse::{Ancestor, BoundIdentifier, Traverse};
 
@@ -47,21 +47,21 @@ impl<'a> RefreshIdentifierResolver<'a> {
         let first_part = parts.next().unwrap();
         let Some(second_part) = parts.next() else {
             // Handle simple identifier reference
-            return Self::Identifier(ast.identifier_reference(SPAN, ast.atom(input)));
+            return Self::Identifier(ast.identifier_reference(SPAN, ast.ident(input)));
         };
 
         if first_part == "import" {
             // Handle `import.meta.$RefreshReg$` expression
             let mut expr = ast.expression_meta_property(
                 SPAN,
-                ast.identifier_name(SPAN, "import"),
-                ast.identifier_name(SPAN, ast.atom(second_part)),
+                ast.identifier_name(SPAN, Ident::new("import")),
+                ast.identifier_name(SPAN, ast.ident(second_part)),
             );
             if let Some(property) = parts.next() {
                 expr = Expression::from(ast.member_expression_static(
                     SPAN,
                     expr,
-                    ast.identifier_name(SPAN, ast.atom(property)),
+                    ast.identifier_name(SPAN, ast.ident(property)),
                     false,
                 ));
             }
@@ -69,8 +69,8 @@ impl<'a> RefreshIdentifierResolver<'a> {
         }
 
         // Handle `window.$RefreshReg$` member expression
-        let object = ast.identifier_reference(SPAN, ast.atom(first_part));
-        let property = ast.identifier_name(SPAN, ast.atom(second_part));
+        let object = ast.identifier_reference(SPAN, ast.ident(first_part));
+        let property = ast.identifier_name(SPAN, ast.ident(second_part));
         Self::Member((object, property))
     }
 
@@ -352,7 +352,7 @@ impl<'a> Traverse<'a, TransformState<'a>> for ReactRefresh<'a, '_> {
                     ctx.scoping()
                         .find_binding(
                             ctx.scoping().scope_parent_id(ctx.current_scope_id()).unwrap(),
-                            binding_name.as_str(),
+                            &binding_name,
                         )
                         .map(|symbol_id| {
                             let mut expr = ctx.create_bound_ident_expr(
@@ -528,7 +528,7 @@ impl<'a> ReactRefresh<'a, '_> {
         id: &BindingIdentifier<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) -> Statement<'a> {
-        let left = self.create_registration(id.name, ctx);
+        let left = self.create_registration(id.name.as_atom(), ctx);
         let right =
             ctx.create_bound_ident_expr(SPAN, id.name, id.symbol_id(), ReferenceFlags::Read);
         let expr = ctx.ast.expression_assignment(SPAN, AssignmentOperator::Assign, left, right);
diff --git a/crates/oxc_transformer/src/plugins/styled_components.rs b/crates/oxc_transformer/src/plugins/styled_components.rs
index bb02a24d7d530..bc18afa39c380 100644
--- a/crates/oxc_transformer/src/plugins/styled_components.rs
+++ b/crates/oxc_transformer/src/plugins/styled_components.rs
@@ -67,7 +67,7 @@ use oxc_allocator::{TakeIn, Vec as ArenaVec};
 use oxc_ast::{AstBuilder, NONE, ast::*};
 use oxc_data_structures::{inline_string::InlineString, slice_iter::SliceIter};
 use oxc_semantic::SymbolId;
-use oxc_span::SPAN;
+use oxc_span::{Ident, SPAN};
 use oxc_traverse::{Ancestor, Traverse};
 
 use crate::{
@@ -451,7 +451,7 @@ impl<'a> StyledComponents<'a, '_> {
             let object = ctx.ast.alloc_object_expression(SPAN, properties);
             let arguments = ctx.ast.vec1(Argument::ObjectExpression(object));
             let object = expr.take_in(ctx.ast);
-            let property = ctx.ast.identifier_name(SPAN, "withConfig");
+            let property = ctx.ast.identifier_name(SPAN, Ident::new("withConfig"));
             let callee =
                 Expression::from(ctx.ast.member_expression_static(SPAN, object, property, false));
             let call = ctx.ast.expression_call(SPAN, callee, NONE, arguments, false);
@@ -563,7 +563,7 @@ impl<'a> StyledComponents<'a, '_> {
                     return if let BindingPatternKind::BindingIdentifier(ident) =
                         &declarator.id().kind
                     {
-                        Some(ident.name)
+                        Some(ident.name.as_atom())
                     } else {
                         None
                     };
@@ -571,7 +571,7 @@ impl<'a> StyledComponents<'a, '_> {
                 // `const X = { Y: styled }`
                 Ancestor::ObjectPropertyValue(property) => {
                     return if let PropertyKey::StaticIdentifier(ident) = property.key() {
-                        Some(ident.name)
+                        Some(ident.name.as_atom())
                     } else {
                         None
                     };
@@ -579,7 +579,7 @@ impl<'a> StyledComponents<'a, '_> {
                 // `class Y { (static) X = styled }`
                 Ancestor::PropertyDefinitionValue(property) => {
                     return if let PropertyKey::StaticIdentifier(ident) = property.key() {
-                        Some(ident.name)
+                        Some(ident.name.as_atom())
                     } else {
                         None
                     };
@@ -587,7 +587,7 @@ impl<'a> StyledComponents<'a, '_> {
                 _ => {
                     if ancestor.is_parent_of_statement() {
                         // we've hit a statement, we should stop crawling up
-                        return assignment_name;
+                        return assignment_name.map(|name: Ident<'_>| Ident::as_atom(&name));
                     }
                 }
             }
@@ -796,7 +796,7 @@ impl<'a> StyledComponents<'a, '_> {
         value: Atom<'a>,
         ctx: &TraverseCtx<'a>,
     ) -> ObjectPropertyKind<'a> {
-        let key = ctx.ast.property_key_static_identifier(SPAN, key);
+        let key = ctx.ast.property_key_static_identifier(SPAN, Ident::new(key));
         let value = ctx.ast.expression_string_literal(SPAN, value, None);
         ctx.ast.object_property_kind_object_property(
             SPAN,
diff --git a/crates/oxc_transformer/src/regexp/mod.rs b/crates/oxc_transformer/src/regexp/mod.rs
index 3d8875d44c8de..9c16e0db0099b 100644
--- a/crates/oxc_transformer/src/regexp/mod.rs
+++ b/crates/oxc_transformer/src/regexp/mod.rs
@@ -49,7 +49,7 @@ use oxc_regular_expression::{
     RegexUnsupportedPatterns, has_unsupported_regular_expression_pattern,
 };
 use oxc_semantic::ReferenceFlags;
-use oxc_span::{Atom, SPAN};
+use oxc_span::{Ident, SPAN};
 use oxc_traverse::Traverse;
 
 use crate::{
@@ -163,8 +163,9 @@ impl<'a> RegExp<'a, '_> {
         }
 
         let callee = {
-            let symbol_id = ctx.scoping().find_binding(ctx.current_scope_id(), "RegExp");
-            ctx.create_ident_expr(SPAN, Atom::from("RegExp"), symbol_id, ReferenceFlags::read())
+            let symbol_id =
+                ctx.scoping().find_binding(ctx.current_scope_id(), &Ident::from("RegExp"));
+            ctx.create_ident_expr(SPAN, Ident::from("RegExp"), symbol_id, ReferenceFlags::read())
         };
 
         let arguments = ctx.ast.vec_from_array([
diff --git a/crates/oxc_transformer/src/typescript/annotations.rs b/crates/oxc_transformer/src/typescript/annotations.rs
index d4b06d3a6102f..c75ea032bfa4a 100644
--- a/crates/oxc_transformer/src/typescript/annotations.rs
+++ b/crates/oxc_transformer/src/typescript/annotations.rs
@@ -2,7 +2,7 @@ use oxc_allocator::{TakeIn, Vec as ArenaVec};
 use oxc_ast::ast::*;
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_semantic::SymbolFlags;
-use oxc_span::{Atom, GetSpan, SPAN, Span};
+use oxc_span::{Atom, GetSpan, Ident, SPAN, Span};
 use oxc_syntax::{
     operator::AssignmentOperator,
     reference::ReferenceFlags,
@@ -613,7 +613,11 @@ impl<'a> Assignment<'a> {
     // Creates `this.name = name`
     fn create_this_property_assignment(&self, ctx: &mut TraverseCtx<'a>) -> Statement<'a> {
         let reference_id = ctx.create_bound_reference(self.symbol_id, ReferenceFlags::Read);
-        let id = ctx.ast.identifier_reference_with_reference_id(self.span, self.name, reference_id);
+        let id = ctx.ast.identifier_reference_with_reference_id(
+            self.span,
+            Ident::from(self.name),
+            reference_id,
+        );
 
         ctx.ast.statement_expression(
             SPAN,
@@ -623,7 +627,7 @@ impl<'a> Assignment<'a> {
                 SimpleAssignmentTarget::from(ctx.ast.member_expression_static(
                     SPAN,
                     ctx.ast.expression_this(SPAN),
-                    ctx.ast.identifier_name(self.span, self.name),
+                    ctx.ast.identifier_name(self.span, Ident::from(self.name)),
                     false,
                 ))
                 .into(),
diff --git a/crates/oxc_transformer/src/typescript/enum.rs b/crates/oxc_transformer/src/typescript/enum.rs
index d63e3f75ef5ea..80941d4940622 100644
--- a/crates/oxc_transformer/src/typescript/enum.rs
+++ b/crates/oxc_transformer/src/typescript/enum.rs
@@ -1,14 +1,12 @@
 use std::cell::Cell;
 
-use rustc_hash::FxHashMap;
-
 use oxc_allocator::{StringBuilder, TakeIn, Vec as ArenaVec};
 use oxc_ast::{NONE, ast::*};
 use oxc_ast_visit::{VisitMut, walk_mut};
 use oxc_data_structures::stack::NonEmptyStack;
 use oxc_ecmascript::{ToInt32, ToUint32};
 use oxc_semantic::{ScopeFlags, ScopeId};
-use oxc_span::{Atom, SPAN, Span};
+use oxc_span::{Atom, Ident, IdentHashMap, SPAN, Span};
 use oxc_syntax::{
     number::{NumberBase, ToJsString},
     operator::{AssignmentOperator, BinaryOperator, LogicalOperator, UnaryOperator},
@@ -20,15 +18,15 @@ use oxc_traverse::{BoundIdentifier, Traverse};
 use crate::{context::TraverseCtx, state::TransformState};
 
 /// enum member values (or None if it can't be evaluated at build time) keyed by names
-type PrevMembers<'a> = FxHashMap<Atom<'a>, Option<ConstantValue<'a>>>;
+type PrevMembers<'a> = IdentHashMap<'a, Option<ConstantValue<'a>>>;
 
 pub struct TypeScriptEnum<'a> {
-    enums: FxHashMap<Atom<'a>, PrevMembers<'a>>,
+    enums: IdentHashMap<'a, PrevMembers<'a>>,
 }
 
 impl TypeScriptEnum<'_> {
     pub fn new() -> Self {
-        Self { enums: FxHashMap::default() }
+        Self { enums: IdentHashMap::default() }
     }
 }
 
@@ -220,7 +218,8 @@ impl<'a> TypeScriptEnum<'a> {
         // if it's the first member, it will be `0`.
         // It used to keep track of the previous constant number.
         let mut prev_constant_number = Some(-1.0);
-        let mut previous_enum_members = self.enums.entry(param_binding.name).or_default().clone();
+        let mut previous_enum_members: IdentHashMap<'a, _> =
+            self.enums.entry(param_binding.name).or_default().clone();
 
         let mut prev_member_name = None;
 
@@ -238,7 +237,7 @@ impl<'a> TypeScriptEnum<'a> {
                         prev_constant_number = None;
 
                         IdentifierReferenceRename::new(
-                            param_binding.name,
+                            param_binding.name.as_atom(),
                             enum_scope_id,
                             previous_enum_members.clone(),
                             ctx,
@@ -328,10 +327,11 @@ impl<'a> TypeScriptEnum<'a> {
 
         // Infinity
         let expr = if value.is_infinite() {
-            let infinity_symbol_id = ctx.scoping().find_binding(ctx.current_scope_id(), "Infinity");
+            let infinity_symbol_id =
+                ctx.scoping().find_binding(ctx.current_scope_id(), &Ident::from("Infinity"));
             ctx.create_ident_expr(
                 SPAN,
-                Atom::from("Infinity"),
+                Ident::from("Infinity"),
                 infinity_symbol_id,
                 ReferenceFlags::Read,
             )
@@ -377,7 +377,8 @@ impl<'a> TypeScriptEnum<'a> {
                 let Expression::Identifier(ident) = expr.object() else { return None };
                 let members = self.enums.get(&ident.name)?;
                 let property = expr.static_property_name()?;
-                *members.get(property)?
+                let property = Ident::from(property);
+                *members.get(&property)?
             }
             Expression::Identifier(ident) => {
                 if ident.name == "Infinity" {
@@ -638,7 +639,7 @@ impl<'a> VisitMut<'a> for IdentifierReferenceRename<'a, '_> {
     fn visit_expression(&mut self, expr: &mut Expression<'a>) {
         match expr {
             Expression::Identifier(ident) if self.should_reference_enum_member(ident) => {
-                let object = self.ctx.ast.expression_identifier(SPAN, self.enum_name);
+                let object = self.ctx.ast.expression_identifier(SPAN, Ident::from(self.enum_name));
                 let property = self.ctx.ast.identifier_name(SPAN, ident.name);
                 *expr = self.ctx.ast.member_expression_static(SPAN, object, property, false).into();
             }
diff --git a/crates/oxc_transformer/src/typescript/module.rs b/crates/oxc_transformer/src/typescript/module.rs
index 636ce8910e3ce..a626696b7fa5f 100644
--- a/crates/oxc_transformer/src/typescript/module.rs
+++ b/crates/oxc_transformer/src/typescript/module.rs
@@ -1,7 +1,7 @@
 use oxc_allocator::TakeIn;
 use oxc_ast::{NONE, ast::*};
 use oxc_semantic::{Reference, SymbolFlags};
-use oxc_span::SPAN;
+use oxc_span::{Ident, SPAN};
 use oxc_syntax::reference::ReferenceFlags;
 use oxc_traverse::Traverse;
 
@@ -68,11 +68,14 @@ impl<'a> TypeScriptModule<'a, '_> {
         // module.exports
         let module_exports = {
             let reference_id =
-                ctx.create_reference_in_current_scope("module", ReferenceFlags::Read);
-            let reference =
-                ctx.ast.alloc_identifier_reference_with_reference_id(SPAN, "module", reference_id);
+                ctx.create_reference_in_current_scope(&Ident::from("module"), ReferenceFlags::Read);
+            let reference = ctx.ast.alloc_identifier_reference_with_reference_id(
+                SPAN,
+                Ident::new("module"),
+                reference_id,
+            );
             let object = Expression::Identifier(reference);
-            let property = ctx.ast.identifier_name(SPAN, "exports");
+            let property = ctx.ast.identifier_name(SPAN, Ident::new("exports"));
             ctx.ast.member_expression_static(SPAN, object, property, false)
         };
 
@@ -150,10 +153,10 @@ impl<'a> TypeScriptModule<'a, '_> {
                 }
 
                 let require_symbol_id =
-                    ctx.scoping().find_binding(ctx.current_scope_id(), "require");
+                    ctx.scoping().find_binding(ctx.current_scope_id(), &Ident::from("require"));
                 let callee = ctx.create_ident_expr(
                     SPAN,
-                    Atom::from("require"),
+                    Ident::new("require"),
                     require_symbol_id,
                     ReferenceFlags::Read,
                 );
diff --git a/crates/oxc_transformer/src/utils/ast_builder.rs b/crates/oxc_transformer/src/utils/ast_builder.rs
index e7c2ee589f2c0..a03689514c60d 100644
--- a/crates/oxc_transformer/src/utils/ast_builder.rs
+++ b/crates/oxc_transformer/src/utils/ast_builder.rs
@@ -3,7 +3,7 @@ use std::iter;
 use oxc_allocator::{Box as ArenaBox, Vec as ArenaVec};
 use oxc_ast::{NONE, ast::*};
 use oxc_semantic::{ReferenceFlags, ScopeFlags, ScopeId, SymbolFlags};
-use oxc_span::{GetSpan, SPAN};
+use oxc_span::{GetSpan, Ident, SPAN};
 use oxc_traverse::BoundIdentifier;
 
 use crate::context::TraverseCtx;
@@ -14,7 +14,7 @@ pub fn create_member_callee<'a>(
     property: &'static str,
     ctx: &TraverseCtx<'a>,
 ) -> Expression<'a> {
-    let property = ctx.ast.identifier_name(SPAN, Atom::from(property));
+    let property = ctx.ast.identifier_name(SPAN, Ident::new(property));
     Expression::from(ctx.ast.member_expression_static(SPAN, object, property, false))
 }
 
@@ -80,7 +80,7 @@ pub fn create_prototype_member<'a>(
     object: Expression<'a>,
     ctx: &TraverseCtx<'a>,
 ) -> Expression<'a> {
-    let property = ctx.ast.identifier_name(SPAN, Atom::from("prototype"));
+    let property = ctx.ast.identifier_name(SPAN, Ident::new("prototype"));
     let static_member = ctx.ast.member_expression_static(SPAN, object, property, false);
     Expression::from(static_member)
 }
@@ -92,7 +92,7 @@ pub fn create_property_access<'a>(
     property: &str,
     ctx: &TraverseCtx<'a>,
 ) -> Expression<'a> {
-    let property = ctx.ast.identifier_name(SPAN, ctx.ast.atom(property));
+    let property = ctx.ast.identifier_name(SPAN, ctx.ast.ident(property));
     Expression::from(ctx.ast.member_expression_static(span, object, property, false))
 }
 
@@ -100,7 +100,7 @@ pub fn create_property_access<'a>(
 #[inline]
 pub fn create_this_property_access<'a>(
     span: Span,
-    property: Atom<'a>,
+    property: Ident<'a>,
     ctx: &TraverseCtx<'a>,
 ) -> MemberExpression<'a> {
     let object = ctx.ast.expression_this(span);
@@ -112,7 +112,7 @@ pub fn create_this_property_access<'a>(
 #[inline]
 pub fn create_this_property_assignment<'a>(
     span: Span,
-    property: Atom<'a>,
+    property: Ident<'a>,
     ctx: &TraverseCtx<'a>,
 ) -> AssignmentTarget<'a> {
     AssignmentTarget::from(create_this_property_access(span, property, ctx))
@@ -196,7 +196,7 @@ pub fn create_class_constructor_with_params<'a>(
         MethodDefinitionType::MethodDefinition,
         ctx.ast.vec(),
         PropertyKey::StaticIdentifier(
-            ctx.ast.alloc_identifier_name(SPAN, Atom::from("constructor")),
+            ctx.ast.alloc_identifier_name(SPAN, Ident::new("constructor")),
         ),
         ctx.ast.alloc_function_with_scope_id(
             SPAN,
diff --git a/crates/oxc_transformer_plugins/src/inject_global_variables.rs b/crates/oxc_transformer_plugins/src/inject_global_variables.rs
index 8458a3dc37913..7a0d7f11bc761 100644
--- a/crates/oxc_transformer_plugins/src/inject_global_variables.rs
+++ b/crates/oxc_transformer_plugins/src/inject_global_variables.rs
@@ -5,7 +5,7 @@ use cow_utils::CowUtils;
 use oxc_allocator::Allocator;
 use oxc_ast::{AstBuilder, NONE, ast::*};
 use oxc_semantic::Scoping;
-use oxc_span::{CompactStr, SPAN, format_compact_str};
+use oxc_span::{CompactStr, Ident, SPAN, format_compact_str};
 use oxc_syntax::identifier;
 use oxc_traverse::{Traverse, traverse_mut};
 
@@ -230,12 +230,17 @@ impl<'a> InjectGlobalVariables<'a> {
                     Some(imported_name) => {
                         let imported_name = self.ast.atom(imported_name);
                         if identifier::is_identifier_name(&imported_name) {
-                            self.ast.module_export_name_identifier_name(SPAN, imported_name)
+                            self.ast.module_export_name_identifier_name(
+                                SPAN,
+                                Ident::from(imported_name),
+                            )
                         } else {
                             self.ast.module_export_name_string_literal(SPAN, imported_name, None)
                         }
                     }
-                    None => self.ast.module_export_name_identifier_name(SPAN, "default"),
+                    None => {
+                        self.ast.module_export_name_identifier_name(SPAN, Ident::new("default"))
+                    }
                 };
 
                 let local = inject.replace_value.as_ref().unwrap_or(local).as_str();
@@ -243,18 +248,18 @@ impl<'a> InjectGlobalVariables<'a> {
                 self.ast.import_declaration_specifier_import_specifier(
                     SPAN,
                     imported,
-                    self.ast.binding_identifier(SPAN, self.ast.atom(local)),
+                    self.ast.binding_identifier(SPAN, self.ast.ident(local)),
                     ImportOrExportKind::Value,
                 )
             }
             InjectImportSpecifier::DefaultSpecifier { local } => {
                 let local = inject.replace_value.as_ref().unwrap_or(local).as_str();
-                let local = self.ast.binding_identifier(SPAN, self.ast.atom(local));
+                let local = self.ast.binding_identifier(SPAN, self.ast.ident(local));
                 self.ast.import_declaration_specifier_import_default_specifier(SPAN, local)
             }
             InjectImportSpecifier::NamespaceSpecifier { local } => {
                 let local = inject.replace_value.as_ref().unwrap_or(local).as_str();
-                let local = self.ast.binding_identifier(SPAN, self.ast.atom(local));
+                let local = self.ast.binding_identifier(SPAN, self.ast.ident(local));
                 self.ast.import_declaration_specifier_import_namespace_specifier(SPAN, local)
             }
         }
@@ -277,7 +282,7 @@ impl<'a> InjectGlobalVariables<'a> {
                             self.ast.atom(dot_define.value.as_str())
                         });
 
-                        let value = self.ast.expression_identifier(SPAN, value_atom);
+                        let value = self.ast.expression_identifier(SPAN, Ident::from(value_atom));
                         *expr = value;
                         self.mark_as_changed();
                         break;
@@ -301,7 +306,8 @@ impl<'a> InjectGlobalVariables<'a> {
                                 self.ast.atom(dot_define.value.as_str())
                             });
 
-                            let value = self.ast.expression_identifier(SPAN, value_atom);
+                            let value =
+                                self.ast.expression_identifier(SPAN, Ident::from(value_atom));
                             *expr = value;
                             self.mark_as_changed();
                             break;
diff --git a/crates/oxc_transformer_plugins/src/module_runner_transform.rs b/crates/oxc_transformer_plugins/src/module_runner_transform.rs
index aeca46c6fe5ac..a9e9373c4b09b 100644
--- a/crates/oxc_transformer_plugins/src/module_runner_transform.rs
+++ b/crates/oxc_transformer_plugins/src/module_runner_transform.rs
@@ -54,7 +54,7 @@ use oxc_allocator::{Allocator, Box as ArenaBox, TakeIn, Vec as ArenaVec};
 use oxc_ast::{NONE, ast::*};
 use oxc_ecmascript::BoundNames;
 use oxc_semantic::{ReferenceFlags, ScopeFlags, Scoping, SymbolFlags, SymbolId};
-use oxc_span::SPAN;
+use oxc_span::{Ident, SPAN};
 use oxc_syntax::identifier::is_identifier_name;
 use oxc_traverse::{Ancestor, BoundIdentifier, Traverse, traverse_mut};
 
@@ -263,7 +263,8 @@ impl<'a> ModuleRunnerTransform<'a> {
         }
 
         let flags = ReferenceFlags::Read;
-        let callee = ctx.create_unbound_ident_expr(SPAN, SSR_DYNAMIC_IMPORT_KEY, flags);
+        let callee =
+            ctx.create_unbound_ident_expr(SPAN, Ident::from(SSR_DYNAMIC_IMPORT_KEY), flags);
         let arguments = options.into_iter().map(Argument::from);
         let arguments = ctx.ast.vec_from_iter(iter::once(Argument::from(source)).chain(arguments));
         *expr = ctx.ast.expression_call(span, callee, NONE, arguments, false);
@@ -276,7 +277,11 @@ impl<'a> ModuleRunnerTransform<'a> {
             unreachable!();
         };
 
-        *expr = ctx.create_unbound_ident_expr(meta.span, SSR_IMPORT_META_KEY, ReferenceFlags::Read);
+        *expr = ctx.create_unbound_ident_expr(
+            meta.span,
+            Ident::from(SSR_IMPORT_META_KEY),
+            ReferenceFlags::Read,
+        );
     }
 
     /// Transform import declaration (`import { foo } from 'vue'`).
@@ -327,7 +332,7 @@ impl<'a> ModuleRunnerTransform<'a> {
 
                 // Reuse the `vue` binding identifier by renaming it to `__vite_ssr_import_0__`
                 let mut local = specifier.unbox().local;
-                local.name = self.generate_import_binding_name(ctx);
+                local.name = Ident::from(self.generate_import_binding_name(ctx));
                 let binding = BoundIdentifier::from_binding_ident(&local);
                 ctx.scoping_mut().set_symbol_name(binding.symbol_id, &binding.name);
                 self.import_bindings.insert(binding.symbol_id, (binding, None));
@@ -398,7 +403,12 @@ impl<'a> ModuleRunnerTransform<'a> {
                     variable.bound_names(&mut |ident| {
                         let binding = BoundIdentifier::from_binding_ident(ident);
                         let ident = binding.create_read_expression(ctx);
-                        hoist_exports.push(Self::create_export(span, ident, binding.name, ctx));
+                        hoist_exports.push(Self::create_export(
+                            span,
+                            ident,
+                            binding.name.as_atom(),
+                            ctx,
+                        ));
                     });
                     // Should be inserted before the exports
                     new_stmts.insert(new_stmts_index, Statement::from(declaration));
@@ -408,13 +418,13 @@ impl<'a> ModuleRunnerTransform<'a> {
                 Declaration::FunctionDeclaration(func) => {
                     let binding = BoundIdentifier::from_binding_ident(func.id.as_ref().unwrap());
                     let ident = binding.create_read_expression(ctx);
-                    Self::create_export(span, ident, binding.name, ctx)
+                    Self::create_export(span, ident, binding.name.as_atom(), ctx)
                 }
                 // `export class Foo {}`
                 Declaration::ClassDeclaration(class) => {
                     let binding = BoundIdentifier::from_binding_ident(class.id.as_ref().unwrap());
                     let ident = binding.create_read_expression(ctx);
-                    Self::create_export(span, ident, binding.name, ctx)
+                    Self::create_export(span, ident, binding.name.as_atom(), ctx)
                 }
                 _ => {
                     unreachable!(
@@ -461,7 +471,7 @@ impl<'a> ModuleRunnerTransform<'a> {
                     };
                     Expression::Identifier(ctx.ast.alloc(ident))
                 };
-                Self::create_export(span, expr, exported.name(), ctx)
+                Self::create_export(span, expr, exported.name().as_atom(), ctx)
             }));
         }
     }
@@ -503,11 +513,11 @@ impl<'a> ModuleRunnerTransform<'a> {
         if let Some(exported) = exported {
             // `export * as foo from 'vue'` ->
             // `Object.defineProperty(__vite_ssr_exports__, 'foo', { enumerable: true, configurable: true, get(){ return __vite_ssr_import_0__ } });`
-            let export = Self::create_export(span, ident, exported.name(), ctx);
+            let export = Self::create_export(span, ident, exported.name().as_atom(), ctx);
             hoist_imports.push(import);
             hoist_exports.push(export);
         } else {
-            let callee = ctx.ast.expression_identifier(SPAN, SSR_EXPORT_ALL_KEY);
+            let callee = ctx.ast.expression_identifier(SPAN, Ident::from(SSR_EXPORT_ALL_KEY));
             let arguments = ctx.ast.vec1(Argument::from(ident));
             // `export * from 'vue'` -> `__vite_ssr_exportAll__(__vite_ssr_import_0__);`
             let call = ctx.ast.expression_call(SPAN, callee, NONE, arguments, false);
@@ -600,7 +610,7 @@ impl<'a> ModuleRunnerTransform<'a> {
             ctx.ast.vec_from_iter(specifiers.into_iter().map(|specifier| match specifier {
                 ImportDeclarationSpecifier::ImportSpecifier(specifier) => {
                     let ImportSpecifier { span, local, imported, .. } = specifier.unbox();
-                    self.insert_import_binding(span, binding, local, imported.name(), ctx)
+                    self.insert_import_binding(span, binding, local, imported.name().as_atom(), ctx)
                 }
                 ImportDeclarationSpecifier::ImportDefaultSpecifier(specifier) => {
                     let ImportDefaultSpecifier { span, local } = specifier.unbox();
@@ -659,7 +669,7 @@ impl<'a> ModuleRunnerTransform<'a> {
     #[inline]
     fn generate_import_binding(&mut self, ctx: &mut TraverseCtx<'a>) -> BoundIdentifier<'a> {
         let name = self.generate_import_binding_name(ctx);
-        ctx.generate_binding_in_current_scope(name, SymbolFlags::BlockScopedVariable)
+        ctx.generate_binding_in_current_scope(Ident::from(name), SymbolFlags::BlockScopedVariable)
     }
 
     // { importedNames: ['foo', 'bar'] }
@@ -668,7 +678,7 @@ impl<'a> ModuleRunnerTransform<'a> {
         ctx: &TraverseCtx<'a>,
     ) -> Argument<'a> {
         let value = ctx.ast.expression_array(SPAN, elements);
-        let key = ctx.ast.property_key_static_identifier(SPAN, Atom::from("importedNames"));
+        let key = ctx.ast.property_key_static_identifier(SPAN, Ident::from("importedNames"));
         let imported_names = ctx.ast.object_property_kind_object_property(
             SPAN,
             PropertyKind::Init,
@@ -688,7 +698,8 @@ impl<'a> ModuleRunnerTransform<'a> {
         arguments: ArenaVec<'a, Argument<'a>>,
         ctx: &mut TraverseCtx<'a>,
     ) -> Statement<'a> {
-        let callee = ctx.create_unbound_ident_expr(SPAN, SSR_IMPORT_KEY, ReferenceFlags::Read);
+        let callee =
+            ctx.create_unbound_ident_expr(SPAN, Ident::from(SSR_IMPORT_KEY), ReferenceFlags::Read);
         let call = ctx.ast.expression_call(SPAN, callee, NONE, arguments, false);
         let init = ctx.ast.expression_await(SPAN, call);
 
@@ -704,7 +715,7 @@ impl<'a> ModuleRunnerTransform<'a> {
         ctx: &mut TraverseCtx<'a>,
     ) -> Expression<'a> {
         let object =
-            ctx.create_unbound_ident_expr(SPAN, Atom::from("Object"), ReferenceFlags::Read);
+            ctx.create_unbound_ident_expr(SPAN, Ident::from("Object"), ReferenceFlags::Read);
         let member = create_member_callee(object, "defineProperty", ctx);
         ctx.ast.expression_call(SPAN, member, NONE, arguments, false)
     }
@@ -719,7 +730,7 @@ impl<'a> ModuleRunnerTransform<'a> {
         ctx.ast.object_property_kind_object_property(
             SPAN,
             PropertyKind::Init,
-            ctx.ast.property_key_static_identifier(SPAN, key),
+            ctx.ast.property_key_static_identifier(SPAN, Ident::from(key)),
             value.unwrap_or_else(|| ctx.ast.expression_boolean_literal(SPAN, true)),
             is_method,
             false,
@@ -776,7 +787,7 @@ impl<'a> ModuleRunnerTransform<'a> {
         let arguments = ctx.ast.vec_from_array([
             Argument::from(ctx.create_unbound_ident_expr(
                 SPAN,
-                SSR_MODULE_EXPORTS_KEY,
+                Ident::from(SSR_MODULE_EXPORTS_KEY),
                 ReferenceFlags::Read,
             )),
             Argument::from(ctx.ast.expression_string_literal(SPAN, exported_name, None)),
@@ -789,7 +800,11 @@ impl<'a> ModuleRunnerTransform<'a> {
     fn create_export_default(span: Span, ctx: &mut TraverseCtx<'a>) -> Statement<'a> {
         Self::create_export(
             span,
-            ctx.create_unbound_ident_expr(SPAN, SSR_EXPORT_DEFAULT_KEY, ReferenceFlags::Read),
+            ctx.create_unbound_ident_expr(
+                SPAN,
+                Ident::from(SSR_EXPORT_DEFAULT_KEY),
+                ReferenceFlags::Read,
+            ),
             DEFAULT,
             ctx,
         )
@@ -802,7 +817,7 @@ impl<'a> ModuleRunnerTransform<'a> {
         ctx: &mut TraverseCtx<'a>,
     ) -> Statement<'a> {
         let binding = ctx.generate_binding_in_current_scope(
-            SSR_EXPORT_DEFAULT_KEY,
+            Ident::from(SSR_EXPORT_DEFAULT_KEY),
             SymbolFlags::BlockScopedVariable,
         );
         let pattern = binding.create_binding_pattern(ctx);
@@ -830,7 +845,7 @@ pub fn create_member_callee<'a>(
     property: &'static str,
     ctx: &TraverseCtx<'a>,
 ) -> Expression<'a> {
-    let property = ctx.ast.identifier_name(SPAN, Atom::from(property));
+    let property = ctx.ast.identifier_name(SPAN, Ident::from(property));
     Expression::from(ctx.ast.member_expression_static(SPAN, object, property, false))
 }
 
@@ -841,7 +856,7 @@ pub fn create_property_access<'a>(
     property: &str,
     ctx: &TraverseCtx<'a>,
 ) -> Expression<'a> {
-    let property = ctx.ast.identifier_name(SPAN, ctx.ast.atom(property));
+    let property = ctx.ast.identifier_name(SPAN, ctx.ast.ident(property));
     Expression::from(ctx.ast.member_expression_static(span, object, property, false))
 }
 
diff --git a/crates/oxc_transformer_plugins/src/replace_global_defines.rs b/crates/oxc_transformer_plugins/src/replace_global_defines.rs
index 1ff900c8d62a6..69bb237f143eb 100644
--- a/crates/oxc_transformer_plugins/src/replace_global_defines.rs
+++ b/crates/oxc_transformer_plugins/src/replace_global_defines.rs
@@ -596,7 +596,7 @@ impl<'a> ReplaceGlobalDefines<'a> {
             current_part_member_expression = if let Some(member) = current_part_member_expression {
                 match &member.object() {
                     Expression::StaticMemberExpression(member) => {
-                        cur_part_name = &member.property.name;
+                        cur_part_name = member.property.name.as_atom();
                         Some(DotDefineMemberExpression::StaticMemberExpression(member))
                     }
                     Expression::ComputedMemberExpression(computed_member) => {
@@ -609,11 +609,11 @@ impl<'a> ReplaceGlobalDefines<'a> {
                         if !ident.is_global_reference(ctx.scoping()) {
                             return false;
                         }
-                        cur_part_name = &ident.name;
+                        cur_part_name = ident.name.as_atom();
                         None
                     }
                     Expression::ThisExpression(_) if should_replace_this_expr => {
-                        cur_part_name = &THIS_ATOM;
+                        cur_part_name = THIS_ATOM;
                         None
                     }
                     Expression::MetaProperty(meta) => {
@@ -653,9 +653,11 @@ pub enum DotDefineMemberExpression<'b, 'ast: 'b> {
 }
 
 impl<'b, 'a> DotDefineMemberExpression<'b, 'a> {
-    fn name(&self) -> Option<&'b Atom<'a>> {
+    fn name(&self) -> Option<Atom<'a>> {
         match self {
-            DotDefineMemberExpression::StaticMemberExpression(expr) => Some(&expr.property.name),
+            DotDefineMemberExpression::StaticMemberExpression(expr) => {
+                Some(expr.property.name.as_atom())
+            }
             DotDefineMemberExpression::ComputedMemberExpression(expr) => {
                 static_property_name_of_computed_expr(expr)
             }
@@ -672,11 +674,11 @@ impl<'b, 'a> DotDefineMemberExpression<'b, 'a> {
 
 fn static_property_name_of_computed_expr<'b, 'a: 'b>(
     expr: &'b ComputedMemberExpression<'a>,
-) -> Option<&'b Atom<'a>> {
+) -> Option<Atom<'a>> {
     match &expr.expression {
-        Expression::StringLiteral(lit) => Some(&lit.value),
+        Expression::StringLiteral(lit) => Some(lit.value),
         Expression::TemplateLiteral(lit) if lit.expressions.is_empty() && lit.quasis.len() == 1 => {
-            Some(&lit.quasis[0].value.raw)
+            Some(lit.quasis[0].value.raw)
         }
         _ => None,
     }
@@ -763,7 +765,7 @@ struct UpdateReplacedExpression<'a, 'b> {
 impl VisitMut<'_> for UpdateReplacedExpression<'_, '_> {
     fn visit_identifier_reference(&mut self, ident: &mut IdentifierReference<'_>) {
         let reference_id =
-            self.ctx.create_reference_in_current_scope(ident.name.as_str(), ReferenceFlags::Read);
+            self.ctx.create_reference_in_current_scope(&ident.name, ReferenceFlags::Read);
         ident.set_reference_id(reference_id);
         walk_mut::walk_identifier_reference(self, ident);
     }
diff --git a/crates/oxc_traverse/src/context/bound_identifier.rs b/crates/oxc_traverse/src/context/bound_identifier.rs
index 0ee66cac82d46..d0632a2c95c4c 100644
--- a/crates/oxc_traverse/src/context/bound_identifier.rs
+++ b/crates/oxc_traverse/src/context/bound_identifier.rs
@@ -5,7 +5,7 @@ use oxc_ast::{
         IdentifierReference, SimpleAssignmentTarget,
     },
 };
-use oxc_span::{Atom, SPAN, Span};
+use oxc_span::{Ident, SPAN, Span};
 use oxc_syntax::{reference::ReferenceFlags, symbol::SymbolId};
 
 use crate::TraverseCtx;
@@ -41,13 +41,13 @@ use super::MaybeBoundIdentifier;
 ///   created from it.
 #[derive(Debug, Clone)]
 pub struct BoundIdentifier<'a> {
-    pub name: Atom<'a>,
+    pub name: Ident<'a>,
     pub symbol_id: SymbolId,
 }
 
 impl<'a> BoundIdentifier<'a> {
     /// Create `BoundIdentifier` for `name` and `symbol_id`
-    pub fn new(name: Atom<'a>, symbol_id: SymbolId) -> Self {
+    pub fn new(name: Ident<'a>, symbol_id: SymbolId) -> Self {
         Self { name, symbol_id }
     }
 
diff --git a/crates/oxc_traverse/src/context/maybe_bound_identifier.rs b/crates/oxc_traverse/src/context/maybe_bound_identifier.rs
index 5ddf12a560466..05ca414a1f697 100644
--- a/crates/oxc_traverse/src/context/maybe_bound_identifier.rs
+++ b/crates/oxc_traverse/src/context/maybe_bound_identifier.rs
@@ -1,5 +1,5 @@
 use oxc_ast::ast::{AssignmentTarget, Expression, IdentifierReference, SimpleAssignmentTarget};
-use oxc_span::{Atom, SPAN, Span};
+use oxc_span::{Ident, SPAN, Span};
 use oxc_syntax::{reference::ReferenceFlags, symbol::SymbolId};
 
 use crate::TraverseCtx;
@@ -29,13 +29,13 @@ use super::BoundIdentifier;
 /// * `MaybeBoundIdentifier` looks up the `SymbolId` for the reference only once.
 #[derive(Debug, Clone)]
 pub struct MaybeBoundIdentifier<'a> {
-    pub name: Atom<'a>,
+    pub name: Ident<'a>,
     pub symbol_id: Option<SymbolId>,
 }
 
 impl<'a> MaybeBoundIdentifier<'a> {
     /// Create `MaybeBoundIdentifier` for `name` and `Option<SymbolId>`
-    pub fn new(name: Atom<'a>, symbol_id: Option<SymbolId>) -> Self {
+    pub fn new(name: Ident<'a>, symbol_id: Option<SymbolId>) -> Self {
         Self { name, symbol_id }
     }
 
diff --git a/crates/oxc_traverse/src/context/mod.rs b/crates/oxc_traverse/src/context/mod.rs
index 0703a3b472e02..8db4fe0391d93 100644
--- a/crates/oxc_traverse/src/context/mod.rs
+++ b/crates/oxc_traverse/src/context/mod.rs
@@ -4,7 +4,7 @@ use oxc_ast::{
     ast::{Expression, IdentifierReference, Statement},
 };
 use oxc_semantic::Scoping;
-use oxc_span::{Atom, Span};
+use oxc_span::{Atom, Ident, Span};
 use oxc_syntax::{
     reference::{ReferenceFlags, ReferenceId},
     scope::{ScopeFlags, ScopeId},
@@ -369,7 +369,7 @@ impl<'a, State> TraverseCtx<'a, State> {
     /// This is a shortcut for `ctx.scoping.generate_binding`.
     pub fn generate_binding(
         &mut self,
-        name: Atom<'a>,
+        name: Ident<'a>,
         scope_id: ScopeId,
         flags: SymbolFlags,
     ) -> BoundIdentifier<'a> {
@@ -383,7 +383,7 @@ impl<'a, State> TraverseCtx<'a, State> {
     /// This is a shortcut for `ctx.scoping.generate_binding_in_current_scope`.
     pub fn generate_binding_in_current_scope(
         &mut self,
-        name: Atom<'a>,
+        name: Ident<'a>,
         flags: SymbolFlags,
     ) -> BoundIdentifier<'a> {
         self.scoping.generate_binding_in_current_scope(name, flags)
@@ -414,6 +414,7 @@ impl<'a, State> TraverseCtx<'a, State> {
     ) -> BoundIdentifier<'a> {
         // Get name for UID
         let name = self.generate_uid_name(name);
+        let name = Ident::from(name);
         let symbol_id = self.scoping.add_binding(&name, scope_id, flags);
         BoundIdentifier::new(name, symbol_id)
     }
@@ -512,7 +513,7 @@ impl<'a, State> TraverseCtx<'a, State> {
     pub fn create_bound_ident_reference(
         &mut self,
         span: Span,
-        name: Atom<'a>,
+        name: Ident<'a>,
         symbol_id: SymbolId,
         flags: ReferenceFlags,
     ) -> IdentifierReference<'a> {
@@ -524,7 +525,7 @@ impl<'a, State> TraverseCtx<'a, State> {
     pub fn create_bound_ident_expr(
         &mut self,
         span: Span,
-        name: Atom<'a>,
+        name: Ident<'a>,
         symbol_id: SymbolId,
         flags: ReferenceFlags,
     ) -> Expression<'a> {
@@ -536,7 +537,11 @@ impl<'a, State> TraverseCtx<'a, State> {
     ///
     /// This is a shortcut for `ctx.scoping.create_unbound_reference`.
     #[inline]
-    pub fn create_unbound_reference(&mut self, name: &str, flags: ReferenceFlags) -> ReferenceId {
+    pub fn create_unbound_reference(
+        &mut self,
+        name: &Ident<'_>,
+        flags: ReferenceFlags,
+    ) -> ReferenceId {
         self.scoping.create_unbound_reference(name, flags)
     }
 
@@ -544,10 +549,10 @@ impl<'a, State> TraverseCtx<'a, State> {
     pub fn create_unbound_ident_reference(
         &mut self,
         span: Span,
-        name: Atom<'a>,
+        name: Ident<'a>,
         flags: ReferenceFlags,
     ) -> IdentifierReference<'a> {
-        let reference_id = self.create_unbound_reference(name.as_str(), flags);
+        let reference_id = self.create_unbound_reference(&name, flags);
         self.ast.identifier_reference_with_reference_id(span, name, reference_id)
     }
 
@@ -555,7 +560,7 @@ impl<'a, State> TraverseCtx<'a, State> {
     pub fn create_unbound_ident_expr(
         &mut self,
         span: Span,
-        name: Atom<'a>,
+        name: Ident<'a>,
         flags: ReferenceFlags,
     ) -> Expression<'a> {
         let ident = self.create_unbound_ident_reference(span, name, flags);
@@ -571,7 +576,7 @@ impl<'a, State> TraverseCtx<'a, State> {
     #[inline]
     pub fn create_reference(
         &mut self,
-        name: &str,
+        name: &Ident<'_>,
         symbol_id: Option<SymbolId>,
         flags: ReferenceFlags,
     ) -> ReferenceId {
@@ -585,7 +590,7 @@ impl<'a, State> TraverseCtx<'a, State> {
     pub fn create_ident_reference(
         &mut self,
         span: Span,
-        name: Atom<'a>,
+        name: Ident<'a>,
         symbol_id: Option<SymbolId>,
         flags: ReferenceFlags,
     ) -> IdentifierReference<'a> {
@@ -603,7 +608,7 @@ impl<'a, State> TraverseCtx<'a, State> {
     pub fn create_ident_expr(
         &mut self,
         span: Span,
-        name: Atom<'a>,
+        name: Ident<'a>,
         symbol_id: Option<SymbolId>,
         flags: ReferenceFlags,
     ) -> Expression<'a> {
@@ -620,7 +625,7 @@ impl<'a, State> TraverseCtx<'a, State> {
     #[inline]
     pub fn create_reference_in_current_scope(
         &mut self,
-        name: &str,
+        name: &Ident,
         flags: ReferenceFlags,
     ) -> ReferenceId {
         self.scoping.create_reference_in_current_scope(name, flags)
diff --git a/crates/oxc_traverse/src/context/scoping.rs b/crates/oxc_traverse/src/context/scoping.rs
index f3d414544e166..15285bfc8eb78 100644
--- a/crates/oxc_traverse/src/context/scoping.rs
+++ b/crates/oxc_traverse/src/context/scoping.rs
@@ -4,7 +4,7 @@ use oxc_allocator::{Allocator, Vec as ArenaVec};
 use oxc_ast::ast::*;
 use oxc_ast_visit::Visit;
 use oxc_semantic::{NodeId, Reference, Scoping};
-use oxc_span::SPAN;
+use oxc_span::{Ident, SPAN};
 use oxc_syntax::{
     reference::{ReferenceFlags, ReferenceId},
     scope::{ScopeFlags, ScopeId},
@@ -242,7 +242,7 @@ impl<'a> TraverseScoping<'a> {
     #[inline]
     pub(crate) fn add_binding(
         &mut self,
-        name: &str,
+        name: &Ident,
         scope_id: ScopeId,
         flags: SymbolFlags,
     ) -> SymbolId {
@@ -257,11 +257,11 @@ impl<'a> TraverseScoping<'a> {
     /// Creates a symbol with the provided name and flags and adds it to the specified scope.
     pub fn generate_binding(
         &mut self,
-        name: Atom<'a>,
+        name: Ident<'a>,
         scope_id: ScopeId,
         flags: SymbolFlags,
     ) -> BoundIdentifier<'a> {
-        let symbol_id = self.add_binding(name.as_str(), scope_id, flags);
+        let symbol_id = self.add_binding(&name, scope_id, flags);
         BoundIdentifier::new(name, symbol_id)
     }
 
@@ -270,7 +270,7 @@ impl<'a> TraverseScoping<'a> {
     /// Creates a symbol with the provided name and flags and adds it to the current scope.
     pub fn generate_binding_in_current_scope(
         &mut self,
-        name: Atom<'a>,
+        name: Ident<'a>,
         flags: SymbolFlags,
     ) -> BoundIdentifier<'a> {
         self.generate_binding(name, self.current_scope_id, flags)
@@ -306,7 +306,11 @@ impl<'a> TraverseScoping<'a> {
     }
 
     /// Create an unbound reference
-    pub fn create_unbound_reference(&mut self, name: &str, flags: ReferenceFlags) -> ReferenceId {
+    pub fn create_unbound_reference(
+        &mut self,
+        name: &Ident<'_>,
+        flags: ReferenceFlags,
+    ) -> ReferenceId {
         let reference = Reference::new(NodeId::DUMMY, flags);
         let reference_id = self.scoping.create_reference(reference);
         self.scoping.add_root_unresolved_reference(name, reference_id);
@@ -319,7 +323,7 @@ impl<'a> TraverseScoping<'a> {
     /// or `TraverseCtx::create_unbound_reference`.
     pub fn create_reference(
         &mut self,
-        name: &str,
+        name: &Ident<'_>,
         symbol_id: Option<SymbolId>,
         flags: ReferenceFlags,
     ) -> ReferenceId {
@@ -333,7 +337,7 @@ impl<'a> TraverseScoping<'a> {
     /// Create reference in current scope, looking up binding for `name`
     pub fn create_reference_in_current_scope(
         &mut self,
-        name: &str,
+        name: &Ident,
         flags: ReferenceFlags,
     ) -> ReferenceId {
         let symbol_id = self.scoping.find_binding(self.current_scope_id, name);
diff --git a/crates/oxc_traverse/src/context/uid.rs b/crates/oxc_traverse/src/context/uid.rs
index b4ee17b137253..4d29f414f9a35 100644
--- a/crates/oxc_traverse/src/context/uid.rs
+++ b/crates/oxc_traverse/src/context/uid.rs
@@ -143,7 +143,7 @@ impl<'a> UidGenerator<'a> {
         for name in scoping.symbol_names() {
             generator.add(name);
         }
-        for &name in scoping.root_unresolved_references().keys() {
+        for name in scoping.root_unresolved_references().keys() {
             generator.add(name);
         }
 
diff --git a/editors/vscode/tests/commands.spec.ts b/editors/vscode/tests/commands.spec.ts
index 6ef932e03f9b6..287d364ed6654 100644
--- a/editors/vscode/tests/commands.spec.ts
+++ b/editors/vscode/tests/commands.spec.ts
@@ -31,55 +31,31 @@ suite('commands', () => {
   testSingleFolderMode('listed commands', async () => {
     const oxcCommands = (await commands.getCommands(true)).filter(x => x.startsWith('oxc.'));
 
-    const expectedCommands = [
-      'oxc.showOutputChannel',
-      'oxc.showOutputChannelFormatter',
+    const extraCommands = process.env.SKIP_LINTER_TEST === 'true' ? [] : [
+      'oxc.fixAll',
     ];
 
-    if (process.env.SKIP_LINTER_TEST !== 'true') {
-      expectedCommands.push(
-        'oxc.restartServer',
-        'oxc.toggleEnable',
-        'oxc.applyAllFixesFile',
-        'oxc.fixAll',
-      );
-    }
-
-    if (process.env.SKIP_FORMATTER_TEST !== 'true' && !process.env.SERVER_PATH_DEV?.includes('oxc_language_server')) {
-      expectedCommands.push(
-        'oxc.restartServerFormatter',
-      );
-    }
-
-    deepStrictEqual(expectedCommands, oxcCommands);
+    deepStrictEqual([
+      'oxc.showOutputChannel',
+      'oxc.restartServer',
+      'oxc.toggleEnable',
+      'oxc.applyAllFixesFile', // TODO: only if linter tests are enabled
+      ...extraCommands,
+    ], oxcCommands);
   });
 
   testSingleFolderMode('oxc.showOutputChannel', async () => {
     await commands.executeCommand('oxc.showOutputChannel');
-    await sleep(250);
-
-    notEqual(window.activeTextEditor, undefined);
-    const { uri } = window.activeTextEditor!.document;
-    strictEqual(uri.toString(), 'output:oxc.oxc-vscode.Oxc%20%28Lint%29');
-
-    await commands.executeCommand('workbench.action.closeActiveEditor');
-  });
-
-  testSingleFolderMode('oxc.showOutputChannelFormatter', async () => {
-    await commands.executeCommand('oxc.showOutputChannelFormatter');
-    await sleep(250);
+    await sleep(500);
 
     notEqual(window.activeTextEditor, undefined);
     const { uri } = window.activeTextEditor!.document;
-    strictEqual(uri.toString(), 'output:oxc.oxc-vscode.Oxc%20%28Fmt%29');
+    strictEqual(uri.toString(), 'output:oxc.oxc-vscode.Oxc');
 
     await commands.executeCommand('workbench.action.closeActiveEditor');
   });
 
   testSingleFolderMode('oxc.toggleEnable', async () => {
-    if (process.env.SKIP_LINTER_TEST === 'true') {
-      return;
-    }
     const isEnabledBefore = workspace.getConfiguration('oxc').get<boolean>('enable');
     strictEqual(isEnabledBefore, true);
 
diff --git a/napi/parser/generated/deserialize/js.js b/napi/parser/generated/deserialize/js.js
index 665d39f7cfe51..623b804824c8e 100644
--- a/napi/parser/generated/deserialize/js.js
+++ b/napi/parser/generated/deserialize/js.js
@@ -142,7 +142,7 @@ function deserializeIdentifierName(pos) {
     end = deserializeU32(pos + 4);
   return {
     type: "Identifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
   };
@@ -153,7 +153,7 @@ function deserializeIdentifierReference(pos) {
     end = deserializeU32(pos + 4);
   return {
     type: "Identifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
   };
@@ -164,7 +164,7 @@ function deserializeBindingIdentifier(pos) {
     end = deserializeU32(pos + 4);
   return {
     type: "Identifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
   };
@@ -175,7 +175,7 @@ function deserializeLabelIdentifier(pos) {
     end = deserializeU32(pos + 4);
   return {
     type: "Identifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
   };
@@ -1976,7 +1976,7 @@ function deserializePrivateIdentifier(pos) {
     end = deserializeU32(pos + 4);
   return {
     type: "PrivateIdentifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
   };
@@ -2788,7 +2788,7 @@ function deserializeJSXIdentifier(pos) {
     end = deserializeU32(pos + 4);
   return {
     type: "JSXIdentifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
   };
diff --git a/napi/parser/generated/deserialize/js_parent.js b/napi/parser/generated/deserialize/js_parent.js
index c719d95a3e564..fde3642372b82 100644
--- a/napi/parser/generated/deserialize/js_parent.js
+++ b/napi/parser/generated/deserialize/js_parent.js
@@ -151,7 +151,7 @@ function deserializeIdentifierName(pos) {
     previousParent = parent,
     node = (parent = {
       type: "Identifier",
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       start,
       end,
       parent,
@@ -166,7 +166,7 @@ function deserializeIdentifierReference(pos) {
     previousParent = parent,
     node = (parent = {
       type: "Identifier",
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       start,
       end,
       parent,
@@ -181,7 +181,7 @@ function deserializeBindingIdentifier(pos) {
     previousParent = parent,
     node = (parent = {
       type: "Identifier",
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       start,
       end,
       parent,
@@ -196,7 +196,7 @@ function deserializeLabelIdentifier(pos) {
     previousParent = parent,
     node = (parent = {
       type: "Identifier",
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       start,
       end,
       parent,
@@ -2289,7 +2289,7 @@ function deserializePrivateIdentifier(pos) {
     end = deserializeU32(pos + 4);
   return {
     type: "PrivateIdentifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
     parent,
@@ -3233,7 +3233,7 @@ function deserializeJSXIdentifier(pos) {
     end = deserializeU32(pos + 4);
   return {
     type: "JSXIdentifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
     parent,
diff --git a/napi/parser/generated/deserialize/js_range.js b/napi/parser/generated/deserialize/js_range.js
index 7b946532e948a..acb6c8109d458 100644
--- a/napi/parser/generated/deserialize/js_range.js
+++ b/napi/parser/generated/deserialize/js_range.js
@@ -143,7 +143,7 @@ function deserializeIdentifierName(pos) {
     end = deserializeU32(pos + 4);
   return {
     type: "Identifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
     range: [start, end],
@@ -155,7 +155,7 @@ function deserializeIdentifierReference(pos) {
     end = deserializeU32(pos + 4);
   return {
     type: "Identifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
     range: [start, end],
@@ -167,7 +167,7 @@ function deserializeBindingIdentifier(pos) {
     end = deserializeU32(pos + 4);
   return {
     type: "Identifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
     range: [start, end],
@@ -179,7 +179,7 @@ function deserializeLabelIdentifier(pos) {
     end = deserializeU32(pos + 4);
   return {
     type: "Identifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
     range: [start, end],
@@ -2148,7 +2148,7 @@ function deserializePrivateIdentifier(pos) {
     end = deserializeU32(pos + 4);
   return {
     type: "PrivateIdentifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
     range: [start, end],
@@ -3040,7 +3040,7 @@ function deserializeJSXIdentifier(pos) {
     end = deserializeU32(pos + 4);
   return {
     type: "JSXIdentifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
     range: [start, end],
diff --git a/napi/parser/generated/deserialize/js_range_parent.js b/napi/parser/generated/deserialize/js_range_parent.js
index c9547ede082a3..d9af496427e8c 100644
--- a/napi/parser/generated/deserialize/js_range_parent.js
+++ b/napi/parser/generated/deserialize/js_range_parent.js
@@ -152,7 +152,7 @@ function deserializeIdentifierName(pos) {
     previousParent = parent,
     node = (parent = {
       type: "Identifier",
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       start,
       end,
       range: [start, end],
@@ -168,7 +168,7 @@ function deserializeIdentifierReference(pos) {
     previousParent = parent,
     node = (parent = {
       type: "Identifier",
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       start,
       end,
       range: [start, end],
@@ -184,7 +184,7 @@ function deserializeBindingIdentifier(pos) {
     previousParent = parent,
     node = (parent = {
       type: "Identifier",
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       start,
       end,
       range: [start, end],
@@ -200,7 +200,7 @@ function deserializeLabelIdentifier(pos) {
     previousParent = parent,
     node = (parent = {
       type: "Identifier",
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       start,
       end,
       range: [start, end],
@@ -2380,7 +2380,7 @@ function deserializePrivateIdentifier(pos) {
     end = deserializeU32(pos + 4);
   return {
     type: "PrivateIdentifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
     range: [start, end],
@@ -3364,7 +3364,7 @@ function deserializeJSXIdentifier(pos) {
     end = deserializeU32(pos + 4);
   return {
     type: "JSXIdentifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
     range: [start, end],
diff --git a/napi/parser/generated/deserialize/ts.js b/napi/parser/generated/deserialize/ts.js
index 5e1eda6a9ba7b..86b59f5147bb6 100644
--- a/napi/parser/generated/deserialize/ts.js
+++ b/napi/parser/generated/deserialize/ts.js
@@ -162,7 +162,7 @@ function deserializeIdentifierName(pos) {
     node = {
       type: "Identifier",
       decorators: null,
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       optional: null,
       typeAnnotation: null,
       start,
@@ -179,7 +179,7 @@ function deserializeIdentifierReference(pos) {
     node = {
       type: "Identifier",
       decorators: null,
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       optional: null,
       typeAnnotation: null,
       start,
@@ -196,7 +196,7 @@ function deserializeBindingIdentifier(pos) {
     node = {
       type: "Identifier",
       decorators: null,
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       optional: null,
       typeAnnotation: null,
       start,
@@ -213,7 +213,7 @@ function deserializeLabelIdentifier(pos) {
     node = {
       type: "Identifier",
       decorators: null,
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       optional: null,
       typeAnnotation: null,
       start,
@@ -2150,7 +2150,7 @@ function deserializePrivateIdentifier(pos) {
     end = deserializeU32(pos + 4);
   return {
     type: "PrivateIdentifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
   };
@@ -2985,7 +2985,7 @@ function deserializeJSXIdentifier(pos) {
     end = deserializeU32(pos + 4);
   return {
     type: "JSXIdentifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
   };
diff --git a/napi/parser/generated/deserialize/ts_parent.js b/napi/parser/generated/deserialize/ts_parent.js
index 778184ba59eae..14089bf297639 100644
--- a/napi/parser/generated/deserialize/ts_parent.js
+++ b/napi/parser/generated/deserialize/ts_parent.js
@@ -171,7 +171,7 @@ function deserializeIdentifierName(pos) {
     node = (parent = {
       type: "Identifier",
       decorators: null,
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       optional: null,
       typeAnnotation: null,
       start,
@@ -191,7 +191,7 @@ function deserializeIdentifierReference(pos) {
     node = (parent = {
       type: "Identifier",
       decorators: null,
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       optional: null,
       typeAnnotation: null,
       start,
@@ -211,7 +211,7 @@ function deserializeBindingIdentifier(pos) {
     node = (parent = {
       type: "Identifier",
       decorators: null,
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       optional: null,
       typeAnnotation: null,
       start,
@@ -231,7 +231,7 @@ function deserializeLabelIdentifier(pos) {
     node = (parent = {
       type: "Identifier",
       decorators: null,
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       optional: null,
       typeAnnotation: null,
       start,
@@ -2465,7 +2465,7 @@ function deserializePrivateIdentifier(pos) {
     end = deserializeU32(pos + 4);
   return {
     type: "PrivateIdentifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
     parent,
@@ -3425,7 +3425,7 @@ function deserializeJSXIdentifier(pos) {
     end = deserializeU32(pos + 4);
   return {
     type: "JSXIdentifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
     parent,
diff --git a/napi/parser/generated/deserialize/ts_range.js b/napi/parser/generated/deserialize/ts_range.js
index 1a6083087f5bf..5e6ff5419306a 100644
--- a/napi/parser/generated/deserialize/ts_range.js
+++ b/napi/parser/generated/deserialize/ts_range.js
@@ -163,7 +163,7 @@ function deserializeIdentifierName(pos) {
     node = {
       type: "Identifier",
       decorators: null,
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       optional: null,
       typeAnnotation: null,
       start,
@@ -181,7 +181,7 @@ function deserializeIdentifierReference(pos) {
     node = {
       type: "Identifier",
       decorators: null,
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       optional: null,
       typeAnnotation: null,
       start,
@@ -199,7 +199,7 @@ function deserializeBindingIdentifier(pos) {
     node = {
       type: "Identifier",
       decorators: null,
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       optional: null,
       typeAnnotation: null,
       start,
@@ -217,7 +217,7 @@ function deserializeLabelIdentifier(pos) {
     node = {
       type: "Identifier",
       decorators: null,
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       optional: null,
       typeAnnotation: null,
       start,
@@ -2322,7 +2322,7 @@ function deserializePrivateIdentifier(pos) {
     end = deserializeU32(pos + 4);
   return {
     type: "PrivateIdentifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
     range: [start, end],
@@ -3229,7 +3229,7 @@ function deserializeJSXIdentifier(pos) {
     end = deserializeU32(pos + 4);
   return {
     type: "JSXIdentifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
     range: [start, end],
diff --git a/napi/parser/generated/deserialize/ts_range_parent.js b/napi/parser/generated/deserialize/ts_range_parent.js
index 4f3edd4da410a..d923d052d5b8d 100644
--- a/napi/parser/generated/deserialize/ts_range_parent.js
+++ b/napi/parser/generated/deserialize/ts_range_parent.js
@@ -172,7 +172,7 @@ function deserializeIdentifierName(pos) {
     node = (parent = {
       type: "Identifier",
       decorators: null,
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       optional: null,
       typeAnnotation: null,
       start,
@@ -193,7 +193,7 @@ function deserializeIdentifierReference(pos) {
     node = (parent = {
       type: "Identifier",
       decorators: null,
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       optional: null,
       typeAnnotation: null,
       start,
@@ -214,7 +214,7 @@ function deserializeBindingIdentifier(pos) {
     node = (parent = {
       type: "Identifier",
       decorators: null,
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       optional: null,
       typeAnnotation: null,
       start,
@@ -235,7 +235,7 @@ function deserializeLabelIdentifier(pos) {
     node = (parent = {
       type: "Identifier",
       decorators: null,
-      name: deserializeStr(pos + 8),
+      name: deserializeIdent(pos + 8),
       optional: null,
       typeAnnotation: null,
       start,
@@ -2558,7 +2558,7 @@ function deserializePrivateIdentifier(pos) {
     end = deserializeU32(pos + 4);
   return {
     type: "PrivateIdentifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
     range: [start, end],
@@ -3558,7 +3558,7 @@ function deserializeJSXIdentifier(pos) {
     end = deserializeU32(pos + 4);
   return {
     type: "JSXIdentifier",
-    name: deserializeStr(pos + 8),
+    name: deserializeIdent(pos + 8),
     start,
     end,
     range: [start, end],
diff --git a/napi/parser/generated/lazy/constructors.js b/napi/parser/generated/lazy/constructors.js
index d9dc7c1b75d30..99b9588cef4e0 100644
--- a/napi/parser/generated/lazy/constructors.js
+++ b/napi/parser/generated/lazy/constructors.js
@@ -173,7 +173,7 @@ export class IdentifierName {
     const cached = nodes.get(pos);
     if (cached !== void 0) return cached;
 
-    this.#internal = { pos, ast, $name: void 0 };
+    this.#internal = { pos, ast };
     nodes.set(pos, this);
   }
 
@@ -188,10 +188,8 @@ export class IdentifierName {
   }
 
   get name() {
-    const internal = this.#internal,
-      cached = internal.$name;
-    if (cached !== void 0) return cached;
-    return (internal.$name = constructStr(internal.pos + 8, internal.ast));
+    const internal = this.#internal;
+    return constructIdent(internal.pos + 8, internal.ast);
   }
 
   toJSON() {
@@ -221,7 +219,7 @@ export class IdentifierReference {
     const cached = nodes.get(pos);
     if (cached !== void 0) return cached;
 
-    this.#internal = { pos, ast, $name: void 0 };
+    this.#internal = { pos, ast };
     nodes.set(pos, this);
   }
 
@@ -236,10 +234,8 @@ export class IdentifierReference {
   }
 
   get name() {
-    const internal = this.#internal,
-      cached = internal.$name;
-    if (cached !== void 0) return cached;
-    return (internal.$name = constructStr(internal.pos + 8, internal.ast));
+    const internal = this.#internal;
+    return constructIdent(internal.pos + 8, internal.ast);
   }
 
   toJSON() {
@@ -269,7 +265,7 @@ export class BindingIdentifier {
     const cached = nodes.get(pos);
     if (cached !== void 0) return cached;
 
-    this.#internal = { pos, ast, $name: void 0 };
+    this.#internal = { pos, ast };
     nodes.set(pos, this);
   }
 
@@ -284,10 +280,8 @@ export class BindingIdentifier {
   }
 
   get name() {
-    const internal = this.#internal,
-      cached = internal.$name;
-    if (cached !== void 0) return cached;
-    return (internal.$name = constructStr(internal.pos + 8, internal.ast));
+    const internal = this.#internal;
+    return constructIdent(internal.pos + 8, internal.ast);
   }
 
   toJSON() {
@@ -317,7 +311,7 @@ export class LabelIdentifier {
     const cached = nodes.get(pos);
     if (cached !== void 0) return cached;
 
-    this.#internal = { pos, ast, $name: void 0 };
+    this.#internal = { pos, ast };
     nodes.set(pos, this);
   }
 
@@ -332,10 +326,8 @@ export class LabelIdentifier {
   }
 
   get name() {
-    const internal = this.#internal,
-      cached = internal.$name;
-    if (cached !== void 0) return cached;
-    return (internal.$name = constructStr(internal.pos + 8, internal.ast));
+    const internal = this.#internal;
+    return constructIdent(internal.pos + 8, internal.ast);
   }
 
   toJSON() {
@@ -5266,7 +5258,7 @@ export class PrivateIdentifier {
     const cached = nodes.get(pos);
     if (cached !== void 0) return cached;
 
-    this.#internal = { pos, ast, $name: void 0 };
+    this.#internal = { pos, ast };
     nodes.set(pos, this);
   }
 
@@ -5281,10 +5273,8 @@ export class PrivateIdentifier {
   }
 
   get name() {
-    const internal = this.#internal,
-      cached = internal.$name;
-    if (cached !== void 0) return cached;
-    return (internal.$name = constructStr(internal.pos + 8, internal.ast));
+    const internal = this.#internal;
+    return constructIdent(internal.pos + 8, internal.ast);
   }
 
   toJSON() {
@@ -7464,7 +7454,7 @@ export class JSXIdentifier {
     const cached = nodes.get(pos);
     if (cached !== void 0) return cached;
 
-    this.#internal = { pos, ast, $name: void 0 };
+    this.#internal = { pos, ast };
     nodes.set(pos, this);
   }
 
@@ -7479,10 +7469,8 @@ export class JSXIdentifier {
   }
 
   get name() {
-    const internal = this.#internal,
-      cached = internal.$name;
-    if (cached !== void 0) return cached;
-    return (internal.$name = constructStr(internal.pos + 8, internal.ast));
+    const internal = this.#internal;
+    return constructIdent(internal.pos + 8, internal.ast);
   }
 
   toJSON() {
diff --git a/tasks/ast_tools/src/derives/estree.rs b/tasks/ast_tools/src/derives/estree.rs
index 3199565325d96..6ed0a9ebe0703 100644
--- a/tasks/ast_tools/src/derives/estree.rs
+++ b/tasks/ast_tools/src/derives/estree.rs
@@ -499,6 +499,9 @@ impl<'s> StructSerializerGenerator<'s> {
                 TypeDef::Primitive(primitive_def) => match primitive_def.name() {
                     "&str" => Some(quote!( JsonSafeString(#self_path.#field_name_ident) )),
                     "Atom" => Some(quote!( JsonSafeString(#self_path.#field_name_ident.as_str()) )),
+                    "Ident" => {
+                        Some(quote!( JsonSafeString(#self_path.#field_name_ident.as_str()) ))
+                    }
                     _ => None,
                 },
                 TypeDef::Option(option_def) => option_def
@@ -508,7 +511,7 @@ impl<'s> StructSerializerGenerator<'s> {
                         "&str" => Some(quote! {
                             #self_path.#field_name_ident.map(|s| JsonSafeString(s))
                         }),
-                        "Atom" => Some(quote! {
+                        "Atom" | "Ident" => Some(quote! {
                             #self_path.#field_name_ident.map(|s| JsonSafeString(s.as_str()))
                         }),
                         _ => None,
diff --git a/tasks/ast_tools/src/generators/assert_layouts.rs b/tasks/ast_tools/src/generators/assert_layouts.rs
index 84051a96d120b..b8345c751642d 100644
--- a/tasks/ast_tools/src/generators/assert_layouts.rs
+++ b/tasks/ast_tools/src/generators/assert_layouts.rs
@@ -479,6 +479,7 @@ fn calculate_layout_for_primitive(primitive_def: &PrimitiveDef) -> Layout {
         "f64" => Layout::from_type::<f64>(),
         "&str" => str_layout,
         "Atom" => str_layout,
+        "Ident" => str_layout, // TODO: Double-check this is correct
         "NonZeroU8" => Layout::from_type_with_niche_for_zero::<num::NonZeroU8>(),
         "NonZeroU16" => Layout::from_type_with_niche_for_zero::<num::NonZeroU16>(),
         "NonZeroU32" => Layout::from_type_with_niche_for_zero::<num::NonZeroU32>(),
diff --git a/tasks/ast_tools/src/generators/ast_builder.rs b/tasks/ast_tools/src/generators/ast_builder.rs
index 8ebd29c6ea5b3..66e27f0937b21 100644
--- a/tasks/ast_tools/src/generators/ast_builder.rs
+++ b/tasks/ast_tools/src/generators/ast_builder.rs
@@ -83,6 +83,7 @@ impl Generator for AstBuilderGenerator {
 
             ///@@line_break
             use oxc_allocator::{Allocator, Box, IntoIn, Vec};
+            use oxc_span::Ident;
             use oxc_syntax::{
                 comment_node::CommentNodeId,
                 scope::ScopeId,
diff --git a/tasks/ast_tools/src/generators/formatter/ast_nodes.rs b/tasks/ast_tools/src/generators/formatter/ast_nodes.rs
index 5f05357d0c038..72dc95c3eafa6 100644
--- a/tasks/ast_tools/src/generators/formatter/ast_nodes.rs
+++ b/tasks/ast_tools/src/generators/formatter/ast_nodes.rs
@@ -108,7 +108,7 @@ impl Generator for FormatterAstNodesGenerator {
             ///@@line_break
             use oxc_allocator::Vec;
             use oxc_ast::ast::*;
-            use oxc_span::GetSpan;
+            use oxc_span::{GetSpan, Ident};
             ///@@line_break
             use crate::ast_nodes::AstNode;
             use crate::formatter::{
diff --git a/tasks/ast_tools/src/generators/raw_transfer.rs b/tasks/ast_tools/src/generators/raw_transfer.rs
index 41604d51cc595..21b0370dcc29e 100644
--- a/tasks/ast_tools/src/generators/raw_transfer.rs
+++ b/tasks/ast_tools/src/generators/raw_transfer.rs
@@ -16,7 +16,7 @@ use oxc_ast::{
     },
 };
 use oxc_ast_visit::VisitMut;
-use oxc_span::SPAN;
+use oxc_span::{Ident, SPAN};
 
 use crate::{
     ALLOCATOR_CRATE_PATH, Generator, NAPI_PARSER_PACKAGE_PATH, OXLINT_APP_PATH,
@@ -741,6 +741,7 @@ fn generate_primitive(primitive_def: &PrimitiveDef, code: &mut String, schema: &
     let ret = match primitive_def.name() {
         // Reuse deserializer for `&str`
         "Atom" => return,
+        "Ident" => return,
         // Dummy type
         "PointerAlign" => return,
         "bool" => "return uint8[pos] === 1;",
@@ -1343,8 +1344,8 @@ impl<'a> VisitMut<'a> for LocFieldAdder<'a> {
         let prop = self.ast.object_property_kind_object_property(
             SPAN,
             PropertyKind::Init,
-            self.ast.property_key_static_identifier(SPAN, "__proto__"),
-            self.ast.expression_identifier(SPAN, "NodeProto"),
+            self.ast.property_key_static_identifier(SPAN, Ident::new("__proto__")),
+            self.ast.expression_identifier(SPAN, Ident::new("NodeProto")),
             false,
             false,
             false,
diff --git a/tasks/ast_tools/src/generators/raw_transfer_lazy.rs b/tasks/ast_tools/src/generators/raw_transfer_lazy.rs
index 52afa5f98d276..430c75c3d2de9 100644
--- a/tasks/ast_tools/src/generators/raw_transfer_lazy.rs
+++ b/tasks/ast_tools/src/generators/raw_transfer_lazy.rs
@@ -899,6 +899,7 @@ fn generate_primitive(primitive_def: &PrimitiveDef, state: &mut State, schema: &
     let ret = match primitive_def.name() {
         // Reuse constructor for `&str`
         "Atom" => return,
+        "Ident" => return,
         // Dummy type
         "PointerAlign" => return,
         "bool" => "return ast.buffer[pos] === 1;",
diff --git a/tasks/ast_tools/src/generators/typescript.rs b/tasks/ast_tools/src/generators/typescript.rs
index bf6b2ee99f7e3..de068647d2d5a 100644
--- a/tasks/ast_tools/src/generators/typescript.rs
+++ b/tasks/ast_tools/src/generators/typescript.rs
@@ -401,7 +401,7 @@ fn ts_type_name<'s>(type_def: &'s TypeDef, schema: &'s Schema) -> Cow<'s, str> {
             | "i8" | "i16" | "i32" | "i64" | "i128" | "isize"
             | "f32" | "f64" => "number",
             "bool" => "boolean",
-            "&str" | "Atom" => "string",
+            "&str" | "Atom" | "Ident" => "string",
             name => name,
         }),
         TypeDef::Option(option_def) => {
diff --git a/tasks/ast_tools/src/parse/parse.rs b/tasks/ast_tools/src/parse/parse.rs
index 0e5034f88b13f..ff7dc330fa6f1 100644
--- a/tasks/ast_tools/src/parse/parse.rs
+++ b/tasks/ast_tools/src/parse/parse.rs
@@ -257,6 +257,7 @@ impl<'c> Parser<'c> {
             "AtomicPtr" => primitive("AtomicPtr"),
             "&str" => primitive("&str"),
             "Atom" => primitive("Atom"),
+            "Ident" => primitive("Ident"),
             "NonMaxU32" => primitive("NonMaxU32"),
             // TODO: Remove the need for this by adding
             // `#[cfg_attr(target_pointer_width = "64", repr(align(8)))]` to all AST types
diff --git a/tasks/ast_tools/src/schema/defs/primitive.rs b/tasks/ast_tools/src/schema/defs/primitive.rs
index 0e7c1b64e0894..3cd3077c73123 100644
--- a/tasks/ast_tools/src/schema/defs/primitive.rs
+++ b/tasks/ast_tools/src/schema/defs/primitive.rs
@@ -71,6 +71,13 @@ impl Def for PrimitiveDef {
                     quote!(Atom<'a>)
                 }
             }
+            "Ident" => {
+                if anon {
+                    quote!(Ident<'_>)
+                } else {
+                    quote!(Ident<'a>)
+                }
+            }
             _ => {
                 let ident = self.ident();
                 quote!( #ident )
diff --git a/tasks/coverage/snapshots/semantic_typescript.snap b/tasks/coverage/snapshots/semantic_typescript.snap
index 57e07f8d4231f..9df7175ac64d9 100644
--- a/tasks/coverage/snapshots/semantic_typescript.snap
+++ b/tasks/coverage/snapshots/semantic_typescript.snap
@@ -5706,15 +5706,15 @@ rebuilt        : ScopeId(13): []
 Symbol reference IDs mismatch for "A":
 after transform: SymbolId(12): [ReferenceId(47), ReferenceId(48), ReferenceId(49)]
 rebuilt        : SymbolId(10): [ReferenceId(36), ReferenceId(39)]
+Unresolved reference IDs mismatch for "Set":
+after transform: [ReferenceId(3), ReferenceId(4), ReferenceId(5), ReferenceId(7), ReferenceId(10), ReferenceId(14), ReferenceId(15), ReferenceId(17), ReferenceId(24), ReferenceId(25), ReferenceId(28), ReferenceId(31), ReferenceId(32), ReferenceId(34), ReferenceId(37)]
+rebuilt        : [ReferenceId(2), ReferenceId(5), ReferenceId(10), ReferenceId(19), ReferenceId(23), ReferenceId(26)]
 Unresolved reference IDs mismatch for "Symbol":
 after transform: [ReferenceId(0), ReferenceId(2), ReferenceId(40), ReferenceId(45)]
 rebuilt        : [ReferenceId(30), ReferenceId(34)]
 Unresolved reference IDs mismatch for "Promise":
 after transform: [ReferenceId(1), ReferenceId(20)]
 rebuilt        : [ReferenceId(13)]
-Unresolved reference IDs mismatch for "Set":
-after transform: [ReferenceId(3), ReferenceId(4), ReferenceId(5), ReferenceId(7), ReferenceId(10), ReferenceId(14), ReferenceId(15), ReferenceId(17), ReferenceId(24), ReferenceId(25), ReferenceId(28), ReferenceId(31), ReferenceId(32), ReferenceId(34), ReferenceId(37)]
-rebuilt        : [ReferenceId(2), ReferenceId(5), ReferenceId(10), ReferenceId(19), ReferenceId(23), ReferenceId(26)]
 
 semantic Error: tasks/coverage/typescript/tests/cases/compiler/controlFlowManyConsecutiveConditionsNoTimeout.ts
 Bindings mismatch:
@@ -19432,12 +19432,12 @@ rebuilt        : SymbolId(9): [ReferenceId(30), ReferenceId(39), ReferenceId(40)
 Unresolved references mismatch:
 after transform: ["Boolean", "Number", "Object", "String", "require"]
 rebuilt        : ["Boolean", "Number", "Object", "require"]
-Unresolved reference IDs mismatch for "Boolean":
-after transform: [ReferenceId(22), ReferenceId(23), ReferenceId(28)]
-rebuilt        : [ReferenceId(14)]
 Unresolved reference IDs mismatch for "Object":
 after transform: [ReferenceId(0), ReferenceId(18), ReferenceId(29), ReferenceId(51), ReferenceId(55), ReferenceId(63)]
 rebuilt        : [ReferenceId(9), ReferenceId(19), ReferenceId(42), ReferenceId(47), ReferenceId(57)]
+Unresolved reference IDs mismatch for "Boolean":
+after transform: [ReferenceId(22), ReferenceId(23), ReferenceId(28)]
+rebuilt        : [ReferenceId(14)]
 
 semantic Error: tasks/coverage/typescript/tests/cases/compiler/metadataOfUnionWithNull.ts
 Symbol reference IDs mismatch for "A":
@@ -29159,21 +29159,21 @@ after transform: ScopeId(0): [ScopeId(1), ScopeId(3)]
 rebuilt        : ScopeId(0): [ScopeId(1)]
 
 semantic Error: tasks/coverage/typescript/tests/cases/compiler/typeGuardConstructorPrimitiveTypes.ts
-Unresolved reference IDs mismatch for "BigInt":
-after transform: [ReferenceId(16), ReferenceId(22), ReferenceId(36)]
-rebuilt        : [ReferenceId(16), ReferenceId(31)]
-Unresolved reference IDs mismatch for "Number":
-after transform: [ReferenceId(4), ReferenceId(19), ReferenceId(27)]
-rebuilt        : [ReferenceId(4), ReferenceId(22)]
 Unresolved reference IDs mismatch for "String":
 after transform: [ReferenceId(1), ReferenceId(18), ReferenceId(24)]
 rebuilt        : [ReferenceId(1), ReferenceId(19)]
+Unresolved reference IDs mismatch for "Number":
+after transform: [ReferenceId(4), ReferenceId(19), ReferenceId(27)]
+rebuilt        : [ReferenceId(4), ReferenceId(22)]
 Unresolved reference IDs mismatch for "Symbol":
 after transform: [ReferenceId(13), ReferenceId(21), ReferenceId(33)]
 rebuilt        : [ReferenceId(13), ReferenceId(28)]
 Unresolved reference IDs mismatch for "Boolean":
 after transform: [ReferenceId(7), ReferenceId(20), ReferenceId(30)]
 rebuilt        : [ReferenceId(7), ReferenceId(25)]
+Unresolved reference IDs mismatch for "BigInt":
+after transform: [ReferenceId(16), ReferenceId(22), ReferenceId(36)]
+rebuilt        : [ReferenceId(16), ReferenceId(31)]
 
 semantic Error: tasks/coverage/typescript/tests/cases/compiler/typeGuardNarrowByMutableUntypedField.ts
 Bindings mismatch:
@@ -30427,12 +30427,12 @@ semantic Error: tasks/coverage/typescript/tests/cases/compiler/unionWithIndexSig
 Scope children mismatch:
 after transform: ScopeId(0): [ScopeId(1), ScopeId(2), ScopeId(3), ScopeId(4), ScopeId(5), ScopeId(6)]
 rebuilt        : ScopeId(0): [ScopeId(1), ScopeId(2), ScopeId(3)]
-Unresolved reference IDs mismatch for "Int32Array":
-after transform: [ReferenceId(6), ReferenceId(8), ReferenceId(11)]
-rebuilt        : [ReferenceId(2)]
 Unresolved reference IDs mismatch for "Uint8Array":
 after transform: [ReferenceId(7), ReferenceId(9), ReferenceId(13)]
 rebuilt        : [ReferenceId(4)]
+Unresolved reference IDs mismatch for "Int32Array":
+after transform: [ReferenceId(6), ReferenceId(8), ReferenceId(11)]
+rebuilt        : [ReferenceId(2)]
 
 semantic Error: tasks/coverage/typescript/tests/cases/compiler/uniqueSymbolAssignmentOnGlobalAugmentationSuceeds.ts
 Scope children mismatch:
@@ -30671,15 +30671,9 @@ rebuilt        : [ReferenceId(8)]
 Unresolved reference IDs mismatch for "Int8Array":
 after transform: [ReferenceId(0), ReferenceId(1)]
 rebuilt        : [ReferenceId(0)]
-Unresolved reference IDs mismatch for "Float32Array":
-after transform: [ReferenceId(12), ReferenceId(13)]
-rebuilt        : [ReferenceId(6)]
 Unresolved reference IDs mismatch for "Uint8Array":
 after transform: [ReferenceId(2), ReferenceId(3)]
 rebuilt        : [ReferenceId(1)]
-Unresolved reference IDs mismatch for "Int16Array":
-after transform: [ReferenceId(4), ReferenceId(5)]
-rebuilt        : [ReferenceId(2)]
 Unresolved reference IDs mismatch for "Float64Array":
 after transform: [ReferenceId(14), ReferenceId(15)]
 rebuilt        : [ReferenceId(7)]
@@ -30689,6 +30683,12 @@ rebuilt        : [ReferenceId(9)]
 Unresolved reference IDs mismatch for "Int32Array":
 after transform: [ReferenceId(8), ReferenceId(9)]
 rebuilt        : [ReferenceId(4)]
+Unresolved reference IDs mismatch for "Float32Array":
+after transform: [ReferenceId(12), ReferenceId(13)]
+rebuilt        : [ReferenceId(6)]
+Unresolved reference IDs mismatch for "Int16Array":
+after transform: [ReferenceId(4), ReferenceId(5)]
+rebuilt        : [ReferenceId(2)]
 Unresolved reference IDs mismatch for "Uint32Array":
 after transform: [ReferenceId(10), ReferenceId(11)]
 rebuilt        : [ReferenceId(5)]
@@ -33417,15 +33417,15 @@ semantic Error: tasks/coverage/typescript/tests/cases/conformance/classes/proper
 Symbol reference IDs mismatch for "C1":
 after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(12)]
 rebuilt        : SymbolId(3): [ReferenceId(7)]
-Reference symbol mismatch for "":
+Reference symbol mismatch for "x":
 after transform: SymbolId(0) "C1"
 rebuilt        : <None>
-Reference symbol mismatch for "":
+Reference symbol mismatch for "x":
 after transform: SymbolId(0) "C1"
 rebuilt        : <None>
 Unresolved references mismatch:
 after transform: ["require"]
-rebuilt        : ["", "require"]
+rebuilt        : ["require", "x"]
 
 semantic Error: tasks/coverage/typescript/tests/cases/conformance/classes/propertyMemberDeclarations/autoAccessor8.ts
 Bindings mismatch:
@@ -38189,10 +38189,10 @@ rebuilt        : <None>
 Reference symbol mismatch for "D":
 after transform: SymbolId(7) "D"
 rebuilt        : SymbolId(5) "D"
-Reference symbol mismatch for "":
+Reference symbol mismatch for "x":
 after transform: SymbolId(0) "dec"
 rebuilt        : <None>
-Reference symbol mismatch for "":
+Reference symbol mismatch for "x":
 after transform: SymbolId(0) "dec"
 rebuilt        : <None>
 Reference symbol mismatch for "dec":
@@ -38200,7 +38200,7 @@ after transform: SymbolId(0) "dec"
 rebuilt        : <None>
 Unresolved references mismatch:
 after transform: ["Object", "require"]
-rebuilt        : ["", "Object", "dec", "require"]
+rebuilt        : ["Object", "dec", "require", "x"]
 
 semantic Error: tasks/coverage/typescript/tests/cases/conformance/esDecorators/classDeclaration/methods/esDecorators-classDeclaration-methods-nonStatic.ts
 Bindings mismatch:
diff --git a/tasks/coverage/snapshots/transformer_typescript.snap b/tasks/coverage/snapshots/transformer_typescript.snap
index f3d1c1e11ccd9..af1390101cd77 100644
--- a/tasks/coverage/snapshots/transformer_typescript.snap
+++ b/tasks/coverage/snapshots/transformer_typescript.snap
@@ -2,8 +2,4 @@ commit: 669c25c0
 
 transformer_typescript Summary:
 AST Parsed     : 9822/9822 (100.00%)
-Positive Passed: 9820/9822 (99.98%)
-Mismatch: tasks/coverage/typescript/tests/cases/conformance/classes/propertyMemberDeclarations/autoAccessor2.ts
-
-Mismatch: tasks/coverage/typescript/tests/cases/conformance/esDecorators/classDeclaration/fields/esDecorators-classDeclaration-fields-staticPrivateAccessor.ts
-
+Positive Passed: 9822/9822 (100.00%)
diff --git a/tasks/rulegen/src/main.rs b/tasks/rulegen/src/main.rs
index 0d9b35e320c15..3219ba2de8a17 100644
--- a/tasks/rulegen/src/main.rs
+++ b/tasks/rulegen/src/main.rs
@@ -1022,7 +1022,7 @@ impl<'a> RuleConfig<'a> {
                 self.log_error(&String::from("Cannot find next element"));
                 continue;
             };
-            properties.insert(identifier.name.into(), element);
+            properties.insert(identifier.name.as_str().to_string(), element);
         }
         properties
     }
diff --git a/tasks/transform_checker/src/lib.rs b/tasks/transform_checker/src/lib.rs
index 2a8797d7d7e4b..e402d59786a46 100644
--- a/tasks/transform_checker/src/lib.rs
+++ b/tasks/transform_checker/src/lib.rs
@@ -99,7 +99,7 @@ use oxc_ast::ast::*;
 use oxc_ast_visit::{Visit, walk};
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_semantic::{Scoping, SemanticBuilder};
-use oxc_span::CompactStr;
+use oxc_span::{CompactStr, Ident};
 use oxc_syntax::{
     reference::ReferenceId,
     scope::{ScopeFlags, ScopeId},
@@ -180,7 +180,7 @@ struct PostTransformChecker<'a, 's> {
     scope_ids_map: IdMapping<ScopeId>,
     symbol_ids_map: IdMapping<SymbolId>,
     reference_ids_map: IdMapping<ReferenceId>,
-    reference_names: Vec<Atom<'a>>,
+    reference_names: Vec<Ident<'a>>,
     errors: Errors,
 }
 
@@ -612,7 +612,7 @@ struct SemanticIdsCollector<'a, 'e> {
     scope_ids: Vec<Option<ScopeId>>,
     symbol_ids: Vec<Option<SymbolId>>,
     reference_ids: Vec<Option<ReferenceId>>,
-    reference_names: Vec<Atom<'a>>,
+    reference_names: Vec<Ident<'a>>,
     errors: &'e mut Errors,
 }
 
@@ -632,7 +632,7 @@ impl<'a, 'e> SemanticIdsCollector<'a, 'e> {
     fn collect(
         mut self,
         program: &Program<'a>,
-    ) -> (Vec<Option<ScopeId>>, Vec<Option<SymbolId>>, Vec<Option<ReferenceId>>, Vec<Atom<'a>>)
+    ) -> (Vec<Option<ScopeId>>, Vec<Option<SymbolId>>, Vec<Option<ReferenceId>>, Vec<Ident<'a>>)
     {
         if !program.source_type.is_typescript_definition() {
             self.visit_program(program);