Enum ValidationError 

#[non_exhaustive]
pub enum ValidationError {
    MissingTerminator {
        block: Block,
    },
    BlockOutOfRange {
        block: Block,
    },
    ValueOutOfRange {
        value: Value,
    },
    EntryBranchTarget {
        block: Block,
    },
    ArgCountMismatch {
        block: Block,
        expected: usize,
        found: usize,
    },
    TypeMismatch {
        value: Value,
        expected: Type,
        found: Type,
    },
    NotNumeric {
        value: Value,
        found: Type,
    },
    ReturnValueExpected {
        expected: Type,
    },
    UseBeforeDef {
        value: Value,
        block: Block,
    },
    InconsistentDefinition {
        value: Value,
    },
}

A reason a Function is not well-formed.

Function::validate returns the first one it finds. Every variant names the offending entity so a caller can point a diagnostic at it. The set is #[non_exhaustive]: future checks may add variants without it being a breaking change, so a match on it must include a wildcard arm.

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.

MissingTerminator

A block has no terminator. Every block must end in exactly one. Set the block’s terminator before finishing the function.

Fields

block: Block

The unterminated block.

BlockOutOfRange

A terminator names a block that does not exist in the function. The branch target is a stale or fabricated handle; rebuild it from a block the function actually contains.

Fields

block: Block

The out-of-range target.

ValueOutOfRange

An instruction or terminator references a value that does not exist in the function. The handle is stale or from another function; values are scoped to the function that minted them.

Fields

value: Value

The out-of-range value.

EntryBranchTarget

A terminator branches to the entry block. Execution enters at the entry, so it must have no predecessors; route the edge to a fresh block instead.

Fields

block: Block

The block whose terminator targets the entry.

ArgCountMismatch

A jump or branch passes the wrong number of arguments for the target block’s parameters. Pass exactly one argument per target parameter.

Fields

block: Block

The target block whose parameter count was not matched.

expected: usize

The number of parameters the target declares.

found: usize

The number of arguments the terminator supplied.

TypeMismatch

A value was used where a different type was required — mismatched binary operands, a non-boolean branch condition, a return value of the wrong type, or a block argument that does not match the target parameter. Fix the lowering so the value’s type matches the position it is used in.

Fields

value: Value

The value whose type is wrong.

expected: Type

The type the position required.

found: Type

The type the value actually has.

NotNumeric

An arithmetic operation was applied to a non-numeric value. Add, subtract, multiply, divide, negate, and the ordering comparisons require Int or Float operands.

Fields

value: Value

The non-numeric value.

found: Type

Its actual type.

ReturnValueExpected

A return with no value was used in a function whose return type is not Unit. Return a value of the declared type.

Fields

expected: Type

The return type the function declares.

UseBeforeDef

A value was used before its definition reaches the use — its defining block does not dominate the use, or it is used earlier in the block than it is defined. In SSA every use must be dominated by its single definition.

Fields

value: Value

The value used too early.

block: Block

The block the premature use is in.

InconsistentDefinition

A value’s recorded definition is inconsistent with the block that lists it: the value is listed in a block other than the one it records as its definition site, or it is listed as a parameter while it records an instruction result (or the reverse). The Builder never produces this; it can only arise from a hand-assembled or corrupt deserialized function.

Fields

value: Value

The value whose definition does not match where it is listed.

Trait Implementations

impl Clone for ValidationError

fn clone(&self) -> ValidationError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ValidationError

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ValidationError

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ValidationError

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

Formats the value using the given formatter.

impl Error for ValidationError

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 ValidationError

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ValidationError