crates/core/src/driver/single_file.rs
GitHubuse anyhow::Result;
use swc_core::common::{sync::Lrc, Mark, SourceMap, GLOBALS};
use swc_core::ecma::transforms::base::resolver;
use swc_core::ecma::visit::VisitMutWith;
use super::diagnostics::{
collect_duplicate_declaration_warnings, collect_input_parse_warnings, collect_tdz_warnings,
verify_output_parses,
};
use super::io::{
apply_fixer, build_output_sourcemap, parse_js_with_recovery, print_js, print_js_with_srcmap,
};
use super::types::{DecompileOptions, DecompileOutput};
use crate::rules::{apply_rules, ImportDedup, RulePipelineOptions, UnImportRename};
use crate::sourcemap_rename::{apply_sourcemap_renames, parse_sourcemap};
pub fn decompile(source: &str, options: DecompileOptions) -> Result<DecompileOutput> {
let span = tracing::info_span!("decompile", filename = %options.filename);
let _enter = span.enter();
GLOBALS.set(&Default::default(), || {
let cm: Lrc<SourceMap> = Default::default();
let parsed = {
let span = tracing::info_span!("parse");
let _enter = span.enter();
parse_js_with_recovery(source, &options.filename, cm.clone())?
};
let mut module = parsed.module;
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
{
let span = tracing::info_span!("resolver");
let _enter = span.enter();
module.visit_mut_with(&mut resolver(unresolved_mark, top_level_mark, false));
}
{
let span = tracing::info_span!("rules");
let _enter = span.enter();
apply_rules(
&mut module,
unresolved_mark,
RulePipelineOptions::default()
.with_dce_mode(options.dce_mode)
.with_rewrite_level(options.level),
);
}
// Source-map-enhanced passes (only when sourcemap bytes are supplied).
if let Some(bytes) = &options.sourcemap {
let span = tracing::info_span!("sourcemap_renames");
let _enter = span.enter();
let sm = parse_sourcemap(bytes)?;
module.visit_mut_with(&mut ImportDedup);
apply_sourcemap_renames(&mut module, &sm, &cm, unresolved_mark);
module.visit_mut_with(&mut UnImportRename::new(unresolved_mark));
}
if options.level >= crate::rules::RewriteLevel::Standard {
crate::rules::strip_redundant_sentry_source_file(&mut module, &options.filename);
}
let mut warnings = if options.diagnostics {
let mut warnings = collect_input_parse_warnings(&parsed.recoverable_errors);
warnings.extend(collect_tdz_warnings(&module, &options.filename));
warnings.extend(collect_duplicate_declaration_warnings(
&module,
&options.filename,
));
warnings
} else {
Vec::new()
};
{
let span = tracing::info_span!("fixer");
let _enter = span.enter();
apply_fixer(&mut module)?;
}
let (code, source_map) = {
let span = tracing::info_span!("emit");
let _enter = span.enter();
if options.emit_source_map {
let (code, srcmap_buf) = print_js_with_srcmap(&module, cm.clone())?;
let map_json = build_output_sourcemap(&srcmap_buf, &cm, &options.filename)?;
(code, Some(map_json))
} else {
(print_js(&module, cm)?, None)
}
};
if options.diagnostics {
warnings.extend(verify_output_parses(&code, &options.filename));
}
Ok(DecompileOutput {
code,
warnings,
source_map,
})
})
}
#[cfg(test)]
mod tests {
use super::super::types::UnpackWarningKind;
use super::*;
#[test]
fn diagnostics_off_by_default() {
let output = decompile("console.log(x);\nlet x = 1;", DecompileOptions::default())
.expect("decompile should succeed");
assert!(
output.warnings.is_empty(),
"default decompile should produce no diagnostic warnings"
);
}
#[test]
fn diagnostics_opt_in_reports_tdz() {
let output = decompile(
"console.log(x);\nlet x = 1;",
DecompileOptions {
diagnostics: true,
..Default::default()
},
)
.expect("decompile should succeed");
assert!(
output
.warnings
.iter()
.any(|w| w.kind == UnpackWarningKind::TdzViolation),
"diagnostics should report TDZ violation"
);
}
#[test]
fn diagnostics_opt_in_reports_recovered_input_parse_errors() {
let output = decompile(
"label: label: break label;",
DecompileOptions {
diagnostics: true,
filename: "duplicate-label.js".to_string(),
..Default::default()
},
)
.expect("recovered input parse should still decompile");
assert!(
output
.warnings
.iter()
.any(|w| w.kind == UnpackWarningKind::InputParseRecovered),
"diagnostics should report recovered input parse error: {:?}",
output.warnings
);
}
#[test]
fn diagnostics_opt_in_reports_recovered_output_parse_errors() {
let output = decompile(
"label: label: break label;",
DecompileOptions {
diagnostics: true,
filename: "duplicate-label.js".to_string(),
..Default::default()
},
)
.expect("recovered output parse should still return emitted code");
assert!(
output
.warnings
.iter()
.any(|w| w.kind == UnpackWarningKind::OutputParseRecovered),
"diagnostics should report recovered output parse error: {:?}",
output.warnings
);
assert!(
output.has_errors(),
"recovered output parse errors should be error-severity diagnostics"
);
}
#[test]
fn diagnostics_opt_in_reports_duplicate_lexical_declarations() {
let output = decompile(
"let a = 1;\nlet a = 2;",
DecompileOptions {
diagnostics: true,
filename: "duplicate.js".to_string(),
..Default::default()
},
)
.expect("duplicate declarations should still return emitted code");
assert!(
output
.warnings
.iter()
.any(|w| w.kind == UnpackWarningKind::DuplicateDeclaration),
"diagnostics should report duplicate declaration: {:?}",
output.warnings
);
assert!(
output.has_errors(),
"duplicate declarations should be error-severity diagnostics"
);
}
#[test]
fn diagnostics_duplicate_declarations_inside_block() {
let output = decompile(
"{ const x = 1; const x = 2; }",
DecompileOptions {
diagnostics: true,
filename: "block-dup.js".to_string(),
..Default::default()
},
)
.expect("decompile should succeed");
assert!(
output
.warnings
.iter()
.any(|w| w.kind == UnpackWarningKind::DuplicateDeclaration),
"should detect duplicate declarations inside block: {:?}",
output.warnings
);
}
#[test]
fn diagnostics_no_false_positive_across_block_scopes() {
let output = decompile(
"{ const x = 1; } { const x = 2; }",
DecompileOptions {
diagnostics: true,
filename: "separate-scopes.js".to_string(),
..Default::default()
},
)
.expect("decompile should succeed");
assert!(
!output
.warnings
.iter()
.any(|w| w.kind == UnpackWarningKind::DuplicateDeclaration),
"separate block scopes should not report duplicate: {:?}",
output.warnings
);
}
#[test]
fn diagnostics_no_false_positive_across_for_of_loops() {
let output = decompile(
"function f(items) { for (const x of items) { } for (const x of items) { } }",
DecompileOptions {
diagnostics: true,
filename: "for-of-scopes.js".to_string(),
..Default::default()
},
)
.expect("decompile should succeed");
assert!(
!output
.warnings
.iter()
.any(|w| w.kind == UnpackWarningKind::DuplicateDeclaration),
"separate for-of loop scopes should not report duplicate: {:?}",
output.warnings
);
}
#[test]
fn diagnostics_valid_output_no_parse_warning() {
let output = decompile(
"const x = 1;",
DecompileOptions {
diagnostics: true,
..Default::default()
},
)
.expect("decompile should succeed");
assert!(
!output.warnings.iter().any(|w| matches!(
w.kind,
UnpackWarningKind::OutputParseRecovered | UnpackWarningKind::OutputParseFailed
)),
"valid output should not produce parse warning"
);
}
#[test]
fn emit_source_map_off_by_default() {
let output = decompile("const x = 1;", DecompileOptions::default())
.expect("decompile should succeed");
assert!(
output.source_map.is_none(),
"source map should not be generated by default"
);
}
#[test]
fn emit_source_map_produces_valid_v3_map() {
let output = decompile(
"var a = 1;\nvar b = a && a.x && a.x.y;",
DecompileOptions {
filename: "test-input.js".to_string(),
emit_source_map: true,
..Default::default()
},
)
.expect("decompile should succeed");
let map_json = output
.source_map
.expect("source map should be generated when emit_source_map is true");
let sm = sourcemap::SourceMap::from_reader(map_json.as_bytes())
.expect("source map JSON should parse as valid v3");
assert_eq!(sm.get_file(), Some("test-input.js"));
assert!(sm.get_source_count() > 0, "should have at least one source");
assert!(sm.get_token_count() > 0, "should have mapping tokens");
}
#[test]
fn emit_source_map_includes_source_content() {
let input = "const greeting = 'hello';";
let output = decompile(
input,
DecompileOptions {
filename: "content-test.js".to_string(),
emit_source_map: true,
..Default::default()
},
)
.expect("decompile should succeed");
let map_json = output.source_map.expect("source map should be generated");
let sm = sourcemap::SourceMap::from_reader(map_json.as_bytes())
.expect("source map JSON should parse");
assert_eq!(
sm.get_source_contents(0),
Some(input),
"source map should embed the original input as sourcesContent"
);
}
#[test]
fn emit_source_map_tokens_map_back_to_input() {
let input = "var x = 42;\nvar y = x + 1;";
let output = decompile(
input,
DecompileOptions {
filename: "mapping-test.js".to_string(),
emit_source_map: true,
..Default::default()
},
)
.expect("decompile should succeed");
let map_json = output.source_map.expect("source map should be generated");
let sm = sourcemap::SourceMap::from_reader(map_json.as_bytes())
.expect("source map JSON should parse");
let has_line_0 = sm.tokens().any(|t| t.get_src_line() == 0);
let has_line_1 = sm.tokens().any(|t| t.get_src_line() == 1);
assert!(has_line_0, "should have tokens mapping to input line 0");
assert!(has_line_1, "should have tokens mapping to input line 1");
}
}