Struct ProjectManifest 

pub struct ProjectManifest { /* private fields */ }

What a project’s manifest says about the targets it declares.

The facts are read with miden_project’s own extractors — the very ones miden_project::Package::parse uses — so that a target’s kind, a target’s defaulted name and the package’s name mean here exactly what they mean to a loaded project. None of them is inheritable from a workspace, which is what makes reading the package manifest alone correct: [package] name is a required key of the package’s own file, [lib] kind defaults to library there, and a [[bin]] with no name takes the package’s.

This is the one place the rules live

Two questions are answered from these facts — what target type a project builds by default and which executable it builds — and both have to be answered identically everywhere, because the answers decide different halves of one build. Session::new uses them to set Options::target_type and Options::entrypoint; the Rust frontend’s nested cargo build uses the second to reject a project it could not build, and used to carry its own copy of both rules over a separately loaded project. Two implementations of one rule can only ever agree by coincidence.

read parses a manifest for them, and from_package takes them off a project that is already loaded. That is the whole difference between the callers: where the facts come from, never what is done with them.

Implementations

impl ProjectManifest

pub fn from_package(package: &Package) -> Self

Take these facts off an already-loaded package.

For a caller that has a miden_project::Package in hand and must not load a second one — either because it just loaded that one, or because it came from a workspace and was never a file of its own.

pub fn library_target_type(&self) -> TargetType

The target type a project declaring these targets builds when nothing selects one.

The library target’s kind if there is a library target, and otherwise an executable — which is what a package declaring only [[bin]]s is.

pub fn selected_executable( &self, requested: Option<&str>, ) -> Result<&Target, Report>

The executable target this build compiles, of the ones declared.

requested is --target, which names one outright. Without it there must be exactly one to choose, because nothing else distinguishes them: a package declaring several says which it means, or is asked to.