...

src/compiler/CLI/Program.cs

@@ -4,6 +4,7 @@ using Generation.QBE;
 using Syntax;
 using Syntax.Binding;
 using Syntax.Diagnostics;
+using Syntax.Node;
 using Syntax.Parsing;
 using Syntax.Tokenization;
 using Binder = Syntax.Binding.Binder;

src/compiler/Generation/QBE/QBEGenerator.cs

@@ -3,7 +3,6 @@ using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Text;
 using Syntax;
-using Syntax.Binding;
 using Syntax.Node;
 using Syntax.Tokenization;
 
@@ -543,7 +542,7 @@ public static class QBEGenerator
         };
     }
 
-    private static void EmitFuncDefinition(BoundNode debugNode, string name, List<BoundFuncParameter> parameters, NubType returnType, BoundBlockNode body, bool exported)
+    private static void EmitFuncDefinition(BoundNode debugNode, string name, List<FuncParameter> parameters, NubType returnType, BoundBlock body, bool exported)
     {
         _variables.Clear();
         _variableScopes.Clear();
@@ -689,7 +688,7 @@ public static class QBEGenerator
         EmitCopyIntoOrInitialize(assignment.Value, destination.Name);
     }
 
-    private static void EmitBlock(BoundBlockNode block, List<Variable>? variables = null)
+    private static void EmitBlock(BoundBlock block, List<Variable>? variables = null)
     {
         _variableScopes.Push(_variables.Count);
         if (variables != null)

src/compiler/Syntax/Binding/Binder.cs

@@ -1,7 +1,6 @@
 using Common;
 using Syntax.Diagnostics;
 using Syntax.Node;
-using Syntax.Parsing;
 using Syntax.Tokenization;
 using UnaryExpressionNode = Syntax.Node.UnaryExpressionNode;
 
@@ -55,14 +54,12 @@ public static class Binder
 
         foreach (var function in node.Functions)
         {
-            var parameters = new List<BoundFuncParameter>();
             foreach (var parameter in function.Parameters)
             {
-                parameters.Add(new BoundFuncParameter(parameter.Name, parameter.Type));
                 _variables[parameter.Name] = parameter.Type;
             }
 
-            functions.Add(new BoundImplementationFuncNode(function.Tokens, function.Name, parameters, function.ReturnType, BindBlock(function.Body)));
+            functions.Add(new BoundImplementationFuncNode(function.Tokens, function.Name, function.Parameters, function.ReturnType, BindBlock(function.Body)));
         }
 
         return new BoundTraitImplementationDefinitionNode(node.Tokens, node.Namespace, node.TraitType, node.ForType, functions);
@@ -74,14 +71,7 @@ public static class Binder
 
         foreach (var func in node.Functions)
         {
-            var parameters = new List<BoundFuncParameter>();
+            functions.Add(new BountTraitFunc(func.Name, func.Parameters, func.ReturnType));
-
-            foreach (var parameter in func.Parameters)
-            {
-                parameters.Add(new BoundFuncParameter(parameter.Name, parameter.Type));
-            }
-
-            functions.Add(new BountTraitFunc(func.Name, parameters, func.ReturnType));
         }
 
         return new BoundTraitDefinitionNode(node.Tokens, node.Namespace, node.Name, functions);
@@ -120,14 +110,7 @@ public static class Binder
 
     private static BoundExternFuncDefinitionNode BindExternFuncDefinition(ExternFuncDefinitionNode node)
     {
-        var parameters = new List<BoundFuncParameter>();
+        return new BoundExternFuncDefinitionNode(node.Tokens, node.Namespace, node.Name, node.CallName, node.Parameters, node.ReturnType);
-
-        foreach (var parameter in node.Parameters)
-        {
-            parameters.Add(new BoundFuncParameter(parameter.Name, parameter.Type));
-        }
-
-        return new BoundExternFuncDefinitionNode(node.Tokens, node.Namespace, node.Name, node.CallName, parameters, node.ReturnType);
     }
 
     private static BoundLocalFuncDefinitionNode BindLocalFuncDefinition(LocalFuncDefinitionNode node)
@@ -135,20 +118,17 @@ public static class Binder
         _variables.Clear();
         _funcReturnType = node.ReturnType;
 
-        var parameters = new List<BoundFuncParameter>();
-
         foreach (var parameter in node.Parameters)
         {
-            parameters.Add(new BoundFuncParameter(parameter.Name, parameter.Type));
             _variables[parameter.Name] = parameter.Type;
         }
 
         var body = BindBlock(node.Body);
 
-        return new BoundLocalFuncDefinitionNode(node.Tokens, node.Namespace, node.Name, parameters, body, node.ReturnType, node.Exported);
+        return new BoundLocalFuncDefinitionNode(node.Tokens, node.Namespace, node.Name, node.Parameters, body, node.ReturnType, node.Exported);
     }
 
-    private static BoundBlockNode BindBlock(BlockNode node)
+    private static BoundBlock BindBlock(BlockNode node)
     {
         var statements = new List<BoundStatementNode>();
 
@@ -157,7 +137,7 @@ public static class Binder
             statements.Add(BindStatement(statement));
         }
 
-        return new BoundBlockNode(node.Tokens, statements);
+        return new BoundBlock(node.Tokens, statements);
     }
 
     private static BoundStatementNode BindStatement(StatementNode node)
@@ -195,11 +175,11 @@ public static class Binder
 
     private static BoundIfNode BindIf(IfNode statement)
     {
-        var elseStatement = Optional.Empty<Variant<BoundIfNode, BoundBlockNode>>();
+        var elseStatement = Optional.Empty<Variant<BoundIfNode, BoundBlock>>();
 
         if (statement.Else.HasValue)
         {
-            elseStatement = statement.Else.Value.Match<Variant<BoundIfNode, BoundBlockNode>>
+            elseStatement = statement.Else.Value.Match<Variant<BoundIfNode, BoundBlock>>
             (
                 elseIf => BindIf(elseIf),
                 @else => BindBlock(@else)
@@ -286,19 +266,11 @@ public static class Binder
 
     private static BoundAnonymousFuncNode BindAnonymousFunc(AnonymousFuncNode expression)
     {
-        var parameters = new List<BoundFuncParameter>();
+        var parameterTypes = expression.Parameters.Select(x => x.Type).ToList();
-        var parameterTypes = new List<NubType>();
-
-        foreach (var parameter in expression.Parameters)
-        {
-            var boundParameter = new BoundFuncParameter(parameter.Name, parameter.Type);
-            parameters.Add(boundParameter);
-            parameterTypes.Add(boundParameter.Type);
-        }
 
         var body = BindBlock(expression.Body);
 
-        return new BoundAnonymousFuncNode(expression.Tokens, new NubFuncType(expression.ReturnType, parameterTypes), parameters, body, expression.ReturnType);
+        return new BoundAnonymousFuncNode(expression.Tokens, new NubFuncType(expression.ReturnType, parameterTypes), expression.Parameters, body, expression.ReturnType);
     }
 
     private static BoundArrayIndexAccessNode BindArrayIndexAccess(ArrayIndexAccessNode expression)

src/compiler/Syntax/Binding/BoundSyntaxTree.cs

@@ -1,5 +0,0 @@
-using Syntax.Node;
-
-namespace Syntax.Binding;
-
-public record BoundSyntaxTree(string Namespace, List<BoundDefinitionNode> Definitions);

src/compiler/Syntax/Node/Definition.cs

@@ -7,16 +7,15 @@ public abstract record DefinitionNode(IEnumerable<Token> Tokens, string Namespac
 public abstract record BoundDefinitionNode(IEnumerable<Token> Tokens, string Namespace) : BoundNode(Tokens);
 
 public record FuncParameter(string Name, NubType Type);
-public record BoundFuncParameter(string Name, NubType Type);
 
 public abstract record FuncDefinition(IEnumerable<Token> Tokens, string Namespace, string Name, List<FuncParameter> Parameters, NubType ReturnType) : DefinitionNode(Tokens, Namespace);
-public abstract record BoundFuncDefinition(IEnumerable<Token> Tokens, string Namespace, string Name, List<BoundFuncParameter> Parameters, NubType ReturnType) : BoundDefinitionNode(Tokens, Namespace);
+public abstract record BoundFuncDefinition(IEnumerable<Token> Tokens, string Namespace, string Name, List<FuncParameter> Parameters, NubType ReturnType) : BoundDefinitionNode(Tokens, Namespace);
 
 public record LocalFuncDefinitionNode(IEnumerable<Token> Tokens, string Namespace, string Name, List<FuncParameter> Parameters, BlockNode Body, NubType ReturnType, bool Exported) : FuncDefinition(Tokens, Namespace, Name, Parameters, ReturnType);
-public record BoundLocalFuncDefinitionNode(IEnumerable<Token> Tokens, string Namespace, string Name, List<BoundFuncParameter> Parameters, BoundBlockNode Body, NubType ReturnType, bool Exported) : BoundFuncDefinition(Tokens, Namespace, Name, Parameters, ReturnType);
+public record BoundLocalFuncDefinitionNode(IEnumerable<Token> Tokens, string Namespace, string Name, List<FuncParameter> Parameters, BoundBlock Body, NubType ReturnType, bool Exported) : BoundFuncDefinition(Tokens, Namespace, Name, Parameters, ReturnType);
 
 public record ExternFuncDefinitionNode(IEnumerable<Token> Tokens, string Namespace, string Name, string CallName, List<FuncParameter> Parameters, NubType ReturnType) : FuncDefinition(Tokens, Namespace, Name, Parameters, ReturnType);
-public record BoundExternFuncDefinitionNode(IEnumerable<Token> Tokens, string Namespace, string Name, string CallName, List<BoundFuncParameter> Parameters, NubType ReturnType) : BoundFuncDefinition(Tokens, Namespace, Name, Parameters, ReturnType);
+public record BoundExternFuncDefinitionNode(IEnumerable<Token> Tokens, string Namespace, string Name, string CallName, List<FuncParameter> Parameters, NubType ReturnType) : BoundFuncDefinition(Tokens, Namespace, Name, Parameters, ReturnType);
 
 public record StructField(string Name, NubType Type, Optional<ExpressionNode> Value);
 public record BoundStructField(string Name, NubType Type, Optional<BoundExpressionNode> Value);
@@ -25,13 +24,13 @@ public record StructDefinitionNode(IEnumerable<Token> Tokens, string Namespace,
 public record BoundStructDefinitionNode(IEnumerable<Token> Tokens, string Namespace, string Name, List<BoundStructField> Fields) : BoundDefinitionNode(Tokens, Namespace);
 
 public record TraitFunc(string Name, List<FuncParameter> Parameters, NubType ReturnType);
-public record BountTraitFunc(string Name, List<BoundFuncParameter> Parameters, NubType ReturnType);
+public record BountTraitFunc(string Name, List<FuncParameter> Parameters, NubType ReturnType);
 
 public record TraitDefinitionNode(IEnumerable<Token> Tokens, string Namespace, string Name, List<TraitFunc> Functions) : DefinitionNode(Tokens, Namespace);
 public record BoundTraitDefinitionNode(IEnumerable<Token> Tokens, string Namespace, string Name, List<BountTraitFunc> Functions) : BoundDefinitionNode(Tokens, Namespace);
 
 public record ImplementationFuncNode(IEnumerable<Token> Tokens, string Name, List<FuncParameter> Parameters, NubType ReturnType, BlockNode Body) : BoundNode(Tokens);
-public record BoundImplementationFuncNode(IEnumerable<Token> Tokens, string Name, List<BoundFuncParameter> Parameters, NubType ReturnType, BoundBlockNode Body) : BoundNode(Tokens);
+public record BoundImplementationFuncNode(IEnumerable<Token> Tokens, string Name, List<FuncParameter> Parameters, NubType ReturnType, BoundBlock Body) : BoundNode(Tokens);
 
 public record BoundTraitImplementationDefinitionNode(IEnumerable<Token> Tokens, string Namespace, NubType TraitType, NubType ForType, List<BoundImplementationFuncNode> Functions) : BoundDefinitionNode(Tokens, Namespace);
 public record TraitImplementationDefinitionNode(IEnumerable<Token> Tokens, string Namespace, NubType TraitType, NubType ForType, List<ImplementationFuncNode> Functions) : DefinitionNode(Tokens, Namespace);

src/compiler/Syntax/Node/Expression.cs

@@ -45,7 +45,7 @@ public record ArrayIndexAccessNode(IEnumerable<Token> Tokens, ExpressionNode Arr
 public record BoundArrayIndexAccessNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Array, BoundExpressionNode Index) : BoundExpressionNode(Tokens, Type);
 
 public record AnonymousFuncNode(IEnumerable<Token> Tokens, List<FuncParameter> Parameters, BlockNode Body, NubType ReturnType) : ExpressionNode(Tokens);
-public record BoundAnonymousFuncNode(IEnumerable<Token> Tokens, NubType Type, List<BoundFuncParameter> Parameters, BoundBlockNode Body, NubType ReturnType) : BoundExpressionNode(Tokens, Type);
+public record BoundAnonymousFuncNode(IEnumerable<Token> Tokens, NubType Type, List<FuncParameter> Parameters, BoundBlock Body, NubType ReturnType) : BoundExpressionNode(Tokens, Type);
 
 public record AddressOfNode(IEnumerable<Token> Tokens, ExpressionNode Expression) : ExpressionNode(Tokens);
 public record BoundAddressOfNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Expression) : BoundExpressionNode(Tokens, Type);

src/compiler/Syntax/Node/Node.cs

@@ -6,4 +6,5 @@ public abstract record Node(IEnumerable<Token> Tokens);
 public abstract record BoundNode(IEnumerable<Token> Tokens);
 
 public record BlockNode(IEnumerable<Token> Tokens, List<StatementNode> Statements) : Node(Tokens);
-public record BoundBlockNode(IEnumerable<Token> Tokens, List<BoundStatementNode> Statements) : BoundNode(Tokens);
+
+public record BoundBlock(IEnumerable<Token> Tokens, List<BoundStatementNode> Statements);

src/compiler/Syntax/Node/Statement.cs

@@ -17,7 +17,7 @@ public record AssignmentNode(IEnumerable<Token> Tokens, ExpressionNode Expressio
 public record BoundAssignmentNode(IEnumerable<Token> Tokens, BoundExpressionNode Expression, BoundExpressionNode Value) : BoundStatementNode(Tokens);
 
 public record IfNode(IEnumerable<Token> Tokens, ExpressionNode Condition, BlockNode Body, Optional<Variant<IfNode, BlockNode>> Else) : StatementNode(Tokens);
-public record BoundIfNode(IEnumerable<Token> Tokens, BoundExpressionNode Condition, BoundBlockNode Body, Optional<Variant<BoundIfNode, BoundBlockNode>> Else) : BoundStatementNode(Tokens);
+public record BoundIfNode(IEnumerable<Token> Tokens, BoundExpressionNode Condition, BoundBlock Body, Optional<Variant<BoundIfNode, BoundBlock>> Else) : BoundStatementNode(Tokens);
 
 public record VariableDeclarationNode(IEnumerable<Token> Tokens, string Name, Optional<NubType> ExplicitType, Optional<ExpressionNode> Assignment) : StatementNode(Tokens);
 public record BoundVariableDeclarationNode(IEnumerable<Token> Tokens, string Name, Optional<NubType> ExplicitType, Optional<BoundExpressionNode> Assignment, NubType Type) : BoundStatementNode(Tokens);
@@ -29,4 +29,4 @@ public record BreakNode(IEnumerable<Token> Tokens) : StatementNode(Tokens);
 public record BoundBreakNode(IEnumerable<Token> Tokens) : BoundStatementNode(Tokens);
 
 public record WhileNode(IEnumerable<Token> Tokens, ExpressionNode Condition, BlockNode Body) : StatementNode(Tokens);
-public record BoundWhileNode(IEnumerable<Token> Tokens, BoundExpressionNode Condition, BoundBlockNode Body) : BoundStatementNode(Tokens);
+public record BoundWhileNode(IEnumerable<Token> Tokens, BoundExpressionNode Condition, BoundBlock Body) : BoundStatementNode(Tokens);

src/compiler/Syntax/Node/SyntaxTree.cs

@@ -0,0 +1,4 @@
+namespace Syntax.Node;
+
+public record SyntaxTree(string Namespace, List<DefinitionNode> Definitions);
+public record BoundSyntaxTree(string Namespace, List<BoundDefinitionNode> Definitions);

src/compiler/Syntax/Parsing/SyntaxTree.cs

@@ -1,5 +0,0 @@
-using Syntax.Node;
-
-namespace Syntax.Parsing;
-
-public record SyntaxTree(string Namespace, List<DefinitionNode> Definitions);