crates/core/tests/common/mod.rs
GitHubuse swc_core::common::{sync::Lrc, FileName, Mark, SourceMap, GLOBALS};
use swc_core::ecma::ast::Module;
use swc_core::ecma::codegen::{text_writer::JsWriter, Config, Emitter};
use swc_core::ecma::parser::{lexer::Lexer, EsSyntax, Parser, StringInput, Syntax};
use swc_core::ecma::transforms::base::{fixer::fixer, resolver};
use swc_core::ecma::visit::{VisitMut, VisitMutWith};
use wakaru_core::ModuleFactsMap;
use wakaru_core::{
apply_rules, decompile, trace_rules, DecompileOptions, RewriteLevel, RulePipelineOptions,
RuleTraceEvent, RuleTraceOptions,
};
#[allow(dead_code)]
pub fn render_pipeline(source: &str) -> String {
decompile(
source,
DecompileOptions {
filename: "fixture.js".to_string(),
..Default::default()
},
)
.expect("decompile should succeed")
.code
}
#[allow(dead_code)]
pub fn render(source: &str) -> String {
render_pipeline(source)
}
#[allow(dead_code)]
pub fn render_rule<R, F>(source: &str, build_rule: F) -> String
where
R: VisitMut,
F: FnOnce(Mark) -> R,
{
render_rule_with_filename(source, "fixture.js", build_rule)
}
#[allow(dead_code)]
pub fn render_rule_with_filename<R, F>(source: &str, filename: &str, build_rule: F) -> String
where
R: VisitMut,
F: FnOnce(Mark) -> R,
{
GLOBALS.set(&Default::default(), || {
let cm: Lrc<SourceMap> = Default::default();
let mut module = parse_module_with_filename(source, filename, cm.clone());
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
module.visit_mut_with(&mut resolver(unresolved_mark, top_level_mark, false));
let mut rule = build_rule(unresolved_mark);
module.visit_mut_with(&mut rule);
module.visit_mut_with(&mut fixer(None));
emit_module(&module, cm)
})
}
/// Run the decompile pipeline up through `stop_after_rule`, then emit.
/// Rule names match struct names (e.g. "SmartInline", "UnEsm").
/// Second passes use suffixed names: "UnWebpackInterop2", "UnIife2".
#[allow(dead_code)]
pub fn render_pipeline_until(source: &str, stop_after_rule: &str) -> String {
render_pipeline_until_with_level(source, stop_after_rule, RewriteLevel::Standard)
}
#[allow(dead_code)]
pub fn render_pipeline_until_with_level(
source: &str,
stop_after_rule: &str,
level: RewriteLevel,
) -> String {
GLOBALS.set(&Default::default(), || {
let cm: Lrc<SourceMap> = Default::default();
let mut module = parse_module_with_filename(source, "fixture.js", cm.clone());
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
module.visit_mut_with(&mut resolver(unresolved_mark, top_level_mark, false));
apply_rules(
&mut module,
unresolved_mark,
RulePipelineOptions::until(stop_after_rule).with_rewrite_level(level),
);
module.visit_mut_with(&mut fixer(None));
emit_module(&module, cm)
})
}
/// Run only the rules from `start_from` through `stop_after` (inclusive).
/// Useful for testing a rule's behavior given realistic pre-processed input
/// without the full pipeline's downstream effects.
#[allow(dead_code)]
pub fn render_pipeline_between(source: &str, start_from: &str, stop_after: &str) -> String {
GLOBALS.set(&Default::default(), || {
let cm: Lrc<SourceMap> = Default::default();
let mut module = parse_module_with_filename(source, "fixture.js", cm.clone());
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
module.visit_mut_with(&mut resolver(unresolved_mark, top_level_mark, false));
apply_rules(
&mut module,
unresolved_mark,
RulePipelineOptions::between(start_from, stop_after),
);
module.visit_mut_with(&mut fixer(None));
emit_module(&module, cm)
})
}
/// Run an isolated pipeline span with cross-module facts available.
#[allow(dead_code)]
pub fn render_pipeline_between_with_facts(
source: &str,
start_from: &str,
stop_after: &str,
module_facts: &ModuleFactsMap,
current_filename: Option<&str>,
) -> String {
GLOBALS.set(&Default::default(), || {
let cm: Lrc<SourceMap> = Default::default();
let filename = current_filename.unwrap_or("fixture.js");
let mut module = parse_module_with_filename(source, filename, cm.clone());
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
module.visit_mut_with(&mut resolver(unresolved_mark, top_level_mark, false));
let mut options =
RulePipelineOptions::between(start_from, stop_after).with_module_facts(module_facts);
if let Some(filename) = current_filename {
options = options.with_current_filename(filename);
}
apply_rules(&mut module, unresolved_mark, options);
module.visit_mut_with(&mut fixer(None));
emit_module(&module, cm)
})
}
#[allow(dead_code)]
pub fn trace_pipeline(source: &str, options: RuleTraceOptions) -> Vec<RuleTraceEvent> {
trace_rules(
source,
DecompileOptions {
filename: "fixture.js".to_string(),
..Default::default()
},
options,
)
.expect("trace should succeed")
}
#[allow(dead_code)]
pub fn changed_rules(source: &str) -> Vec<&'static str> {
trace_pipeline(
source,
RuleTraceOptions {
only_changed: true,
..Default::default()
},
)
.into_iter()
.map(|event| event.rule)
.collect()
}
#[allow(dead_code)]
pub fn normalize(input: &str) -> String {
GLOBALS.set(&Default::default(), || {
let cm: Lrc<SourceMap> = Default::default();
let module = parse_module_with_filename(input, "normalize.js", cm.clone());
emit_module(&module, cm)
})
}
#[allow(dead_code)]
pub fn assert_eq_normalized(actual: &str, expected: &str) {
assert_eq!(normalize(actual), normalize(expected));
}
fn parse_module_with_filename(code: &str, filename: &str, cm: Lrc<SourceMap>) -> Module {
let fm = cm.new_source_file(
FileName::Custom(filename.to_string()).into(),
code.to_string(),
);
let lexer = Lexer::new(
Syntax::Es(EsSyntax {
jsx: true,
..Default::default()
}),
Default::default(),
StringInput::from(&*fm),
None,
);
let mut parser = Parser::new_from(lexer);
let parser_errors = parser.take_errors();
assert!(
parser_errors.is_empty(),
"failed to parse for normalization: {:?}",
parser_errors
);
parser
.parse_module()
.expect("failed to parse module for normalization")
}
fn emit_module(module: &Module, cm: Lrc<SourceMap>) -> String {
let mut output = Vec::new();
{
let mut emitter = Emitter {
cfg: Config::default().with_minify(false),
cm: cm.clone(),
comments: None,
wr: JsWriter::new(cm, "\n", &mut output, None),
};
emitter
.emit_module(module)
.expect("failed to emit module for normalization");
}
String::from_utf8(output).expect("normalization output is not utf-8")
}