use std::cell::{OnceCell, RefCell};
use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
use std::path::{Path, PathBuf};
use std::rc::Rc;
use serde_json::Value;
use xuanji::ScanDepth;
use crate::cargo_metadata::root_reading;
use crate::errors::{missing_src_error, out_of_package_root_error, walk_refusal_in_unit};
use super::source_texts::SourceTexts;
use super::{UnitScan, governed_files, names_crate_by_path_alone, reachable_modules, rust_files};
fn package_src_dir(package: &Value) -> Option<PathBuf> {
package["manifest_path"]
.as_str()
.and_then(|manifest| Path::new(manifest).parent())
.map(|crate_dir| crate_dir.join("src"))
}
pub(crate) struct RootScan {
pub(crate) src_dir: PathBuf,
pub(crate) root_relative: Option<PathBuf>,
pub(crate) unit: Option<String>,
pub(crate) files: Vec<PathBuf>,
pub(crate) reachable: BTreeSet<String>,
pub(crate) inline_only: BTreeMap<String, PathBuf>,
pub(crate) remapped: Vec<(PathBuf, String)>,
pub(crate) remap_shadowed: BTreeSet<String>,
all_files: Vec<(PathBuf, String)>,
unit_scan: UnitScan,
item_definitions: OnceCell<BTreeSet<String>>,
}
impl RootScan {
fn read(
sources: Rc<SourceTexts>,
package: &Value,
crate_package: &str,
root_file: Option<&Path>,
sibling_roots: Option<&[PathBuf]>,
) -> Result<Self, String> {
let src_dir = match root_file.and_then(Path::parent) {
Some(dir) => dir.to_path_buf(),
None => package_src_dir(package).ok_or_else(|| missing_src_error(crate_package))?,
};
let root_relative = root_file
.and_then(|root| root.strip_prefix(&src_dir).ok())
.map(Path::to_path_buf);
let unit = match root_file {
Some(root) => Some(
crate::cargo_metadata::compilation_unit_label(package, root)
.ok_or_else(|| out_of_package_root_error(crate_package, root))?,
),
None => None,
};
let reading = root_reading(package, root_file, crate_package)?;
let mut files = rust_files(&src_dir)?;
if let Some(siblings) = sibling_roots {
files.retain(|file| {
root_file.is_some_and(|root| root == file.as_path()) || !siblings.contains(file)
});
}
files.retain(|file| !names_crate_by_path_alone(file, &src_dir, root_relative.as_deref()));
let (reachable, inline_only, remapped, remap_shadowed) = reachable_modules(
&sources,
&src_dir,
&files,
root_relative.as_deref(),
reading.edition,
)
.map_err(|refusal| walk_refusal_in_unit(crate_package, unit.as_deref(), &refusal))?;
let all_files = governed_files(
&src_dir,
&files,
"crate",
&reachable,
&inline_only,
&remapped,
&remap_shadowed,
root_relative.as_deref(),
ScanDepth::Subtree,
);
let dependencies = crate::cargo_metadata::dependency_import_names(package)
.into_iter()
.chain(crate::cargo_metadata::library_import_names(package))
.collect();
let unit_scan = UnitScan::read(
&sources,
&all_files,
reading.edition,
reading.proc_macro,
dependencies,
)?;
Ok(RootScan {
src_dir,
root_relative,
unit,
files,
reachable,
inline_only,
remapped,
remap_shadowed,
all_files,
unit_scan,
item_definitions: OnceCell::new(),
})
}
pub(crate) fn unit_label(&self) -> &str {
self.unit.as_deref().unwrap_or("src")
}
pub(crate) fn all_files(&self) -> &[(PathBuf, String)] {
&self.all_files
}
pub(crate) fn unit_scan(&self) -> &UnitScan {
&self.unit_scan
}
pub(crate) fn item_definitions(&self) -> &BTreeSet<String> {
self.item_definitions
.get_or_init(|| self.unit_scan.item_definitions())
}
pub(crate) fn governed_module_value_items(
&self,
governed_module: &str,
) -> Result<HashSet<String>, String> {
let mut items = HashSet::new();
for (file, module) in governed_files(
&self.src_dir,
&self.files,
governed_module,
&self.reachable,
&self.inline_only,
&self.remapped,
&self.remap_shadowed,
self.root_relative.as_deref(),
ScanDepth::Shallow,
) {
items.extend(self.unit_scan.value_items(&file, &module)?);
}
Ok(items)
}
}
type RootKey = (String, Option<PathBuf>);
pub(crate) struct EvaluationScans {
scans: RefCell<HashMap<RootKey, Rc<RootScan>>>,
sources: Rc<SourceTexts>,
#[cfg(test)]
sharing: Sharing,
#[cfg(test)]
builds: std::cell::Cell<usize>,
}
#[cfg(test)]
#[derive(Clone, Copy, PartialEq, Eq)]
enum Sharing {
Shared,
Independent,
}
impl EvaluationScans {
pub(crate) fn shared() -> Self {
EvaluationScans {
scans: RefCell::new(HashMap::new()),
sources: Rc::default(),
#[cfg(test)]
sharing: Sharing::Shared,
#[cfg(test)]
builds: std::cell::Cell::new(0),
}
}
#[cfg(test)]
pub(crate) fn independent() -> Self {
EvaluationScans {
scans: RefCell::new(HashMap::new()),
sources: Rc::default(),
sharing: Sharing::Independent,
builds: std::cell::Cell::new(0),
}
}
pub(crate) fn root_scan(
&self,
package: &Value,
crate_package: &str,
root_file: Option<&Path>,
sibling_roots: Option<&[PathBuf]>,
) -> Result<Rc<RootScan>, String> {
#[cfg(test)]
if self.sharing == Sharing::Independent {
return Ok(Rc::new(self.build(
package,
crate_package,
root_file,
sibling_roots,
)?));
}
let key: RootKey = (crate_package.to_string(), root_file.map(Path::to_path_buf));
if let Some(scan) = self.scans.borrow().get(&key) {
return Ok(Rc::clone(scan));
}
let scan = Rc::new(self.build(package, crate_package, root_file, sibling_roots)?);
self.scans.borrow_mut().insert(key, Rc::clone(&scan));
Ok(scan)
}
fn build(
&self,
package: &Value,
crate_package: &str,
root_file: Option<&Path>,
sibling_roots: Option<&[PathBuf]>,
) -> Result<RootScan, String> {
#[cfg(test)]
self.builds.set(self.builds.get() + 1);
#[cfg(test)]
if self.sharing == Sharing::Independent {
return RootScan::read(
Rc::default(),
package,
crate_package,
root_file,
sibling_roots,
);
}
RootScan::read(
Rc::clone(&self.sources),
package,
crate_package,
root_file,
sibling_roots,
)
}
#[cfg(test)]
pub(crate) fn roots_built(&self) -> usize {
self.builds.get()
}
#[cfg(test)]
pub(crate) fn source_reads(&self) -> HashMap<PathBuf, usize> {
self.sources.reads()
}
#[cfg(test)]
pub(crate) fn classifications(&self) -> HashMap<(PathBuf, String), usize> {
let mut counts = HashMap::new();
for root in self.scans.borrow().values() {
for (pair, count) in root.unit_scan().classifications() {
*counts.entry(pair).or_default() += count;
}
}
counts
}
}