Struct TypeId 

pub struct TypeId(pub u32);

A lightweight handle to an interned type. Equality check is O(1) - just compare the u32 values.

Sentinel Value Semantics

The following sentinel values have specific semantics for error handling and type inference:

TypeId::ERROR

Used when type resolution fails due to an actual error:

• Missing AST nodes or invalid syntax
• Type annotation that cannot be resolved
• Failed type inference with no fallback

Error propagation: ERROR is “contagious” - operations on ERROR types return ERROR. This prevents cascading errors from a single root cause. Property access on ERROR returns ERROR silently (no additional diagnostics emitted).

Example uses:

• Missing type annotation: let x; -> ERROR (prevents “any poisoning”)
• Failed generic inference with no constraint/default
• Invalid type syntax or unresolved type references

TypeId::UNKNOWN

The TypeScript unknown type - a type-safe alternative to any. Use when the type is genuinely unknown at compile time, but should be checked before use.

Strict behavior: Property access on UNKNOWN returns IsUnknown result, which the checker reports as TS2571 “Object is of type ‘unknown’”.

Example uses:

• Explicit unknown type annotation
• Return type of functions that could return anything
• Missing this parameter type (stricter than any)

TypeId::ANY

The TypeScript any type - opts out of type checking entirely. Use for intentional any-typed values or interop with untyped code.

Permissive behavior: Property access on ANY succeeds and returns ANY. No type errors are produced for any-typed expressions.

Example uses:

• Explicit any type annotation
• Arrays with no element type context: [] defaults to any[]
• Interop with JavaScript libraries without type definitions

TypeId::NEVER

The bottom type - represents values that can never exist. Used for exhaustive checking and functions that never return.

Example uses:

• Function that always throws or loops forever
• Exhaustive switch/if narrowing (remaining type after all cases)
• Intersection of incompatible types

Summary: When to Use Each

Scenario	Use
Type resolution failed	ERROR
Missing required type annotation	ERROR
Failed inference (no fallback)	ERROR
Explicit unknown annotation	UNKNOWN
Missing this parameter type	UNKNOWN
Explicit any annotation	ANY
Empty array literal []	any[]
Function never returns	NEVER
Exhaustive narrowing remainder	NEVER

Tuple Fields

0: u32

Implementations

impl TypeId

pub const NONE: Self

Internal placeholder - no valid type.

pub const ERROR: Self

Error sentinel - type resolution failed. Propagates through operations to prevent cascading errors. See struct-level docs for detailed semantics.

pub const NEVER: Self

The bottom type - represents values that can never exist. Used for exhaustive checks and functions that never return.

pub const UNKNOWN: Self

TypeScript’s unknown type - type-safe top type. Requires type narrowing before use. See struct-level docs.

pub const ANY: Self

TypeScript’s any type - opts out of type checking. All operations succeed, returning any. See struct-level docs.

pub const VOID: Self

The void type - used for functions with no meaningful return.

pub const UNDEFINED: Self

The undefined type - represents the undefined value.

pub const NULL: Self

The null type - represents the null value.

pub const BOOLEAN: Self

The boolean type - union of true | false.

pub const NUMBER: Self

The number type - all numeric values.

pub const STRING: Self

The string type - all string values.

pub const BIGINT: Self

The bigint type - arbitrary precision integers.

pub const SYMBOL: Self

The symbol type - unique symbol values.

pub const OBJECT: Self

The object type - any non-primitive value.

pub const BOOLEAN_TRUE: Self

The literal type true.

pub const BOOLEAN_FALSE: Self

The literal type false.

pub const FUNCTION: Self

The Function type - any callable.

pub const PROMISE_BASE: Self

Synthetic Promise base type for Promise when Promise symbol is not resolved. Used to allow promise_like_return_type_argument to extract T from await expressions.

pub const DELEGATE: Self

Internal sentinel indicating that expression checking should be delegated to CheckerState for complex cases that need full checker context. This is NOT a real type and should never escape ExpressionChecker/CheckerState.

pub const STRICT_ANY: Self

Internal sentinel used to represent ‘any’ in strict mode (North Star Fix). Behaves like ‘any’ but does NOT silence structural mismatches.

pub const FIRST_USER: u32 = 100

First user-defined type ID (after built-in intrinsics)

pub const LOCAL_MASK: u32 = 0x80000000

Mask for the local bit (MSB of u32).

Local IDs have MSB=1 (0x80000000+), Global IDs have MSB=0 (0x7FFFFFFF-). This partitioning allows ScopedTypeInterner to create ephemeral types that don’t pollute the global TypeId space.

pub const fn is_intrinsic(self) -> bool

pub fn is_error(self) -> bool

pub fn is_any(self) -> bool

pub fn is_unknown(self) -> bool

pub fn is_never(self) -> bool

pub fn is_nullish(self) -> bool

Returns true if this type is nullish (null or undefined). Useful for strict null checking logic.

pub fn is_nullable(self) -> bool

Returns true if this type is nullable (null, undefined, or void). VOID is considered nullable because it represents undefined in some contexts.

pub fn is_top_type(self) -> bool

Returns true if this type is a top type (any or unknown). Top types are assignable from all other types.

pub fn is_any_or_unknown(self) -> bool

Returns true if this type is any or unknown (types that accept anything). Alias for is_top_type for clarity in some contexts.

pub const fn is_local(self) -> bool

Check if this TypeId is a local (ephemeral) type.

Local types are created by ScopedTypeInterner and are only valid for the current operation/request. They are automatically freed when the ScopedTypeInterner is dropped.

Returns true if MSB is set (0x80000000+).

pub const fn is_global(self) -> bool

Check if this TypeId is a global (persistent) type.

Global types are managed by TypeInterner and persist for the lifetime of the project/server. These include declarations and intrinsics.

Returns true if MSB is clear (0x7FFFFFFF-).

Trait Implementations

impl Clone for TypeId

fn clone(&self) -> TypeId

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TypeId

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

Formats the value using the given formatter.

impl Default for TypeId

fn default() -> TypeId

Returns the “default value” for a type.

impl From<TypeId> for DiagnosticArg

fn from(v: TypeId) -> Self

Converts to this type from the input type.

impl Hash for TypeId

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for TypeId

fn eq(&self, other: &TypeId) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for TypeId

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TypeIdExt for TypeId

fn non_never(self) -> Option<Self>

Returns Some(self) if self is not NEVER, otherwise None.

impl Copy for TypeId

impl Eq for TypeId

impl StructuralPartialEq for TypeId