Struct ExplicitSourceRoots 

pub struct ExplicitSourceRoots { /* private fields */ }

Explicit source roots resolved against a project root. Each is an existing directory or a single file, so a flat layout can name the modules it keeps at the root one by one. A root that does not exist names nothing to measure and is skipped; one that is neither a file nor a directory is refused, since a symlink root would reach outside what the project owns.

Implementations

impl ExplicitSourceRoots

pub fn resolve( root: &Path, configured: &[String], ) -> Result<Self, SourceDiscoveryError>

pub fn from_environment( root: &Path, environment: &BTreeMap<String, String>, ) -> Result<Option<Self>, SourceDiscoveryError>

Read the roots from the environment, if any are named.

pub fn from_environment_in( project: &Path, workspace: &Path, environment: &BTreeMap<String, String>, ) -> Result<Option<Self>, SourceDiscoveryError>

Read the roots named against project, resolved inside workspace – the isolated copy Go, the JVM and Rust measure. The copy mirrors the project, so a relative root names the same file in both. An absolute one names the original tree, which nothing in the copy lies under, so it is rebased onto the copy; without that it would match nothing and read as a typo. The roots are still quoted as they were written.

pub fn contains(&self, relative: &str) -> bool

Whether a project-relative file lies under these roots: inside a directory root, or the very file a file root names.

pub fn configured(&self) -> &[String]

The roots exactly as they were written, including any that name nothing. An error about roots quotes these, because the one that does not exist is usually the typo the person needs to see.

pub fn refuse_if_empty( &self, remaining: usize, language: &str, ) -> Result<(), String>

Refuse roots that left a frontend nothing to measure. A typo in the variable must not become a green run over zero files – the failure mode most likely to pass unnoticed in an agent loop.

pub fn scope( &self, included: &[String], excluded: &[(String, &'static str)], ) -> Result<SourceScope, SourceDiscoveryError>

The scope a frontend that has no scope of its own records when explicit roots shaped what it measures: the files kept, and the files the roots left out. Without it, honouring the variable would be as invisible as ignoring it – the complaint that started this – since runs <id> scope would have nothing to show.

pub fn local_roots(&self) -> Result<Vec<String>, SourceDiscoveryError>

The roots as project-relative paths, as the recorded scope names them.

pub fn narrow<T>( &self, sources: &mut Vec<T>, excluded: &mut Vec<(String, &'static str)>, file: impl Fn(&T) -> &str, )

Split sources into the files these roots keep and the ones they leave out, recording why each was left out. A frontend’s own exclusions – tests, environments, build output – have already been applied, so a root narrows what is measured and never pulls a test file back in.

Trait Implementations

impl Clone for ExplicitSourceRoots

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ExplicitSourceRoots

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.