From 652c644e36029ae60227030b5fc9d735ee2fe046 Mon Sep 17 00:00:00 2001
From: nub31 <oliverlhs@outlook.com>
Date: Wed, 9 Jul 2025 20:32:59 +0200
Subject: [PATCH] Reordering

---
 src/compiler/NubLang.CLI/Program.cs           |  2 +
 .../BoundDefinitionTable.cs}                  | 61 +------------------
 .../Generation/QBE/QBEGenerator.Expression.cs |  1 +
 .../NubLang/Generation/QBE/QBEGenerator.cs    |  1 +
 .../NubLang/Syntax/Binding/DefinitionTable.cs | 60 ++++++++++++++++++
 .../NubLang/{ => Syntax/Binding}/NubType.cs   |  3 +-
 .../NubLang/Syntax/Parsing/Node/TypeSyntax.cs | 17 +++++-
 src/compiler/NubLang/Syntax/Parsing/Parser.cs | 23 +++----
 8 files changed, 96 insertions(+), 72 deletions(-)
 rename src/compiler/NubLang/{DefinitionTable.cs => Generation/BoundDefinitionTable.cs} (53%)
 create mode 100644 src/compiler/NubLang/Syntax/Binding/DefinitionTable.cs
 rename src/compiler/NubLang/{ => Syntax/Binding}/NubType.cs (99%)

diff --git a/src/compiler/NubLang.CLI/Program.cs b/src/compiler/NubLang.CLI/Program.cs
index 33cb6fb..d9ab13e 100644
--- a/src/compiler/NubLang.CLI/Program.cs
+++ b/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;
diff --git a/src/compiler/NubLang/DefinitionTable.cs b/src/compiler/NubLang/Generation/BoundDefinitionTable.cs
similarity index 53%
rename from src/compiler/NubLang/DefinitionTable.cs
rename to src/compiler/NubLang/Generation/BoundDefinitionTable.cs
index 01e8408..1fc7c87 100644
--- a/src/compiler/NubLang/DefinitionTable.cs
+++ b/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;
-
-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);
-    }
-}
+namespace NubLang.Generation;
 
 public sealed class BoundDefinitionTable
 {
diff --git a/src/compiler/NubLang/Generation/QBE/QBEGenerator.Expression.cs b/src/compiler/NubLang/Generation/QBE/QBEGenerator.Expression.cs
index f39e1ea..754cd07 100644
--- a/src/compiler/NubLang/Generation/QBE/QBEGenerator.Expression.cs
+++ b/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;
 
diff --git a/src/compiler/NubLang/Generation/QBE/QBEGenerator.cs b/src/compiler/NubLang/Generation/QBE/QBEGenerator.cs
index 9d99d04..d2da756 100644
--- a/src/compiler/NubLang/Generation/QBE/QBEGenerator.cs
+++ b/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;
 
diff --git a/src/compiler/NubLang/Syntax/Binding/DefinitionTable.cs b/src/compiler/NubLang/Syntax/Binding/DefinitionTable.cs
new file mode 100644
index 0000000..fb2fc21
--- /dev/null
+++ b/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);
+    }
+}
\ No newline at end of file
diff --git a/src/compiler/NubLang/NubType.cs b/src/compiler/NubLang/Syntax/Binding/NubType.cs
similarity index 99%
rename from src/compiler/NubLang/NubType.cs
rename to src/compiler/NubLang/Syntax/Binding/NubType.cs
index becd22e..48dff79 100644
--- a/src/compiler/NubLang/NubType.cs
+++ b/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>
 {
diff --git a/src/compiler/NubLang/Syntax/Parsing/Node/TypeSyntax.cs b/src/compiler/NubLang/Syntax/Parsing/Node/TypeSyntax.cs
index f59b8bf..ef26f09 100644
--- a/src/compiler/NubLang/Syntax/Parsing/Node/TypeSyntax.cs
+++ b/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);
 
diff --git a/src/compiler/NubLang/Syntax/Parsing/Parser.cs b/src/compiler/NubLang/Syntax/Parsing/Parser.cs
index dcbd1fb..cde4229 100644
--- a/src/compiler/NubLang/Syntax/Parsing/Parser.cs
+++ b/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),
-                "i32" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeKind.I32),
-                "i16" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeKind.I16),
-                "i8" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeKind.I8),
-                "u64" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeKind.U64),
-                "u32" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeKind.U32),
-                "u16" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeKind.U16),
-                "u8" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeKind.U8),
-                "f64" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeKind.F64),
-                "f32" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeKind.F32),
-                "bool" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeKind.Bool),
+                "i64" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeSyntaxKind.I64),
+                "i32" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeSyntaxKind.I32),
+                "i16" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeSyntaxKind.I16),
+                "i8" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeSyntaxKind.I8),
+                "u64" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeSyntaxKind.U64),
+                "u32" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeSyntaxKind.U32),
+                "u16" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeSyntaxKind.U16),
+                "u8" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeSyntaxKind.U8),
+                "f64" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeSyntaxKind.F64),
+                "f32" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeSyntaxKind.F32),
+                "bool" => new PrimitiveTypeSyntax(GetTokens(startIndex), PrimitiveTypeSyntaxKind.Bool),
                 _ => ParseCustomType()
             };