Simplify nodes

src/Generation/QBE/QBEGenerator.cs

@@ -3,9 +3,7 @@ using System.Globalization;
 using System.Text;
 using Syntax;
 using Syntax.Parsing;
-using Syntax.Parsing.Definitions;
+using Syntax.Parsing.Node;
-using Syntax.Parsing.Expressions;
-using Syntax.Parsing.Statements;
 using Syntax.Tokenization;
 using Syntax.Typing;
 

src/Syntax/DefinitionTable.cs

@@ -1,6 +1,6 @@
 using Common;
 using Syntax.Parsing;
-using Syntax.Parsing.Definitions;
+using Syntax.Parsing.Node;
 
 namespace Syntax;
 

src/Syntax/Diagnostics/Diagnostic.cs

@@ -1,5 +1,6 @@
 using System.Text;
 using Syntax.Parsing;
+using Syntax.Parsing.Node;
 using Syntax.Tokenization;
 
 namespace Syntax.Diagnostics;

src/Syntax/Parsing/CompilationUnit.cs

@@ -1,4 +1,4 @@
-using Syntax.Parsing.Definitions;
+using Syntax.Parsing.Node;
 
 namespace Syntax.Parsing;
 

src/Syntax/Parsing/Definitions/DefinitionNode.cs

@@ -1,10 +0,0 @@
-using Common;
-using Syntax.Tokenization;
-
-namespace Syntax.Parsing.Definitions;
-
-public abstract class DefinitionNode(IEnumerable<Token> tokens, Optional<string> documentation, string @namespace) : Node(tokens)
-{
-    public Optional<string> Documentation { get; } = documentation;
-    public string Namespace { get; set; } = @namespace;
-}

src/Syntax/Parsing/Definitions/FuncDefinitionNode.cs

@@ -1,44 +0,0 @@
-using Common;
-using Syntax.Parsing.Statements;
-using Syntax.Tokenization;
-using Syntax.Typing;
-
-namespace Syntax.Parsing.Definitions;
-
-public class FuncParameter(string name, NubType type)
-{
-    public string Name { get; } = name;
-    public NubType Type { get; } = type;
-
-    public override string ToString() => $"{Name}: {Type}";
-}
-
-public interface IFuncSignature
-{
-    public string Name { get; }
-    public List<FuncParameter> Parameters { get; }
-    public NubType ReturnType { get; }
-
-    public string ToString() => $"{Name}({string.Join(", ", Parameters.Select(p => p.ToString()))}){": " + ReturnType}";
-}
-
-public class LocalFuncDefinitionNode(IEnumerable<Token> tokens, Optional<string> documentation, string @namespace, string name, List<FuncParameter> parameters, BlockNode body, NubType returnType, bool exported) : DefinitionNode(tokens, documentation, @namespace), IFuncSignature
-{
-    public string Name { get; } = name;
-    public List<FuncParameter> Parameters { get; } = parameters;
-    public BlockNode Body { get; } = body;
-    public NubType ReturnType { get; } = returnType;
-    public bool Exported { get; } = exported;
-
-    public override string ToString() => $"{Name}({string.Join(", ", Parameters.Select(p => p.ToString()))}){": " + ReturnType}";
-}
-
-public class ExternFuncDefinitionNode(IEnumerable<Token> tokens, Optional<string> documentation, string @namespace, string name, string callName, List<FuncParameter> parameters, NubType returnType) : DefinitionNode(tokens, documentation, @namespace), IFuncSignature
-{
-    public string Name { get; } = name;
-    public string CallName { get; } = callName;
-    public List<FuncParameter> Parameters { get; } = parameters;
-    public NubType ReturnType { get; } = returnType;
-
-    public override string ToString() => $"{Name}({string.Join(", ", Parameters.Select(p => p.ToString()))}){": " + ReturnType}";
-}

src/Syntax/Parsing/Definitions/StructDefinitionNode.cs

@@ -1,19 +0,0 @@
-using Common;
-using Syntax.Parsing.Expressions;
-using Syntax.Tokenization;
-using Syntax.Typing;
-
-namespace Syntax.Parsing.Definitions;
-
-public class StructField(string name, NubType type, Optional<ExpressionNode> value)
-{
-    public string Name { get; } = name;
-    public NubType Type { get; } = type;
-    public Optional<ExpressionNode> Value { get; } = value;
-}
-
-public class StructDefinitionNode(IEnumerable<Token> tokens, Optional<string> documentation, string @namespace, string name, List<StructField> fields) : DefinitionNode(tokens, documentation, @namespace)
-{
-    public string Name { get; } = name;
-    public List<StructField> Fields { get; } = fields;
-}

src/Syntax/Parsing/Expressions/AddressOfNode.cs

@@ -1,8 +0,0 @@
-using Syntax.Tokenization;
-
-namespace Syntax.Parsing.Expressions;
-
-public class AddressOfNode(IEnumerable<Token> tokens, LValueNode expression) : ExpressionNode(tokens)
-{
-    public LValueNode Expression { get; } = expression;
-}

src/Syntax/Parsing/Expressions/AnonymousFuncNode.cs

@@ -1,13 +0,0 @@
-using Syntax.Parsing.Definitions;
-using Syntax.Parsing.Statements;
-using Syntax.Tokenization;
-using Syntax.Typing;
-
-namespace Syntax.Parsing.Expressions;
-
-public class AnonymousFuncNode(IEnumerable<Token> tokens, List<FuncParameter> parameters, BlockNode body, NubType returnType) : ExpressionNode(tokens)
-{
-    public List<FuncParameter> Parameters { get; } = parameters;
-    public BlockNode Body { get; } = body;
-    public NubType ReturnType { get; } = returnType;
-}

src/Syntax/Parsing/Expressions/ArrayIndexAccessNode.cs

@@ -1,9 +0,0 @@
-using Syntax.Tokenization;
-
-namespace Syntax.Parsing.Expressions;
-
-public class ArrayIndexAccessNode(IEnumerable<Token> tokens, ExpressionNode array, ExpressionNode index) : LValueNode(tokens)
-{
-    public ExpressionNode Array { get; } = array;
-    public ExpressionNode Index { get; } = index;
-}

src/Syntax/Parsing/Expressions/ArrayInitializerNode.cs

@@ -1,10 +0,0 @@
-using Syntax.Tokenization;
-using Syntax.Typing;
-
-namespace Syntax.Parsing.Expressions;
-
-public class ArrayInitializerNode(IEnumerable<Token> tokens, ExpressionNode capacity, NubType elementType) : ExpressionNode(tokens)
-{
-    public ExpressionNode Capacity { get; } = capacity;
-    public NubType ElementType { get; } = elementType;
-}

src/Syntax/Parsing/Expressions/BinaryExpressionNode.cs

@@ -1,24 +0,0 @@
-using Syntax.Tokenization;
-
-namespace Syntax.Parsing.Expressions;
-
-public class BinaryExpressionNode(IEnumerable<Token> tokens, ExpressionNode left, BinaryExpressionOperator @operator, ExpressionNode right) : ExpressionNode(tokens)
-{
-    public ExpressionNode Left { get; } = left;
-    public BinaryExpressionOperator Operator { get; } = @operator;
-    public ExpressionNode Right { get; } = right;
-}
-
-public enum BinaryExpressionOperator
-{
-    Equal,
-    NotEqual,
-    GreaterThan,
-    GreaterThanOrEqual,
-    LessThan,
-    LessThanOrEqual,
-    Plus,
-    Minus,
-    Multiply,
-    Divide
-}

src/Syntax/Parsing/Expressions/DereferenceNode.cs

@@ -1,8 +0,0 @@
-using Syntax.Tokenization;
-
-namespace Syntax.Parsing.Expressions;
-
-public class DereferenceNode(IEnumerable<Token> tokens, ExpressionNode expression) : LValueNode(tokens)
-{
-    public ExpressionNode Expression { get; } = expression;
-}

src/Syntax/Parsing/Expressions/ExpressionNode.cs

@@ -1,16 +0,0 @@
-using Syntax.Tokenization;
-using Syntax.Typing;
-
-namespace Syntax.Parsing.Expressions;
-
-public abstract class ExpressionNode(IEnumerable<Token> tokens) : Node(tokens)
-{
-    private NubType? _type;
-    public NubType Type
-    {
-        get => _type ?? throw new Exception("Tried to access expression type before type was populated");
-        set => _type = value;
-    }
-}
-
-public abstract class LValueNode(IEnumerable<Token> tokens) : ExpressionNode(tokens);

src/Syntax/Parsing/Expressions/FixedArrayInitializerNode.cs

@@ -1,10 +0,0 @@
-using Syntax.Tokenization;
-using Syntax.Typing;
-
-namespace Syntax.Parsing.Expressions;
-
-public class FixedArrayInitializerNode(IEnumerable<Token> tokens, NubType elementType, int capacity) : ExpressionNode(tokens)
-{
-    public NubType ElementType { get; } = elementType;
-    public int Capacity { get; } = capacity;
-}

src/Syntax/Parsing/Expressions/FuncCallNode.cs

@@ -1,11 +0,0 @@
-using Syntax.Tokenization;
-
-namespace Syntax.Parsing.Expressions;
-
-public class FuncCallNode(IEnumerable<Token> tokens, ExpressionNode expression, List<ExpressionNode> parameters) : ExpressionNode(tokens)
-{
-    public ExpressionNode Expression = expression;
-    public List<ExpressionNode> Parameters { get; } = parameters;
-
-    public override string ToString() => $"{Expression}({string.Join(", ", Parameters)})";
-}

src/Syntax/Parsing/Expressions/IdentifierNode.cs

@@ -1,12 +0,0 @@
-using Common;
-using Syntax.Tokenization;
-
-namespace Syntax.Parsing.Expressions;
-
-public class IdentifierNode(IEnumerable<Token> tokens, Optional<string> @namespace, string name) : LValueNode(tokens)
-{
-    public Optional<string> Namespace { get; } = @namespace;
-    public string Name { get; } = name;
-
-    public override string ToString() => Namespace.HasValue ? $"{Namespace.Value}::{Name}" : Name;
-}

src/Syntax/Parsing/Expressions/LiteralNode.cs

@@ -1,9 +0,0 @@
-using Syntax.Tokenization;
-
-namespace Syntax.Parsing.Expressions;
-
-public class LiteralNode(IEnumerable<Token> tokens, string literal, LiteralKind kind) : ExpressionNode(tokens)
-{
-    public string Literal { get; } = literal;
-    public LiteralKind Kind { get; } = kind;
-}

src/Syntax/Parsing/Expressions/MemberAccessNode.cs

@@ -1,9 +0,0 @@
-using Syntax.Tokenization;
-
-namespace Syntax.Parsing.Expressions;
-
-public class MemberAccessNode(IEnumerable<Token> tokens, ExpressionNode expression, string member) : LValueNode(tokens)
-{
-    public ExpressionNode Expression { get; } = expression;
-    public string Member { get; } = member;
-}

src/Syntax/Parsing/Expressions/StructInitializerNode.cs

@@ -1,10 +0,0 @@
-using Syntax.Tokenization;
-using Syntax.Typing;
-
-namespace Syntax.Parsing.Expressions;
-
-public class StructInitializerNode(IEnumerable<Token> tokens, NubStructType structType, Dictionary<string, ExpressionNode> initializers) : ExpressionNode(tokens)
-{
-    public NubStructType StructType { get; } = structType;
-    public Dictionary<string, ExpressionNode> Initializers { get; } = initializers;
-}

src/Syntax/Parsing/Expressions/UnaryExpressionNode.cs

@@ -1,15 +0,0 @@
-using Syntax.Tokenization;
-
-namespace Syntax.Parsing.Expressions;
-
-public class UnaryExpressionNode(IEnumerable<Token> tokens, UnaryExpressionOperator @operator, ExpressionNode operand) : ExpressionNode(tokens)
-{
-    public UnaryExpressionOperator Operator { get; } = @operator;
-    public ExpressionNode Operand { get; } = operand;
-}
-
-public enum UnaryExpressionOperator
-{
-    Negate,
-    Invert
-}

src/Syntax/Parsing/Node.cs

@@ -1,8 +0,0 @@
-using Syntax.Tokenization;
-
-namespace Syntax.Parsing;
-
-public abstract class Node(IEnumerable<Token> tokens)
-{
-    public IEnumerable<Token> Tokens { get; set; } = tokens;
-}

src/Syntax/Parsing/Node/DefinitionNode.cs

@@ -0,0 +1,34 @@
+using Common;
+using Syntax.Tokenization;
+using Syntax.Typing;
+
+namespace Syntax.Parsing.Node;
+
+public abstract record DefinitionNode(IEnumerable<Token> Tokens, Optional<string> Documentation, string Namespace) : Node(Tokens);
+
+public record FuncParameter(string Name, NubType Type)
+{
+    public override string ToString() => $"{Name}: {Type}";
+}
+
+public interface IFuncSignature
+{
+    public string Name { get; }
+    public List<FuncParameter> Parameters { get; }
+    public NubType ReturnType { get; }
+
+    public string ToString() => $"{Name}({string.Join(", ", Parameters.Select(p => p.ToString()))}){": " + ReturnType}";
+}
+
+public record LocalFuncDefinitionNode(IEnumerable<Token> Tokens, Optional<string> Documentation, string Namespace, string Name, List<FuncParameter> Parameters, BlockNode Body, NubType ReturnType, bool Exported) : DefinitionNode(Tokens, Documentation, Namespace), IFuncSignature
+{
+    public override string ToString() => $"{Name}({string.Join(", ", Parameters.Select(p => p.ToString()))}){": " + ReturnType}";
+}
+
+public record ExternFuncDefinitionNode(IEnumerable<Token> Tokens, Optional<string> Documentation, string Namespace, string Name, string CallName, List<FuncParameter> Parameters, NubType ReturnType) : DefinitionNode(Tokens, Documentation, Namespace), IFuncSignature
+{
+    public override string ToString() => $"{Name}({string.Join(", ", Parameters.Select(p => p.ToString()))}){": " + ReturnType}";
+}
+
+public record StructField(string Name, NubType Type, Optional<ExpressionNode> Value);
+public record StructDefinitionNode(IEnumerable<Token> Tokens, Optional<string> Documentation, string Namespace, string Name, List<StructField> Fields) : DefinitionNode(Tokens, Documentation, Namespace);

src/Syntax/Parsing/Node/ExpressionNode.cs

@@ -0,0 +1,54 @@
+using Common;
+using Syntax.Tokenization;
+using Syntax.Typing;
+
+namespace Syntax.Parsing.Node;
+
+public abstract record ExpressionNode(IEnumerable<Token> Tokens) : Node(Tokens)
+{
+    private NubType? _type;
+    public NubType Type
+    {
+        get => _type ?? throw new Exception("Tried to access expression type before type was populated");
+        set => _type = value;
+    }
+}
+
+public abstract record LValueNode(IEnumerable<Token> Tokens) : ExpressionNode(Tokens);
+
+public record DereferenceNode(IEnumerable<Token> Tokens, ExpressionNode Expression) : LValueNode(Tokens);
+
+public record BinaryExpressionNode(IEnumerable<Token> Tokens, ExpressionNode Left, BinaryExpressionOperator Operator, ExpressionNode Right) : ExpressionNode(Tokens);
+
+public enum BinaryExpressionOperator
+{
+    Equal,
+    NotEqual,
+    GreaterThan,
+    GreaterThanOrEqual,
+    LessThan,
+    LessThanOrEqual,
+    Plus,
+    Minus,
+    Multiply,
+    Divide
+}
+
+public record UnaryExpressionNode(IEnumerable<Token> Tokens, UnaryExpressionOperator Operator, ExpressionNode Operand) : ExpressionNode(Tokens);
+
+public enum UnaryExpressionOperator
+{
+    Negate,
+    Invert
+}
+
+public record FuncCallNode(IEnumerable<Token> Tokens, ExpressionNode Expression, List<ExpressionNode> Parameters) : ExpressionNode(Tokens);
+public record IdentifierNode(IEnumerable<Token> Tokens, Optional<string> Namespace, string Name) : LValueNode(Tokens);
+public record ArrayInitializerNode(IEnumerable<Token> Tokens, ExpressionNode Capacity, NubType ElementType) : ExpressionNode(Tokens);
+public record ArrayIndexAccessNode(IEnumerable<Token> Tokens, ExpressionNode Array, ExpressionNode Index) : LValueNode(Tokens);
+public record AnonymousFuncNode(IEnumerable<Token> Tokens, List<FuncParameter> Parameters, BlockNode Body, NubType ReturnType) : ExpressionNode(Tokens);
+public record AddressOfNode(IEnumerable<Token> Tokens, LValueNode Expression) : ExpressionNode(Tokens);
+public record FixedArrayInitializerNode(IEnumerable<Token> Tokens, NubType ElementType, int Capacity) : ExpressionNode(Tokens);
+public record LiteralNode(IEnumerable<Token> Tokens, string Literal, LiteralKind Kind) : ExpressionNode(Tokens);
+public record MemberAccessNode(IEnumerable<Token> Tokens, ExpressionNode Expression, string Member) : LValueNode(Tokens);
+public record StructInitializerNode(IEnumerable<Token> Tokens, NubStructType StructType, Dictionary<string, ExpressionNode> Initializers) : ExpressionNode(Tokens);

src/Syntax/Parsing/Node/Node.cs

@@ -0,0 +1,6 @@
+using Syntax.Tokenization;
+
+namespace Syntax.Parsing.Node;
+
+public abstract record Node(IEnumerable<Token> Tokens);
+public record BlockNode(IEnumerable<Token> Tokens, List<StatementNode> Statements) : Node(Tokens);

src/Syntax/Parsing/Node/StatementNode.cs

@@ -0,0 +1,18 @@
+using Common;
+using Syntax.Tokenization;
+using Syntax.Typing;
+
+namespace Syntax.Parsing.Node;
+
+public record StatementNode(IEnumerable<Token> Tokens) : Node(Tokens);
+public record StatementExpressionNode(IEnumerable<Token> Tokens, ExpressionNode Expression) : StatementNode(Tokens);
+public record ReturnNode(IEnumerable<Token> Tokens, Optional<ExpressionNode> Value) : StatementNode(Tokens);
+public record MemberAssignmentNode(IEnumerable<Token> Tokens, MemberAccessNode MemberAccess, ExpressionNode Value) : StatementNode(Tokens);
+public record IfNode(IEnumerable<Token> Tokens, ExpressionNode Condition, BlockNode Body, Optional<Variant<IfNode, BlockNode>> Else) : StatementNode(Tokens);
+public record DereferenceAssignmentNode(IEnumerable<Token> Tokens, DereferenceNode Dereference, ExpressionNode Value) : StatementNode(Tokens);
+public record VariableAssignmentNode(IEnumerable<Token> Tokens, IdentifierNode Identifier, ExpressionNode Value) : StatementNode(Tokens);
+public record VariableDeclarationNode(IEnumerable<Token> Tokens, string Name, NubType Type) : StatementNode(Tokens);
+public record ContinueNode(IEnumerable<Token> Tokens) : StatementNode(Tokens);
+public record BreakNode(IEnumerable<Token> Tokens) : StatementNode(Tokens);
+public record ArrayIndexAssignmentNode(IEnumerable<Token> Tokens, ArrayIndexAccessNode ArrayIndexAccess, ExpressionNode Value) : StatementNode(Tokens);
+public record WhileNode(IEnumerable<Token> Tokens, ExpressionNode Condition, BlockNode Body) : StatementNode(Tokens);

src/Syntax/Parsing/Parser.cs

@@ -2,9 +2,7 @@
 using System.Diagnostics.CodeAnalysis;
 using Common;
 using Syntax.Diagnostics;
-using Syntax.Parsing.Definitions;
+using Syntax.Parsing.Node;
-using Syntax.Parsing.Expressions;
-using Syntax.Parsing.Statements;
 using Syntax.Tokenization;
 using Syntax.Typing;
 

src/Syntax/Parsing/Statements/ArrayIndexAssignmentNode.cs

@@ -1,10 +0,0 @@
-using Syntax.Parsing.Expressions;
-using Syntax.Tokenization;
-
-namespace Syntax.Parsing.Statements;
-
-public class ArrayIndexAssignmentNode(IEnumerable<Token> tokens, ArrayIndexAccessNode arrayIndexAccess, ExpressionNode value) : StatementNode(tokens)
-{
-    public ArrayIndexAccessNode ArrayIndexAccess { get; } = arrayIndexAccess;
-    public ExpressionNode Value { get; } = value;
-}

src/Syntax/Parsing/Statements/BlockNode.cs

@@ -1,8 +0,0 @@
-using Syntax.Tokenization;
-
-namespace Syntax.Parsing.Statements;
-
-public class BlockNode(IEnumerable<Token> tokens, List<StatementNode> statements) : Node(tokens)
-{
-    public List<StatementNode> Statements { get; } = statements;
-}

src/Syntax/Parsing/Statements/BreakNode.cs

@@ -1,5 +0,0 @@
-using Syntax.Tokenization;
-
-namespace Syntax.Parsing.Statements;
-
-public class BreakNode(IEnumerable<Token> tokens) : StatementNode(tokens);

src/Syntax/Parsing/Statements/ContinueNode.cs

@@ -1,5 +0,0 @@
-using Syntax.Tokenization;
-
-namespace Syntax.Parsing.Statements;
-
-public class ContinueNode(IEnumerable<Token> tokens) : StatementNode(tokens);

src/Syntax/Parsing/Statements/DereferenceAssignmentNode.cs

@@ -1,10 +0,0 @@
-using Syntax.Parsing.Expressions;
-using Syntax.Tokenization;
-
-namespace Syntax.Parsing.Statements;
-
-public class DereferenceAssignmentNode(IEnumerable<Token> tokens, DereferenceNode dereference, ExpressionNode value) : StatementNode(tokens)
-{
-    public DereferenceNode Dereference { get; } = dereference;
-    public ExpressionNode Value { get; } = value;
-}

src/Syntax/Parsing/Statements/IfNode.cs

@@ -1,12 +0,0 @@
-using Common;
-using Syntax.Parsing.Expressions;
-using Syntax.Tokenization;
-
-namespace Syntax.Parsing.Statements;
-
-public class IfNode(IEnumerable<Token> tokens, ExpressionNode condition, BlockNode body, Optional<Variant<IfNode, BlockNode>> @else) : StatementNode(tokens)
-{
-    public ExpressionNode Condition { get; } = condition;
-    public BlockNode Body { get; } = body;
-    public Optional<Variant<IfNode, BlockNode>> Else { get; } = @else;
-}

src/Syntax/Parsing/Statements/MemberAssignmentNode.cs

@@ -1,10 +0,0 @@
-using Syntax.Parsing.Expressions;
-using Syntax.Tokenization;
-
-namespace Syntax.Parsing.Statements;
-
-public class MemberAssignmentNode(IEnumerable<Token> tokens, MemberAccessNode expression, ExpressionNode value) : StatementNode(tokens)
-{
-    public MemberAccessNode MemberAccess { get; } = expression;
-    public ExpressionNode Value { get; } = value;
-}

src/Syntax/Parsing/Statements/ReturnNode.cs

@@ -1,10 +0,0 @@
-using Common;
-using Syntax.Parsing.Expressions;
-using Syntax.Tokenization;
-
-namespace Syntax.Parsing.Statements;
-
-public class ReturnNode(IEnumerable<Token> tokens, Optional<ExpressionNode> value) : StatementNode(tokens)
-{
-    public Optional<ExpressionNode> Value { get; } = value;
-}

src/Syntax/Parsing/Statements/StatementExpressionNode.cs

@@ -1,9 +0,0 @@
-using Syntax.Parsing.Expressions;
-using Syntax.Tokenization;
-
-namespace Syntax.Parsing.Statements;
-
-public class StatementExpressionNode(IEnumerable<Token> tokens, ExpressionNode expression) : StatementNode(tokens)
-{
-    public ExpressionNode Expression { get; } = expression;
-}

src/Syntax/Parsing/Statements/StatementNode.cs

@@ -1,5 +0,0 @@
-using Syntax.Tokenization;
-
-namespace Syntax.Parsing.Statements;
-
-public abstract class StatementNode(IEnumerable<Token> tokens) : Node(tokens);

src/Syntax/Parsing/Statements/VariableAssignmentNode.cs

@@ -1,10 +0,0 @@
-using Syntax.Parsing.Expressions;
-using Syntax.Tokenization;
-
-namespace Syntax.Parsing.Statements;
-
-public class VariableAssignmentNode(IEnumerable<Token> tokens, IdentifierNode identifier, ExpressionNode value) : StatementNode(tokens)
-{
-    public IdentifierNode Identifier { get; } = identifier;
-    public ExpressionNode Value { get; } = value;
-}

src/Syntax/Parsing/Statements/VariableDeclarationNode.cs

@@ -1,10 +0,0 @@
-using Syntax.Tokenization;
-using Syntax.Typing;
-
-namespace Syntax.Parsing.Statements;
-
-public class VariableDeclarationNode(IEnumerable<Token> tokens, string name, NubType type) : StatementNode(tokens)
-{
-    public string Name { get; } = name;
-    public NubType Type { get; } = type;
-}

src/Syntax/Parsing/Statements/WhileNode.cs

@@ -1,10 +0,0 @@
-using Syntax.Parsing.Expressions;
-using Syntax.Tokenization;
-
-namespace Syntax.Parsing.Statements;
-
-public class WhileNode(IEnumerable<Token> tokens, ExpressionNode condition, BlockNode body) : StatementNode(tokens)
-{
-    public ExpressionNode Condition { get; } = condition;
-    public BlockNode Body { get; } = body;
-}

src/Syntax/Typing/TypeChecker.cs

@@ -1,9 +1,7 @@
 using System.Diagnostics;
 using Syntax.Diagnostics;
 using Syntax.Parsing;
-using Syntax.Parsing.Definitions;
+using Syntax.Parsing.Node;
-using Syntax.Parsing.Expressions;
-using Syntax.Parsing.Statements;
 using Syntax.Tokenization;
 
 namespace Syntax.Typing;