Enum CheckType 

pub enum CheckType {
    Known(TypeAnnotation),
    Function {
        params: Vec<TypeAnnotation>,
        return_type: TypeAnnotation,
    },
    Unknown,
}

The type of a value as seen by the static checker.

Variants

Known(TypeAnnotation)

A fully resolved type (e.g. int, arr[string]).

Function

A function type with known parameter and return types.

Fields

params: Vec<TypeAnnotation>

return_type: TypeAnnotation

Unknown

Type could not be determined statically (stdlib calls, unresolved names). Propagates silently to avoid cascading false errors.

Implementations

impl CheckType

pub fn known(ty: TypeAnnotation) -> Self

Constructs a CheckType::Known from a TypeAnnotation.

pub fn is_null(&self) -> bool

Returns true if this type is TypeAnnotation::Null.

pub fn is_unknown(&self) -> bool

Returns true if this type is CheckType::Unknown.

pub fn into_const(self) -> Self

Converts a mutable Known type to its const variant (e.g. Int -> CInt).

pub fn matches(&self, expected: &CheckType) -> bool

Returns true if self is compatible with expected.

Compatibility rules:

• Either side being Unknown always matches (avoids cascading errors)
• Null matches anything (represents the absence of a value)
• Function { .. } matches Known(Fn) and vice versa
• Two Function types match only if params and return type are identical
• Two Known types match if equal, or via null_array_elision or const_matches

pub fn info(&self) -> String

Returns a human-readable description of this type for error messages.

Trait Implementations

impl Clone for CheckType

fn clone(&self) -> CheckType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CheckType

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

Formats the value using the given formatter.

impl PartialEq for CheckType

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