Reordering

src/compiler/NubLang.CLI/Program.cs

@@ -2,7 +2,9 @@
 using NubLang.CLI;
 using NubLang;
 using NubLang.Diagnostics;
+using NubLang.Generation;
 using NubLang.Generation.QBE;
+using NubLang.Syntax.Binding;
 using NubLang.Syntax.Binding.Node;
 using NubLang.Syntax.Parsing;
 using NubLang.Syntax.Parsing.Node;

src/compiler/NubLang/Generation/BoundDefinitionTable.cs

@@ -1,64 +1,7 @@
+using NubLang.Syntax.Binding;
 using NubLang.Syntax.Binding.Node;
-using NubLang.Syntax.Parsing.Node;
 
-namespace NubLang;
+namespace NubLang.Generation;
-
-public sealed class DefinitionTable
-{
-    private readonly List<DefinitionSyntax> _definitions;
-
-    public DefinitionTable(IEnumerable<SyntaxTree> syntaxTrees)
-    {
-        _definitions = syntaxTrees.SelectMany(x => x.Definitions).ToList();
-    }
-
-    public IEnumerable<LocalFuncSyntax> LookupLocalFunc(string @namespace, string name)
-    {
-        return _definitions
-            .OfType<LocalFuncSyntax>()
-            .Where(x => x.Namespace == @namespace && x.Name == name);
-    }
-
-    public IEnumerable<ExternFuncSyntax> LookupExternFunc(string @namespace, string name)
-    {
-        return _definitions
-            .OfType<ExternFuncSyntax>()
-            .Where(x => x.Namespace == @namespace && x.Name == name);
-    }
-
-    public IEnumerable<StructSyntax> LookupStruct(string @namespace, string name)
-    {
-        return _definitions
-            .OfType<StructSyntax>()
-            .Where(x => x.Namespace == @namespace && x.Name == name);
-    }
-
-    public IEnumerable<StructFieldSyntax> LookupStructField(StructSyntax structNode, string field)
-    {
-        return structNode.Fields.Where(x => x.Name == field);
-    }
-
-    public IEnumerable<TraitFuncImplSyntax> LookupTraitFuncImpl(NubType forType, string name)
-    {
-        return _definitions
-            .OfType<TraitImplSyntax>()
-            .Where(x => x.ForType == forType)
-            .SelectMany(x => x.Functions)
-            .Where(x => x.Name == name);
-    }
-
-    public IEnumerable<TraitSyntax> LookupTrait(string @namespace, string name)
-    {
-        return _definitions
-            .OfType<TraitSyntax>()
-            .Where(x => x.Namespace == @namespace && x.Name == name);
-    }
-
-    public IEnumerable<TraitFuncSyntax> LookupTraitFunc(TraitSyntax trait, string name)
-    {
-        return trait.Functions.Where(x => x.Name == name);
-    }
-}
 
 public sealed class BoundDefinitionTable
 {

src/compiler/NubLang/Generation/QBE/QBEGenerator.Expression.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Globalization;
+using NubLang.Syntax.Binding;
 using NubLang.Syntax.Binding.Node;
 using NubLang.Syntax.Tokenization;
 

src/compiler/NubLang/Generation/QBE/QBEGenerator.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Text;
+using NubLang.Syntax.Binding;
 using NubLang.Syntax.Binding.Node;
 using NubLang.Syntax.Tokenization;
 

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

@@ -0,0 +1,60 @@
+using NubLang.Syntax.Parsing.Node;
+
+namespace NubLang.Syntax.Binding;
+
+public class DefinitionTable
+{
+    private readonly List<DefinitionSyntax> _definitions;
+
+    public DefinitionTable(IEnumerable<SyntaxTree> syntaxTrees)
+    {
+        _definitions = syntaxTrees.SelectMany(x => x.Definitions).ToList();
+    }
+
+    public IEnumerable<LocalFuncSyntax> LookupLocalFunc(string @namespace, string name)
+    {
+        return _definitions
+            .OfType<LocalFuncSyntax>()
+            .Where(x => x.Namespace == @namespace && x.Name == name);
+    }
+
+    public IEnumerable<ExternFuncSyntax> LookupExternFunc(string @namespace, string name)
+    {
+        return _definitions
+            .OfType<ExternFuncSyntax>()
+            .Where(x => x.Namespace == @namespace && x.Name == name);
+    }
+
+    public IEnumerable<StructSyntax> LookupStruct(string @namespace, string name)
+    {
+        return _definitions
+            .OfType<StructSyntax>()
+            .Where(x => x.Namespace == @namespace && x.Name == name);
+    }
+
+    public IEnumerable<StructFieldSyntax> LookupStructField(StructSyntax structNode, string field)
+    {
+        return structNode.Fields.Where(x => x.Name == field);
+    }
+
+    public IEnumerable<TraitFuncImplSyntax> LookupTraitFuncImpl(NubType forType, string name)
+    {
+        return _definitions
+            .OfType<TraitImplSyntax>()
+            .Where(x => x.ForType == forType)
+            .SelectMany(x => x.Functions)
+            .Where(x => x.Name == name);
+    }
+
+    public IEnumerable<TraitSyntax> LookupTrait(string @namespace, string name)
+    {
+        return _definitions
+            .OfType<TraitSyntax>()
+            .Where(x => x.Namespace == @namespace && x.Name == name);
+    }
+
+    public IEnumerable<TraitFuncSyntax> LookupTraitFunc(TraitSyntax trait, string name)
+    {
+        return trait.Functions.Where(x => x.Name == name);
+    }
+}

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

@@ -1,6 +1,7 @@
 using System.Diagnostics.CodeAnalysis;
+using NubLang.Generation;
 
-namespace NubLang;
+namespace NubLang.Syntax.Binding;
 
 public abstract class NubType : IEquatable<NubType>
 {

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

@@ -2,6 +2,21 @@ using NubLang.Syntax.Tokenization;
 
 namespace NubLang.Syntax.Parsing.Node;
 
+public enum PrimitiveTypeSyntaxKind
+{
+    I64,
+    I32,
+    I16,
+    I8,
+    U64,
+    U32,
+    U16,
+    U8,
+    F64,
+    F32,
+    Bool
+}
+
 public abstract record TypeSyntax(IReadOnlyList<Token> Tokens) : SyntaxNode(Tokens);
 
 public record FuncTypeSyntax(IReadOnlyList<Token> Tokens, IReadOnlyList<TypeSyntax> Parameters, TypeSyntax ReturnType) : TypeSyntax(Tokens);
@@ -10,7 +25,7 @@ public record PointerTypeSyntax(IReadOnlyList<Token> Tokens, TypeSyntax BaseType
 
 public record VoidTypeSyntax(IReadOnlyList<Token> Tokens) : TypeSyntax(Tokens);
 
-public record PrimitiveTypeSyntax(IReadOnlyList<Token> Tokens, PrimitiveTypeKind Kind) : TypeSyntax(Tokens);
+public record PrimitiveTypeSyntax(IReadOnlyList<Token> Tokens, PrimitiveTypeSyntaxKind SyntaxKind) : TypeSyntax(Tokens);
 
 public record CStringTypeSyntax(IReadOnlyList<Token> Tokens) : TypeSyntax(Tokens);
 

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

@@ -1,6 +1,7 @@
 using System.Diagnostics.CodeAnalysis;
 using NubLang.Common;
 using NubLang.Diagnostics;
+using NubLang.Syntax.Binding;
 using NubLang.Syntax.Parsing.Node;
 using NubLang.Syntax.Tokenization;
 
@@ -660,17 +661,17 @@ public sealed class Parser
                 "void" => new VoidTypeSyntax(GetTokens(startIndex)),
                 "string" => new StringTypeSyntax(GetTokens(startIndex)),
                 "cstring" => new CStringTypeSyntax(GetTokens(startIndex)),
-                "i64" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeKind.I64),
+                "i64" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeSyntaxKind.I64),
-                "i32" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeKind.I32),
+                "i32" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeSyntaxKind.I32),
-                "i16" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeKind.I16),
+                "i16" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeSyntaxKind.I16),
-                "i8" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeKind.I8),
+                "i8" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeSyntaxKind.I8),
-                "u64" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeKind.U64),
+                "u64" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeSyntaxKind.U64),
-                "u32" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeKind.U32),
+                "u32" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeSyntaxKind.U32),
-                "u16" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeKind.U16),
+                "u16" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeSyntaxKind.U16),
-                "u8" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeKind.U8),
+                "u8" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeSyntaxKind.U8),
-                "f64" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeKind.F64),
+                "f64" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeSyntaxKind.F64),
-                "f32" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeKind.F32),
+                "f32" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeSyntaxKind.F32),
-                "bool" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeKind.Bool),
+                "bool" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeSyntaxKind.Bool),
                 _ => ParseCustomType()
             };