feat: introduce rolldown_rstr

Part of #427.

.vscode/settings.json

@@ -36,6 +36,7 @@
     "repr",
     "rolldown",
     "rollup",
+    "Rstr",
     "rustc",
     "smallvec",
     "treeshake"

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members  = ["./crates/*"]
+members  = ["./crates/*", "crates/rolldown_rstr"]
 resolver = "2"
 
 [workspace.package]

crates/rolldown/Cargo.toml

@@ -18,10 +18,11 @@ rolldown_tracing   = { path = "../rolldown_tracing" }
 rolldown_utils     = { path = "../rolldown_utils" }
 rolldown_resolver  = { path = "../rolldown_resolver" }
 rolldown_error     = { path = "../rolldown_error" }
-rolldown_oxc_utils       = { path = "../rolldown_oxc_utils" }
+rolldown_oxc_utils = { path = "../rolldown_oxc_utils" }
 rolldown_fs        = { path = "../rolldown_fs" }
 rolldown_sourcemap = { path = "../rolldown_sourcemap" }
 rolldown_plugin    = { path = "../rolldown_plugin" }
+rolldown_rstr      = { path = "../rolldown_rstr" }
 derivative         = { workspace = true }
 sugar_path         = { workspace = true }
 oxc                = { workspace = true }

crates/rolldown/src/ast_scanner/mod.rs

@@ -20,6 +20,7 @@ use rolldown_common::{
 };
 use rolldown_error::BuildError;
 use rolldown_oxc_utils::{BindingIdentifierExt, BindingPatternExt};
+use rolldown_rstr::{Rstr, ToRstr};
 use rustc_hash::FxHashMap;
 use std::sync::Arc;
 
@@ -29,7 +30,7 @@ use super::types::ast_symbols::AstSymbols;
 pub struct ScanResult {
   pub repr_name: String,
   pub named_imports: FxHashMap<SymbolId, NamedImport>,
-  pub named_exports: FxHashMap<Atom, LocalExport>,
+  pub named_exports: FxHashMap<Rstr, LocalExport>,
   pub stmt_infos: StmtInfos,
   pub import_records: IndexVec<ImportRecordId, RawImportRecord>,
   pub star_exports: Vec<ImportRecordId>,
@@ -149,7 +150,7 @@ impl<'ast> AstScanner<'ast> {
     let namespace_ref: SymbolRef =
       (self.idx, self.symbol_table.create_symbol(Atom::new_inline(""), self.scope.root_scope_id()))
         .into();
-    let rec = RawImportRecord::new(module_request.clone(), kind, namespace_ref);
+    let rec = RawImportRecord::new(module_request.to_rstr(), kind, namespace_ref);
 
     let id = self.result.import_records.push(rec);
     self.current_stmt_info.import_records.push(id);
@@ -160,7 +161,7 @@ impl<'ast> AstScanner<'ast> {
     self.result.named_imports.insert(
       local,
       NamedImport {
-        imported: imported.clone().into(),
+        imported: imported.to_rstr().into(),
         imported_as: (self.idx, local).into(),
         record_id,
       },
@@ -178,14 +179,14 @@ impl<'ast> AstScanner<'ast> {
     self
       .result
       .named_exports
-      .insert(export_name.clone(), LocalExport { referenced: (self.idx, local).into() });
+      .insert(export_name.to_rstr(), LocalExport { referenced: (self.idx, local).into() });
   }
 
   fn add_local_default_export(&mut self, local: SymbolId) {
     self
       .result
       .named_exports
-      .insert(Atom::new_inline("default"), LocalExport { referenced: (self.idx, local).into() });
+      .insert("default".into(), LocalExport { referenced: (self.idx, local).into() });
   }
 
   fn add_re_export(&mut self, export_name: &Atom, imported: &Atom, record_id: ImportRecordId) {
@@ -205,7 +206,7 @@ impl<'ast> AstScanner<'ast> {
       .into();
     self.current_stmt_info.declared_symbols.push(generated_imported_as_ref);
     let name_import = NamedImport {
-      imported: imported.clone().into(),
+      imported: imported.to_rstr().into(),
       imported_as: generated_imported_as_ref,
       record_id,
     };
@@ -216,7 +217,7 @@ impl<'ast> AstScanner<'ast> {
     self
       .result
       .named_exports
-      .insert(export_name.clone(), LocalExport { referenced: generated_imported_as_ref });
+      .insert(export_name.to_rstr(), LocalExport { referenced: generated_imported_as_ref });
   }
 
   fn add_star_re_export(&mut self, export_name: &Atom, record_id: ImportRecordId) {
@@ -231,7 +232,7 @@ impl<'ast> AstScanner<'ast> {
     self
       .result
       .named_exports
-      .insert(export_name.clone(), LocalExport { referenced: generated_imported_as_ref });
+      .insert(export_name.to_rstr(), LocalExport { referenced: generated_imported_as_ref });
   }
 
   fn scan_export_all_decl(&mut self, decl: &ExportAllDeclaration) {
@@ -263,7 +264,7 @@ impl<'ast> AstScanner<'ast> {
             var_decl.declarations.iter().for_each(|decl| {
               decl.id.binding_identifiers().into_iter().for_each(|id| {
                 self.result.named_exports.insert(
-                  id.name.clone(),
+                  id.name.to_rstr(),
                   LocalExport { referenced: (self.idx, id.expect_symbol_id()).into() },
                 );
               });

crates/rolldown/src/chunk/chunk.rs

@@ -1,8 +1,8 @@
-use oxc::span::Atom;
 use rolldown_common::{
   ExternalModuleId, NamedImport, NormalModuleId, RenderedModule, Specifier, SymbolRef,
 };
 use rolldown_error::BuildError;
+use rolldown_rstr::Rstr;
 use rolldown_sourcemap::{collapse_sourcemaps, concat_sourcemaps, SourceMap};
 use rustc_hash::FxHashMap;
 
@@ -44,12 +44,12 @@ pub struct Chunk {
   pub modules: Vec<NormalModuleId>,
   pub name: Option<String>,
   pub file_name: Option<String>,
-  pub canonical_names: FxHashMap<SymbolRef, Atom>,
+  pub canonical_names: FxHashMap<SymbolRef, Rstr>,
   pub bits: BitSet,
   pub imports_from_other_chunks: FxHashMap<ChunkId, Vec<CrossChunkImportItem>>,
   pub imports_from_external_modules: FxHashMap<ExternalModuleId, Vec<NamedImport>>,
   // meaningless if the chunk is an entrypoint
-  pub exports_to_other_chunks: FxHashMap<SymbolRef, Atom>,
+  pub exports_to_other_chunks: FxHashMap<SymbolRef, Rstr>,
 }
 
 impl Chunk {

crates/rolldown/src/chunk/de_conflict.rs

@@ -1,5 +1,7 @@
 use std::borrow::Cow;
 
+use rolldown_rstr::ToRstr;
+
 use super::chunk::Chunk;
 use crate::{stages::link_stage::LinkStageOutput, utils::renamer::Renamer};
 
@@ -17,7 +19,7 @@ impl Chunk {
       .flat_map(|m| m.scope.root_unresolved_references().keys().map(Cow::Borrowed))
       .for_each(|name| {
         // global names should be reserved
-        renamer.reserve(name);
+        renamer.reserve(Cow::Owned(name.to_rstr()));
       });
 
     self.imports_from_other_chunks.iter().flat_map(|(_, items)| items.iter()).for_each(|item| {

crates/rolldown/src/chunk/render_chunk_exports.rs

@@ -1,5 +1,5 @@
-use oxc::span::Atom;
 use rolldown_common::{SymbolRef, WrapKind};
+use rolldown_rstr::Rstr;
 use string_wizard::MagicString;
 
 use crate::{stages::link_stage::LinkStageOutput, OutputFormat, OutputOptions};
@@ -62,7 +62,7 @@ impl Chunk {
     Some(s)
   }
 
-  fn get_export_items(&self, graph: &LinkStageOutput) -> Vec<(Atom, SymbolRef)> {
+  fn get_export_items(&self, graph: &LinkStageOutput) -> Vec<(Rstr, SymbolRef)> {
     match self.kind {
       ChunkKind::EntryPoint { module, .. } => {
         let meta = &graph.metas[module];

crates/rolldown/src/finalizer/finalizer_context.rs

@@ -1,6 +1,6 @@
-use oxc::span::Atom;
 use rolldown_common::{NormalModule, NormalModuleId, SymbolRef};
 
+use rolldown_rstr::Rstr;
 use rustc_hash::FxHashMap;
 
 use crate::{
@@ -20,7 +20,7 @@ pub struct FinalizerContext<'me> {
   pub linking_info: &'me LinkingMetadata,
   pub linking_infos: &'me LinkingMetadataVec,
   pub symbols: &'me Symbols,
-  pub canonical_names: &'me FxHashMap<SymbolRef, Atom>,
+  pub canonical_names: &'me FxHashMap<SymbolRef, Rstr>,
   pub runtime: &'me RuntimeModuleBrief,
   pub chunk_graph: &'me ChunkGraph,
 }

crates/rolldown/src/finalizer/impl_visit_mut_for_finalizer.rs

@@ -62,7 +62,7 @@ impl<'ast, 'me: 'ast> VisitMut<'ast> for Finalizer<'me, 'ast> {
             if matches!(importee_linking_info.wrap_kind, WrapKind::Esm) {
               let wrapper_ref_name =
                 self.canonical_name_for(importee_linking_info.wrapper_ref.unwrap());
-              program.body.push(self.snippet.call_expr_stmt(wrapper_ref_name.clone()));
+              program.body.push(self.snippet.call_expr_stmt(wrapper_ref_name.to_oxc_atom()));
             }
 
             match importee.exports_kind {
@@ -77,9 +77,9 @@ impl<'ast, 'me: 'ast> VisitMut<'ast> for Finalizer<'me, 'ast> {
                     self
                       .snippet
                       .call_expr_with_2arg_expr(
-                        re_export_fn_name.clone(),
-                        importer_namespace_name.clone(),
-                        importee_namespace_name.clone(),
+                        re_export_fn_name.to_oxc_atom(),
+                        importer_namespace_name.to_oxc_atom(),
+                        importee_namespace_name.to_oxc_atom(),
                       )
                       .into_in(self.alloc),
                   );
@@ -97,11 +97,11 @@ impl<'ast, 'me: 'ast> VisitMut<'ast> for Finalizer<'me, 'ast> {
                   self
                     .snippet
                     .call_expr_with_2arg_expr_expr(
-                      re_export_fn_name.clone(),
-                      self.snippet.id_ref_expr(importer_namespace_name.clone()),
+                      re_export_fn_name.to_oxc_atom(),
+                      self.snippet.id_ref_expr(importer_namespace_name.to_oxc_atom()),
                       self.snippet.call_expr_with_arg_expr_expr(
-                        to_esm_fn_name.clone(),
-                        self.snippet.call_expr_expr(importee_wrapper_ref_name.clone()),
+                        to_esm_fn_name.to_oxc_atom(),
+                        self.snippet.call_expr_expr(importee_wrapper_ref_name.to_oxc_atom()),
                       ),
                     )
                     .into_in(self.alloc),
@@ -118,7 +118,7 @@ impl<'ast, 'me: 'ast> VisitMut<'ast> for Finalizer<'me, 'ast> {
               let canonical_name_for_default_export_ref =
                 self.canonical_name_for(self.ctx.module.default_export_ref);
               top_stmt = self.snippet.var_decl_stmt(
-                canonical_name_for_default_export_ref.clone(),
+                canonical_name_for_default_export_ref.to_oxc_atom(),
                 expr.take_in(self.alloc),
               );
             }
@@ -128,7 +128,8 @@ impl<'ast, 'me: 'ast> VisitMut<'ast> for Finalizer<'me, 'ast> {
               if func.id.is_none() {
                 let canonical_name_for_default_export_ref =
                   self.canonical_name_for(self.ctx.module.default_export_ref);
-                func.id = Some(self.snippet.id(canonical_name_for_default_export_ref.clone()));
+                func.id =
+                  Some(self.snippet.id(canonical_name_for_default_export_ref.to_oxc_atom()));
               }
               top_stmt = ast::Statement::Declaration(ast::Declaration::FunctionDeclaration(
                 func.take_in(self.alloc),
@@ -140,7 +141,8 @@ impl<'ast, 'me: 'ast> VisitMut<'ast> for Finalizer<'me, 'ast> {
               if class.id.is_none() {
                 let canonical_name_for_default_export_ref =
                   self.canonical_name_for(self.ctx.module.default_export_ref);
-                class.id = Some(self.snippet.id(canonical_name_for_default_export_ref.clone()));
+                class.id =
+                  Some(self.snippet.id(canonical_name_for_default_export_ref.to_oxc_atom()));
               }
               top_stmt = ast::Statement::Declaration(ast::Declaration::ClassDeclaration(
                 class.take_in(self.alloc),
@@ -197,8 +199,8 @@ impl<'ast, 'me: 'ast> VisitMut<'ast> for Finalizer<'me, 'ast> {
           let old_body = program.body.take_in(self.alloc);
 
           program.body.push(self.snippet.commonjs_wrapper_stmt(
-            wrap_ref_name.clone(),
-            commonjs_ref_name.clone(),
+            wrap_ref_name.to_oxc_atom(),
+            commonjs_ref_name.to_oxc_atom(),
             old_body,
           ));
         }
@@ -258,8 +260,8 @@ impl<'ast, 'me: 'ast> VisitMut<'ast> for Finalizer<'me, 'ast> {
             )));
           }
           program.body.push(self.snippet.esm_wrapper_stmt(
-            wrap_ref_name.clone(),
-            esm_ref_name.clone(),
+            wrap_ref_name.to_oxc_atom(),
+            esm_ref_name.to_oxc_atom(),
             stmts_inside_closure,
           ));
         }
@@ -276,8 +278,8 @@ impl<'ast, 'me: 'ast> VisitMut<'ast> for Finalizer<'me, 'ast> {
       let symbol = self.ctx.symbols.get(canonical_ref);
       assert!(symbol.namespace_alias.is_none());
       let canonical_name = self.canonical_name_for(symbol_ref);
-      if ident.name != canonical_name {
-        ident.name = canonical_name.clone();
+      if ident.name != canonical_name.as_str() {
+        ident.name = canonical_name.to_oxc_atom();
       }
       ident.symbol_id.get_mut().take();
     } else {
@@ -321,13 +323,16 @@ impl<'ast, 'me: 'ast> VisitMut<'ast> for Finalizer<'me, 'ast> {
             let importee_linking_info = &self.ctx.linking_infos[importee.id];
             let wrap_ref_name = self.canonical_name_for(importee_linking_info.wrapper_ref.unwrap());
             if matches!(importee.exports_kind, ExportsKind::CommonJs) {
-              *expr = self.snippet.call_expr_expr(wrap_ref_name.clone());
+              *expr = self.snippet.call_expr_expr(wrap_ref_name.to_oxc_atom());
             } else {
               let ns_name = self.canonical_name_for(importee.namespace_symbol);
               let to_commonjs_ref_name = self.canonical_name_for_runtime("__toCommonJS");
               *expr = self.snippet.seq2_in_paren_expr(
-                self.snippet.call_expr_expr(wrap_ref_name.clone()),
-                self.snippet.call_expr_with_arg_expr(to_commonjs_ref_name.clone(), ns_name.clone()),
+                self.snippet.call_expr_expr(wrap_ref_name.to_oxc_atom()),
+                self.snippet.call_expr_with_arg_expr(
+                  to_commonjs_ref_name.to_oxc_atom(),
+                  ns_name.to_oxc_atom(),
+                ),
               );
             }
           }
@@ -371,8 +376,8 @@ impl<'ast, 'me: 'ast> VisitMut<'ast> for Finalizer<'me, 'ast> {
         ast::BindingPatternKind::BindingIdentifier(ident) if prop.shorthand => {
           if let Some(symbol_id) = ident.symbol_id.get() {
             let canonical_name = self.canonical_name_for((self.ctx.id, symbol_id).into());
-            if ident.name != canonical_name {
-              ident.name = canonical_name.clone();
+            if ident.name != canonical_name.as_str() {
+              ident.name = canonical_name.to_oxc_atom();
               prop.shorthand = false;
             }
             ident.symbol_id.get_mut().take();
@@ -389,8 +394,8 @@ impl<'ast, 'me: 'ast> VisitMut<'ast> for Finalizer<'me, 'ast> {
           };
           if let Some(symbol_id) = ident.symbol_id.get() {
             let canonical_name = self.canonical_name_for((self.ctx.id, symbol_id).into());
-            if ident.name != canonical_name {
-              ident.name = canonical_name.clone();
+            if ident.name != canonical_name.as_str() {
+              ident.name = canonical_name.to_oxc_atom();
               prop.shorthand = false;
             }
             ident.symbol_id.get_mut().take();