Enum rusttyc::TcErr

pub enum TcErr<V: ContextSensitiveVariant> {
    KeyEquation(TcKey, TcKey, V::Err),
    Bound(TcKey, Option<TcKey>, V::Err),
    ChildAccessOutOfBound(TcKey, V, usize),
    ArityMismatch {
        key: TcKey,
        variant: V,
        inferred_arity: usize,
        reported_arity: usize,
    },
    Construction(TcKey, Preliminary<V>, V::Err),
    ChildConstruction(TcKey, usize, Preliminary<V>, V::Err),
    CyclicGraph,
}

Represents an error during the type check procedure.

Variants

KeyEquation(TcKey, TcKey, V::Err)

Two keys were attempted to be equated and their underlying types turned out to be incompatible. Contains the two keys and the error that occurred when attempting to meet their ContextSensitiveVariant types.

Tuple Fields of KeyEquation

0: TcKey1: TcKey2: V::Err

Bound(TcKey, Option<TcKey>, V::Err)

An explicit type bound imposed on a key turned out to be incompatible with the type inferred based on remaining information on the key. Contains the key and the error that occurred when meeting the explicit bound with the inferred type variant.

Tuple Fields of Bound

0: TcKey1: Option<TcKey>2: V::Err

ChildAccessOutOfBound(TcKey, V, usize)

This error occurs when a constraint accesses the nth child of a type and its variant turns out to only have k < n sub-types. Contains the affected key, its inferred or explicitly assigned variant, and the index of the child that was attempted to be accessed.

Tuple Fields of ChildAccessOutOfBound

0: TcKey1: V2: usize

ArityMismatch

This error occurs if the type checker inferred a specific arity but the variant reports a fixed arity that is lower than the inferred one.

Fields of ArityMismatch

key: TcKey

The key for which the mismatch was detected.

variant: V

The variant with fixed arity.

inferred_arity: usize

The least required arity according to the type check procedure.

reported_arity: usize

The arity required according to the meet operation that created the variant.

Construction(TcKey, Preliminary<V>, V::Err)

An error reporting a failed type construction. Contains the affected key, the preliminary result for which the construction failed, and the error reported by the construction.

Tuple Fields of Construction

0: TcKey1: Preliminary<V>2: V::Err

ChildConstruction(TcKey, usize, Preliminary<V>, V::Err)

This error indicates that a variant requires children, for one of which the construction failed. Note that this can occur seemingly-spuriously, e.g., if a child needs to be present but there were no restrictions on said child. In this case, the construction attempts and might fail to construct a child out of a ContextSensitiveVariant::top(). The error contains the affected key, the index of the child, the preliminary result of which a child construction failed, and the error reported by the construction of the child.

Tuple Fields of ChildConstruction

0: TcKey1: usize2: Preliminary<V>3: V::Err

CyclicGraph

This error reports cyclic non-equality dependencies in the constraint graph. Example: Key 1 is more concrete than Key 2, which is more concrete than Key 3, which is more concrete than Key 1.

Trait Implementations

impl<V: Clone + ContextSensitiveVariant> Clone for TcErr<V> where
    V::Err: Clone,
    V::Err: Clone,
    V::Err: Clone,
    V::Err: Clone, 

fn clone(&self) -> TcErr<V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V: Debug + ContextSensitiveVariant> Debug for TcErr<V> where
    V::Err: Debug,
    V::Err: Debug,
    V::Err: Debug,
    V::Err: Debug, 

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

Formats the value using the given formatter.