Enum Unsupported 

pub enum Unsupported {
    Inst {
        inst: Inst,
        term: Option<&'static str>,
        opcode: Opcode,
        ty: Option<Type>,
    },
    Argument {
        index: usize,
        missing: Missing,
    },
    Call {
        inst: Inst,
        refused: Refused,
    },
    Indirect {
        inst: Inst,
    },
    Dynamic {
        inst: Inst,
    },
}

Why a function could not be lowered.

One reason and then nothing. A function with no rule for something in it is a function this cannot finish, and the second thing it could not lower is not news.

Variants

Inst

An instruction no rule fires on.

Fields

inst: Inst

The instruction that stopped it.

term: Option<&'static str>

What the rule file would call it, or nothing if the rule language has no name for it at all, which is what an instruction at a width nothing is written about looks like.

opcode: Opcode

The opcode, which is what gets named when the rule language has no word for it.

An opcode the rule language has no word for is exactly the opcode no rule lowers, so without this the message would be empty in every case where somebody needs it.

ty: Option<Type>

What it produces, or nothing for an instruction that is only an effect.

Argument

A parameter that does not arrive somewhere this can bring it in from.

Not an instruction, which is why it is a separate arm: it is a fact about the signature and there is nothing in the body of the function to point at.

Fields

index: usize

Its position in the signature.

missing: Missing

What is wrong with where it arrives.

Call

A call that passes or gives back a value this cannot put where the convention wants it.

Fields

inst: Inst

The call.

refused: Refused

Which value, and what is wrong with where it travels.

Indirect

A call through an address rather than to a name.

The address is a value in a register and the instruction that calls one is a different instruction, which nothing describes yet.

Fields

inst: Inst

The call.

Dynamic

A stack slot whose size is not known until the function runs, which is what a variable length array is.

Not an instruction no rule covers. Growing the stack where the declaration stands is arithmetic on the stack pointer, and everything else in the frame then has to be reached through a frame pointer instead, and neither of those is a term a rule could be written about or a thing the frame here knows how to lay out.

Fields

inst: Inst

The alloca.

Implementations

impl Unsupported

pub fn inst(&self) -> Option<Inst>

The instruction it is about, or nothing for the one arm that is about a signature.

What a caller wants this for is the span. The function knows where every instruction in it came from, so a caller holding both can point a message at the line somebody wrote rather than at the file as a whole, and nothing here has to carry a span of its own.

Trait Implementations

impl Clone for Unsupported

fn clone(&self) -> Unsupported

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Unsupported

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

Formats the value using the given formatter.

impl Display for Unsupported

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

Formats the value using the given formatter.

impl Eq for Unsupported

impl Error for Unsupported

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 PartialEq for Unsupported

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Unsupported