Enum MemberRef 

pub enum MemberRef {
    Absolute(u16),
    Deferred {
        field_name: Symbol,
        field_type: TypeId,
    },
    DeferredByIndex {
        parent_type: TypeId,
        relative_index: u16,
    },
}

Symbolic reference to a struct field or enum variant. Resolved to absolute member index during bytecode emission.

Struct field indices are deduplicated globally: same (name, type) pair → same index. This enables call-site scoping where uncaptured refs share the caller’s scope.

Enum variant indices use the traditional (parent_type, relative_index) approach since enum variants don’t bubble between scopes.

Variants

Absolute(u16)

Already resolved to absolute index (for cases where it’s known).

Deferred

Deferred resolution by field identity (for struct fields). The same (field_name, field_type) pair resolves to the same member index regardless of which struct type contains it.

Fields

field_name: Symbol

The Symbol of the field name (from query interner).

field_type: TypeId

The TypeId of the field’s value type (from query TypeContext).

DeferredByIndex

Deferred resolution by parent type + relative index (for enum variants). Uses the parent enum’s member_base + relative_index.

Fields

parent_type: TypeId

The TypeId of the parent enum type.

relative_index: u16

Relative index within the parent type’s members.

Implementations

impl MemberRef

pub fn absolute(index: u16) -> Self

Create an absolute reference.

pub fn deferred(field_name: Symbol, field_type: TypeId) -> Self

Create a deferred reference by field identity (for struct fields).

pub fn deferred_by_index(parent_type: TypeId, relative_index: u16) -> Self

Create a deferred reference by parent type + index (for enum variants).

pub fn resolve<F, G>(self, lookup_member: F, get_member_base: G) -> u16

where F: Fn(Symbol, TypeId) -> Option<u16>, G: Fn(TypeId) -> Option<u16>,

Resolve this reference using lookup functions.

• lookup_member: maps (field_name Symbol, field_type TypeId) to member index
• get_member_base: maps parent TypeId to member base index

Trait Implementations

impl Clone for MemberRef

fn clone(&self) -> MemberRef

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MemberRef

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

Formats the value using the given formatter.

impl PartialEq for MemberRef

fn eq(&self, other: &MemberRef) -> 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 Copy for MemberRef

impl Eq for MemberRef

impl StructuralPartialEq for MemberRef