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 eval_value_proj_call( &self, lhs: TyParam, attr_name: Str, args: Vec<TyParam>, t_loc: &impl Locational, ) -> EvalResult<Result<ValueObj, TyParam>>
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.
Trait Implementations§
source§impl ContextProvider for Context
impl ContextProvider for Context
Auto Trait Implementations§
impl Freeze for Context
impl !RefUnwindSafe for Context
impl Send for Context
impl Sync for Context
impl Unpin for Context
impl !UnwindSafe for Context
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)