Struct TaskState 

pub struct TaskState<'s> {
    pub env: TypeEnv,
    pub scopes: Scopes,
    pub cursor: Cursor,
    pub imports: ImportState,
    pub builtins: FxHashMap<String, Type>,
    pub sink: &'s LocalSink,
    pub facts: Facts,
    pub satisfying_stack: FxHashSet<(String, String)>,
    pub ufcs_methods: FxHashSet<(String, String)>,
    pub typed_files: Vec<(String, File)>,
    pub bound_position_depth: u32,
    /* private fields */
}

Per-task mutable state. Paired with AnalysisContext (shared read-only view).

Fields

env: TypeEnv

scopes: Scopes

cursor: Cursor

imports: ImportState

builtins: FxHashMap<String, Type>

sink: &'s LocalSink

facts: Facts

satisfying_stack: FxHashSet<(String, String)>

Recursion guard for interface satisfaction. Prevents collect_interface_violations from diverging when a bound on T transitively requires checking T against the same interface.

ufcs_methods: FxHashSet<(String, String)>

typed_files: Vec<(String, File)>

Typed files produced by inference.

bound_position_depth: u32

Reentrancy counter: > 0 while resolving a generic bound annotation. Lets convert_to_type admit bound-only markers (e.g. Comparable) without flagging them as misuse in value positions.

Implementations

impl TaskState<'_>

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

impl TaskState<'_>

pub fn check_const_cycles( &mut self, store: &Store, items_per_file: &[&[Expression]], )

impl TaskState<'_>

pub fn infer_module(&mut self, store: &Store, module_id: &str, files: Vec<File>)

Infer types for files belonging to module_id.

pub fn take_module_files( &mut self, store: &mut Store, module_id: &str, ) -> Vec<File>

Extract a module’s .lis files from the store.

impl TaskState<'_>

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, store: &Store) -> 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, store: &Store, ok_type: Type, error_type: Type, ) -> Type

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

pub fn type_panic_value(&mut self, store: &Store) -> Type

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

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

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

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

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

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

Checks if a type is a generic container (Option, Result) whose type parameter needs the expected type to flow through for codegen: Go interfaces (for method-set satisfaction) or Go-imported named types (for Go generic instantiation preserving alias names like tea.Cmd instead of collapsing to the underlying func() Msg).

impl TaskState<'_>

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

Resolves a generic-bound annotation. Bound-only markers like Comparable are admitted here; the same names in value position are flagged inside convert_to_type.

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

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

impl TaskState<'_>

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

pub fn parse_and_register_go_module( &mut self, store: &mut Store, module_id: &str, source: &str, cache_path: Option<PathBuf>, locator: &TypedefLocator, )

Register a Go module (stdlib or third-party). Unlike regular modules, Go modules export everything as public and do not put their own module in scope (no self-references like MyModule.Type). cache_path is the on-disk typedef location, or None for embedded stdlib typedefs.

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

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

pub fn register_type_definitions( &mut self, store: &mut Store, items: &[Expression], )

pub fn register_impl_blocks(&mut self, store: &mut Store, items: &[Expression])

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

impl<'s> TaskState<'s>

pub fn new(sink: &'s LocalSink, binding_ids: Arc<BindingIdAllocator>) -> Self

pub fn with_fresh_allocator(sink: &'s LocalSink) -> 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, store: &Store) -> u32

pub fn is_d_lis(&self, store: &Store) -> bool

pub fn is_lis(&self, store: &Store) -> bool

pub fn reset_scopes(&mut self)

pub fn failed(&self) -> bool

pub fn put_prelude_in_scope(&mut self, store: &Store)

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

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

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