use std::collections::{BTreeMap, BTreeSet, HashMap};
use std::mem::size_of;
use std::sync::Arc;
use purrdf_lex::allocation::Memory;
use crate::cost::{btree_entry, btree_map, hash_entry, hash_map, shared_text, vec_first, vec_slot};
use crate::error::{LoadError, LoadErrorKind};
use crate::facts::{
ConfigurationDependence, FieldShape, ImplFact, ItemFact, ItemKind, ModBody, ModFact, PathFact,
SpanFact, TestRole, UseTree, Vis,
};
use crate::glob_scope::{GlobTables, ImportReach};
use crate::intern::Interner;
use crate::item::{
DisabledSyntax, ImplBlock, ImplId, Item, ItemId, Namespace, SelfType, SharedStr, SymbolKind,
TraitKey, Unexpanded, UnresolvedImpl,
};
use crate::manifest::DependencyKind;
use crate::meter::{ItemAdmission, LookupCount, Meter, NativeAdmission, Steps, push_item_work};
use crate::modtree::{TargetId, Visit};
use crate::path::RelPath;
use crate::settle::{Entry, ImportReadState, Origin, Scope};
use crate::target::{PackageId, Target, TargetKind};
use crate::workspace::SourceFile;
use purrdf_hash::fixed::FixedState;
use purrdf_lex::walk::WorkList;
const ITEM_BYTES: usize = vec_slot::<Item>()
+ 2 * vec_slot::<ItemId>()
+ btree_entry::<(RelPath, usize), Vec<ItemId>>()
+ vec_first::<ItemId>()
+ vec_slot::<ItemId>();
pub(crate) const MODULE_BYTES: usize = vec_slot::<Module>()
+ btree_entry::<(usize, SharedStr), usize>()
+ vec_slot::<Scope>()
+ btree_map::<String, Box<Entry>>()
+ 2 * vec_first::<ItemId>()
+ vec_slot::<(usize, Vec<ItemId>)>();
pub(crate) const MEMBERS_BYTES: usize =
btree_entry::<ItemId, BTreeMap<String, Vec<ItemId>>>() + btree_map::<String, Vec<ItemId>>();
pub(crate) const LOAD_BASE_BYTES: usize = size_of::<Vec<Option<(usize, &str)>>>()
+ btree_map::<String, Vec<usize>>()
+ btree_map::<(usize, SharedStr), usize>()
+ btree_map::<ItemId, usize>()
+ btree_map::<ItemId, usize>()
+ btree_map::<ItemId, Vec<usize>>()
+ btree_map::<ItemId, SharedStr>()
+ btree_map::<usize, ItemId>()
+ btree_map::<(RelPath, usize), Vec<ItemId>>()
+ btree_map::<ItemId, BTreeMap<String, Vec<ItemId>>>()
+ btree_map::<String, Vec<ItemId>>()
+ btree_map::<RelPath, Vec<ItemId>>()
+ btree_map::<ItemId, (usize, Arc<PathFact>)>()
+ btree_map::<RelPath, SourceFile>()
+ btree_map::<(RelPath, TargetId, SharedStr), ()>()
+ btree_map::<(TargetId, &str), Vec<&SourceFile>>()
+ hash_map::<(crate::tree::FileId, usize)>()
+ hash_map::<(RelPath, crate::tree::FileId)>()
+ 2 * hash_map::<SharedStr>()
+ hash_map::<(*const PathFact, Arc<PathFact>)>()
+ vec_first::<Item>()
+ vec_first::<Unexpanded>()
+ 3 * vec_first::<ItemId>()
+ vec_first::<Module>()
+ vec_first::<Scope>()
+ vec_first::<UseDecl>()
+ 4 * vec_first::<bool>()
+ 4 * vec_first::<[bool; 3]>()
+ vec_first::<[ImportReadState; 3]>()
+ vec_first::<BTreeSet<usize>>()
+ vec_first::<(usize, usize)>()
+ vec_first::<Visit>()
+ vec_first::<ImplDecl<'static>>()
+ vec_first::<UnresolvedImpl>()
+ vec_first::<ImplBlock>()
+ vec_first::<usize>()
+ vec_first::<BTreeMap<String, ExternName>>()
+ vec_first::<u16>()
+ vec_first::<bool>()
+ 2 * vec_first::<usize>()
+ vec_first::<(usize, u64)>();
fn name_prefix(name: &str) -> u64 {
let mut bytes = [0; 8];
let taken = name.len().min(8);
bytes[..taken].copy_from_slice(&name.as_bytes()[..taken]);
u64::from_be_bytes(bytes)
}
fn scope_bytes(name: &str, vis: &Vis, namespaces: usize) -> usize {
2 * vec_slot::<ItemId>()
+ (btree_entry::<String, Box<Entry>>() + size_of::<Entry>())
+ name.len()
+ namespaces * (vec_slot::<(ItemId, Origin)>() + vis_capacity(vis))
}
pub(crate) fn binding_bytes(name: &str, vis: &Vis, source: usize) -> usize {
(btree_entry::<String, Box<Entry>>() + size_of::<Entry>())
+ 2 * name.len()
+ vec_slot::<(ItemId, Origin)>()
+ vis_capacity(vis)
+ source
}
pub(crate) fn member_bytes(key: &str) -> usize {
btree_entry::<String, Vec<ItemId>>() + key.len() + vec_first::<ItemId>() + vec_slot::<ItemId>()
}
fn vis_capacity(vis: &Vis) -> usize {
match vis {
Vis::Restricted(text) => text.capacity(),
Vis::Inherited | Vis::Public => 0,
}
}
fn strings_bytes(strings: &[String]) -> usize {
size_of_val(strings) + strings.iter().map(String::capacity).sum::<usize>()
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) enum UseKind {
Named {
name: String,
segs: Vec<String>,
namespaces: NamedNamespaces,
},
Glob { segs: Vec<String> },
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum NamedNamespaces {
All,
TypeOnly,
}
impl NamedNamespaces {
pub(crate) fn spaces(self) -> &'static [Namespace] {
match self {
Self::All => &Namespace::ALL,
Self::TypeOnly => &[Namespace::Type],
}
}
}
impl UseKind {
pub(crate) fn terminal_namespaces(&self) -> &'static [Namespace] {
match self {
Self::Named { namespaces, .. } => namespaces.spaces(),
Self::Glob { .. } => &[Namespace::Type],
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct UseDecl {
pub(crate) module: usize,
pub(crate) file: RelPath,
pub(crate) line: usize,
pub(crate) leading_colon: bool,
pub(crate) vis: Vis,
pub(crate) test: bool,
pub(crate) doc_hidden: bool,
pub(crate) configuration: ConfigurationDependence,
pub(crate) kind: UseKind,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct PackageInfo {
pub(crate) configured: bool,
pub(crate) edition: u16,
pub(crate) dependencies: Vec<DependencyInfo>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct DependencyInfo {
pub(crate) kind: DependencyKind,
pub(crate) name: String,
pub(crate) renamed: bool,
pub(crate) package: Option<PackageId>,
pub(crate) active_targets: Option<Vec<TargetId>>,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub(crate) struct ExternName {
pub(crate) everywhere: bool,
pub(crate) roots: Vec<(usize, bool)>,
}
impl ExternName {
pub(crate) fn roots(&self, test: bool) -> impl Iterator<Item = usize> + '_ {
self.roots
.iter()
.filter(move |(_, everywhere)| *everywhere || test)
.map(|(root, _)| *root)
}
}
impl UseDecl {
pub(crate) const fn heads(&self, position: usize) -> crate::resolve::Heads {
crate::resolve::Heads::Use {
test: self.test,
own: Some(position),
}
}
pub(crate) fn clone_bytes(&self) -> usize {
let path = match &self.kind {
UseKind::Named { name, segs, .. } => name.len() + strings_bytes(segs),
UseKind::Glob { segs } => strings_bytes(segs),
};
path + self.file.as_str().len() + vis_capacity(&self.vis)
}
fn bytes(&self) -> usize {
let owned = match &self.kind {
UseKind::Named { name, segs, .. } => name.capacity() + strings_bytes(segs),
UseKind::Glob { segs } => strings_bytes(segs),
};
vec_slot::<Self>()
+ 4 * vec_slot::<bool>()
+ 4 * vec_slot::<[bool; 3]>()
+ vec_slot::<[ImportReadState; 3]>()
+ vec_slot::<BTreeSet<usize>>()
+ vec_slot::<usize>()
+ vec_slot::<(usize, u64)>()
+ owned
+ vis_capacity(&self.vis)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct ImplDecl<'f> {
pub(crate) module: usize,
pub(crate) file: RelPath,
pub(crate) target: TargetId,
pub(crate) reach_test: bool,
pub(crate) fact: &'f ImplFact,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct BlockModule {
pub(crate) module: usize,
pub(crate) parent: usize,
pub(crate) file: RelPath,
pub(crate) span: (usize, usize),
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct Module {
pub(crate) path: SharedStr,
pub(crate) parent: Option<usize>,
pub(crate) root: usize,
pub(crate) target: TargetId,
pub(crate) defs: Vec<ItemId>,
pub(crate) configuration: ConfigurationDependence,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct Index {
pub(crate) items: Vec<Item>,
pub(crate) unexpanded: Vec<Unexpanded>,
pub(crate) disabled_syntax: Vec<DisabledSyntax>,
pub(crate) order: Vec<ItemId>,
pub(crate) modules: Vec<Module>,
pub(crate) module_by_path: BTreeMap<(usize, SharedStr), usize>,
pub(crate) block_modules: Vec<BlockModule>,
pub(crate) module_of: BTreeMap<ItemId, usize>,
pub(crate) macro_modules: BTreeMap<ItemId, usize>,
pub(crate) crate_of: BTreeMap<ItemId, Vec<usize>>,
pub(crate) crate_roots: BTreeMap<String, Vec<usize>>,
pub(crate) target_roots: Vec<usize>,
pub(crate) preludes: Vec<BTreeMap<String, ExternName>>,
pub(crate) targets: Vec<Target>,
pub(crate) target_editions: Vec<u16>,
pub(crate) target_no_std: Vec<bool>,
pub(crate) crates_open: bool,
pub(crate) unresolved: Vec<UnresolvedImpl>,
pub(crate) impl_blocks: Vec<ImplBlock>,
pub(crate) scopes: Vec<Scope>,
pub(crate) uses: Vec<UseDecl>,
pub(crate) named_imports: Vec<usize>,
pub(crate) named_keys: Vec<(usize, u64)>,
pub(crate) glob_imports: Vec<usize>,
pub(crate) use_resolved: Vec<bool>,
pub(crate) use_settled: Vec<bool>,
pub(crate) use_ambiguous: Vec<bool>,
pub(crate) use_bound: Vec<[bool; 3]>,
pub(crate) use_free: Vec<[bool; 3]>,
pub(crate) use_decided: Vec<[bool; 3]>,
pub(crate) use_empty: Vec<[bool; 3]>,
pub(crate) use_read_state: Vec<[ImportReadState; 3]>,
pub(crate) has_late_imports: bool,
pub(crate) glob_closed: Vec<bool>,
pub(crate) glob_reach: Vec<BTreeSet<usize>>,
pub(crate) glob_facts: crate::resolve::GlobFactsCache,
pub(crate) lookups: LookupCount,
pub(crate) globs: GlobTables,
pub(crate) import_reach: ImportReach,
pub(crate) extern_names: BTreeMap<ItemId, SharedStr>,
pub(crate) root_items: BTreeMap<usize, ItemId>,
pub(crate) by_source: BTreeMap<(RelPath, usize), Vec<ItemId>>,
pub(crate) assoc: BTreeMap<ItemId, BTreeMap<String, Vec<ItemId>>>,
pub(crate) foreign: BTreeMap<String, Vec<ItemId>>,
pub(crate) by_file: BTreeMap<RelPath, Vec<ItemId>>,
pub(crate) aliases: BTreeMap<ItemId, (usize, Arc<PathFact>, ConfigurationDependence)>,
}
pub(crate) struct Store<'m> {
strings: Interner,
meter: &'m Meter,
}
impl Store<'_> {
pub(crate) fn meter(&self) -> &Meter {
self.meter
}
pub(crate) fn intern(&mut self, text: &str) -> (SharedStr, usize) {
self.strings.intern(text)
}
pub(crate) fn charge(
&self,
bytes: usize,
file: &RelPath,
line: Option<usize>,
) -> Result<(), LoadError> {
self.meter.items(bytes, file, line)
}
pub(crate) fn reserve_items<T>(
&self,
values: &mut Vec<T>,
required: usize,
file: &RelPath,
line: Option<usize>,
) -> Result<(), LoadError> {
let bytes = values.capacity() * size_of::<T>();
let mut admission = NativeAdmission::items(self.meter, file, line, bytes);
let capacity = purrdf_lex::allocation::growth_capacity::<T>(values.capacity(), required)
.map_err(|error| admission.graph_error(error.into()))?;
Memory::resume(&mut admission, bytes)
.reserve(values, capacity)
.map_err(|error| admission.graph_error(error.into()))
}
}
fn symbol_kind(kind: ItemKind) -> SymbolKind {
match kind {
ItemKind::Fn => SymbolKind::Fn,
ItemKind::Struct => SymbolKind::Struct,
ItemKind::Enum => SymbolKind::Enum,
ItemKind::Union => SymbolKind::Union,
ItemKind::Trait => SymbolKind::Trait,
ItemKind::TypeAlias => SymbolKind::TypeAlias,
ItemKind::Const | ItemKind::UnnamedConst => SymbolKind::Const,
ItemKind::Static => SymbolKind::Static,
ItemKind::MacroRules => SymbolKind::MacroRules,
ItemKind::ExternCrate => SymbolKind::ExternCrate,
ItemKind::ForeignFn => SymbolKind::ForeignFn,
ItemKind::ForeignStatic => SymbolKind::ForeignStatic,
ItemKind::ForeignType => SymbolKind::ForeignType,
}
}
fn main_namespace(kind: SymbolKind) -> Namespace {
match kind {
SymbolKind::Fn
| SymbolKind::Const
| SymbolKind::Static
| SymbolKind::ForeignFn
| SymbolKind::ForeignStatic
| SymbolKind::InherentMethod
| SymbolKind::TraitImplMethod
| SymbolKind::TraitDefaultMethod
| SymbolKind::TraitRequiredMethod
| SymbolKind::AssocConst => Namespace::Value,
SymbolKind::MacroRules => Namespace::Macro,
SymbolKind::Struct
| SymbolKind::Enum
| SymbolKind::Union
| SymbolKind::Trait
| SymbolKind::TypeAlias
| SymbolKind::Mod
| SymbolKind::ExternCrate
| SymbolKind::ForeignType
| SymbolKind::AssocType => Namespace::Type,
}
}
pub(crate) fn combine(own: TestRole, reached_in_tests: bool) -> TestRole {
if own == TestRole::None && reached_in_tests {
TestRole::CfgTest
} else {
own
}
}
fn flatten(tree: &UseTree, prefix: &mut Vec<String>, out: &mut Vec<UseKind>) -> Result<(), String> {
match tree {
UseTree::Path { name, rest } => {
prefix.push(name.clone());
let result = flatten(rest, prefix, out);
prefix.pop();
result
}
UseTree::Name(name) if name == "self" => {
let last = prefix
.last()
.ok_or_else(|| "`use {self}` has no path before `self`".to_owned())?;
out.push(UseKind::Named {
name: last.clone(),
segs: prefix.clone(),
namespaces: NamedNamespaces::TypeOnly,
});
Ok(())
}
UseTree::Name(name) => {
let mut segs = prefix.clone();
segs.push(name.clone());
out.push(UseKind::Named {
name: name.clone(),
segs,
namespaces: NamedNamespaces::All,
});
Ok(())
}
UseTree::Rename { name, alias } if name == "self" => {
if prefix.is_empty() {
return Err("`use {self as name}` has no path before `self`".to_owned());
}
if alias != "_" {
out.push(UseKind::Named {
name: alias.clone(),
segs: prefix.clone(),
namespaces: NamedNamespaces::TypeOnly,
});
}
Ok(())
}
UseTree::Rename { name, alias } => {
let mut segs = prefix.clone();
segs.push(name.clone());
if alias != "_" {
out.push(UseKind::Named {
name: alias.clone(),
segs,
namespaces: NamedNamespaces::All,
});
}
Ok(())
}
UseTree::Glob => {
out.push(UseKind::Glob {
segs: prefix.clone(),
});
Ok(())
}
UseTree::Group(items) => {
for item in items {
flatten(item, prefix, out)?;
}
Ok(())
}
}
}
struct Cx<'a> {
file: &'a RelPath,
target: TargetId,
reach_test: bool,
}
struct Builder<'a> {
targets: &'a [Target],
files_at: BTreeMap<(TargetId, &'a str), Vec<&'a SourceFile>>,
store: Store<'a>,
impls: Vec<ImplDecl<'a>>,
aliases: HashMap<*const PathFact, Arc<PathFact>, FixedState>,
index: Index,
}
impl<'a> Builder<'a> {
fn declare(
&mut self,
path: &str,
parent: usize,
file: &RelPath,
line: usize,
) -> Result<usize, LoadError> {
let (path, cost) = self.store.intern(path);
let root = self.index.modules[parent].root;
let key = (root, path);
if let Some(&known) = self.index.module_by_path.get(&key) {
return Ok(known);
}
self.store.charge(cost + MODULE_BYTES, file, Some(line))?;
let idx = self.index.modules.len();
self.index.modules.push(Module {
path: key.1.clone(),
parent: Some(parent),
root,
target: self.index.modules[parent].target,
defs: Vec::new(),
configuration: ConfigurationDependence::Unconditional,
});
self.index.module_by_path.insert(key, idx);
Ok(idx)
}
fn push(
&mut self,
fact: &ItemFact,
kind: SymbolKind,
path: &str,
module: usize,
cx: &Cx<'_>,
documented: bool,
) -> Result<ItemId, LoadError> {
self.record(fact, kind, path, cx, documented, true)
.inspect(|id| self.index.modules[module].defs.push(*id))
}
fn record(
&mut self,
fact: &ItemFact,
kind: SymbolKind,
path: &str,
cx: &Cx<'_>,
documented: bool,
in_scope: bool,
) -> Result<ItemId, LoadError> {
let (path, path_cost) = self.store.intern(path);
let (name, name_cost) = self.store.intern(&fact.name);
let namespaces = if kind == SymbolKind::Struct
&& matches!(fact.shape, Some(FieldShape::Unit | FieldShape::Tuple))
{
2
} else {
1
};
let place = if in_scope {
scope_bytes(&fact.name, &fact.vis, namespaces)
} else {
member_bytes(&fact.name)
};
self.store.charge(
ITEM_BYTES + path_cost + name_cost + vis_capacity(&fact.vis) + place,
cx.file,
Some(fact.name_line),
)?;
let id = ItemId(self.index.items.len());
self.index.items.push(Item {
id,
path,
name,
kind,
namespace: main_namespace(kind),
file: cx.file.clone(),
name_line: fact.name_line,
span: fact.span.clone(),
body: fact.body.clone(),
detail: fact.detail.clone(),
visibility: fact.vis.clone(),
documented,
doc_hidden: fact.doc_hidden,
test: combine(fact.test, cx.reach_test),
target: cx.target,
self_type: None,
trait_key: None,
trait_definition_target: None,
self_key: None,
trait_path: None,
shape: fact.shape,
macro_export: fact.macro_export,
});
Ok(id)
}
fn shared_alias(
&mut self,
alias: &PathFact,
cx: &Cx<'_>,
line: usize,
) -> Result<Arc<PathFact>, LoadError> {
if let Some(shared) = self.aliases.get(&std::ptr::from_ref(alias)) {
return Ok(Arc::clone(shared));
}
self.store.charge(
shared_text(size_of::<PathFact>())
+ strings_bytes(&alias.segments)
+ hash_entry::<(*const PathFact, Arc<PathFact>)>()
+ btree_entry::<ItemId, (usize, Arc<PathFact>)>(),
cx.file,
Some(line),
)?;
let shared = Arc::new(alias.clone());
self.aliases
.insert(std::ptr::from_ref(alias), Arc::clone(&shared));
Ok(shared)
}
fn item(&mut self, fact: &ItemFact, module: usize, cx: &Cx<'_>) -> Result<(), LoadError> {
if fact.kind == ItemKind::UnnamedConst {
return Ok(());
}
let kind = symbol_kind(fact.kind);
let (home, base) = if fact.macro_export {
let root = self.index.modules[module].root;
(root, self.index.modules[root].path.clone())
} else {
(module, self.index.modules[module].path.clone())
};
let path = format!("{base}::{}", fact.name);
let id = self.push(fact, kind, &path, home, cx, fact.documented)?;
if home != module {
self.store.charge(
btree_entry::<ItemId, usize>(),
cx.file,
Some(fact.name_line),
)?;
self.index.macro_modules.insert(id, module);
}
if let Some(alias) = &fact.alias {
let shared = self.shared_alias(alias, cx, fact.name_line)?;
self.store.charge(
btree_entry::<ItemId, (usize, Arc<PathFact>, ConfigurationDependence)>(),
cx.file,
Some(fact.name_line),
)?;
let configuration = ConfigurationDependence::of(&fact.attrs);
self.index.aliases.insert(id, (home, shared, configuration));
}
if fact.kind == ItemKind::ExternCrate {
let crate_name = fact.renamed_from.as_deref().unwrap_or(&fact.name);
let (shared, cost) = self.store.intern(crate_name);
self.store.charge(
cost + btree_entry::<ItemId, SharedStr>(),
cx.file,
Some(fact.name_line),
)?;
self.index.extern_names.insert(id, shared);
let test = fact.test != TestRole::None || cx.reach_test;
let roots: Vec<usize> = if crate_name == "self" {
vec![self.index.modules[module].root]
} else {
self.index
.extern_name(module, crate_name, test)
.map_or_default(|name| name.roots(test).collect())
};
if !roots.is_empty() {
self.store.charge(
btree_entry::<ItemId, Vec<usize>>() + roots.capacity() * size_of::<usize>(),
cx.file,
Some(fact.name_line),
)?;
self.index.crate_of.insert(id, roots);
}
}
if !fact.members.is_empty() {
self.store
.charge(MEMBERS_BYTES, cx.file, Some(fact.name_line))?;
}
for member in &fact.members {
let member_kind = match (member.kind, member.body.is_some()) {
(ItemKind::Fn, true) => SymbolKind::TraitDefaultMethod,
(ItemKind::Fn, false) => SymbolKind::TraitRequiredMethod,
(ItemKind::TypeAlias, _) => SymbolKind::AssocType,
_ => SymbolKind::AssocConst,
};
let member_path = format!("{path}::{}", member.name);
let member_id = self.member(member, member_kind, &member_path, cx)?;
self.index
.assoc
.entry(id)
.or_default()
.entry(member.name.clone())
.or_default()
.push(member_id);
}
Ok(())
}
fn member(
&mut self,
fact: &ItemFact,
kind: SymbolKind,
path: &str,
cx: &Cx<'_>,
) -> Result<ItemId, LoadError> {
self.record(fact, kind, path, cx, fact.documented, false)
}
fn body(&mut self, root: &'a ModBody, module: usize, cx: &Cx<'_>) -> Result<(), LoadError> {
let meter = self.store.meter;
let push = |stack: &mut WorkList<_, 8>, value, line| {
push_item_work(stack, value, meter, cx.file, Some(line))
};
let mut stack = WorkList::<_, 8>::new();
push(&mut stack, Emit::Enter(root, module, 1), 1)?;
while let Some(step) = stack.pop() {
match step {
Emit::Enter(body, module, line) => {
for fact in &body.items {
self.item(fact, module, cx)?;
}
for fact in &body.unexpanded {
let line = Some(fact.span.lines.start);
let (invoked, cost) = self.store.intern(&fact.invoked);
self.store.charge(cost, cx.file, line)?;
let mut identifiers = Vec::new();
self.store.reserve_items(
&mut identifiers,
fact.identifiers.len(),
cx.file,
line,
)?;
for name in &fact.identifiers {
let (name, cost) = self.store.intern(name);
self.store.charge(cost, cx.file, line)?;
identifiers.push(name);
}
self.store.charge(vec_slot::<Unexpanded>(), cx.file, line)?;
self.index.unexpanded.push(Unexpanded {
file: cx.file.clone(),
span: fact.span.clone(),
module: self.index.modules[module].path.clone(),
target: cx.target,
invoked,
test: combine(fact.test, cx.reach_test),
identifiers,
});
}
self.disabled_syntax(&body.disabled, module, cx)?;
push(&mut stack, Emit::Rest(body, module), line)?;
push(&mut stack, Emit::Mods(body, module, 0), line)?;
}
Emit::Mods(body, module, next) => {
let Some(decl) = body.declaration(next) else {
continue;
};
push(
&mut stack,
Emit::Mods(body, module, next + 1),
decl.name_line,
)?;
let child = if body.is_block_local(next) {
self.block_module(decl, module, cx)?
} else {
self.module_item(decl, module, cx)?
};
if let Some(inline) = &decl.inline {
push(
&mut stack,
Emit::Enter(inline, child, decl.name_line),
decl.name_line,
)?;
}
}
Emit::Rest(body, module) => self.uses_and_impls(body, module, cx)?,
}
}
Ok(())
}
fn disabled_syntax(
&mut self,
spans: &[SpanFact],
module: usize,
cx: &Cx<'_>,
) -> Result<(), LoadError> {
let Some(first) = spans.first() else {
return Ok(());
};
let line = Some(first.lines.start);
let records = &mut self.index.disabled_syntax;
self.store.reserve_items(
records,
records.len().saturating_add(spans.len()),
cx.file,
line,
)?;
self.store.meter.work(spans.len(), cx.file, line)?;
let module = &self.index.modules[module].path;
records.extend(spans.iter().cloned().map(|span| DisabledSyntax {
file: cx.file.clone(),
span,
module: module.clone(),
target: cx.target,
}));
Ok(())
}
fn block_module(
&mut self,
decl: &ModFact,
module: usize,
cx: &Cx<'_>,
) -> Result<usize, LoadError> {
let path = format!(
"{}::{}",
self.index.modules[module].path,
decl.block_segment()
);
let child = self.declare(&path, module, cx.file, decl.name_line)?;
self.note_module_configuration(child, ConfigurationDependence::of(&decl.attrs));
self.store
.charge(size_of::<BlockModule>(), cx.file, Some(decl.name_line))?;
self.index.block_modules.push(BlockModule {
module: child,
parent: module,
file: cx.file.clone(),
span: (decl.span.start_byte, decl.span.end_byte),
});
Ok(child)
}
fn module_item(
&mut self,
decl: &ModFact,
module: usize,
cx: &Cx<'_>,
) -> Result<usize, LoadError> {
let path = format!("{}::{}", self.index.modules[module].path, decl.name);
let child = self.declare(&path, module, cx.file, decl.name_line)?;
self.note_module_configuration(child, ConfigurationDependence::of(&decl.attrs));
let file_docs = self
.files_at
.get(&(cx.target, path.as_str()))
.is_some_and(|files| files.iter().any(|file| file.facts.documented));
let fact = ItemFact {
name: decl.name.clone(),
renamed_from: None,
kind: ItemKind::Fn,
name_line: decl.name_line,
span: decl.span.clone(),
body: decl.body_span.clone(),
detail: None,
vis: decl.vis.clone(),
attrs: Vec::new(),
documented: decl.documented,
doc_hidden: decl.doc_hidden,
test: decl.test,
macro_export: false,
members: Vec::new(),
shape: None,
alias: None,
};
let id = self.push(
&fact,
SymbolKind::Mod,
&path,
module,
cx,
decl.documented || file_docs,
)?;
self.store.charge(
btree_entry::<ItemId, usize>(),
cx.file,
Some(decl.name_line),
)?;
self.index.module_of.insert(id, child);
Ok(child)
}
fn note_module_configuration(&mut self, module: usize, configuration: ConfigurationDependence) {
if configuration == ConfigurationDependence::Conditional {
self.index.modules[module].configuration = configuration;
}
}
fn uses_and_impls(
&mut self,
body: &'a ModBody,
module: usize,
cx: &Cx<'_>,
) -> Result<(), LoadError> {
for decl in &body.uses {
let mut kinds = Vec::new();
flatten(&decl.tree, &mut Vec::new(), &mut kinds).map_err(|what| {
LoadError::new(
cx.file,
Some(decl.line),
LoadErrorKind::UnsupportedItem { what },
)
})?;
for kind in kinds {
let entry = UseDecl {
module,
file: cx.file.clone(),
line: decl.line,
leading_colon: decl.leading_colon,
vis: decl.vis.clone(),
test: decl.test != TestRole::None || cx.reach_test,
doc_hidden: decl.doc_hidden,
configuration: decl.configuration,
kind,
};
self.store.charge(entry.bytes(), cx.file, Some(decl.line))?;
self.index.uses.push(entry);
}
}
for fact in &body.impls {
self.store
.charge(vec_slot::<ImplDecl<'_>>(), cx.file, Some(fact.line))?;
self.impls.push(ImplDecl {
module,
file: cx.file.clone(),
target: cx.target,
reach_test: cx.reach_test,
fact,
});
}
Ok(())
}
}
enum Emit<'a> {
Enter(&'a ModBody, usize, usize),
Mods(&'a ModBody, usize, usize),
Rest(&'a ModBody, usize),
}
type ObservationPosition<'a> = (&'a RelPath, &'a SpanFact, &'a SharedStr, TargetId);
fn sort_observations<T>(
meter: &Meter,
observations: &mut [T],
position: impl Fn(&T) -> ObservationPosition<'_>,
) -> Result<(), LoadError> {
purrdf_lex::walk::try_sort_unstable_by(observations, |left, right| {
let (left_file, left_span, left_module, left_target) = position(left);
let (right_file, right_span, right_module, right_target) = position(right);
meter.work(
left_file
.as_str()
.len()
.saturating_add(right_file.as_str().len())
.saturating_add(left_module.len())
.saturating_add(right_module.len())
.saturating_add(1),
left_file,
Some(left_span.lines.start),
)?;
Ok(
(left_file, left_span.start_byte, left_module, left_target).cmp(&(
right_file,
right_span.start_byte,
right_module,
right_target,
)),
)
})
}
impl Index {
fn empty(targets: &[Target]) -> Self {
Self {
items: Vec::new(),
unexpanded: Vec::new(),
disabled_syntax: Vec::new(),
order: Vec::new(),
modules: Vec::new(),
module_by_path: BTreeMap::new(),
block_modules: Vec::new(),
module_of: BTreeMap::new(),
crate_of: BTreeMap::new(),
crate_roots: BTreeMap::new(),
target_roots: Vec::new(),
preludes: Vec::new(),
targets: targets.to_vec(),
target_editions: Vec::new(),
target_no_std: Vec::new(),
crates_open: false,
unresolved: Vec::new(),
impl_blocks: Vec::new(),
scopes: Vec::new(),
uses: Vec::new(),
named_imports: Vec::new(),
named_keys: Vec::new(),
glob_imports: Vec::new(),
use_resolved: Vec::new(),
use_settled: Vec::new(),
use_ambiguous: Vec::new(),
use_bound: Vec::new(),
use_free: Vec::new(),
use_decided: Vec::new(),
use_empty: Vec::new(),
use_read_state: Vec::new(),
has_late_imports: false,
glob_closed: Vec::new(),
glob_reach: Vec::new(),
glob_facts: crate::resolve::GlobFactsCache::default(),
lookups: LookupCount::default(),
globs: GlobTables::default(),
import_reach: ImportReach::default(),
extern_names: BTreeMap::new(),
root_items: BTreeMap::new(),
macro_modules: BTreeMap::new(),
by_source: BTreeMap::new(),
assoc: BTreeMap::new(),
foreign: BTreeMap::new(),
by_file: BTreeMap::new(),
aliases: BTreeMap::new(),
}
}
pub(crate) fn build(
targets: &[Target],
files: &BTreeMap<RelPath, SourceFile>,
visits: &[Visit],
infos: &[PackageInfo],
strings: Interner,
meter: &Meter,
) -> Result<Self, LoadError> {
let mut files_at: BTreeMap<(TargetId, &str), Vec<&SourceFile>> = BTreeMap::new();
for file in files.values() {
for reach in &file.reached {
files_at
.entry((reach.target, reach.module_path.as_str()))
.or_default()
.push(file);
}
}
let mut builder = Builder {
targets,
files_at,
store: Store { strings, meter },
impls: Vec::new(),
aliases: HashMap::with_hasher(FixedState::new()),
index: Index::empty(targets),
};
for (position, target) in builder.targets.iter().enumerate() {
builder.ensure_root(TargetId(position), target)?;
}
builder.preludes(infos)?;
let mut seen: BTreeSet<(RelPath, TargetId, SharedStr)> = BTreeSet::new();
for visit in visits {
let internal =
|what: String| LoadError::new(&visit.file, None, LoadErrorKind::Internal { what });
let file = files
.get(&visit.file)
.ok_or_else(|| internal("a visited file was not loaded".to_owned()))?;
let reach = file
.reached
.get(visit.reach)
.ok_or_else(|| internal(format!("the file has no module path {}", visit.reach)))?;
let key = (file.path.clone(), reach.target, reach.module_path.clone());
if !seen.insert(key) {
continue;
}
let root = *builder
.index
.target_roots
.get(reach.target.index())
.ok_or_else(|| {
internal(format!("the target {} has no root", reach.target.index()))
})?;
let module = *builder
.index
.module_by_path
.get(&(root, reach.module_path.clone()))
.ok_or_else(|| {
internal(format!(
"the module `{}` was reached before the declaration that names it",
reach.module_path
))
})?;
builder
.note_module_configuration(module, ConfigurationDependence::of(&file.facts.attrs));
if reach.predicate.is_some() {
builder.note_module_configuration(module, ConfigurationDependence::Conditional);
}
let cx = Cx {
file: &file.path,
target: reach.target,
reach_test: reach.test,
};
builder.body(&file.facts.body, module, &cx)?;
}
let Builder {
impls,
mut index,
mut store,
..
} = builder;
index.add_roots(files, infos, &mut store)?;
index.order_imports();
index.build_scopes();
index.settle_agreed(store.meter)?;
index.attach_impls(impls, &mut store)?;
sort_observations(store.meter, &mut index.unexpanded, |row| {
(&row.file, &row.span, &row.module, row.target)
})?;
sort_observations(store.meter, &mut index.disabled_syntax, |row| {
(&row.file, &row.span, &row.module, row.target)
})?;
index.finish();
index.settle_glob_facts(store.meter)?;
index.lookups_charged()?;
Ok(index)
}
fn add_roots(
&mut self,
files: &BTreeMap<RelPath, SourceFile>,
infos: &[PackageInfo],
store: &mut Store<'_>,
) -> Result<(), LoadError> {
for (position, target) in self.targets.clone().iter().enumerate() {
let internal =
|what: String| LoadError::new(&target.root, None, LoadErrorKind::Internal { what });
let file = files.get(&target.root).ok_or_else(|| {
internal(format!(
"the root file of `{}` was not loaded",
target.crate_path
))
})?;
let module = *self.target_roots.get(position).ok_or_else(|| {
internal(format!("`{}` has no crate root module", target.crate_path))
})?;
let id = ItemId(self.items.len());
let lines = file.text.lines().count().max(1);
let name = target
.crate_path
.rsplit("::")
.next()
.unwrap_or(&target.crate_path);
let (path, path_cost) = store.intern(&target.crate_path);
let (name, name_cost) = store.intern(name);
store.charge(
ITEM_BYTES
+ path_cost
+ name_cost
+ btree_entry::<ItemId, usize>()
+ btree_entry::<usize, ItemId>()
+ vec_slot::<bool>(),
&target.root,
None,
)?;
self.target_no_std.push(
file.facts
.attrs
.iter()
.any(|attr| attr.path == "no_std" && attr.args.is_empty()),
);
let test = if infos[target.package_id.index()].configured {
store.meter.work(file.reached.len(), &target.root, None)?;
if file
.reached
.iter()
.any(|reach| reach.target == TargetId(position) && reach.test)
{
TestRole::CfgTest
} else {
TestRole::None
}
} else {
match target.kind {
TargetKind::Test | TargetKind::Bench => TestRole::CfgTest,
TargetKind::Lib
| TargetKind::Bin
| TargetKind::Example
| TargetKind::BuildScript => TestRole::None,
}
};
self.items.push(Item {
id,
path,
name,
kind: SymbolKind::Mod,
namespace: Namespace::Type,
file: file.path.clone(),
name_line: 1,
span: SpanFact {
lines: 1..lines + 1,
start_byte: 0,
end_byte: file.text.len(),
},
body: None,
detail: None,
visibility: Vis::Public,
documented: file.facts.documented,
doc_hidden: file.facts.doc_hidden,
test,
target: TargetId(position),
self_type: None,
trait_key: None,
trait_definition_target: None,
self_key: None,
trait_path: None,
shape: None,
macro_export: false,
});
self.module_of.insert(id, module);
self.root_items.insert(module, id);
}
Ok(())
}
fn finish(&mut self) {
self.impl_blocks.sort_by(|a, b| {
(&a.file, a.span.start_byte, &a.module, a.target).cmp(&(
&b.file,
b.span.start_byte,
&b.module,
b.target,
))
});
for (position, block) in self.impl_blocks.iter_mut().enumerate() {
block.id = ImplId(position);
}
self.unresolved.sort_unstable_by(|a, b| {
(&a.path, &a.file, a.span.start_byte, a.target).cmp(&(
&b.path,
&b.file,
b.span.start_byte,
b.target,
))
});
let mut order: Vec<ItemId> = self.items.iter().map(|item| item.id).collect();
order.sort_by(|a, b| self.sort_key(*a).cmp(&self.sort_key(*b)));
self.order = order;
for item in &self.items {
self.by_file
.entry(item.file.clone())
.or_default()
.push(item.id);
}
let items = &self.items;
for id in &self.order {
if self.is_root(*id) {
continue;
}
let item = &items[id.0];
self.by_source
.entry((item.file.clone(), item.span.start_byte))
.or_default()
.push(*id);
}
for ids in self.by_file.values_mut() {
ids.sort_by(|a, b| {
let (a, b) = (&items[a.0], &items[b.0]);
(a.span.start_byte, &a.path, a.id).cmp(&(b.span.start_byte, &b.path, b.id))
});
}
}
pub(crate) fn is_root(&self, id: ItemId) -> bool {
self.module_of
.get(&id)
.and_then(|module| self.root_items.get(module))
== Some(&id)
}
pub(crate) fn sort_key(&self, id: ItemId) -> (&str, Namespace, &RelPath, usize, usize) {
let item = &self.items[id.0];
(
item.path.as_str(),
item.namespace,
&item.file,
item.span.start_byte,
item.target.index(),
)
}
pub(crate) fn sorted(&self, ids: impl IntoIterator<Item = ItemId>) -> Vec<ItemId> {
let mut ids: Vec<ItemId> = ids.into_iter().collect();
ids.sort_by(|a, b| self.sort_key(*a).cmp(&self.sort_key(*b)));
ids.dedup();
ids
}
#[expect(
clippy::too_many_arguments,
reason = "a member is built from its impl, its fact and what the impl resolved to"
)]
pub(crate) fn push_member(
&mut self,
decl: &ImplDecl<'_>,
member: &ItemFact,
kind: SymbolKind,
path: &str,
self_type: &str,
self_key: SelfType,
trait_key: Option<Arc<TraitKey>>,
trait_definition_target: Option<TargetId>,
store: &mut Store<'_>,
) -> Result<ItemId, LoadError> {
let (path, path_cost) = store.intern(path);
let (name, name_cost) = store.intern(&member.name);
let (self_type, self_cost) = store.intern(self_type);
let written = decl
.fact
.trait_path
.as_ref()
.map(|text| text.split_whitespace().collect::<String>());
let (trait_path, trait_cost) = match written {
Some(text) => {
let (shared, cost) = store.intern(&text);
(Some(shared), cost)
}
None => (None, 0),
};
store.charge(
ITEM_BYTES + path_cost + name_cost + self_cost + trait_cost + vis_capacity(&member.vis),
&decl.file,
Some(member.name_line),
)?;
let id = ItemId(self.items.len());
self.items.push(Item {
id,
path,
name,
kind,
namespace: main_namespace(kind),
file: decl.file.clone(),
name_line: member.name_line,
span: member.span.clone(),
body: member.body.clone(),
detail: member.detail.clone(),
visibility: member.vis.clone(),
documented: member.documented,
doc_hidden: member.doc_hidden,
test: combine(member.test, decl.reach_test),
target: decl.target,
self_type: Some(self_type),
trait_key,
trait_definition_target,
self_key: Some(self_key),
trait_path,
shape: None,
macro_export: false,
});
Ok(id)
}
pub(crate) fn extern_name(&self, module: usize, name: &str, test: bool) -> Option<&ExternName> {
let target = self.modules[module].target;
self.preludes
.get(target.index())?
.get(name)
.filter(|entry| entry.everywhere || test)
}
pub(crate) fn edition(&self, module: usize) -> u16 {
self.target_editions[self.modules[module].target.index()]
}
pub(crate) fn no_std(&self, module: usize) -> bool {
self.target_no_std[self.modules[module].target.index()]
}
pub(crate) fn injected_crate(&self, module: usize) -> &'static str {
if self.no_std(module) { "core" } else { "std" }
}
fn order_imports(&mut self) {
let named = self
.uses
.iter()
.filter(|decl| matches!(decl.kind, UseKind::Named { .. }))
.count();
let mut named_imports = Vec::with_capacity(named);
let mut glob_imports = Vec::with_capacity(self.uses.len() - named);
for (position, decl) in self.uses.iter().enumerate() {
match decl.kind {
UseKind::Named { .. } => named_imports.push(position),
UseKind::Glob { .. } => glob_imports.push(position),
}
}
named_imports.sort_by(|a, b| self.named_key(*a).cmp(&self.named_key(*b)));
glob_imports.sort_by_key(|position| (self.uses[*position].module, *position));
let mut named_keys = Vec::with_capacity(named);
named_keys.extend(named_imports.iter().map(|position| {
let (module, name, _) = self.named_key(*position);
(module, name_prefix(name))
}));
self.named_keys = named_keys;
self.named_imports = named_imports;
self.glob_imports = glob_imports;
}
fn named_key(&self, position: usize) -> (usize, &str, usize) {
let decl = &self.uses[position];
let name = match &decl.kind {
UseKind::Named { name, .. } => name.as_str(),
UseKind::Glob { .. } => "",
};
(decl.module, name, position)
}
pub(crate) fn imports_of(&self, module: usize, name: &str) -> &[usize] {
if self.named_imports.is_empty() {
return &self.named_imports;
}
let key = (module, name_prefix(name));
let from = self.named_keys.partition_point(|at| *at < key);
let to = from + self.named_keys[from..].partition_point(|at| *at == key);
let here = &self.named_imports[from..to];
let start = here.partition_point(|position| self.named_key(*position).1 < name);
let end = here[start..].partition_point(|position| self.named_key(*position).1 == name);
&here[start..start + end]
}
pub(crate) fn first_imports_in(
&self,
module: usize,
name: &str,
namespace: Namespace,
steps: Steps<'_>,
) -> Result<[Option<usize>; 2], LoadError> {
let mut first = None;
for &position in self.imports_of(module, name) {
if self.uses[position]
.kind
.terminal_namespaces()
.contains(&namespace)
{
if first.is_some() {
return Ok([first, Some(position)]);
}
first = Some(position);
} else {
steps.storage_work(1)?;
}
}
Ok([first, None])
}
pub(crate) fn settle_bytes(&self) -> usize {
let definitions: usize = self
.modules
.iter()
.flat_map(|module| &module.defs)
.map(|id| {
let item = &self.items[id.0];
let namespaces = Namespace::ALL
.into_iter()
.filter(|ns| item.in_namespace(*ns))
.count();
scope_bytes(&item.name, &item.visibility, namespaces)
})
.sum();
definitions
+ self.modules.len()
* (vec_slot::<Scope>()
+ btree_map::<String, Box<Entry>>()
+ 2 * vec_first::<ItemId>()
+ vec_slot::<(usize, Vec<ItemId>)>())
+ vec_first::<Scope>()
+ self.uses.len()
* (4 * vec_slot::<bool>()
+ 4 * vec_slot::<[bool; 3]>()
+ vec_slot::<[ImportReadState; 3]>()
+ vec_slot::<BTreeSet<usize>>())
+ 4 * vec_first::<bool>()
+ 4 * vec_first::<[bool; 3]>()
+ vec_first::<[ImportReadState; 3]>()
+ vec_first::<BTreeSet<usize>>()
}
pub(crate) fn named_of(&self, module: usize) -> &[usize] {
let start = self
.named_imports
.partition_point(|position| self.uses[*position].module < module);
let end = self.named_imports[start..]
.partition_point(|position| self.uses[*position].module == module);
&self.named_imports[start..start + end]
}
pub(crate) fn globs_of(&self, module: usize) -> &[usize] {
let start = self
.glob_imports
.partition_point(|position| self.uses[*position].module < module);
let end = self.glob_imports[start..]
.partition_point(|position| self.uses[*position].module == module);
&self.glob_imports[start..start + end]
}
pub(crate) fn error(decl: &ImplDecl<'_>, kind: LoadErrorKind) -> LoadError {
LoadError::new(&decl.file, Some(decl.fact.line), kind)
}
pub(crate) fn path_fact(fact: &ImplFact) -> Option<PathFact> {
fact.self_path.as_ref().map(|segments| PathFact {
segments: segments.clone(),
leading_colon: fact.self_leading_colon,
})
}
}
fn library_roots<'a>(
targets: &'a [Target],
roots: &[usize],
packages: usize,
meter: &Meter,
) -> Result<Vec<Option<(usize, &'a str)>>, LoadError> {
let mut libraries = Vec::new();
let root = RelPath::root();
let mut admission = ItemAdmission::new(meter, &root);
Memory::new(&mut admission)
.reserve(&mut libraries, packages)
.map_err(|error| admission.error(error))?;
libraries.resize(packages, None);
for (position, target) in targets.iter().enumerate() {
if target.kind == TargetKind::Lib {
let slot = libraries
.get_mut(target.package_id.index())
.ok_or_else(|| {
LoadError::new(
&target.root,
None,
LoadErrorKind::Internal {
what: format!("the package `{}` has no manifest facts", target.package),
},
)
})?;
*slot = Some((roots[position], target.crate_path.as_str()));
}
}
Ok(libraries)
}
fn edition_of(target: &Target, infos: &[PackageInfo]) -> Result<u16, LoadError> {
infos
.get(target.package_id.index())
.map(|info| info.edition)
.ok_or_else(|| {
LoadError::new(
&target.root,
None,
LoadErrorKind::Internal {
what: format!("the package `{}` has no manifest facts", target.package),
},
)
})
}
fn dependency_scope(target: &Target, dependency: &DependencyInfo, id: TargetId) -> Option<bool> {
if let Some(active) = &dependency.active_targets {
return active.contains(&id).then_some(true);
}
match (target.kind, dependency.kind) {
(TargetKind::BuildScript, DependencyKind::Build)
| (
TargetKind::Test | TargetKind::Bench | TargetKind::Example,
DependencyKind::Normal | DependencyKind::Dev,
)
| (TargetKind::Lib | TargetKind::Bin, DependencyKind::Normal) => Some(true),
(TargetKind::Lib | TargetKind::Bin, DependencyKind::Dev) => Some(false),
(TargetKind::BuildScript, DependencyKind::Normal | DependencyKind::Dev)
| (_, DependencyKind::Build) => None,
}
}
impl Builder<'_> {
fn ensure_root(&mut self, id: TargetId, target: &Target) -> Result<usize, LoadError> {
let idx = self.index.modules.len();
let path = target.crate_path.as_str();
let (shared, cost) = self.store.intern(path);
self.store.charge(
cost + MODULE_BYTES
+ btree_entry::<String, Vec<usize>>()
+ path.len()
+ vec_first::<usize>()
+ 2 * vec_slot::<usize>(),
&target.root,
None,
)?;
self.index.modules.push(Module {
path: shared.clone(),
parent: None,
root: idx,
target: id,
defs: Vec::new(),
configuration: ConfigurationDependence::Unconditional,
});
self.index.module_by_path.insert((idx, shared), idx);
self.index
.crate_roots
.entry(path.to_owned())
.or_default()
.push(idx);
self.index.target_roots.push(idx);
Ok(idx)
}
fn preludes(&mut self, infos: &[PackageInfo]) -> Result<(), LoadError> {
let libraries = library_roots(
self.targets,
&self.index.target_roots,
infos.len(),
self.store.meter,
)?;
for (target_index, target) in self.targets.iter().enumerate() {
self.store.charge(vec_slot::<u16>(), &target.root, None)?;
self.index.target_editions.push(edition_of(target, infos)?);
let mut names: BTreeMap<String, ExternName> = BTreeMap::new();
let mut offer =
|store: &Store<'_>, name: &str, root: Option<usize>, everywhere: bool| {
let fresh = !names.contains_key(name);
let pushed = root.is_some();
store.charge(
if fresh {
btree_entry::<String, ExternName>() + name.len()
} else {
0
} + if pushed {
vec_first::<(usize, bool)>() + vec_slot::<(usize, bool)>()
} else {
0
},
&target.root,
None,
)?;
let entry = names.entry(name.to_owned()).or_default();
entry.everywhere |= everywhere;
if let Some(root) = root {
match entry.roots.iter_mut().find(|(known, _)| *known == root) {
Some((_, known)) => *known |= everywhere,
None => entry.roots.push((root, everywhere)),
}
}
Ok::<(), LoadError>(())
};
if !matches!(target.kind, TargetKind::Lib | TargetKind::BuildScript)
&& let Some(Some((root, name))) = libraries.get(target.package_id.index())
{
offer(&self.store, name, Some(*root), true)?;
}
let dependencies = infos
.get(target.package_id.index())
.map_or(&[][..], |info| info.dependencies.as_slice());
for dependency in dependencies {
self.store.meter.work(
dependency.active_targets.as_ref().map_or(0, Vec::len),
&target.root,
None,
)?;
let Some(everywhere) = dependency_scope(target, dependency, TargetId(target_index))
else {
continue;
};
let library = match dependency.package {
None => None,
Some(package) => libraries
.get(package.index())
.ok_or_else(|| {
LoadError::new(
&target.root,
None,
LoadErrorKind::Internal {
what: format!(
"dependency `{}` of `{}` names unknown package identity {}",
dependency.name,
target.package,
package.index(),
),
},
)
})?
.as_ref(),
};
let name = match library {
Some((_, crate_name)) if !dependency.renamed => crate_name,
_ => dependency.name.as_str(),
};
offer(
&self.store,
name,
library.map(|(root, _)| *root),
everywhere,
)?;
}
self.store.charge(
vec_slot::<BTreeMap<String, ExternName>>() + btree_map::<String, ExternName>(),
&target.root,
None,
)?;
self.index.preludes.push(names);
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::tree::MemoryTree;
use crate::workspace::Workspace;
fn parts(ws: &Workspace) -> (Vec<Target>, BTreeMap<RelPath, SourceFile>) {
let targets: Vec<Target> = ws.targets().cloned().collect();
let files: BTreeMap<RelPath, SourceFile> = ws
.files()
.map(|file| {
(
file.path.clone(),
SourceFile {
path: file.path.clone(),
package: file.package.clone(),
shipping: file.shipping,
test: file.test,
text: file.text.clone(),
facts: file.facts.clone(),
reached: file.reached.clone(),
},
)
})
.collect();
(targets, files)
}
fn build_index(
targets: &[Target],
files: &BTreeMap<RelPath, SourceFile>,
visits: &[Visit],
infos: &[PackageInfo],
) -> Result<Index, LoadError> {
let meter = Meter::new(&crate::options::LoadOptions::default());
Index::build(targets, files, visits, infos, Interner::default(), &meter)
}
fn demo_infos() -> Vec<PackageInfo> {
vec![PackageInfo {
configured: false,
edition: 2021,
dependencies: Vec::new(),
}]
}
fn visit(file: &str) -> Visit {
Visit {
file: RelPath::new(file).expect("path"),
reach: 0,
}
}
#[test]
fn a_target_whose_root_file_is_missing_is_a_typed_internal_error() {
let tree = MemoryTree::from([
("Cargo.toml", "[package]\nname = \"demo\"\n"),
("src/lib.rs", ""),
]);
let ws = Workspace::load(&tree, &["."]).expect("loads");
let (targets, files) = parts(&ws);
let infos = demo_infos();
assert!(build_index(&targets, &files, &[visit("src/lib.rs")], &infos).is_ok());
let error = build_index(&targets, &files, &[visit("src/lib.rs")], &[])
.expect_err("no package facts");
assert!(
matches!(&error.kind, LoadErrorKind::Internal { what } if what.contains("`demo`")),
"{error}"
);
let error = build_index(&targets, &BTreeMap::new(), &[], &infos).expect_err("no root file");
assert!(
matches!(error.kind, LoadErrorKind::Internal { .. }),
"{error}"
);
assert_eq!(error.file.as_str(), "src/lib.rs");
}
#[test]
fn an_unknown_dependency_identity_is_not_an_external_or_libraryless_package() {
let tree = MemoryTree::from([
("Cargo.toml", "[package]\nname = \"demo\"\n"),
("src/lib.rs", ""),
]);
let ws = Workspace::load(&tree, &["."]).expect("loads");
let (targets, files) = parts(&ws);
let mut infos = demo_infos();
infos[0].dependencies.push(DependencyInfo {
kind: DependencyKind::Normal,
name: "dep".into(),
renamed: true,
package: Some(PackageId(1)),
active_targets: None,
});
let error = build_index(&targets, &files, &[visit("src/lib.rs")], &infos)
.expect_err("invalid dependency identity");
assert!(
matches!(&error.kind, LoadErrorKind::Internal { what }
if what.contains("unknown package identity 1")),
"{error}"
);
infos[0].dependencies[0].package = Some(PackageId(0));
assert!(build_index(&targets, &files, &[visit("src/lib.rs")], &infos).is_ok());
infos.push(PackageInfo {
configured: false,
edition: 2021,
dependencies: Vec::new(),
});
infos[0].dependencies[0].package = Some(PackageId(1));
assert!(build_index(&targets, &files, &[visit("src/lib.rs")], &infos).is_ok());
}
#[test]
fn a_module_file_visited_before_the_declaration_that_names_it_is_an_internal_error() {
let tree = MemoryTree::from([
("Cargo.toml", "[package]\nname = \"demo\"\n"),
("src/lib.rs", "pub mod a;\n"),
("src/a/mod.rs", "pub mod b;\n"),
("src/a/b.rs", "pub fn in_b() {}\n"),
]);
let ws = Workspace::load(&tree, &["."]).expect("loads");
let (targets, files) = parts(&ws);
let infos = demo_infos();
let walked = [
visit("src/lib.rs"),
visit("src/a/mod.rs"),
visit("src/a/b.rs"),
];
let index = build_index(&targets, &files, &walked, &infos).expect("walk order");
let paths: Vec<&str> = index.items.iter().map(|item| item.path.as_str()).collect();
assert!(paths.contains(&"demo::a::b::in_b"), "{paths:?}");
let sorted: Vec<Visit> = files.keys().map(|path| visit(path.as_str())).collect();
let error = build_index(&targets, &files, &sorted, &infos).expect_err("name order");
assert!(
matches!(&error.kind, LoadErrorKind::Internal { what } if what.contains("`demo::a::b`")),
"{error}"
);
assert_eq!(error.file.as_str(), "src/a/b.rs");
for stray in [
visit("src/missing.rs"),
Visit {
file: RelPath::new("src/lib.rs").expect("path"),
reach: 1,
},
] {
let error = build_index(&targets, &files, &[stray], &infos).expect_err("stray visit");
assert!(
matches!(error.kind, LoadErrorKind::Internal { .. }),
"{error}"
);
}
}
}