Struct Resolver

pub struct Resolver<'a> {
    pub types: &'a ResolvedProgramTypes,
    pub state: &'a mut ResolvedProgramState,
    pub modules: &'a ResolvedModules,
    pub current_module: &'a mut ResolvedModule,
    pub block_scope_stack: Vec<BlockScope>,
    pub return_type: Option<ResolvedType>,
}

Fields

types: &'a ResolvedProgramTypes

state: &'a mut ResolvedProgramState

modules: &'a ResolvedModules

current_module: &'a mut ResolvedModule

block_scope_stack: Vec<BlockScope>

return_type: Option<ResolvedType>

Implementations

impl<'a> Resolver<'a>

pub fn new( types: &'a ResolvedProgramTypes, state: &'a mut ResolvedProgramState, modules: &'a ResolvedModules, current_module: &'a mut ResolvedModule, ) -> Self

pub fn resolve_array_type( &mut self, ast_type: &Type, ) -> Result<ResolvedArrayTypeRef, ResolveError>

pub fn resolve_map_type( &mut self, ast_key_type: &Type, ast_value_type: &Type, ) -> Result<ResolvedMapTypeRef, ResolveError>

pub fn resolve_type( &mut self, ast_type: &Type, ) -> Result<ResolvedType, ResolveError>

pub fn find_module(&self, path: &ModulePath) -> Option<&ResolvedModule>

pub fn find_struct_type( &self, type_name: &QualifiedTypeIdentifier, ) -> Result<ResolvedStructTypeRef, ResolveError>

pub fn find_struct_type_local_mut( &mut self, type_name: &LocalTypeIdentifier, ) -> Result<ResolvedStructTypeRef, ResolveError>

pub fn resolve_struct_type_definition( &mut self, ast_struct: &StructType, ) -> Result<ResolvedStructType, ResolveError>

pub fn insert_definition( &mut self, resolved_definition: ResolvedDefinition, ) -> Result<(), ResolveError>

pub fn resolve_definition( &mut self, ast_def: &Definition, ) -> Result<ResolvedDefinition, ResolveError>

pub fn resolve_type_alias_definition( &mut self, name: &LocalTypeIdentifier, target_type: &Type, ) -> Result<ResolvedType, ResolveError>

pub fn resolve_statements( &mut self, statements: &Vec<Statement>, ) -> Result<Vec<ResolvedStatement>, ResolveError>