diff --git a/compiler/NubLang.LSP/AstExtensions.cs b/compiler/NubLang.LSP/AstExtensions.cs
index 82ceb0f..e0b2477 100644
--- a/compiler/NubLang.LSP/AstExtensions.cs
+++ b/compiler/NubLang.LSP/AstExtensions.cs
@@ -68,368 +68,10 @@ public static class AstExtensions
     public static Node? DeepestNodeAtPosition(this CompilationUnit compilationUnit, int line, int character)
     {
         return compilationUnit.Functions
-            .SelectMany(x => x.EnumerateDescendantsAndSelf())
+            .SelectMany(x => x.DescendantsAndSelf())
             .Where(n => n.ContainsPosition(line, character))
             .OrderBy(n => n.Tokens.First().Span.Start.Line)
             .ThenBy(n => n.Tokens.First().Span.Start.Column)
             .LastOrDefault();
     }
-
-    public static Node? DeepestNodeAtPosition(this Node node, int line, int character)
-    {
-        return node.EnumerateDescendantsAndSelf()
-            .Where(n => n.ContainsPosition(line, character))
-            .OrderBy(n => n.Tokens.First().Span.Start.Line)
-            .ThenBy(n => n.Tokens.First().Span.Start.Column)
-            .LastOrDefault();
-    }
-
-    public static IEnumerable<Node> EnumerateDescendantsAndSelf(this Node node)
-    {
-        yield return node;
-
-        switch (node)
-        {
-            case FuncNode func:
-            {
-                foreach (var n in func.Prototype.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                if (func.Body != null)
-                {
-                    foreach (var n in func.Body.EnumerateDescendantsAndSelf())
-                    {
-                        yield return n;
-                    }
-                }
-
-                break;
-            }
-            case FuncPrototypeNode proto:
-            {
-                foreach (var n in proto.Parameters.SelectMany(param => param.EnumerateDescendantsAndSelf()))
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case BlockNode block:
-            {
-                foreach (var n in block.Statements.SelectMany(stmt => stmt.EnumerateDescendantsAndSelf()))
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case StatementFuncCallNode stmtCall:
-            {
-                foreach (var n in stmtCall.FuncCall.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case ReturnNode { Value: not null } ret:
-            {
-                foreach (var n in ret.Value.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case AssignmentNode assign:
-            {
-                foreach (var n in assign.Target.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                foreach (var n in assign.Value.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case IfNode ifNode:
-            {
-                foreach (var n in ifNode.Condition.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                foreach (var n in ifNode.Body.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                if (ifNode.Else.HasValue)
-                {
-                    if (ifNode.Else.Value.IsCase1(out var elseIfNode))
-                    {
-                        foreach (var n in elseIfNode.EnumerateDescendantsAndSelf())
-                        {
-                            yield return n;
-                        }
-                    }
-                    else if (ifNode.Else.Value.IsCase2(out var elseNode))
-                    {
-                        foreach (var n in elseNode.EnumerateDescendantsAndSelf())
-                        {
-                            yield return n;
-                        }
-                    }
-                }
-
-                break;
-            }
-            case VariableDeclarationNode decl:
-            {
-                if (decl.Assignment != null)
-                {
-                    foreach (var n in decl.Assignment.EnumerateDescendantsAndSelf())
-                    {
-                        yield return n;
-                    }
-                }
-
-                break;
-            }
-            case WhileNode whileNode:
-            {
-                foreach (var n in whileNode.Condition.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                foreach (var n in whileNode.Body.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case ForSliceNode forSlice:
-            {
-                foreach (var n in forSlice.Target.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                foreach (var n in forSlice.Body.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case ForConstArrayNode forConst:
-            {
-                foreach (var n in forConst.Target.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                foreach (var n in forConst.Body.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case DeferNode defer:
-            {
-                foreach (var n in defer.Statement.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case BinaryExpressionNode bin:
-            {
-                foreach (var n in bin.Left.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                foreach (var n in bin.Right.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case UnaryExpressionNode unary:
-            {
-                foreach (var n in unary.Operand.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case FuncCallNode call:
-            {
-                foreach (var n in call.Expression.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                foreach (var n in call.Parameters.SelectMany(param => param.EnumerateDescendantsAndSelf()))
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case ArrayInitializerNode arrInit:
-            {
-                foreach (var n in arrInit.Values.SelectMany(val => val.EnumerateDescendantsAndSelf()))
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case ConstArrayInitializerNode constArrInit:
-            {
-                foreach (var n in constArrInit.Values.SelectMany(val => val.EnumerateDescendantsAndSelf()))
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case ArrayIndexAccessNode arrIndex:
-            {
-                foreach (var n in arrIndex.Target.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                foreach (var n in arrIndex.Index.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case ConstArrayIndexAccessNode constArrIndex:
-            {
-                foreach (var n in constArrIndex.Target.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                foreach (var n in constArrIndex.Index.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case SliceIndexAccessNode sliceIndex:
-            {
-                foreach (var n in sliceIndex.Target.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                foreach (var n in sliceIndex.Index.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case AddressOfNode addr:
-            {
-                foreach (var n in addr.LValue.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case StructFieldAccessNode field:
-            {
-                foreach (var n in field.Target.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case StructInitializerNode structInit:
-            {
-                foreach (var n in structInit.Initializers.SelectMany(kv => kv.Value.EnumerateDescendantsAndSelf()))
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case DereferenceNode deref:
-            {
-                foreach (var n in deref.Target.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case ConvertIntNode convInt:
-            {
-                foreach (var n in convInt.Value.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case ConvertFloatNode convFloat:
-            {
-                foreach (var n in convFloat.Value.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case ConvertCStringToStringNode convStr:
-            {
-                foreach (var n in convStr.Value.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case FloatToIntBuiltinNode ftoi:
-            {
-                foreach (var n in ftoi.Value.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case ConstArrayToSliceNode constSlice:
-            {
-                foreach (var n in constSlice.Array.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-        }
-    }
 }
\ No newline at end of file
diff --git a/compiler/NubLang.LSP/CompletionHandler.cs b/compiler/NubLang.LSP/CompletionHandler.cs
index 583e9e5..8155328 100644
--- a/compiler/NubLang.LSP/CompletionHandler.cs
+++ b/compiler/NubLang.LSP/CompletionHandler.cs
@@ -150,9 +150,8 @@ internal class CompletionHandler(WorkspaceManager workspaceManager) : Completion
                     });
                 }
 
-                var variables = function
-                    .Body!
-                    .EnumerateDescendantsAndSelf()
+                var variables = function.Body!
+                    .Descendants()
                     .OfType<VariableDeclarationNode>();
 
                 foreach (var variable in variables)
diff --git a/compiler/NubLang.LSP/DefinitionHandler.cs b/compiler/NubLang.LSP/DefinitionHandler.cs
index 6329111..d354e9d 100644
--- a/compiler/NubLang.LSP/DefinitionHandler.cs
+++ b/compiler/NubLang.LSP/DefinitionHandler.cs
@@ -44,7 +44,7 @@ internal class DefinitionHandler(WorkspaceManager workspaceManager) : Definition
                 }
 
                 var variable = function?.Body?
-                    .EnumerateDescendantsAndSelf()
+                    .Descendants()
                     .OfType<VariableDeclarationNode>()
                     .FirstOrDefault(x => x.Name == variableIdentifierNode.Name);
 
diff --git a/compiler/NubLang/Ast/Node.cs b/compiler/NubLang/Ast/Node.cs
index 4db39b8..73c3641 100644
--- a/compiler/NubLang/Ast/Node.cs
+++ b/compiler/NubLang/Ast/Node.cs
@@ -2,17 +2,62 @@ using NubLang.Syntax;
 
 namespace NubLang.Ast;
 
-public abstract record Node(List<Token> Tokens);
+public abstract record Node(List<Token> Tokens)
+{
+    public abstract IEnumerable<Node> Children();
+
+    public IEnumerable<Node> Descendants()
+    {
+        foreach (var child in Children())
+        {
+            foreach (var descendant in child.DescendantsAndSelf())
+            {
+                yield return descendant;
+            }
+        }
+    }
+
+    public IEnumerable<Node> DescendantsAndSelf()
+    {
+        yield return this;
+        foreach (var descendant in Descendants())
+        {
+            yield return descendant;
+        }
+    }
+}
 
 #region Definitions
 
 public abstract record DefinitionNode(List<Token> Tokens, string Module, string Name) : Node(Tokens);
 
-public record FuncParameterNode(List<Token> Tokens, string Name, NubType Type) : Node(Tokens);
+public record FuncParameterNode(List<Token> Tokens, string Name, NubType Type) : Node(Tokens)
+{
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record FuncPrototypeNode(List<Token> Tokens, string Module, string Name, string? ExternSymbol, List<FuncParameterNode> Parameters, NubType ReturnType) : Node(Tokens);
+public record FuncPrototypeNode(List<Token> Tokens, string Module, string Name, string? ExternSymbol, List<FuncParameterNode> Parameters, NubType ReturnType) : Node(Tokens)
+{
+    public override IEnumerable<Node> Children()
+    {
+        return Parameters;
+    }
+}
 
-public record FuncNode(List<Token> Tokens, FuncPrototypeNode Prototype, BlockNode? Body) : DefinitionNode(Tokens, Prototype.Module, Prototype.Name);
+public record FuncNode(List<Token> Tokens, FuncPrototypeNode Prototype, BlockNode? Body) : DefinitionNode(Tokens, Prototype.Module, Prototype.Name)
+{
+    public override IEnumerable<Node> Children()
+    {
+        yield return Prototype;
+        if (Body != null)
+        {
+            yield return Body;
+        }
+    }
+}
 
 #endregion
 
@@ -22,29 +67,110 @@ public abstract record StatementNode(List<Token> Tokens) : Node(Tokens);
 
 public abstract record TerminalStatementNode(List<Token> Tokens) : StatementNode(Tokens);
 
-public record BlockNode(List<Token> Tokens, List<StatementNode> Statements) : StatementNode(Tokens);
+public record BlockNode(List<Token> Tokens, List<StatementNode> Statements) : StatementNode(Tokens)
+{
+    public override IEnumerable<Node> Children()
+    {
+        return Statements;
+    }
+}
 
-public record StatementFuncCallNode(List<Token> Tokens, FuncCallNode FuncCall) : StatementNode(Tokens);
+public record StatementFuncCallNode(List<Token> Tokens, FuncCallNode FuncCall) : StatementNode(Tokens)
+{
+    public override IEnumerable<Node> Children()
+    {
+        yield return FuncCall;
+    }
+}
 
-public record ReturnNode(List<Token> Tokens, ExpressionNode? Value) : TerminalStatementNode(Tokens);
+public record ReturnNode(List<Token> Tokens, ExpressionNode? Value) : TerminalStatementNode(Tokens)
+{
+    public override IEnumerable<Node> Children()
+    {
+        if (Value != null) yield return Value;
+    }
+}
 
-public record AssignmentNode(List<Token> Tokens, LValueExpressionNode Target, ExpressionNode Value) : StatementNode(Tokens);
+public record AssignmentNode(List<Token> Tokens, LValueExpressionNode Target, ExpressionNode Value) : StatementNode(Tokens)
+{
+    public override IEnumerable<Node> Children()
+    {
+        yield return Target;
+        yield return Value;
+    }
+}
 
-public record IfNode(List<Token> Tokens, ExpressionNode Condition, BlockNode Body, Variant<IfNode, BlockNode>? Else) : StatementNode(Tokens);
+public record IfNode(List<Token> Tokens, ExpressionNode Condition, BlockNode Body, Variant<IfNode, BlockNode>? Else) : StatementNode(Tokens)
+{
+    public override IEnumerable<Node> Children()
+    {
+        yield return Condition;
+        yield return Body;
+        if (Else.HasValue)
+        {
+            yield return Else.Value.Match<Node>(x => x, x => x);
+        }
+    }
+}
 
-public record VariableDeclarationNode(List<Token> Tokens, string Name, ExpressionNode? Assignment, NubType Type) : StatementNode(Tokens);
+public record VariableDeclarationNode(List<Token> Tokens, string Name, ExpressionNode? Assignment, NubType Type) : StatementNode(Tokens)
+{
+    public override IEnumerable<Node> Children()
+    {
+        if (Assignment != null) yield return Assignment;
+    }
+}
 
-public record ContinueNode(List<Token> Tokens) : TerminalStatementNode(Tokens);
+public record ContinueNode(List<Token> Tokens) : TerminalStatementNode(Tokens)
+{
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record BreakNode(List<Token> Tokens) : TerminalStatementNode(Tokens);
+public record BreakNode(List<Token> Tokens) : TerminalStatementNode(Tokens)
+{
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record WhileNode(List<Token> Tokens, ExpressionNode Condition, BlockNode Body) : StatementNode(Tokens);
+public record WhileNode(List<Token> Tokens, ExpressionNode Condition, BlockNode Body) : StatementNode(Tokens)
+{
+    public override IEnumerable<Node> Children()
+    {
+        yield return Condition;
+        yield return Body;
+    }
+}
 
-public record ForSliceNode(List<Token> Tokens, string ElementName, string? IndexName, ExpressionNode Target, BlockNode Body) : StatementNode(Tokens);
+public record ForSliceNode(List<Token> Tokens, string ElementName, string? IndexName, ExpressionNode Target, BlockNode Body) : StatementNode(Tokens)
+{
+    public override IEnumerable<Node> Children()
+    {
+        yield return Target;
+        yield return Body;
+    }
+}
 
-public record ForConstArrayNode(List<Token> Tokens, string ElementName, string? IndexName, ExpressionNode Target, BlockNode Body) : StatementNode(Tokens);
+public record ForConstArrayNode(List<Token> Tokens, string ElementName, string? IndexName, ExpressionNode Target, BlockNode Body) : StatementNode(Tokens)
+{
+    public override IEnumerable<Node> Children()
+    {
+        yield return Target;
+        yield return Body;
+    }
+}
 
-public record DeferNode(List<Token> Tokens, StatementNode Statement) : StatementNode(Tokens);
+public record DeferNode(List<Token> Tokens, StatementNode Statement) : StatementNode(Tokens)
+{
+    public override IEnumerable<Node> Children()
+    {
+        yield return Statement;
+    }
+}
 
 #endregion
 
@@ -86,72 +212,287 @@ public abstract record RValueExpressionNode(List<Token> Tokens, NubType Type) :
 
 public abstract record IntermediateExpression(List<Token> Tokens) : ExpressionNode(Tokens, new NubVoidType());
 
-public record StringLiteralNode(List<Token> Tokens, string Value) : RValueExpressionNode(Tokens, new NubStringType());
+public record StringLiteralNode(List<Token> Tokens, string Value) : RValueExpressionNode(Tokens, new NubStringType())
+{
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record CStringLiteralNode(List<Token> Tokens, string Value) : RValueExpressionNode(Tokens, new NubCStringType());
+public record CStringLiteralNode(List<Token> Tokens, string Value) : RValueExpressionNode(Tokens, new NubCStringType())
+{
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record I8LiteralNode(List<Token> Tokens, sbyte Value) : RValueExpressionNode(Tokens, new NubIntType(true, 8));
+public record I8LiteralNode(List<Token> Tokens, sbyte Value) : RValueExpressionNode(Tokens, new NubIntType(true, 8))
+{
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record I16LiteralNode(List<Token> Tokens, short Value) : RValueExpressionNode(Tokens, new NubIntType(true, 16));
+public record I16LiteralNode(List<Token> Tokens, short Value) : RValueExpressionNode(Tokens, new NubIntType(true, 16))
+{
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record I32LiteralNode(List<Token> Tokens, int Value) : RValueExpressionNode(Tokens, new NubIntType(true, 32));
+public record I32LiteralNode(List<Token> Tokens, int Value) : RValueExpressionNode(Tokens, new NubIntType(true, 32))
+{
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record I64LiteralNode(List<Token> Tokens, long Value) : RValueExpressionNode(Tokens, new NubIntType(true, 64));
+public record I64LiteralNode(List<Token> Tokens, long Value) : RValueExpressionNode(Tokens, new NubIntType(true, 64))
+{
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record U8LiteralNode(List<Token> Tokens, byte Value) : RValueExpressionNode(Tokens, new NubIntType(false, 8));
+public record U8LiteralNode(List<Token> Tokens, byte Value) : RValueExpressionNode(Tokens, new NubIntType(false, 8))
+{
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record U16LiteralNode(List<Token> Tokens, ushort Value) : RValueExpressionNode(Tokens, new NubIntType(false, 16));
+public record U16LiteralNode(List<Token> Tokens, ushort Value) : RValueExpressionNode(Tokens, new NubIntType(false, 16))
+{
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record U32LiteralNode(List<Token> Tokens, uint Value) : RValueExpressionNode(Tokens, new NubIntType(false, 32));
+public record U32LiteralNode(List<Token> Tokens, uint Value) : RValueExpressionNode(Tokens, new NubIntType(false, 32))
+{
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record U64LiteralNode(List<Token> Tokens, ulong Value) : RValueExpressionNode(Tokens, new NubIntType(false, 64));
+public record U64LiteralNode(List<Token> Tokens, ulong Value) : RValueExpressionNode(Tokens, new NubIntType(false, 64))
+{
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record Float32LiteralNode(List<Token> Tokens, float Value) : RValueExpressionNode(Tokens, new NubFloatType(32));
+public record Float32LiteralNode(List<Token> Tokens, float Value) : RValueExpressionNode(Tokens, new NubFloatType(32))
+{
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record Float64LiteralNode(List<Token> Tokens, double Value) : RValueExpressionNode(Tokens, new NubFloatType(64));
+public record Float64LiteralNode(List<Token> Tokens, double Value) : RValueExpressionNode(Tokens, new NubFloatType(64))
+{
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record BoolLiteralNode(List<Token> Tokens, NubType Type, bool Value) : RValueExpressionNode(Tokens, Type);
+public record BoolLiteralNode(List<Token> Tokens, NubType Type, bool Value) : RValueExpressionNode(Tokens, Type)
+{
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record BinaryExpressionNode(List<Token> Tokens, NubType Type, ExpressionNode Left, BinaryOperator Operator, ExpressionNode Right) : RValueExpressionNode(Tokens, Type);
+public record BinaryExpressionNode(List<Token> Tokens, NubType Type, ExpressionNode Left, BinaryOperator Operator, ExpressionNode Right) : RValueExpressionNode(Tokens, Type)
+{
+    public override IEnumerable<Node> Children()
+    {
+        yield return Left;
+        yield return Right;
+    }
+}
 
-public record UnaryExpressionNode(List<Token> Tokens, NubType Type, UnaryOperator Operator, ExpressionNode Operand) : RValueExpressionNode(Tokens, Type);
+public record UnaryExpressionNode(List<Token> Tokens, NubType Type, UnaryOperator Operator, ExpressionNode Operand) : RValueExpressionNode(Tokens, Type)
+{
+    public override IEnumerable<Node> Children()
+    {
+        yield return Operand;
+    }
+}
 
-public record FuncCallNode(List<Token> Tokens, NubType Type, ExpressionNode Expression, List<ExpressionNode> Parameters) : RValueExpressionNode(Tokens, Type);
+public record FuncCallNode(List<Token> Tokens, NubType Type, ExpressionNode Expression, List<ExpressionNode> Parameters) : RValueExpressionNode(Tokens, Type)
+{
+    public override IEnumerable<Node> Children()
+    {
+        yield return Expression;
+        foreach (var expressionNode in Parameters)
+        {
+            yield return expressionNode;
+        }
+    }
+}
 
-public record VariableIdentifierNode(List<Token> Tokens, NubType Type, string Name) : LValueExpressionNode(Tokens, Type);
+public record VariableIdentifierNode(List<Token> Tokens, NubType Type, string Name) : LValueExpressionNode(Tokens, Type)
+{
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record FuncIdentifierNode(List<Token> Tokens, NubType Type, string Module, string Name, string? ExternSymbol) : RValueExpressionNode(Tokens, Type);
+public record FuncIdentifierNode(List<Token> Tokens, NubType Type, string Module, string Name, string? ExternSymbol) : RValueExpressionNode(Tokens, Type)
+{
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record ArrayInitializerNode(List<Token> Tokens, NubType Type, List<ExpressionNode> Values) : RValueExpressionNode(Tokens, Type);
+public record ArrayInitializerNode(List<Token> Tokens, NubType Type, List<ExpressionNode> Values) : RValueExpressionNode(Tokens, Type)
+{
+    public override IEnumerable<Node> Children()
+    {
+        return Values;
+    }
+}
 
-public record ConstArrayInitializerNode(List<Token> Tokens, NubType Type, List<ExpressionNode> Values) : RValueExpressionNode(Tokens, Type);
+public record ConstArrayInitializerNode(List<Token> Tokens, NubType Type, List<ExpressionNode> Values) : RValueExpressionNode(Tokens, Type)
+{
+    public override IEnumerable<Node> Children()
+    {
+        return Values;
+    }
+}
 
-public record ArrayIndexAccessNode(List<Token> Tokens, NubType Type, ExpressionNode Target, ExpressionNode Index) : LValueExpressionNode(Tokens, Type);
+public record ArrayIndexAccessNode(List<Token> Tokens, NubType Type, ExpressionNode Target, ExpressionNode Index) : LValueExpressionNode(Tokens, Type)
+{
+    public override IEnumerable<Node> Children()
+    {
+        yield return Target;
+        yield return Index;
+    }
+}
 
-public record ConstArrayIndexAccessNode(List<Token> Tokens, NubType Type, ExpressionNode Target, ExpressionNode Index) : LValueExpressionNode(Tokens, Type);
+public record ConstArrayIndexAccessNode(List<Token> Tokens, NubType Type, ExpressionNode Target, ExpressionNode Index) : LValueExpressionNode(Tokens, Type)
+{
+    public override IEnumerable<Node> Children()
+    {
+        yield return Target;
+        yield return Index;
+    }
+}
 
-public record SliceIndexAccessNode(List<Token> Tokens, NubType Type, ExpressionNode Target, ExpressionNode Index) : LValueExpressionNode(Tokens, Type);
+public record SliceIndexAccessNode(List<Token> Tokens, NubType Type, ExpressionNode Target, ExpressionNode Index) : LValueExpressionNode(Tokens, Type)
+{
+    public override IEnumerable<Node> Children()
+    {
+        yield return Target;
+        yield return Index;
+    }
+}
 
-public record AddressOfNode(List<Token> Tokens, NubType Type, LValueExpressionNode LValue) : RValueExpressionNode(Tokens, Type);
+public record AddressOfNode(List<Token> Tokens, NubType Type, LValueExpressionNode LValue) : RValueExpressionNode(Tokens, Type)
+{
+    public override IEnumerable<Node> Children()
+    {
+        yield return LValue;
+    }
+}
 
-public record StructFieldAccessNode(List<Token> Tokens, NubType Type, ExpressionNode Target, string Field) : LValueExpressionNode(Tokens, Type);
+public record StructFieldAccessNode(List<Token> Tokens, NubType Type, ExpressionNode Target, string Field) : LValueExpressionNode(Tokens, Type)
+{
+    public override IEnumerable<Node> Children()
+    {
+        yield return Target;
+    }
+}
 
-public record StructInitializerNode(List<Token> Tokens, NubType Type, Dictionary<string, ExpressionNode> Initializers) : RValueExpressionNode(Tokens, Type);
+public record StructInitializerNode(List<Token> Tokens, NubType Type, Dictionary<string, ExpressionNode> Initializers) : RValueExpressionNode(Tokens, Type)
+{
+    public override IEnumerable<Node> Children()
+    {
+        foreach (var initializer in Initializers)
+        {
+            yield return initializer.Value;
+        }
+    }
+}
 
-public record DereferenceNode(List<Token> Tokens, NubType Type, ExpressionNode Target) : LValueExpressionNode(Tokens, Type);
+public record DereferenceNode(List<Token> Tokens, NubType Type, ExpressionNode Target) : LValueExpressionNode(Tokens, Type)
+{
+    public override IEnumerable<Node> Children()
+    {
+        yield return Target;
+    }
+}
 
-public record ConvertIntNode(List<Token> Tokens, ExpressionNode Value, int StartWidth, int TargetWidth, bool StartSignedness, bool TargetSignedness) : RValueExpressionNode(Tokens, new NubIntType(TargetSignedness, TargetWidth));
+public record ConvertIntNode(List<Token> Tokens, ExpressionNode Value, int StartWidth, int TargetWidth, bool StartSignedness, bool TargetSignedness) : RValueExpressionNode(Tokens, new NubIntType(TargetSignedness, TargetWidth))
+{
+    public override IEnumerable<Node> Children()
+    {
+        yield return Value;
+    }
+}
 
-public record ConvertFloatNode(List<Token> Tokens, ExpressionNode Value, int StartWidth, int TargetWidth) : RValueExpressionNode(Tokens, new NubFloatType(TargetWidth));
+public record ConvertFloatNode(List<Token> Tokens, ExpressionNode Value, int StartWidth, int TargetWidth) : RValueExpressionNode(Tokens, new NubFloatType(TargetWidth))
+{
+    public override IEnumerable<Node> Children()
+    {
+        yield return Value;
+    }
+}
 
-public record ConvertCStringToStringNode(List<Token> Tokens, ExpressionNode Value) : RValueExpressionNode(Tokens, new NubStringType());
+public record ConvertCStringToStringNode(List<Token> Tokens, ExpressionNode Value) : RValueExpressionNode(Tokens, new NubStringType())
+{
+    public override IEnumerable<Node> Children()
+    {
+        yield return Value;
+    }
+}
 
-public record SizeBuiltinNode(List<Token> Tokens, NubType Type, NubType TargetType) : RValueExpressionNode(Tokens, Type);
+public record SizeBuiltinNode(List<Token> Tokens, NubType Type, NubType TargetType) : RValueExpressionNode(Tokens, Type)
+{
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record FloatToIntBuiltinNode(List<Token> Tokens, NubType Type, ExpressionNode Value, NubFloatType ValueType, NubIntType TargetType) : RValueExpressionNode(Tokens, Type);
+public record FloatToIntBuiltinNode(List<Token> Tokens, NubType Type, ExpressionNode Value, NubFloatType ValueType, NubIntType TargetType) : RValueExpressionNode(Tokens, Type)
+{
+    public override IEnumerable<Node> Children()
+    {
+        yield return Value;
+    }
+}
 
-public record ConstArrayToSliceNode(List<Token> Tokens, NubType Type, ExpressionNode Array) : RValueExpressionNode(Tokens, Type);
+public record ConstArrayToSliceNode(List<Token> Tokens, NubType Type, ExpressionNode Array) : RValueExpressionNode(Tokens, Type)
+{
+    public override IEnumerable<Node> Children()
+    {
+        yield return Array;
+    }
+}
 
-public record EnumReferenceIntermediateNode(List<Token> Tokens, string Module, string Name) : IntermediateExpression(Tokens);
+public record EnumReferenceIntermediateNode(List<Token> Tokens, string Module, string Name) : IntermediateExpression(Tokens)
+{
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
 #endregion
\ No newline at end of file