reorganized code and clean up syntax tree

Compiler.API/AzothCompiler.cs

@@ -4,6 +4,7 @@
 using System.Threading.Tasks;
 using System.Threading.Tasks.Dataflow;
 using Azoth.Tools.Bootstrap.Compiler.Core;
+using Azoth.Tools.Bootstrap.Compiler.Core.Diagnostics;
 using Azoth.Tools.Bootstrap.Compiler.CST;
 using Azoth.Tools.Bootstrap.Compiler.Lexing;
 using Azoth.Tools.Bootstrap.Compiler.Names;

Compiler.CST/IPackageSyntax.cs

@@ -1,4 +1,4 @@
-using Azoth.Tools.Bootstrap.Compiler.Core;
+using Azoth.Tools.Bootstrap.Compiler.Core.Diagnostics;
 using Azoth.Tools.Bootstrap.Compiler.Names;
 using Azoth.Tools.Bootstrap.Framework;
 
@@ -11,5 +11,5 @@ public interface IPackageSyntax : ISyntax
     IFixedSet<ICompilationUnitSyntax> TestingCompilationUnits { get; }
     IFixedSet<IPackageReferenceSyntax> References { get; }
 
-    Diagnostics Diagnostics { get; }
+    DiagnosticsCollection Diagnostics { get; }
 }

Compiler.CST/PackageSyntax.cs

@@ -1,5 +1,6 @@
 using System.Linq;
 using Azoth.Tools.Bootstrap.Compiler.Core;
+using Azoth.Tools.Bootstrap.Compiler.Core.Diagnostics;
 using Azoth.Tools.Bootstrap.Compiler.Names;
 using Azoth.Tools.Bootstrap.Framework;
 
@@ -20,7 +21,7 @@ public class PackageSyntax : IPackageSyntax
     public IFixedSet<ICompilationUnitSyntax> CompilationUnits { get; }
     public IFixedSet<ICompilationUnitSyntax> TestingCompilationUnits { get; }
     public IFixedSet<IPackageReferenceSyntax> References { get; }
-    public Diagnostics Diagnostics { get; }
+    public DiagnosticsCollection Diagnostics { get; }
 
     public PackageSyntax(
         IdentifierName name,

Compiler.CST/SyntaxTree.tree

@@ -4,10 +4,10 @@
 ◊suffix Syntax;
 ◊using System.Numerics;
 ◊using Azoth.Tools.Bootstrap.Compiler.Core;
+◊using Azoth.Tools.Bootstrap.Compiler.Core.Diagnostics;
 ◊using Azoth.Tools.Bootstrap.Compiler.Core.Operators;
 ◊using Azoth.Tools.Bootstrap.Compiler.Names;
 ◊using Azoth.Tools.Bootstrap.Compiler.Tokens;
-◊using Azoth.Tools.Bootstrap.Compiler.Types;
 ◊using Azoth.Tools.Bootstrap.Compiler.Types.Capabilities;
 ◊using Azoth.Tools.Bootstrap.Framework;
 
@@ -18,7 +18,7 @@
 //     `SpecialTypeNameExpression` should be the same type.
 
 Code = Span:`TextSpan`;
-CompilationUnit = File:`CodeFile` ImplicitNamespaceName:`NamespaceName` Diagnostics:`Diagnostics`
+CompilationUnit = File:`CodeFile` ImplicitNamespaceName:`NamespaceName` Diagnostics:`DiagnosticsCollection`
     UsingDirectives:UsingDirective* Definitions:NonMemberDefinition*;
 UsingDirective = Name:`NamespaceName`;
 

Compiler.CST/SyntaxTree.tree.cs

@@ -1,9 +1,9 @@
 using System.Numerics;
 using Azoth.Tools.Bootstrap.Compiler.Core;
+using Azoth.Tools.Bootstrap.Compiler.Core.Diagnostics;
 using Azoth.Tools.Bootstrap.Compiler.Core.Operators;
 using Azoth.Tools.Bootstrap.Compiler.Names;
 using Azoth.Tools.Bootstrap.Compiler.Tokens;
-using Azoth.Tools.Bootstrap.Compiler.Types;
 using Azoth.Tools.Bootstrap.Compiler.Types.Capabilities;
 using Azoth.Tools.Bootstrap.Framework;
 using ExhaustiveMatching;
@@ -40,7 +40,7 @@ public partial interface ICompilationUnitSyntax : ICodeSyntax
 {
     CodeFile File { get; }
     NamespaceName ImplicitNamespaceName { get; }
-    Diagnostics Diagnostics { get; }
+    DiagnosticsCollection Diagnostics { get; }
     IFixedList<IUsingDirectiveSyntax> UsingDirectives { get; }
     IFixedList<INonMemberDefinitionSyntax> Definitions { get; }
 }

Compiler.Core/CompilerResult.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using Azoth.Tools.Bootstrap.Compiler.Core.Diagnostics;
 using Azoth.Tools.Bootstrap.Framework;
 
 namespace Azoth.Tools.Bootstrap.Compiler.Core;

Compiler.Core/Diagnostic.cs → Compiler.Core/Diagnostics/Diagnostic.cs

@@ -1,7 +1,7 @@
 using System;
 using Azoth.Tools.Bootstrap.Framework;
 
-namespace Azoth.Tools.Bootstrap.Compiler.Core;
+namespace Azoth.Tools.Bootstrap.Compiler.Core.Diagnostics;
 
 public class Diagnostic
 {

Compiler.Core/DiagnosticLevel.cs → Compiler.Core/Diagnostics/DiagnosticLevel.cs

@@ -1,4 +1,4 @@
-namespace Azoth.Tools.Bootstrap.Compiler.Core;
+namespace Azoth.Tools.Bootstrap.Compiler.Core.Diagnostics;
 
 public enum DiagnosticLevel
 {

Compiler.Core/DiagnosticPhase.cs → Compiler.Core/Diagnostics/DiagnosticPhase.cs

@@ -1,4 +1,4 @@
-namespace Azoth.Tools.Bootstrap.Compiler.Core;
+namespace Azoth.Tools.Bootstrap.Compiler.Core.Diagnostics;
 
 public enum DiagnosticPhase
 {

Compiler.Core/DiagnosticsBuilder.cs → Compiler.Core/Diagnostics/DiagnosticsBuilder.cs

@@ -3,7 +3,7 @@
 using System.Diagnostics;
 using Azoth.Tools.Bootstrap.Framework;
 
-namespace Azoth.Tools.Bootstrap.Compiler.Core;
+namespace Azoth.Tools.Bootstrap.Compiler.Core.Diagnostics;
 
 // TODO rename to DiagnosticsBuilder (and maybe introduce an immutable diagnostics class)
 [DebuggerDisplay("Count = {items.Count}")]
@@ -22,7 +22,7 @@ public void Add(Diagnostic diagnostic)
         UpdateFatalErrorCount(diagnostic);
     }
 
-    public void Add(Diagnostics diagnostics)
+    public void Add(DiagnosticsCollection diagnostics)
     {
         items.AddRange(diagnostics);
         FatalErrorCount += diagnostics.FatalErrorCount;
@@ -37,7 +37,7 @@ private void UpdateFatalErrorCount(Diagnostic diagnostic)
             FatalErrorCount++;
     }
 
-    public Diagnostics Build() => new(this);
+    public DiagnosticsCollection Build() => new(this);
 
     public IEnumerator<Diagnostic> GetEnumerator() => items.GetEnumerator();
 

Compiler.Core/Diagnostics.cs → Compiler.Core/Diagnostics/DiagnosticsCollection.cs

@@ -2,18 +2,18 @@
 using System.Collections.Generic;
 using System.Linq;
 
-namespace Azoth.Tools.Bootstrap.Compiler.Core;
+namespace Azoth.Tools.Bootstrap.Compiler.Core.Diagnostics;
 
-public sealed class Diagnostics : IReadOnlyList<Diagnostic>
+public sealed class DiagnosticsCollection : IReadOnlyList<Diagnostic>
 {
-    public static readonly Diagnostics Empty = new();
+    public static readonly DiagnosticsCollection Empty = new();
 
     private readonly IReadOnlyList<Diagnostic> diagnostics;
 
     public int Count => diagnostics.Count;
     public int FatalErrorCount { get; }
 
-    public Diagnostics(DiagnosticsBuilder diagnostics)
+    public DiagnosticsCollection(DiagnosticsBuilder diagnostics)
     {
         FatalErrorCount = diagnostics.FatalErrorCount;
         // Don't wrap in read only list, as this class is the wrapper
@@ -22,7 +22,7 @@ public Diagnostics(DiagnosticsBuilder diagnostics)
                                       .ToList();
     }
 
-    private Diagnostics()
+    private DiagnosticsCollection()
     {
         diagnostics = [];
     }

Compiler.Core/ErrorCodeRange.cs → Compiler.Core/Diagnostics/ErrorCodeRange.cs

@@ -1,6 +1,6 @@
 using System;
 
-namespace Azoth.Tools.Bootstrap.Compiler.Core;
+namespace Azoth.Tools.Bootstrap.Compiler.Core.Diagnostics;
 
 public static class ErrorCodeRange
 {

Compiler.Core/Diagnostics/FatalCompilationErrorException.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace Azoth.Tools.Bootstrap.Compiler.Core.Diagnostics;
+
+public class FatalCompilationErrorException : Exception
+{
+    public DiagnosticsCollection Diagnostics { get; }
+
+    public FatalCompilationErrorException(DiagnosticsCollection diagnostics)
+    {
+        Diagnostics = diagnostics;
+    }
+}

Compiler.Types/ParameterIndependence.cs → Compiler.Core/ParameterIndependence.cs

@@ -1,6 +1,6 @@
 using ExhaustiveMatching;
 
-namespace Azoth.Tools.Bootstrap.Compiler.Types;
+namespace Azoth.Tools.Bootstrap.Compiler.Core;
 
 public enum ParameterIndependence
 {

Compiler.Core/ParseContext.cs

@@ -1,3 +1,5 @@
+using Azoth.Tools.Bootstrap.Compiler.Core.Diagnostics;
+
 namespace Azoth.Tools.Bootstrap.Compiler.Core;
 
 public class ParseContext

Compiler.Lexing/LexError.cs

@@ -1,4 +1,5 @@
 using Azoth.Tools.Bootstrap.Compiler.Core;
+using Azoth.Tools.Bootstrap.Compiler.Core.Diagnostics;
 
 namespace Azoth.Tools.Bootstrap.Compiler.Lexing;
 
@@ -7,67 +8,67 @@ internal static class LexError
 {
     public static Diagnostic UnclosedBlockComment(CodeFile file, TextSpan span)
     {
-        return new(file, span, DiagnosticLevel.CompilationError, DiagnosticPhase.Lexing,
-            1001, "End-of-file found, expected `*/`");
+        return new(file, span, (DiagnosticLevel)DiagnosticLevel.CompilationError, (DiagnosticPhase)DiagnosticPhase.Lexing,
+            (int)1001, (string)"End-of-file found, expected `*/`");
     }
 
     public static Diagnostic UnclosedStringLiteral(CodeFile file, TextSpan span)
     {
-        return new(file, span, DiagnosticLevel.CompilationError, DiagnosticPhase.Lexing,
-            1002, "End-of-file in string constant");
+        return new(file, span, (DiagnosticLevel)DiagnosticLevel.CompilationError, (DiagnosticPhase)DiagnosticPhase.Lexing,
+            (int)1002, (string)"End-of-file in string constant");
     }
 
     public static Diagnostic InvalidEscapeSequence(CodeFile file, TextSpan span)
     {
-        return new(file, span, DiagnosticLevel.CompilationError, DiagnosticPhase.Lexing,
-            1003, "Unrecognized escape sequence");
+        return new(file, span, (DiagnosticLevel)DiagnosticLevel.CompilationError, (DiagnosticPhase)DiagnosticPhase.Lexing,
+            (int)1003, (string)"Unrecognized escape sequence");
     }
 
     public static Diagnostic CStyleNotEquals(CodeFile file, TextSpan span)
     {
-        return new(file, span, DiagnosticLevel.CompilationError, DiagnosticPhase.Lexing,
-            1004, "Use `≠` or `=/=` for not equal instead of `!=`");
+        return new(file, span, (DiagnosticLevel)DiagnosticLevel.CompilationError, (DiagnosticPhase)DiagnosticPhase.Lexing,
+            (int)1004, (string)"Use `≠` or `=/=` for not equal instead of `!=`");
     }
 
     public static Diagnostic UnexpectedCharacter(CodeFile file, TextSpan span, char character)
     {
-        return new(file, span, DiagnosticLevel.CompilationError, DiagnosticPhase.Lexing,
-            1005, $"Unexpected character `{character}`");
+        return new(file, span, (DiagnosticLevel)DiagnosticLevel.CompilationError, (DiagnosticPhase)DiagnosticPhase.Lexing,
+            (int)1005, (string)$"Unexpected character `{character}`");
     }
 
     public static Diagnostic ReservedWord(CodeFile file, TextSpan span, string word)
     {
-        return new(file, span, DiagnosticLevel.CompilationError, DiagnosticPhase.Lexing,
-            1006, $"Reserved word `{word}` used as an identifier");
+        return new(file, span, (DiagnosticLevel)DiagnosticLevel.CompilationError, (DiagnosticPhase)DiagnosticPhase.Lexing,
+            (int)1006, (string)$"Reserved word `{word}` used as an identifier");
     }
 
     public static Diagnostic ContinueInsteadOfNext(CodeFile file, TextSpan span)
     {
-        return new(file, span, DiagnosticLevel.CompilationError, DiagnosticPhase.Lexing,
-            1007, "The word `continue` is a reserved word. Use the `next` keyword or escape the identifier as `\\continue` instead");
+        return new(file, span, (DiagnosticLevel)DiagnosticLevel.CompilationError, (DiagnosticPhase)DiagnosticPhase.Lexing,
+            (int)1007, (string)"The word `continue` is a reserved word. Use the `next` keyword or escape the identifier as `\\continue` instead");
     }
 
     public static Diagnostic EscapedIdentifierShouldNotBeEscaped(CodeFile file, TextSpan span, string identifier)
     {
-        return new(file, span, DiagnosticLevel.CompilationError, DiagnosticPhase.Lexing,
-            1008, $"The word `{identifier}` is not a keyword or reserved word, it should not be escaped");
+        return new(file, span, (DiagnosticLevel)DiagnosticLevel.CompilationError, (DiagnosticPhase)DiagnosticPhase.Lexing,
+            (int)1008, (string)$"The word `{identifier}` is not a keyword or reserved word, it should not be escaped");
     }
 
     public static Diagnostic ReservedOperator(CodeFile file, TextSpan span, string op)
     {
-        return new(file, span, DiagnosticLevel.CompilationError, DiagnosticPhase.Lexing,
-            1009, $"Unexpected character(s) `{op}`, reserved for operator or punctuators");
+        return new(file, span, (DiagnosticLevel)DiagnosticLevel.CompilationError, (DiagnosticPhase)DiagnosticPhase.Lexing,
+            (int)1009, (string)$"Unexpected character(s) `{op}`, reserved for operator or punctuators");
     }
 
     public static Diagnostic UInt8InsteadOfByte(CodeFile file, TextSpan span)
     {
-        return new(file, span, DiagnosticLevel.CompilationError, DiagnosticPhase.Lexing,
-            1010, "The word `uint8` is a reserved word. Use the `byte` keyword instead");
+        return new(file, span, (DiagnosticLevel)DiagnosticLevel.CompilationError, (DiagnosticPhase)DiagnosticPhase.Lexing,
+            (int)1010, (string)"The word `uint8` is a reserved word. Use the `byte` keyword instead");
     }
 
     public static Diagnostic UnclosedStringIdentifier(CodeFile file, TextSpan span)
     {
-        return new(file, span, DiagnosticLevel.CompilationError, DiagnosticPhase.Lexing,
-            1011, "End-of-file in string identifier");
+        return new(file, span, (DiagnosticLevel)DiagnosticLevel.CompilationError, (DiagnosticPhase)DiagnosticPhase.Lexing,
+            (int)1011, (string)"End-of-file in string identifier");
     }
 }

Compiler.Lexing/Lexer.cs

@@ -7,6 +7,7 @@
 using System.Runtime.CompilerServices;
 using System.Text;
 using Azoth.Tools.Bootstrap.Compiler.Core;
+using Azoth.Tools.Bootstrap.Compiler.Core.Diagnostics;
 using Azoth.Tools.Bootstrap.Compiler.Tokens;
 
 namespace Azoth.Tools.Bootstrap.Compiler.Lexing;

Compiler.Parsing/CompilationUnitParser.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.CodeAnalysis;
 using Azoth.Tools.Bootstrap.Compiler.Core;
+using Azoth.Tools.Bootstrap.Compiler.Core.Diagnostics;
 using Azoth.Tools.Bootstrap.Compiler.CST;
 using Azoth.Tools.Bootstrap.Compiler.Lexing;
 using Azoth.Tools.Bootstrap.Compiler.Names;

Compiler.Parsing/NotImplemented/SyntaxNotImplementedChecker.cs

@@ -1,4 +1,5 @@
 using Azoth.Tools.Bootstrap.Compiler.Core;
+using Azoth.Tools.Bootstrap.Compiler.Core.Diagnostics;
 using Azoth.Tools.Bootstrap.Compiler.CST;
 using Azoth.Tools.Bootstrap.Compiler.CST.Walkers;
 using Azoth.Tools.Bootstrap.Compiler.Parsing.Tree;