crates/core/src/rules/dead_imports.rs

GitHub
//! Strip unused import specifiers. Runs late in the pipeline, after all
//! rewrites that might remove usages (JSX synthesis, SmartInline, etc.).
//!
//! In full DCE mode, specifiers whose local binding has no reference in the
//! module body are removed. Transform-only DCE receives the specifier spans it
//! must preserve from the pipeline: source-module default/named imports are
//! observable ESM link-time export checks, while imports recovered from bundle
//! edges are generated structure and may be cleaned up after their last use.
//! - If all specifiers are stripped, the declaration becomes a side-effect
//!   import `import "./x.js";` — we don't delete it outright because the
//!   source module may have side effects on evaluation.
//! - Duplicate side-effect imports are collapsed. If any remaining binding
//!   import exists for the same source, side-effect-only imports for that source
//!   are removed because the binding import still evaluates the module.
//!
//! Property-name positions (`obj.foo`, `{foo: ...}` keys, JSX attribute names)
//! are not counted as references.

use std::collections::HashSet;

use swc_core::atoms::Atom;
use swc_core::common::{BytePos, SyntaxContext, DUMMY_SP};
use swc_core::ecma::ast::{ImportDecl, ImportSpecifier, Module, ModuleDecl, ModuleItem, Str};
use swc_core::ecma::visit::{VisitMut, VisitMutWith};

use crate::analysis::binding_uses::BindingUseIndex;

pub struct DeadImports {
    preserved_spans: Option<HashSet<(BytePos, BytePos)>>,
}

impl DeadImports {
    pub fn full() -> Self {
        Self {
            preserved_spans: None,
        }
    }

    pub fn delta(preserved_spans: &HashSet<(BytePos, BytePos)>) -> Self {
        Self {
            preserved_spans: Some(preserved_spans.clone()),
        }
    }

    pub(crate) fn preserve_currently_dead(module: &Module) -> Self {
        Self::delta(&compute_pre_dead_import_spans(module))
    }
}

impl VisitMut for DeadImports {
    fn visit_mut_module(&mut self, module: &mut Module) {
        let referenced = collect_references(module);

        for item in &mut module.body {
            let ModuleItem::ModuleDecl(ModuleDecl::Import(import)) = item else {
                continue;
            };
            strip_unused_specifiers(import, &referenced, self.preserved_spans.as_ref());
        }
        dedup_side_effect_imports(module);

        module.visit_mut_children_with(self);
    }
}

fn collect_references(module: &Module) -> HashSet<(Atom, SyntaxContext)> {
    BindingUseIndex::collect(module).referenced_bindings()
}

pub(crate) fn compute_pre_existing_import_spans(module: &Module) -> HashSet<(BytePos, BytePos)> {
    let mut spans = HashSet::new();
    for item in &module.body {
        let ModuleItem::ModuleDecl(ModuleDecl::Import(import)) = item else {
            continue;
        };
        for spec in &import.specifiers {
            let span = match spec {
                ImportSpecifier::Default(s) => s.local.span,
                ImportSpecifier::Namespace(s) => s.local.span,
                ImportSpecifier::Named(s) => s.local.span,
            };
            if span != DUMMY_SP {
                spans.insert((span.lo, span.hi));
            }
        }
    }
    spans
}

pub(crate) fn compute_pre_dead_import_spans(module: &Module) -> HashSet<(BytePos, BytePos)> {
    let referenced = collect_references(module);
    let mut spans = HashSet::new();
    for item in &module.body {
        let ModuleItem::ModuleDecl(ModuleDecl::Import(import)) = item else {
            continue;
        };
        for spec in &import.specifiers {
            let (sym, ctxt, span) = match spec {
                ImportSpecifier::Default(s) => (s.local.sym.clone(), s.local.ctxt, s.local.span),
                ImportSpecifier::Namespace(s) => (s.local.sym.clone(), s.local.ctxt, s.local.span),
                ImportSpecifier::Named(s) => (s.local.sym.clone(), s.local.ctxt, s.local.span),
            };
            if !referenced.contains(&(sym, ctxt)) && span != DUMMY_SP {
                spans.insert((span.lo, span.hi));
            }
        }
    }
    spans
}

fn strip_unused_specifiers(
    import: &mut ImportDecl,
    referenced: &HashSet<(Atom, SyntaxContext)>,
    preserved_spans: Option<&HashSet<(BytePos, BytePos)>>,
) {
    import.specifiers.retain(|spec| {
        let (sym, ctxt, span) = match spec {
            ImportSpecifier::Default(s) => (s.local.sym.clone(), s.local.ctxt, s.local.span),
            ImportSpecifier::Namespace(s) => (s.local.sym.clone(), s.local.ctxt, s.local.span),
            ImportSpecifier::Named(s) => (s.local.sym.clone(), s.local.ctxt, s.local.span),
        };
        if referenced.contains(&(sym, ctxt)) {
            return true;
        }
        if let Some(preserved) = preserved_spans {
            if span != DUMMY_SP && preserved.contains(&(span.lo, span.hi)) {
                return true;
            }
        }
        false
    });
}

fn dedup_side_effect_imports(module: &mut Module) {
    let sources_with_bindings: HashSet<String> = module
        .body
        .iter()
        .filter_map(|item| {
            let ModuleItem::ModuleDecl(ModuleDecl::Import(import)) = item else {
                return None;
            };
            if import.specifiers.is_empty() {
                None
            } else {
                Some(import_source_key(&import.src))
            }
        })
        .collect();

    let mut seen_side_effect_sources = HashSet::new();
    module.body.retain(|item| {
        let ModuleItem::ModuleDecl(ModuleDecl::Import(import)) = item else {
            return true;
        };
        if !import.specifiers.is_empty() {
            return true;
        }

        let source = import_source_key(&import.src);
        if sources_with_bindings.contains(&source) {
            return false;
        }
        seen_side_effect_sources.insert(source)
    });
}

fn import_source_key(src: &Str) -> String {
    src.value.as_str().unwrap_or("").to_string()
}