Struct CompileEnvironment 

#[non_exhaustive]
pub struct CompileEnvironment {
    pub directives: Vec<CompileDirective>,
    pub pragma_effects: Vec<PragmaEffect>,
    pub pragma_state_facts: Vec<PragmaStateFact>,
    pub inc_roots: Vec<IncRootFact>,
    pub module_requests: Vec<ModuleRequest>,
    pub phase_blocks: Vec<CompilePhaseBlock>,
    pub dynamic_boundaries: Vec<CompileEnvironmentBoundary>,
}

HIR-local compile environment for compiler-substrate proof.

This model records compile-time directives, pragma state changes, include roots, module requests, phase blocks, and dynamic boundaries without changing LSP provider behavior.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

directives: Vec<CompileDirective>

use, no, and require directives in stable source order.

pragma_effects: Vec<PragmaEffect>

Pragma or feature effects in stable source order.

pragma_state_facts: Vec<PragmaStateFact>

Effective strict/warnings/feature state facts in source order.

inc_roots: Vec<IncRootFact>

Include-root effects such as use lib and no lib.

module_requests: Vec<ModuleRequest>

Static and dynamic module requests observed in the file.

phase_blocks: Vec<CompilePhaseBlock>

Compile-time phase blocks observed in source order.

dynamic_boundaries: Vec<CompileEnvironmentBoundary>

Unsupported or dynamic compile-environment boundaries.

Implementations

impl CompileEnvironment

pub fn pragma_state_facts(&self) -> &[PragmaStateFact]

Effective pragma state facts in source order.

pub fn pragma_state_at(&self, offset: usize) -> Option<&PragmaStateFact>

Return the latest effective pragma state fact at or before offset.

pub fn import_specs(&self, file_id: FileId) -> Vec<ImportSpec>

Project HIR compile directives into canonical import facts.

This is a compiler-substrate projection only. It does not inspect the filesystem, execute Perl, or change workspace/LSP provider behavior.

pub fn module_resolution_candidates( &self, supplied_roots: &[ModuleResolutionRoot], ) -> Vec<ModuleResolutionCandidate>

Build module-resolution candidate facts from static module requests.

The HIR layer records lexical include-root effects and module requests, but it does not read process environment, inspect the filesystem, or depend on the downstream perl-module resolver. Callers provide configured, PERL5LIB, and system roots explicitly; this method combines them with source-order lexical use lib roots active at each request.

pub fn resolved_module_resolution_candidates( &self, supplied_roots: &[ModuleResolutionRoot], path_exists: impl FnMut(&str) -> bool, ) -> Vec<ModuleResolutionCandidate>

Resolve static module candidate facts using a caller-supplied path predicate.

This preserves the HIR layer’s explicit boundary: the caller supplies roots and the existence check, so parser-core still does not read ambient process state or spawn Perl.

Trait Implementations

impl Clone for CompileEnvironment

fn clone(&self) -> CompileEnvironment

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompileEnvironment

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

Formats the value using the given formatter.

impl Default for CompileEnvironment

fn default() -> CompileEnvironment

Returns the “default value” for a type.

impl PartialEq for CompileEnvironment

fn eq(&self, other: &CompileEnvironment) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for CompileEnvironment

impl StructuralPartialEq for CompileEnvironment