Formatting

2026-02-22 02:35:06 +01:00
parent 2123f1d279
commit 329b885c4b
25 changed files with 8053 additions and 6400 deletions
@@ -1,85 +1,95 @@
-use std::collections::HashMap;
-use crate::ast::compiler::bound_nodes::{BoundKind, Address, BoundNode};
-
-/// A pass that collects all global function definitions (lambdas) into a registry.
-/// This allows the Specializer to retrieve the original AST of a function for monomorphization.
-pub struct LambdaCollector<'a, T> {
-    registry: &'a mut HashMap<u32, BoundNode<T>>,
-}
-
-impl<'a, T: Clone> LambdaCollector<'a, T> {
-    /// Performs a full traversal of the AST and populates the provided registry.
-    pub fn collect(node: &BoundNode<T>, registry: &'a mut HashMap<u32, BoundNode<T>>) {
-        let mut collector = Self { registry };
-        collector.visit(node);
-    }
-
-    fn visit(&mut self, node: &BoundNode<T>) {
-        match &node.kind {
-            BoundKind::Block { exprs } => {
-                for expr in exprs {
-                    self.visit(expr);
-                }
-            }
-            
-            BoundKind::DefGlobal { global_index, value, .. } => {
-                // Register the full Lambda node as the template.
-                if let BoundKind::Lambda { .. } = &value.kind {
-                    self.registry.insert(*global_index, (*value).as_ref().clone());
-                }
-                self.visit(value);
-            }
-
-            BoundKind::Set { addr, value } => {
-                // Also track assignments to globals if they hold lambdas.
-                if let Address::Global(global_index) = addr 
-                    && let BoundKind::Lambda { .. } = &value.kind 
-                {
-                    self.registry.insert(*global_index, (*value).as_ref().clone());
-                }
-                self.visit(value);
-            }
-
-            BoundKind::If { cond, then_br, else_br } => {
-                self.visit(cond);
-                self.visit(then_br);
-                if let Some(e) = else_br {
-                    self.visit(e);
-                }
-            }
-
-            BoundKind::Lambda { params, body, .. } => {
-                self.visit(params);
-                self.visit(body);
-            }
-
-            BoundKind::DefLocal { value, .. } => {
-                self.visit(value);
-            }
-
-            BoundKind::Call { callee, args } => {
-                self.visit(callee);
-                self.visit(args);
-            }
-
-            BoundKind::Tuple { elements } => {
-                for el in elements {
-                    self.visit(el);
-                }
-            }
-
-            BoundKind::Record { fields } => {
-                for (k, v) in fields {
-                    self.visit(k);
-                    self.visit(v);
-                }
-            }
-
-            BoundKind::Expansion { bound_expanded, .. } => {
-                self.visit(bound_expanded);
-            }
-
-            _ => {} // Leaf nodes
-        }
-    }
-}
+use crate::ast::compiler::bound_nodes::{Address, BoundKind, BoundNode};
+use std::collections::HashMap;
+
+/// A pass that collects all global function definitions (lambdas) into a registry.
+/// This allows the Specializer to retrieve the original AST of a function for monomorphization.
+pub struct LambdaCollector<'a, T> {
+    registry: &'a mut HashMap<u32, BoundNode<T>>,
+}
+
+impl<'a, T: Clone> LambdaCollector<'a, T> {
+    /// Performs a full traversal of the AST and populates the provided registry.
+    pub fn collect(node: &BoundNode<T>, registry: &'a mut HashMap<u32, BoundNode<T>>) {
+        let mut collector = Self { registry };
+        collector.visit(node);
+    }
+
+    fn visit(&mut self, node: &BoundNode<T>) {
+        match &node.kind {
+            BoundKind::Block { exprs } => {
+                for expr in exprs {
+                    self.visit(expr);
+                }
+            }
+
+            BoundKind::DefGlobal {
+                global_index,
+                value,
+                ..
+            } => {
+                // Register the full Lambda node as the template.
+                if let BoundKind::Lambda { .. } = &value.kind {
+                    self.registry
+                        .insert(*global_index, (*value).as_ref().clone());
+                }
+                self.visit(value);
+            }
+
+            BoundKind::Set { addr, value } => {
+                // Also track assignments to globals if they hold lambdas.
+                if let Address::Global(global_index) = addr
+                    && let BoundKind::Lambda { .. } = &value.kind
+                {
+                    self.registry
+                        .insert(*global_index, (*value).as_ref().clone());
+                }
+                self.visit(value);
+            }
+
+            BoundKind::If {
+                cond,
+                then_br,
+                else_br,
+            } => {
+                self.visit(cond);
+                self.visit(then_br);
+                if let Some(e) = else_br {
+                    self.visit(e);
+                }
+            }
+
+            BoundKind::Lambda { params, body, .. } => {
+                self.visit(params);
+                self.visit(body);
+            }
+
+            BoundKind::DefLocal { value, .. } => {
+                self.visit(value);
+            }
+
+            BoundKind::Call { callee, args } => {
+                self.visit(callee);
+                self.visit(args);
+            }
+
+            BoundKind::Tuple { elements } => {
+                for el in elements {
+                    self.visit(el);
+                }
+            }
+
+            BoundKind::Record { fields } => {
+                for (k, v) in fields {
+                    self.visit(k);
+                    self.visit(v);
+                }
+            }
+
+            BoundKind::Expansion { bound_expanded, .. } => {
+                self.visit(bound_expanded);
+            }
+
+            _ => {} // Leaf nodes
+        }
+    }
+}