Skip to main content

fallow_graph/resolve/
types.rs

1//! Type definitions and constants for import resolution.
2
3use std::path::{Path, PathBuf};
4use std::sync::{Arc, Mutex};
5
6use dashmap::DashMap;
7use rustc_hash::{FxBuildHasher, FxHashMap, FxHashSet};
8use serde_json::Value;
9
10use fallow_config::TsconfigOutputMap;
11use fallow_types::discover::FileId;
12
13use crate::read_trace::Resolver;
14
15/// Result of resolving an import specifier.
16#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
17pub enum ResolveResult {
18    /// Resolved to a file within the project.
19    InternalModule(FileId),
20    /// Resolved from a CommonJS `require()` to a file within the project.
21    CommonJsInternalModule(FileId),
22    /// Resolved to a project file through a framework convention auto-import.
23    SyntheticAutoImport(FileId),
24    /// Resolved to a workspace or self package source file while preserving
25    /// dependency usage for package accounting.
26    InternalPackageModule {
27        /// Internal source file reached by the package map.
28        file_id: FileId,
29        /// Package name that was used in the import specifier.
30        package_name: String,
31    },
32    /// Resolved from a CommonJS `require()` to workspace or self-package source.
33    CommonJsInternalPackageModule {
34        /// Internal source file reached by the package map.
35        file_id: FileId,
36        /// Package name used in the require specifier.
37        package_name: String,
38    },
39    /// Resolved to a file outside the project (`node_modules`, `.json`, etc.).
40    ExternalFile(PathBuf),
41    /// Bare specifier — an npm package.
42    NpmPackage(String),
43    /// Bare npm package referenced through CommonJS `require()`.
44    CommonJsNpmPackage(String),
45    /// Could not resolve.
46    Unresolvable(String),
47}
48
49impl ResolveResult {
50    /// Return the target file for any project-internal result.
51    #[must_use]
52    pub const fn internal_file_id(&self) -> Option<FileId> {
53        match self {
54            Self::InternalModule(file_id)
55            | Self::CommonJsInternalModule(file_id)
56            | Self::SyntheticAutoImport(file_id)
57            | Self::InternalPackageModule { file_id, .. }
58            | Self::CommonJsInternalPackageModule { file_id, .. } => Some(*file_id),
59            Self::ExternalFile(_)
60            | Self::NpmPackage(_)
61            | Self::CommonJsNpmPackage(_)
62            | Self::Unresolvable(_) => None,
63        }
64    }
65
66    /// Return whether this edge was synthesized from framework auto-import conventions.
67    #[must_use]
68    pub const fn is_synthetic_auto_import(&self) -> bool {
69        matches!(self, Self::SyntheticAutoImport(_))
70    }
71
72    /// Return whether this edge originated from CommonJS `require()`.
73    #[must_use]
74    pub(crate) const fn is_commonjs_require(&self) -> bool {
75        matches!(
76            self,
77            Self::CommonJsInternalModule(_)
78                | Self::CommonJsInternalPackageModule { .. }
79                | Self::CommonJsNpmPackage(_)
80        )
81    }
82
83    /// Return whether this target is an unresolved bare package edge.
84    #[must_use]
85    pub const fn is_bare_package(&self) -> bool {
86        matches!(self, Self::NpmPackage(_) | Self::CommonJsNpmPackage(_))
87    }
88
89    /// Retain CommonJS provenance on targets that can participate in upgrades.
90    #[must_use]
91    pub(crate) fn into_commonjs_require(self) -> Self {
92        match self {
93            Self::InternalModule(file_id) => Self::CommonJsInternalModule(file_id),
94            Self::InternalPackageModule {
95                file_id,
96                package_name,
97            } => Self::CommonJsInternalPackageModule {
98                file_id,
99                package_name,
100            },
101            Self::NpmPackage(package_name) => Self::CommonJsNpmPackage(package_name),
102            other => other,
103        }
104    }
105
106    /// Return the package name that should receive dependency usage credit.
107    #[must_use]
108    pub fn package_usage_name(&self) -> Option<&str> {
109        match self {
110            Self::InternalPackageModule { package_name, .. }
111            | Self::CommonJsInternalPackageModule { package_name, .. }
112            | Self::NpmPackage(package_name)
113            | Self::CommonJsNpmPackage(package_name) => Some(package_name),
114            Self::InternalModule(_)
115            | Self::CommonJsInternalModule(_)
116            | Self::SyntheticAutoImport(_)
117            | Self::ExternalFile(_)
118            | Self::Unresolvable(_) => None,
119        }
120    }
121}
122
123/// Resolver output for one extracted project.
124#[derive(Debug, Default)]
125pub struct ResolvedProject {
126    /// Modules with every ordinary import and re-export resolved.
127    pub modules: Vec<ResolvedModule>,
128    /// Proven test-time replacements whose targets resolve inside the project.
129    pub replaced_module_targets: Vec<ResolvedReplacedModuleTarget>,
130    /// Deterministic work counts of the resolution that built this project.
131    /// Zero for a project restored from the graph cache.
132    pub work: super::ResolveWork,
133    /// The paths below the root that the resolution checked and did not
134    /// find. A file that appears at one of them can change a resolution, so
135    /// the graph cache stores them (see [`crate::missed_probes`]).
136    pub missed_probes: crate::missed_probes::MissedProbes,
137    /// The package manifests below `node_modules` that the resolution read,
138    /// sorted. A path above the root has `../` steps. The graph cache keys
139    /// the versions of the Bun installs among them (see
140    /// [`crate::installed_versions`]). Empty for a project restored from the
141    /// graph cache.
142    pub package_manifests: Vec<String>,
143}
144
145/// One project-internal module replacement resolved from its declaring source file.
146#[derive(Debug, Clone, Copy, PartialEq, Eq)]
147pub struct ResolvedReplacedModuleTarget {
148    /// File that declares the replacement fact.
149    pub source_file: FileId,
150    /// Project file replaced for this source's test-root traversal.
151    pub target_file: FileId,
152}
153
154/// A resolved import with its target.
155#[derive(Debug, Clone)]
156pub struct ResolvedImport {
157    /// The original import information.
158    pub info: fallow_types::extract::ImportInfo,
159    /// Where the import resolved to.
160    pub target: ResolveResult,
161}
162
163/// A resolved re-export with its target.
164#[derive(Debug, Clone)]
165pub struct ResolvedReExport {
166    /// The original re-export information.
167    pub info: fallow_types::extract::ReExportInfo,
168    /// Where the re-export source resolved to.
169    pub target: ResolveResult,
170}
171
172/// Any source-bearing module edge that resolves one literal specifier.
173pub enum ResolvedSourceEdge<'a> {
174    /// Static or literal dynamic import edge.
175    Import(&'a ResolvedImport),
176    /// Re-export source edge.
177    ReExport(&'a ResolvedReExport),
178}
179
180impl<'a> ResolvedSourceEdge<'a> {
181    /// Return the original source specifier.
182    #[must_use]
183    pub fn source_specifier(&self) -> &'a str {
184        match self {
185            Self::Import(import) => &import.info.source,
186            Self::ReExport(re_export) => &re_export.info.source,
187        }
188    }
189
190    /// Return the resolved target.
191    #[must_use]
192    pub const fn target(&self) -> &'a ResolveResult {
193        match self {
194            Self::Import(import) => &import.target,
195            Self::ReExport(re_export) => &re_export.target,
196        }
197    }
198
199    /// Return whether this edge is type-only.
200    #[must_use]
201    pub const fn is_type_only(&self) -> bool {
202        match self {
203            Self::Import(import) => import.info.is_type_only,
204            Self::ReExport(re_export) => re_export.info.is_type_only,
205        }
206    }
207
208    /// Return the span of the full import or re-export declaration.
209    #[must_use]
210    pub const fn span(&self) -> oxc_span::Span {
211        match self {
212            Self::Import(import) => import.info.span,
213            Self::ReExport(re_export) => re_export.info.span,
214        }
215    }
216
217    /// Return the source literal span when the extractor has one.
218    #[must_use]
219    pub const fn source_span(&self) -> oxc_span::Span {
220        match self {
221            Self::Import(import) => import.info.source_span,
222            Self::ReExport(re_export) => re_export.info.source_span,
223        }
224    }
225
226    /// Return the span of the enclosing statement.
227    ///
228    /// Imports do not record a statement span, so their per-binding
229    /// declaration span is the closest available statement anchor.
230    #[must_use]
231    pub const fn statement_span(&self) -> oxc_span::Span {
232        match self {
233            Self::Import(import) => import.info.span,
234            Self::ReExport(re_export) => re_export.info.statement_span,
235        }
236    }
237}
238
239/// Fully resolved module with all imports mapped to targets.
240///
241/// The `Arc<[T]>` fields are refcounted views of the same allocations owned by
242/// the source [`fallow_types::extract::ModuleInfo`], not copies; see the note
243/// on that struct.
244#[derive(Debug, Clone)]
245pub struct ResolvedModule {
246    /// Unique file identifier.
247    pub file_id: FileId,
248    /// Absolute path to the module file.
249    pub path: PathBuf,
250    /// All export declarations in this module.
251    pub exports: Arc<[fallow_types::extract::ExportInfo]>,
252    /// All re-exports with resolved targets.
253    pub re_exports: Vec<ResolvedReExport>,
254    /// All static imports with resolved targets.
255    pub resolved_imports: Vec<ResolvedImport>,
256    /// All dynamic imports with resolved targets.
257    pub resolved_dynamic_imports: Vec<ResolvedImport>,
258    /// Dynamic import patterns and their matched target files.
259    pub resolved_dynamic_patterns: Vec<(fallow_types::extract::DynamicImportPattern, Vec<FileId>)>,
260    /// Static member accesses (e.g., `Status.Active`).
261    pub member_accesses: Arc<[fallow_types::extract::MemberAccess]>,
262    /// Typed semantic facts produced by extraction for cross-layer analysis.
263    pub semantic_facts: Arc<[fallow_types::extract::SemanticFact]>,
264    /// Identifiers used as whole objects (Object.values, for..in, spread, etc.).
265    pub whole_object_uses: Arc<[String]>,
266    /// Whether this module uses `CommonJS` exports.
267    pub has_cjs_exports: bool,
268    /// Whether this module declares at least one Angular `@Component({
269    /// templateUrl: ... })` decorator. Mirrors `ModuleInfo.has_angular_component_template_url`;
270    /// see that field for the contract this gate enforces.
271    pub has_angular_component_template_url: bool,
272    /// Local names of import bindings that are never referenced in this file.
273    pub unused_import_bindings: FxHashSet<String>,
274    /// Local import bindings referenced from type positions.
275    pub type_referenced_import_bindings: Vec<String>,
276    /// Local import bindings referenced from runtime/value positions.
277    pub value_referenced_import_bindings: Vec<String>,
278    /// Namespace-import aliases re-exported through an object literal.
279    /// See `fallow_types::extract::NamespaceObjectAlias` for the shape.
280    pub namespace_object_aliases: Vec<fallow_types::extract::NamespaceObjectAlias>,
281    /// Exported free-function factories that provably return one class instance.
282    /// See `fallow_types::extract::FactoryReturnExport` and issue #1441 (Part A).
283    pub exported_factory_returns: Arc<[fallow_types::extract::FactoryReturnExport]>,
284    /// Object-literal factory-return shapes (`export function createUi() {
285    /// return { orders: factory.ordersPage } }`), threaded from `ModuleInfo` for
286    /// the analyze-layer member-crediting join. See issue #1858.
287    pub exported_factory_return_object_shapes:
288        Arc<[fallow_types::extract::FactoryReturnObjectShapeExport]>,
289    /// Named-type property types declared by this module's top-level interfaces
290    /// and type-literal aliases. See `fallow_types::extract::TypeMemberTypeEntry`
291    /// and issue #1785.
292    pub type_member_types: Arc<[fallow_types::extract::TypeMemberTypeEntry]>,
293    /// Unresolved bare specifiers whose package `exports` entry names only
294    /// paths that do not exist, in specifier order. The resolver records the
295    /// paths so that the unresolved-import check can test them against the
296    /// ignore rules of the repository. No edge points at these paths.
297    pub missing_export_targets: Vec<MissingExportTarget>,
298}
299
300/// A plugin path alias that applies only to the files of one workspace package.
301///
302/// A framework alias such as SvelteKit `$lib` or Nuxt `~/` maps to a directory
303/// of the package that owns the framework config. Two packages can declare the
304/// same prefix, so the resolver must apply an alias only to an importing file
305/// inside the package that declared it.
306#[derive(Debug, Clone, PartialEq, Eq)]
307pub struct ScopedPathAlias {
308    /// The workspace root, relative to the project root. A workspace outside
309    /// the project tree keeps its absolute path.
310    pub scope: String,
311    /// The import prefix, for example `$lib/`.
312    pub prefix: String,
313    /// The replacement directory, relative to the project root.
314    pub replacement: String,
315}
316
317/// The missing paths that the `exports` map of a project package names for
318/// one unresolved bare specifier.
319#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
320pub struct MissingExportTarget {
321    /// The import specifier, for example `store/enums`.
322    pub specifier: String,
323    /// The absolute paths that the matched `exports` entry names.
324    pub paths: Vec<PathBuf>,
325}
326
327impl Default for ResolvedModule {
328    fn default() -> Self {
329        Self {
330            file_id: FileId(0),
331            path: PathBuf::new(),
332            exports: Arc::default(),
333            re_exports: vec![],
334            resolved_imports: vec![],
335            resolved_dynamic_imports: vec![],
336            resolved_dynamic_patterns: vec![],
337            member_accesses: Arc::default(),
338            semantic_facts: Arc::default(),
339            whole_object_uses: Arc::default(),
340            has_cjs_exports: false,
341            has_angular_component_template_url: false,
342            unused_import_bindings: FxHashSet::default(),
343            type_referenced_import_bindings: vec![],
344            value_referenced_import_bindings: vec![],
345            namespace_object_aliases: vec![],
346            exported_factory_returns: Arc::default(),
347            exported_factory_return_object_shapes: Arc::default(),
348            type_member_types: Arc::default(),
349            missing_export_targets: vec![],
350        }
351    }
352}
353
354impl ResolvedModule {
355    /// Iterate over all concrete resolved imports in source order buckets.
356    ///
357    /// Includes static `import`/`require` edges and literal dynamic `import()`
358    /// edges. Dynamic import patterns are intentionally excluded because they
359    /// resolve to sets of files rather than single import specifiers.
360    pub fn all_resolved_imports(&self) -> impl Iterator<Item = &ResolvedImport> {
361        self.resolved_imports
362            .iter()
363            .chain(self.resolved_dynamic_imports.iter())
364    }
365
366    /// Iterate over every literal source edge that has one resolved target.
367    ///
368    /// Includes static imports, literal dynamic imports, and re-export sources.
369    /// Dynamic import patterns are excluded because they resolve to sets of
370    /// files rather than single import specifiers.
371    pub fn all_resolved_source_edges(&self) -> impl Iterator<Item = ResolvedSourceEdge<'_>> {
372        self.resolved_imports
373            .iter()
374            .map(ResolvedSourceEdge::Import)
375            .chain(
376                self.resolved_dynamic_imports
377                    .iter()
378                    .map(ResolvedSourceEdge::Import),
379            )
380            .chain(self.re_exports.iter().map(ResolvedSourceEdge::ReExport))
381    }
382}
383
384/// Shared context for resolving import specifiers.
385///
386/// Groups the immutable lookup tables and caches that are shared across all
387/// `resolve_specifier` calls within a single `resolve_all_imports` invocation.
388pub(super) struct ResolveContext<'a> {
389    /// The oxc_resolver instance (configured once, shared across threads).
390    pub resolver: &'a Resolver,
391    /// Script and JSON extension inference, with explicit asset targets intact.
392    /// Shares the broad resolver's filesystem and PnP cache.
393    pub script_resolver: &'a Resolver,
394    /// CSS-only resolver with package.json `sass` and `style` conditions enabled.
395    /// Used only for stylesheet package subpaths so JS/TS imports do not
396    /// accidentally prefer CSS export branches.
397    pub style_resolver: &'a Resolver,
398    /// Ordered extension list used by the resolver.
399    pub extensions: &'a [String],
400    /// Canonical path → FileId lookup (raw paths when root is canonical).
401    pub path_to_id: &'a FxHashMap<&'a Path, FileId>,
402    /// Raw (non-canonical) path → FileId lookup.
403    pub raw_path_to_id: &'a FxHashMap<&'a Path, FileId>,
404    /// Workspace name → canonical root path.
405    pub workspace_roots: &'a FxHashMap<&'a str, &'a Path>,
406    /// Package manifests for the root package and workspace packages.
407    pub package_manifests: &'a [PackageManifestInfo],
408    /// Whether any package scope declared a Deno import map; false skips map
409    /// lookup per import.
410    pub has_deno_import_maps: bool,
411    /// Ordered package condition names matching the resolver configuration.
412    pub condition_names: &'a [String],
413    /// Plugin-provided path aliases (prefix, replacement).
414    pub path_aliases: &'a [(String, String)],
415    /// Plugin-provided path aliases that apply only inside one workspace.
416    pub scoped_path_aliases: &'a [ScopedPathAlias],
417    /// Absolute directories to search when resolving bare SCSS/Sass
418    /// `@import` / `@use` specifiers. Populated from Angular's
419    /// `stylePreprocessorOptions.includePaths` and equivalent settings.
420    pub scss_include_paths: &'a [PathBuf],
421    /// Static directory URL mappings from framework config.
422    /// Each tuple is `(absolute_source_dir, normalized_url_mount)`.
423    pub static_dir_mappings: &'a [(PathBuf, String)],
424    /// Mounts a framework serves for the whole project, reachable from any HTML
425    /// document, unlike `static_dir_mappings`, which stays scoped to the tool
426    /// whose config declared it.
427    pub framework_static_dir_mappings: &'a [(PathBuf, String)],
428    /// Project root directory.
429    pub root: &'a Path,
430    /// Lazy canonical path → FileId fallback for intra-project symlinks.
431    /// Only initialized on first miss when root is canonical. `None` when
432    /// path_to_id already uses canonical paths (root is not canonical).
433    pub canonical_fallback: Option<&'a CanonicalFallback<'a>>,
434    /// Dedup set for broken-tsconfig warnings. Emits one `tracing::warn!`
435    /// per unique error message instead of spamming the log with one
436    /// warning per affected file. Shared across all parallel resolver
437    /// threads via `Mutex`. Empty and unused when no tsconfig errors occur.
438    pub tsconfig_warned: &'a Mutex<FxHashSet<String>>,
439    /// Per-analysis cache for local tsconfig discovery and JSON parsing.
440    /// Import resolution calls these fallbacks for every unresolved or
441    /// tsconfig-poisoned specifier, so keeping it session-local avoids
442    /// repeated filesystem work without risking stale data across runs.
443    pub tsconfig_cache: &'a TsconfigCache,
444    /// Per-analysis cache of `dunce::canonicalize` results keyed by resolved
445    /// path. Every import resolving to a `node_modules` / output-dir / symlinked
446    /// target is realpath'd during classification, and the same package path is
447    /// re-canonicalized for every file that imports the package. The result is a
448    /// pure function of the path's on-disk state (constant within a run), so the
449    /// cache is session-local for watch-mode safety.
450    pub canonicalize_cache: &'a CanonicalizeCache,
451}
452
453/// Session-local cache of `dunce::canonicalize` results keyed by input path.
454#[derive(Default)]
455pub(super) struct CanonicalizeCache {
456    map: DashMap<PathBuf, Option<PathBuf>, FxBuildHasher>,
457}
458
459impl CanonicalizeCache {
460    /// Return the cached `dunce::canonicalize(path)` outcome, computing it on
461    /// first miss. `None` (a path that fails to canonicalize) is cached too so a
462    /// repeated probe of the same missing path does not re-issue the syscall.
463    pub fn get(&self, path: &Path) -> Option<PathBuf> {
464        if let Some(value) = self.map.get(path) {
465            return value.clone();
466        }
467        let value = crate::read_trace::canonicalize(path).ok();
468        self.map.insert(path.to_path_buf(), value.clone());
469        value
470    }
471
472    /// Number of distinct paths this cache canonicalized. Two threads that
473    /// miss the same path at once can both call the filesystem, so this is the
474    /// work the run needs, not an exact syscall count.
475    pub fn distinct_paths(&self) -> usize {
476        self.map.len()
477    }
478}
479
480/// Session-local cache for tsconfig helper lookups used during import resolution.
481#[derive(Default)]
482pub(super) struct TsconfigCache {
483    json: DashMap<PathBuf, Option<Arc<Value>>, FxBuildHasher>,
484    chains: DashMap<PathBuf, Arc<[PathBuf]>, FxBuildHasher>,
485    output_maps: DashMap<PathBuf, Arc<TsconfigOutputMap>, FxBuildHasher>,
486}
487
488impl TsconfigCache {
489    /// Return a cached parsed tsconfig JSON value, loading it on first miss.
490    ///
491    /// Handing back an [`Arc`] rather than a clone matters: a tsconfig chain is
492    /// walked several times per import specifier, and deep-copying every parsed
493    /// document on each hop dominated resolution on large project-reference
494    /// graphs.
495    pub fn json(
496        &self,
497        path: &Path,
498        load: impl FnOnce(&Path) -> Option<Value>,
499    ) -> Option<Arc<Value>> {
500        if let Some(value) = self.json.get(path) {
501            return value.clone();
502        }
503
504        let value = load(path).map(Arc::new);
505        self.json.insert(path.to_path_buf(), value.clone());
506        value
507    }
508
509    /// Return the cached tsconfig chain for a source file, if one exists.
510    pub fn chain(&self, from_file: &Path) -> Option<Arc<[PathBuf]>> {
511        self.chains.get(from_file).map(|entry| Arc::clone(&entry))
512    }
513
514    /// Store the computed tsconfig chain for a source file.
515    pub fn store_chain(&self, from_file: &Path, chain: Arc<[PathBuf]>) {
516        self.chains.insert(from_file.to_path_buf(), chain);
517    }
518
519    /// Return the output-to-source map of a package root, building it on
520    /// first miss. Each package root reads its tsconfig files once per run.
521    pub fn output_map(&self, package_root: &Path) -> Arc<TsconfigOutputMap> {
522        if let Some(map) = self.output_maps.get(package_root) {
523            return Arc::clone(&map);
524        }
525        let map = Arc::new(TsconfigOutputMap::from_project(package_root));
526        self.output_maps
527            .insert(package_root.to_path_buf(), Arc::clone(&map));
528        map
529    }
530}
531
532/// Package manifest data used by source fallbacks.
533#[derive(Debug, Clone)]
534pub(super) struct PackageManifestInfo {
535    /// Package root path as discovered from the workspace tree.
536    pub root: PathBuf,
537    /// Canonical package root path for node_modules symlink comparisons.
538    pub canonical_root: PathBuf,
539    /// Parsed package name.
540    pub name: Option<String>,
541    /// Parsed package.json fields.
542    pub package_json: fallow_config::PackageJson,
543    /// Effective Deno import map for this package scope.
544    pub deno_import_map: Vec<DenoImportMapEntry>,
545}
546
547/// One effective Deno import-map entry with the directory that declared it.
548#[derive(Debug, Clone)]
549pub(super) struct DenoImportMapEntry {
550    pub key: String,
551    pub target: String,
552    pub declaring_dir: PathBuf,
553}
554
555/// Thread-safe lazy canonical path index, built on first access.
556pub(super) struct CanonicalFallback<'a> {
557    files: &'a [fallow_types::discover::DiscoveredFile],
558    map: std::sync::OnceLock<FxHashMap<std::path::PathBuf, FileId>>,
559}
560
561impl<'a> CanonicalFallback<'a> {
562    pub const fn new(files: &'a [fallow_types::discover::DiscoveredFile]) -> Self {
563        Self {
564            files,
565            map: std::sync::OnceLock::new(),
566        }
567    }
568
569    /// Look up a canonical path, lazily building the index on first call.
570    pub fn get(&self, canonical: &Path) -> Option<FileId> {
571        let map = self.map.get_or_init(|| {
572            super::work::note_canonicalize(self.files.len() as u64);
573            tracing::debug!(
574                "intra-project symlinks detected, building canonical path index ({} files)",
575                self.files.len()
576            );
577            self.files
578                .iter()
579                .filter_map(|f| {
580                    crate::read_trace::canonicalize(&f.path)
581                        .ok()
582                        .map(|canonical| (canonical, f.id))
583                })
584                .collect()
585        });
586        map.get(canonical).copied()
587    }
588}
589
590#[cfg(all(test, not(miri)))]
591mod tests {
592    use super::*;
593    use fallow_types::discover::DiscoveredFile;
594
595    #[test]
596    fn canonical_fallback_returns_none_for_empty_files() {
597        let files: Vec<DiscoveredFile> = vec![];
598        let fallback = CanonicalFallback::new(&files);
599        assert!(fallback.get(Path::new("/nonexistent")).is_none());
600    }
601
602    #[test]
603    fn canonical_fallback_finds_existing_file() {
604        let temp = std::env::temp_dir().join("fallow-test-canonical-fallback");
605        let _ = std::fs::create_dir_all(&temp);
606        let test_file = temp.join("test.ts");
607        std::fs::write(&test_file, "").unwrap();
608
609        let files = vec![DiscoveredFile {
610            id: FileId(42),
611            path: test_file.clone(),
612            size_bytes: 0,
613        }];
614        let fallback = CanonicalFallback::new(&files);
615
616        let canonical = dunce::canonicalize(&test_file).unwrap();
617        assert_eq!(fallback.get(&canonical), Some(FileId(42)));
618
619        assert_eq!(fallback.get(&canonical), Some(FileId(42)));
620
621        let _ = std::fs::remove_dir_all(&temp);
622    }
623
624    #[test]
625    fn canonical_fallback_returns_none_for_missing_path() {
626        let temp = std::env::temp_dir().join("fallow-test-canonical-miss");
627        let _ = std::fs::create_dir_all(&temp);
628        let test_file = temp.join("exists.ts");
629        std::fs::write(&test_file, "").unwrap();
630
631        let files = vec![DiscoveredFile {
632            id: FileId(1),
633            path: test_file,
634            size_bytes: 0,
635        }];
636        let fallback = CanonicalFallback::new(&files);
637        assert!(fallback.get(Path::new("/nonexistent/file.ts")).is_none());
638
639        let _ = std::fs::remove_dir_all(&temp);
640    }
641
642    #[test]
643    fn tsconfig_cache_loads_once_and_shares_the_parsed_document() {
644        let cache = TsconfigCache::default();
645        let path = Path::new("/project/tsconfig.json");
646        let loads = std::sync::atomic::AtomicUsize::new(0);
647        let load = |_: &Path| {
648            loads.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
649            Some(serde_json::json!({ "compilerOptions": {} }))
650        };
651
652        let first = cache.json(path, load).unwrap();
653        let second = cache.json(path, load).unwrap();
654
655        assert_eq!(loads.load(std::sync::atomic::Ordering::SeqCst), 1);
656        assert!(
657            Arc::ptr_eq(&first, &second),
658            "repeat reads must share one allocation rather than deep-copy"
659        );
660    }
661
662    /// An unreadable tsconfig is cached as a miss so the read is not retried.
663    #[test]
664    fn tsconfig_cache_caches_a_failed_load() {
665        let cache = TsconfigCache::default();
666        let path = Path::new("/project/missing.json");
667        let loads = std::sync::atomic::AtomicUsize::new(0);
668        let load = |_: &Path| {
669            loads.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
670            None
671        };
672
673        assert!(cache.json(path, load).is_none());
674        assert!(cache.json(path, load).is_none());
675        assert_eq!(loads.load(std::sync::atomic::Ordering::SeqCst), 1);
676    }
677
678    #[test]
679    fn tsconfig_cache_round_trips_a_chain() {
680        let cache = TsconfigCache::default();
681        let from_file = Path::new("/project/src/index.ts");
682        assert!(cache.chain(from_file).is_none());
683
684        let chain: Arc<[PathBuf]> = vec![PathBuf::from("/project/tsconfig.json")].into();
685        cache.store_chain(from_file, Arc::clone(&chain));
686
687        assert!(Arc::ptr_eq(&cache.chain(from_file).unwrap(), &chain));
688    }
689
690    /// Both caches are read concurrently by rayon workers during resolution.
691    #[test]
692    fn tsconfig_cache_is_consistent_under_concurrent_access() {
693        const THREADS: usize = 8;
694        const PATHS: usize = 32;
695
696        let cache = TsconfigCache::default();
697        std::thread::scope(|scope| {
698            for _ in 0..THREADS {
699                scope.spawn(|| {
700                    for index in 0..PATHS {
701                        let path = PathBuf::from(format!("/project/{index}/tsconfig.json"));
702                        let json = cache
703                            .json(&path, |_| Some(serde_json::json!({ "index": index })))
704                            .unwrap();
705                        assert_eq!(json["index"], index);
706                    }
707                });
708            }
709        });
710    }
711
712    #[test]
713    fn canonicalize_cache_returns_the_same_result_on_repeat_lookups() {
714        let temp = tempfile::tempdir().expect("create temp dir");
715        let file = temp.path().join("file.ts");
716        std::fs::write(&file, "").unwrap();
717
718        let cache = CanonicalizeCache::default();
719        let expected = dunce::canonicalize(&file).ok();
720        assert_eq!(cache.get(&file), expected);
721        assert_eq!(cache.get(&file), expected);
722        assert!(cache.get(&temp.path().join("missing.ts")).is_none());
723    }
724
725    #[test]
726    fn commonjs_provenance_wraps_internal_and_bare_package_targets() {
727        assert!(matches!(
728            ResolveResult::InternalModule(FileId(4)).into_commonjs_require(),
729            ResolveResult::CommonJsInternalModule(FileId(4))
730        ));
731        assert!(matches!(
732            ResolveResult::InternalPackageModule {
733                file_id: FileId(5),
734                package_name: "pkg".to_string(),
735            }
736            .into_commonjs_require(),
737            ResolveResult::CommonJsInternalPackageModule {
738                file_id: FileId(5),
739                package_name,
740            } if package_name == "pkg"
741        ));
742        assert!(matches!(
743            ResolveResult::NpmPackage("pkg".to_string()).into_commonjs_require(),
744            ResolveResult::CommonJsNpmPackage(package_name) if package_name == "pkg"
745        ));
746    }
747}
748
749/// Known output directory names that may appear in exports map targets.
750/// When an exports map points to `./dist/utils.js`, we try replacing these
751/// prefixes with `src/` (the conventional source directory) to find the tracked
752/// source file.
753pub const OUTPUT_DIRS: &[&str] = &["dist", "build", "out", "esm", "cjs"];
754
755/// Output directory names that map to `src/` only when the target is absent.
756///
757/// Many TypeScript libraries build `src/` into `lib/`, but older packages keep
758/// hand-written source in `lib/`. Thus `lib` maps to `src/` only when the
759/// `lib/` target is absent from the analyzed file set (for example in a fresh
760/// clone before the build, or a gitignored build), and only for package
761/// manifest targets. A `lib/` file in the file set always wins, and generic
762/// relative imports never use this list.
763pub const MISSING_ONLY_OUTPUT_DIRS: &[&str] = &["lib"];
764
765/// Source extensions to try when mapping a built output file back to source.
766pub const SOURCE_EXTS: &[&str] = &["ts", "tsx", "mts", "cts", "js", "jsx", "mjs", "cjs"];
767
768/// React Native platform extension prefixes.
769/// Metro resolves platform-specific files (e.g., `./foo` -> `./foo.web.tsx` on web).
770pub const RN_PLATFORM_PREFIXES: &[&str] = &[".web", ".ios", ".android", ".native"];