Struct erg_compiler::context::Context

pub struct Context {
    pub name: Str,
    pub kind: ContextKind,
    /* private fields */
}

Represents the context of the current scope

Recursive functions/methods are highlighted with the prefix rec_, as performance may be significantly degraded.

Fields

name: Str

kind: ContextKind

Implementations

impl Context

pub fn subtype_of(&self, lhs: &Type, rhs: &Type) -> bool

lhs <: rhs ?

e.g.

Named :> Module
=> Module.super_types == [Named]

Seq(T) :> Range(T)
=> Range(T).super_types == [Eq, Mutate, Seq(T), Output(T)]

pub fn fields(&self, t: &Type) -> Dict<Field, Type>

pub fn diff(&self, lhs: &Type, rhs: &Type) -> Type

Returns difference of two types (A - B == A and not B).

(A or B).diff(B) == A

impl Context

pub const TOP_LEVEL: usize = 1usize

pub fn readable_type(&self, t: Type) -> Type

impl Context

pub fn new_module<S: Into<Str>>( name: S, cfg: ErgConfig, shared: SharedCompilerResource ) -> Self

impl Context

pub fn get_method_kv(&self, name: &str) -> Option<(&VarName, &VarInfo)>

pub fn get_singular_ctxs_by_hir_expr( &self, obj: &Expr, namespace: &Context ) -> SingleTyCheckResult<Vec<&Context>>

pub fn sort_types<'a>( &self, types: impl Iterator<Item = &'a Type> ) -> Vec<&'a Type>

Perform types linearization. TODO: Current implementation may be very inefficient.

C3 linearization requires prior knowledge of inter-type dependencies, and cannot be used for Erg structural subtype linearization

Algorithm:

[Int, Str, Nat, Never, Obj, Str!, Module]
=> [], [Int, Str, Nat, Never, Obj, Str!, Module]
=> [[Int]], [Str, Nat, Never, Obj, Str!, Module]
# 1. If related, put them in the same array; if not, put them in different arrays.
=> [[Int], [Str]], [Nat, Never, Obj, Str!, Module]
=> ...
=> [[Int, Nat, Never, Obj]], [Str, Str!], [Module]]
# 2. Then, perform sorting on the arrays
=> [[Never, Nat, Int, Obj], [Str!, Str], [Module]]
# 3. Concatenate the arrays
=> [Never, Nat, Int, Obj, Str!, Str, Module]
# 4. From the left, "slide" types as far as it can.
=> [Never, Nat, Int, Str!, Str, Module, Obj]

pub fn min_type<'a>( &self, types: impl Iterator<Item = &'a Type> ) -> Option<&'a Type>

Returns the smallest type among the iterators of a given type. If there is no subtype relationship, returns None.

min_type([Int, Int]) == Int
min_type([Int, Nat]) == Nat
min_type([Int, Str]) == None
min_type([Int, Str, Nat]) == None

pub fn max_type<'a>( &self, types: impl Iterator<Item = &'a Type> ) -> Option<&'a Type>

Returns the largest type among the iterators of a given type. If there is no subtype relationship, returns None.

max_type([Int, Int]) == Int
max_type([Int, Nat]) == Int
max_type([Int, Str]) == None
max_type([Int, Str, Nat]) == None

pub fn get_nominal_super_type_ctxs<'a>( &'a self, t: &Type ) -> Option<Vec<&'a TypeContext>>

pub fn get_mod_with_t(&self, mod_t: &Type) -> Option<&Context>

pub fn get_type_info_by_str(&self, name: &str) -> Option<(&VarName, &VarInfo)>

pub fn is_class(&self, typ: &Type) -> bool

pub fn is_trait(&self, typ: &Type) -> bool

pub fn meta_type(&self, typ: &Type) -> Type

Int.meta_type() == ClassType (<: Type)
Show.meta_type() == TraitType (<: Type)
[Int; 3].meta_type() == [ClassType; 3] (<: Type)
Indexable(T).meta_type() == TraitType (<: Type)
NamedTuple({ .x = Int; .y = Str }).meta_type() == NamedTuple({ .x = ClassType; .y = ClassType })

impl Context

pub fn del(&mut self, ident: &Identifier) -> CompileResult<()>

impl Context

pub fn assert_var_type(&self, varname: &str, ty: &Type) -> Result<(), ()>

pub fn assert_attr_type( &self, receiver_t: &Type, attr: &str, ty: &Type ) -> Result<(), ()>

pub fn test_refinement_subtyping(&self) -> Result<(), ()>

pub fn test_quant_subtyping(&self) -> Result<(), ()>

pub fn test_resolve_trait_inner1(&self) -> Result<(), ()>

pub fn test_instantiation_and_generalization(&self) -> Result<(), ()>

pub fn test_patch(&self) -> Result<(), ()>

pub fn test_intersection(&self) -> Result<(), ()>

impl Context

pub fn dir(&self) -> Dict<&VarName, &VarInfo>

pub fn get_receiver_ctx(&self, receiver_name: &str) -> Option<&Context>

pub fn get_receiver_ctxs(&self, receiver_name: &str) -> Vec<&Context>

pub fn get_var_info(&self, name: &str) -> Option<(&VarName, &VarInfo)>

pub fn has(&self, name: &str) -> bool

pub fn get_type_info(&self, typ: &Type) -> Option<(&VarName, &VarInfo)>

pub fn unregister(&mut self, name: &str) -> Option<VarInfo>

impl Context

pub fn new( name: Str, cfg: ErgConfig, kind: ContextKind, params: Vec<ParamSpec>, outer: Option<Context>, shared: Option<SharedCompilerResource>, level: usize ) -> Self

pub fn default_with_name(name: &'static str) -> Self

pub fn with_capacity( name: Str, cfg: ErgConfig, kind: ContextKind, params: Vec<ParamSpec>, outer: Option<Context>, shared: Option<SharedCompilerResource>, capacity: usize, level: usize ) -> Self

pub fn mono( name: Str, cfg: ErgConfig, kind: ContextKind, outer: Option<Context>, shared: Option<SharedCompilerResource>, level: usize ) -> Self

pub fn poly( name: Str, cfg: ErgConfig, kind: ContextKind, params: Vec<ParamSpec>, outer: Option<Context>, shared: Option<SharedCompilerResource>, capacity: usize, level: usize ) -> Self

pub fn poly_trait<S: Into<Str>>( name: S, params: Vec<ParamSpec>, cfg: ErgConfig, shared: Option<SharedCompilerResource>, capacity: usize, level: usize ) -> Self

pub fn builtin_poly_trait<S: Into<Str>>( name: S, params: Vec<ParamSpec>, capacity: usize ) -> Self

pub fn poly_class<S: Into<Str>>( name: S, params: Vec<ParamSpec>, cfg: ErgConfig, shared: Option<SharedCompilerResource>, capacity: usize, level: usize ) -> Self

pub fn builtin_poly_class<S: Into<Str>>( name: S, params: Vec<ParamSpec>, capacity: usize ) -> Self

pub fn poly_patch<S: Into<Str>>( name: S, base: Type, params: Vec<ParamSpec>, cfg: ErgConfig, shared: Option<SharedCompilerResource>, capacity: usize, level: usize ) -> Self

pub fn mono_trait<S: Into<Str>>( name: S, cfg: ErgConfig, shared: Option<SharedCompilerResource>, capacity: usize, level: usize ) -> Self

pub fn builtin_mono_trait<S: Into<Str>>(name: S, capacity: usize) -> Self

pub fn mono_class<S: Into<Str>>( name: S, cfg: ErgConfig, shared: Option<SharedCompilerResource>, capacity: usize, level: usize ) -> Self

pub fn builtin_mono_class<S: Into<Str>>(name: S, capacity: usize) -> Self

pub fn mono_patch<S: Into<Str>>( name: S, base: Type, cfg: ErgConfig, shared: Option<SharedCompilerResource>, capacity: usize, level: usize ) -> Self

pub fn methods( impl_trait: Option<Type>, cfg: ErgConfig, shared: Option<SharedCompilerResource>, capacity: usize, level: usize ) -> Self

pub fn builtin_methods(impl_trait: Option<Type>, capacity: usize) -> Self

pub fn poly_glue_patch<S: Into<Str>>( name: S, base: Type, impls: Type, params: Vec<ParamSpec>, cfg: ErgConfig, shared: Option<SharedCompilerResource>, capacity: usize, level: usize ) -> Self

pub fn builtin_poly_glue_patch<S: Into<Str>>( name: S, base: Type, impls: Type, params: Vec<ParamSpec>, capacity: usize ) -> Self

pub fn builtin_patch<S: Into<Str>>( name: S, impls: Type, params: Vec<ParamSpec>, capacity: usize ) -> Self

pub fn module( name: Str, cfg: ErgConfig, shared: Option<SharedCompilerResource>, capacity: usize ) -> Self

pub fn builtin_module<S: Into<Str>>( name: S, cfg: ErgConfig, shared: SharedCompilerResource, capacity: usize ) -> Self

pub fn instant( name: Str, cfg: ErgConfig, capacity: usize, shared: Option<SharedCompilerResource>, outer: Context ) -> Self

pub fn caused_by(&self) -> String

pub fn is_empty(&self) -> bool

pub fn initialize(&mut self)

This method is intended to be called only in the top-level module. .cfg is not initialized and is used around.

pub fn pop(&mut self) -> Context

Note that the popped context is detached and outer == None.

pub fn pop_mod(&mut self) -> Option<Context>

unlike pop, outer must be None.

pub fn local_dir(&self) -> Dict<&VarName, &VarInfo>

pub fn index(&self) -> &SharedModuleIndex

pub fn graph(&self) -> &SharedModuleGraph

pub fn trait_impls(&self) -> &SharedTraitImpls

pub fn shared(&self) -> &SharedCompilerResource

pub fn promises(&self) -> &SharedPromises

pub fn current_control_flow(&self) -> Option<ControlKind>

pub fn control_kind(&self) -> Option<ControlKind>

pub fn current_true_function_ctx(&self) -> Option<&Context>

Context of the function that actually creates the scope. Control flow function blocks do not create actual scopes.

Trait Implementations

impl Clone for Context

fn clone(&self) -> Context

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ContextProvider for Context

fn dir(&self) -> Dict<&VarName, &VarInfo>

fn get_receiver_ctx(&self, receiver_name: &str) -> Option<&Context>

fn get_var_info(&self, name: &str) -> Option<(&VarName, &VarInfo)>

fn has(&self, name: &str) -> bool

impl Debug for Context

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

Formats the value using the given formatter.

impl Default for Context

fn default() -> Self

Returns the “default value” for a type.

impl Display for Context

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

Formats the value using the given formatter.