Struct Context 

pub struct Context {

    pub typing_context: VarType,
    pub subtypes: Graph<Type>,
    pub type_constructors: Vec<(String, Vec<Type>, ConstructorCategory)>,
    pub interface_constraints: HashMap<String, Type>,
    pub rigid_counter: u64,
    pub record_aliases: Vec<(String, Type)>,
    pub embedded_methods: Vec<(String, String, String)>,
    pub test_preamble: Vec<String>,
    pub self_type: Option<Type>,
    pub expected_return_type: Option<Type>,
    pub module_inner_contexts: HashMap<String, Arc<Context>>,
    pub processed_modules: HashMap<String, Type>,
    pub modules_in_progress: HashSet<String>,
    pub extern_fns: Vec<(String, Option<String>)>,
    pub import_from_fns: Vec<(String, String)>,
    pub signature_fns: Vec<String>,
    pub vectorizable_fns: Vec<(String, bool)>,
    /* private fields */
}

Fields

typing_context: VarType

subtypes: Graph<Type>

type_constructors: Vec<(String, Vec<Type>, ConstructorCategory)>

Registry of user-declared typeconstructors: (name, parameter signature, category).

interface_constraints: HashMap<String, Type>

Constraints mapping a rigid generic variable name to its interface. Introduced when an interface type appears in parameter position: fn(i: I): R ⇒ i : A with A: I stored here.

rigid_counter: u64

Counter for generating unique rigid generic variable names.

record_aliases: Vec<(String, Type)>

Flat, whole-program registry of every type X <- list { ... } record alias declared anywhere, including inside mod bodies. Unlike typing_context.aliases, this is never scoped away at a module boundary: R’s S3 class system has no module privacy, so transpilation needs the full picture to compute structural supertypes for the class vector (see record_field_class callers in processes::transpiling).

embedded_methods: Vec<(String, String, String)>

Named type embedding (embed field: Type): provenance of every function auto-generated by forwarding/reconstruction, as (type_name, method_name, source_field_name). Used to detect a later explicit definition that collides with an inherited embedded function (E-EMBED-003).

test_preamble: Vec<String>

RFC-TR-031: lines injected at the top of a Test { ... } file so the test body can reach @testable private members of the enclosing module (e.g. sq <- Math$.test_sq). Set while transpiling a module body in a test build; empty otherwise. Not serialised.

self_type: Option<Type>

Self:{ ... } (generic_constructor.md): the type bound to the enclosing function/method’s first parameter, set only while type-checking that function’s body. None everywhere else, which is what makes Self invalid outside a function body.

expected_return_type: Option<Type>

The declared return type of the function whose body is currently being type-checked (audit_type_checking.md C1) — lets Lang::Return compare an early return against the same target the trailing expression is checked against in function(). None outside a function body.

module_inner_contexts: HashMap<String, Arc<Context>>

Inner typing contexts computed while type-checking each module M { ... } body, keyed by module name. Populated during type-checking; consumed during transpilation to avoid re-running typing() on every module body.

processed_modules: HashMap<String, Type>

Cache of fully type-checked modules. Maps module name → its Type::Module so that use Module::*; can be resolved without re-walking the module path in the variable table. Populated by eval() for Lang::Module and consumed by typing() for Lang::UseModule.

modules_in_progress: HashSet<String>

Set of module names whose body is currently being type-checked. Used to detect circular import chains at the type-checking level. A Lang::UseModule targeting a name in this set is a cycle error.

extern_fns: Vec<(String, Option<String>)>

Registry of @extern function declarations: (TypR name, R-side qualified name). When Option<String> is None the TypR name is used directly as the R call.

import_from_fns: Vec<(String, String)>

Registry of @importFrom declarations: (TypR function name, “pkg::fn_name”). At call sites the transpiler emits pkg::fn_name(args) instead of fn_name(args), bypassing TypR’s own S3 generic stubs for names like get, map, factor.

signature_fns: Vec<String>

Names declared signature-only (@name: T;), i.e. typed here but implemented in R somewhere else — base R, a package, or hand-written R. Unlike an ordinary let, such a name has no TypR body to transpile into name.<Type> methods, so shadowing it with a UseMethod stub strands whatever R implementation it was declared for. typr build reads this to tell the two cases apart when deciding whether a missing <name>.default is worth reporting (see r_name_lint).

vectorizable_fns: Vec<(String, bool)>

Static vectorizability of user-declared functions, keyed by name: true means every declaration seen so far for that name has a body made only of natively-vectorized R operations (see processes::type_checking::vectorizability), so a Vec[N, T] call site may call it directly instead of wrapping it in vapply. Any non-vectorizable overload of the same name downgrades the entry to false for good (S3 dispatch at the call site can’t tell overloads apart by name alone).

Implementations

impl Context

pub fn fingerprint(&self) -> u64

Order-stable hash of everything in the context that can influence how a subsequent expression is typed or transpiled.

impl Context

pub fn new(types: Vec<(Var, Type)>) -> Context

pub fn empty() -> Self

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

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

Whether name was introduced by a signature declaration (@name: T;) rather than by a TypR definition with a body.

pub fn get_extern_r_name(&self, name: &str) -> Option<String>

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

pub fn get_import_from_r_name(&self, name: &str) -> Option<String>

pub fn register_vectorizable_fn(self, name: &str, is_vectorizable: bool) -> Self

Record whether a user function declaration has a natively-vectorizable body. A name is only vectorizable while every declaration seen for it is — one non-vectorizable overload downgrades the entry permanently.

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

pub fn set_config(self, config: Config) -> Self

pub fn set_as_module_context(self) -> Context

pub fn set_test_mode(self, val: bool) -> Context

pub fn get_test_mode(&self) -> bool

pub fn set_checked_mode(self, val: bool) -> Context

pub fn get_checked_mode(&self) -> bool

pub fn set_test_preamble(self, lines: Vec<String>) -> Context

pub fn set_self_type(self, self_type: Option<Type>) -> Context

Self:{ ... } (generic_constructor.md §4.1): bind/clear the type denoted by Self for the duration of typing a function body.

pub fn set_expected_return_type( self, expected_return_type: Option<Type>, ) -> Context

Bind/clear the declared return type of the function whose body is currently being type-checked (audit_type_checking.md C1).

pub fn get_expected_return_type(&self) -> Option<Type>

pub fn store_module_inner_context(self, name: &str, inner: &Context) -> Self

pub fn get_module_inner_context(&self, name: &str) -> Option<&Context>

pub fn mark_module_in_progress(self, name: &str) -> Self

Mark a module as currently being type-checked. Returns the updated context with name added to modules_in_progress.

pub fn unmark_module_in_progress(self, name: &str) -> Self

Remove a module from the in-progress set after its body has been fully type-checked.

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

True when name is currently being type-checked (its body is on the call stack). A use {name}::*; encountered while this returns true is a circular dependency.

pub fn cache_processed_module(self, name: &str, module_type: Type) -> Self

Register module_type in the processed-module cache so that subsequent use {name}::*; directives can resolve it without walking the full variable-path chain.

pub fn get_processed_module(&self, name: &str) -> Option<&Type>

Look up a previously cached module by name. Returns Some(module_type) when name has already been fully type-checked in this session.

pub fn set_in_module_body(self) -> Self

pub fn is_in_module_body(&self) -> bool

pub fn set_in_loop(self, val: bool) -> Self

See Config::in_loop — set while type-checking the body of a Loop/WhileLoop/ForLoop so break/next inside it are valid.

pub fn is_in_loop(&self) -> bool

pub fn with_subtypes(self, subtypes: Graph<Type>) -> Self

Retourne un nouveau Context avec le Graph de sous-typage mis à jour

pub fn get_members(&self) -> Vec<(Var, Type)>

pub fn variable_exist(&self, var: Var) -> Option<Var>

pub fn get_type_from_variable(&self, var: &Var) -> Result<Type, String>

pub fn get_types_from_name(&self, name: &str) -> Vec<Type>

pub fn get_type_from_aliases(&self, var: &Var) -> Option<Type>

pub fn find_alias_source_module(&self, name: &str) -> Option<String>

Search every module currently in scope (declared via module M { ... } somewhere visible, whether or not any of its members were ever brought in via use) for a public alias named name. Returns the module’s name on a hit — used to tell “genuinely undefined alias” apart from “exists, but this file never imported it” so the error can point at the fix (use M::Name;) instead of just saying “not defined”.

pub fn find_variable_source_module(&self, name: &str) -> Option<(String, bool)>

Same idea as find_alias_source_module, but for ordinary names (variables and functions) rather than type aliases. Scans every module currently in scope for a member named name, checking public members first, then private ones — returns (module_name, is_public) on a hit. A private hit still points the error at use M::name; (per the fix this supports): the member exists and this is where it lives, even though that particular use will itself fail with PrivateImport until the declaration gains @pub/@export.

pub fn get_matching_alias_signature( &self, var: &Var, ) -> Option<(Type, Vec<Type>)>

pub fn variables(&self) -> impl Iterator<Item = &(Var, Type)> + '_

pub fn aliases(&self) -> impl Iterator<Item = &(Var, Type)> + '_

pub fn fresh_rigid_name(self) -> (String, Self)

Generate a fresh rigid generic variable name (immutable builder pattern).

pub fn add_interface_constraint( self, rigid_name: String, interface: Type, ) -> Context

Register a constraint: rigid variable → interface type.

pub fn get_interface_constraint(&self, name: &str) -> Option<&Type>

Look up the interface constraint for a rigid variable.

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

Check if a name is a constrained rigid variable.

pub fn push_var_type(self, lang: Var, typ: Type, context: &Context) -> Context

pub fn replace_or_push_var_type( self, lang: Var, typ: Type, context: &Context, ) -> Context

pub fn remove_vars(self, vars: &[Var]) -> Context

pub fn push_types(self, types: &[Type]) -> Self

pub fn hoist_aliases(self, inner: &Context) -> Self

Hoists auto-generated type-alias registrations from an inner scope’s context (function body, module body) into this one — see VarType::hoist_aliases. The hoisted types are also added to the subtype graph so structural supertype lookups (S3 class chains) keep working outside the scope that registered them.

pub fn get_type_from_existing_variable(&self, var: Var) -> Type

pub fn get_true_variable(&self, var: &Var) -> Var

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

pub fn atomic_array_elem(&self, t: &Type) -> Option<Type>

Step ③ (unification_arrays.md): does t denote an array with the bare-atomic-vector runtime representation? See VarType::atomic_array_elem — the single representation predicate.

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

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

pub fn module_aliases(&self) -> Vec<(Var, Type)>

pub fn get_type_anotations(&self) -> String

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

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

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

Does name resolve (through alias hops) to the stdlib Foreign<T> alias? See VarType::resolves_to_foreign / get_type_anotation for the rationale (soundness_transpilation.md Phase D).

pub fn get_classes(&self, t: &Type) -> Option<String>

pub fn get_functions(&self, var1: Var) -> Vec<(Var, Type)>

pub fn get_all_generic_functions(&self) -> Vec<(Var, Type)>

pub fn get_first_matching_function(&self, var1: Var) -> Type

pub fn get_matching_typed_functions(&self, var1: Var) -> Vec<Type>

pub fn get_matching_untyped_functions( &self, var: Var, ) -> Result<Vec<Type>, String>

pub fn get_matching_functions(&self, var: Var) -> Result<Vec<Type>, String>

pub fn get_type_from_class(&self, class: &str) -> Type

pub fn add_arg_types(&self, params: &[ArgumentType]) -> Context

pub fn set_environment(&self, e: Environment) -> Context

pub fn display_typing_context(&self) -> String

pub fn error(&self, msg: String) -> String

pub fn push_alias(self, alias_name: String, typ: Type) -> Self

pub fn push_type_constructor( self, name: String, parameters: Vec<Type>, category: ConstructorCategory, ) -> Self

Register a user-declared typeconstructor in the registry.

pub fn get_type_constructor( &self, name: &str, ) -> Option<&(String, Vec<Type>, ConstructorCategory)>

Look up a declared typeconstructor by name.

pub fn push_record_alias(self, name: String, typ: Type) -> Self

Register a type X <- list { ... } record alias in the whole-program registry, regardless of the current module scope. No-op for non-record aliases. Last declaration for a given name wins.

pub fn merge_record_aliases(self, other: &Context) -> Self

Merge another context’s whole-program record-alias registry into this one. Used at module boundaries, where the rest of the inner typing context is intentionally discarded for encapsulation but this registry must still bubble up (see Lang::Module in processes::type_checking).

pub fn push_embedded_method( self, type_name: String, method_name: String, field_name: String, ) -> Self

Record that method_name on type_name was auto-generated by named type embedding (embed field: Type), forwarded from field_name. See processes::type_checking::embedding.

pub fn get_embedded_method( &self, type_name: &str, method_name: &str, ) -> Option<String>

If method_name on type_name was inherited via named type embedding, return the source field name it was forwarded from.

pub fn push_alias2(self, alias_var: Var, typ: Type) -> Self

pub fn in_a_project(&self) -> bool

pub fn get_unification_map( &self, entered_types: &[Type], param_types: &[Type], ) -> Option<UnificationMap>

pub fn get_related_functions( &self, typ: &Type, functions: &VarFunction, ) -> Vec<Lang>

pub fn get_functions_from_type(&self, typ: &Type) -> Vec<(Var, Type)>

pub fn get_functions_from_name(&self, name: &str) -> Vec<(Var, Type)>

pub fn get_type_definition(&self, _functions: &VarFunction) -> String

pub fn update_variable(self, var: Var) -> Self

pub fn set_target_language(self, language: TargetLanguage) -> Self

pub fn set_default_var_types(self) -> Self

pub fn get_target_language(&self) -> TargetLanguage

pub fn set_new_aliase_signature(self, alias: &str, related_type: Type) -> Self

pub fn extract_module_as_vartype(&self, module_name: &str) -> Self

pub fn get_vartype(&self) -> VarType

pub fn get_environment(&self) -> Environment

pub fn extend_typing_context(self, var_types: VarType) -> Self

Trait Implementations

impl Add for Context

type Output = Context

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self::Output

Performs the + operation.

impl Clone for Context

fn clone(&self) -> Context

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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<'de> Deserialize<'de> for Context

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Context> for Translatable

fn from(val: Context) -> Self

Converts to this type from the input type.

impl From<Vec<(Lang, Type)>> for Context

fn from(val: Vec<(Lang, Type)>) -> Self

Converts to this type from the input type.

impl PartialEq for Context

fn eq(&self, other: &Context) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Context

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Context