fallow_graph/resolve/

mod.rs

//! Import specifier resolution using `oxc_resolver`.
//!
//! Orchestrates the resolution pipeline: for every extracted module, resolves all
//! import specifiers in parallel (via rayon) to an [`ResolveResult`] — internal file,
//! npm package, external file, or unresolvable. The entry point is [`resolve_all_imports`].
//!
//! Resolution is split into submodules by import kind:
//! - `static_imports` — ES `import` declarations
//! - `dynamic_imports` — `import()` expressions and glob-based dynamic patterns
//! - `require_imports` — CommonJS `require()` calls
//! - `re_exports` — `export { x } from './y'` re-export sources
//! - `upgrades` — post-resolution pass fixing non-deterministic bare specifier results
//!
//! Handles tsconfig path aliases (auto-discovered per file), pnpm virtual store paths,
//! React Native platform extensions, and package.json `exports` subpath resolution with
//! output-to-source directory fallback.

mod dynamic_imports;
pub(crate) mod fallbacks;
mod path_info;
mod re_exports;
mod react_native;
mod require_imports;
mod specifier;
mod static_imports;
#[cfg(test)]
mod tests;
mod types;
mod upgrades;

pub use fallbacks::extract_package_name_from_node_modules_path;
pub use path_info::{
    extract_package_name, is_bare_specifier, is_path_alias, is_valid_package_name,
};
pub use types::{
    ResolveResult, ResolvedImport, ResolvedModule, ResolvedReExport, ResolvedSourceEdge,
};

use std::path::{Path, PathBuf};
use std::sync::Mutex;

use rayon::prelude::*;
use rustc_hash::{FxHashMap, FxHashSet};

use fallow_config::{AutoImportKind, AutoImportRule};
use fallow_types::discover::{DiscoveredFile, FileId};
use fallow_types::extract::{ImportInfo, ImportedName, ModuleInfo};
use oxc_span::Span;

use dynamic_imports::{resolve_dynamic_imports, resolve_dynamic_patterns};
use re_exports::resolve_re_exports;
use react_native::{build_condition_names, build_extensions};
use require_imports::resolve_require_imports;
use specifier::create_resolver;
use static_imports::resolve_static_imports;
use types::{PackageManifestInfo, ResolveContext};
use upgrades::apply_specifier_upgrades;

/// Resolve all imports across all modules in parallel.
#[must_use]
#[expect(
    clippy::too_many_arguments,
    reason = "resolver inputs come from disjoint sources (config, plugins, workspace, filesystem); \
              bundling them into a struct would be a cross-cutting refactor outside this task"
)]
pub fn resolve_all_imports(
    modules: &[ModuleInfo],
    files: &[DiscoveredFile],
    workspaces: &[fallow_config::WorkspaceInfo],
    active_plugins: &[String],
    path_aliases: &[(String, String)],
    auto_imports: &[AutoImportRule],
    scss_include_paths: &[PathBuf],
    static_dir_mappings: &[(PathBuf, String)],
    root: &Path,
    extra_conditions: &[String],
) -> Vec<ResolvedModule> {
    // Build workspace name → root index for pnpm store fallback.
    // Canonicalize roots to match path_to_id (which uses canonical paths).
    // Without this, macOS /var → /private/var and similar platform symlinks
    // cause workspace roots to mismatch canonical file paths.
    let canonical_ws_roots: Vec<PathBuf> = workspaces
        .par_iter()
        .map(|ws| dunce::canonicalize(&ws.root).unwrap_or_else(|_| ws.root.clone()))
        .collect();
    let workspace_roots: FxHashMap<&str, &Path> = workspaces
        .iter()
        .zip(canonical_ws_roots.iter())
        .map(|(ws, canonical)| (ws.name.as_str(), canonical.as_path()))
        .collect();
    let root_canonical = dunce::canonicalize(root).unwrap_or_else(|_| root.to_path_buf());
    let mut package_manifests = Vec::new();
    if let Ok(package_json) = fallow_config::PackageJson::load(&root.join("package.json")) {
        package_manifests.push(PackageManifestInfo {
            root: root.to_path_buf(),
            canonical_root: root_canonical,
            name: package_json.name.clone(),
            package_json,
        });
    }
    for (ws, canonical_root) in workspaces.iter().zip(canonical_ws_roots.iter()) {
        if let Ok(package_json) = fallow_config::PackageJson::load(&ws.root.join("package.json")) {
            package_manifests.push(PackageManifestInfo {
                root: ws.root.clone(),
                canonical_root: canonical_root.clone(),
                name: package_json.name.clone().or_else(|| Some(ws.name.clone())),
                package_json,
            });
        }
    }

    // Check if project root is already canonical (no symlinks in path).
    // When true, raw paths == canonical paths for files under root, so we can skip
    // the upfront bulk canonicalize() of all source files (21k+ syscalls on large projects).
    // A lazy CanonicalFallback handles the rare intra-project symlink case.
    let root_is_canonical = dunce::canonicalize(root).is_ok_and(|c| c == root);

    // Pre-compute canonical paths ONCE for all files in parallel (avoiding repeated syscalls).
    // Skipped when root is canonical — the lazy fallback below handles edge cases.
    let canonical_paths: Vec<PathBuf> = if root_is_canonical {
        Vec::new()
    } else {
        files
            .par_iter()
            .map(|f| dunce::canonicalize(&f.path).unwrap_or_else(|_| f.path.clone()))
            .collect()
    };

    // Primary path → FileId index. When root is canonical, uses raw paths (fast).
    // Otherwise uses pre-computed canonical paths (correct for all symlink configurations).
    let path_to_id: FxHashMap<&Path, FileId> = if root_is_canonical {
        files.iter().map(|f| (f.path.as_path(), f.id)).collect()
    } else {
        canonical_paths
            .iter()
            .enumerate()
            .map(|(idx, canonical)| (canonical.as_path(), files[idx].id))
            .collect()
    };

    // Also index by non-canonical path for fallback lookups
    let raw_path_to_id: FxHashMap<&Path, FileId> =
        files.iter().map(|f| (f.path.as_path(), f.id)).collect();

    // FileIds are sequential 0..n, so direct array indexing is faster than FxHashMap.
    let file_paths: Vec<&Path> = files.iter().map(|f| f.path.as_path()).collect();

    // Create resolvers ONCE and share across threads (oxc_resolver::Resolver is Send + Sync).
    let extensions = build_extensions(active_plugins);
    let condition_names = build_condition_names(active_plugins, extra_conditions);
    let resolver = create_resolver(active_plugins, extra_conditions);
    let mut style_conditions = extra_conditions.to_vec();
    style_conditions.push("style".to_string());
    let style_resolver = create_resolver(active_plugins, &style_conditions);

    // Lazy canonical fallback — only needed when root is canonical (path_to_id uses raw paths).
    // When root is NOT canonical, path_to_id already uses canonical paths, no fallback needed.
    let canonical_fallback = if root_is_canonical {
        Some(types::CanonicalFallback::new(files))
    } else {
        None
    };

    // Dedup set for broken-tsconfig warnings. See `ResolveContext::tsconfig_warned`.
    let tsconfig_warned: Mutex<FxHashSet<String>> = Mutex::new(FxHashSet::default());

    // Shared resolution context — avoids passing 6 arguments to every resolve_specifier call
    let ctx = ResolveContext {
        resolver: &resolver,
        style_resolver: &style_resolver,
        extensions: &extensions,
        path_to_id: &path_to_id,
        raw_path_to_id: &raw_path_to_id,
        workspace_roots: &workspace_roots,
        package_manifests: &package_manifests,
        condition_names: &condition_names,
        path_aliases,
        scss_include_paths,
        static_dir_mappings,
        root,
        canonical_fallback: canonical_fallback.as_ref(),
        tsconfig_warned: &tsconfig_warned,
    };

    // Resolve in parallel — shared resolver instance.
    // Each file resolves its own imports independently (no shared bare specifier cache).
    // oxc_resolver's internal caches (package.json, tsconfig, directory entries) are
    // shared across threads for performance.
    let mut resolved: Vec<ResolvedModule> = modules
        .par_iter()
        .filter_map(|module| {
            let Some(file_path) = file_paths.get(module.file_id.0 as usize) else {
                tracing::warn!(
                    file_id = module.file_id.0,
                    "Skipping module with unknown file_id during resolution"
                );
                return None;
            };

            let mut all_imports = resolve_static_imports(&ctx, file_path, &module.imports);
            all_imports.extend(resolve_require_imports(
                &ctx,
                file_path,
                &module.require_calls,
            ));

            let from_dir = if canonical_paths.is_empty() {
                // Root is canonical — raw paths are canonical
                file_path.parent().unwrap_or(file_path)
            } else {
                canonical_paths
                    .get(module.file_id.0 as usize)
                    .and_then(|p| p.parent())
                    .unwrap_or(file_path)
            };

            Some(ResolvedModule {
                file_id: module.file_id,
                path: file_path.to_path_buf(),
                exports: module.exports.clone(),
                re_exports: resolve_re_exports(&ctx, file_path, &module.re_exports),
                resolved_imports: all_imports,
                resolved_dynamic_imports: resolve_dynamic_imports(
                    &ctx,
                    file_path,
                    &module.dynamic_imports,
                ),
                resolved_dynamic_patterns: resolve_dynamic_patterns(
                    from_dir,
                    &module.dynamic_import_patterns,
                    &canonical_paths,
                    files,
                ),
                member_accesses: module.member_accesses.clone(),
                whole_object_uses: module.whole_object_uses.clone(),
                has_cjs_exports: module.has_cjs_exports,
                has_angular_component_template_url: module.has_angular_component_template_url,
                unused_import_bindings: module.unused_import_bindings.iter().cloned().collect(),
                type_referenced_import_bindings: module.type_referenced_import_bindings.clone(),
                value_referenced_import_bindings: module.value_referenced_import_bindings.clone(),
                namespace_object_aliases: module.namespace_object_aliases.clone(),
            })
        })
        .collect();

    apply_specifier_upgrades(&mut resolved);

    synthesize_auto_import_edges(
        &mut resolved,
        modules,
        auto_imports,
        &path_to_id,
        &raw_path_to_id,
    );

    resolved
}

/// Synthesize module-graph edges for convention auto-imports.
///
/// For each module, every captured `auto_import_candidates` name is matched
/// against the active plugins' auto-import table; on a hit a synthetic
/// [`ResolvedImport`] to the providing file is appended so the existing graph
/// builder credits the edge. Name collisions across files (e.g. `Comments`
/// declared in both `Comments.client.vue` and `Comments.server.vue`) over-credit
/// every match, keeping each provider reachable. Resolution is recomputed every
/// run from the live file index, so it is never folded into per-file caching.
/// See issue #704.
fn synthesize_auto_import_edges(
    resolved: &mut [ResolvedModule],
    modules: &[ModuleInfo],
    auto_imports: &[AutoImportRule],
    path_to_id: &FxHashMap<&Path, FileId>,
    raw_path_to_id: &FxHashMap<&Path, FileId>,
) {
    if auto_imports.is_empty() {
        return;
    }

    // Name -> providing files. Built from the live file index, so a rule whose
    // source file was not discovered is skipped rather than synthesizing a dangling edge.
    let mut table: FxHashMap<&str, Vec<(FileId, AutoImportKind)>> = FxHashMap::default();
    for rule in auto_imports {
        let source = rule.source.as_path();
        let Some(file_id) = raw_path_to_id
            .get(source)
            .or_else(|| path_to_id.get(source))
            .copied()
        else {
            continue;
        };
        table
            .entry(rule.name.as_str())
            .or_default()
            .push((file_id, rule.kind));
    }
    if table.is_empty() {
        return;
    }

    // Captured candidate names keyed by the file that referenced them.
    let candidates: FxHashMap<FileId, &[String]> = modules
        .iter()
        .filter(|module| !module.auto_import_candidates.is_empty())
        .map(|module| (module.file_id, module.auto_import_candidates.as_slice()))
        .collect();
    if candidates.is_empty() {
        return;
    }

    for module in resolved.iter_mut() {
        let Some(names) = candidates.get(&module.file_id) else {
            continue;
        };
        for name in *names {
            let Some(targets) = table.get(name.as_str()) else {
                continue;
            };
            for (target_id, kind) in targets {
                if *target_id == module.file_id {
                    continue;
                }
                module.resolved_imports.push(ResolvedImport {
                    info: synthetic_auto_import_info(name, *kind),
                    target: ResolveResult::InternalModule(*target_id),
                });
            }
        }
    }
}

/// Build a synthetic [`ImportInfo`] for a convention auto-import. Component and
/// default kinds credit the default export; named kinds credit the named export.
fn synthetic_auto_import_info(name: &str, kind: AutoImportKind) -> ImportInfo {
    let imported_name = match kind {
        AutoImportKind::Named => ImportedName::Named(name.to_string()),
        AutoImportKind::Default | AutoImportKind::DefaultComponent => ImportedName::Default,
    };
    ImportInfo {
        source: format!("<auto-import:{name}>"),
        imported_name,
        local_name: name.to_string(),
        is_type_only: false,
        from_style: false,
        span: Span::default(),
        source_span: Span::default(),
    }
}