Struct RefExpr

pub struct RefExpr {
    pub decl: DeclExpr,
    pub step: Option<Expr>,
    pub root: Option<Expr>,
    pub term: Option<Ty>,
}

Represents a reference expression.

A reference expression tracks how an identifier resolves through the lexical scope, imports, and field accesses. It maintains a chain of resolution steps to support features like go-to-definition, go-to-reference, and type inference.

Resolution Chain

The fields form a resolution chain: root -> step -> decl, where:

• root is the original source of the value
• step is any intermediate transformation
• decl is the final identifier being referenced
• term is the resolved type (if known)
  • Hint: A value 1’s typst type is int, but here we keep the type as 1 to improve the type inference.

Examples

Simple identifier reference

// For: let x = value; let y = x;
RefExpr {
    decl: y,           // The identifier 'y'
    root: Some(x),     // Points back to 'x'
    step: Some(x),     // Same as root for simple refs
    term: None,        // Type may not be known yet
}

Import with rename

// For: import "mod.typ": old as new
// First creates ref for 'old':
RefExpr { decl: old, root: Some(mod.old), step: Some(field), term: Some(Func(() -> dict)) }
// Then creates ref for 'new':
RefExpr { decl: new, root: Some(mod.old), step: Some(old), term: Some(Func(() -> dict)) }

Builtin definitions

// For: std.length
RefExpr { decl: length, root: None, step: None, term: Some(Type(length)) }

Fields

decl: DeclExpr

The declaration being referenced (the final identifier in the chain).

This is always set and represents the identifier at the current point of reference (e.g., the variable name, import alias, or field name).

step: Option<Expr>

The intermediate expression in the resolution chain.

Set in the following cases:

• Import/include: The module expression being imported
• Field access: The selected field’s expression
• Scope resolution: The scope expression being resolved
• Renamed imports: The original name before renaming

None when the identifier is an undefined reference.

root: Option<Expr>

The root expression at the start of the reference chain.

A root definition never references another root definition.

term: Option<Ty>

The final resolved type of the referenced value.

Set whenever a type is known for the referenced value.

Some reference doesn’t have a root definition, but has a term. For example, std.length is termed as Type(length) while has no a definition.

Trait Implementations

impl Clone for RefExpr

fn clone(&self) -> RefExpr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RefExpr

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

Formats the value using the given formatter.

impl Hash for RefExpr

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 Internable for RefExpr

fn storage() -> &'static InternStorage<Self>

impl PartialEq for RefExpr

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

impl StructuralPartialEq for RefExpr