Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

25.2 KB
Raw Blame
//! `cargo xtask mesh-decisions`: model decisions use exact geometry. What an operation does,
//! which bodies it touches, which face or edge a point or a name refers to, depths and nearness
//! are worked out from the exact B-rep (SMLib: `Body::exact_bounds`, `apart` in
//! `crates/kernel/src/ops.rs`, point classification, projection). A mesh, a body's display
//! tessellation or an imported mesh body, is for display, export, picking previews and measuring
//! mesh bodies.
//!
//! The check reads the non-test Rust of the model crates ([`CRATES`]), following each crate's
//! module tree from its `lib.rs` (a `#[cfg(test)]` module, function or impl is left out), and
//! finds the functions that use a mesh ([`site_uses`] names the patterns). The modules and the
//! functions whose job is display, export, previews or mesh bodies are skipped
//! ([`SKIPPED_MODULES`], [`SKIPPED_FUNCTIONS`], each with its reason).
//! Every other function that uses a mesh is a decision site. The sites there are today are
//! listed in [`LIST`], one a line, `<path>:<function> <what it decides with the mesh>`, sorted
//! (the kernel rig's known-failing format). The list only shrinks: the check fails on a site the
//! list does not name, and on a listed site that no longer uses a mesh (its fix removes its
//! line), as `tests/KNOWN_FAILING_TESTS` and `schema/unconverted.txt` do.

use std::collections::BTreeMap;
use std::path::{Path, PathBuf};

use syn::visit::{self, Visit};

pub const LIST: &str = "xtask/mesh-decisions.txt";

/// The crates whose code decides geometry: the document, the engine and the kernel.
pub const CRATES: &[&str] = &["crates/doc", "crates/engine", "crates/kernel"];

/// The crates where `ModelBody::mesh()` (no argument) is a display mesh. In the kernel, the
/// one argument-less `mesh()` is a T-spline's control net (`geom::tspline::TSpline::mesh`),
/// which is exact geometry, and `ModelBody` does not exist there.
const MODEL_BODY_CRATES: &[&str] = &["crates/doc", "crates/engine"];

/// Modules (a file, or a directory with everything below it) whose job is display, export,
/// previews or mesh bodies: their mesh use is what a mesh is for. Or that hold no mesh at all,
/// only a field the check's syntactic pattern takes for one.
pub const SKIPPED_MODULES: &[(&str, &str)] = &[
    ("crates/doc/src/display_quality.rs", "the viewport's display quality levels"),
    ("crates/doc/src/placed_mesh.rs", "the display meshes and plans of bodies and placed parts"),
    ("crates/doc/src/point_cloud.rs", "no mesh: the triangles of a point cloud's own complex"),
    ("crates/doc/src/point_cloud_complex.rs", "no mesh: the triangles of a point cloud's own complex"),
    ("crates/doc/src/point_cloud_distribution.rs", "no mesh: the triangles of a point cloud's own complex"),
    ("crates/engine/src/cmd/file_thumbnail.rs", "a design's thumbnail picture"),
    ("crates/engine/src/cmd/mesh.rs", "mesh bodies: repair, decimate and inspect imported meshes"),
    ("crates/engine/src/cmd/render", "rendered pictures"),
    ("crates/engine/src/cmd/render.rs", "rendered pictures"),
    ("crates/engine/src/cmd/silhouette.rs", "a picture's view-aligned silhouette of the display meshes"),
    ("crates/engine/src/cmd/surface_analysis.rs", "view analyses: zebra, draft and curvature shading of the display mesh"),
    ("crates/engine/src/cmd/view_dxf_meshes.rs", "a drawing's view lines from display meshes"),
    ("crates/engine/src/cmd/view_dxf_scene.rs", "a drawing's hidden-line occlusion over display meshes"),
    ("crates/engine/src/cosmetic_threads.rs", "cosmetic thread hatching drawn on the displayed triangles"),
    ("crates/engine/src/fuzz.rs", "the fuzz harness, which frames what it built"),
    ("crates/engine/src/product_scene.rs", "the scene a rendered picture draws"),
    ("crates/engine/src/render_jobs.rs", "rendered pictures"),
    ("crates/engine/src/slicer_files.rs", "the mesh export a 3D-printing slicer opens"),
    ("crates/engine/src/snap.rs", "the pointer's snap preview over the display mesh"),
    ("crates/engine/src/view.rs", "the viewport's meshes, edges and highlights"),
    ("crates/kernel/src/mesh_convert.rs", "mesh bodies: turning a mesh body into a solid"),
    ("crates/kernel/src/meshbody.rs", "mesh bodies"),
    ("crates/kernel/src/native/preview.rs", "a feature's preview mesh"),
    ("crates/kernel/src/polybool.rs", "mesh bodies: booleans of a body with a closed triangle mesh"),
    ("crates/kernel/src/tess", "the mesher: a body's display tessellation"),
];

/// Functions, in modules that also decide geometry, whose job is the display mesh itself, a
/// preview, or a mesh body.
pub const SKIPPED_FUNCTIONS: &[(&str, &str)] = &[
    ("crates/doc/src/eval.rs:ImportDigests::of", "mesh-body imports: retained content identities, not tessellated-solid decisions"),
    ("crates/doc/src/eval.rs:MeshDigest::matches", "mesh-body imports: compares retained source-array identities"),
    ("crates/doc/src/eval.rs:ModelBody::display_plan", "the display plan"),
    ("crates/doc/src/eval.rs:ModelBody::mesh", "the display mesh"),
    ("crates/doc/src/eval.rs:ModelBody::mesh_in_place", "the display mesh where the body stands"),
    ("crates/doc/src/eval.rs:ModelBody::plan_mesh", "the display plan's mesh"),
    ("crates/doc/src/eval.rs:ModelBody::plan_mesh_at", "the display plan's mesh"),
    ("crates/doc/src/eval.rs:ModelBody::plan_mesh_in_place_at", "the display plan's mesh where the body stands"),
    ("crates/doc/src/eval.rs:ModelBody::plan_mesh_soon", "the display plan's mesh, made ahead"),
    ("crates/doc/src/eval.rs:ModelBody::refined_display", "the display plan at a finer quality"),
    ("crates/doc/src/eval.rs:ModelState::warm_display", "display meshes made ahead"),
    ("crates/doc/src/eval.rs:ModelState::warm_display_at", "display meshes made ahead"),
    ("crates/doc/src/eval.rs:ModelState::warm_meshes", "display meshes made ahead"),
    ("crates/doc/src/eval.rs:feature_json", "fingerprints feature inputs; triangles are only embedded mesh-body source data"),
    ("crates/doc/src/eval.rs:mesh_bodies", "mesh bodies: a mesh import's triangles"),
    ("crates/doc/src/eval.rs:mesh_content_digest", "mesh-body imports: hashes source arrays without geometric classification"),
    ("crates/engine/src/cmd/file.rs:saved_preview", "the preview picture saved in a design"),
    ("crates/kernel/src/body.rs:Body::classify_point", "mesh bodies: its mesh-body branch (a B-rep is classified by SMLib)"),
    ("crates/kernel/src/body.rs:Body::mesh_untimed", "the mesher: a body's tessellation"),
    ("crates/kernel/src/body.rs:Body::retained_bytes", "the evaluation cache's memory estimate"),
    ("crates/kernel/src/body.rs:Body::unmeshed_faces", "the mesher's report of faces it left out"),
];

/// What a function does with a mesh, the patterns the check matches:
/// - `.mesh(t)` (one argument): `kernel::Body::mesh`, a body's tessellation;
/// - `.mesh()` (none), in [`MODEL_BODY_CRATES`]: `ModelBody::mesh`, its display mesh;
/// - `.mesh_plan(t)`, `.mesh_of(plan)`: the tessellation plan and the mesh it evaluates to;
/// - `.plan_mesh()`, `.plan_mesh_at(q)`, `.display_plan()`, `.display_plan_at(q)`: the display
///   plan and its mesh;
/// - `mesh_box(..)`, `body_box(..)`, `reference_mesh(..)`: a box or mesh from a tessellation;
/// - `.triangles`: reading a mesh's triangles (nearest point, ray casts, inside tests);
/// - `closest_on_triangle(..)`: the nearest point of a triangle.
fn site_uses(call: &Call, model_body: bool) -> Option<&'static str> {
    match (call, call.name()) {
        (Call::Method { args: 1, .. }, "mesh") => Some(".mesh(t)"),
        (Call::Method { args: 0, .. }, "mesh") if model_body => Some(".mesh()"),
        (Call::Method { .. }, "mesh_plan") => Some(".mesh_plan()"),
        (Call::Method { .. }, "mesh_of") => Some(".mesh_of()"),
        (Call::Method { .. }, "plan_mesh" | "plan_mesh_at") => Some(".plan_mesh()"),
        (Call::Method { .. }, "display_plan" | "display_plan_at") => Some(".display_plan()"),
        (Call::Function { .. }, "mesh_box") => Some("mesh_box()"),
        (Call::Function { .. }, "body_box") => Some("body_box()"),
        (Call::Function { .. }, "reference_mesh") => Some("reference_mesh()"),
        (Call::Function { .. }, "closest_on_triangle") => Some("closest_on_triangle()"),
        (Call::Field { .. }, "triangles") => Some(".triangles"),
        _ => None,
    }
}

/// A use in the source that [`site_uses`] grades.
enum Call {
    Method { name: String, args: usize },
    Function { name: String },
    Field { name: String },
}

impl Call {
    fn name(&self) -> &str {
        match self {
            Call::Method { name, .. } | Call::Function { name } | Call::Field { name } => name,
        }
    }
}

pub fn run(root: &Path) -> Result<(), String> {
    println!("{}", check(root, SKIPPED_MODULES, SKIPPED_FUNCTIONS)?);
    Ok(())
}

/// The sites under `root`, these modules and functions skipped, graded against [`LIST`].
fn check(root: &Path, modules: &[(&str, &str)], functions: &[(&str, &str)]) -> Result<String, String> {
    let found = scan_skipping(root, modules, functions)?;
    let text = std::fs::read_to_string(root.join(LIST)).map_err(|e| format!("{LIST}: {e}"))?;
    grade(&text, &found).map_err(|e| format!("{LIST}: {e}"))
}

/// Every decision site under `root`, these modules and functions skipped: `<path>:<function>`
/// with the patterns it uses. A skipped module that does not exist, or a skipped function that
/// does not use a mesh, is an error: the skips stay true.
fn scan_skipping(root: &Path, modules: &[(&str, &str)], functions: &[(&str, &str)]) -> Result<BTreeMap<String, Vec<&'static str>>, String> {
    for (skip, _) in modules {
        if !root.join(skip).exists() {
            return Err(format!("{skip} is skipped but does not exist: take it off SKIPPED_MODULES in xtask/src/mesh_decisions.rs"));
        }
    }
    let mut found = BTreeMap::new();
    for krate in CRATES {
        let lib = root.join(krate).join("src/lib.rs");
        let model_body = MODEL_BODY_CRATES.contains(krate);
        let mut files = Vec::new();
        module_files(&lib, true, &mut files)?;
        files.sort();
        files.dedup();
        for path in files {
            let rel = relative(root, &path);
            if modules.iter().any(|(skip, _)| rel == *skip || rel.starts_with(&format!("{skip}/"))) {
                continue;
            }
            let source = std::fs::read_to_string(&path).map_err(|e| format!("{rel}: {e}"))?;
            for (function, uses) in sites(&source, model_body).map_err(|e| format!("{rel}: {e}"))? {
                found.insert(format!("{rel}:{function}"), uses);
            }
        }
    }
    for (skip, _) in functions {
        if found.remove(*skip).is_none() {
            return Err(format!("{skip} is skipped but uses no mesh: take it off SKIPPED_FUNCTIONS in xtask/src/mesh_decisions.rs"));
        }
    }
    Ok(found)
}

fn relative(root: &Path, path: &Path) -> String {
    path.strip_prefix(root).unwrap_or(path).to_string_lossy().replace('\\', "/")
}

/// The source files of the module at `file` and of every non-test module below it, into `out`.
/// `owns_dir` is whether `file` is a `lib.rs` or `mod.rs` (its submodules sit beside it) rather
/// than `name.rs` (its submodules sit in `name/`).
fn module_files(file: &Path, owns_dir: bool, out: &mut Vec<PathBuf>) -> Result<(), String> {
    let source = std::fs::read_to_string(file).map_err(|e| format!("{}: {e}", file.display()))?;
    let ast = syn::parse_file(&source).map_err(|e| format!("{}: cannot parse Rust source: {e}", file.display()))?;
    out.push(file.to_path_buf());
    let here = file.parent().unwrap_or(Path::new("."));
    let dir = if owns_dir { here.to_path_buf() } else { here.join(file.file_stem().unwrap_or_default()) };
    declared_modules(&ast.items, here, &dir, out)
}

/// The out-of-line modules `items` declare. `here` is the directory of the file they are in
/// (`#[path]` resolves against it); `dir` is where their files sit without one.
fn declared_modules(items: &[syn::Item], here: &Path, dir: &Path, out: &mut Vec<PathBuf>) -> Result<(), String> {
    for item in items {
        let syn::Item::Mod(m) = item else { continue };
        if test_only(&m.attrs) {
            continue;
        }
        let name = m.ident.to_string();
        let path = path_attribute(&m.attrs);
        match &m.content {
            Some((_, inner)) => {
                let base = match &path {
                    Some(p) => here.join(p),
                    None => dir.join(&name),
                };
                declared_modules(inner, &base, &base, out)?;
            }
            None => match path {
                Some(p) => {
                    let file = here.join(p);
                    let owns = file.file_name().is_some_and(|f| f == "mod.rs");
                    module_files(&file, owns, out)?;
                }
                None => {
                    let flat = dir.join(format!("{name}.rs"));
                    if flat.is_file() {
                        module_files(&flat, false, out)?;
                    } else {
                        module_files(&dir.join(&name).join("mod.rs"), true, out)?;
                    }
                }
            },
        }
    }
    Ok(())
}

fn path_attribute(attrs: &[syn::Attribute]) -> Option<String> {
    attrs.iter().find(|a| a.path().is_ident("path")).and_then(|a| match &a.meta {
        syn::Meta::NameValue(nv) => match &nv.value {
            syn::Expr::Lit(syn::ExprLit { lit: syn::Lit::Str(s), .. }) => Some(s.value()),
            _ => None,
        },
        _ => None,
    })
}

/// Whether `attrs` keep an item to test builds: `#[test]`, `#[cfg(test)]` or
/// `#[cfg(all(.., test, ..))]`.
fn test_only(attrs: &[syn::Attribute]) -> bool {
    attrs.iter().any(|a| {
        if a.path().is_ident("test") {
            return true;
        }
        if !a.path().is_ident("cfg") {
            return false;
        }
        let Ok(meta) = a.parse_args::<syn::Meta>() else { return false };
        match meta {
            syn::Meta::Path(p) => p.is_ident("test"),
            syn::Meta::List(l) if l.path.is_ident("all") => l
                .parse_args_with(syn::punctuated::Punctuated::<syn::Meta, syn::Token![,]>::parse_terminated)
                .is_ok_and(|items| items.iter().any(|m| m.path().is_ident("test"))),
            _ => false,
        }
    })
}

/// The functions of `source` that use a mesh, with the patterns each uses (outside test code).
pub fn sites(source: &str, model_body: bool) -> Result<BTreeMap<String, Vec<&'static str>>, String> {
    let ast = syn::parse_file(source).map_err(|e| format!("cannot parse Rust source: {e}"))?;
    let mut finder = Finder { model_body, scope: Vec::new(), found: BTreeMap::new() };
    finder.visit_file(&ast);
    Ok(finder.found)
}

struct Finder {
    model_body: bool,
    /// The enclosing inline modules, impl type and function, outermost first.
    scope: Vec<String>,
    found: BTreeMap<String, Vec<&'static str>>,
}

impl Finder {
    fn note(&mut self, call: Call) {
        let Some(what) = site_uses(&call, self.model_body) else { return };
        let site = if self.scope.is_empty() { "<module>".to_owned() } else { self.scope.join("::") };
        let uses = self.found.entry(site).or_default();
        if !uses.contains(&what) {
            uses.push(what);
        }
    }

    fn scoped(&mut self, name: String, f: impl FnOnce(&mut Self)) {
        self.scope.push(name);
        f(self);
        self.scope.pop();
    }

    /// A macro's arguments, when they are expressions (`format!`, `vec!`, `assert!`): syn leaves
    /// macro bodies unparsed, and a mesh call inside one is a use all the same.
    fn macro_args(&mut self, mac: &syn::Macro) {
        let parser = syn::punctuated::Punctuated::<syn::Expr, syn::Token![,]>::parse_terminated;
        if let Ok(args) = mac.parse_body_with(parser) {
            for e in &args {
                self.visit_expr(e);
            }
        } else if let Ok(block) = mac.parse_body_with(syn::Block::parse_within) {
            for s in &block {
                self.visit_stmt(s);
            }
        }
    }
}

fn type_name(ty: &syn::Type) -> String {
    match ty {
        syn::Type::Path(p) => p.path.segments.last().map_or_else(|| "<type>".to_owned(), |s| s.ident.to_string()),
        syn::Type::Reference(r) => type_name(&r.elem),
        _ => "<type>".to_owned(),
    }
}

impl<'ast> Visit<'ast> for Finder {
    fn visit_item_mod(&mut self, m: &'ast syn::ItemMod) {
        if !test_only(&m.attrs) && m.content.is_some() {
            self.scoped(m.ident.to_string(), |f| visit::visit_item_mod(f, m));
        }
    }

    fn visit_item_fn(&mut self, i: &'ast syn::ItemFn) {
        if !test_only(&i.attrs) {
            self.scoped(i.sig.ident.to_string(), |f| visit::visit_item_fn(f, i));
        }
    }

    fn visit_item_impl(&mut self, i: &'ast syn::ItemImpl) {
        if !test_only(&i.attrs) {
            self.scoped(type_name(&i.self_ty), |f| visit::visit_item_impl(f, i));
        }
    }

    fn visit_impl_item_fn(&mut self, i: &'ast syn::ImplItemFn) {
        if !test_only(&i.attrs) {
            self.scoped(i.sig.ident.to_string(), |f| visit::visit_impl_item_fn(f, i));
        }
    }

    fn visit_item_trait(&mut self, i: &'ast syn::ItemTrait) {
        if !test_only(&i.attrs) {
            self.scoped(i.ident.to_string(), |f| visit::visit_item_trait(f, i));
        }
    }

    fn visit_trait_item_fn(&mut self, i: &'ast syn::TraitItemFn) {
        if !test_only(&i.attrs) {
            self.scoped(i.sig.ident.to_string(), |f| visit::visit_trait_item_fn(f, i));
        }
    }

    fn visit_item_const(&mut self, i: &'ast syn::ItemConst) {
        if !test_only(&i.attrs) {
            self.scoped(i.ident.to_string(), |f| visit::visit_item_const(f, i));
        }
    }

    fn visit_item_static(&mut self, i: &'ast syn::ItemStatic) {
        if !test_only(&i.attrs) {
            self.scoped(i.ident.to_string(), |f| visit::visit_item_static(f, i));
        }
    }

    fn visit_stmt(&mut self, s: &'ast syn::Stmt) {
        if let syn::Stmt::Local(l) = s
            && test_only(&l.attrs)
        {
            return;
        }
        visit::visit_stmt(self, s);
    }

    fn visit_expr_method_call(&mut self, e: &'ast syn::ExprMethodCall) {
        self.note(Call::Method { name: e.method.to_string(), args: e.args.len() });
        visit::visit_expr_method_call(self, e);
    }

    fn visit_expr_call(&mut self, e: &'ast syn::ExprCall) {
        if let syn::Expr::Path(p) = e.func.as_ref()
            && let Some(last) = p.path.segments.last()
        {
            self.note(Call::Function { name: last.ident.to_string() });
        }
        visit::visit_expr_call(self, e);
    }

    fn visit_expr_field(&mut self, e: &'ast syn::ExprField) {
        if let syn::Member::Named(name) = &e.member {
            self.note(Call::Field { name: name.to_string() });
        }
        visit::visit_expr_field(self, e);
    }

    fn visit_macro(&mut self, mac: &'ast syn::Macro) {
        self.macro_args(mac);
        visit::visit_macro(self, mac);
    }
}

/// The gate: every site in `found` is listed in `list`, and every listed site is still found.
fn grade(list: &str, found: &BTreeMap<String, Vec<&'static str>>) -> Result<String, String> {
    let listed = crate::kernel_cases::known_failing(list)?;
    let mut problems = Vec::new();
    for (site, uses) in found {
        if !listed.iter().any(|(s, _)| s == site) {
            problems.push(format!(
                "NEW: {site} decides with a mesh ({}): use exact geometry (`Body::exact_bounds`, `kernel::apart`, the B-rep's \
                 faces and edges); a mesh is for display, export, previews and mesh bodies",
                uses.join(", ")
            ));
        }
    }
    for (site, _) in &listed {
        if !found.contains_key(*site) {
            problems.push(format!("FIXED: {site} no longer uses a mesh: remove its line"));
        }
    }
    if problems.is_empty() {
        Ok(format!("mesh-decisions: {} known decision sites use a mesh; no new ones", listed.len()))
    } else {
        Err(format!("{} problem(s):\n  {}", problems.len(), problems.join("\n  ")))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn found(source: &str) -> BTreeMap<String, Vec<&'static str>> {
        sites(source, true).unwrap()
    }

    #[test]
    fn mesh_uses_are_found_per_function_outside_tests() {
        let s = found(
            r#"
            fn decides(b: &Body) -> bool { b.mesh(&tol).is_ok() }
            fn display_mesh(mb: &ModelBody) -> usize { mb.mesh().triangles.len() }
            impl Sheet { fn near(&self) -> bool { boxes_apart(&mesh_box(self.mb), &body_box(&self.tool)) } }
            fn in_macro(mb: &ModelBody) -> String { format!("{}", mb.plan_mesh().is_some()) }
            fn exact(b: &Body) -> bool { b.exact_bounds().is_ok() }
            #[cfg(test)] mod tests { fn fixture(b: &Body) { b.mesh(&tol); } }
            #[test] fn t(b: &Body) { b.mesh(&tol); }
            mod inner { fn nearest(p: Vec3, t: [Vec3; 3]) -> Vec3 { closest_on_triangle(p, t[0], t[1], t[2]) } }
            "#,
        );
        let keys: Vec<&str> = s.keys().map(String::as_str).collect();
        assert_eq!(keys, ["Sheet::near", "decides", "display_mesh", "in_macro", "inner::nearest"]);
        assert_eq!(s["display_mesh"], [".triangles", ".mesh()"]);
        assert_eq!(s["Sheet::near"], ["mesh_box()", "body_box()"]);
        // In the kernel the argument-less `mesh()` is a T-spline's control net.
        assert!(sites("fn regular(ts: &TSpline) -> bool { ts.mesh().is_regular() }", false).unwrap().is_empty());
        assert!(sites("invalid Rust {{", true).is_err(), "unparseable source fails closed");
    }

    const LISTED: &str = "# comment\na.rs:decides why\nb.rs:near why\n";

    fn sites_of(names: &[&str]) -> BTreeMap<String, Vec<&'static str>> {
        names.iter().map(|n| (n.to_string(), vec![".mesh(t)"])).collect()
    }

    #[test]
    fn listed_sites_pass() {
        assert!(grade(LISTED, &sites_of(&["a.rs:decides", "b.rs:near"])).is_ok());
    }

    #[test]
    fn a_new_site_fails() {
        let e = grade(LISTED, &sites_of(&["a.rs:decides", "b.rs:near", "c.rs:picks"])).unwrap_err();
        assert!(e.contains("NEW: c.rs:picks"), "{e}");
    }

    #[test]
    fn a_fixed_site_still_listed_fails() {
        let e = grade(LISTED, &sites_of(&["a.rs:decides"])).unwrap_err();
        assert!(e.contains("FIXED: b.rs:near"), "{e}");
    }

    #[test]
    fn the_list_is_sorted_with_a_reason_each() {
        assert!(grade("b.rs:near why\na.rs:decides why\n", &sites_of(&["a.rs:decides", "b.rs:near"])).is_err());
        assert!(grade("a.rs:decides\n", &sites_of(&["a.rs:decides"])).is_err());
    }

    #[test]
    fn the_module_tree_leaves_out_test_modules_and_follows_paths() {
        let unique = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos();
        let root = std::env::temp_dir().join(format!("solidcraft-mesh-decisions-{}-{unique}", std::process::id()));
        let src = root.join("crates/doc/src");
        std::fs::create_dir_all(src.join("eval")).unwrap();
        std::fs::create_dir_all(root.join("crates/engine/src")).unwrap();
        std::fs::create_dir_all(root.join("crates/kernel/src/tess")).unwrap();
        std::fs::write(src.join("lib.rs"), "mod eval;\n#[cfg(test)]\nmod tests;\n").unwrap();
        std::fs::write(src.join("eval.rs"), "#[path = \"more.rs\"]\nmod more;\nmod nested;\n").unwrap();
        std::fs::write(src.join("more.rs"), "fn skip(mb: &ModelBody) -> bool { mb.mesh().triangles.is_empty() }").unwrap();
        std::fs::write(src.join("eval/nested.rs"), "fn hit(b: &Body) { b.mesh(&t); }").unwrap();
        std::fs::write(src.join("tests.rs"), "fn fixture(b: &Body) { b.mesh(&t); }").unwrap();
        std::fs::write(root.join("crates/engine/src/lib.rs"), "").unwrap();
        std::fs::write(root.join("crates/kernel/src/lib.rs"), "mod tess;").unwrap();
        std::fs::write(root.join("crates/kernel/src/tess/mod.rs"), "fn mesher(b: &Body) { b.mesh_plan(&t); }").unwrap();
        let found = scan_skipping(&root, &[("crates/kernel/src/tess", "the mesher")], &[]).unwrap();
        assert!(scan_skipping(&root, &[("crates/doc/src/gone.rs", "gone")], &[]).is_err(), "a skipped module that is gone fails");
        assert!(scan_skipping(&root, &[], &[("crates/doc/src/more.rs:other", "x")]).is_err(), "a skipped function without a mesh fails");
        let keys: Vec<&str> = found.keys().map(String::as_str).collect();
        assert_eq!(keys, ["crates/doc/src/eval/nested.rs:hit", "crates/doc/src/more.rs:skip"]);
        std::fs::create_dir_all(root.join("xtask")).unwrap();
        std::fs::write(root.join(LIST), "crates/doc/src/eval/nested.rs:hit picks a face\ncrates/doc/src/more.rs:skip skips a body\n").unwrap();
        let skips: &[(&str, &str)] = &[("crates/kernel/src/tess", "the mesher")];
        check(&root, skips, &[]).unwrap();
        std::fs::write(src.join("eval/nested.rs"), "fn hit(b: &Body) { b.exact_bounds(); }").unwrap();
        assert!(check(&root, skips, &[]).unwrap_err().contains("FIXED: crates/doc/src/eval/nested.rs:hit"));
        std::fs::write(src.join("eval/nested.rs"), "fn hit(b: &Body) { b.mesh(&t); }\nfn picks(b: &Body) { b.mesh(&t); }").unwrap();
        assert!(check(&root, skips, &[]).unwrap_err().contains("NEW: crates/doc/src/eval/nested.rs:picks"));
        std::fs::remove_dir_all(root).unwrap();
    }

    #[test]
    fn the_workspace_has_no_new_mesh_decisions() {
        run(Path::new(env!("CARGO_MANIFEST_DIR")).parent().unwrap()).unwrap();
    }
}