Struct TypeState

pub struct TypeState {

    pub(crate) type_vars: Vec<TypeVar>,
    pub(crate) key: u64,
    pub(crate) keys: BTreeSet<u64>,
    pub(crate) equations: TypeEquations,
    pub(crate) next_typeid: RefCell<u64>,
    pub(crate) generic_lists: HashMap<GenericListToken, HashMap<NameID, TypeVarID>>,
    pub(crate) constraints: TypeConstraints,
    pub(crate) requirements: Vec<Requirement>,
    pub(crate) replacements: ReplacementStack,
    pub(crate) pipeline_state: Option<PipelineState>,
    pub trait_impls: TraitImplList,
    pub trace_stack: TraceStack,
    pub diags: DiagList,
}

State of the type inference algorithm

Fields

type_vars: Vec<TypeVar>

All types are referred to by their index to allow type vars changing inside the type state while the types are “out in the wild”. The TypeVarID is an index into this type_vars list which is used to look up the actual type as currently seen by the type state

key: u64

This key is used to prevent bugs when multiple type states are mixed. Each TypeVarID holds the value of the key of the type state which created it, and this is checked to ensure that type vars are not mixed. The key is initialized randomly on type state creation

keys: BTreeSet<u64>

A type state can also support keys from other sources, this is tracked here

equations: TypeEquations

next_typeid: RefCell<u64>

generic_lists: HashMap<GenericListToken, HashMap<NameID, TypeVarID>>

constraints: TypeConstraints

requirements: Vec<Requirement>

Requirements which must be fulfilled but which do not guide further type inference. For example, if seeing let y = x.a before knowing the type of x, a requirement is added to say “x has field a, and y should be the type of that field”

replacements: ReplacementStack

pipeline_state: Option<PipelineState>

The type var containing the depth of the pipeline stage we are currently in

trait_impls: TraitImplList

trace_stack: TraceStack

diags: DiagList

Implementations

impl TypeState

pub fn visit_identifier( &mut self, expression: &Loc<Expression>, ctx: &Context<'_>, ) -> Result<()>

pub fn visit_type_level_integer( &mut self, expression: &Loc<Expression>, generic_list: &GenericListToken, ctx: &Context<'_>, ) -> Result<()>

pub fn visit_pipeline_ref( &mut self, expression: &Loc<Expression>, generic_list: &GenericListToken, ctx: &Context<'_>, ) -> Result<()>

pub fn visit_int_literal( &mut self, expression: &Loc<Expression>, ctx: &Context<'_>, ) -> Result<()>

pub fn visit_bool_literal( &mut self, expression: &Loc<Expression>, ctx: &Context<'_>, ) -> Result<()>

pub fn visit_bit_literal( &mut self, expression: &Loc<Expression>, ctx: &Context<'_>, ) -> Result<()>

pub fn visit_tuple_literal( &mut self, expression: &Loc<Expression>, ctx: &Context<'_>, generic_list: &GenericListToken, ) -> Result<()>

pub fn visit_tuple_index( &mut self, expression: &Loc<Expression>, ctx: &Context<'_>, generic_list: &GenericListToken, ) -> Result<()>

pub fn visit_field_access( &mut self, expression: &Loc<Expression>, ctx: &Context<'_>, generic_list: &GenericListToken, ) -> Result<()>

pub fn visit_method_call( &mut self, expression: &Loc<Expression>, ctx: &Context<'_>, generic_list: &GenericListToken, ) -> Result<()>

pub fn visit_array_literal( &mut self, expression: &Loc<Expression>, ctx: &Context<'_>, generic_list: &GenericListToken, ) -> Result<()>

pub fn visit_array_shorthand_literal( &mut self, expression: &Loc<Expression>, ctx: &Context<'_>, generic_list: &GenericListToken, ) -> Result<()>

pub fn visit_create_ports( &mut self, expression: &Loc<Expression>, ctx: &Context<'_>, _generic_list: &GenericListToken, ) -> Result<()>

pub fn visit_index( &mut self, expression: &Loc<Expression>, ctx: &Context<'_>, generic_list: &GenericListToken, ) -> Result<()>

pub fn visit_range_index( &mut self, expression: &Loc<Expression>, ctx: &Context<'_>, generic_list: &GenericListToken, ) -> Result<()>

pub fn visit_block_expr( &mut self, expression: &Loc<Expression>, ctx: &Context<'_>, generic_list: &GenericListToken, ) -> Result<()>

pub fn visit_if( &mut self, expression: &Loc<Expression>, ctx: &Context<'_>, generic_list: &GenericListToken, ) -> Result<()>

pub fn visit_match( &mut self, expression: &Loc<Expression>, ctx: &Context<'_>, generic_list: &GenericListToken, ) -> Result<()>

pub fn visit_binary_operator( &mut self, expression: &Loc<Expression>, ctx: &Context<'_>, generic_list: &GenericListToken, ) -> Result<()>

pub fn visit_unary_operator( &mut self, expression: &Loc<Expression>, ctx: &Context<'_>, generic_list: &GenericListToken, ) -> Result<()>

impl TypeState

pub fn t_int(&mut self, loc: Loc<()>, symtab: &SymbolTable) -> TypeVarID

pub fn t_uint(&mut self, loc: Loc<()>, symtab: &SymbolTable) -> TypeVarID

pub fn t_bit(&mut self, loc: Loc<()>, symtab: &SymbolTable) -> TypeVarID

pub fn t_bool(&mut self, loc: Loc<()>, symtab: &SymbolTable) -> TypeVarID

pub fn t_clock(&mut self, loc: Loc<()>, symtab: &SymbolTable) -> TypeVarID

pub fn t_err(&mut self, loc: Loc<()>) -> TypeVarID

impl TypeState

pub fn type_decl_to_concrete( decl: &TypeDeclaration, type_list: &TypeList, params: Vec<ConcreteType>, invert: bool, ) -> ConcreteType

pub fn type_expr_to_concrete( expr: &TypeExpression, type_list: &TypeList, generic_substitutions: &HashMap<NameID, &ConcreteType>, invert: bool, ) -> ConcreteType

pub fn type_spec_to_concrete( spec: &TypeSpec, type_list: &TypeList, generic_substitutions: &HashMap<NameID, &ConcreteType>, invert: bool, ) -> ConcreteType

pub fn inner_ungenerify_type( &self, var: &TypeVarID, symtab: &SymbolTable, type_list: &TypeList, invert: bool, ) -> Option<ConcreteType>

pub fn ungenerify_type( &self, var: &TypeVarID, symtab: &SymbolTable, type_list: &TypeList, ) -> Option<ConcreteType>

Converts the specified type to a concrete type, returning None if it fails

pub fn concrete_type_of_infallible( &self, id: ExprID, symtab: &SymbolTable, type_list: &TypeList, ) -> ConcreteType

Returns the type of the specified expression ID as a concrete type. If the type is not known, or the type is Generic, panics

pub fn concrete_type_of( &self, id: impl HasConcreteType, symtab: &SymbolTable, types: &TypeList, ) -> Result<ConcreteType, Diagnostic>

Returns the concrete type of anything that might have a concrete type. Errors if the type is not fully known.

pub fn concrete_type_of_name( &self, name: &Loc<NameID>, symtab: &SymbolTable, types: &TypeList, ) -> Result<ConcreteType, Diagnostic>

Like concrete_type_of but reports an error message that mentions names instead of an expression

impl TypeState

pub fn fresh() -> Self

Create a fresh type state, in most cases, this should be .create_child of an existing type state

pub fn create_child(&self) -> Self

pub fn add_type_var(&mut self, var: TypeVar) -> TypeVarID

pub fn get_equations(&self) -> &TypeEquations

pub fn get_constraints(&self) -> &TypeConstraints

pub fn get_generic_list<'a>( &'a self, generic_list_token: &'a GenericListToken, ) -> Option<&'a HashMap<NameID, TypeVarID>>

pub(crate) fn hir_type_expr_to_var<'a>( &'a mut self, e: &Loc<TypeExpression>, generic_list_token: &GenericListToken, ) -> Result<TypeVarID>

pub fn type_var_from_hir<'a>( &'a mut self, loc: Loc<()>, hir_type: &TypeSpec, generic_list_token: &GenericListToken, ) -> Result<TypeVarID>

pub fn type_of(&self, expr: &TypedExpression) -> TypeVarID

Returns the type of the expression with the specified id. Error if no equation for the specified expression exists

pub fn maybe_type_of(&self, expr: &TypedExpression) -> Option<&TypeVarID>

pub fn new_generic_int(&mut self, loc: Loc<()>, symtab: &SymbolTable) -> TypeVar

pub fn new_concrete_int(&mut self, size: BigUint, loc: Loc<()>) -> TypeVarID

pub fn new_split_generic_int( &mut self, loc: Loc<()>, symtab: &SymbolTable, ) -> (TypeVarID, TypeVarID)

Return a new generic int. The first returned value is int, and the second value is N

pub fn new_split_generic_uint( &mut self, loc: Loc<()>, symtab: &SymbolTable, ) -> (TypeVarID, TypeVarID)

pub fn new_generic_with_meta( &mut self, loc: Loc<()>, meta: MetaType, ) -> TypeVarID

pub fn new_generic_type(&mut self, loc: Loc<()>) -> TypeVarID

pub fn new_generic_any(&mut self) -> TypeVarID

pub fn new_generic_tlbool(&mut self, loc: Loc<()>) -> TypeVarID

pub fn new_generic_tluint(&mut self, loc: Loc<()>) -> TypeVarID

pub fn new_generic_tlint(&mut self, loc: Loc<()>) -> TypeVarID

pub fn new_generic_tlnumber(&mut self, loc: Loc<()>) -> TypeVarID

pub fn new_generic_number( &mut self, loc: Loc<()>, ctx: &Context<'_>, ) -> (TypeVarID, TypeVarID)

pub fn new_generic_with_traits( &mut self, loc: Loc<()>, traits: TraitList, ) -> TypeVarID

pub fn get_pipeline_state<T>( &self, access_loc: &Loc<T>, ) -> Result<&PipelineState>

Returns the current pipeline state. access_loc is not used to specify where to get the state from, it is only used for the Diagnostic::bug that gets emitted if there is no pipeline state

pub fn visit_unit_with_preprocessing( &mut self, entity: &Loc<Unit>, pp: impl Fn(&mut TypeState, &Loc<Unit>, &GenericListToken, &Context<'_>) -> Result<()>, ctx: &Context<'_>, ) -> Result<()>

Visit a unit but before doing any preprocessing run the pp function.

pub fn visit_unit( &mut self, entity: &Loc<Unit>, ctx: &Context<'_>, ) -> Result<()>

pub(crate) fn visit_argument_list( &mut self, args: &Loc<ArgumentList<Expression>>, ctx: &Context<'_>, generic_list: &GenericListToken, ) -> Result<()>

pub(crate) fn type_check_argument_list( &mut self, args: &[Argument<'_, Expression, TypeSpec>], ctx: &Context<'_>, generic_list: &GenericListToken, ) -> Result<()>

pub fn visit_expression_result( &mut self, expression: &Loc<Expression>, ctx: &Context<'_>, generic_list: &GenericListToken, new_type: TypeVarID, ) -> Result<()>

pub fn visit_expression( &mut self, expression: &Loc<Expression>, ctx: &Context<'_>, generic_list: &GenericListToken, )

pub(crate) fn handle_function_like( &mut self, expression_id: Loc<ExprID>, expression_type: &TypeVarID, name: &FunctionLikeName, head: &Loc<UnitHead>, call_kind: &CallKind, args: &Loc<ArgumentList<Expression>>, ctx: &Context<'_>, visit_args: bool, is_method: bool, turbofish: Option<TurbofishCtx<'_>>, generic_list: &GenericListToken, ) -> Result<()>

pub fn handle_concat( &mut self, expression_id: Loc<ExprID>, source_lhs_ty: TypeVarID, source_rhs_ty: TypeVarID, source_result_ty: TypeVarID, args: &[Argument<'_, Expression, TypeSpec>], ctx: &Context<'_>, ) -> Result<()>

pub fn handle_trunc( &mut self, expression_id: Loc<ExprID>, source_in_ty: TypeVarID, source_result_ty: TypeVarID, args: &[Argument<'_, Expression, TypeSpec>], ctx: &Context<'_>, ) -> Result<()>

pub fn handle_comb_mod_or_div( &mut self, n_ty: TypeVarID, args: &[Argument<'_, Expression, TypeSpec>], ctx: &Context<'_>, ) -> Result<()>

pub fn handle_clocked_memory( &mut self, num_elements: TypeVarID, addr_size_arg: TypeVarID, args: &[Argument<'_, Expression, TypeSpec>], ctx: &Context<'_>, ) -> Result<()>

pub fn handle_read_memory( &mut self, num_elements: TypeVarID, addr_size_arg: TypeVarID, args: &[Argument<'_, Expression, TypeSpec>], ctx: &Context<'_>, ) -> Result<()>

pub fn create_generic_list( &mut self, source: GenericListSource<'_>, type_params: &[Loc<TypeParam>], scope_type_params: &[Loc<TypeParam>], turbofish: Option<TurbofishCtx<'_>>, where_clauses: &[Loc<WhereClause>], ) -> Result<GenericListToken>

pub fn add_mapped_generic_list( &mut self, source: GenericListSource<'_>, mapping: HashMap<NameID, TypeVarID>, ) -> GenericListToken

Adds a generic list with parameters already mapped to types

pub fn remove_generic_list(&mut self, source: GenericListSource<'_>)

pub fn visit_block( &mut self, block: &Block, ctx: &Context<'_>, generic_list: &GenericListToken, ) -> Result<()>

pub fn visit_impl_blocks(&mut self, item_list: &ItemList) -> TraitImplList

pub fn visit_pattern( &mut self, pattern: &Loc<Pattern>, ctx: &Context<'_>, generic_list: &GenericListToken, ) -> Result<()>

pub fn visit_wal_trace( &mut self, trace: &Loc<WalTrace>, ctx: &Context<'_>, generic_list: &GenericListToken, ) -> Result<()>

pub fn visit_statement_error( &mut self, stmt: &Loc<Statement>, ctx: &Context<'_>, generic_list: &GenericListToken, ) -> Result<()>

pub fn visit_statement( &mut self, stmt: &Loc<Statement>, ctx: &Context<'_>, generic_list: &GenericListToken, )

pub fn visit_register( &mut self, reg: &Register, ctx: &Context<'_>, generic_list: &GenericListToken, ) -> Result<()>

pub fn visit_trait_spec( &mut self, trait_spec: &Loc<TraitSpec>, generic_list: &GenericListToken, ) -> Result<Loc<TraitReq>>

pub fn visit_trait_bounds( &mut self, target: &Loc<NameID>, traits: &[Loc<TraitSpec>], generic_list_tok: &GenericListToken, ) -> Result<()>

pub fn visit_const_generic_with_id( &mut self, gen: &Loc<ConstGenericWithId>, generic_list_token: &GenericListToken, constraint_source: ConstraintSource, ctx: &Context<'_>, ) -> Result<TypeVarID>

pub fn visit_const_generic( &self, constraint: &ConstGeneric, generic_list: &GenericListToken, ) -> Result<ConstraintExpr>

impl TypeState

pub(crate) fn new_typeid(&self) -> u64

pub fn add_equation(&mut self, expression: TypedExpression, var: TypeVarID)

pub(crate) fn add_constraint( &mut self, lhs: TypeVarID, rhs: ConstraintExpr, loc: Loc<()>, inside: &TypeVarID, source: ConstraintSource, )

pub(crate) fn add_requirement(&mut self, requirement: Requirement)

pub(crate) fn unify_inner( &mut self, e1: &impl HasType, e2: &impl HasType, ctx: &Context<'_>, ) -> Result<TypeVarID, UnificationError>

Performs unification but does not update constraints. This is done to avoid updating constraints more often than necessary. Technically, constraints can be updated even less often, but unify is a pretty natural point to do so.

pub fn can_unify( &mut self, e1: &impl HasType, e2: &impl HasType, ctx: &Context<'_>, ) -> bool

pub fn unify( &mut self, e1: &impl HasType, e2: &impl HasType, ctx: &Context<'_>, ) -> Result<TypeVarID, UnificationError>

pub(crate) fn check_type_for_recursion( &self, ty: TypeVarID, seen: &mut Vec<TypeVarID>, ) -> Result<(), String>

pub(crate) fn ensure_impls( &mut self, var: &TypeVarID, traits: &TraitList, trait_is_expected: bool, trait_list_loc: &Loc<()>, ctx: &Context<'_>, ) -> Result<Vec<(TraitImpl, TraitReq)>, UnificationError>

pub fn unify_expression_generic_error( &mut self, expr: &Loc<Expression>, other: &impl HasType, ctx: &Context<'_>, ) -> Result<TypeVarID>

pub fn check_requirements( &mut self, is_final_check: bool, ctx: &Context<'_>, ) -> Result<()>

pub fn get_replacement(&self, var: &TypeVarID) -> TypeVarID

pub fn do_and_restore<T, E>( &mut self, inner: impl Fn(&mut Self) -> Result<T, E>, ) -> Result<T, E>

pub(crate) fn checkpoint(&mut self)

Create a “checkpoint” to which we can restore later using restore. This acts like a stack, nested checkpoints are possible

pub(crate) fn restore(&mut self)

impl TypeState

pub fn print_equations(&self)

Trait Implementations

impl Clone for TypeState

fn clone(&self) -> TypeState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for TypeState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TypeState

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.