1mod locked;
7mod module_paths;
8mod selected;
9pub use locked::{
10 LockedBinding, LockedEdge, LockedManifest, LockedPackageRoots, LockedTree, ReferenceBinding,
11 ReferenceObservation, ReferencePackageRoots, ReferenceRequest, ReferenceTree,
12};
13pub use module_paths::ForeignModulePath;
14
15use std::cmp::Ordering;
16use std::collections::{BTreeMap, BTreeSet};
17use std::convert::Infallible;
18use std::rc::Rc;
19
20use purrdf_lex::allocation::Memory;
21use purrdf_lex::walk::{try_equal_range_by, try_sort_unstable_by};
22
23use crate::discovery::{Found, discover};
24use crate::error::{LoadError, LoadErrorKind, Origin};
25use crate::exports::{ExportError, ExportOptions, Exports, Surface};
26use crate::facts::{FileFacts, TestRole};
27use crate::index::{DependencyInfo, Index, LOAD_BASE_BYTES, PackageInfo};
28use crate::item::{ImplBlock, ImplId, Item, ItemId, Namespace, UnresolvedImpl};
29use crate::manifest::{
30 self, Dependency, DependencyDeclaration, EditionDecl, InheritedDependency, Manifest,
31 PackageDecl, PathSource, VersionDecl, WorkspaceDependency,
32};
33use crate::members::members;
34use crate::meter::{ItemAdmission, Meter, Usage};
35use crate::modtree::{Reach, TargetId, Visited, WalkConfiguration, Walked, Walker, tidy};
36use crate::options::LoadOptions;
37#[cfg(target_os = "linux")]
38use crate::parse::ConfigurationKey;
39use crate::path::{PathError, RelPath};
40use crate::reach::{self, Node, ReachError, Reachability};
41use crate::resolve::{Resolution, ResolutionAttempt, ResolveError};
42use crate::target::TargetKind;
43use crate::target::{Context, Package, PackageId, Target, check_crate_paths, derive_targets};
44use crate::tree::Tree;
45
46#[derive(Clone, Copy)]
47enum SyntaxLoad<'a> {
48 Ordinary(Option<&'a dyn crate::parse::Parser>),
49 ShippingMembers,
50 Configured(crate::DeclaredConfiguration<'a>),
51 #[cfg(target_os = "linux")]
52 ConfiguredParallel(crate::DeclaredConfiguration<'a>, &'a crate::ParallelOptions),
53 #[cfg(target_os = "linux")]
54 LockedParallel(&'a crate::ParallelOptions),
55}
56
57impl<'a> SyntaxLoad<'a> {
58 fn declared(self) -> Option<crate::DeclaredConfiguration<'a>> {
59 match self {
60 Self::Ordinary(_) | Self::ShippingMembers => None,
61 Self::Configured(configuration) => Some(configuration),
62 #[cfg(target_os = "linux")]
63 Self::ConfiguredParallel(configuration, _) => Some(configuration),
64 #[cfg(target_os = "linux")]
65 Self::LockedParallel(_) => None,
66 }
67 }
68}
69
70struct SourceWalk {
71 walked: Walked,
72 #[cfg(target_os = "linux")]
73 parallel_usage: Option<crate::ParallelUsage>,
74}
75
76#[derive(Debug, PartialEq, Eq)]
90#[non_exhaustive]
91pub struct SourceFile {
92 pub path: RelPath,
94 pub package: String,
96 pub shipping: bool,
99 pub test: bool,
101 pub text: String,
103 pub(crate) facts: FileFacts,
105 pub reached: Vec<Reach>,
108}
109
110impl SourceFile {
111 #[must_use]
114 pub fn reached_only_through_tests(&self) -> bool {
115 self.reached.iter().all(|reach| reach.test)
116 }
117}
118
119#[derive(Debug)]
125pub struct Workspace {
126 packages: Vec<Package>,
127 dependencies: Vec<Vec<DependencyDeclaration>>,
128 versions: Vec<DeclaredVersion>,
130 locked: Vec<LockedBinding>,
131 references: Vec<LockedBinding>,
132 selected_configuration: Option<crate::ActiveConfiguration>,
133 package_names: Vec<PackageId>,
135 targets: Vec<Target>,
136 files: BTreeMap<RelPath, SourceFile>,
137 index: Index,
138 usage: Usage,
139 #[cfg(target_os = "linux")]
140 parallel_usage: Option<crate::ParallelUsage>,
141 options: LoadOptions,
144}
145
146impl PartialEq for Workspace {
147 fn eq(&self, other: &Self) -> bool {
148 self.packages == other.packages
149 && self.dependencies == other.dependencies
150 && self.versions == other.versions
151 && self.locked == other.locked
152 && self.references == other.references
153 && self.selected_configuration == other.selected_configuration
154 && self.package_names == other.package_names
155 && self.targets == other.targets
156 && self.files == other.files
157 && self.index == other.index
158 }
159}
160
161impl Eq for Workspace {}
162
163impl Workspace {
164 pub(crate) fn selected_configuration(&self) -> Option<&crate::ActiveConfiguration> {
166 self.selected_configuration.as_ref()
167 }
168
169 pub fn code_resolver(&self) -> Result<crate::CodeResolver<'_>, LoadError> {
176 crate::CodeResolver::new(self, &self.index, &self.options, self.usage)
177 }
178
179 pub fn load(tree: &dyn Tree, roots: &[&str]) -> Result<Self, LoadError> {
190 Self::load_with(tree, roots, &LoadOptions::default())
191 }
192
193 pub fn load_with(
216 tree: &dyn Tree,
217 roots: &[&str],
218 options: &LoadOptions,
219 ) -> Result<Self, LoadError> {
220 let mut root_paths = Vec::new();
221 for root in roots {
222 let path = RelPath::new(root).map_err(|error| {
223 LoadError::tree(
224 &RelPath::root(),
225 None,
226 &Origin::Discovery,
227 crate::error::TreeError::from(error),
228 )
229 })?;
230 root_paths.push(path);
231 }
232 Self::load_from(tree, &root_paths, options)
233 }
234
235 #[cfg(target_os = "linux")]
249 pub fn par_load(
250 tree: &dyn crate::ParallelTree,
251 roots: &[&str],
252 options: &LoadOptions,
253 parallel: &crate::ParallelOptions,
254 ) -> Result<Self, LoadError> {
255 let mut root_paths = Vec::new();
256 for root in roots {
257 root_paths.push(RelPath::new(root).map_err(|error| {
258 LoadError::tree(&RelPath::root(), None, &Origin::Discovery, error.into())
259 })?);
260 }
261 let resources = crate::parse::parallel::Resources::new(parallel)?;
262 std::thread::scope(|scope| {
263 let parser = crate::parse::parallel::Executor::new(scope, &resources, parallel, None)?;
264 let meter = Meter::new(options);
265 let result = Self::load_meter_with_syntax(
266 tree,
267 &root_paths,
268 options,
269 &meter,
270 None,
271 SyntaxLoad::Ordinary(Some(&parser)),
272 );
273 let usage = parser.finish();
274 result.map(|mut workspace| {
275 workspace.parallel_usage = Some(usage);
276 workspace
277 })
278 })
279 }
280
281 pub fn load_from(
292 tree: &dyn Tree,
293 roots: &[RelPath],
294 options: &LoadOptions,
295 ) -> Result<Self, LoadError> {
296 let meter = Meter::new(options);
297 Self::load_meter(tree, roots, options, &meter, None)
298 }
299
300 pub fn load_members(
309 tree: &dyn Tree,
310 root: &RelPath,
311 options: &LoadOptions,
312 ) -> Result<Self, LoadError> {
313 Self::members_with_syntax(tree, root, options, SyntaxLoad::Ordinary(None))
314 }
315
316 pub fn load_shipping_members(
325 tree: &dyn Tree,
326 root: &RelPath,
327 options: &LoadOptions,
328 ) -> Result<Self, LoadError> {
329 Self::members_with_syntax(tree, root, options, SyntaxLoad::ShippingMembers)
330 }
331
332 fn members_with_syntax(
333 tree: &dyn Tree,
334 root: &RelPath,
335 options: &LoadOptions,
336 syntax: SyntaxLoad<'_>,
337 ) -> Result<Self, LoadError> {
338 let meter = Meter::new(options);
339 meter.items(LOAD_BASE_BYTES, root, None)?;
340 let selected = crate::discovery::workspace_members(tree, root, &meter)?;
341 Self::build_discovered_with_syntax(tree, options, &meter, None, &selected, syntax)
342 }
343
344 fn load_meter(
345 tree: &dyn Tree,
346 roots: &[RelPath],
347 options: &LoadOptions,
348 meter: &Meter,
349 binding: Option<&locked::BindingLoad<'_>>,
350 ) -> Result<Self, LoadError> {
351 Self::load_meter_with_syntax(
352 tree,
353 roots,
354 options,
355 meter,
356 binding,
357 SyntaxLoad::Ordinary(None),
358 )
359 }
360
361 fn load_meter_with_syntax(
362 tree: &dyn Tree,
363 roots: &[RelPath],
364 options: &LoadOptions,
365 meter: &Meter,
366 binding: Option<&locked::BindingLoad<'_>>,
367 syntax: SyntaxLoad<'_>,
368 ) -> Result<Self, LoadError> {
369 let root = RelPath::root();
370 if roots.is_empty() {
371 return Err(LoadError::new(&root, None, LoadErrorKind::NoRoots));
372 }
373 meter.items(LOAD_BASE_BYTES, &root, None)?;
374 let discovered = discover(tree, roots, meter)?;
375 Self::build_discovered_with_syntax(tree, options, meter, binding, &discovered, syntax)
376 }
377
378 fn build_discovered(
379 tree: &dyn Tree,
380 options: &LoadOptions,
381 meter: &Meter,
382 binding: Option<&locked::BindingLoad<'_>>,
383 discovered: &crate::discovery::Discovered,
384 ) -> Result<Self, LoadError> {
385 Self::build_discovered_with_syntax(
386 tree,
387 options,
388 meter,
389 binding,
390 discovered,
391 SyntaxLoad::Ordinary(None),
392 )
393 }
394
395 fn build_discovered_with_syntax(
396 tree: &dyn Tree,
397 options: &LoadOptions,
398 meter: &Meter,
399 binding: Option<&locked::BindingLoad<'_>>,
400 discovered: &crate::discovery::Discovered,
401 syntax: SyntaxLoad<'_>,
402 ) -> Result<Self, LoadError> {
403 let root = RelPath::root();
404 let found = &discovered.packages;
405 let dirs = package_directory_index(found, meter)?;
406 let mut infos = Vec::new();
407 let mut admission = ItemAdmission::new(meter, &root);
408 Memory::new(&mut admission)
409 .reserve(&mut infos, found.len())
410 .map_err(|error| admission.error(error))?;
411 let mut caches = Caches::default();
412 let reader = Reader {
413 tree,
414 meter,
415 dirs: &dirs,
416 found,
417 };
418 let mut locked = binding.map_or_else(
419 || Ok(Vec::new()),
420 |binding| locked::bind_found(binding, &reader, &mut caches),
421 )?;
422 let (mut packages, mut derived) = (Vec::new(), Vec::new());
423 let mut dependencies = Vec::new();
424 let mut dependency_admission = ItemAdmission::new(meter, &root);
425 Memory::new(&mut dependency_admission)
426 .reserve(&mut dependencies, found.len())
427 .map_err(|error| dependency_admission.error(error))?;
428 for (package_index, entry) in found.iter().enumerate() {
429 let context = Context {
430 package_id: PackageId(package_index),
431 tree,
432 manifest_path: &entry.package.manifest,
433 dir: &entry.package.dir,
434 manifest: &entry.manifest,
435 package: &entry.declared,
436 };
437 for target in derive_targets(&context)? {
438 derived.push((&entry.package.manifest, target));
439 }
440 infos.push(package_info(
441 &reader,
442 &entry.package,
443 &entry.declared,
444 &entry.manifest,
445 &mut caches,
446 )?);
447 dependencies.push(dependency_declarations(
448 &reader,
449 &entry.package,
450 &entry.manifest,
451 &mut caches,
452 )?);
453 packages.push(entry.package.clone());
454 }
455 let selected = configure_targets(
456 &reader,
457 &dependencies,
458 binding,
459 &mut locked,
460 &mut infos,
461 &mut derived,
462 syntax,
463 )?;
464 let versions = declared_versions(&reader, found, &mut caches)?;
465 let package_names = package_name_index(&packages, meter)?;
466 let (targets, origins) = selected_targets(derived)?;
467 let source = walk_source_syntax(
468 tree,
469 &targets,
470 &origins,
471 &locked,
472 selected.as_ref(),
473 meter,
474 syntax,
475 )?;
476 let files = source_files(source.walked.files, &targets)?;
477 reader.install_edges(binding, &dependencies, &locked, &targets, &mut infos)?;
478 let index = Index::build(
479 &targets,
480 &files,
481 &source.walked.visits,
482 &infos,
483 source.walked.paths,
484 meter,
485 )?;
486 let (locked, references) = binding_sets(binding, locked);
487 Ok(Self {
488 packages,
489 dependencies,
490 versions,
491 locked,
492 references,
493 selected_configuration: selected,
494 package_names,
495 targets,
496 files,
497 index,
498 usage: meter.usage(),
499 #[cfg(target_os = "linux")]
500 parallel_usage: source.parallel_usage,
501 options: options.clone(),
502 })
503 }
504
505 #[cfg(test)]
507 pub(crate) fn index(&self) -> &Index {
508 &self.index
509 }
510
511 #[must_use]
515 pub fn usage(&self) -> Usage {
516 self.usage
517 }
518
519 #[cfg(target_os = "linux")]
524 #[must_use]
525 pub fn parallel_usage(&self) -> Option<crate::ParallelUsage> {
526 self.parallel_usage
527 }
528
529 #[must_use]
531 pub fn packages(&self) -> &[Package] {
532 &self.packages
533 }
534
535 #[must_use]
542 pub fn dependency_declarations(&self, package: PackageId) -> Option<&[DependencyDeclaration]> {
543 self.dependencies.get(package.index()).map(Vec::as_slice)
544 }
545
546 #[must_use]
549 pub fn locked_binding(&self, package: PackageId) -> Option<&LockedBinding> {
550 self.locked.get(package.index())
551 }
552
553 #[must_use]
555 pub fn package(&self, id: PackageId) -> Option<&Package> {
556 self.packages.get(id.index())
557 }
558
559 pub fn package_version(&self, id: PackageId) -> Result<Option<&str>, LoadError> {
567 match self.versions.get(id.index()) {
568 Some(DeclaredVersion::Value(version)) => Ok(Some(version)),
569 Some(DeclaredVersion::Unset) => Ok(None),
570 Some(DeclaredVersion::Unresolved) | None => {
571 let manifest = self
572 .packages
573 .get(id.index())
574 .map_or_else(RelPath::root, |package| package.manifest.clone());
575 Err(manifest_error(
576 &manifest,
577 "package.version",
578 "the package inherits its version and the nearest workspace manifest supplies none".to_owned(),
579 ))
580 }
581 }
582 }
583
584 pub fn package_ids(&self) -> impl Iterator<Item = PackageId> {
586 (0..self.packages.len()).map(PackageId)
587 }
588
589 pub fn targets(&self) -> impl Iterator<Item = &Target> {
592 self.targets.iter()
593 }
594
595 #[must_use]
597 pub fn target(&self, id: TargetId) -> Option<&Target> {
598 self.targets.get(id.index())
599 }
600
601 #[must_use]
609 pub fn target_edition(&self, id: TargetId) -> Option<u16> {
610 self.index.target_editions.get(id.index()).copied()
611 }
612
613 pub fn target_ids(&self) -> impl Iterator<Item = TargetId> {
615 (0..self.targets.len()).map(TargetId)
616 }
617
618 pub fn library_prelude_dependencies(
624 &self,
625 library: TargetId,
626 ) -> Option<impl Iterator<Item = PackageId> + '_> {
627 self.target(library)
628 .filter(|target| target.kind == TargetKind::Lib)?;
629 Some(
630 self.index.preludes[library.index()]
631 .values()
632 .flat_map(|name| name.roots(false))
633 .map(move |module| {
634 self.targets[self.index.modules[module].target.index()].package_id
635 }),
636 )
637 }
638
639 pub fn files(&self) -> impl Iterator<Item = &SourceFile> {
641 self.files.values()
642 }
643
644 #[must_use]
646 pub fn file(&self, path: &RelPath) -> Option<&SourceFile> {
647 self.files.get(path)
648 }
649
650 #[must_use]
652 pub fn source(&self, path: &RelPath) -> Option<&str> {
653 self.files.get(path).map(|file| file.text.as_str())
654 }
655
656 pub fn items(&self) -> impl Iterator<Item = &Item> {
658 self.index
659 .order
660 .iter()
661 .map(|id| &self.index.items[id.index()])
662 }
663
664 #[must_use]
667 pub fn unexpanded(&self) -> &[crate::Unexpanded] {
668 &self.index.unexpanded
669 }
670
671 #[must_use]
674 pub fn disabled_syntax(&self) -> &[crate::DisabledSyntax] {
675 &self.index.disabled_syntax
676 }
677
678 pub fn items_under<'a>(&'a self, prefix: &'a str) -> impl Iterator<Item = &'a Item> {
682 let order = &self.index.order;
683 let start = order.partition_point(|id| self.index.items[id.index()].path.as_str() < prefix);
684 order[start..]
685 .iter()
686 .map(|id| &self.index.items[id.index()])
687 .take_while(move |item| item.path.starts_with(prefix))
688 .filter(move |item| {
689 prefix.is_empty()
690 || item
691 .path
692 .strip_prefix(prefix)
693 .is_some_and(|rest| rest.is_empty() || rest.starts_with("::"))
694 })
695 }
696
697 #[must_use]
699 pub fn item(&self, id: ItemId) -> Option<&Item> {
700 self.index.items.get(id.index())
701 }
702
703 pub fn test_platform_guard(
712 &self,
713 id: ItemId,
714 ) -> Result<crate::TestPlatformGuard<'_>, LoadError> {
715 crate::platform::guard(self, id, &self.index, &self.options, self.usage.item_bytes)
716 }
717
718 pub fn items_in<'a>(&'a self, file: &RelPath) -> impl Iterator<Item = &'a Item> {
720 self.index
721 .by_file
722 .get(file)
723 .into_iter()
724 .flatten()
725 .map(|id| &self.index.items[id.index()])
726 }
727
728 #[must_use]
733 pub fn item_count_in(&self, file: &RelPath) -> usize {
734 self.index.by_file.get(file).map_or(0, Vec::len)
735 }
736
737 #[must_use]
740 pub fn item_at(&self, file: &RelPath, offset: usize) -> Vec<&Item> {
741 let holding: Vec<&Item> = self
742 .items_in(file)
743 .filter(|item| item.span.start_byte <= offset && offset < item.span.end_byte)
744 .collect();
745 let smallest = holding
746 .iter()
747 .map(|item| item.span.end_byte - item.span.start_byte)
748 .min();
749 holding
750 .into_iter()
751 .filter(|item| Some(item.span.end_byte - item.span.start_byte) == smallest)
752 .collect()
753 }
754
755 #[must_use]
757 pub fn is_shipping(&self, item: &Item) -> bool {
758 item.test == TestRole::None
759 && self
760 .targets
761 .get(item.target.index())
762 .is_some_and(|target| target.shipping)
763 }
764
765 pub fn resolve(&self, path: &str) -> Result<Resolution, ResolveError> {
783 self.index
784 .resolve(path, None, None, &Meter::query(&self.options))
785 }
786
787 pub fn resolve_in(&self, path: &str, namespace: Namespace) -> Result<Resolution, ResolveError> {
793 self.index
794 .resolve(path, Some(namespace), None, &Meter::query(&self.options))
795 }
796
797 pub fn resolve_in_observed(
808 &self,
809 path: &str,
810 namespace: Namespace,
811 ) -> Result<ResolutionAttempt, ResolveError> {
812 self.index
813 .resolve_observed(path, namespace, &Meter::query(&self.options))
814 }
815
816 pub fn resolve_in_package(
827 &self,
828 package: &str,
829 path: &str,
830 ) -> Result<Resolution, ResolveError> {
831 let matching = try_equal_range_by(&self.package_names, |id| {
832 Ok::<_, Infallible>(self.packages[id.index()].name.as_str().cmp(package))
833 })
834 .unwrap_or_else(|never| match never {});
835 if matching.is_empty() {
836 return Err(ResolveError::UnknownPackage(package.to_owned()));
837 }
838 if matching.len() > 1 {
839 return Err(ResolveError::AmbiguousPackageName(package.to_owned()));
840 }
841 self.resolve_in_package_id(self.package_names[matching.start], path)
842 }
843
844 pub fn resolve_in_package_id(
854 &self,
855 package: PackageId,
856 path: &str,
857 ) -> Result<Resolution, ResolveError> {
858 if self.package(package).is_none() {
859 return Err(ResolveError::UnknownPackageId(package));
860 }
861 self.index
862 .resolve(path, None, Some(package), &Meter::query(&self.options))
863 }
864
865 pub fn resolve_from(&self, module: &str, path: &str) -> Result<Resolution, ResolveError> {
903 self.index
904 .resolve_from(module, path, None, None, &Meter::query(&self.options))
905 }
906
907 pub fn resolve_from_in(
913 &self,
914 module: &str,
915 path: &str,
916 namespace: Namespace,
917 ) -> Result<Resolution, ResolveError> {
918 self.index.resolve_from(
919 module,
920 path,
921 Some(namespace),
922 None,
923 &Meter::query(&self.options),
924 )
925 }
926
927 pub fn resolve_from_package_id(
941 &self,
942 package: PackageId,
943 module: &str,
944 path: &str,
945 ) -> Result<Resolution, ResolveError> {
946 if self.package(package).is_none() {
947 return Err(ResolveError::UnknownPackageId(package));
948 }
949 self.index.resolve_from(
950 module,
951 path,
952 None,
953 Some(package),
954 &Meter::query(&self.options),
955 )
956 }
957
958 pub fn resolve_from_package_id_in(
964 &self,
965 package: PackageId,
966 module: &str,
967 path: &str,
968 namespace: Namespace,
969 ) -> Result<Resolution, ResolveError> {
970 if self.package(package).is_none() {
971 return Err(ResolveError::UnknownPackageId(package));
972 }
973 self.index.resolve_from(
974 module,
975 path,
976 Some(namespace),
977 Some(package),
978 &Meter::query(&self.options),
979 )
980 }
981
982 pub fn resolve_active_from_package_id_in(
994 &self,
995 package: PackageId,
996 module: &str,
997 path: &str,
998 namespace: Namespace,
999 ) -> Result<Resolution, ResolveError> {
1000 if self.package(package).is_none() {
1001 return Err(ResolveError::UnknownPackageId(package));
1002 }
1003 if self
1004 .locked_binding(package)
1005 .is_none_or(|binding| binding.configurations().is_empty())
1006 {
1007 return Err(ResolveError::UnconfiguredPackage(package));
1008 }
1009 let resolved = self.resolve_from_package_id_in(package, module, path, namespace)?;
1010 if resolved.sites.is_empty() {
1011 return Err(ResolveError::NotFound(path.to_owned()));
1012 }
1013 for site in &resolved.sites {
1014 let valid = self
1015 .item(*site)
1016 .and_then(|item| self.target(item.target))
1017 .and_then(|target| {
1018 self.locked_binding(target.package_id)?
1019 .configuration_for(target.kind, &target.name)
1020 })
1021 .is_some();
1022 if !valid {
1023 return Err(ResolveError::UnconfiguredDefinition(*site));
1024 }
1025 }
1026 Ok(resolved)
1027 }
1028
1029 pub fn unresolved_impls(&self) -> impl Iterator<Item = &UnresolvedImpl> {
1035 self.index.unresolved.iter()
1036 }
1037
1038 pub fn impls(&self) -> impl Iterator<Item = &ImplBlock> {
1069 self.index.impl_blocks.iter()
1070 }
1071
1072 #[must_use]
1074 pub fn impls_in(&self, file: &RelPath) -> &[ImplBlock] {
1075 let blocks = &self.index.impl_blocks;
1076 let start = blocks.partition_point(|block| &block.file < file);
1077 let end = blocks.partition_point(|block| &block.file <= file);
1078 &blocks[start..end]
1079 }
1080
1081 #[must_use]
1083 pub fn impl_block(&self, id: ImplId) -> Option<&ImplBlock> {
1084 self.index.impl_blocks.get(id.index())
1085 }
1086
1087 pub fn reachable(&self, roots: &[Node]) -> Result<Reachability, ReachError> {
1146 reach::reachable(
1147 &self.index,
1148 &self.files,
1149 (&self.options, self.usage.item_bytes),
1150 roots,
1151 )
1152 }
1153
1154 pub fn items_by_source(&self) -> impl Iterator<Item = (&RelPath, usize, &[ItemId])> {
1160 self.index
1161 .by_source
1162 .iter()
1163 .map(|((file, offset), ids)| (file, *offset, ids.as_slice()))
1164 }
1165
1166 #[must_use]
1170 pub fn same_source(&self, item: &Item) -> &[ItemId] {
1171 if self.index.is_root(item.id) {
1172 return &[];
1173 }
1174 self.index
1175 .by_source
1176 .get(&(item.file.clone(), item.span.start_byte))
1177 .map_or(&[][..], Vec::as_slice)
1178 }
1179
1180 pub fn exported_items(&self, target: TargetId) -> Result<Exports, ExportError> {
1207 self.exported_items_with(target, &ExportOptions::default())
1208 }
1209
1210 pub fn exported_items_with(
1241 &self,
1242 target: TargetId,
1243 options: &ExportOptions,
1244 ) -> Result<Exports, ExportError> {
1245 self.exports_after(
1246 target,
1247 options,
1248 Usage {
1249 item_bytes: self.usage.item_bytes,
1250 ..Usage::default()
1251 },
1252 )
1253 .map(|(exports, _)| exports)
1254 }
1255
1256 pub(crate) fn exports_after(
1257 &self,
1258 target: TargetId,
1259 options: &ExportOptions,
1260 retained: Usage,
1261 ) -> Result<(Exports, Usage), ExportError> {
1262 let Some(found) = self
1263 .targets
1264 .get(target.index())
1265 .filter(|found| matches!(found.kind, TargetKind::Lib | TargetKind::Bin))
1266 else {
1267 return Err(ExportError::NotLibraryOrBinary(target));
1268 };
1269 let meter = Meter::resume_query(&self.options, retained);
1270 let hidden_files: BTreeSet<&str> = self
1272 .files
1273 .values()
1274 .filter(|file| file.facts.doc_hidden)
1275 .flat_map(|file| &file.reached)
1276 .filter(|reach| reach.target == target)
1277 .map(|reach| reach.module_path.as_str())
1278 .collect();
1279 let exports = Surface::new(
1280 &self.index,
1281 target,
1282 &found.crate_path,
1283 options,
1284 &meter,
1285 &hidden_files,
1286 )
1287 .list()?;
1288 Ok((exports, meter.usage()))
1289 }
1290
1291 pub fn test_fns(&self) -> Result<Vec<TestFn>, LoadError> {
1301 self.items()
1302 .filter(|item| item.test == TestRole::TestFn)
1303 .filter(|item| !item.path.contains("::{"))
1306 .map(|item| test_fn_of(item, &self.targets))
1307 .collect()
1308 }
1309}
1310
1311#[derive(Default)]
1313struct Caches {
1314 workspaces: BTreeMap<RelPath, WorkspaceOf>,
1315 members: BTreeMap<RelPath, BTreeSet<RelPath>>,
1316}
1317
1318fn binding_sets(
1320 binding: Option<&locked::BindingLoad<'_>>,
1321 bindings: Vec<LockedBinding>,
1322) -> (Vec<LockedBinding>, Vec<LockedBinding>) {
1323 if binding.is_some_and(locked::BindingLoad::structural) {
1324 (Vec::new(), bindings)
1325 } else {
1326 (bindings, Vec::new())
1327 }
1328}
1329
1330fn package_name_index(packages: &[Package], meter: &Meter) -> Result<Vec<PackageId>, LoadError> {
1332 package_index_by(packages.len(), meter, |left, right| {
1333 packages[left.index()]
1334 .name
1335 .cmp(&packages[right.index()].name)
1336 })
1337}
1338
1339fn package_directory_index(found: &[Found], meter: &Meter) -> Result<Vec<PackageId>, LoadError> {
1340 package_index_by(found.len(), meter, |left, right| {
1341 found[left.index()]
1342 .package
1343 .dir
1344 .cmp(&found[right.index()].package.dir)
1345 })
1346}
1347
1348fn package_index_by(
1350 len: usize,
1351 meter: &Meter,
1352 compare: impl Fn(PackageId, PackageId) -> Ordering,
1353) -> Result<Vec<PackageId>, LoadError> {
1354 let file = RelPath::root();
1355 meter.items(size_of::<Vec<PackageId>>(), &file, None)?;
1356 let mut names = Vec::new();
1357 let mut admission = ItemAdmission::new(meter, &file);
1358 Memory::new(&mut admission)
1359 .reserve(&mut names, len)
1360 .map_err(|error| admission.error(error))?;
1361 for index in 0..len {
1362 names.push(PackageId(index));
1363 }
1364 try_sort_unstable_by(&mut names, |left, right| {
1365 Ok::<_, Infallible>(compare(*left, *right).then_with(|| left.cmp(right)))
1366 })
1367 .unwrap_or_else(|never| match never {});
1368 Ok(names)
1369}
1370
1371struct Reader<'a> {
1374 tree: &'a dyn Tree,
1375 meter: &'a Meter,
1376 dirs: &'a [PackageId],
1377 found: &'a [Found],
1378}
1379
1380impl Reader<'_> {
1381 fn install_edges(
1382 &self,
1383 binding: Option<&locked::BindingLoad<'_>>,
1384 dependencies: &[Vec<DependencyDeclaration>],
1385 locked: &[LockedBinding],
1386 targets: &[Target],
1387 infos: &mut [PackageInfo],
1388 ) -> Result<(), LoadError> {
1389 if let Some(binding) = binding {
1390 locked::install_edges(binding, self, dependencies, locked, targets, infos)?;
1391 }
1392 Ok(())
1393 }
1394}
1395
1396#[derive(Debug, Clone, PartialEq, Eq)]
1398enum DeclaredVersion {
1399 Value(String),
1400 Unset,
1401 Unresolved,
1402}
1403
1404fn declared_versions(
1406 reader: &Reader<'_>,
1407 found: &[Found],
1408 caches: &mut Caches,
1409) -> Result<Vec<DeclaredVersion>, LoadError> {
1410 let mut versions = Vec::new();
1411 let root = RelPath::root();
1412 let mut admission = ItemAdmission::new(reader.meter, &root);
1413 Memory::new(&mut admission)
1414 .reserve(&mut versions, found.len())
1415 .map_err(|error| admission.error(error))?;
1416 for entry in found {
1417 versions.push(declared_version(
1418 reader,
1419 &entry.package,
1420 &entry.declared,
1421 caches,
1422 )?);
1423 }
1424 Ok(versions)
1425}
1426
1427fn declared_version(
1429 reader: &Reader<'_>,
1430 package: &Package,
1431 declared: &PackageDecl,
1432 caches: &mut Caches,
1433) -> Result<DeclaredVersion, LoadError> {
1434 let version = match &declared.version {
1435 VersionDecl::Explicit(version) => version.clone(),
1436 VersionDecl::Unset => return Ok(DeclaredVersion::Unset),
1437 VersionDecl::Inherited => match workspace_of(reader, &package.dir, caches)? {
1438 WorkspaceOf::Member {
1439 version: Some(version),
1440 ..
1441 } => version.as_str().to_owned(),
1442 _ => return Ok(DeclaredVersion::Unresolved),
1443 },
1444 };
1445 reader.meter.items(
1446 version.len().saturating_add(size_of::<DeclaredVersion>()),
1447 &package.manifest,
1448 None,
1449 )?;
1450 Ok(DeclaredVersion::Value(version))
1451}
1452
1453#[derive(Debug, Clone, PartialEq, Eq)]
1456enum WorkspaceOf {
1457 Member {
1459 dir: RelPath,
1460 edition: Option<u16>,
1462 version: Option<Rc<String>>,
1463 dependencies: Rc<BTreeMap<String, WorkspaceDependency>>,
1465 },
1466 NotMember(RelPath),
1468 Absent,
1470}
1471
1472fn manifest_error(path: &RelPath, key: &str, message: String) -> LoadError {
1473 LoadError::new(
1474 path,
1475 None,
1476 LoadErrorKind::Manifest {
1477 message,
1478 source: None,
1479 },
1480 )
1481 .reached_by(&Origin::ManifestKey {
1482 key: key.to_owned(),
1483 })
1484}
1485
1486fn workspace_of(
1492 reader: &Reader<'_>,
1493 dir: &RelPath,
1494 caches: &mut Caches,
1495) -> Result<WorkspaceOf, LoadError> {
1496 let (tree, meter) = (reader.tree, reader.meter);
1497 if let Some(known) = caches.workspaces.get(dir) {
1498 return Ok(known.clone());
1499 }
1500 let origin = Origin::Discovery;
1501 let mut at = Some(dir.clone());
1502 let mut found = WorkspaceOf::Absent;
1503 while let Some(current) = at {
1504 let path = current
1505 .join("Cargo.toml")
1506 .map_err(|error| LoadError::tree(¤t, None, &origin, error.into()))?;
1507 let present = tree
1508 .entry(&path)
1509 .map_err(|error| LoadError::tree(&path, None, &origin, error))?;
1510 if present.is_some() {
1511 let text = tree
1512 .read(&path, meter.options().max_file_bytes)
1513 .map_err(|error| LoadError::tree(&path, None, &origin, error))?;
1514 meter
1515 .read(&path, &text)
1516 .map_err(|error| error.reached_by(&origin))?;
1517 let parsed = manifest::parse(&text).map_err(|problem| {
1518 let origin = problem
1519 .key
1520 .map_or(Origin::Discovery, |key| Origin::ManifestKey { key });
1521 LoadError::new(
1522 &path,
1523 None,
1524 LoadErrorKind::Manifest {
1525 message: problem.message,
1526 source: problem.source,
1527 },
1528 )
1529 .reached_by(&origin)
1530 })?;
1531 if parsed.has_workspace {
1532 let set = match caches.members.entry(current.clone()) {
1533 std::collections::btree_map::Entry::Occupied(known) => known.into_mut(),
1534 std::collections::btree_map::Entry::Vacant(slot) => {
1535 slot.insert(members(tree, meter, ¤t, &path, &parsed)?)
1536 }
1537 };
1538 found = if set.contains(dir) {
1539 let version = parsed
1540 .workspace_version
1541 .map(|version| {
1542 meter.items(
1543 version
1544 .len()
1545 .saturating_add(size_of::<String>())
1546 .saturating_add(2 * size_of::<usize>()),
1547 &path,
1548 None,
1549 )?;
1550 Ok::<_, LoadError>(Rc::new(version))
1551 })
1552 .transpose()?;
1553 WorkspaceOf::Member {
1554 dir: current,
1555 edition: parsed.workspace_edition,
1556 version,
1557 dependencies: Rc::new(parsed.workspace_dependencies),
1558 }
1559 } else {
1560 WorkspaceOf::NotMember(path)
1561 };
1562 break;
1563 }
1564 }
1565 at = current.parent();
1566 }
1567 caches.workspaces.insert(dir.clone(), found.clone());
1568 Ok(found)
1569}
1570
1571fn package_info(
1580 reader: &Reader<'_>,
1581 package: &Package,
1582 declared: &PackageDecl,
1583 manifest: &Manifest,
1584 caches: &mut Caches,
1585) -> Result<PackageInfo, LoadError> {
1586 let edition = match &declared.edition {
1587 EditionDecl::Explicit(edition) => *edition,
1588 EditionDecl::Unset => 2015,
1589 EditionDecl::Inherited => match workspace_of(reader, &package.dir, caches)? {
1590 WorkspaceOf::Member {
1591 edition: Some(edition),
1592 ..
1593 } => edition,
1594 WorkspaceOf::Member { edition: None, .. } | WorkspaceOf::Absent => {
1595 return Err(manifest_error(
1596 &package.manifest,
1597 "package.edition",
1598 "`edition.workspace = true` but no `[workspace.package] edition` is set by the nearest workspace manifest above the package"
1599 .to_owned(),
1600 ));
1601 }
1602 WorkspaceOf::NotMember(workspace) => {
1603 return Err(manifest_error(
1604 &package.manifest,
1605 "package.edition",
1606 format!(
1607 "`edition.workspace = true` but the package is not a member of the workspace {workspace} (it is not listed in `workspace.members`, or is excluded)"
1608 ),
1609 ));
1610 }
1611 },
1612 };
1613 let mut dependencies = Vec::new();
1614 for dependency in &manifest.dependencies {
1615 dependencies.push(dependency_info(reader, package, dependency, caches)?);
1616 }
1617 Ok(PackageInfo {
1618 configured: false,
1619 edition,
1620 dependencies,
1621 })
1622}
1623
1624fn dependency_declarations(
1627 reader: &Reader<'_>,
1628 package: &Package,
1629 manifest: &Manifest,
1630 caches: &mut Caches,
1631) -> Result<Vec<DependencyDeclaration>, LoadError> {
1632 let mut declarations = Vec::new();
1633 let mut admission = ItemAdmission::new(reader.meter, &package.manifest);
1634 Memory::new(&mut admission)
1635 .reserve(&mut declarations, manifest.dependencies.len())
1636 .map_err(|error| admission.error(error))?;
1637 for dependency in &manifest.dependencies {
1638 let inherited = if dependency.declaration.specification.workspace {
1639 let WorkspaceOf::Member {
1641 dir, dependencies, ..
1642 } = workspace_of(reader, &package.dir, caches)?
1643 else {
1644 return Err(internal(
1645 &package.manifest,
1646 None,
1647 "validated workspace dependency lost its workspace".to_owned(),
1648 ));
1649 };
1650 let entry = dependencies.get(&dependency.name).ok_or_else(|| {
1651 internal(
1652 &package.manifest,
1653 None,
1654 "validated workspace dependency lost its declaration".to_owned(),
1655 )
1656 })?;
1657 let manifest = dir
1658 .join("Cargo.toml")
1659 .map_err(|error| internal(&package.manifest, None, error.to_string()))?;
1660 reader.meter.items(
1661 manifest
1662 .as_str()
1663 .len()
1664 .saturating_add(entry.specification.heap_bytes()),
1665 &package.manifest,
1666 None,
1667 )?;
1668 Some(InheritedDependency {
1669 manifest,
1670 specification: entry.specification.clone(),
1671 })
1672 } else {
1673 None
1674 };
1675 let original = &dependency.declaration;
1676 let bytes = original
1677 .key
1678 .len()
1679 .saturating_add(original.name.len())
1680 .saturating_add(original.condition.as_ref().map_or(0, String::len))
1681 .saturating_add(original.specification.heap_bytes());
1682 reader.meter.items(bytes, &package.manifest, None)?;
1683 let mut declaration = original.clone();
1684 declaration.inherited = inherited;
1685 declarations.push(declaration);
1686 }
1687 Ok(declarations)
1688}
1689
1690fn dependency_info(
1694 reader: &Reader<'_>,
1695 package: &Package,
1696 dependency: &Dependency,
1697 caches: &mut Caches,
1698) -> Result<DependencyInfo, LoadError> {
1699 let mut renamed = dependency.package.is_some();
1700 let place = match &dependency.path {
1701 None => None,
1702 Some(PathSource::Own(path)) => Some((package.dir.clone(), path.clone())),
1703 Some(PathSource::Workspace(name)) => match workspace_of(reader, &package.dir, caches)? {
1704 WorkspaceOf::Member {
1705 dir, dependencies, ..
1706 } => {
1707 let Some(entry) = dependencies.get(name) else {
1708 return Err(manifest_error(
1709 &package.manifest,
1710 &dependency.key,
1711 format!(
1712 "`workspace = true` but the workspace in {dir} has no `[workspace.dependencies]` entry `{name}`"
1713 ),
1714 ));
1715 };
1716 renamed |= entry.package.is_some();
1717 entry.path.clone().map(|path| (dir, path))
1718 }
1719 WorkspaceOf::NotMember(workspace) => {
1720 return Err(manifest_error(
1721 &package.manifest,
1722 &dependency.key,
1723 format!(
1724 "`workspace = true` but the package is not a member of the workspace {workspace} (it is not listed in `workspace.members`, or is excluded)"
1725 ),
1726 ));
1727 }
1728 WorkspaceOf::Absent => {
1729 return Err(manifest_error(
1730 &package.manifest,
1731 &dependency.key,
1732 "`workspace = true` but there is no workspace manifest above the package"
1733 .to_owned(),
1734 ));
1735 }
1736 },
1737 };
1738 let named = match place {
1739 None => None,
1740 Some((base, relative)) => match base.join(&relative) {
1741 Ok(joined) => {
1742 let target = tidy(reader.tree, &joined).map_err(|error| {
1743 LoadError::tree(&package.manifest, None, &Origin::Discovery, error)
1744 })?;
1745 let matching = try_equal_range_by(reader.dirs, |id| {
1746 Ok::<_, Infallible>(reader.found[id.index()].package.dir.cmp(&target))
1747 })
1748 .unwrap_or_else(|never| match never {});
1749 reader
1750 .dirs
1751 .get(matching.start)
1752 .copied()
1753 .filter(|_| !matching.is_empty())
1754 }
1755 Err(PathError::AboveRoot { .. } | PathError::Absolute { .. }) => None,
1758 Err(other) => {
1759 return Err(manifest_error(
1760 &package.manifest,
1761 &dependency.key,
1762 other.to_string(),
1763 ));
1764 }
1765 },
1766 };
1767 Ok(DependencyInfo {
1768 kind: dependency.kind,
1769 name: dependency.name.replace('-', "_"),
1770 renamed,
1771 package: named,
1772 active_targets: None,
1773 })
1774}
1775
1776fn source_files(
1777 visited: BTreeMap<RelPath, Visited>,
1778 targets: &[Target],
1779) -> Result<BTreeMap<RelPath, SourceFile>, LoadError> {
1780 visited
1781 .into_iter()
1782 .map(|(path, visited)| source_file(&path, visited, targets).map(|file| (path, file)))
1783 .collect()
1784}
1785
1786fn selected_targets(
1787 derived: Vec<(&RelPath, crate::target::Derived)>,
1788) -> Result<(Vec<Target>, Vec<Origin>), LoadError> {
1789 check_crate_paths(&derived)?;
1790 Ok(derived
1791 .into_iter()
1792 .map(|(_, item)| (item.target, item.origin))
1793 .unzip())
1794}
1795
1796fn configure_targets(
1797 reader: &Reader<'_>,
1798 dependencies: &[Vec<DependencyDeclaration>],
1799 binding: Option<&locked::BindingLoad<'_>>,
1800 locked: &mut [LockedBinding],
1801 infos: &mut [PackageInfo],
1802 derived: &mut Vec<(&RelPath, crate::target::Derived)>,
1803 syntax: SyntaxLoad<'_>,
1804) -> Result<Option<crate::ActiveConfiguration>, LoadError> {
1805 if matches!(syntax, SyntaxLoad::ShippingMembers) {
1806 derived.retain(|(_, entry)| entry.target.shipping);
1807 }
1808 if let Some(binding) = binding
1809 && locked::configure(binding, reader.found, dependencies, locked, reader.meter)?
1810 {
1811 locked::select_targets(locked, derived, reader.meter)?;
1812 }
1813 syntax
1814 .declared()
1815 .map(|configuration| {
1816 selected::configure(reader, dependencies, infos, derived, configuration)
1817 })
1818 .transpose()
1819}
1820
1821fn walk_source_syntax(
1822 tree: &dyn Tree,
1823 targets: &[Target],
1824 origins: &[Origin],
1825 bindings: &[LockedBinding],
1826 selected: Option<&crate::ActiveConfiguration>,
1827 meter: &Meter,
1828 syntax: SyntaxLoad<'_>,
1829) -> Result<SourceWalk, LoadError> {
1830 #[cfg(target_os = "linux")]
1831 if let Some((parallel, configurations)) = match syntax {
1832 SyntaxLoad::ConfiguredParallel(_, parallel) => {
1833 let active = selected.ok_or_else(|| {
1834 internal(
1835 &RelPath::root(),
1836 None,
1837 "parallel target configuration was not admitted".to_owned(),
1838 )
1839 })?;
1840 Some((
1841 parallel,
1842 crate::parse::parallel::ExtractionConfigurations::Selected(active),
1843 ))
1844 }
1845 SyntaxLoad::LockedParallel(parallel) => Some((
1846 parallel,
1847 crate::parse::parallel::ExtractionConfigurations::Locked(bindings),
1848 )),
1849 _ => None,
1850 } {
1851 let resources = crate::parse::parallel::Resources::new(parallel)?;
1852 return std::thread::scope(|scope| {
1853 let parser = crate::parse::parallel::Executor::new(
1854 scope,
1855 &resources,
1856 parallel,
1857 Some((meter.options(), configurations)),
1858 )?;
1859 let walked = walk_sources(
1860 tree,
1861 targets,
1862 origins,
1863 bindings,
1864 selected,
1865 meter,
1866 Some(&parser),
1867 );
1868 let parallel_usage = Some(parser.finish());
1869 walked.map(|walked| SourceWalk {
1870 walked,
1871 parallel_usage,
1872 })
1873 });
1874 }
1875 let parser = match syntax {
1876 SyntaxLoad::Ordinary(parser) => parser,
1877 _ => None,
1878 };
1879 let walked = walk_sources(tree, targets, origins, bindings, selected, meter, parser)?;
1880 Ok(SourceWalk {
1881 walked,
1882 #[cfg(target_os = "linux")]
1883 parallel_usage: None,
1884 })
1885}
1886
1887fn walk_sources(
1888 tree: &dyn Tree,
1889 targets: &[Target],
1890 origins: &[Origin],
1891 bindings: &[LockedBinding],
1892 selected: Option<&crate::ActiveConfiguration>,
1893 meter: &Meter,
1894 parser: Option<&dyn crate::parse::Parser>,
1895) -> Result<Walked, LoadError> {
1896 let mut walker = Walker::with_parser(tree, meter, parser);
1897 let mut frontier = 1;
1898 for (index, (target, origin)) in targets.iter().zip(origins).enumerate() {
1899 frontier = frontier.max(index + 1);
1900 if let Some(parser) = parser {
1901 while parser.has_capacity() && frontier < targets.len() {
1902 if !walker.speculate(&targets[frontier].root) {
1903 break;
1904 }
1905 frontier += 1;
1906 }
1907 }
1908 let locked = bindings
1909 .get(target.package_id.index())
1910 .map(|proof| {
1911 proof.admitted_configuration_for_under(
1912 target.kind,
1913 &target.name,
1914 meter,
1915 &target.root,
1916 )
1917 })
1918 .transpose()?
1919 .flatten();
1920 let configuration = selected
1921 .map(|active| WalkConfiguration {
1922 package: target.package_id,
1923 active,
1924 #[cfg(target_os = "linux")]
1925 key: ConfigurationKey::Selected,
1926 })
1927 .or_else(|| {
1928 locked.map(|configuration| WalkConfiguration {
1929 package: target.package_id,
1930 active: configuration.active,
1931 #[cfg(target_os = "linux")]
1932 key: ConfigurationKey::Locked(target.package_id, configuration.ordinal),
1933 })
1934 });
1935 walker.configure(configuration);
1936 walker.root(TargetId(index), &target.root, &target.crate_path, origin)?;
1937 }
1938 walker.finish()
1939}
1940
1941fn internal(file: &RelPath, line: Option<usize>, what: String) -> LoadError {
1942 LoadError::new(file, line, LoadErrorKind::Internal { what })
1943}
1944
1945fn test_fn_of(item: &Item, targets: &[Target]) -> Result<TestFn, LoadError> {
1947 let target = targets.get(item.target.index()).ok_or_else(|| {
1948 internal(
1949 &item.file,
1950 Some(item.name_line),
1951 format!(
1952 "the target {} of `{}` does not exist",
1953 item.target.index(),
1954 item.path
1955 ),
1956 )
1957 })?;
1958 let name = item
1959 .path
1960 .strip_prefix(&target.crate_path)
1961 .and_then(|rest| rest.strip_prefix("::"))
1962 .ok_or_else(|| {
1963 internal(
1964 &item.file,
1965 Some(item.name_line),
1966 format!(
1967 "the path `{}` does not start with the crate path `{}`",
1968 item.path, target.crate_path
1969 ),
1970 )
1971 })?;
1972 Ok(TestFn {
1973 id: item.id,
1974 package: target.package.clone(),
1975 kind: target.kind,
1976 target: target.name.clone(),
1977 name: name.to_owned(),
1978 })
1979}
1980
1981fn source_file(
1983 path: &RelPath,
1984 visited: Visited,
1985 targets: &[Target],
1986) -> Result<SourceFile, LoadError> {
1987 let target_of = |reach: &Reach| {
1988 targets.get(reach.target.index()).ok_or_else(|| {
1989 internal(
1990 path,
1991 None,
1992 format!(
1993 "the target {} of a module path does not exist",
1994 reach.target.index()
1995 ),
1996 )
1997 })
1998 };
1999 let Some(first) = visited.reached.first() else {
2000 return Err(internal(
2001 path,
2002 None,
2003 "a loaded file has no module path".to_owned(),
2004 ));
2005 };
2006 let package = target_of(first)?.package.clone();
2007 let mut shipping = false;
2008 let mut test = true;
2009 for reach in &visited.reached {
2010 let target = target_of(reach)?;
2011 if !reach.test {
2012 test = false;
2013 shipping |= target.shipping;
2014 }
2015 }
2016 let parsed = Rc::unwrap_or_clone(visited.parsed);
2017 Ok(SourceFile {
2018 path: path.clone(),
2019 package,
2020 shipping,
2021 test,
2022 text: parsed.text,
2023 facts: parsed.facts,
2024 reached: visited.reached,
2025 })
2026}
2027
2028#[derive(Debug, Clone, PartialEq, Eq)]
2030#[non_exhaustive]
2031pub struct TestFn {
2032 pub id: ItemId,
2034 pub package: String,
2036 pub kind: TargetKind,
2039 pub target: String,
2041 pub name: String,
2043}
2044
2045#[cfg(test)]
2046mod tests {
2047 use super::*;
2048 use crate::budget::Budget;
2049 use crate::tree::MemoryTree;
2050
2051 #[test]
2052 fn native_package_name_index_keeps_identity_and_enforces_its_exact_grant() {
2053 let packages: Vec<_> = (0..24)
2054 .map(|index| Package {
2055 name: format!("package-{:02}", 23 - index),
2056 manifest: RelPath::new(&format!("p{index}/Cargo.toml")).expect("manifest"),
2057 dir: RelPath::new(&format!("p{index}")).expect("directory"),
2058 })
2059 .collect();
2060 let meter = Meter::new(&LoadOptions::default());
2061 let names = package_name_index(&packages, &meter).expect("native index");
2062 assert_eq!(names, (0..24).rev().map(PackageId).collect::<Vec<_>>());
2063 let charged = meter.usage().item_bytes;
2064 let exact = Meter::new(&LoadOptions {
2065 max_item_bytes: charged,
2066 ..LoadOptions::default()
2067 });
2068 assert_eq!(
2069 package_name_index(&packages, &exact).expect("exact grant"),
2070 names
2071 );
2072 let insufficient = Meter::new(&LoadOptions {
2073 max_item_bytes: charged - 1,
2074 ..LoadOptions::default()
2075 });
2076 let error = package_name_index(&packages, &insufficient).expect_err("one byte short");
2077 assert!(matches!(error.kind, LoadErrorKind::Budget {
2078 budget: Budget::ItemBytes,
2079 limit,
2080 } if limit == charged - 1));
2081 assert_eq!(error.file, RelPath::root());
2082 }
2083
2084 #[test]
2085 fn a_test_function_whose_path_leaves_its_crate_path_is_a_typed_error() {
2086 let tree = MemoryTree::from([
2087 ("Cargo.toml", "[package]\nname = \"demo\"\n"),
2088 ("src/lib.rs", "#[test]\nfn case() {}\n"),
2089 ]);
2090 let ws = Workspace::load(&tree, &["."]).expect("loads");
2091 let fns = ws.test_fns().expect("the invariant holds");
2092 assert_eq!(fns.len(), 1);
2093 let mut item = ws.item(fns[0].id).expect("item").clone();
2094 assert!(test_fn_of(&item, &ws.targets).is_ok());
2095 item.path = "other::case".into();
2096 let error = test_fn_of(&item, &ws.targets).expect_err("the path leaves the crate");
2097 assert!(
2098 matches!(error.kind, LoadErrorKind::Internal { .. }),
2099 "{error}"
2100 );
2101 assert_eq!(error.line, Some(2));
2102 item.path = "demo::case".into();
2103 item.target = TargetId(9);
2104 assert!(test_fn_of(&item, &ws.targets).is_err());
2105 }
2106}