Struct QueryCache 

pub struct QueryCache<'a> { /* private fields */ }

Query database wrapper with basic caching.

Implementations

impl<'a> QueryCache<'a>

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

pub fn clear(&self)

pub fn relation_cache_stats(&self) -> RelationCacheStats

pub fn reset_relation_cache_stats(&self)

pub fn probe_subtype_cache(&self, key: RelationCacheKey) -> RelationCacheProbe

pub fn probe_assignability_cache( &self, key: RelationCacheKey, ) -> RelationCacheProbe

Trait Implementations

impl QueryDatabase for QueryCache<'_>

fn is_subtype_of(&self, source: TypeId, target: TypeId) -> bool

Convenience wrapper for is_subtype_of with default flags.

fn is_assignable_to(&self, source: TypeId, target: TypeId) -> bool

Convenience wrapper for is_assignable_to with default flags.

fn as_type_database(&self) -> &dyn TypeDatabase

Expose the underlying TypeDatabase view for legacy entry points.

fn register_array_base_type( &self, type_id: TypeId, type_params: Vec<TypeParamInfo>, )

Register the canonical Array<T> base type used by property access resolution.

fn register_boxed_type(&self, kind: IntrinsicKind, type_id: TypeId)

Register a boxed interface type for a primitive intrinsic kind.

fn evaluate_type(&self, type_id: TypeId) -> TypeId

fn evaluate_type_with_options( &self, type_id: TypeId, no_unchecked_indexed_access: bool, ) -> TypeId

fn lookup_application_eval_cache( &self, def_id: DefId, args: &[TypeId], no_unchecked_indexed_access: bool, ) -> Option<TypeId>

Look up a shared cache entry for evaluated generic applications.

fn insert_application_eval_cache( &self, def_id: DefId, args: &[TypeId], no_unchecked_indexed_access: bool, result: TypeId, )

Store an evaluated generic application result in the shared cache.

fn is_subtype_of_with_flags( &self, source: TypeId, target: TypeId, flags: u16, ) -> bool

Subtype check with explicit compiler flags.

fn is_assignable_to_with_flags( &self, source: TypeId, target: TypeId, flags: u16, ) -> bool

Assignability check with explicit compiler flags.

fn lookup_subtype_cache(&self, key: RelationCacheKey) -> Option<bool>

Look up a cached subtype result for the given key. Returns None if the result is not cached. Default implementation returns None (no caching).

fn insert_subtype_cache(&self, key: RelationCacheKey, result: bool)

Cache a subtype result for the given key. Default implementation is a no-op.

fn lookup_assignability_cache(&self, key: RelationCacheKey) -> Option<bool>

Look up a cached assignability result for the given key. Returns None if the result is not cached. Default implementation returns None (no caching).

fn insert_assignability_cache(&self, key: RelationCacheKey, result: bool)

Cache an assignability result for the given key. Default implementation is a no-op.

fn get_index_signatures(&self, type_id: TypeId) -> IndexInfo

Get index signatures for a type

fn is_nullish_type(&self, type_id: TypeId) -> bool

Check if a type contains null or undefined

fn remove_nullish(&self, type_id: TypeId) -> TypeId

Remove null and undefined from a type

fn resolve_property_access( &self, object_type: TypeId, prop_name: &str, ) -> PropertyAccessResult

fn resolve_property_access_with_options( &self, object_type: TypeId, prop_name: &str, no_unchecked_indexed_access: bool, ) -> PropertyAccessResult

fn resolve_element_access_type( &self, object_type: TypeId, index_type: TypeId, literal_index: Option<usize>, ) -> TypeId

Resolve element access type with cache-friendly error normalization.

fn collect_object_spread_properties( &self, spread_type: TypeId, ) -> Vec<PropertyInfo>

Collect properties that can be spread into object literals.

fn no_unchecked_indexed_access(&self) -> bool

fn set_no_unchecked_indexed_access(&self, enabled: bool)

fn get_type_param_variance(&self, def_id: DefId) -> Option<Arc<[Variance]>>

Task #41: Get the variance mask for a generic type definition.

fn canonical_id(&self, type_id: TypeId) -> TypeId

Get the canonical TypeId for a type, achieving O(1) structural identity checks.

fn factory(&self) -> TypeFactory<'_>

Expose the checked construction surface for type constructors.

fn evaluate_conditional(&self, cond: &ConditionalType) -> TypeId

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

fn evaluate_index_access_with_options( &self, object_type: TypeId, index_type: TypeId, no_unchecked_indexed_access: bool, ) -> TypeId

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

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

fn narrow(&self, type_id: TypeId, narrower: TypeId) -> TypeId

where Self: Sized,

fn property_access_type( &self, object_type: TypeId, prop_name: &str, ) -> PropertyAccessResult

fn contextual_property_type( &self, expected: TypeId, prop_name: &str, ) -> Option<TypeId>

fn is_property_readonly(&self, object_type: TypeId, prop_name: &str) -> bool

fn is_readonly_index_signature( &self, object_type: TypeId, wants_string: bool, wants_number: bool, ) -> bool

fn resolve_element_access( &self, object_type: TypeId, index_type: TypeId, literal_index: Option<usize>, ) -> ElementAccessResult

Resolve element access (array/tuple indexing) with detailed error reporting

fn new_inference_context(&self) -> InferenceContext<'_>

impl TypeDatabase for QueryCache<'_>

fn intern(&self, key: TypeData) -> TypeId

fn lookup(&self, id: TypeId) -> Option<TypeData>

fn intern_string(&self, s: &str) -> Atom

fn resolve_atom(&self, atom: Atom) -> String

fn resolve_atom_ref(&self, atom: Atom) -> Arc<str>

fn type_list(&self, id: TypeListId) -> Arc<[TypeId]>

fn tuple_list(&self, id: TupleListId) -> Arc<[TupleElement]>

fn template_list(&self, id: TemplateLiteralId) -> Arc<[TemplateSpan]>

fn object_shape(&self, id: ObjectShapeId) -> Arc<ObjectShape>

fn object_property_index( &self, shape_id: ObjectShapeId, name: Atom, ) -> PropertyLookup

fn function_shape(&self, id: FunctionShapeId) -> Arc<FunctionShape>

fn callable_shape(&self, id: CallableShapeId) -> Arc<CallableShape>

fn conditional_type(&self, id: ConditionalTypeId) -> Arc<ConditionalType>

fn mapped_type(&self, id: MappedTypeId) -> Arc<MappedType>

fn type_application(&self, id: TypeApplicationId) -> Arc<TypeApplication>

fn literal_string(&self, value: &str) -> TypeId

fn literal_number(&self, value: f64) -> TypeId

fn literal_boolean(&self, value: bool) -> TypeId

fn literal_bigint(&self, value: &str) -> TypeId

fn literal_bigint_with_sign(&self, negative: bool, digits: &str) -> TypeId

fn union(&self, members: Vec<TypeId>) -> TypeId

fn union_from_sorted_vec(&self, flat: Vec<TypeId>) -> TypeId

fn union2(&self, left: TypeId, right: TypeId) -> TypeId

fn union3(&self, first: TypeId, second: TypeId, third: TypeId) -> TypeId

fn intersection(&self, members: Vec<TypeId>) -> TypeId

fn intersection2(&self, left: TypeId, right: TypeId) -> TypeId

fn intersect_types_raw2(&self, left: TypeId, right: TypeId) -> TypeId

Raw intersection without normalization (used to avoid infinite recursion)

fn array(&self, element: TypeId) -> TypeId

fn tuple(&self, elements: Vec<TupleElement>) -> TypeId

fn object(&self, properties: Vec<PropertyInfo>) -> TypeId

fn object_with_flags( &self, properties: Vec<PropertyInfo>, flags: ObjectFlags, ) -> TypeId

fn object_with_flags_and_symbol( &self, properties: Vec<PropertyInfo>, flags: ObjectFlags, symbol: Option<SymbolId>, ) -> TypeId

fn object_with_index(&self, shape: ObjectShape) -> TypeId

fn function(&self, shape: FunctionShape) -> TypeId

fn callable(&self, shape: CallableShape) -> TypeId

fn template_literal(&self, spans: Vec<TemplateSpan>) -> TypeId

fn conditional(&self, conditional: ConditionalType) -> TypeId

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

fn reference(&self, symbol: SymbolRef) -> TypeId

fn lazy(&self, def_id: DefId) -> TypeId

fn bound_parameter(&self, index: u32) -> TypeId

fn recursive(&self, depth: u32) -> TypeId

fn type_param(&self, info: TypeParamInfo) -> TypeId

fn type_query(&self, symbol: SymbolRef) -> TypeId

fn enum_type(&self, def_id: DefId, structural_type: TypeId) -> TypeId

fn application(&self, base: TypeId, args: Vec<TypeId>) -> TypeId

fn literal_string_atom(&self, atom: Atom) -> TypeId

fn union_preserve_members(&self, members: Vec<TypeId>) -> TypeId

fn readonly_type(&self, inner: TypeId) -> TypeId

fn keyof(&self, inner: TypeId) -> TypeId

fn index_access(&self, object_type: TypeId, index_type: TypeId) -> TypeId

fn this_type(&self) -> TypeId

fn no_infer(&self, inner: TypeId) -> TypeId

fn unique_symbol(&self, symbol: SymbolRef) -> TypeId

fn infer(&self, info: TypeParamInfo) -> TypeId

fn string_intrinsic( &self, kind: StringIntrinsicKind, type_arg: TypeId, ) -> TypeId

fn get_class_base_type(&self, symbol_id: SymbolId) -> Option<TypeId>

Get the base class type for a symbol (class/interface). Returns the TypeId of the extends clause, or None if the symbol doesn’t extend anything. This is used by the BCT algorithm to find common base classes.

fn is_identity_comparable_type(&self, type_id: TypeId) -> bool

Check if a type can be compared by TypeId identity alone (O(1) equality). Identity-comparable types include literals, enum members, unique symbols, null, undefined, void, never, and tuples composed entirely of identity-comparable types. Results are cached for O(1) lookup after first computation.

fn object_fresh(&self, properties: Vec<PropertyInfo>) -> TypeId

impl TypeResolver for QueryCache<'_>

Implement TypeResolver for QueryCache with noop resolution.

QueryCache doesn’t have access to the Binder or type environment, so it cannot resolve symbol references or DefIds. Only resolve_ref (required) is explicitly implemented; all other resolution methods inherit the trait’s default None/false behavior. The three boxed/array methods delegate to the underlying interner.

fn resolve_ref( &self, _symbol: SymbolRef, _interner: &dyn TypeDatabase, ) -> Option<TypeId>

Resolve a symbol reference to its structural type. Returns None if the symbol cannot be resolved.

fn get_boxed_type(&self, kind: IntrinsicKind) -> Option<TypeId>

Get the boxed interface type for a primitive intrinsic (Rule #33). For example, IntrinsicKind::Number -> TypeId of the Number interface. This enables primitives to be subtypes of their boxed interfaces.

fn get_array_base_type(&self) -> Option<TypeId>

Get the Array interface type from lib.d.ts.

fn get_array_base_type_params(&self) -> &[TypeParamInfo]

Get the type parameters for the Array interface.

fn resolve_symbol_ref( &self, symbol: SymbolRef, interner: &dyn TypeDatabase, ) -> Option<TypeId>

Resolve a symbol reference to a structural type, preferring DefId-based lazy paths.

fn resolve_lazy( &self, _def_id: DefId, _interner: &dyn TypeDatabase, ) -> Option<TypeId>

Resolve a DefId reference to its structural type.

fn get_type_params(&self, _symbol: SymbolRef) -> Option<Vec<TypeParamInfo>>

Get type parameters for a symbol (for generic type aliases/interfaces). Returns None by default; implementations can override to support Application type expansion.

fn get_lazy_type_params(&self, _def_id: DefId) -> Option<Vec<TypeParamInfo>>

Get type parameters for a DefId (for generic type aliases/interfaces).

fn def_to_symbol_id(&self, _def_id: DefId) -> Option<SymbolId>

Get the SymbolId for a DefId (bridge for InheritanceGraph).

fn symbol_to_def_id(&self, _symbol: SymbolRef) -> Option<DefId>

Get the DefId for a SymbolRef (Ref -> Lazy migration).

fn get_def_kind(&self, _def_id: DefId) -> Option<DefKind>

Get the DefKind for a DefId (Task #32: Graph Isomorphism).

fn is_boxed_def_id(&self, _def_id: DefId, _kind: IntrinsicKind) -> bool

Check if a DefId corresponds to a boxed type for the given intrinsic kind.

fn is_boxed_type_id(&self, _type_id: TypeId, _kind: IntrinsicKind) -> bool

Check if a TypeId is any known resolved form of a boxed type.

fn get_lazy_export(&self, _def_id: DefId, _name: Atom) -> Option<TypeId>

Get an export from a namespace/module by name.

fn get_lazy_enum_member(&self, _def_id: DefId, _name: Atom) -> Option<TypeId>

Get enum member type by name from an enum DefId.

fn is_numeric_enum(&self, _def_id: DefId) -> bool

Check if a DefId corresponds to a numeric enum (not a string enum).

fn is_enum_type(&self, _type_id: TypeId, _interner: &dyn TypeDatabase) -> bool

Check if a TypeId represents a full Enum type (not a specific member).

fn get_enum_parent_def_id(&self, _member_def_id: DefId) -> Option<DefId>

Get the parent Enum’s DefId for an Enum Member’s DefId.

fn is_user_enum_def(&self, _def_id: DefId) -> bool

Check if a DefId represents a user-defined enum (not an intrinsic type).

fn get_base_type( &self, _type_id: TypeId, _interner: &dyn TypeDatabase, ) -> Option<TypeId>

Get the base class type for a class/interface type.

fn get_type_param_variance(&self, _def_id: DefId) -> Option<Arc<[Variance]>>

Get the variance mask for type parameters of a generic type (Task #41).