Struct erg_compiler::context::Context
source · pub struct Context {
pub name: Str,
pub kind: ContextKind,
/* private fields */
}
Expand description
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§
source§impl Context
impl Context
source§impl Context
impl Context
pub fn new_module<S: Into<Str>>( name: S, cfg: ErgConfig, shared: SharedCompilerResource ) -> Self
source§impl Context
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>>
sourcepub fn sort_types<'a>(
&self,
types: impl Iterator<Item = &'a Type>
) -> Vec<&'a Type>
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]
sourcepub fn min_type<'a>(
&self,
types: impl Iterator<Item = &'a Type>
) -> Option<&'a Type>
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
sourcepub fn max_type<'a>(
&self,
types: impl Iterator<Item = &'a Type>
) -> Option<&'a Type>
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
sourcepub fn meta_type(&self, typ: &Type) -> Type
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 })
source§impl Context
impl Context
pub fn del(&mut self, ident: &Identifier) -> CompileResult<()>
source§impl Context
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<(), ()>
source§impl Context
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>
source§impl Context
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
sourcepub fn initialize(&mut self)
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 local_dir(&self) -> Dict<&VarName, &VarInfo>
pub fn index(&self) -> &SharedModuleIndex
pub fn graph(&self) -> &SharedModuleGraph
pub fn trait_impls(&self) -> &SharedTraitImpls
pub fn promises(&self) -> &SharedPromises
pub fn current_control_flow(&self) -> Option<ControlKind>
pub fn control_kind(&self) -> Option<ControlKind>
sourcepub fn current_true_function_ctx(&self) -> Option<&Context>
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.