Refactor: Replace UntypedNode with SyntaxNode

This commit replaces the `UntypedNode` enum with the more accurately named `SyntaxNode`. This change is primarily for clarity and better reflects the role of these nodes as representing the structure of the source code prior to semantic analysis. The corresponding enum `UntypedKind` has also been renamed to `SyntaxKind` to maintain consistency. No functional changes are introduced by this refactoring; it is purely a renaming and organizational update.
2026-03-13 14:21:28 +01:00
parent 7d72a99fa1
commit 84226f6a16
31 changed files with 8611 additions and 8611 deletions
@@ -1,101 +1,101 @@
-use crate::ast::compiler::bound_nodes::{Address, AnalyzedNode, BoundKind, Node, NodeMetrics};
-use crate::ast::types::{Purity, RecordLayout, StaticType, Value};
-use std::cell::RefCell;
-use std::rc::Rc;
-
-pub struct Folder<'a> {
-    pub globals: &'a Option<Rc<RefCell<Vec<Value>>>>,
-}
-
-impl<'a> Folder<'a> {
-    pub fn new(globals: &'a Option<Rc<RefCell<Vec<Value>>>>) -> Self {
-        Self { globals }
-    }
-
-    pub fn make_constant_node(&self, val: Value, template: &AnalyzedNode) -> AnalyzedNode {
-        let ty = val.static_type();
-        let typed_original = Rc::new(Node {
-            identity: template.identity.clone(),
-            kind: BoundKind::Constant(val.clone()),
-            ty: ty.clone(),
-        });
-        Node {
-            identity: template.identity.clone(),
-            kind: BoundKind::Constant(val),
-            ty: NodeMetrics {
-                original: typed_original,
-                purity: Purity::Pure,
-                is_recursive: false,
-            },
-        }
-    }
-
-    pub fn make_nop_node(&self, template: &AnalyzedNode) -> AnalyzedNode {
-        let typed_original = Rc::new(Node {
-            identity: template.identity.clone(),
-            kind: BoundKind::Nop,
-            ty: StaticType::Void,
-        });
-        Node {
-            identity: template.identity.clone(),
-            kind: BoundKind::Nop,
-            ty: NodeMetrics {
-                original: typed_original,
-                purity: Purity::Pure,
-                is_recursive: false,
-            },
-        }
-    }
-
-    pub fn try_fold_record(
-        &self,
-        layout: &std::sync::Arc<RecordLayout>,
-        values: &[Rc<AnalyzedNode>],
-        template: &AnalyzedNode,
-    ) -> Option<AnalyzedNode> {
-        let mut constant_values = Vec::with_capacity(values.len());
-
-        for v_node in values {
-            if let BoundKind::Constant(val) = &v_node.kind {
-                constant_values.push(val.clone());
-            } else {
-                return None;
-            }
-        }
-
-        let record_val = Value::Record(layout.clone(), Rc::new(constant_values));
-        Some(self.make_constant_node(record_val, template))
-    }
-
-    pub fn try_fold_pure(
-        &self,
-        callee: &AnalyzedNode,
-        arg_nodes: &[Rc<AnalyzedNode>],
-    ) -> Option<AnalyzedNode> {
-        if callee.ty.purity < Purity::Pure {
-            return None;
-        }
-
-        let mut arg_values = Vec::with_capacity(arg_nodes.len());
-        for node in arg_nodes {
-            if let BoundKind::Constant(val) = &node.kind {
-                arg_values.push(val.clone());
-            } else {
-                return None;
-            }
-        }
-        let func_val = match &callee.kind {
-            BoundKind::Get {
-                addr: Address::Global(idx),
-                ..
-            } => self.globals.as_ref()?.borrow().get(idx.0 as usize)?.clone(),
-            BoundKind::Constant(val) => val.clone(),
-            _ => return None,
-        };
-        let result = match func_val {
-            Value::Function(f) => (f.func)(&arg_values),
-            _ => return None,
-        };
-        Some(self.make_constant_node(result, callee))
-    }
-}
+use crate::ast::compiler::bound_nodes::{Address, AnalyzedNode, BoundKind, Node, NodeMetrics};
+use crate::ast::types::{Purity, RecordLayout, StaticType, Value};
+use std::cell::RefCell;
+use std::rc::Rc;
+
+pub struct Folder<'a> {
+    pub globals: &'a Option<Rc<RefCell<Vec<Value>>>>,
+}
+
+impl<'a> Folder<'a> {
+    pub fn new(globals: &'a Option<Rc<RefCell<Vec<Value>>>>) -> Self {
+        Self { globals }
+    }
+
+    pub fn make_constant_node(&self, val: Value, template: &AnalyzedNode) -> AnalyzedNode {
+        let ty = val.static_type();
+        let typed_original = Rc::new(Node {
+            identity: template.identity.clone(),
+            kind: BoundKind::Constant(val.clone()),
+            ty: ty.clone(),
+        });
+        Node {
+            identity: template.identity.clone(),
+            kind: BoundKind::Constant(val),
+            ty: NodeMetrics {
+                original: typed_original,
+                purity: Purity::Pure,
+                is_recursive: false,
+            },
+        }
+    }
+
+    pub fn make_nop_node(&self, template: &AnalyzedNode) -> AnalyzedNode {
+        let typed_original = Rc::new(Node {
+            identity: template.identity.clone(),
+            kind: BoundKind::Nop,
+            ty: StaticType::Void,
+        });
+        Node {
+            identity: template.identity.clone(),
+            kind: BoundKind::Nop,
+            ty: NodeMetrics {
+                original: typed_original,
+                purity: Purity::Pure,
+                is_recursive: false,
+            },
+        }
+    }
+
+    pub fn try_fold_record(
+        &self,
+        layout: &std::sync::Arc<RecordLayout>,
+        values: &[Rc<AnalyzedNode>],
+        template: &AnalyzedNode,
+    ) -> Option<AnalyzedNode> {
+        let mut constant_values = Vec::with_capacity(values.len());
+
+        for v_node in values {
+            if let BoundKind::Constant(val) = &v_node.kind {
+                constant_values.push(val.clone());
+            } else {
+                return None;
+            }
+        }
+
+        let record_val = Value::Record(layout.clone(), Rc::new(constant_values));
+        Some(self.make_constant_node(record_val, template))
+    }
+
+    pub fn try_fold_pure(
+        &self,
+        callee: &AnalyzedNode,
+        arg_nodes: &[Rc<AnalyzedNode>],
+    ) -> Option<AnalyzedNode> {
+        if callee.ty.purity < Purity::Pure {
+            return None;
+        }
+
+        let mut arg_values = Vec::with_capacity(arg_nodes.len());
+        for node in arg_nodes {
+            if let BoundKind::Constant(val) = &node.kind {
+                arg_values.push(val.clone());
+            } else {
+                return None;
+            }
+        }
+        let func_val = match &callee.kind {
+            BoundKind::Get {
+                addr: Address::Global(idx),
+                ..
+            } => self.globals.as_ref()?.borrow().get(idx.0 as usize)?.clone(),
+            BoundKind::Constant(val) => val.clone(),
+            _ => return None,
+        };
+        let result = match func_val {
+            Value::Function(f) => (f.func)(&arg_values),
+            _ => return None,
+        };
+        Some(self.make_constant_node(result, callee))
+    }
+}