1use 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#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
17pub enum ResolveResult {
18 InternalModule(FileId),
20 CommonJsInternalModule(FileId),
22 SyntheticAutoImport(FileId),
24 InternalPackageModule {
27 file_id: FileId,
29 package_name: String,
31 },
32 CommonJsInternalPackageModule {
34 file_id: FileId,
36 package_name: String,
38 },
39 ExternalFile(PathBuf),
41 NpmPackage(String),
43 CommonJsNpmPackage(String),
45 Unresolvable(String),
47}
48
49impl ResolveResult {
50 #[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 #[must_use]
68 pub const fn is_synthetic_auto_import(&self) -> bool {
69 matches!(self, Self::SyntheticAutoImport(_))
70 }
71
72 #[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 #[must_use]
85 pub const fn is_bare_package(&self) -> bool {
86 matches!(self, Self::NpmPackage(_) | Self::CommonJsNpmPackage(_))
87 }
88
89 #[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 #[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#[derive(Debug, Default)]
125pub struct ResolvedProject {
126 pub modules: Vec<ResolvedModule>,
128 pub replaced_module_targets: Vec<ResolvedReplacedModuleTarget>,
130 pub work: super::ResolveWork,
133 pub missed_probes: crate::missed_probes::MissedProbes,
137 pub package_manifests: Vec<String>,
143}
144
145#[derive(Debug, Clone, Copy, PartialEq, Eq)]
147pub struct ResolvedReplacedModuleTarget {
148 pub source_file: FileId,
150 pub target_file: FileId,
152}
153
154#[derive(Debug, Clone)]
156pub struct ResolvedImport {
157 pub info: fallow_types::extract::ImportInfo,
159 pub target: ResolveResult,
161}
162
163#[derive(Debug, Clone)]
165pub struct ResolvedReExport {
166 pub info: fallow_types::extract::ReExportInfo,
168 pub target: ResolveResult,
170}
171
172pub enum ResolvedSourceEdge<'a> {
174 Import(&'a ResolvedImport),
176 ReExport(&'a ResolvedReExport),
178}
179
180impl<'a> ResolvedSourceEdge<'a> {
181 #[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 #[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 #[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 #[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 #[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 #[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#[derive(Debug, Clone)]
245pub struct ResolvedModule {
246 pub file_id: FileId,
248 pub path: PathBuf,
250 pub exports: Arc<[fallow_types::extract::ExportInfo]>,
252 pub re_exports: Vec<ResolvedReExport>,
254 pub resolved_imports: Vec<ResolvedImport>,
256 pub resolved_dynamic_imports: Vec<ResolvedImport>,
258 pub resolved_dynamic_patterns: Vec<(fallow_types::extract::DynamicImportPattern, Vec<FileId>)>,
260 pub member_accesses: Arc<[fallow_types::extract::MemberAccess]>,
262 pub semantic_facts: Arc<[fallow_types::extract::SemanticFact]>,
264 pub whole_object_uses: Arc<[String]>,
266 pub has_cjs_exports: bool,
268 pub has_angular_component_template_url: bool,
272 pub unused_import_bindings: FxHashSet<String>,
274 pub type_referenced_import_bindings: Vec<String>,
276 pub value_referenced_import_bindings: Vec<String>,
278 pub namespace_object_aliases: Vec<fallow_types::extract::NamespaceObjectAlias>,
281 pub exported_factory_returns: Arc<[fallow_types::extract::FactoryReturnExport]>,
284 pub exported_factory_return_object_shapes:
288 Arc<[fallow_types::extract::FactoryReturnObjectShapeExport]>,
289 pub type_member_types: Arc<[fallow_types::extract::TypeMemberTypeEntry]>,
293 pub missing_export_targets: Vec<MissingExportTarget>,
300}
301
302#[derive(Debug, Clone, PartialEq, Eq)]
309pub struct ScopedPathAlias {
310 pub scope: String,
313 pub prefix: String,
315 pub replacement: String,
317}
318
319#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
322pub struct MissingExportTarget {
323 pub specifier: String,
325 pub paths: Vec<PathBuf>,
327}
328
329impl Default for ResolvedModule {
330 fn default() -> Self {
331 Self {
332 file_id: FileId(0),
333 path: PathBuf::new(),
334 exports: Arc::default(),
335 re_exports: vec![],
336 resolved_imports: vec![],
337 resolved_dynamic_imports: vec![],
338 resolved_dynamic_patterns: vec![],
339 member_accesses: Arc::default(),
340 semantic_facts: Arc::default(),
341 whole_object_uses: Arc::default(),
342 has_cjs_exports: false,
343 has_angular_component_template_url: false,
344 unused_import_bindings: FxHashSet::default(),
345 type_referenced_import_bindings: vec![],
346 value_referenced_import_bindings: vec![],
347 namespace_object_aliases: vec![],
348 exported_factory_returns: Arc::default(),
349 exported_factory_return_object_shapes: Arc::default(),
350 type_member_types: Arc::default(),
351 missing_export_targets: vec![],
352 }
353 }
354}
355
356impl ResolvedModule {
357 pub fn all_resolved_imports(&self) -> impl Iterator<Item = &ResolvedImport> {
363 self.resolved_imports
364 .iter()
365 .chain(self.resolved_dynamic_imports.iter())
366 }
367
368 pub fn all_resolved_source_edges(&self) -> impl Iterator<Item = ResolvedSourceEdge<'_>> {
374 self.resolved_imports
375 .iter()
376 .map(ResolvedSourceEdge::Import)
377 .chain(
378 self.resolved_dynamic_imports
379 .iter()
380 .map(ResolvedSourceEdge::Import),
381 )
382 .chain(self.re_exports.iter().map(ResolvedSourceEdge::ReExport))
383 }
384}
385
386pub(super) struct ResolveContext<'a> {
391 pub resolver: &'a Resolver,
393 pub script_resolver: &'a Resolver,
396 pub style_resolver: &'a Resolver,
400 pub extensions: &'a [String],
402 pub path_to_id: &'a FxHashMap<&'a Path, FileId>,
404 pub raw_path_to_id: &'a FxHashMap<&'a Path, FileId>,
406 pub workspace_roots: &'a FxHashMap<&'a str, &'a Path>,
408 pub package_manifests: &'a [PackageManifestInfo],
410 pub has_deno_import_maps: bool,
413 pub condition_names: &'a [String],
415 pub path_aliases: &'a [(String, String)],
417 pub scoped_path_aliases: &'a [ScopedPathAlias],
419 pub scss_include_paths: &'a [PathBuf],
423 pub static_dir_mappings: &'a [(PathBuf, String)],
426 pub framework_static_dir_mappings: &'a [(PathBuf, String)],
430 pub root: &'a Path,
432 pub canonical_fallback: Option<&'a CanonicalFallback<'a>>,
436 pub tsconfig_warned: &'a Mutex<FxHashSet<String>>,
441 pub tsconfig_cache: &'a TsconfigCache,
446 pub canonicalize_cache: &'a CanonicalizeCache,
453}
454
455#[derive(Default)]
457pub(super) struct CanonicalizeCache {
458 map: DashMap<PathBuf, Option<PathBuf>, FxBuildHasher>,
459}
460
461impl CanonicalizeCache {
462 pub fn get(&self, path: &Path) -> Option<PathBuf> {
466 if let Some(value) = self.map.get(path) {
467 return value.clone();
468 }
469 let value = crate::read_trace::canonicalize(path).ok();
470 self.map.insert(path.to_path_buf(), value.clone());
471 value
472 }
473
474 pub fn distinct_paths(&self) -> usize {
478 self.map.len()
479 }
480}
481
482#[derive(Default)]
484pub(super) struct TsconfigCache {
485 json: DashMap<PathBuf, Option<Arc<Value>>, FxBuildHasher>,
486 chains: DashMap<PathBuf, Arc<[PathBuf]>, FxBuildHasher>,
487 output_maps: DashMap<PathBuf, Arc<TsconfigOutputMap>, FxBuildHasher>,
488}
489
490impl TsconfigCache {
491 pub fn json(
498 &self,
499 path: &Path,
500 load: impl FnOnce(&Path) -> Option<Value>,
501 ) -> Option<Arc<Value>> {
502 if let Some(value) = self.json.get(path) {
503 return value.clone();
504 }
505
506 let value = load(path).map(Arc::new);
507 self.json.insert(path.to_path_buf(), value.clone());
508 value
509 }
510
511 pub fn chain(&self, from_file: &Path) -> Option<Arc<[PathBuf]>> {
513 self.chains.get(from_file).map(|entry| Arc::clone(&entry))
514 }
515
516 pub fn store_chain(&self, from_file: &Path, chain: Arc<[PathBuf]>) {
518 self.chains.insert(from_file.to_path_buf(), chain);
519 }
520
521 pub fn output_map(&self, package_root: &Path) -> Arc<TsconfigOutputMap> {
524 if let Some(map) = self.output_maps.get(package_root) {
525 return Arc::clone(&map);
526 }
527 let map = Arc::new(TsconfigOutputMap::from_project(package_root));
528 self.output_maps
529 .insert(package_root.to_path_buf(), Arc::clone(&map));
530 map
531 }
532}
533
534#[derive(Debug, Clone)]
536pub(super) struct PackageManifestInfo {
537 pub root: PathBuf,
539 pub canonical_root: PathBuf,
541 pub name: Option<String>,
543 pub package_json: fallow_config::PackageJson,
545 pub deno_import_map: Vec<DenoImportMapEntry>,
547}
548
549#[derive(Debug, Clone)]
551pub(super) struct DenoImportMapEntry {
552 pub key: String,
553 pub target: String,
554 pub declaring_dir: PathBuf,
555}
556
557pub(super) struct CanonicalFallback<'a> {
559 files: &'a [fallow_types::discover::DiscoveredFile],
560 map: std::sync::OnceLock<FxHashMap<std::path::PathBuf, FileId>>,
561}
562
563impl<'a> CanonicalFallback<'a> {
564 pub const fn new(files: &'a [fallow_types::discover::DiscoveredFile]) -> Self {
565 Self {
566 files,
567 map: std::sync::OnceLock::new(),
568 }
569 }
570
571 pub fn get(&self, canonical: &Path) -> Option<FileId> {
573 let map = self.map.get_or_init(|| {
574 super::work::note_canonicalize(self.files.len() as u64);
575 tracing::debug!(
576 "intra-project symlinks detected, building canonical path index ({} files)",
577 self.files.len()
578 );
579 self.files
580 .iter()
581 .filter_map(|f| {
582 crate::read_trace::canonicalize(&f.path)
583 .ok()
584 .map(|canonical| (canonical, f.id))
585 })
586 .collect()
587 });
588 map.get(canonical).copied()
589 }
590}
591
592#[cfg(all(test, not(miri)))]
593mod tests {
594 use super::*;
595 use fallow_types::discover::DiscoveredFile;
596
597 #[test]
598 fn canonical_fallback_returns_none_for_empty_files() {
599 let files: Vec<DiscoveredFile> = vec![];
600 let fallback = CanonicalFallback::new(&files);
601 assert!(fallback.get(Path::new("/nonexistent")).is_none());
602 }
603
604 #[test]
605 fn canonical_fallback_finds_existing_file() {
606 let temp = std::env::temp_dir().join("fallow-test-canonical-fallback");
607 let _ = std::fs::create_dir_all(&temp);
608 let test_file = temp.join("test.ts");
609 std::fs::write(&test_file, "").unwrap();
610
611 let files = vec![DiscoveredFile {
612 id: FileId(42),
613 path: test_file.clone(),
614 size_bytes: 0,
615 }];
616 let fallback = CanonicalFallback::new(&files);
617
618 let canonical = dunce::canonicalize(&test_file).unwrap();
619 assert_eq!(fallback.get(&canonical), Some(FileId(42)));
620
621 assert_eq!(fallback.get(&canonical), Some(FileId(42)));
622
623 let _ = std::fs::remove_dir_all(&temp);
624 }
625
626 #[test]
627 fn canonical_fallback_returns_none_for_missing_path() {
628 let temp = std::env::temp_dir().join("fallow-test-canonical-miss");
629 let _ = std::fs::create_dir_all(&temp);
630 let test_file = temp.join("exists.ts");
631 std::fs::write(&test_file, "").unwrap();
632
633 let files = vec![DiscoveredFile {
634 id: FileId(1),
635 path: test_file,
636 size_bytes: 0,
637 }];
638 let fallback = CanonicalFallback::new(&files);
639 assert!(fallback.get(Path::new("/nonexistent/file.ts")).is_none());
640
641 let _ = std::fs::remove_dir_all(&temp);
642 }
643
644 #[test]
645 fn tsconfig_cache_loads_once_and_shares_the_parsed_document() {
646 let cache = TsconfigCache::default();
647 let path = Path::new("/project/tsconfig.json");
648 let loads = std::sync::atomic::AtomicUsize::new(0);
649 let load = |_: &Path| {
650 loads.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
651 Some(serde_json::json!({ "compilerOptions": {} }))
652 };
653
654 let first = cache.json(path, load).unwrap();
655 let second = cache.json(path, load).unwrap();
656
657 assert_eq!(loads.load(std::sync::atomic::Ordering::SeqCst), 1);
658 assert!(
659 Arc::ptr_eq(&first, &second),
660 "repeat reads must share one allocation rather than deep-copy"
661 );
662 }
663
664 #[test]
666 fn tsconfig_cache_caches_a_failed_load() {
667 let cache = TsconfigCache::default();
668 let path = Path::new("/project/missing.json");
669 let loads = std::sync::atomic::AtomicUsize::new(0);
670 let load = |_: &Path| {
671 loads.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
672 None
673 };
674
675 assert!(cache.json(path, load).is_none());
676 assert!(cache.json(path, load).is_none());
677 assert_eq!(loads.load(std::sync::atomic::Ordering::SeqCst), 1);
678 }
679
680 #[test]
681 fn tsconfig_cache_round_trips_a_chain() {
682 let cache = TsconfigCache::default();
683 let from_file = Path::new("/project/src/index.ts");
684 assert!(cache.chain(from_file).is_none());
685
686 let chain: Arc<[PathBuf]> = vec![PathBuf::from("/project/tsconfig.json")].into();
687 cache.store_chain(from_file, Arc::clone(&chain));
688
689 assert!(Arc::ptr_eq(&cache.chain(from_file).unwrap(), &chain));
690 }
691
692 #[test]
694 fn tsconfig_cache_is_consistent_under_concurrent_access() {
695 const THREADS: usize = 8;
696 const PATHS: usize = 32;
697
698 let cache = TsconfigCache::default();
699 std::thread::scope(|scope| {
700 for _ in 0..THREADS {
701 scope.spawn(|| {
702 for index in 0..PATHS {
703 let path = PathBuf::from(format!("/project/{index}/tsconfig.json"));
704 let json = cache
705 .json(&path, |_| Some(serde_json::json!({ "index": index })))
706 .unwrap();
707 assert_eq!(json["index"], index);
708 }
709 });
710 }
711 });
712 }
713
714 #[test]
715 fn canonicalize_cache_returns_the_same_result_on_repeat_lookups() {
716 let temp = tempfile::tempdir().expect("create temp dir");
717 let file = temp.path().join("file.ts");
718 std::fs::write(&file, "").unwrap();
719
720 let cache = CanonicalizeCache::default();
721 let expected = dunce::canonicalize(&file).ok();
722 assert_eq!(cache.get(&file), expected);
723 assert_eq!(cache.get(&file), expected);
724 assert!(cache.get(&temp.path().join("missing.ts")).is_none());
725 }
726
727 #[test]
728 fn commonjs_provenance_wraps_internal_and_bare_package_targets() {
729 assert!(matches!(
730 ResolveResult::InternalModule(FileId(4)).into_commonjs_require(),
731 ResolveResult::CommonJsInternalModule(FileId(4))
732 ));
733 assert!(matches!(
734 ResolveResult::InternalPackageModule {
735 file_id: FileId(5),
736 package_name: "pkg".to_string(),
737 }
738 .into_commonjs_require(),
739 ResolveResult::CommonJsInternalPackageModule {
740 file_id: FileId(5),
741 package_name,
742 } if package_name == "pkg"
743 ));
744 assert!(matches!(
745 ResolveResult::NpmPackage("pkg".to_string()).into_commonjs_require(),
746 ResolveResult::CommonJsNpmPackage(package_name) if package_name == "pkg"
747 ));
748 }
749}
750
751pub const OUTPUT_DIRS: &[&str] = &["dist", "build", "out", "esm", "cjs"];
756
757pub const MISSING_ONLY_OUTPUT_DIRS: &[&str] = &["lib"];
766
767pub const SOURCE_EXTS: &[&str] = &["ts", "tsx", "mts", "cts", "js", "jsx", "mjs", "cjs"];
769
770pub const RN_PLATFORM_PREFIXES: &[&str] = &[".web", ".ios", ".android", ".native"];