Struct TypeEvaluator 

pub struct TypeEvaluator<'a, R: TypeResolver = NoopResolver> { /* private fields */ }

Type evaluator for meta-types.

Salsa Preparation

This struct uses &mut self methods instead of RefCell + &self. This makes the evaluator thread-safe (Send) and prepares for future Salsa integration where state is managed by the database runtime.

Implementations

impl<'a> TypeEvaluator<'a, NoopResolver>

pub fn new(interner: &'a dyn TypeDatabase) -> Self

Create a new evaluator without a resolver.

impl<'a, R: TypeResolver> TypeEvaluator<'a, R>

pub fn with_resolver(interner: &'a dyn TypeDatabase, resolver: &'a R) -> Self

Create a new evaluator with a custom resolver.

pub fn with_query_db(self, db: &'a dyn QueryDatabase) -> Self

Set the query database for Salsa-backed memoization.

pub fn set_no_unchecked_indexed_access(&mut self, enabled: bool)

pub fn reset(&mut self)

Reset per-evaluation state so this evaluator can be reused.

Clears the cache, cycle detection sets, and counters while preserving configuration and borrowed references. Uses .clear() to reuse memory.

pub const fn is_depth_exceeded(&self) -> bool

Check if depth limit was exceeded.

pub fn evaluate(&mut self, type_id: TypeId) -> TypeId

Evaluate a type, resolving any meta-types if possible. Returns the evaluated type (may be the same if no evaluation needed).

impl<'a, R: TypeResolver> TypeEvaluator<'a, R>

pub fn evaluate_conditional(&mut self, initial_cond: &ConditionalType) -> TypeId

Evaluate a conditional type: T extends U ? X : Y

Algorithm:

1. If check_type is a union and the conditional is distributive, distribute
2. Otherwise, check if check_type <: extends_type
3. If true -> return true_type
4. If false (disjoint) -> return false_type
5. If ambiguous (unresolved type param) -> return deferred conditional

Tail-Recursion Elimination

If the chosen branch (true/false) evaluates to another ConditionalType, we immediately evaluate it in the current stack frame instead of recursing. This allows tail-recursive patterns to work with up to MAX_TAIL_RECURSION_DEPTH iterations instead of being limited by MAX_EVALUATE_DEPTH.

impl<'a, R: TypeResolver> TypeEvaluator<'a, R>

pub fn evaluate_index_access( &mut self, object_type: TypeId, index_type: TypeId, ) -> TypeId

Evaluate an index access type: T[K]

This resolves property access on object types.

impl<'a, R: TypeResolver> TypeEvaluator<'a, R>

pub fn evaluate_keyof(&mut self, operand: TypeId) -> TypeId

Evaluate keyof T - extract the keys of an object type

impl<'a, R: TypeResolver> TypeEvaluator<'a, R>

pub fn evaluate_mapped(&mut self, mapped: &MappedType) -> TypeId

Evaluate a mapped type: { [K in Keys]: Template }

Algorithm:

1. Extract the constraint (Keys) - this defines what keys to iterate over
2. For each key K in the constraint:
   • Substitute K into the template type
   • Apply readonly/optional modifiers
3. Construct a new object type with the resulting properties

impl<'a, R: TypeResolver> TypeEvaluator<'a, R>

pub fn evaluate_template_literal(&mut self, spans: TemplateLiteralId) -> TypeId

Evaluate a template literal type: hello${T}world

Template literals evaluate to a union of all possible literal string combinations. For example: get${K} where K = “a” | “b” evaluates to “geta” | “getb” Multiple unions compute a Cartesian product: ${"a"|"b"}-${"x"|"y"} => “a-x”|“a-y”|“b-x”|“b-y”

pub fn count_literal_members(&self, type_id: TypeId) -> usize

Count the number of literal members that can be converted to strings. Returns 0 if the type contains non-literal types that cannot be stringified.

pub fn extract_literal_strings(&self, type_id: TypeId) -> Vec<String>

Extract string representations from a type. Handles string, number, boolean, and bigint literals, converting them to their string form. For unions, extracts all members recursively.