refactor(codegen)!: change to CodegenReturn::code and CodegenReturn::map (#6310)

crates/oxc/src/compiler.rs

@@ -27,7 +27,7 @@ impl CompilerInterface for Compiler {
     }
 
     fn after_codegen(&mut self, ret: CodegenReturn) {
-        self.printed = ret.source_text;
+        self.printed = ret.code;
     }
 }
 

crates/oxc_codegen/examples/codegen.rs

@@ -68,5 +68,5 @@ fn codegen(source_text: &str, ret: &ParserReturn<'_>, minify: bool) -> String {
         )
         .with_options(CodegenOptions { minify, ..CodegenOptions::default() })
         .build(&ret.program)
-        .source_text
+        .code
 }

crates/oxc_codegen/examples/sourcemap.rs

@@ -27,19 +27,14 @@ fn main() -> std::io::Result<()> {
         return Ok(());
     }
 
-    let CodegenReturn { source_text, source_map } = CodeGenerator::new()
+    let CodegenReturn { code, map } = CodeGenerator::new()
         .enable_source_map(path.to_string_lossy().as_ref(), &source_text)
         .build(&ret.program);
 
-    if let Some(source_map) = source_map {
+    if let Some(source_map) = map {
         let result = source_map.to_json_string();
-        let hash = BASE64_STANDARD.encode(format!(
-            "{}\0{}{}\0{}",
-            source_text.len(),
-            source_text,
-            result.len(),
-            result
-        ));
+        let hash =
+            BASE64_STANDARD.encode(format!("{}\0{}{}\0{}", code.len(), code, result.len(), result));
         println!("https://evanw.github.io/source-map-visualization/#{hash}");
     }
 

crates/oxc_codegen/src/lib.rs

@@ -58,11 +58,11 @@ pub struct CommentOptions {
 /// Output from [`Codegen::build`]
 pub struct CodegenReturn {
     /// The generated source code.
-    pub source_text: String,
+    pub code: String,
     /// The source map from the input source code to the generated source code.
     ///
     /// You must use [`Codegen::enable_source_map`] for this to be [`Some`].
-    pub source_map: Option<oxc_sourcemap::SourceMap>,
+    pub map: Option<oxc_sourcemap::SourceMap>,
 }
 
 pub struct Codegen<'a> {
@@ -228,9 +228,9 @@ impl<'a> Codegen<'a> {
     #[must_use]
     pub fn build(mut self, program: &Program<'_>) -> CodegenReturn {
         program.print(&mut self, Context::default());
-        let source_text = self.into_source_text();
-        let source_map = self.sourcemap_builder.map(SourcemapBuilder::into_sourcemap);
-        CodegenReturn { source_text, source_map }
+        let code = self.into_source_text();
+        let map = self.sourcemap_builder.map(SourcemapBuilder::into_sourcemap);
+        CodegenReturn { code, map }
     }
 
     #[must_use]

crates/oxc_codegen/tests/integration/main.rs

@@ -23,7 +23,7 @@ pub fn codegen(source_text: &str) -> String {
             CommentOptions { preserve_annotate_comments: true },
         )
         .build(&ret.program)
-        .source_text
+        .code
 }
 
 pub fn snapshot(name: &str, cases: &[&str]) {

crates/oxc_codegen/tests/integration/tester.rs

@@ -14,7 +14,7 @@ pub fn test(source_text: &str, expected: &str) {
             CommentOptions { preserve_annotate_comments: true },
         )
         .build(&ret.program)
-        .source_text;
+        .code;
     assert_eq!(result, expected, "\nfor source: {source_text:?}");
 }
 
@@ -22,7 +22,7 @@ pub fn test_without_source(source_text: &str, expected: &str) {
     let source_type = SourceType::jsx();
     let allocator = Allocator::default();
     let ret = Parser::new(&allocator, source_text, source_type).parse();
-    let result = CodeGenerator::new().build(&ret.program).source_text;
+    let result = CodeGenerator::new().build(&ret.program).code;
     assert_eq!(result, expected, "\nfor source: {source_text:?}");
 }
 
@@ -33,6 +33,6 @@ pub fn test_minify(source_text: &str, expected: &str) {
     let result = CodeGenerator::new()
         .with_options(CodegenOptions { minify: true, ..CodegenOptions::default() })
         .build(&ret.program)
-        .source_text;
+        .code;
     assert_eq!(result, expected, "\nfor minify source: {source_text}");
 }

crates/oxc_isolated_declarations/examples/isolated_declarations.rs

@@ -46,7 +46,7 @@ fn main() {
             CommentOptions { preserve_annotate_comments: false },
         )
         .build(&id_ret.program)
-        .source_text;
+        .code;
 
     println!("Dts Emit:\n");
     println!("{printed}\n");

crates/oxc_isolated_declarations/tests/deno/mod.rs

@@ -20,9 +20,9 @@ mod tests {
             IsolatedDeclarationsOptions { strip_internal: true },
         )
         .build(&ret.program);
-        let actual = CodeGenerator::new().build(&ret.program).source_text;
+        let actual = CodeGenerator::new().build(&ret.program).code;
         let expected_program = Parser::new(&allocator, expected, source_type).parse().program;
-        let expected = CodeGenerator::new().build(&expected_program).source_text;
+        let expected = CodeGenerator::new().build(&expected_program).code;
         assert_eq!(actual.trim(), expected.trim());
     }
 

crates/oxc_isolated_declarations/tests/mod.rs

@@ -27,7 +27,7 @@ fn transform(path: &Path, source_text: &str) -> String {
             CommentOptions { preserve_annotate_comments: false },
         )
         .build(&id_ret.program)
-        .source_text;
+        .code;
 
     let mut snapshot =
         format!("```\n==================== .D.TS ====================\n\n{code}\n\n");

crates/oxc_minifier/examples/mangler.rs

@@ -40,5 +40,5 @@ fn mangler(source_text: &str, source_type: SourceType, debug: bool) -> String {
     let ret = Parser::new(&allocator, source_text, source_type).parse();
     let program = allocator.alloc(ret.program);
     let mangler = Mangler::new().with_options(MangleOptions { debug }).build(program);
-    CodeGenerator::new().with_mangler(Some(mangler)).build(program).source_text
+    CodeGenerator::new().with_mangler(Some(mangler)).build(program).code
 }

crates/oxc_minifier/examples/minifier.rs

@@ -47,5 +47,5 @@ fn minify(
     let mut program = ret.program;
     let options = MinifierOptions { mangle, compress: CompressOptions::default() };
     let ret = Minifier::new(options).build(allocator, &mut program);
-    CodeGenerator::new().with_mangler(ret.mangler).build(&program).source_text
+    CodeGenerator::new().with_mangler(ret.mangler).build(&program).code
 }

crates/oxc_minifier/src/tester.rs

@@ -37,5 +37,5 @@ fn run<'a, P: CompressorPass<'a>>(
     CodeGenerator::new()
         .with_options(CodegenOptions { single_quote: true, ..CodegenOptions::default() })
         .build(&program)
-        .source_text
+        .code
 }

crates/oxc_minifier/tests/mangler/mod.rs

@@ -12,7 +12,7 @@ fn mangle(source_text: &str) -> String {
     let ret = Parser::new(&allocator, source_text, source_type).parse();
     let program = ret.program;
     let mangler = Mangler::new().build(&program);
-    CodeGenerator::new().with_mangler(Some(mangler)).build(&program).source_text
+    CodeGenerator::new().with_mangler(Some(mangler)).build(&program).code
 }
 
 #[test]

crates/oxc_minifier/tests/mod.rs

@@ -24,5 +24,5 @@ fn run(source_text: &str, source_type: SourceType, options: Option<CompressOptio
     CodeGenerator::new()
         .with_options(CodegenOptions { single_quote: true, ..CodegenOptions::default() })
         .build(program)
-        .source_text
+        .code
 }

crates/oxc_transformer/examples/transformer.rs

@@ -76,7 +76,7 @@ fn main() {
         }
     }
 
-    let printed = CodeGenerator::new().build(&program).source_text;
+    let printed = CodeGenerator::new().build(&program).code;
     println!("Transformed:\n");
     println!("{printed}");
 }

crates/oxc_transformer/tests/plugins/inject_global_variables.rs

@@ -24,7 +24,7 @@ pub(crate) fn test(source_text: &str, expected: &str, config: InjectGlobalVariab
     let result = CodeGenerator::new()
         .with_options(CodegenOptions { single_quote: true, ..CodegenOptions::default() })
         .build(program)
-        .source_text;
+        .code;
     let expected = run(expected, source_type);
     assert_eq!(result, expected, "for source {source_text}");
 }

crates/oxc_transformer/tests/plugins/mod.rs

@@ -13,5 +13,5 @@ fn run(source_text: &str, source_type: SourceType) -> String {
     CodeGenerator::new()
         .with_options(CodegenOptions { single_quote: true, ..CodegenOptions::default() })
         .build(program)
-        .source_text
+        .code
 }

crates/oxc_transformer/tests/plugins/replace_global_defines.rs

@@ -20,7 +20,7 @@ pub(crate) fn test(source_text: &str, expected: &str, config: ReplaceGlobalDefin
     let result = CodeGenerator::new()
         .with_options(CodegenOptions { single_quote: true, ..CodegenOptions::default() })
         .build(program)
-        .source_text;
+        .code;
     let expected = run(expected, source_type);
     assert_eq!(result, expected, "for source {source_text}");
 }

crates/oxc_wasm/src/lib.rs

@@ -285,7 +285,7 @@ impl Oxc {
                 ..CodegenOptions::default()
             })
             .build(&program)
-            .source_text;
+            .code;
 
         Ok(())
     }

napi/minify/src/lib.rs

@@ -24,5 +24,5 @@ pub fn minify(filename: String, source_text: String) -> String {
         .with_mangler(mangler)
         .with_capacity(source_text.len())
         .build(&program)
-        .source_text
+        .code
 }

napi/transform/src/isolated_declaration.rs

@@ -55,8 +55,8 @@ pub fn isolated_declaration(
     let errors = wrap_diagnostics(source_path, source_type, &source_text, errors);
 
     IsolatedDeclarationsResult {
-        code: codegen_ret.source_text,
-        map: codegen_ret.source_map.map(SourceMap::from),
+        code: codegen_ret.code,
+        map: codegen_ret.map.map(SourceMap::from),
         errors,
     }
 }

napi/transform/src/transformer.rs

@@ -112,13 +112,13 @@ impl CompilerInterface for Compiler {
     }
 
     fn after_codegen(&mut self, ret: CodegenReturn) {
-        self.printed = ret.source_text;
-        self.printed_sourcemap = ret.source_map.map(SourceMap::from);
+        self.printed = ret.code;
+        self.printed_sourcemap = ret.map.map(SourceMap::from);
     }
 
     fn after_isolated_declarations(&mut self, ret: CodegenReturn) {
-        self.declaration.replace(ret.source_text);
-        self.declaration_map = ret.source_map.map(SourceMap::from);
+        self.declaration.replace(ret.code);
+        self.declaration_map = ret.map.map(SourceMap::from);
     }
 }
 

tasks/benchmark/benches/codegen.rs

@@ -15,7 +15,7 @@ fn bench_codegen(criterion: &mut Criterion) {
 
         let mut group = criterion.benchmark_group("codegen");
         group.bench_with_input(id.clone(), &ret.program, |b, program| {
-            b.iter_with_large_drop(|| CodeGenerator::new().build(program).source_map);
+            b.iter_with_large_drop(|| CodeGenerator::new().build(program).map);
         });
         group.finish();
 

tasks/benchmark/benches/sourcemap.rs

@@ -17,16 +17,16 @@ fn bench_sourcemap(criterion: &mut Criterion) {
             let allocator = Allocator::default();
             let ret = Parser::new(&allocator, source_text, source_type).parse();
 
-            let CodegenReturn { source_text: output_txt, .. } = CodeGenerator::new()
+            let CodegenReturn { code: output_txt, .. } = CodeGenerator::new()
                 .enable_source_map(file.file_name.as_str(), source_text)
                 .build(&ret.program);
             let lines = output_txt.matches('\n').count() as u32;
 
             b.iter(|| {
-                let CodegenReturn { source_map, .. } = CodeGenerator::new()
+                let CodegenReturn { map, .. } = CodeGenerator::new()
                     .enable_source_map(file.file_name.as_str(), source_text)
                     .build(&ret.program);
-                if let Some(sourcemap) = source_map {
+                if let Some(sourcemap) = map {
                     let concat_sourcemap_builder = ConcatSourceMapBuilder::from_sourcemaps(&[
                         (&sourcemap, 0),
                         (&sourcemap, lines),

tasks/coverage/src/driver.rs

@@ -111,7 +111,7 @@ impl CompilerInterface for Driver {
     }
 
     fn after_codegen(&mut self, ret: CodegenReturn) {
-        self.printed = ret.source_text;
+        self.printed = ret.code;
     }
 }
 

tasks/coverage/src/runtime/mod.rs

@@ -139,7 +139,7 @@ impl Case for CodegenRuntimeTest262Case {
                 let source_type = SourceType::default().with_module(is_module);
                 let allocator = Allocator::default();
                 let ret = Parser::new(&allocator, source_text, source_type).parse();
-                let mut text = CodeGenerator::new().build(&ret.program).source_text;
+                let mut text = CodeGenerator::new().build(&ret.program).code;
                 if is_only_strict {
                     text = format!("\"use strict\";\n{text}");
                 }

tasks/coverage/src/typescript/meta.rs

@@ -202,7 +202,7 @@ impl Baseline {
         let allocator = Allocator::default();
         let source_type = SourceType::from_path(Path::new(&self.name)).unwrap();
         let ret = Parser::new(&allocator, &self.original, source_type).parse();
-        let printed = CodeGenerator::new().build(&ret.program).source_text;
+        let printed = CodeGenerator::new().build(&ret.program).code;
         self.oxc_printed = printed;
     }
 

tasks/coverage/src/typescript/transpile_runner.rs

@@ -185,6 +185,6 @@ fn transpile(path: &Path, source_text: &str) -> (String, Vec<OxcDiagnostic>) {
         IsolatedDeclarationsOptions { strip_internal: true },
     )
     .build(&ret.program);
-    let printed = CodeGenerator::new().build(&ret.program).source_text;
+    let printed = CodeGenerator::new().build(&ret.program).code;
     (printed, ret.errors)
 }

tasks/minsize/src/lib.rs

@@ -115,7 +115,7 @@ fn minify(source_text: &str, source_type: SourceType, options: MinifierOptions)
         .with_options(CodegenOptions { minify: true, ..CodegenOptions::default() })
         .with_mangler(ret.mangler)
         .build(program)
-        .source_text
+        .code
 }
 
 fn gzip_size(s: &str) -> usize {

tasks/transform_conformance/src/driver.rs

@@ -36,7 +36,7 @@ impl CompilerInterface for Driver {
     }
 
     fn after_codegen(&mut self, ret: CodegenReturn) {
-        self.printed = ret.source_text;
+        self.printed = ret.code;
     }
 
     fn after_transform(

tasks/transform_conformance/src/test_case.rs

@@ -306,7 +306,7 @@ impl TestCase for ConformanceTestCase {
                         // CommentOptions { preserve_annotate_comments: true },
                         // )
                         .build(&ret.program)
-                        .source_text
+                        .code
                 },
             );
 
@@ -396,7 +396,7 @@ impl ExecTestCase {
         let source_text = fs::read_to_string(&target_path).unwrap();
         let source_type = SourceType::from_path(&target_path).unwrap();
         let transformed_ret = Parser::new(&allocator, &source_text, source_type).parse();
-        let result = CodeGenerator::new().build(&transformed_ret.program).source_text;
+        let result = CodeGenerator::new().build(&transformed_ret.program).code;
         fs::write(&target_path, result).unwrap();
         target_path
     }