Struct GatherOutput 

pub struct GatherOutput<'a> {

    pub rir: &'a Rir,
    pub interner: &'a ThreadedRodeo,
    pub structs: HashMap<Spur, StructId>,
    pub enums: HashMap<Spur, EnumId>,
    pub functions: HashMap<Spur, FunctionInfo>,
    pub methods: HashMap<(StructId, Spur), MethodInfo>,
    pub constants: HashMap<Spur, ConstInfo>,
    pub preview_features: PreviewFeatures,
    pub builtin_string_id: Option<StructId>,
    pub builtin_arch_id: Option<EnumId>,
    pub builtin_os_id: Option<EnumId>,
    pub builtin_typekind_id: Option<EnumId>,
    pub type_pool: TypeInternPool,
    pub param_arena: ParamArena,
}

Output from the declaration gathering phase.

This contains the state built during declaration gathering that is needed for function body analysis. After gathering, this can be converted back into a Sema for sequential analysis, or used to drive parallel analysis.

Architecture

The separation of declaration gathering from body analysis enables:

1. Parallel type checking - Each function can be analyzed independently
2. Clearer architecture - Separation of concerns
3. Foundation for incremental - Can cache SemaContext across compilations
4. Better error recovery - One function’s error doesn’t block others

Usage

// Option A: Simple path - all-in-one analysis
let sema = Sema::new(rir, interner, preview);
let output = sema.analyze_all()?;

// Option B: Parallel path (work in progress)
// Build SemaContext and analyze in parallel
let ctx = sema.build_sema_context();
let results: Vec<_> = functions.par_iter()
    .map(|f| analyze_function_body(&ctx, f))
    .collect();

Fields

rir: &'a Rir

Reference to the RIR being analyzed.

interner: &'a ThreadedRodeo

Reference to the string interner.

structs: HashMap<Spur, StructId>

Struct lookup: maps struct name symbol to StructId.

enums: HashMap<Spur, EnumId>

Enum lookup: maps enum name symbol to EnumId.

functions: HashMap<Spur, FunctionInfo>

Function lookup: maps function name to info.

methods: HashMap<(StructId, Spur), MethodInfo>

Method lookup: maps (struct_id, method_name) to info.

constants: HashMap<Spur, ConstInfo>

Constant lookup: maps const name to info.

preview_features: PreviewFeatures

Enabled preview features.

builtin_string_id: Option<StructId>

StructId of the synthetic String type.

builtin_arch_id: Option<EnumId>

EnumId of the synthetic Arch enum (for @target_arch intrinsic).

builtin_os_id: Option<EnumId>

EnumId of the synthetic Os enum (for @target_os intrinsic).

builtin_typekind_id: Option<EnumId>

EnumId of the synthetic TypeKind enum (for @typeInfo intrinsic).

type_pool: TypeInternPool

Type intern pool (ADR-0024 Phase 1).

param_arena: ParamArena

Arena storage for function/method parameter data.

Implementations

impl<'a> GatherOutput<'a>

pub fn into_sema(self) -> Sema<'a>

Convert this gather output back into a Sema for function body analysis.

This is used for sequential analysis. The returned Sema has all declarations already collected and is ready to analyze function bodies.

Trait Implementations

impl<'a> Debug for GatherOutput<'a>

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

Formats the value using the given formatter.