Struct TypeInterner 

pub struct TypeInterner {
    pub string_interner: ShardedInterner,
    /* private fields */
}

Type interning table with lock-free concurrent access.

Uses sharded DashMap structures for all internal storage, enabling true parallel type checking without lock contention.

All internal structures use lazy initialization via OnceLock to minimize startup overhead - DashMaps are only allocated when first accessed.

Fields

string_interner: ShardedInterner

String interner for property names and string literals (already lock-free)

Implementations

impl TypeInterner

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

Intern a template literal type

pub fn template_literal_interpolation_positions( &self, type_id: TypeId, ) -> Vec<usize>

Get the interpolation positions from a template literal type Returns indices of type interpolation spans

pub fn template_literal_get_span( &self, type_id: TypeId, index: usize, ) -> Option<TemplateSpan>

Get the span at a given position from a template literal type

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

Get the number of spans in a template literal type

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

Check if a template literal contains only text (no interpolations) Also returns true for string literals (which are the result of text-only template expansion)

impl TypeInterner

pub fn new() -> Self

Create a new type interner with pre-registered intrinsics.

Uses lazy initialization for all DashMap structures to minimize startup overhead. DashMaps are only allocated when first accessed.

pub fn set_array_base_type(&self, type_id: TypeId, params: Vec<TypeParamInfo>)

Set the global Array base type (e.g., Array from lib.d.ts).

This should be called once during primordial type setup when lib.d.ts is processed. Once set, the value cannot be changed (OnceLock enforces this).

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

Get the global Array base type, if it has been set.

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

Get the type parameters for the global Array base type, if it has been set.

pub fn set_boxed_type(&self, kind: IntrinsicKind, type_id: TypeId)

Set a boxed interface type for a primitive intrinsic kind.

Called during primordial type setup when lib.d.ts is processed. For example, set_boxed_type(IntrinsicKind::String, type_id_of_String_interface) enables property access on string values to resolve through the String interface.

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

Get the boxed interface type for a primitive intrinsic kind.

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

Check if a type can be compared by TypeId identity alone (O(1) equality). Results are cached for O(1) lookup after first computation. This is used for optimization in BCT and subtype checking.

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

Intern a string into an Atom. This is used when constructing types with property names or string literals.

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

Resolve an Atom back to its string value. This is used when formatting types for error messages.

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

Resolve an Atom without allocating a new String.

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

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

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

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

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

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

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

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

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

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

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

Intern a type key and return its TypeId. If the key already exists, returns the existing TypeId. Otherwise, creates a new TypeId and stores the key.

This uses a lock-free pattern with DashMap for concurrent access.

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

Look up the TypeData for a given TypeId.

This uses lock-free DashMap access with lazy shard initialization.

pub fn intern_object_shape(&self, shape: ObjectShape) -> ObjectShapeId

pub fn len(&self) -> usize

Get the number of interned types (lock-free read)

pub fn is_empty(&self) -> bool

Check if the interner is empty (only has intrinsics)

pub const fn intrinsic(&self, kind: IntrinsicKind) -> TypeId

Intern an intrinsic type

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

Intern a literal string type

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

Intern a literal string type from an already-interned Atom

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

Intern a literal number type

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

Intern a literal boolean type

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

Intern a literal bigint type

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

Intern a literal bigint type, allowing a sign prefix without extra clones.

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

Intern a union type, normalizing and deduplicating members

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

Intern a union type from a vector that is already sorted and deduped. This is an O(N) operation that avoids redundant sorting.

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

Intern a union type while preserving member structure.

This keeps unknown/literal members intact for property access checks.

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

Fast path for unions that already fit in registers.

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

Fast path for three-member unions without heap allocations.

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

Intern an intersection type, normalizing and deduplicating members

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

Fast path for two-member intersections.

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

Create an intersection type WITHOUT triggering normalize_intersection

This is a low-level operation used by the SubtypeChecker to merge properties from intersection members without causing infinite recursion.

Safety

Only use this when you need to synthesize a type for intermediate checking. Do NOT use for final compiler output (like .d.ts generation) as the resulting type will be “unsimplified”.

pub fn intersect_types_raw2(&self, a: TypeId, b: TypeId) -> TypeId

Convenience wrapper for raw intersection of two types

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

Intern an array type

pub fn this_type(&self) -> TypeId

Canonical this type.

pub fn readonly_array(&self, element: TypeId) -> TypeId

Intern a readonly array type Returns a distinct type from mutable arrays to enforce readonly semantics

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

Intern a tuple type

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

Intern a readonly tuple type Returns a distinct type from mutable tuples to enforce readonly semantics

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

Wrap any type in a ReadonlyType marker This is used for the readonly type operator

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

Wrap a type in a NoInfer marker.

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

Create a unique symbol type for a symbol declaration.

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

Create an infer binder with the provided info.

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

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

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

Wrap a type in a KeyOf marker.

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

Build an indexed access type (T[K]).

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

Build a nominal enum type that preserves DefId identity and carries structural member information for compatibility with primitive relations.

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

Intern an object type with properties.

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

Intern a fresh object type with properties.

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

Intern an object type with properties and custom flags.

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

Intern an object type with properties, custom flags, and optional symbol. This is used for interfaces that need symbol tracking but no index signatures.

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

Intern an object type with index signatures.

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

Intern a function type

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

Intern a callable type with overloaded signatures

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

Intern a conditional type

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

Intern a mapped type

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

Build a string intrinsic (Uppercase, Lowercase, etc.) marker.

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

Intern a type reference (deprecated - use lazy() with DefId instead).

This method is kept for backward compatibility with tests and legacy code. It converts SymbolRef to DefId and creates TypeData::Lazy.

Deprecated: new code should use lazy(def_id) instead.

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

Intern a lazy type reference (DefId-based).

This is the replacement for reference() that uses Solver-owned DefIds instead of Binder-owned SymbolRefs.

Use this method for all new type references to enable O(1) type equality across Binder and Solver boundaries.

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

Intern a type parameter.

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

Intern a type query (typeof value) marker.

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

Intern a generic type application

Trait Implementations

impl Debug for TypeInterner

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TypeInterner

fn default() -> Self

Returns the “default value” for a type.

impl QueryDatabase for TypeInterner

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 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 is_assignable_to(&self, source: TypeId, target: TypeId) -> bool

TypeScript assignability check with full compatibility rules (The Lawyer).

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

Assignability check with explicit compiler flags.

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 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_type(&self, type_id: TypeId) -> TypeId

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

fn evaluate_mapped(&self, mapped: &MappedType) -> 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 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 no_unchecked_indexed_access(&self) -> bool

fn set_no_unchecked_indexed_access(&self, _enabled: bool)

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 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 is_subtype_of(&self, source: TypeId, target: TypeId) -> bool

Subtype check with compiler flags.

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

Subtype 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 new_inference_context(&self) -> InferenceContext<'_>

impl TypeDatabase for TypeInterner

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 TypeInterner

Implement TypeResolver for TypeInterner with noop resolution.

TypeInterner 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 TypeInterner’s own inherent methods.

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).