Struct DefinitionInfo 

pub struct DefinitionInfo {

    pub kind: DefKind,
    pub name: Atom,
    pub type_params: Vec<TypeParamInfo>,
    pub body: Option<TypeId>,
    pub instance_shape: Option<Arc<ObjectShape>>,
    pub static_shape: Option<Arc<ObjectShape>>,
    pub extends: Option<DefId>,
    pub implements: Vec<DefId>,
    pub enum_members: Vec<(Atom, EnumMemberValue)>,
    pub exports: Vec<(Atom, DefId)>,
    pub file_id: Option<u32>,
    pub span: Option<(u32, u32)>,
    pub symbol_id: Option<u32>,
}

Complete information about a type definition.

This is stored in DefinitionStore and retrieved by DefId.

Fields

kind: DefKind

Kind of definition (affects evaluation strategy)

name: Atom

Name of the definition (for diagnostics)

type_params: Vec<TypeParamInfo>

Type parameters for generic definitions

body: Option<TypeId>

The body TypeId (structural representation) For lazy definitions, this may be computed on demand

instance_shape: Option<Arc<ObjectShape>>

For classes: the instance type’s structural shape

static_shape: Option<Arc<ObjectShape>>

For classes: the static type’s structural shape

extends: Option<DefId>

For classes: parent class DefId (if extends)

implements: Vec<DefId>

For classes/interfaces: implemented interfaces

enum_members: Vec<(Atom, EnumMemberValue)>

For enums: member names and values

exports: Vec<(Atom, DefId)>

For namespaces/modules: exported members Maps export name to the DefId of the exported type

file_id: Option<u32>

Optional file identifier for debugging

span: Option<(u32, u32)>

Optional span for source location

symbol_id: Option<u32>

The binder SymbolId that this DefId was created from. Used for cross-context cycle detection: the same interface may get different DefIds in different checker contexts, but the SymbolId stays the same. This enables coinductive cycle detection for recursive generic interfaces (e.g., Promise<T> vs PromiseLike<T>).

Implementations

impl DefinitionInfo

pub const fn type_alias( name: Atom, type_params: Vec<TypeParamInfo>, body: TypeId, ) -> Self

Create a new type alias definition.

pub fn interface( name: Atom, type_params: Vec<TypeParamInfo>, properties: Vec<PropertyInfo>, ) -> Self

Create a new interface definition.

pub fn class( name: Atom, type_params: Vec<TypeParamInfo>, instance_properties: Vec<PropertyInfo>, static_properties: Vec<PropertyInfo>, ) -> Self

Create a new class definition.

pub const fn enumeration( name: Atom, members: Vec<(Atom, EnumMemberValue)>, ) -> Self

Create a new enum definition.

pub const fn namespace(name: Atom, exports: Vec<(Atom, DefId)>) -> Self

Create a new namespace definition.

pub const fn with_extends(self, parent: DefId) -> Self

Set the extends parent for a class.

pub fn with_implements(self, interfaces: Vec<DefId>) -> Self

Set implemented interfaces.

pub fn with_exports(self, exports: Vec<(Atom, DefId)>) -> Self

Set exports for a namespace/module.

pub fn add_export(&mut self, name: Atom, def_id: DefId)

Add an export to the namespace/module.

pub fn get_export(&self, name: Atom) -> Option<DefId>

Look up an export by name.

pub const fn with_file_id(self, file_id: u32) -> Self

Set file ID for debugging.

pub const fn with_span(self, start: u32, end: u32) -> Self

Set source span.

Trait Implementations

impl Clone for DefinitionInfo

fn clone(&self) -> DefinitionInfo

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DefinitionInfo

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

Formats the value using the given formatter.