Brummel/RustAst
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor: Use root_purity instead of global_purity

Browse Source 
This commit refactors the purity analysis from using a
`HashMap<GlobalIdx, Purity>` to a `Vec<Purity>` indexed by
`GlobalIdx.0`.

This change simplifies the data structure and makes purity lookups more
efficient. The `Binder`'s `globals` field has also been removed as it
was not being used.
This commit is contained in:
Michael Schimmel
2026-03-12 16:57:06 +01:00
parent dcb7685d29
commit bf86c76bb6
8 changed files with 123 additions and 131 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/ast/compiler/analyzer.rs
+6 -6
View File
@@ -6,7 +6,7 @@ use std::collections::{HashMap, HashSet};
use std::rc::Rc;
pub struct Analyzer<'a> {
global_purity: &'a HashMap<GlobalIdx, Purity>,
root_purity: &'a [Purity],
/// Stack of currently visiting lambdas to detect direct recursion.
lambda_stack: Vec<crate::ast::types::Identity>,
/// Map of global index to its Lambda identity if known.
@@ -18,10 +18,10 @@ pub struct Analyzer<'a> {
impl<'a> Analyzer<'a> {
pub fn analyze(
node: &TypedNode,
global_purity: &'a HashMap<GlobalIdx, Purity>,
root_purity: &'a [Purity],
) -> AnalyzedNode {
let mut analyzer = Self {
global_purity,
root_purity,
lambda_stack: Vec::new(),
globals_to_lambdas: HashMap::new(),
recursive_identities: HashSet::new(),
@@ -70,7 +70,7 @@ impl<'a> Analyzer<'a> {
BoundKind::Get { addr, name } => {
let p = match addr {
Address::Global(idx) => {
self.global_purity.get(idx).cloned().unwrap_or(Purity::Pure)
self.root_purity.get(idx.0 as usize).cloned().unwrap_or(Purity::Pure)
}
_ => Purity::Pure,
};
@@ -206,8 +206,8 @@ impl<'a> Analyzer<'a> {
..
} = &callee.kind
{
self.global_purity
.get(idx)
self.root_purity
.get(idx.0 as usize)
.cloned()
.unwrap_or(Purity::Impure)
} else {
src/ast/compiler/binder.rs
+7 -26
View File
@@ -4,7 +4,6 @@ use crate::ast::compiler::bound_nodes::{
use crate::ast::diagnostics::Diagnostics;
use crate::ast::nodes::{Node, Symbol, UntypedKind};
use crate::ast::types::{Identity, StaticType, Purity};
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;
@@ -123,7 +122,6 @@ pub type BindingResult = (
pub struct Binder {
functions: Vec<FunctionCompiler>,
globals: Rc<RefCell<HashMap<Symbol, (GlobalIdx, Identity)>>>,
capture_map: HashMap<Identity, std::collections::HashSet<Identity>>,
fixed_scope_idx: i32,
}
@@ -133,11 +131,9 @@ impl Binder {
initial_scopes: Vec<CompilerScope>,
initial_slot_count: u32,
fixed_scope_idx: i32,
globals: Rc<RefCell<HashMap<Symbol, (GlobalIdx, Identity)>>>,
) -> Self {
let mut binder = Self {
functions: Vec::new(),
globals,
capture_map: HashMap::new(),
fixed_scope_idx,
};
@@ -156,11 +152,10 @@ impl Binder {
initial_scopes: Vec<CompilerScope>,
initial_slot_count: u32,
fixed_scope_idx: i32,
globals: Rc<RefCell<HashMap<Symbol, (GlobalIdx, Identity)>>>,
node: &Node<UntypedKind>,
diagnostics: &mut Diagnostics,
) -> Result<BindingResult, String> {
let mut binder = Self::new(initial_scopes, initial_slot_count, fixed_scope_idx, globals);
let mut binder = Self::new(initial_scopes, initial_slot_count, fixed_scope_idx);
let bound = binder.bind(node, ExprContext::Expression, diagnostics);
let final_captures = binder
@@ -580,13 +575,7 @@ impl Binder {
}
}
// 3. Global Fallback
let globals = self.globals.borrow();
if let Some((idx, _)) = globals.get(sym) {
return Some(Address::Global(*idx));
}
// 4. Global Fallback (search in root level with context removed)
// 3. Global Fallback (search in root level with context removed)
if sym.context.is_some() {
let fallback_sym = Symbol {
name: sym.name.clone(),
@@ -600,9 +589,6 @@ impl Binder {
return Some(info.addr);
}
}
if let Some((idx, _)) = globals.get(&fallback_sym) {
return Some(Address::Global(*idx));
}
}
diag.push_error(
@@ -719,9 +705,8 @@ mod tests {
let mut parser = Parser::new(source);
let untyped = parser.parse_expression();
let globals = Rc::new(RefCell::new(HashMap::new()));
let mut diagnostics = Diagnostics::new();
let (bound, captures, _scopes, _slots) = Binder::bind_root(vec![], 0, 0, globals, &untyped, &mut diagnostics).unwrap();
let (bound, captures, _scopes, _slots) = Binder::bind_root(vec![], 0, 0, &untyped, &mut diagnostics).unwrap();
if let BoundKind::Lambda { body, .. } = &bound.kind {
if let BoundKind::Block { exprs } = &body.kind {
@@ -749,9 +734,8 @@ mod tests {
let mut parser = Parser::new(source);
let untyped = parser.parse_expression();
let globals = Rc::new(RefCell::new(HashMap::new()));
let mut diagnostics = Diagnostics::new();
let (bound, captures, _scopes, _slots) = Binder::bind_root(vec![], 0, 0, globals, &untyped, &mut diagnostics).unwrap();
let (bound, captures, _scopes, _slots) = Binder::bind_root(vec![], 0, 0, &untyped, &mut diagnostics).unwrap();
if let BoundKind::Lambda { body, .. } = &bound.kind {
if let BoundKind::Block { exprs } = &body.kind {
@@ -779,9 +763,8 @@ mod tests {
let mut parser = Parser::new(source);
let untyped = parser.parse_expression();
let globals = Rc::new(RefCell::new(HashMap::new()));
let mut diagnostics = Diagnostics::new();
let _ = Binder::bind_root(vec![], 0, 0, globals, &untyped, &mut diagnostics);
let _ = Binder::bind_root(vec![], 0, 0, &untyped, &mut diagnostics);
assert!(diagnostics.has_errors());
assert!(diagnostics.items.iter().any(|i| i.message.contains("already defined")));
@@ -789,18 +772,16 @@ mod tests {
#[test]
fn test_repro_global_redefinition() {
let globals = Rc::new(RefCell::new(HashMap::new()));
let source1 = "(def x 1) 1";
let untyped1 = Parser::new(source1).parse_expression();
let mut diagnostics = Diagnostics::new();
let (_, _, scopes1, slots1) = Binder::bind_root(vec![], 0, -1, globals.clone(), &untyped1, &mut diagnostics).unwrap();
let (_, _, scopes1, slots1) = Binder::bind_root(vec![], 0, -1, &untyped1, &mut diagnostics).unwrap();
let source2 = "(def x 2) 2";
let untyped2 = Parser::new(source2).parse_expression();
let mut diagnostics2 = Diagnostics::new();
// Here we simulate frozen scope by passing fixed_scope_idx = 0
let _ = Binder::bind_root(scopes1, slots1, 0, globals.clone(), &untyped2, &mut diagnostics2);
let _ = Binder::bind_root(scopes1, slots1, 0, &untyped2, &mut diagnostics2);
assert!(diagnostics2.has_errors());
assert!(diagnostics2.items.iter().any(|i| i.message.contains("frozen/immutable")));
src/ast/compiler/macros.rs
+3 -4
View File
@@ -627,7 +627,6 @@ mod tests {
use crate::ast::compiler::Binder;
use crate::ast::parser::Parser;
use crate::ast::types::{Object, Value};
use std::cell::RefCell;
struct SimpleEvaluator;
impl MacroEvaluator for SimpleEvaluator {
@@ -783,7 +782,7 @@ mod tests {
let mut diag = crate::ast::diagnostics::Diagnostics::new();
// fixed_scope_idx = 0 means scope 0 is frozen (Global)
let result = Binder::bind_root(initial_scopes, 1, 0, Rc::new(RefCell::new(HashMap::new())), &expanded, &mut diag);
let result = Binder::bind_root(initial_scopes, 1, 0, &expanded, &mut diag);
assert!(
result.is_ok(),
"Should find global '*' Error: {:?}",
@@ -807,7 +806,7 @@ mod tests {
let expanded = expander.expand(untyped).unwrap();
let mut diag = crate::ast::diagnostics::Diagnostics::new();
let result = Binder::bind_root(vec![], 0, 0, Rc::new(RefCell::new(HashMap::new())), &expanded, &mut diag);
let result = Binder::bind_root(vec![], 0, 0, &expanded, &mut diag);
assert!(result.is_ok(), "Hygiene failed: {:?}", result.err());
}
@@ -827,7 +826,7 @@ mod tests {
let expanded = expander.expand(untyped).unwrap();
let mut diag = crate::ast::diagnostics::Diagnostics::new();
let result = Binder::bind_root(vec![], 0, 0, Rc::new(RefCell::new(HashMap::new())), &expanded, &mut diag);
let result = Binder::bind_root(vec![], 0, 0, &expanded, &mut diag);
assert!(
result.is_ok(),
"Explicit Hygiene with Backticks failed: {:?}",
src/ast/compiler/optimizer/engine.rs
+13 -12
View File
@@ -1,11 +1,10 @@
use crate::ast::compiler::bound_nodes::{
Address, AnalyzedNode, BoundKind, GlobalAnalyzedRegistry, GlobalIdx, UpvalueIdx,
Address, AnalyzedNode, BoundKind, GlobalAnalyzedRegistry, UpvalueIdx,
};
use crate::ast::nodes::Node;
use crate::ast::types::{Purity, Value};
use crate::ast::vm::Closure;
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;
use super::folder::Folder;
@@ -17,7 +16,7 @@ pub struct Optimizer {
pub enabled: bool,
max_passes: usize,
pub globals: Option<Rc<RefCell<Vec<Value>>>>,
pub global_purity: Option<Rc<RefCell<HashMap<GlobalIdx, Purity>>>>,
pub root_purity: Option<Rc<RefCell<Vec<Purity>>>>,
pub lambda_registry: Option<Rc<RefCell<GlobalAnalyzedRegistry>>>,
}
@@ -27,7 +26,7 @@ impl Optimizer {
enabled,
max_passes: 5,
globals: None,
global_purity: None,
root_purity: None,
lambda_registry: None,
}
}
@@ -37,8 +36,8 @@ impl Optimizer {
self
}
pub fn with_purity(mut self, purity: Rc<RefCell<HashMap<GlobalIdx, Purity>>>) -> Self {
self.global_purity = Some(purity);
pub fn with_purity(mut self, purity: Rc<RefCell<Vec<Purity>>>) -> Self {
self.root_purity = Some(purity);
self
}
@@ -79,7 +78,7 @@ impl Optimizer {
path: &mut PathTracker,
base_sub: Option<SubstitutionMap>,
) -> Option<Rc<AnalyzedNode>> {
let inliner = Inliner::new(&self.globals, &self.global_purity);
let inliner = Inliner::new(&self.globals, &self.root_purity);
let mut inner_sub = base_sub.unwrap_or_else(|| sub.new_for_inlining());
if inliner.prepare_beta_reduction(params, arg_nodes, body, &mut inner_sub).is_some() {
@@ -105,7 +104,7 @@ impl Optimizer {
) -> Rc<AnalyzedNode> {
let node = &*node_rc;
let folder = Folder::new(&self.globals);
let inliner = Inliner::new(&self.globals, &self.global_purity);
let inliner = Inliner::new(&self.globals, &self.root_purity);
let (new_kind, metrics) = match &node.kind {
BoundKind::Get { addr, name } => {
@@ -215,11 +214,13 @@ impl Optimizer {
if let Address::Global(global_index) = addr
&& value_opt.ty.purity > Purity::Impure
&& let Some(purity_rc) = &self.global_purity
&& let Some(purity_rc) = &self.root_purity
{
purity_rc
.borrow_mut()
.insert(*global_index, value_opt.ty.purity);
let mut pr = purity_rc.borrow_mut();
let idx = global_index.0 as usize;
if idx < pr.len() {
pr[idx] = value_opt.ty.purity;
}
}
if Rc::ptr_eq(&value_opt, value) {
src/ast/compiler/optimizer/inliner.rs
+7 -7
View File
@@ -1,8 +1,8 @@
use crate::ast::compiler::bound_nodes::{Address, AnalyzedNode, BoundKind, GlobalIdx, LocalSlot};
use crate::ast::compiler::bound_nodes::{Address, AnalyzedNode, BoundKind, LocalSlot};
use crate::ast::types::{Purity, Value};
use crate::ast::vm::Closure;
use std::cell::RefCell;
use std::collections::{HashMap, HashSet};
use std::collections::HashSet;
use std::rc::Rc;
use super::substitution_map::SubstitutionMap;
@@ -10,17 +10,17 @@ use super::utils::UsageInfo;
pub struct Inliner<'a> {
pub globals: &'a Option<Rc<RefCell<Vec<Value>>>>,
pub global_purity: &'a Option<Rc<RefCell<HashMap<GlobalIdx, Purity>>>>,
pub root_purity: &'a Option<Rc<RefCell<Vec<Purity>>>>,
}
impl<'a> Inliner<'a> {
pub fn new(
globals: &'a Option<Rc<RefCell<Vec<Value>>>>,
global_purity: &'a Option<Rc<RefCell<HashMap<GlobalIdx, Purity>>>>,
root_purity: &'a Option<Rc<RefCell<Vec<Purity>>>>,
) -> Self {
Self {
globals,
global_purity,
root_purity,
}
}
@@ -48,10 +48,10 @@ impl<'a> Inliner<'a> {
}
if let Address::Global(idx) = addr {
if let Some(purity_rc) = &self.global_purity {
if let Some(purity_rc) = &self.root_purity {
let purity = purity_rc
.borrow()
.get(&idx)
.get(idx.0 as usize)
.cloned()
.unwrap_or(Purity::Impure);
return purity >= Purity::Pure;
src/ast/compiler/type_checker.rs
+18 -16
View File
@@ -1,8 +1,7 @@
use crate::ast::compiler::bound_nodes::{Address, BoundKind, BoundNode, GlobalIdx, TypedNode};
use crate::ast::compiler::bound_nodes::{Address, BoundKind, BoundNode, TypedNode};
use crate::ast::diagnostics::Diagnostics;
use crate::ast::nodes::Node;
use crate::ast::types::StaticType;
use std::collections::HashMap;
use std::rc::Rc;
/// Manages the types of locals and upvalues during a single type-checking pass.
@@ -12,8 +11,8 @@ struct TypeContext<'a> {
slots: Vec<StaticType>,
/// Types of captured variables (passed from outer scope)
upvalue_types: Vec<StaticType>,
/// Access to global types for unified resolution
global_types: &'a std::cell::RefCell<HashMap<GlobalIdx, StaticType>>,
/// Access to root types for unified resolution
root_types: &'a std::cell::RefCell<Vec<StaticType>>,
/// The expected parameters of the current function (for 'again' validation)
current_params_ty: Option<StaticType>,
}
@@ -22,14 +21,14 @@ impl<'a> TypeContext<'a> {
fn new(
slot_count: u32,
upvalue_types: Vec<StaticType>,
global_types: &'a std::cell::RefCell<HashMap<GlobalIdx, StaticType>>,
root_types: &'a std::cell::RefCell<Vec<StaticType>>,
parent: Option<&'a TypeContext<'a>>,
) -> Self {
Self {
_parent: parent,
slots: vec![StaticType::Any; slot_count as usize],
upvalue_types,
global_types,
root_types,
current_params_ty: None,
}
}
@@ -42,9 +41,9 @@ impl<'a> TypeContext<'a> {
.cloned()
.unwrap_or(StaticType::Any),
Address::Global(idx) => self
.global_types
.root_types
.borrow()
.get(&idx)
.get(idx.0 as usize)
.cloned()
.unwrap_or(StaticType::Any),
Address::Upvalue(idx) => self
@@ -63,7 +62,10 @@ impl<'a> TypeContext<'a> {
}
}
Address::Global(idx) => {
self.global_types.borrow_mut().insert(idx, ty);
let mut rt = self.root_types.borrow_mut();
if (idx.0 as usize) < rt.len() {
rt[idx.0 as usize] = ty;
}
}
_ => {}
}
@@ -71,12 +73,12 @@ impl<'a> TypeContext<'a> {
}
pub struct TypeChecker {
global_types: Rc<std::cell::RefCell<HashMap<GlobalIdx, StaticType>>>,
root_types: Rc<std::cell::RefCell<Vec<StaticType>>>,
}
impl TypeChecker {
pub fn new(global_types: Rc<std::cell::RefCell<HashMap<GlobalIdx, StaticType>>>) -> Self {
Self { global_types }
pub fn new(root_types: Rc<std::cell::RefCell<Vec<StaticType>>>) -> Self {
Self { root_types }
}
pub fn check(
@@ -99,9 +101,9 @@ impl TypeChecker {
}
// 2. Create the specialized context
let root_ctx = TypeContext::new(0, vec![], &self.global_types, None);
let root_ctx = TypeContext::new(0, vec![], &self.root_types, None);
let mut lambda_ctx =
TypeContext::new(64, upvalue_types, &self.global_types, Some(&root_ctx));
TypeContext::new(64, upvalue_types, &self.root_types, Some(&root_ctx));
// 3. INJECT specialized argument types into slots
let arg_tuple_ty = if arg_types.is_empty() {
@@ -141,7 +143,7 @@ impl TypeChecker {
}
}
_ => {
let mut root_ctx = TypeContext::new(0, vec![], &self.global_types, None);
let mut root_ctx = TypeContext::new(0, vec![], &self.root_types, None);
self.check_node(node, &mut root_ctx, diag)
}
}
@@ -484,7 +486,7 @@ impl TypeChecker {
// 2. Create nested context for lambda body
let mut lambda_ctx =
TypeContext::new(64, upvalue_types, ctx.global_types, Some(ctx));
TypeContext::new(64, upvalue_types, ctx.root_types, Some(ctx));
// 3. Check parameters and body
let params_typed = self.check_params(
src/ast/environment.rs
+68 -59
View File
@@ -21,7 +21,7 @@ use crate::ast::compiler::optimizer::Optimizer;
use crate::ast::compiler::specializer::{FunctionRegistry, MonoCache, Specializer};
use crate::ast::rtl::intrinsics;
use crate::ast::types::{
Identity, NodeIdentity, Object, Purity, SourceLocation, StaticType, Value,
NodeIdentity, Object, Purity, SourceLocation, StaticType, Value,
};
use crate::ast::diagnostics::{DiagnosticLevel, Diagnostics};
@@ -71,10 +71,9 @@ impl CompilationResult {
}
pub struct Environment {
pub global_names: Rc<RefCell<HashMap<Symbol, (GlobalIdx, Identity)>>>,
pub global_types: Rc<RefCell<HashMap<GlobalIdx, StaticType>>>,
pub global_purity: Rc<RefCell<HashMap<GlobalIdx, Purity>>>,
pub global_values: Rc<RefCell<Vec<Value>>>,
pub root_types: Rc<RefCell<Vec<StaticType>>>,
pub root_purity: Rc<RefCell<Vec<Purity>>>,
pub root_values: Rc<RefCell<Vec<Value>>>,
pub fixed_scope_idx: i32,
pub root_scopes: Rc<RefCell<Vec<crate::ast::compiler::binder::CompilerScope>>>,
pub root_slot_count: Rc<RefCell<u32>>,
@@ -112,11 +111,11 @@ impl FunctionRegistry for EnvFunctionRegistry {
}
struct RuntimeMacroEvaluator {
global_names: Rc<RefCell<HashMap<Symbol, (GlobalIdx, Identity)>>>,
root_scopes: Rc<RefCell<Vec<crate::ast::compiler::binder::CompilerScope>>>,
root_slot_count: Rc<RefCell<u32>>,
global_types: Rc<RefCell<HashMap<GlobalIdx, StaticType>>>,
global_values: Rc<RefCell<Vec<Value>>>,
root_types: Rc<RefCell<Vec<StaticType>>>,
root_values: Rc<RefCell<Vec<Value>>>,
root_purity: Rc<RefCell<Vec<Purity>>>,
fixed_scope_idx: i32,
}
@@ -136,9 +135,9 @@ impl MacroEvaluator for RuntimeMacroEvaluator {
let initial_scopes = self.root_scopes.borrow().clone();
let initial_slot_count = *self.root_slot_count.borrow();
let (bound_ast, captures, _, _) = Binder::bind_root(initial_scopes, initial_slot_count, self.fixed_scope_idx, self.global_names.clone(), node, &mut diag)?;
let (bound_ast, captures, _, _) = Binder::bind_root(initial_scopes, initial_slot_count, self.fixed_scope_idx, node, &mut diag)?;
let bound_ast = crate::ast::compiler::captures::CapturePass::apply(bound_ast, &captures);
let checker = TypeChecker::new(self.global_types.clone());
let checker = TypeChecker::new(self.root_types.clone());
let typed_ast = checker.check(&bound_ast, &[], &mut diag);
if diag.has_errors() {
@@ -150,9 +149,9 @@ impl MacroEvaluator for RuntimeMacroEvaluator {
.join("\n"));
}
let exec_ast = Lowering::lower(Analyzer::analyze(&typed_ast, &HashMap::new())); // Minimal analysis for macro eval
let exec_ast = Lowering::lower(Analyzer::analyze(&typed_ast, &self.root_purity.borrow())); // Minimal analysis for macro eval
let mut vm = VM::new(self.global_values.clone());
let mut vm = VM::new(self.root_values.clone());
vm.run(&exec_ast)
}
}
@@ -166,10 +165,9 @@ impl Default for Environment {
impl Environment {
pub fn new() -> Self {
let env = Self {
global_names: Rc::new(RefCell::new(HashMap::new())),
global_types: Rc::new(RefCell::new(HashMap::new())),
global_purity: Rc::new(RefCell::new(HashMap::new())),
global_values: Rc::new(RefCell::new(Vec::new())),
root_types: Rc::new(RefCell::new(Vec::new())),
root_purity: Rc::new(RefCell::new(Vec::new())),
root_values: Rc::new(RefCell::new(Vec::new())),
fixed_scope_idx: -1,
root_scopes: Rc::new(RefCell::new(vec![crate::ast::compiler::binder::CompilerScope::new()])),
root_slot_count: Rc::new(RefCell::new(0)),
@@ -226,11 +224,11 @@ impl Environment {
fn get_expander(&self) -> MacroExpander<RuntimeMacroEvaluator> {
let evaluator = RuntimeMacroEvaluator {
global_names: self.global_names.clone(),
root_scopes: self.root_scopes.clone(),
root_slot_count: self.root_slot_count.clone(),
global_types: self.global_types.clone(),
global_values: self.global_values.clone(),
root_types: self.root_types.clone(),
root_values: self.root_values.clone(),
root_purity: self.root_purity.clone(),
fixed_scope_idx: self.fixed_scope_idx,
};
MacroExpander::new(self.macro_registry.borrow().clone(), evaluator)
@@ -459,7 +457,7 @@ impl Environment {
let initial_slot_count = *self.root_slot_count.borrow();
let (bound_ast, captures, final_scopes, final_slot_count) =
match Binder::bind_root(initial_scopes, initial_slot_count, self.fixed_scope_idx, self.global_names.clone(), &expanded_ast, diagnostics) {
match Binder::bind_root(initial_scopes, initial_slot_count, self.fixed_scope_idx, &expanded_ast, diagnostics) {
Ok(res) => res,
Err(e) => {
diagnostics.push_error(e, None);
@@ -475,7 +473,7 @@ impl Environment {
// Pre-allocate global slots to prevent out-of-bounds during specialization/optimization
{
let mut values = self.global_values.borrow_mut();
let mut values = self.root_values.borrow_mut();
let count = *self.root_slot_count.borrow();
if (count as usize) > values.len() {
values.resize(count as usize, Value::Void);
@@ -484,7 +482,7 @@ impl Environment {
LambdaCollector::collect(&bound_ast, &mut self.function_registry.borrow_mut());
let checker = TypeChecker::new(self.global_types.clone());
let checker = TypeChecker::new(self.root_types.clone());
let wrapped_ast = if let crate::ast::compiler::bound_nodes::BoundKind::Lambda { .. } = bound_ast.kind {
bound_ast
} else {
@@ -529,19 +527,13 @@ impl Environment {
ty: StaticType,
func: Rc<crate::ast::types::NativeFunction>,
) {
let mut names = self.global_names.borrow_mut();
let mut types = self.global_types.borrow_mut();
let mut values = self.global_values.borrow_mut();
let mut purity = self.global_purity.borrow_mut();
let mut types = self.root_types.borrow_mut();
let mut values = self.root_values.borrow_mut();
let mut purity = self.root_purity.borrow_mut();
let idx = GlobalIdx(values.len() as u32);
let identity = NodeIdentity::new(SourceLocation { line: 0, col: 0 });
names.insert(Symbol::from(name), (idx, identity.clone()));
types.insert(idx, ty.clone());
purity.insert(idx, func.purity);
values.push(Value::Function(func.clone()));
// Parallel mode: populate root_scopes[0]
// populate root_scopes[0]
let mut root_scopes = self.root_scopes.borrow_mut();
let mut slot_count = self.root_slot_count.borrow_mut();
let slot = crate::ast::compiler::bound_nodes::LocalSlot(*slot_count);
@@ -550,11 +542,23 @@ impl Environment {
crate::ast::compiler::binder::LocalInfo {
addr: Address::Global(GlobalIdx(slot.0)),
identity,
_ty: ty,
_ty: ty.clone(),
purity: func.purity,
},
);
*slot_count += 1;
// Ensure arrays are large enough
let idx = slot.0 as usize;
if idx >= values.len() {
values.resize(idx + 1, Value::Void);
types.resize(idx + 1, StaticType::Any);
purity.resize(idx + 1, Purity::Impure);
}
types[idx] = ty;
purity[idx] = func.purity;
values[idx] = Value::Function(func);
}
pub fn register_native_fn(
@@ -575,19 +579,13 @@ impl Environment {
}
pub fn register_constant(&self, name: &str, ty: StaticType, val: Value) {
let mut names = self.global_names.borrow_mut();
let mut types = self.global_types.borrow_mut();
let mut values = self.global_values.borrow_mut();
let mut purity = self.global_purity.borrow_mut();
let mut types = self.root_types.borrow_mut();
let mut values = self.root_values.borrow_mut();
let mut purity = self.root_purity.borrow_mut();
let idx = GlobalIdx(values.len() as u32);
let identity = NodeIdentity::new(SourceLocation { line: 0, col: 0 });
names.insert(Symbol::from(name), (idx, identity.clone()));
types.insert(idx, ty.clone());
purity.insert(idx, Purity::Pure);
values.push(val);
// Parallel mode: populate root_scopes[0]
// populate root_scopes[0]
let mut root_scopes = self.root_scopes.borrow_mut();
let mut slot_count = self.root_slot_count.borrow_mut();
let slot = crate::ast::compiler::bound_nodes::LocalSlot(*slot_count);
@@ -596,11 +594,22 @@ impl Environment {
crate::ast::compiler::binder::LocalInfo {
addr: Address::Global(GlobalIdx(slot.0)),
identity,
_ty: ty,
_ty: ty.clone(),
purity: Purity::Pure,
},
);
*slot_count += 1;
let idx = slot.0 as usize;
if idx >= values.len() {
values.resize(idx + 1, Value::Void);
types.resize(idx + 1, StaticType::Any);
purity.resize(idx + 1, Purity::Impure);
}
types[idx] = ty;
purity[idx] = Purity::Pure;
values[idx] = val;
}
@@ -640,7 +649,7 @@ impl Environment {
pub fn link(&self, node: TypedNode) -> ExecNode {
// 1. Analyze
let analyzed = Analyzer::analyze(&node, &self.global_purity.borrow());
let analyzed = Analyzer::analyze(&node, &self.root_purity.borrow());
// 2. Collect Analyzed Lambdas
LambdaCollector::collect(&analyzed, &mut self.typed_function_registry.borrow_mut());
@@ -650,8 +659,8 @@ impl Environment {
// 4. Optimize
let optimizer = Optimizer::new(self.optimization)
.with_globals(self.global_values.clone())
.with_purity(self.global_purity.clone())
.with_globals(self.root_values.clone())
.with_purity(self.root_purity.clone())
.with_registry(self.typed_function_registry.clone());
let optimized = optimizer.optimize(specialized);
@@ -660,7 +669,7 @@ impl Environment {
}
pub fn instantiate(&self, node: ExecNode) -> Rc<crate::ast::types::NativeFunction> {
let global_values = self.global_values.clone();
let root_values = self.root_values.clone();
if let BoundKind::Lambda {
params,
upvalues,
@@ -683,7 +692,7 @@ impl Environment {
return Rc::new(crate::ast::types::NativeFunction {
purity: Purity::Impure,
func: Rc::new(move |args| {
let mut vm = VM::new(global_values.clone());
let mut vm = VM::new(root_values.clone());
match vm.run_with_args(closure_obj.clone(), args) {
Ok(v) => v,
Err(e) => panic!("Myc Runtime Error: {}", e),
@@ -696,7 +705,7 @@ impl Environment {
Rc::new(crate::ast::types::NativeFunction {
purity: Purity::Impure,
func: Rc::new(move |args| {
let mut vm = VM::new(global_values.clone());
let mut vm = VM::new(root_values.clone());
let res = match vm.run(&exec_node) {
Ok(v) => v,
Err(e) => panic!("Myc Runtime Error: {}", e),
@@ -729,9 +738,9 @@ impl Environment {
let typed_reg = self.typed_function_registry.clone();
let untyped_reg = self.function_registry.clone();
let mono_cache = self.monomorph_cache.clone();
let global_values = self.global_values.clone();
let global_types = self.global_types.clone();
let global_purity = self.global_purity.clone();
let root_values = self.root_values.clone();
let root_types = self.root_types.clone();
let root_purity = self.root_purity.clone();
let optimization = self.optimization;
let compiler = Rc::new(
@@ -739,7 +748,7 @@ impl Environment {
arg_types: &[StaticType]|
-> Result<(Value, StaticType), String> {
let mut diag = Diagnostics::new();
let checker = TypeChecker::new(global_types.clone());
let checker = TypeChecker::new(root_types.clone());
let retyped_ast = checker.check(func_template.as_ref(), arg_types, &mut diag);
if diag.has_errors() {
@@ -751,7 +760,7 @@ impl Environment {
.join("\n"));
}
let analyzed = Analyzer::analyze(&retyped_ast, &global_purity.borrow());
let analyzed = Analyzer::analyze(&retyped_ast, &root_purity.borrow());
let sub_registry = Rc::new(EnvFunctionRegistry {
registry: untyped_reg.clone(),
@@ -770,12 +779,12 @@ impl Environment {
let specialized_ast = sub_specializer.specialize(analyzed);
let optimizer = Optimizer::new(optimization)
.with_globals(global_values.clone())
.with_purity(global_purity.clone());
.with_globals(root_values.clone())
.with_purity(root_purity.clone());
let optimized_ast = optimizer.optimize(specialized_ast);
let exec_ast = Lowering::lower(optimized_ast);
let mut vm = VM::new(global_values.clone());
let mut vm = VM::new(root_values.clone());
let compiled_val = match vm.run(&exec_ast) {
Ok(v) => v,
Err(e) => return Err(format!("VM Error during specialization: {}", e)),
@@ -824,7 +833,7 @@ impl Environment {
let compiled = self.compile(source).into_result()?;
let linked = self.link(compiled);
let mut vm = VM::new(self.global_values.clone());
let mut vm = VM::new(self.root_values.clone());
let mut observer = TracingObserver::new();
// 1. Run the script wrapper (returns a closure representing the script)
src/ast/rtl/streams.rs
+1 -1
View File
@@ -413,7 +413,7 @@ pub fn register(env: &Environment) {
// (create-ticker condition-closure) -> StreamNode
let ticker_generators = env.pipeline_generators.clone();
let globals = env.global_values.clone();
let globals = env.root_values.clone();
env.register_native_fn(
"create-ticker",