Struct Checker 

pub struct Checker<'r, 's> {
    pub ids: IdGen,
    pub store: &'r mut Store,
    pub scopes: Scopes,
    pub cursor: Cursor,
    pub imports: ImportState,
    pub builtins: FxHashMap<String, Type>,
    pub sink: &'s DiagnosticSink,
    pub facts: Facts,
    pub coercions: CoercionInfo,
    pub resolutions: ResolutionInfo,
    pub post_inference_checks: Vec<PostInferenceCheck>,
    pub ufcs_methods: FxHashSet<(String, String)>,
    /* private fields */
}

Fields

ids: IdGen

store: &'r mut Store

scopes: Scopes

cursor: Cursor

imports: ImportState

builtins: FxHashMap<String, Type>

sink: &'s DiagnosticSink

facts: Facts

coercions: CoercionInfo

resolutions: ResolutionInfo

post_inference_checks: Vec<PostInferenceCheck>

ufcs_methods: FxHashSet<(String, String)>

Implementations

impl Checker<'_, '_>

pub fn run_post_inference_checks(&mut self)

Runs all post-inference checks for unresolved type variables. Called after inference completes for a file, when type variables have had a chance to be constrained by later usage.

impl Checker<'_, '_>

pub fn infer_expression( &mut self, expression: Expression, expected_ty: &Type, ) -> Expression

impl Checker<'_, '_>

pub fn infer_module(&mut self, module_id: &str)

impl Checker<'_, '_>

pub fn type_unit(&self) -> Type

pub fn type_never(&self) -> Type

pub fn type_int(&mut self) -> Type

pub fn type_float(&mut self) -> Type

pub fn type_string(&mut self) -> Type

pub fn type_char(&mut self) -> Type

pub fn type_bool(&mut self) -> Type

pub fn type_complex128(&mut self) -> Type

pub fn type_unknown(&mut self) -> Type

pub fn type_slice(&mut self, element_type: Type) -> Type

pub fn type_reference(&mut self, inner_type: Type) -> Type

pub fn type_map(&mut self, key_type: Type, value_type: Type) -> Type

pub fn type_result(&mut self, ok_type: Type, error_type: Type) -> Type

pub fn type_option(&mut self, some_type: Type) -> Type

pub fn type_panic_value(&mut self) -> Type

pub fn type_range(&mut self, element_type: Type) -> Type

pub fn type_range_inclusive(&mut self, element_type: Type) -> Type

pub fn type_range_from(&mut self, element_type: Type) -> Type

pub fn type_range_to(&mut self, element_type: Type) -> Type

pub fn type_range_to_inclusive(&mut self, element_type: Type) -> Type

pub fn is_generic_container_with_interface(&self, ty: &Type) -> bool

Checks if a type is a generic container (Option, Result) with interface type parameters. Used to determine when to use the expected type for codegen instead of the inferred type.

pub fn has_interface_type_param(&self, ty: &Type) -> bool

impl Checker<'_, '_>

pub fn convert_to_type(&mut self, annotation: &Annotation, span: &Span) -> Type

pub fn instantiate_from_annotations( &mut self, generics: &[EcoString], body: &Type, type_args: &[Annotation], span: &Span, ) -> Type

impl Checker<'_, '_>

pub fn register_module(&mut self, id: &str)

pub fn parse_and_register_go_module(&mut self, module_id: &str, source: &str)

Register a Go stdlib module. Unlike regular modules, Go modules:

• Export everything as public
• Don’t put their own module in scope (no self-references like MyModule.Type)

pub fn register_types_and_values( &mut self, items: &[Expression], visibility: &Visibility, )

pub fn register_type_names( &mut self, items: &[Expression], visibility: &Visibility, )

pub fn register_types(&mut self, items: &[Expression])

pub fn register_values(&mut self, items: &[Expression], visibility: &Visibility)

impl<'r, 's> Checker<'r, 's>

pub fn new(store: &'r mut Store, sink: &'s DiagnosticSink) -> Self

pub fn new_type_var(&mut self) -> Type

pub fn new_type_var_with_hint(&mut self, hint: &str) -> Type

pub fn type_from_literal_expression( &mut self, expression: &Expression, ) -> Option<Type>

pub fn instantiate(&mut self, ty: &Type) -> (Type, SubstitutionMap)

pub fn new_file_id(&mut self) -> u32

pub fn new_type_var_id(&mut self) -> i32

pub fn is_d_lis(&self) -> bool

pub fn is_lis(&self) -> bool

pub fn reset_scopes(&mut self)

pub fn failed(&self) -> bool

pub fn put_prelude_in_scope(&mut self)

pub fn put_unprefixed_module_in_scope(&mut self, module_id: &str)

pub fn put_imported_modules_in_scope(&mut self, imports: &[FileImport])

pub fn put_module_in_scope(&mut self, module_id: &str, prefix: Option<String>)