crates/core/src/driver/unpack/scope_split.rs

GitHub
//! Heuristic splitting of scope-hoisted modules inside detected bundles.
//!
//! Detector output modules can themselves be scope-hoisted concatenations
//! (esbuild/Bun style). When this aggressive-only pass is enabled, each
//! extracted module is re-examined and split further when the result still
//! resolves.

use std::collections::HashSet;

use swc_core::common::{sync::Lrc, Mark, SourceMap, GLOBALS};
use swc_core::ecma::transforms::base::resolver;
use swc_core::ecma::visit::VisitMutWith;

use super::super::io::parse_js;
use super::{recover_late_esm_from_factory_iifes, LateEsmRecoveryOptions};
use crate::rules::{apply_rules, RewriteLevel, RulePipelineOptions};
use crate::unpacker::{scope_hoist, GeneratedSourceMapPoint, UnpackResult, UnpackedModule};

pub(super) fn maybe_split_scope_hoisted_modules(
    result: UnpackResult,
    enabled: bool,
) -> UnpackResult {
    if !enabled {
        return result;
    }

    let mut modules = Vec::new();
    let mut did_split = false;
    let original_filenames: HashSet<String> = result
        .modules
        .iter()
        .map(|module| module.filename.clone())
        .collect();

    for module in result.modules {
        match split_nested_scope_hoisted_module(&module) {
            Some(split) => {
                let parent_filename = module.filename.clone();
                let split_modules = namespace_scope_hoisted_split(&module, split.modules);
                let mut available_filenames = original_filenames.clone();
                available_filenames.remove(&parent_filename);
                available_filenames
                    .extend(split_modules.iter().map(|module| module.filename.clone()));
                if scope_split_imports_resolve(&split_modules, &available_filenames)
                    && scope_split_modules_parse(&split_modules)
                {
                    did_split = true;
                    modules.extend(split_modules);
                } else {
                    modules.push(module);
                }
            }
            _ => modules.push(module),
        }
    }

    UnpackResult {
        modules,
        allow_cycle_premerge: result.allow_cycle_premerge && !did_split,
        format: result.format,
    }
}

fn split_nested_scope_hoisted_module(module: &UnpackedModule) -> Option<UnpackResult> {
    let raw_split = scope_hoist::split_scope_hoisted(&module.code);
    if raw_split.as_ref().is_some_and(is_usable_nested_split) {
        return raw_split;
    }
    if module.generated_source_map.is_empty() {
        return None;
    }

    split_esm_recovered_scope_hoisted_module(&module.code, &module.filename)
        .filter(is_usable_nested_split)
}

fn is_usable_nested_split(split: &UnpackResult) -> bool {
    split.modules.len() > 1 && has_nontrivial_scope_split_entry(split)
}

fn has_nontrivial_scope_split_entry(split: &UnpackResult) -> bool {
    split
        .modules
        .iter()
        .find(|module| module.is_entry)
        .is_some_and(|module| module.code.contains("from \"./"))
}

fn split_esm_recovered_scope_hoisted_module(source: &str, filename: &str) -> Option<UnpackResult> {
    GLOBALS.set(&Default::default(), || {
        let cm: Lrc<SourceMap> = Default::default();
        let mut module = parse_js(source, filename, cm.clone()).ok()?;
        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("UnEsm"),
        );
        recover_late_esm_from_factory_iifes(
            &mut module,
            unresolved_mark,
            RewriteLevel::Standard,
            LateEsmRecoveryOptions {
                smart_rename: false,
                export_rename: false,
            },
        );
        scope_hoist::split_scope_hoisted_module(&module, cm)
    })
}

fn namespace_scope_hoisted_split(
    parent: &UnpackedModule,
    split_modules: Vec<UnpackedModule>,
) -> Vec<UnpackedModule> {
    let (parent_dir, parent_stem, parent_basename) = split_parent_path_parts(&parent.filename);
    let child_dir = if parent_dir.is_empty() {
        parent_stem.clone()
    } else {
        format!("{parent_dir}/{parent_stem}")
    };
    let entry_import_dir = parent_stem;
    let child_filenames: HashSet<String> = split_modules
        .iter()
        .filter(|module| !module.is_entry)
        .map(|module| module.filename.clone())
        .collect();

    let mut modules = Vec::with_capacity(split_modules.len());
    for mut module in split_modules {
        let source_ranges = if parent.generated_source_map.is_empty() {
            parent.source_ranges.clone()
        } else {
            map_generated_ranges_to_source(&parent.generated_source_map, &module.source_ranges)
                .unwrap_or_default()
        };
        module.source_ranges = source_ranges;
        module.source_input = parent.source_input.clone();
        module.generated_source_map.clear();
        if module.is_entry {
            module.id = parent.id.clone();
            module.is_entry = parent.is_entry;
            module.filename = parent.filename.clone();
            module.code =
                rewrite_scope_entry_imports(module.code, &entry_import_dir, &child_filenames);
        } else {
            module.id = format!("{}/{}", parent.id, module.id);
            module.filename = format!("{child_dir}/{}", module.filename);
            module.code =
                rewrite_scope_child_imports(module.code, &parent_basename, &child_filenames);
        }
        modules.push(module);
    }
    modules
}

fn map_generated_ranges_to_source(
    mappings: &[GeneratedSourceMapPoint],
    generated_ranges: &[(u32, u32)],
) -> Option<Vec<(u32, u32)>> {
    if mappings.is_empty() || generated_ranges.is_empty() {
        return None;
    }

    let mut source_ranges = Vec::new();
    for &(generated_start, generated_end) in generated_ranges {
        if generated_start >= generated_end {
            continue;
        }

        let start = mappings.partition_point(|point| point.generated_offset < generated_start);
        let end = mappings.partition_point(|point| point.generated_offset < generated_end);
        if start >= end {
            continue;
        }

        for idx in start..end {
            let source_start = mappings[idx].source_offset;
            // Only use the next mapping's source_offset as our end when it
            // falls inside the same generated range (idx + 1 < end).
            // Beyond that boundary the next mapping belongs to a different
            // child module and would over-claim provenance.
            let source_end = if idx + 1 < end {
                mappings[idx + 1].source_offset.max(source_start)
            } else {
                let generated_remaining = generated_end - mappings[idx].generated_offset;
                source_start.saturating_add(generated_remaining)
            };
            if source_start < source_end {
                source_ranges.push((source_start, source_end));
            }
        }
    }

    if source_ranges.is_empty() {
        return None;
    }
    Some(coalesce_ranges(source_ranges))
}

fn coalesce_ranges(mut ranges: Vec<(u32, u32)>) -> Vec<(u32, u32)> {
    ranges.sort_unstable();
    let mut out: Vec<(u32, u32)> = Vec::new();
    for (start, end) in ranges {
        match out.last_mut() {
            Some(last) if start <= last.1 => last.1 = last.1.max(end),
            _ => out.push((start, end)),
        }
    }
    out
}

fn split_parent_path_parts(filename: &str) -> (String, String, String) {
    let normalized = filename.replace('\\', "/");
    let (parent, basename) = normalized
        .rsplit_once('/')
        .map(|(parent, basename)| (parent.to_string(), basename))
        .unwrap_or_else(|| (String::new(), normalized.as_str()));
    let stem = basename
        .rsplit_once('.')
        .map(|(stem, _)| stem)
        .filter(|stem| !stem.is_empty())
        .unwrap_or("module")
        .to_string();
    (parent, stem, basename.to_string())
}

fn rewrite_scope_entry_imports(
    mut code: String,
    entry_import_dir: &str,
    child_filenames: &HashSet<String>,
) -> String {
    for child_filename in child_filenames {
        let old = format!("from \"./{child_filename}\"");
        let new = format!("from \"./{entry_import_dir}/{child_filename}\"");
        code = code.replace(&old, &new);
    }
    code
}

fn rewrite_scope_child_imports(
    mut code: String,
    parent_basename: &str,
    child_filenames: &HashSet<String>,
) -> String {
    let replacements = scan_static_relative_imports(&code)
        .into_iter()
        .filter_map(|import| {
            if import.specifier == "./entry.js" {
                return Some((import.start, import.end, format!("../{parent_basename}")));
            }

            let child_or_sibling = import.specifier.strip_prefix("./")?;
            if child_filenames.contains(child_or_sibling) {
                return None;
            }
            Some((import.start, import.end, format!("../{child_or_sibling}")))
        })
        .collect::<Vec<_>>();

    for (start, end, replacement) in replacements.into_iter().rev() {
        code.replace_range(start..end, &replacement);
    }
    code
}

fn scope_split_imports_resolve(
    modules: &[UnpackedModule],
    available_filenames: &HashSet<String>,
) -> bool {
    modules.iter().all(|module| {
        extract_static_relative_imports(&module.code)
            .into_iter()
            .all(|spec| {
                resolve_relative_module_filename(&module.filename, &spec)
                    .is_some_and(|filename| available_filenames.contains(&filename))
            })
    })
}

fn scope_split_modules_parse(modules: &[UnpackedModule]) -> bool {
    modules.iter().all(|module| {
        GLOBALS.set(&Default::default(), || {
            let cm: Lrc<SourceMap> = Default::default();
            parse_js(&module.code, &module.filename, cm).is_ok()
        })
    })
}

fn extract_static_relative_imports(code: &str) -> Vec<String> {
    scan_static_relative_imports(code)
        .into_iter()
        .map(|import| import.specifier)
        .collect()
}

#[derive(Debug, Clone, PartialEq, Eq)]
struct StaticRelativeImport {
    specifier: String,
    start: usize,
    end: usize,
}

fn scan_static_relative_imports(code: &str) -> Vec<StaticRelativeImport> {
    let mut imports = Vec::new();
    let bytes = code.as_bytes();
    let mut index = 0;

    while index < bytes.len() {
        match bytes[index] {
            b'\'' | b'"' => {
                index = skip_quoted(code, index);
                continue;
            }
            b'`' => {
                index = skip_template_literal(code, index);
                continue;
            }
            b'/' if bytes.get(index + 1) == Some(&b'/') => {
                index = skip_line_comment(code, index + 2);
                continue;
            }
            b'/' if bytes.get(index + 1) == Some(&b'*') => {
                index = skip_block_comment(code, index + 2);
                continue;
            }
            _ => {}
        }

        if starts_with_keyword(code, index, "from") {
            if let Some(import) = scan_quoted_specifier(code, skip_ascii_ws(code, index + 4)) {
                imports.push(import);
                index += 4;
                continue;
            }
        } else if starts_with_keyword(code, index, "import") {
            if let Some(import) = scan_quoted_specifier(code, skip_ascii_ws(code, index + 6)) {
                imports.push(import);
                index += 6;
                continue;
            }
        } else if starts_with_keyword(code, index, "require") {
            if let Some(import) = scan_require_specifier(code, index + 7) {
                imports.push(import);
                index += 7;
                continue;
            }
        }

        index += 1;
    }

    imports
}

fn starts_with_keyword(code: &str, index: usize, keyword: &str) -> bool {
    let after = index + keyword.len();
    if after > code.len() || !code.is_char_boundary(index) || !code.is_char_boundary(after) {
        return false;
    }

    code[index..].starts_with(keyword)
        && !code[..index]
            .bytes()
            .next_back()
            .is_some_and(is_js_ident_continue)
        && !code[index + keyword.len()..]
            .bytes()
            .next()
            .is_some_and(is_js_ident_continue)
}

fn is_js_ident_continue(byte: u8) -> bool {
    byte.is_ascii_alphanumeric() || matches!(byte, b'_' | b'$')
}

fn skip_ascii_ws(code: &str, mut index: usize) -> usize {
    let bytes = code.as_bytes();
    while index < bytes.len() && bytes[index].is_ascii_whitespace() {
        index += 1;
    }
    index
}

fn scan_require_specifier(code: &str, index: usize) -> Option<StaticRelativeImport> {
    let index = skip_ascii_ws(code, index);
    if code.as_bytes().get(index) != Some(&b'(') {
        return None;
    }
    scan_quoted_specifier(code, skip_ascii_ws(code, index + 1))
}

fn scan_quoted_specifier(code: &str, index: usize) -> Option<StaticRelativeImport> {
    let quote = *code.as_bytes().get(index)?;
    if !matches!(quote, b'\'' | b'"') {
        return None;
    }
    let start = index + 1;
    let end = find_quoted_end(code, index)?;
    let specifier = &code[start..end];
    if !(specifier.starts_with("./") || specifier.starts_with("../")) {
        return None;
    }
    Some(StaticRelativeImport {
        specifier: specifier.to_string(),
        start,
        end,
    })
}

fn find_quoted_end(code: &str, index: usize) -> Option<usize> {
    let quote = *code.as_bytes().get(index)?;
    let bytes = code.as_bytes();
    let mut cursor = index + 1;
    while cursor < bytes.len() {
        match bytes[cursor] {
            b'\\' => cursor = cursor.saturating_add(2),
            byte if byte == quote => return Some(cursor),
            _ => cursor += 1,
        }
    }
    None
}

fn skip_quoted(code: &str, index: usize) -> usize {
    find_quoted_end(code, index)
        .map(|end| end + 1)
        .unwrap_or(code.len())
}

fn skip_template_literal(code: &str, index: usize) -> usize {
    let bytes = code.as_bytes();
    let mut cursor = index + 1;
    while cursor < bytes.len() {
        match bytes[cursor] {
            b'\\' => cursor = cursor.saturating_add(2),
            b'`' => return cursor + 1,
            _ => cursor += 1,
        }
    }
    code.len()
}

fn skip_line_comment(code: &str, index: usize) -> usize {
    code[index..]
        .find('\n')
        .map(|offset| index + offset + 1)
        .unwrap_or(code.len())
}

fn skip_block_comment(code: &str, index: usize) -> usize {
    code[index..]
        .find("*/")
        .map(|offset| index + offset + 2)
        .unwrap_or(code.len())
}

fn resolve_relative_module_filename(current_filename: &str, specifier: &str) -> Option<String> {
    let normalized_current = current_filename.replace('\\', "/");
    let mut parts: Vec<&str> = normalized_current
        .rsplit_once('/')
        .map(|(parent, _)| parent.split('/').filter(|part| !part.is_empty()).collect())
        .unwrap_or_default();

    for part in specifier.split('/') {
        match part {
            "" | "." => {}
            ".." => {
                parts.pop()?;
            }
            part => parts.push(part),
        }
    }

    let mut resolved = parts.join("/");
    if !resolved.ends_with(".js") {
        resolved.push_str(".js");
    }
    Some(resolved)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::unpacker::BundleFormat;

    #[test]
    fn disabled_nested_scope_split_preserves_detected_module() {
        let result = UnpackResult {
            modules: vec![UnpackedModule {
                id: "100".to_string(),
                is_entry: false,
                code: nested_scope_hoist_fixture(),
                filename: "module-100.js".to_string(),
                ..Default::default()
            }],
            allow_cycle_premerge: true,
            format: BundleFormat::Webpack5,
        };

        let output = maybe_split_scope_hoisted_modules(result, false);

        assert_eq!(output.modules.len(), 1);
        assert_eq!(output.modules[0].id, "100");
        assert_eq!(output.modules[0].filename, "module-100.js");
        assert!(output.allow_cycle_premerge);
    }

    #[test]
    fn enabled_nested_scope_split_namespaces_child_modules() {
        let result = UnpackResult {
            modules: vec![UnpackedModule {
                id: "100".to_string(),
                is_entry: false,
                code: nested_scope_hoist_fixture(),
                filename: "module-100.js".to_string(),
                ..Default::default()
            }],
            allow_cycle_premerge: true,
            format: BundleFormat::Webpack5,
        };

        let output = maybe_split_scope_hoisted_modules(result, true);
        let names: HashSet<_> = output
            .modules
            .iter()
            .map(|module| module.filename.as_str())
            .collect();

        assert!(
            output.modules.len() > 1,
            "aggressive nested split should split fixture, got {:?}",
            names
        );
        assert!(names.contains("module-100.js"));
        assert!(
            names.iter().any(|name| name.starts_with("module-100/")),
            "child modules should be namespaced under parent filename: {:?}",
            names
        );
        assert!(
            !output.allow_cycle_premerge,
            "recursive scope split should disable later cycle premerge"
        );
    }

    #[test]
    fn namespace_scope_split_keeps_parent_filename_and_rewrites_entry_imports() {
        let parent = UnpackedModule {
            id: "11111".to_string(),
            is_entry: false,
            code: String::new(),
            filename: "module-11111.js".to_string(),
            ..Default::default()
        };
        let split_modules = vec![
            UnpackedModule {
                id: "entry".to_string(),
                is_entry: true,
                code: r#"import { value } from "./chunk_value.js";
console.log(value);
"#
                .to_string(),
                filename: "entry.js".to_string(),
                ..Default::default()
            },
            UnpackedModule {
                id: "chunk_value".to_string(),
                is_entry: false,
                code: r#"import { init } from "./entry.js";
import { other } from "./chunk_other.js";
import sibling from "./module-44444.js";
const siblingCjs = require("./module-44444.js");
const literal = 'require("./module-44444.js")';
// from "./module-44444.js";
export const value = init + 1;
"#
                .to_string(),
                filename: "chunk_value.js".to_string(),
                ..Default::default()
            },
            UnpackedModule {
                id: "chunk_other".to_string(),
                is_entry: false,
                code: r#"export const other = 1;
"#
                .to_string(),
                filename: "chunk_other.js".to_string(),
                ..Default::default()
            },
        ];

        let modules = namespace_scope_hoisted_split(&parent, split_modules);
        assert_eq!(modules[0].id, "11111");
        assert_eq!(modules[0].filename, "module-11111.js");
        assert!(
            modules[0]
                .code
                .contains(r#"from "./module-11111/chunk_value.js""#),
            "entry imports should target the namespaced child chunk:\n{}",
            modules[0].code
        );
        assert_eq!(modules[1].id, "11111/chunk_value");
        assert_eq!(modules[1].filename, "module-11111/chunk_value.js");
        assert!(
            modules[1].code.contains(r#"from "../module-11111.js""#),
            "child imports of split entry should target the preserved parent filename:\n{}",
            modules[1].code
        );
        assert!(
            modules[1].code.contains(r#"from "./chunk_other.js""#),
            "child-to-child imports should stay within the namespaced child dir:\n{}",
            modules[1].code
        );
        assert!(
            modules[1].code.contains(r#"from "../module-44444.js""#),
            "child imports of external sibling modules should point out of the child dir:\n{}",
            modules[1].code
        );
        assert!(
            modules[1].code.contains(r#"require("../module-44444.js")"#),
            "child require() calls of external sibling modules should point out of the child dir:\n{}",
            modules[1].code
        );
        assert!(
            modules[1]
                .code
                .contains(r#"const literal = 'require("./module-44444.js")';"#),
            "import-looking text in string literals should not be rewritten:\n{}",
            modules[1].code
        );
        assert!(
            modules[1].code.contains(r#"// from "./module-44444.js";"#),
            "import-looking text in comments should not be rewritten:\n{}",
            modules[1].code
        );

        let mut available: HashSet<String> = modules
            .iter()
            .map(|module| module.filename.clone())
            .collect();
        available.insert("module-44444.js".to_string());
        assert!(scope_split_imports_resolve(&modules, &available));

        let missing_entry = HashSet::from(["module-11111/chunk_value.js".to_string()]);
        assert!(!scope_split_imports_resolve(&modules, &missing_entry));
    }

    #[test]
    fn scope_split_parse_guard_rejects_invalid_child_modules() {
        let modules = vec![
            UnpackedModule {
                id: "entry".to_string(),
                is_entry: true,
                code: r#"import { value } from "./chunk_value.js";
console.log(value);
"#
                .to_string(),
                filename: "entry.js".to_string(),
                ..Default::default()
            },
            UnpackedModule {
                id: "chunk_value".to_string(),
                is_entry: false,
                code: "const = ;".to_string(),
                filename: "chunk_value.js".to_string(),
                ..Default::default()
            },
        ];

        assert!(
            !scope_split_modules_parse(&modules),
            "invalid nested split output should be rejected before CLI unpack fails"
        );
    }

    fn nested_scope_hoist_fixture() -> String {
        r#"
            function helperA1() { return 1; }
            function helperA2() { return helperA1() + 1; }
            function helperA3() { return helperA2() * 2; }
            function helperA4() { return helperA3() + 5; }
            function publicA() { return helperA4(); }

            function helperB1() { return 10; }
            function helperB2() { return helperB1() + 10; }
            function helperB3() { return helperB2() * 20; }
            function helperB4() { return helperB3() + 50; }
            function publicB() { return helperB4(); }

            const result = publicA() + publicB();
            export { result };
        "#
        .to_string()
    }
}