use super::{Index, Level, Nobody, reference};
use crate::item::ItemId;
use crate::meter::{Meter, Transient};
use crate::options::LoadOptions;
use crate::{MemoryTree, Namespace, ResolveError, Workspace};
const MANIFEST: &str = "[package]\nname = \"demo\"\nversion = \"0.1.0\"\nedition = \"2021\"\n";
fn permutations(blocks: &[&str]) -> Vec<Vec<String>> {
if blocks.len() <= 1 {
return vec![blocks.iter().map(|block| (*block).to_owned()).collect()];
}
let mut all = Vec::new();
for (at, first) in blocks.iter().enumerate() {
let mut rest = blocks.to_vec();
rest.remove(at);
for mut tail in permutations(&rest) {
tail.insert(0, (*first).to_owned());
all.push(tail);
}
}
all
}
fn every_answer(lib: &str) -> Vec<String> {
let tree: MemoryTree = [("Cargo.toml", MANIFEST), ("src/lib.rs", lib)]
.into_iter()
.collect();
let ws = Workspace::load(&tree, &["."]).unwrap_or_else(|error| panic!("{lib}: {error}"));
let mut names: Vec<&str> = lib
.split(|ch: char| !ch.is_ascii_alphanumeric() && ch != '_')
.filter(|word| word.starts_with(|ch: char| ch.is_ascii_uppercase()))
.collect();
names.sort_unstable();
names.dedup();
let mut answers = Vec::new();
for module in &ws.index().modules {
for name in &names {
for ns in [Namespace::Type, Namespace::Value, Namespace::Macro] {
let found = ws.resolve_from_in(&module.path, &format!("self::{name}"), ns);
answers.push(format!(
"{} {name} {ns:?}: {}",
module.path,
shown(&ws, found)
));
}
}
}
answers
}
fn shown(ws: &Workspace, found: Result<crate::Resolution, ResolveError>) -> String {
match found {
Ok(found) => format!("ok {}", found.path),
Err(ResolveError::Ambiguous(ids)) => {
let paths: Vec<&str> = ids
.iter()
.map(|id| ws.item(*id).expect("an item of the load").path.as_str())
.collect();
format!("ambiguous {}", paths.join(" "))
}
Err(error) => format!("err {error:?}"),
}
}
fn answers(lib: &str, probes: &[(&str, &str)]) -> Vec<String> {
let tree: MemoryTree = [("Cargo.toml", MANIFEST), ("src/lib.rs", lib)]
.into_iter()
.collect();
let ws = Workspace::load(&tree, &["."]).unwrap_or_else(|error| panic!("{lib}: {error}"));
probes
.iter()
.map(|(module, path)| shown(&ws, ws.resolve_from_in(module, path, Namespace::Type)))
.collect()
}
fn every_order(variants: &[&[&str]], probes: &[(&str, &str)], expected: &[&str]) -> usize {
let mut loads = 0;
for blocks in variants {
for order in permutations(blocks) {
let lib = order.concat();
let settled = answers(&lib, probes);
let exact = reference::exact(|| answers(&lib, probes));
assert_eq!(settled, exact, "the two modes differ on\n{lib}");
assert_eq!(settled, expected, "{lib}");
loads += 1;
}
}
loads
}
#[test]
fn a_module_whose_covert_read_turns_active_is_no_longer_looked_at_as_a_covert_reader_when_the_view_grows()
{
let blocks: &[&str] = &[
"pub mod r { pub use crate::a::m::*; }\n",
"pub mod s { pub use crate::b::n::*; }\n",
"pub mod a { pub mod m { pub(super) use crate::t::*; } pub mod q { pub use super::m::*; } }\n",
"pub mod b { pub mod n { pub(super) use crate::t::*; } }\n",
"pub mod t { pub use crate::d::*; }\n",
"pub mod d { pub struct X; }\n",
];
let loads = every_order(
&[blocks],
&[
("demo::a::q", "self::X"),
("demo::a::m", "self::X"),
("demo::r", "self::X"),
("demo::s", "self::X"),
],
&[
"ok demo::d::X",
"ok demo::d::X",
"err NotFound(\"self::X\")",
"err NotFound(\"self::X\")",
],
);
assert_eq!(loads, 720);
}
#[test]
fn an_item_that_a_view_read_through_a_glob_its_class_cannot_access_holds_makes_the_first_item_it_can_access_under_the_name_ambiguous()
{
let probes = &[("demo::u", "self::X")];
let expected = &["ambiguous demo::d::X demo::h::X"];
let loads = every_order(
&[
&[
"pub mod u { pub use crate::t::*; }\n",
"pub mod t { use crate::h::*; pub use crate::d::*; }\n",
"pub mod h { pub struct X; }\n",
"pub mod d { pub struct X; }\n",
],
&[
"pub mod u { pub use crate::t::*; }\n",
"pub mod t { pub use crate::d::*; use crate::h::*; }\n",
"pub mod h { pub struct X; }\n",
"pub mod d { pub struct X; }\n",
],
],
probes,
expected,
);
assert_eq!(loads, 48);
every_order(
&[&[
"pub mod u { pub use crate::t::*; }\n",
"pub mod t { use crate::h::*; pub use crate::d::*; }\n",
"pub mod h { pub struct Y; }\n",
"pub mod d { pub struct X; }\n",
]],
probes,
&["ok demo::d::X"],
);
}
#[test]
fn an_item_its_class_cannot_access_that_arrived_under_a_name_its_view_did_not_hold_makes_the_first_item_it_can_access_ambiguous()
{
let probes = &[("demo::r", "self::X"), ("demo::a::m", "self::X")];
let expected = &[
"ambiguous demo::a::s::X demo::d::X",
"ambiguous demo::a::s::X demo::d::X",
];
let loads = every_order(
&[
&[
"pub mod r { pub use crate::a::m::*; }\n",
"pub mod a { pub mod s { pub(super) struct X; } pub mod m { pub use super::s::*; pub use crate::d::*; } }\n",
"pub mod d { pub struct X; }\n",
],
&[
"pub mod r { pub use crate::a::m::*; }\n",
"pub mod a { pub mod m { pub use crate::d::*; pub use super::s::*; } pub mod s { pub(super) struct X; } }\n",
"pub mod d { pub struct X; }\n",
],
&[
"pub mod r { pub use crate::a::m::*; }\n",
"pub mod a { pub mod s { pub(super) struct X; } pub mod m { pub use super::s::*; pub use crate::e::*; } }\n",
"pub mod e { pub use crate::d::*; }\n",
"pub mod d { pub struct X; }\n",
],
],
probes,
expected,
);
assert_eq!(loads, 36);
every_order(
&[&[
"pub mod r { pub use crate::a::m::*; }\n",
"pub mod a { pub mod s { pub(super) struct Y; } pub mod m { pub use super::s::*; pub use crate::d::*; } }\n",
"pub mod d { pub struct X; }\n",
]],
&[("demo::r", "self::X")],
&["ok demo::d::X"],
);
}
fn module(index: &Index, path: &str) -> usize {
index
.modules
.iter()
.position(|module| module.path == path)
.unwrap_or_else(|| panic!("a module {path}"))
}
fn item(index: &Index, path: &str) -> ItemId {
index
.items
.iter()
.find(|item| item.path == path)
.unwrap_or_else(|| panic!("an item {path}"))
.id
}
fn glob(index: &Index, from: &str, to: &str) -> (usize, usize) {
let (from, to) = (module(index, from), module(index, to));
let glob = index
.glob_imports
.iter()
.copied()
.find(|position| {
index.uses[*position].module == from && index.glob_reach[*position].contains(&to)
})
.unwrap_or_else(|| panic!("a glob of module {from} that reaches module {to}"));
(glob, to)
}
fn held(index: &Index, path: &str) -> Vec<(ItemId, bool)> {
let view = index.globs.exports[module(index, path)][0];
index.globs.views[view]
.names
.get("P")
.map_or_else(Vec::new, |lists| {
lists[0]
.iter()
.map(|(id, level): &(ItemId, Level)| (*id, level.is_companion()))
.collect()
})
}
#[test]
fn a_covert_read_is_listed_before_its_names_arrive_so_an_item_its_view_gains_while_they_arrive_reaches_the_module()
{
let lib = "pub mod m { use crate::t::*; pub use crate::s2::*; }\n\
pub mod y { pub use crate::m::*; use crate::z::*; use crate::f::P; }\n\
pub mod t { pub use crate::y::*; pub use crate::v::*; }\n\
pub mod s2 { pub use crate::s::*; }\npub mod v { pub use crate::w::*; }\n\
pub mod s { pub struct P; }\npub mod z { pub struct P; }\n\
pub mod w { pub struct P; }\npub mod f { pub fn P() {} }\n";
let tree: MemoryTree = [("Cargo.toml", MANIFEST), ("src/lib.rs", lib)]
.into_iter()
.collect();
let loaded = Workspace::load(&tree, &["."])
.expect("loads")
.index()
.clone();
let (s, z, w) = (
item(&loaded, "demo::s::P"),
item(&loaded, "demo::z::P"),
item(&loaded, "demo::w::P"),
);
let settled = built(&loaded, s);
let exact = reference::exact(|| built(&loaded, s));
assert!(settled.covert && !exact.covert);
assert_eq!(settled.y, exact.y);
assert_eq!(settled.m, exact.m);
assert!(settled.y.contains(&(z, true)), "{:?}", settled.y);
let mut expected = vec![(s, false), (z, true), (w, true)];
expected.sort_unstable();
assert_eq!(settled.m, expected);
}
struct Built {
y: Vec<(ItemId, bool)>,
m: Vec<(ItemId, bool)>,
covert: bool,
}
fn built(loaded: &Index, s: ItemId) -> Built {
let mut index = loaded.clone();
let meter = Meter::new(&LoadOptions::default());
index.clear_globs();
index.globs.drops.clear();
index.globs.dropped = 0;
index.globs.replaced_names.clear();
index
.reset_globs(&meter)
.expect("the tables are built again");
let import = index.imports_of(module(&index, "demo::y"), "P")[0];
let read = |index: &mut Index, from: &str, to: &str| {
let (glob, target) = glob(index, from, to);
index
.read_glob(glob, target, &mut Nobody, &meter)
.expect("read");
};
index.use_free[import][0] = false;
read(&mut index, "demo::y", "demo::m");
read(&mut index, "demo::t", "demo::y");
read(&mut index, "demo::v", "demo::w");
read(&mut index, "demo::t", "demo::v");
read(&mut index, "demo::s2", "demo::s");
read(&mut index, "demo::y", "demo::z");
index.use_free[import][0] = true;
index.use_decided[import][0] = true;
index
.refresh(module(&index, "demo::y"), "P", &mut Nobody, &meter)
.expect("read again");
read(&mut index, "demo::m", "demo::s2");
let mut y_expected = vec![(s, false), (item(loaded, "demo::z::P"), true)];
y_expected.sort_unstable();
assert_eq!(held(&index, "demo::y"), y_expected);
assert_eq!(held(&index, "demo::m"), vec![(s, false)]);
read(&mut index, "demo::m", "demo::t");
if !Index::exact_mode() {
let module = module(&index, "demo::m");
let (glob, target) = glob(&index, "demo::m", "demo::t");
let class = index.class_for(target, module);
let view = index.globs.view_of[&(target, class)];
assert_delivery_scratch(&index, module, view, glob);
}
let t_view = index.globs.exports[module(&index, "demo::t")][0];
Built {
y: held(&index, "demo::y"),
m: held(&index, "demo::m"),
covert: index.globs.views[t_view]
.unseen()
.covert
.contains_key(&module(&index, "demo::m")),
}
}
fn assert_delivery_scratch(index: &Index, module: usize, view: usize, glob: usize) {
let due = |limit| {
let meter = Meter::new(&LoadOptions {
max_glob_bytes: limit,
..LoadOptions::default()
});
let memory = Transient::new(&meter);
let result = index.covert_due(module, view, glob, &meter, &memory);
(result, meter.usage().glob_bytes)
};
let (expected, bytes) = due(usize::MAX);
let expected = expected.expect("due names fit");
assert!(!expected.is_empty(), "the covert read has delivery scratch");
assert!(bytes > 0, "due storage uses the original glob-byte grant");
assert_eq!(due(bytes).0.expect("exact due scratch grant"), expected);
for limit in [0, bytes - 1] {
let error = due(limit).0.expect_err("short due scratch refuses");
assert!(matches!(
error.kind,
crate::LoadErrorKind::Budget {
budget: crate::Budget::GlobBytes,
limit: actual,
} if actual == limit
));
assert_eq!(error.file, index.uses[glob].file);
assert_eq!(error.line, Some(index.uses[glob].line));
}
let ids = &index.globs.views[view].names["P"][0];
assert!(ids.len() > 2, "the reentrant ambiguity spills its snapshot");
let copy = |count, limit| {
let meter = Meter::new(&LoadOptions {
max_glob_bytes: limit,
..LoadOptions::default()
});
let memory = Transient::new(&meter);
let mut inline = [(ItemId(0), Level::NOBODY); 2];
let decl = &index.uses[glob];
let copied = super::copy_held(
&ids[..count],
&mut inline,
crate::meter::Steps::LoadAt {
memory: &memory,
file: &decl.file,
line: decl.line,
},
)?;
assert_eq!(copied.as_ref(), &ids[..count]);
assert_eq!(matches!(copied, std::borrow::Cow::Borrowed(_)), count <= 2);
Ok::<_, crate::LoadError>(meter.usage())
};
for count in 0..=2 {
let usage = copy(count, 0).expect("bounded stack snapshot");
assert_eq!(usage.glob_bytes, 0);
assert_eq!(usage.work, count, "inline copies retain their work charge");
}
let bytes = copy(ids.len(), usize::MAX).expect("spill fits").glob_bytes;
copy(ids.len(), bytes).expect("exact snapshot spill grant");
for limit in [0, bytes - 1] {
let error = copy(ids.len(), limit).expect_err("short snapshot spill grant");
assert!(matches!(
error.kind,
crate::LoadErrorKind::Budget {
budget: crate::Budget::GlobBytes,
limit: actual,
} if actual == limit
));
assert_eq!(error.file, index.uses[glob].file);
assert_eq!(error.line, Some(index.uses[glob].line));
}
}
#[test]
fn a_view_made_when_its_module_has_left_the_open_readers_makes_it_open_again_until_it_learns_what_it_cannot_access()
{
let blocks: &[&str] = &[
"pub mod r { pub use crate::a::b::m::*; }\n\
pub mod a { pub mod x { pub(super) struct Z; } \
pub mod b { pub mod m { pub use crate::a::x::*; pub(super) use crate::t::*; \
pub use crate::e::*; pub struct K; } } pub mod q { pub use super::b::m::*; } }\n",
"pub mod n { pub mod n1 { pub(super) use crate::t::*; } pub mod n2 { pub(super) use crate::t::*; } \
pub mod n3 { pub(super) use crate::t::*; } pub mod n4 { pub(super) use crate::t::*; } }\n\
pub mod o { pub use crate::n::n1::*; pub use crate::n::n2::*; pub use crate::n::n3::*; \
pub use crate::n::n4::*; }\n",
"pub mod t { pub struct K; pub use crate::g::*; }\npub mod g { pub use crate::y::*; }\n\
pub mod y { pub struct Y; }\n",
"pub mod e { pub use crate::w::*; }\npub mod w { pub struct Y; }\n",
];
let loads = every_order(
&[blocks],
&[("demo::a::q", "self::Y"), ("demo::r", "self::Y")],
&[
"ambiguous demo::w::Y demo::y::Y",
"ambiguous demo::w::Y demo::y::Y",
],
);
assert_eq!(loads, 24);
}
fn as_the_reference_mode(lib: &str, (module, name, ns): (&str, &str, Namespace), expected: &str) {
let settled = every_answer(lib);
let exact = reference::exact(|| every_answer(lib));
let differ: Vec<String> = settled
.iter()
.zip(&exact)
.filter(|(left, right)| left != right)
.map(|(left, right)| format!("{left}\n in the reference mode {right}"))
.collect();
assert!(differ.is_empty(), "{}", differ.join("\n"));
assert_eq!(settled.len(), exact.len());
let probe = format!("{module} {name} {ns:?}: ");
let found = settled
.iter()
.find_map(|answer| answer.strip_prefix(probe.as_str()))
.unwrap_or_else(|| panic!("no answer for {probe}"));
assert_eq!(found, expected, "{probe}");
}
#[test]
fn a_covert_reader_is_woken_in_the_turn_an_active_read_of_it_would_have_so_the_imports_that_wait_on_the_name_are_queued_again_in_that_order()
{
let lib = "pub(crate) struct A;\n\
mod m5 {\n\
pub(crate) mod s0 {\n\
pub use crate::m3::s1::*;\n\
pub(in crate) use crate::m3::*;\n\
pub use crate::m6::s0::*;\n\
use crate::m7::s0::*;\n\
}\n\
pub mod s1 {\n\
use crate::m6::s0::*;\n\
pub(crate) use crate::m10::*;\n\
}\n\
}\n\
mod m7 {\n\
pub mod s0 {\n\
pub(super) use crate::m3::*;\n\
pub use crate::m0::*;\n\
}\n\
}\n\
pub(crate) mod m9 {\n\
pub use crate::m5::s0::A as D;\n\
}\n\
pub mod m4 {\n\
pub(super) use crate::m7::s0::A as A;\n\
}\n\
pub(crate) mod m3 {\n\
pub(in crate) use crate::m4::*;\n\
pub mod s1 {\n\
pub(crate) struct A;\n\
}\n\
pub use crate::m5::s0::*;\n\
}\n\
pub mod m6 {\n\
pub mod s0 {\n\
pub use crate::m5::s1::D;\n\
}\n\
pub mod s1 {\n\
pub(crate) struct D;\n\
}\n\
}\n\
pub mod m10 {\n\
pub use crate::m3::*;\n\
pub use crate::m6::s1::*;\n\
pub(in crate::m10) use crate::m9::*;\n\
use crate::*;\n\
}\n\
mod m0 {\n\
pub use crate::m10::*;\n\
}\n";
as_the_reference_mode(
lib,
("demo::m5::s0", "D", Namespace::Type),
"ambiguous demo::m3::s1::A demo::m6::s1::D",
);
as_the_reference_mode(
lib,
("demo::m9", "D", Namespace::Type),
"ok demo::m3::s1::A",
);
}
#[test]
fn a_covert_reader_takes_a_gain_in_the_turn_an_active_read_of_it_would_have_so_the_companions_of_a_name_are_kept_as_its_drops_allow()
{
let lib = "pub mod m3 {\n\
pub(crate) use crate::m14::*;\n\
}\n\
pub mod m4 {\n\
mod s1 {\n\
use super::*;\n\
pub use crate::m4::s0::*;\n\
}\n\
pub(in crate::m4) use crate::m3::*;\n\
pub(super) use crate::m4::s1::*;\n\
pub(crate) mod s0 {\n\
pub(in crate) use crate::m13::s0::*;\n\
pub(crate) use crate::m4::*;\n\
}\n\
}\n\
mod m10 {\n\
pub use crate::m4::s0::*;\n\
}\n\
pub(crate) mod m7 {\n\
pub(crate) mod s0 {\n\
pub(in crate::m7) use crate::m13::s0::*;\n\
use crate::m10::*;\n\
}\n\
}\n\
mod m6 {\n\
pub mod s0 {\n\
macro_rules! D { () => {} }\n\
}\n\
pub use crate::m14::s0::*;\n\
}\n\
mod m13 {\n\
pub(crate) mod s0 {\n\
macro_rules! D { () => {} }\n\
}\n\
}\n\
mod m14 {\n\
pub use crate::m6::*;\n\
}\n";
as_the_reference_mode(
lib,
("demo::m7::s0", "D", Namespace::Macro),
"ambiguous demo::m13::s0::D demo::m6::s0::D",
);
}