Struct EvalContext 

pub struct EvalContext { /* private fields */ }

Evaluation context for a REPL session

Manages session state, execution tiers, and caching.

Architecture

Uses Arc<Mutex<>> for components that need shared mutable state:

• ArtifactCache: Shared persistent cache across clones
• CachedCompiler: Shared compilation state
• SubprocessExecutor: Single subprocess per session (not cloned)
• SessionDir: Shared session directory

Implementations

impl EvalContext

pub fn new(session_id: SessionId, mode: ReplMode) -> Self

Create a new evaluation context

Examples

use oxur_repl::eval::EvalContext;
use oxur_repl::protocol::{ReplMode, SessionId};

let ctx = EvalContext::new(SessionId::new("session-1"), ReplMode::Lisp);

pub fn with_compilation(session_id: SessionId, mode: ReplMode) -> Result<Self>

Create a new evaluation context with full compilation pipeline

Initializes all Tier 2/3 components for actual compilation and execution.

Errors

Returns error if:

• Session directory cannot be created
• Artifact cache cannot be initialized
• Subprocess cannot be spawned

pub fn session_id(&self) -> &SessionId

Get the session ID

pub fn mode(&self) -> ReplMode

Get the evaluation mode

pub fn stats(&self) -> (u64, u64, u64)

Get execution statistics (legacy method for backward compatibility)

Returns (tier1_count, tier2_count, cache_hits) Note: tier2_count includes both CachedLoaded and JustInTime tiers for backward compatibility

pub fn stats_collector(&self) -> Arc<Mutex<EvalMetrics>>

Get the statistics collector

Returns a shared reference to the stats collector for detailed metrics access.

pub fn usage_metrics(&self) -> Arc<Mutex<UsageMetrics>>

Get the usage metrics collector

Returns a shared reference to the usage metrics collector for command frequency tracking.

pub fn clone_to(&self, new_session_id: SessionId) -> Self

Clone this context into a new session

Creates a new context with a different session ID but the same cache and state. Resets execution statistics.

Note: Shared components (Arc<Mutex<>>) are cloned (reference counted), so they share state across clones.

pub async fn eval(&mut self, code: impl AsRef<str>) -> Result<EvalResult>

Evaluate code in this context

Uses tiered execution strategy:

• Tier 1 (Calculator): Simple arithmetic literals only
• Tier 2 (Cached Compilation): Everything else
• Hybrid: Calculator variables accessible in compiled code

Errors

Returns EvalError if evaluation fails due to:

• SyntaxError: Invalid syntax in the input code
• TypeError: Type mismatch or invalid type operations
• RuntimeError: Runtime errors during execution
• CompilationError: Failed to compile to executable code
• UnsupportedOperation: Operation not supported in current tier

pub fn clear_cache(&mut self)

Clear the compilation cache

pub fn cache_size(&self) -> usize

Get cache size

pub fn session_dir_stats(&self) -> Option<DirStats>

Get session directory statistics

Returns information about files and disk usage in the session’s temporary directory. Returns None if the session directory is not initialized.

pub fn artifact_cache_stats(&self) -> Option<CacheStats>

Get artifact cache statistics

Returns detailed statistics about the global artifact cache including entry count, total size, and oldest/newest entries. Returns None if artifact cache is not initialized.

pub fn subprocess_stats(&self) -> Option<SubprocessMetricsSnapshot>

Get subprocess metrics snapshot.

Returns metrics about the subprocess executor including restart count, uptime, and last restart reason.

pub fn infer_types(&self, code: impl AsRef<str>) -> Vec<(String, String, bool)>

Infer types from Rust code

Parses the provided Rust code and extracts type information for all variable declarations. This can be used to implement the :type REPL command.

Arguments

• code - Rust source code to analyze

Returns

Vector of (variable_name, type_info) pairs

Examples

use oxur_repl::eval::EvalContext;
use oxur_repl::protocol::{ReplMode, SessionId};

let ctx = EvalContext::new(SessionId::new("test"), ReplMode::Lisp);

let code = r#"
    fn main() {
        let x: i32 = 42;
        let y = "hello";
    }
"#;

let types = ctx.infer_types(code);
assert_eq!(types.len(), 2);

pub fn register_variable_type( &mut self, name: impl Into<String>, type_name: impl Into<String>, is_mutable: bool, )

Register a variable’s type information

Manually register type information for a variable. This is useful for tracking types across REPL evaluations.

Arguments

• name - Variable name
• type_name - Type as a string (e.g., “i32”, “String”)
• is_mutable - Whether the variable is mutable

Examples

use oxur_repl::eval::EvalContext;
use oxur_repl::protocol::{ReplMode, SessionId};

let mut ctx = EvalContext::new(SessionId::new("test"), ReplMode::Lisp);
ctx.register_variable_type("x", "i32", false);

let type_name = ctx.get_variable_type("x");
assert_eq!(type_name, Some("i32".to_string()));

pub fn get_variable_type(&self, name: impl AsRef<str>) -> Option<String>

Get the type of a variable

Returns the type name for a previously registered variable.

Arguments

• name - Variable name

Returns

Some(type_name) if variable is tracked, None otherwise

Examples

use oxur_repl::eval::EvalContext;
use oxur_repl::protocol::{ReplMode, SessionId};

let mut ctx = EvalContext::new(SessionId::new("test"), ReplMode::Lisp);
ctx.register_variable_type("x", "i32", false);

assert_eq!(ctx.get_variable_type("x"), Some("i32".to_string()));
assert_eq!(ctx.get_variable_type("y"), None);

pub fn get_all_variable_types(&self) -> Vec<(String, String, bool)>

Get all tracked variables with their types

Returns a list of all variables currently tracked by the type inference engine along with their type information.

Returns

Vector of (variable_name, type_name, is_mutable) tuples

Examples

use oxur_repl::eval::EvalContext;
use oxur_repl::protocol::{ReplMode, SessionId};

let mut ctx = EvalContext::new(SessionId::new("test"), ReplMode::Lisp);
ctx.register_variable_type("x", "i32", false);
ctx.register_variable_type("y", "String", true);

let vars = ctx.get_all_variable_types();
assert_eq!(vars.len(), 2);

pub fn clear_type_information(&mut self)

Clear all tracked type information

Removes all tracked variable types from the type inference engine. Useful when starting a new REPL session or resetting state.

Examples

use oxur_repl::eval::EvalContext;
use oxur_repl::protocol::{ReplMode, SessionId};

let mut ctx = EvalContext::new(SessionId::new("test"), ReplMode::Lisp);
ctx.register_variable_type("x", "i32", false);
assert_eq!(ctx.get_all_variable_types().len(), 1);

ctx.clear_type_information();
assert_eq!(ctx.get_all_variable_types().len(), 0);

Trait Implementations

impl Clone for EvalContext

fn clone(&self) -> EvalContext

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EvalContext

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

Formats the value using the given formatter.