use crate::error::{LoadError, LoadErrorKind, Origin, TargetProblem, TreeError};
use crate::manifest::{Build, Manifest, PackageDecl, TargetDecl, TargetSettings};
use crate::modtree::tidy;
use crate::path::RelPath;
use crate::tree::{EntryKind, Tree};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct PackageId(pub(crate) usize);
impl PackageId {
#[must_use]
pub const fn index(self) -> usize {
self.0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[non_exhaustive]
pub enum TargetKind {
Lib,
Bin,
Test,
Bench,
Example,
BuildScript,
}
impl TargetKind {
#[must_use]
pub const fn is_shipping(self) -> bool {
matches!(self, Self::Lib | Self::Bin | Self::BuildScript)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct Package {
pub name: String,
pub manifest: RelPath,
pub dir: RelPath,
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
#[expect(
clippy::struct_excessive_bools,
reason = "harness, test and doctest are Cargo's boolean target keys, kept one to one"
)]
pub struct Target {
pub package_id: PackageId,
pub package: String,
pub name: String,
pub kind: TargetKind,
pub crate_path: String,
pub root: RelPath,
pub shipping: bool,
pub harness: bool,
pub required_features: Vec<String>,
pub test: bool,
pub doctest: bool,
}
pub(crate) struct Derived {
pub(crate) target: Target,
pub(crate) origin: Origin,
}
fn ident(name: &str) -> String {
name.replace('-', "_")
}
pub(crate) struct Context<'a> {
pub(crate) package_id: PackageId,
pub(crate) tree: &'a dyn Tree,
pub(crate) manifest_path: &'a RelPath,
pub(crate) dir: &'a RelPath,
pub(crate) manifest: &'a Manifest,
pub(crate) package: &'a PackageDecl,
}
impl Context<'_> {
fn error(&self, origin: &Origin, kind: LoadErrorKind) -> LoadError {
LoadError::new(self.manifest_path, None, kind).reached_by(origin)
}
fn tree_error(&self, origin: &Origin, error: TreeError) -> LoadError {
LoadError::tree(self.manifest_path, None, origin, error)
}
fn join(&self, relative: &str, origin: &Origin) -> Result<RelPath, LoadError> {
let joined = self
.dir
.join(relative)
.map_err(|error| self.tree_error(origin, error.into()))?;
tidy(self.tree, &joined).map_err(|error| self.tree_error(origin, error))
}
fn is_file(&self, path: &RelPath, origin: &Origin) -> Result<bool, LoadError> {
match self
.tree
.entry(path)
.map_err(|error| self.tree_error(origin, error))?
{
Some(EntryKind::File | EntryKind::Symlink | EntryKind::Other) => Ok(true),
Some(EntryKind::Dir) | None => Ok(false),
}
}
fn list(&self, relative: &str) -> Result<Vec<crate::tree::Entry>, LoadError> {
let origin = Origin::Discovery;
let path = self.join(relative, &origin)?;
match self
.tree
.entry(&path)
.map_err(|error| self.tree_error(&origin, error))?
{
None => Ok(Vec::new()),
Some(EntryKind::Dir) => self
.tree
.list(&path)
.map_err(|error| LoadError::tree(&path, None, &origin, error)),
Some(EntryKind::Symlink) => {
Err(LoadError::new(&path, None, LoadErrorKind::DirSymlink).reached_by(&origin))
}
Some(EntryKind::File | EntryKind::Other) => Err(LoadError::tree(
&path,
None,
&origin,
TreeError::NotRegular {
path: path.to_string(),
},
)),
}
}
fn missing(&self, path: RelPath, origin: &Origin) -> LoadError {
self.error(
origin,
LoadErrorKind::Target(Box::new(TargetProblem::MissingFile { path })),
)
}
fn derive(
&self,
name: &str,
kind: TargetKind,
crate_path: String,
root: RelPath,
origin: Origin,
settings: Option<&TargetSettings>,
) -> Derived {
let defaults = TargetSettings::default();
let settings = settings.unwrap_or(&defaults);
let tested = kind != TargetKind::BuildScript;
Derived {
target: Target {
package_id: self.package_id,
package: self.package.name.clone(),
name: name.to_owned(),
kind,
crate_path,
root,
shipping: kind.is_shipping(),
harness: settings.harness.unwrap_or(tested),
required_features: settings.required_features.clone(),
test: settings.test.unwrap_or(matches!(
kind,
TargetKind::Lib | TargetKind::Bin | TargetKind::Test
)),
doctest: settings.doctest.unwrap_or(kind == TargetKind::Lib),
},
origin,
}
}
fn key(table: &str, field: &str) -> Origin {
Origin::ManifestKey {
key: format!("{table}.{field}"),
}
}
fn pick(&self, candidates: &[String], origin: &Origin) -> Result<Option<RelPath>, LoadError> {
let mut found: Vec<RelPath> = Vec::new();
for candidate in candidates {
let path = self.join(candidate, origin)?;
if self.is_file(&path, origin)? {
found.push(path);
}
}
match found.as_slice() {
[] => Ok(None),
[only] => Ok(Some(only.clone())),
[first, second, ..] => Err(self.error(
origin,
LoadErrorKind::Target(Box::new(TargetProblem::AmbiguousRoot {
first: first.clone(),
second: second.clone(),
})),
)),
}
}
fn library(&self, out: &mut Vec<Derived>) -> Result<(), LoadError> {
let explicit = self.manifest.lib.as_ref();
if explicit.is_none() && !self.package.auto("lib") {
return Ok(());
}
let written = explicit.and_then(|lib| lib.path.as_deref());
let origin = match (written, explicit) {
(Some(_), _) => Self::key("lib", "path"),
(None, Some(_)) => Origin::ManifestKey {
key: "lib".to_owned(),
},
(None, None) => Origin::Discovery,
};
let relative = written.unwrap_or("src/lib.rs");
let root = self.join(relative, &origin)?;
if self.is_file(&root, &origin)? {
let name = explicit
.and_then(|lib| lib.name.clone())
.unwrap_or_else(|| self.package.name.clone());
let crate_path = ident(&name);
let settings = explicit.map(|lib| &lib.settings);
out.push(self.derive(&name, TargetKind::Lib, crate_path, root, origin, settings));
Ok(())
} else if explicit.is_some() {
Err(self.missing(root, &origin))
} else {
Ok(())
}
}
fn binaries(&self, out: &mut Vec<Derived>) -> Result<(), LoadError> {
let package = &self.package.name;
for declared in &self.manifest.bins {
let name = declared.name.clone().ok_or_else(|| self.no_name("bin"))?;
let (origin, root) = if let Some(path) = &declared.path {
let origin = Self::key("bin", "path");
let root = self.join(path, &origin)?;
if !self.is_file(&root, &origin)? {
return Err(self.missing(root, &origin));
}
(origin, root)
} else {
let origin = Self::key("bin", "name");
let mut candidates = Vec::new();
if &name == package {
candidates.push("src/main.rs".to_owned());
}
candidates.push(format!("src/bin/{name}.rs"));
candidates.push(format!("src/bin/{name}/main.rs"));
let Some(root) = self.pick(&candidates, &origin)? else {
let first = self.join(&candidates[0], &origin)?;
return Err(self.missing(first, &origin));
};
(origin, root)
};
let crate_path = format!("{}::bin_crate::{}", ident(package), ident(&name));
out.push(self.derive(
&name,
TargetKind::Bin,
crate_path,
root,
origin,
Some(&declared.settings),
));
}
if !self.package.auto("bin") {
return Ok(());
}
let origin = Origin::Discovery;
let main = self.join("src/main.rs", &origin)?;
if self.is_file(&main, &origin)? {
self.add_inferred(out, package, TargetKind::Bin, main);
}
self.infer_from("src/bin", TargetKind::Bin, out)
}
fn no_name(&self, table: &str) -> LoadError {
self.error(
&Self::key(table, "name"),
LoadErrorKind::Target(Box::new(TargetProblem::NoName)),
)
}
fn add_inferred(&self, out: &mut Vec<Derived>, name: &str, kind: TargetKind, root: RelPath) {
let taken = out
.iter()
.any(|d| d.target.kind == kind && (d.target.name == name || d.target.root == root));
if !taken {
let crate_path = self.crate_path(kind, name);
out.push(self.derive(name, kind, crate_path, root, Origin::Discovery, None));
}
}
fn crate_path(&self, kind: TargetKind, name: &str) -> String {
let package = ident(&self.package.name);
let segment = match kind {
TargetKind::Bin => "bin_crate",
TargetKind::Test => "test_crate",
TargetKind::Bench => "bench_crate",
TargetKind::Example => "example_crate",
TargetKind::Lib | TargetKind::BuildScript => return ident(name),
};
format!("{package}::{segment}::{}", ident(name))
}
fn infer_from(
&self,
directory: &str,
kind: TargetKind,
out: &mut Vec<Derived>,
) -> Result<(), LoadError> {
let origin = Origin::Discovery;
for entry in self.list(directory)? {
match entry.kind {
EntryKind::File | EntryKind::Symlink => {
if let Some(stem) = entry.name.strip_suffix(".rs") {
let root = self.join(&format!("{directory}/{}", entry.name), &origin)?;
self.add_inferred(out, stem, kind, root);
}
}
EntryKind::Dir => {
let root =
self.join(&format!("{directory}/{}/main.rs", entry.name), &origin)?;
if self.is_file(&root, &origin)? {
self.add_inferred(out, &entry.name, kind, root);
}
}
EntryKind::Other => {}
}
}
Ok(())
}
fn examples_like(
&self,
table: &str,
directory: &str,
kind: TargetKind,
declared: &[TargetDecl],
auto: bool,
out: &mut Vec<Derived>,
) -> Result<(), LoadError> {
for target in declared {
let name = target.name.clone().ok_or_else(|| self.no_name(table))?;
let (origin, root) = if let Some(path) = &target.path {
let origin = Self::key(table, "path");
let root = self.join(path, &origin)?;
if !self.is_file(&root, &origin)? {
return Err(self.missing(root, &origin));
}
(origin, root)
} else {
let origin = Self::key(table, "name");
let candidates = [
format!("{directory}/{name}.rs"),
format!("{directory}/{name}/main.rs"),
];
let Some(root) = self.pick(&candidates, &origin)? else {
let first = self.join(&candidates[0], &origin)?;
return Err(self.missing(first, &origin));
};
(origin, root)
};
let crate_path = self.crate_path(kind, &name);
out.push(self.derive(
&name,
kind,
crate_path,
root,
origin,
Some(&target.settings),
));
}
if auto {
self.infer_from(directory, kind, out)?;
}
Ok(())
}
fn build_script(&self, out: &mut Vec<Derived>) -> Result<(), LoadError> {
let (origin, relative) = match &self.package.build {
Build::Disabled => return Ok(()),
Build::Path(path) => (Self::key("package", "build"), path.as_str()),
Build::Default => (Origin::Discovery, "build.rs"),
};
let root = self.join(relative, &origin)?;
if self.is_file(&root, &origin)? {
let crate_path = format!("{}::build_script", ident(&self.package.name));
out.push(self.derive(
"build-script-build",
TargetKind::BuildScript,
crate_path,
root,
origin,
None,
));
Ok(())
} else if matches!(self.package.build, Build::Path(_)) {
Err(self.missing(root, &origin))
} else {
Ok(())
}
}
}
pub(crate) fn derive_targets(context: &Context<'_>) -> Result<Vec<Derived>, LoadError> {
let mut out = Vec::new();
context.library(&mut out)?;
context.binaries(&mut out)?;
let manifest = context.manifest;
let package = context.package;
context.examples_like(
"test",
"tests",
TargetKind::Test,
&manifest.tests,
package.auto("test"),
&mut out,
)?;
context.examples_like(
"bench",
"benches",
TargetKind::Bench,
&manifest.benches,
package.auto("bench"),
&mut out,
)?;
context.examples_like(
"example",
"examples",
TargetKind::Example,
&manifest.examples,
package.auto("example"),
&mut out,
)?;
context.build_script(&mut out)?;
for (index, derived) in out.iter().enumerate() {
if let Some(first) = out[..index]
.iter()
.find(|earlier| earlier.target.root == derived.target.root)
{
return Err(context.error(
&derived.origin,
LoadErrorKind::Target(Box::new(TargetProblem::SharedRoot {
root: derived.target.root.clone(),
other: first.target.name.clone(),
})),
));
}
}
Ok(out)
}
pub(crate) fn check_crate_paths(derived: &[(&RelPath, Derived)]) -> Result<(), LoadError> {
for (index, (manifest, later)) in derived.iter().enumerate() {
if let Some((first_manifest, first)) = derived[..index].iter().find(|(_, earlier)| {
earlier.target.package_id == later.target.package_id
&& earlier.target.crate_path == later.target.crate_path
}) {
return Err(LoadError::new(
manifest,
None,
LoadErrorKind::Target(Box::new(TargetProblem::DuplicateCratePath {
crate_path: later.target.crate_path.clone(),
other: first.target.name.clone(),
with: (*first_manifest).clone(),
})),
)
.reached_by(&later.origin));
}
}
Ok(())
}