Enum LowerError 

#[non_exhaustive]
pub enum LowerError {
    NotYetImplemented {
        what: String,
    },
    LiteralOutOfRange {
        payload: String,
        target: PrimitiveType,
    },
    LiteralTypeMismatch {
        kind: String,
        ty: ResolvedType,
    },
    UnknownBinding(BindingId),
    UnresolvedReference,
    UnsupportedOperator {
        op: String,
        operand: PrimitiveType,
    },
    TypeMap(TypeMapError),
    ZeroSizedLetBinding {
        name: String,
        ty: ResolvedType,
    },
    UnknownFunction(FunctionId),
    UnresolvedFunctionCall {
        path: Vec<String>,
    },
    MissingContext {
        what: &'static str,
    },
    ExternalStructInst,
    Layout(LayoutError),
    FieldIndexOutOfRange {
        struct_name: String,
        field_count: usize,
        field_idx: u32,
    },
    FieldAccessOnNonAggregate {
        ty: ResolvedType,
    },
    UnknownStruct(StructId),
    ExternalEnumInst,
    UnknownEnum(EnumId),
    UnknownVariant {
        enum_name: String,
        variant: String,
    },
    MissingSelfStruct,
    UnknownMethod {
        impl_id: ImplId,
        method_idx: MethodIdx,
    },
    VirtualMethodCall,
    UnknownVtable {
        trait_id: TraitId,
        target: ImplTargetKey,
    },
    UnknownVirtualMethodType {
        trait_id: TraitId,
        method_idx: MethodIdx,
    },
    UnsupportedVirtualReceiver {
        ty: ResolvedType,
    },
}

Errors produced by the expression-lowering helpers.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

NotYetImplemented

The expression variant or operand shape is in scope for the backend but not yet implemented in this phase.

Fields

what: String

Short tag describing the missing variant or shape.

LiteralOutOfRange

A numeric literal whose payload is incompatible with its declared type — e.g. an I32-typed literal whose value is out of range or carries a float-syntax payload. Semantic analysis should catch these upstream; the variant exists so we never silently emit a wrong constant.

Fields

payload: String

String form of the offending payload (e.g. "3.14" or "2147483648").

target: PrimitiveType

The declared target primitive type.

LiteralTypeMismatch

A literal whose type doesn’t match its kind, e.g. a String literal carrying a non-Primitive(String) ty.

Fields

kind: String

Tag for the literal kind ("Boolean", "Number(integer)", …).

ty: ResolvedType

The declared resolved type.

UnknownBinding(BindingId)

A reference / LetRef carries a BindingId that the caller’s BindingMap does not know about. Indicates a lowering pass failed to register the binding before walking expressions that reference it.

UnresolvedReference

A reference’s ReferenceTarget is Unresolved. Means ResolveReferencesPass did not run before the backend.

UnsupportedOperator

A binary or unary operator was applied to operand type(s) the backend does not support — either a fundamentally invalid combo (e.g. And on I32) or a deferred case (e.g. arithmetic on String, which lives in Phase 2).

Fields

op: String

Operator name (e.g. "Add", "Range", "Mod").

operand: PrimitiveType

Operand primitive type at the offending site.

TypeMap(TypeMapError)

A type appearing on a parameter or let binding could not be mapped to a wasm value type — typically because the lowering for that type lives in a later phase.

ZeroSizedLetBinding

A let-binding inside a block has a unit/Never type that can’t be assigned to a wasm local. Indicates an upstream invariant violation.

Fields

name: String

Source-level name of the offending binding.

ty: ResolvedType

The declared resolved type.

UnknownFunction(FunctionId)

A FunctionCall carries a FunctionId that the caller’s FunctionMap does not know about. Indicates the module- level lowering pass failed to register this function before walking call sites.

UnresolvedFunctionCall

A FunctionCall carries function_id = None. Either the resolution pass failed, or the call targets an external (cross-module) function which won’t be supported until Phase 4.

Fields

path: Vec<String>

Source-level path of the call (e.g. ["math", "sin"]).

MissingContext

A lowering needs an LowerContext field that is not set — typically the IrModule reference (for struct/enum lookups) or the bump-allocator function index. Surfaced when an aggregate lowering runs through a context built for the expression-only test path.

Fields

what: &'static str

Static tag identifying the missing field.

ExternalStructInst

A StructInst carries struct_id = None, which means it instantiates an external (cross-module) struct. External references land in Phase 4.

Layout(LayoutError)

A struct’s layout could not be planned — see the wrapped LayoutError for the underlying cause.

FieldIndexOutOfRange

A FieldAccess references a field index past the end of its containing struct’s fields vector. Indicates an upstream invariant violation.

Fields

struct_name: String

Source-level struct name.

field_count: usize

Number of fields actually in the struct.

field_idx: u32

The offending field index.

FieldAccessOnNonAggregate

A FieldAccess’s object expression has a non-aggregate type (e.g. a primitive). This means the type-checker accepted a field access on something that has no fields.

Fields

ty: ResolvedType

The offending object’s resolved type.

UnknownStruct(StructId)

A StructInst was given a struct_id that the module’s structs vector does not contain. Indicates corrupt IR.

ExternalEnumInst

An EnumInst carries enum_id = None, which means it instantiates an external (cross-module) enum. External references land in Phase 4.

UnknownEnum(EnumId)

An EnumInst was given an enum_id that the module’s enums vector does not contain. Indicates corrupt IR.

UnknownVariant

An EnumInst references a variant that the resolved enum definition does not contain. Indicates an upstream invariant violation.

Fields

enum_name: String

Containing enum name.

variant: String

Source-level variant name.

MissingSelfStruct

A SelfFieldRef was lowered without a LowerContext::self_struct_id set. Means the function is not a method of any struct, but its body uses self.field — an upstream invariant violation.

UnknownMethod

A MethodCall with DispatchKind::Static { impl_id } and method_idx whose pair is not present in the module’s MethodMap. Indicates the impl was never walked or the indices are inconsistent.

Fields

impl_id: ImplId

The offending impl id.

method_idx: MethodIdx

The offending method index inside that impl.

VirtualMethodCall

A MethodCall with DispatchKind::Virtual { .. } was encountered. Virtual dispatch lands in Phase 3.

UnknownVtable

A virtual MethodCall whose (trait_id, impl_target) pair has no vtable registered. Indicates the module-level pre-walk missed the impl, or the receiver type is one the layout planner doesn’t recognise as a vtable target.

Fields

trait_id: TraitId

The trait whose vtable is missing.

target: ImplTargetKey

The impl-target key the lookup was keyed on.

UnknownVirtualMethodType

A virtual MethodCall whose (trait_id, method_idx) pair has no call_indirect type-index registered. Indicates the module- level pre-walk missed the trait method.

Fields

trait_id: TraitId

Trait id.

method_idx: MethodIdx

Method index inside the trait’s methods vector.

UnsupportedVirtualReceiver

A virtual MethodCall whose receiver type cannot be resolved to an ImplTarget. Phase 3 supports concrete struct / enum receivers; trait-object receivers stay rejected (semantic analysis bans Trait as a value).

Fields

ty: ResolvedType

The offending receiver’s resolved type.

Trait Implementations

impl Debug for LowerError

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

Formats the value using the given formatter.

impl Display for LowerError

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

Formats the value using the given formatter.

impl Error for LowerError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<LayoutError> for LowerError

fn from(source: LayoutError) -> Self

Converts to this type from the input type.

impl From<LowerError> for ModuleLowerError

fn from(source: LowerError) -> Self

Converts to this type from the input type.

impl From<TypeMapError> for LowerError

fn from(source: TypeMapError) -> Self

Converts to this type from the input type.