Struct ResolveContext

pub struct ResolveContext<'a> {
    pub constants: &'a Arena<Constant>,
    pub overrides: &'a Arena<Override>,
    pub types: &'a UniqueArena<Type>,
    pub special_types: &'a SpecialTypes,
    pub global_vars: &'a Arena<GlobalVariable>,
    pub local_vars: &'a Arena<LocalVariable>,
    pub functions: &'a Arena<Function>,
    pub arguments: &'a [FunctionArgument],
}

Fields

constants: &'a Arena<Constant>

overrides: &'a Arena<Override>

types: &'a UniqueArena<Type>

special_types: &'a SpecialTypes

global_vars: &'a Arena<GlobalVariable>

local_vars: &'a Arena<LocalVariable>

functions: &'a Arena<Function>

arguments: &'a [FunctionArgument]

Implementations

impl<'a> ResolveContext<'a>

pub const fn with_locals( module: &'a Module, local_vars: &'a Arena<LocalVariable>, arguments: &'a [FunctionArgument], ) -> Self

Initialize a resolve context from the module.

pub fn resolve( &self, expr: &Expression, past: impl Fn(Handle<Expression>) -> Result<&'a TypeResolution, ResolveError>, ) -> Result<TypeResolution, ResolveError>

Determine the type of expr.

The past argument must be a closure that can resolve the types of any expressions that expr refers to. These can be gathered by caching the results of prior calls to resolve, perhaps as done by the front::Typifier utility type.

Type resolution is a read-only process: this method takes self by shared reference. However, this means that we cannot add anything to self.types that we might need to describe expr. To work around this, this method returns a TypeResolution, rather than simply returning a Handle<Type>; see the documentation for TypeResolution for details.