Struct OwnedValidationContext 

pub struct OwnedValidationContext<'a> { /* private fields */ }

Context for Stage 2 (owned) validation.

This context is used when validating owned metadata through CilObject, which contains fully resolved type information and cross-references. CilObject provides access to both raw and resolved metadata through its public API.

Caching

The context maintains a ValidationCache that lazily computes expensive data structures on first access. This eliminates redundant computations across validators while ensuring unused caches have zero overhead.

Available cached data:

• target_assembly_types() - Types from the target assembly
• all_types() - All types including external references
• method_type_mapping() - Method-to-type ownership mappings

Implementations

impl<'a> OwnedValidationContext<'a>

pub fn new( object: &'a CilObject, scanner: &'a ReferenceScanner, config: &'a ValidationConfig, thread_pool: &'a ThreadPool, ) -> Self

Creates a new owned validation context.

Arguments

• object - The CilObject containing both raw and resolved metadata
• scanner - Shared reference scanner
• config - Validation configuration
• thread_pool - Dedicated thread pool for parallel validation

Caching

The context initializes an empty ValidationCache that will lazily compute expensive data structures on first access by any validator.

pub fn object(&self) -> &CilObject

Returns a reference to the CilObject.

This provides access to both raw and fully resolved metadata including type registries, method maps, and other resolved structures through CilObject’s public API.

pub fn thread_pool(&self) -> &ThreadPool

Returns a reference to the dedicated thread pool for this validation session.

This thread pool should be used for all parallel operations within validators to avoid interference with other concurrent validation sessions.

Returns

Returns a reference to the ThreadPool for this validation session.

impl OwnedValidationContext<'_>

pub fn target_assembly_types(&self) -> &Vec<CilTypeRc>

Get types that belong to the assembly being validated (cached).

This method returns only the types that should be validated for the current assembly, filtering out external assembly types that should not be subject to local validation rules.

The result is cached on first access and shared across all validators.

Returns

Cached reference to types from the target assembly that should be validated.

Performance

First call: O(n) where n is the total number of types (filters by assembly) Subsequent calls: O(1) (returns cached reference)

pub fn all_types(&self) -> &Vec<CilTypeRc>

Get all types including external references (cached).

This method returns all types known to the type system, including types from external assemblies. This is needed by validators that must examine cross-assembly relationships (e.g., field type validation).

The result is cached on first access and shared across all validators.

Returns

Cached reference to all types in the type system.

Performance

First call: O(n) where n is the total number of types Subsequent calls: O(1) (returns cached reference)

pub fn method_type_mapping(&self) -> &MethodTypeMapping

Get method-to-type ownership mapping (cached).

This method returns a mapping structure that provides O(1) lookups for:

• Which type owns a given method
• All methods belonging to a given type
• Method lookup by address

The mapping is built from all types (not just target assembly types) to support cross-assembly method inheritance validation.

The result is cached on first access and shared across all validators.

Returns

Cached reference to the MethodTypeMapping structure.

Performance

First call: O(n*m) where n is types and m is average methods per type Subsequent calls: O(1) (returns cached reference)

Usage

let mapping = context.method_type_mapping();
let type_addr = Arc::as_ptr(&some_type) as usize;
for &method_addr in mapping.get_type_methods(type_addr) {
    if let Some(method) = mapping.get_method(method_addr) {
        // Use method...
    }
}

pub fn interface_relationships(&self) -> &FxHashMap<usize, Vec<usize>>

Get interface implementation relationships (cached).

This method returns a mapping from type tokens to the tokens of interfaces they implement. This is used by circularity validators to detect cycles in interface implementation chains.

The result is cached on first access and shared across all validators.

Returns

Cached reference to a FxHashMap mapping type Arc pointers (as usize) to implemented interface Arc pointers (as usize). Using Arc pointers instead of tokens avoids token collisions in multi-assembly scenarios where different types from different assemblies may share the same token value.

Performance

First call: O(n*m) where n is types and m is average interfaces per type Subsequent calls: O(1) (returns cached reference)

pub fn nested_relationships(&self) -> &FxHashMap<Token, Vec<Token>>

Get nested type relationships (cached).

This method returns a mapping from parent type tokens to the tokens of their nested types. This is used by circularity validators to detect cycles in nested type containment.

The result is cached on first access and shared across all validators.

Returns

Cached reference to a FxHashMap mapping type tokens to nested type tokens.

Performance

First call: O(n*m) where n is types and m is average nested types per type Subsequent calls: O(1) (returns cached reference)

Trait Implementations

impl ValidationContext for OwnedValidationContext<'_>

fn validation_stage(&self) -> ValidationStage

Returns the validation stage this context represents.

fn reference_scanner(&self) -> &ReferenceScanner

Returns a reference to the shared reference scanner.

fn config(&self) -> &ValidationConfig

Returns a reference to the validation configuration.