Struct lark_type_check::TypeCheckResults

pub struct TypeCheckResults<F: TypeFamily> {
    pub max_types: BTreeMap<MetaIndex, Ty<F>>,
    pub access_types: BTreeMap<Expression, Ty<F>>,
    pub access_permissions: BTreeMap<Expression, F::Perm>,
    pub generics: BTreeMap<MetaIndex, Generics<F>>,
    pub entities: BTreeMap<MetaIndex, Entity>,
}

Fields

max_types: BTreeMap<MetaIndex, Ty<F>>

The "maximum type" computed for expressions, identified-expressions, and other things that have a type. The maximum type is the full set of permissions available from that expression.

access_types: BTreeMap<Expression, Ty<F>>

The "access type" for a given expression -- this is the set of permissions required by that particular expression. These cannot exceed the "max types" and are determined by how the result of the expression is used.

access_permissions: BTreeMap<Expression, F::Perm>

The "permission variable" recorded for a given expression instance.

generics: BTreeMap<MetaIndex, Generics<F>>

For references to entities, the generics applied.

entities: BTreeMap<MetaIndex, Entity>

For "type-relative" identifiers, stores the entity that we resolved to. Examples:

• foo.bar -- attached to the identifier bar, entity of the field
• foo.bar(..) -- attached to the identifier bar, entity of the method
• Foo { a: b } -- attached to the identifier a, entity of the field
• foo -- when an identifier refers to an entity

Methods

impl<F: TypeFamily> TypeCheckResults<F>

pub fn ty(
    &self,
    index: impl Into<MetaIndex>
) -> Ty<F>

Access the type stored for the given index, usually the index of an expression. Indicates the "maximum type".

pub fn access_ty(&self, expression: Expression) -> Ty<F>

Returns the "access type" of this expression, which indicates how many permissions were needed.

pub fn opt_ty(
    &self,
    index: impl Into<MetaIndex>
) -> Option<Ty<F>>

Load the type for index, if any is stored, else return None.

pub fn has_recorded_ty(
    &self,
    index: impl Into<MetaIndex>
) -> bool

Check whether there is a type recorded for index.

Trait Implementations

impl<F: Eq + TypeFamily> Eq for TypeCheckResults<F> where
    F::Perm: Eq, 

impl<F: Clone + TypeFamily> Clone for TypeCheckResults<F> where
    F::Perm: Clone, 

fn clone(&self) -> TypeCheckResults<F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: PartialEq + TypeFamily> PartialEq<TypeCheckResults<F>> for TypeCheckResults<F> where
    F::Perm: PartialEq, 

fn eq(&self, other: &TypeCheckResults<F>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &TypeCheckResults<F>) -> bool

This method tests for !=.

impl<F: TypeFamily> Default for TypeCheckResults<F>

fn default() -> Self

Returns the "default value" for a type.

impl<F: Hash + TypeFamily> Hash for TypeCheckResults<F> where
    F::Perm: Hash, 

fn hash<__HF: Hasher>(&self, state: &mut __HF)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<F: Debug + TypeFamily> Debug for TypeCheckResults<F> where
    F::Perm: Debug, 

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

Formats the value using the given formatter.

impl<S, T> Map<S, T> for TypeCheckResults<S> where
    S: TypeFamily,
    T: TypeFamily, 

type Output = TypeCheckResults<T>

fn map(
    &self,
    mapper: &mut impl FamilyMapper<S, T>
) -> Self::Output