...

src/compiler/NubLang.CLI/Program.cs

@@ -67,7 +67,7 @@ for (var i = 0; i < args.Length; i++)
 }
 
 var diagnostics = new List<Diagnostic>();
-var syntaxTrees = new Dictionary<string, SyntaxTree>();
+var syntaxTrees = new Dictionary<string, ParseTree>();
 
 foreach (var file in options.Files)
 {

src/compiler/NubLang/Syntax/Binding/Binder.cs

@@ -8,7 +8,7 @@ namespace NubLang.Syntax.Binding;
 
 public sealed class Binder
 {
-    private readonly SyntaxTree _syntaxTree;
+    private readonly ParseTree _parseTree;
     private readonly DefinitionTable _definitionTable;
 
     private readonly Stack<Scope> _scopes = [];
@@ -16,9 +16,9 @@ public sealed class Binder
 
     private Scope Scope => _scopes.Peek();
 
-    public Binder(SyntaxTree syntaxTree, DefinitionTable definitionTable)
+    public Binder(ParseTree parseTree, DefinitionTable definitionTable)
     {
-        _syntaxTree = syntaxTree;
+        _parseTree = parseTree;
         _definitionTable = definitionTable;
     }
 
@@ -30,7 +30,7 @@ public sealed class Binder
         var diagnostics = new List<Diagnostic>();
         var definitions = new List<BoundDefinition>();
 
-        foreach (var definition in _syntaxTree.Definitions)
+        foreach (var definition in _parseTree.Definitions)
         {
             try
             {
@@ -42,7 +42,7 @@ public sealed class Binder
             }
         }
 
-        return new BoundSyntaxTree(_syntaxTree.Namespace, definitions, diagnostics);
+        return new BoundSyntaxTree(_parseTree.Namespace, definitions, diagnostics);
     }
 
     private BoundDefinition BindDefinition(DefinitionSyntax node)
@@ -309,7 +309,7 @@ public sealed class Binder
 
     private BoundExpression BindIdentifier(IdentifierSyntax expression)
     {
-        var @namespace = expression.Namespace.Or(_syntaxTree.Namespace);
+        var @namespace = expression.Namespace.Or(_parseTree.Namespace);
         var localFuncs = _definitionTable.LookupLocalFunc(@namespace, expression.Name).ToArray();
         if (localFuncs.Length > 0)
         {
@@ -365,7 +365,7 @@ public sealed class Binder
             _ => throw new ArgumentOutOfRangeException()
         };
 
-        return new BoundLiteral(expression.Tokens, type, expression.Literal, expression.Kind);
+        return new BoundLiteral(expression.Tokens, type, expression.Value, expression.Kind);
     }
 
     private BoundExpression BindMemberAccess(MemberAccessSyntax expression)

src/compiler/NubLang/Syntax/Binding/DefinitionTable.cs

@@ -6,7 +6,7 @@ public class DefinitionTable
 {
     private readonly List<DefinitionSyntax> _definitions;
 
-    public DefinitionTable(IEnumerable<SyntaxTree> syntaxTrees)
+    public DefinitionTable(IEnumerable<ParseTree> syntaxTrees)
     {
         _definitions = syntaxTrees.SelectMany(x => x.Definitions).ToList();
     }

src/compiler/NubLang/Syntax/Generics/GenericInstantiator.cs

@@ -0,0 +1,30 @@
+using NubLang.Syntax.Generics.Node;
+using NubLang.Syntax.Parsing.Node;
+
+namespace NubLang.Syntax.Generics;
+
+public class GenericInstantiator
+{
+    private readonly ParseTree _parseTree;
+
+    public GenericInstantiator(ParseTree parseTree)
+    {
+        _parseTree = parseTree;
+    }
+
+    public UnboundTree Visit()
+    {
+        var unboundDefinitions = new List<UnboundDefinition>();
+
+        foreach (var definition in _parseTree.Definitions)
+        {
+            switch (definition)
+            {
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(definition));
+            }
+        }
+
+        return new UnboundTree(_parseTree.Namespace, unboundDefinitions, _parseTree.Diagnostics);
+    }
+}

src/compiler/NubLang/Syntax/Generics/Node/DefinitionSyntax.cs

@@ -0,0 +1,26 @@
+using NubLang.Common;
+using NubLang.Syntax.Tokenization;
+
+namespace NubLang.Syntax.Generics.Node;
+
+public record UnboundGenericParameter(IReadOnlyList<Token> Tokens, string Name) : UnboundNode(Tokens);
+
+public abstract record UnboundDefinition(IReadOnlyList<Token> Tokens, string Namespace, IReadOnlyList<UnboundGenericParameter> Parameters) : UnboundNode(Tokens);
+
+public record UnboundFuncParameter(IReadOnlyList<Token> Tokens, string Name, UnboundType Type) : UnboundNode(Tokens);
+
+public record UnboundFuncSignature(IReadOnlyList<Token> Tokens, IReadOnlyList<UnboundFuncParameter> Parameters, UnboundType ReturnType) : UnboundNode(Tokens);
+
+public record UnboundLocalFunc(IReadOnlyList<Token> Tokens, string Namespace, IReadOnlyList<UnboundGenericParameter> Parameters, string Name, UnboundFuncSignature Signature, UnboundBlock Body) : UnboundDefinition(Tokens, Namespace, Parameters);
+
+public record UnboundExternFunc(IReadOnlyList<Token> Tokens, string Namespace, IReadOnlyList<UnboundGenericParameter> Parameters, string Name, string CallName, UnboundFuncSignature Signature) : UnboundDefinition(Tokens, Namespace, Parameters);
+
+public record UnboundStructField(IReadOnlyList<Token> Tokens, int Index, string Name, UnboundType Type, Optional<UnboundExpression> Value) : UnboundNode(Tokens);
+
+public record UnboundStructFunc(IReadOnlyList<Token> Tokens, string Name, UnboundFuncSignature Signature, UnboundBlock Body) : UnboundNode(Tokens);
+
+public record UnboundStruct(IReadOnlyList<Token> Tokens, string Namespace, IReadOnlyList<UnboundGenericParameter> Parameters, string Name, IReadOnlyList<UnboundStructField> Fields, IReadOnlyList<UnboundStructFunc> Funcs) : UnboundDefinition(Tokens, Namespace, Parameters);
+
+public record UnboundInterfaceFunc(IReadOnlyList<Token> Tokens, string Name, UnboundFuncSignature Signature) : UnboundNode(Tokens);
+
+public record UnboundInterface(IReadOnlyList<Token> Tokens, string Namespace, IReadOnlyList<UnboundGenericParameter> Parameters, string Name, IReadOnlyList<UnboundInterfaceFunc> Functions) : UnboundDefinition(Tokens, Namespace, Parameters);

src/compiler/NubLang/Syntax/Generics/Node/ExpressionSyntax.cs

@@ -0,0 +1,52 @@
+using NubLang.Common;
+using NubLang.Syntax.Tokenization;
+
+namespace NubLang.Syntax.Generics.Node;
+
+public enum UnboundUnaryOperator
+{
+    Negate,
+    Invert
+}
+
+public enum UnboundBinaryOperator
+{
+    Equal,
+    NotEqual,
+    GreaterThan,
+    GreaterThanOrEqual,
+    LessThan,
+    LessThanOrEqual,
+    Plus,
+    Minus,
+    Multiply,
+    Divide
+}
+
+public abstract record UnboundExpression(IReadOnlyList<Token> Tokens) : UnboundNode(Tokens);
+
+public record UnboundBinaryExpression(IReadOnlyList<Token> Tokens, UnboundExpression Left, UnboundBinaryOperator Operator, UnboundExpression Right) : UnboundExpression(Tokens);
+
+public record UnboundUnaryExpression(IReadOnlyList<Token> Tokens, UnboundUnaryOperator Operator, UnboundExpression Operand) : UnboundExpression(Tokens);
+
+public record UnboundFuncCall(IReadOnlyList<Token> Tokens, UnboundExpression Expression, IReadOnlyList<UnboundExpression> Parameters) : UnboundExpression(Tokens);
+
+public record UnboundIdentifier(IReadOnlyList<Token> Tokens, Optional<string> Namespace, string Name) : UnboundExpression(Tokens);
+
+public record UnboundArrayInitializer(IReadOnlyList<Token> Tokens, UnboundExpression Capacity, UnboundType ElementType) : UnboundExpression(Tokens);
+
+public record UnboundArrayIndexAccess(IReadOnlyList<Token> Tokens, UnboundExpression Target, UnboundExpression Index) : UnboundExpression(Tokens);
+
+public record UnboundArrowFuncParameter(IReadOnlyList<Token> Tokens, string Name) : UnboundExpression(Tokens);
+
+public record UnboundArrowFunc(IReadOnlyList<Token> Tokens, IReadOnlyList<UnboundArrowFuncParameter> Parameters, UnboundBlock Body) : UnboundExpression(Tokens);
+
+public record UnboundAddressOf(IReadOnlyList<Token> Tokens, UnboundExpression Expression) : UnboundExpression(Tokens);
+
+public record UnboundLiteral(IReadOnlyList<Token> Tokens, string Value, LiteralKind Kind) : UnboundExpression(Tokens);
+
+public record UnboundMemberAccess(IReadOnlyList<Token> Tokens, UnboundExpression Target, string Member) : UnboundExpression(Tokens);
+
+public record UnboundStructInitializer(IReadOnlyList<Token> Tokens, UnboundType StructType, Dictionary<string, UnboundExpression> Initializers) : UnboundExpression(Tokens);
+
+public record UnboundDereference(IReadOnlyList<Token> Tokens, UnboundExpression Expression) : UnboundExpression(Tokens);

src/compiler/NubLang/Syntax/Generics/Node/StatementSyntax.cs

@@ -0,0 +1,22 @@
+using NubLang.Common;
+using NubLang.Syntax.Tokenization;
+
+namespace NubLang.Syntax.Generics.Node;
+
+public record UnboundStatement(IReadOnlyList<Token> Tokens) : UnboundNode(Tokens);
+
+public record UnboundStatementExpression(IReadOnlyList<Token> Tokens, UnboundExpression Expression) : UnboundStatement(Tokens);
+
+public record UnboundReturn(IReadOnlyList<Token> Tokens, Optional<UnboundExpression> Value) : UnboundStatement(Tokens);
+
+public record UnboundAssignment(IReadOnlyList<Token> Tokens, UnboundExpression Target, UnboundExpression Value) : UnboundStatement(Tokens);
+
+public record UnboundIf(IReadOnlyList<Token> Tokens, UnboundExpression Condition, UnboundBlock Body, Optional<Variant<UnboundIf, UnboundBlock>> Else) : UnboundStatement(Tokens);
+
+public record UnboundVariableDeclaration(IReadOnlyList<Token> Tokens, string Name, Optional<UnboundType> ExplicitType, Optional<UnboundExpression> Assignment) : UnboundStatement(Tokens);
+
+public record UnboundContinue(IReadOnlyList<Token> Tokens) : UnboundStatement(Tokens);
+
+public record UnboundBreak(IReadOnlyList<Token> Tokens) : UnboundStatement(Tokens);
+
+public record UnboundWhile(IReadOnlyList<Token> Tokens, UnboundExpression Condition, UnboundBlock Body) : UnboundStatement(Tokens);

src/compiler/NubLang/Syntax/Generics/Node/TypeSyntax.cs

@@ -0,0 +1,36 @@
+using NubLang.Syntax.Tokenization;
+
+namespace NubLang.Syntax.Generics.Node;
+
+public enum UnboundPrimitiveTypeKind
+{
+    I64,
+    I32,
+    I16,
+    I8,
+    U64,
+    U32,
+    U16,
+    U8,
+    F64,
+    F32,
+    Bool
+}
+
+public abstract record UnboundType(IReadOnlyList<Token> Tokens) : UnboundNode(Tokens);
+
+public record UnboundFuncType(IReadOnlyList<Token> Tokens, IReadOnlyList<UnboundType> Parameters, UnboundType ReturnType) : UnboundType(Tokens);
+
+public record UnboundPointerType(IReadOnlyList<Token> Tokens, UnboundType BaseType) : UnboundType(Tokens);
+
+public record UnboundVoidType(IReadOnlyList<Token> Tokens) : UnboundType(Tokens);
+
+public record UnboundPrimitiveType(IReadOnlyList<Token> Tokens, UnboundPrimitiveTypeKind SyntaxKind) : UnboundType(Tokens);
+
+public record UnboundCStringType(IReadOnlyList<Token> Tokens) : UnboundType(Tokens);
+
+public record UnboundStringType(IReadOnlyList<Token> Tokens) : UnboundType(Tokens);
+
+public record UnboundCustomType(IReadOnlyList<Token> Tokens, string Namespace, string Name, IReadOnlyList<UnboundType> Arguments) : UnboundType(Tokens);
+
+public record UnboundArrayType(IReadOnlyList<Token> Tokens, UnboundType BaseType) : UnboundType(Tokens);

src/compiler/NubLang/Syntax/Generics/Node/UnboundTree.cs

@@ -0,0 +1,10 @@
+using NubLang.Diagnostics;
+using NubLang.Syntax.Tokenization;
+
+namespace NubLang.Syntax.Generics.Node;
+
+public record UnboundTree(string Namespace, IReadOnlyList<UnboundDefinition> Definitions, IReadOnlyList<Diagnostic> Diagnostics);
+
+public abstract record UnboundNode(IReadOnlyList<Token> Tokens);
+
+public record UnboundBlock(IReadOnlyList<Token> Tokens, IReadOnlyList<UnboundStatement> Statements) : UnboundNode(Tokens);

src/compiler/NubLang/Syntax/Parsing/Node/ExpressionSyntax.cs

@@ -43,7 +43,7 @@ public record ArrowFuncSyntax(IReadOnlyList<Token> Tokens, IReadOnlyList<ArrowFu
 
 public record AddressOfSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Expression) : ExpressionSyntax(Tokens);
 
-public record LiteralSyntax(IReadOnlyList<Token> Tokens, string Literal, LiteralKind Kind) : ExpressionSyntax(Tokens);
+public record LiteralSyntax(IReadOnlyList<Token> Tokens, string Value, LiteralKind Kind) : ExpressionSyntax(Tokens);
 
 public record MemberAccessSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Target, string Member) : ExpressionSyntax(Tokens);
 

src/compiler/NubLang/Syntax/Parsing/Node/ParseTree.cs

@@ -3,7 +3,7 @@ using NubLang.Syntax.Tokenization;
 
 namespace NubLang.Syntax.Parsing.Node;
 
-public record SyntaxTree(string Namespace, IReadOnlyList<DefinitionSyntax> Definitions, IReadOnlyList<Diagnostic> Diagnostics);
+public record ParseTree(string Namespace, IReadOnlyList<DefinitionSyntax> Definitions, IReadOnlyList<Diagnostic> Diagnostics);
 
 public abstract record SyntaxNode(IReadOnlyList<Token> Tokens);
 

src/compiler/NubLang/Syntax/Parsing/Parser.cs

@@ -21,7 +21,7 @@ public sealed class Parser
         _tokens = tokens;
     }
 
-    public SyntaxTree Parse()
+    public ParseTree Parse()
     {
         _diagnostics.Clear();
         _genericParameters.Clear();
@@ -95,7 +95,7 @@ public sealed class Parser
             }
         }
 
-        return new SyntaxTree(_namespace, definitions, _diagnostics);
+        return new ParseTree(_namespace, definitions, _diagnostics);
     }
 
     private FuncSignatureSyntax ParseFuncSignature(FuncParameterSyntax? thisArg = null)