Clean

src/compiler/Generation/QBE/QBEGenerator.cs

@@ -3,10 +3,9 @@ using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Text;
 using Syntax;
-using Syntax.Parsing.Node;
+using Syntax.Node;
 using Syntax.Tokenization;
 using Syntax.Typing;
-using Syntax.Typing.BoundNode;
 
 namespace Generation.QBE;
 

src/compiler/Generation/QBE/QBEWriter.cs

@@ -1,6 +1,6 @@
 using System.Text;
 using Syntax;
-using Syntax.Typing.BoundNode;
+using Syntax.Node;
 
 namespace Generation.QBE;
 

src/compiler/Syntax/DefinitionTable.cs

@@ -1,8 +1,7 @@
 using Common;
+using Syntax.Node;
 using Syntax.Parsing;
-using Syntax.Parsing.Node;
 using Syntax.Typing;
-using Syntax.Typing.BoundNode;
 
 namespace Syntax;
 
@@ -73,48 +72,6 @@ public class DefinitionTable
 
         return Optional<TraitFunc>.Empty();
     }
-
-    public IEnumerable<StructDefinitionNode> GetStructs()
-    {
-        return _syntaxTrees
-            .SelectMany(c => c.Definitions)
-            .OfType<StructDefinitionNode>();
-    }
-
-    public IEnumerable<FuncDefinition> GetFunctions()
-    {
-        return _syntaxTrees
-            .SelectMany(c => c.Definitions)
-            .OfType<FuncDefinition>();
-    }
-
-    public IEnumerable<LocalFuncDefinitionNode> GetLocalFunctions()
-    {
-        return _syntaxTrees
-            .SelectMany(c => c.Definitions)
-            .OfType<LocalFuncDefinitionNode>();
-    }
-
-    public IEnumerable<ExternFuncDefinitionNode> GetExternFunctions()
-    {
-        return _syntaxTrees
-            .SelectMany(c => c.Definitions)
-            .OfType<ExternFuncDefinitionNode>();
-    }
-
-    public IEnumerable<TraitDefinitionNode> GetTraits()
-    {
-        return _syntaxTrees
-            .SelectMany(c => c.Definitions)
-            .OfType<TraitDefinitionNode>();
-    }
-
-    public IEnumerable<TraitImplementationDefinitionNode> GetTraitImplementations()
-    {
-        return _syntaxTrees
-            .SelectMany(c => c.Definitions)
-            .OfType<TraitImplementationDefinitionNode>();
-    }
 }
 
 public class BoundDefinitionTable
@@ -192,38 +149,10 @@ public class BoundDefinitionTable
             .OfType<BoundStructDefinitionNode>();
     }
 
-    public IEnumerable<BoundFuncDefinition> GetFunctions()
-    {
-        return _syntaxTrees
-            .SelectMany(c => c.Definitions)
-            .OfType<BoundFuncDefinition>();
-    }
-
-    public IEnumerable<BoundLocalFuncDefinitionNode> GetLocalFunctions()
-    {
-        return _syntaxTrees
-            .SelectMany(c => c.Definitions)
-            .OfType<BoundLocalFuncDefinitionNode>();
-    }
-
-    public IEnumerable<BoundExternFuncDefinitionNode> GetExternFunctions()
-    {
-        return _syntaxTrees
-            .SelectMany(c => c.Definitions)
-            .OfType<BoundExternFuncDefinitionNode>();
-    }
-
     public IEnumerable<BoundTraitDefinitionNode> GetTraits()
     {
         return _syntaxTrees
             .SelectMany(c => c.Definitions)
             .OfType<BoundTraitDefinitionNode>();
     }
-
-    public IEnumerable<BoundTraitImplementationDefinitionNode> GetTraitImplementations()
-    {
-        return _syntaxTrees
-            .SelectMany(c => c.Definitions)
-            .OfType<BoundTraitImplementationDefinitionNode>();
-    }
 }

src/compiler/Syntax/Diagnostics/ConsoleColors.cs

@@ -61,8 +61,6 @@ public static class ConsoleColors
     {
         switch (token)
         {
-            case DocumentationToken:
-                return Faint;
             case IdentifierToken:
                 return White;
             case LiteralToken literal:

src/compiler/Syntax/Diagnostics/Diagnostic.cs

@@ -1,6 +1,5 @@
 using System.Text;
 using Syntax.Parsing;
-using Syntax.Parsing.Node;
 using Syntax.Tokenization;
 
 namespace Syntax.Diagnostics;
@@ -26,7 +25,7 @@ public class Diagnostic
             return this;
         }
 
-        public DiagnosticBuilder At(Node node)
+        public DiagnosticBuilder At(Node.Node node)
         {
             _sourceSpan = SourceSpan.Merge(node.Tokens.Select(t => t.Span));
             return this;

src/compiler/Syntax/Node/Definition.cs

@@ -0,0 +1,38 @@
+using Common;
+using Syntax.Tokenization;
+using Syntax.Typing;
+
+namespace Syntax.Node;
+
+public abstract record DefinitionNode(IEnumerable<Token> Tokens, string Namespace) : Node(Tokens);
+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 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 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 StructField(string Name, NubType Type, Optional<ExpressionNode> Value);
+public record BoundStructField(string Name, NubType Type, Optional<BoundExpressionNode> Value);
+
+public record StructDefinitionNode(IEnumerable<Token> Tokens, string Namespace, string Name, List<StructField> Fields) : DefinitionNode(Tokens, 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 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 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

@@ -1,19 +1,64 @@
 using Common;
-using Syntax.Parsing.Node;
 using Syntax.Tokenization;
+using Syntax.Typing;
 
-namespace Syntax.Typing.BoundNode;
+namespace Syntax.Node;
 
+public enum UnaryExpressionOperator
+{
+    Negate,
+    Invert
+}
+
+public enum BinaryExpressionOperator
+{
+    Equal,
+    NotEqual,
+    GreaterThan,
+    GreaterThanOrEqual,
+    LessThan,
+    LessThanOrEqual,
+    Plus,
+    Minus,
+    Multiply,
+    Divide
+}
+
+public abstract record ExpressionNode(IEnumerable<Token> Tokens) : Node(Tokens);
 public abstract record BoundExpressionNode(IEnumerable<Token> Tokens, NubType Type) : BoundNode(Tokens);
+
+public record BinaryExpressionNode(IEnumerable<Token> Tokens, ExpressionNode Left, BinaryExpressionOperator Operator, ExpressionNode Right) : ExpressionNode(Tokens);
 public record BoundBinaryExpressionNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Left, BinaryExpressionOperator Operator, BoundExpressionNode Right) : BoundExpressionNode(Tokens, Type);
+
+public record UnaryExpressionNode(IEnumerable<Token> Tokens, UnaryExpressionOperator Operator, ExpressionNode Operand) : ExpressionNode(Tokens);
 public record BoundUnaryExpressionNode(IEnumerable<Token> Tokens, NubType Type, UnaryExpressionOperator Operator, BoundExpressionNode Operand) : BoundExpressionNode(Tokens, Type);
+
+public record FuncCallNode(IEnumerable<Token> Tokens, ExpressionNode Expression, List<ExpressionNode> Parameters) : ExpressionNode(Tokens);
 public record BoundFuncCallNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Expression, List<BoundExpressionNode> Parameters) : BoundExpressionNode(Tokens, Type);
+
+public record IdentifierNode(IEnumerable<Token> Tokens, Optional<string> Namespace, string Name) : ExpressionNode(Tokens);
 public record BoundIdentifierNode(IEnumerable<Token> Tokens, NubType Type, Optional<string> Namespace, string Name) : BoundExpressionNode(Tokens, Type);
+
+public record ArrayInitializerNode(IEnumerable<Token> Tokens, ExpressionNode Capacity, NubType ElementType) : ExpressionNode(Tokens);
 public record BoundArrayInitializerNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Capacity, NubType ElementType) : BoundExpressionNode(Tokens, Type);
+
+public record ArrayIndexAccessNode(IEnumerable<Token> Tokens, ExpressionNode Array, ExpressionNode Index) : ExpressionNode(Tokens);
 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 AddressOfNode(IEnumerable<Token> Tokens, ExpressionNode Expression) : ExpressionNode(Tokens);
 public record BoundAddressOfNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Expression) : BoundExpressionNode(Tokens, Type);
+
+public record LiteralNode(IEnumerable<Token> Tokens, string Literal, LiteralKind Kind) : ExpressionNode(Tokens);
 public record BoundLiteralNode(IEnumerable<Token> Tokens, NubType Type, string Literal, LiteralKind Kind) : BoundExpressionNode(Tokens, Type);
+
+public record MemberAccessNode(IEnumerable<Token> Tokens, ExpressionNode Expression, string Member) : ExpressionNode(Tokens);
 public record BoundMemberAccessNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Expression, string Member) : BoundExpressionNode(Tokens, Type);
+
+public record StructInitializerNode(IEnumerable<Token> Tokens, NubType StructType, Dictionary<string, ExpressionNode> Initializers) : ExpressionNode(Tokens);
 public record BoundStructInitializerNode(IEnumerable<Token> Tokens, NubType Type, NubType StructType, Dictionary<string, BoundExpressionNode> Initializers) : BoundExpressionNode(Tokens, Type);
+
+public record DereferenceNode(IEnumerable<Token> Tokens, ExpressionNode Expression) : ExpressionNode(Tokens);
 public record BoundDereferenceNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Expression) : BoundExpressionNode(Tokens, Type);

src/compiler/Syntax/Node/Node.cs

@@ -0,0 +1,9 @@
+using Syntax.Tokenization;
+
+namespace Syntax.Node;
+
+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);

src/compiler/Syntax/Node/Statement.cs

@@ -1,14 +1,33 @@
 using Common;
 using Syntax.Tokenization;
+using Syntax.Typing;
 
-namespace Syntax.Typing.BoundNode;
+namespace Syntax.Node;
 
+
+public record StatementNode(IEnumerable<Token> Tokens) : Node(Tokens);
 public record BoundStatementNode(IEnumerable<Token> Tokens) : BoundNode(Tokens);
+
+public record StatementExpressionNode(IEnumerable<Token> Tokens, ExpressionNode Expression) : StatementNode(Tokens);
 public record BoundStatementExpressionNode(IEnumerable<Token> Tokens, BoundExpressionNode Expression) : BoundStatementNode(Tokens);
+
+public record ReturnNode(IEnumerable<Token> Tokens, Optional<ExpressionNode> Value) : StatementNode(Tokens);
 public record BoundReturnNode(IEnumerable<Token> Tokens, Optional<BoundExpressionNode> Value) : BoundStatementNode(Tokens);
+
+public record AssignmentNode(IEnumerable<Token> Tokens, ExpressionNode Expression, ExpressionNode Value) : StatementNode(Tokens);
 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 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);
+
+public record ContinueNode(IEnumerable<Token> Tokens) : StatementNode(Tokens);
 public record BoundContinueNode(IEnumerable<Token> Tokens) : BoundStatementNode(Tokens);
+
+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);

src/compiler/Syntax/Parsing/Node/Definition.cs

@@ -1,22 +0,0 @@
-using Common;
-using Syntax.Tokenization;
-using Syntax.Typing;
-using Syntax.Typing.BoundNode;
-
-namespace Syntax.Parsing.Node;
-
-public abstract record DefinitionNode(IEnumerable<Token> Tokens, Optional<string> Documentation, string Namespace) : Node(Tokens);
-
-public record FuncParameter(string Name, NubType Type);
-public abstract record FuncDefinition(IEnumerable<Token> Tokens, Optional<string> Documentation, string Namespace, string Name, List<FuncParameter> Parameters, NubType ReturnType) : DefinitionNode(Tokens, Documentation, Namespace);
-public record LocalFuncDefinitionNode(IEnumerable<Token> Tokens, Optional<string> Documentation, string Namespace, string Name, List<FuncParameter> Parameters, BlockNode Body, NubType ReturnType, bool Exported) : FuncDefinition(Tokens, Documentation, Namespace, Name, Parameters, ReturnType);
-public record ExternFuncDefinitionNode(IEnumerable<Token> Tokens, Optional<string> Documentation, string Namespace, string Name, string CallName, List<FuncParameter> Parameters, NubType ReturnType) : FuncDefinition(Tokens, Documentation, Namespace, Name, Parameters, ReturnType);
-
-public record StructField(string Name, NubType Type, Optional<ExpressionNode> Value);
-public record StructDefinitionNode(IEnumerable<Token> Tokens, Optional<string> Documentation, string Namespace, string Name, List<StructField> Fields) : DefinitionNode(Tokens, Documentation, Namespace);
-
-public record TraitFunc(string Name, List<FuncParameter> Parameters, NubType ReturnType);
-public record TraitDefinitionNode(IEnumerable<Token> Tokens, Optional<string> Documentation, string Namespace, string Name, List<TraitFunc> Functions) : DefinitionNode(Tokens, Documentation, Namespace);
-
-public record ImplementationFuncNode(IEnumerable<Token> Tokens, string Name, List<FuncParameter> Parameters, NubType ReturnType, BlockNode Body) : BoundNode(Tokens);
-public record TraitImplementationDefinitionNode(IEnumerable<Token> Tokens, Optional<string> Documentation, string Namespace, NubType TraitType, NubType ForType, List<ImplementationFuncNode> Functions) : DefinitionNode(Tokens, Documentation, Namespace);

src/compiler/Syntax/Parsing/Node/Expression.cs

@@ -1,42 +0,0 @@
-using Common;
-using Syntax.Tokenization;
-using Syntax.Typing;
-
-namespace Syntax.Parsing.Node;
-
-public abstract record ExpressionNode(IEnumerable<Token> Tokens) : Node(Tokens);
-
-public record BinaryExpressionNode(IEnumerable<Token> Tokens, ExpressionNode Left, BinaryExpressionOperator Operator, ExpressionNode Right) : ExpressionNode(Tokens);
-
-public enum BinaryExpressionOperator
-{
-    Equal,
-    NotEqual,
-    GreaterThan,
-    GreaterThanOrEqual,
-    LessThan,
-    LessThanOrEqual,
-    Plus,
-    Minus,
-    Multiply,
-    Divide
-}
-
-public record UnaryExpressionNode(IEnumerable<Token> Tokens, UnaryExpressionOperator Operator, ExpressionNode Operand) : ExpressionNode(Tokens);
-
-public enum UnaryExpressionOperator
-{
-    Negate,
-    Invert
-}
-
-public record FuncCallNode(IEnumerable<Token> Tokens, ExpressionNode Expression, List<ExpressionNode> Parameters) : ExpressionNode(Tokens);
-public record IdentifierNode(IEnumerable<Token> Tokens, Optional<string> Namespace, string Name) : ExpressionNode(Tokens);
-public record ArrayInitializerNode(IEnumerable<Token> Tokens, ExpressionNode Capacity, NubType ElementType) : ExpressionNode(Tokens);
-public record ArrayIndexAccessNode(IEnumerable<Token> Tokens, ExpressionNode Array, ExpressionNode Index) : ExpressionNode(Tokens);
-public record AnonymousFuncNode(IEnumerable<Token> Tokens, List<FuncParameter> Parameters, BlockNode Body, NubType ReturnType) : ExpressionNode(Tokens);
-public record AddressOfNode(IEnumerable<Token> Tokens, ExpressionNode Expression) : ExpressionNode(Tokens);
-public record LiteralNode(IEnumerable<Token> Tokens, string Literal, LiteralKind Kind) : ExpressionNode(Tokens);
-public record MemberAccessNode(IEnumerable<Token> Tokens, ExpressionNode Expression, string Member) : ExpressionNode(Tokens);
-public record StructInitializerNode(IEnumerable<Token> Tokens, NubType StructType, Dictionary<string, ExpressionNode> Initializers) : ExpressionNode(Tokens);
-public record DereferenceNode(IEnumerable<Token> Tokens, ExpressionNode Expression) : ExpressionNode(Tokens);

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

@@ -1,6 +0,0 @@
-using Syntax.Tokenization;
-
-namespace Syntax.Parsing.Node;
-
-public abstract record Node(IEnumerable<Token> Tokens);
-public record BlockNode(IEnumerable<Token> Tokens, List<StatementNode> Statements) : Node(Tokens);

src/compiler/Syntax/Parsing/Node/Statement.cs

@@ -1,15 +0,0 @@
-using Common;
-using Syntax.Tokenization;
-using Syntax.Typing;
-
-namespace Syntax.Parsing.Node;
-
-public record StatementNode(IEnumerable<Token> Tokens) : Node(Tokens);
-public record StatementExpressionNode(IEnumerable<Token> Tokens, ExpressionNode Expression) : StatementNode(Tokens);
-public record ReturnNode(IEnumerable<Token> Tokens, Optional<ExpressionNode> Value) : StatementNode(Tokens);
-public record AssignmentNode(IEnumerable<Token> Tokens, ExpressionNode Expression, ExpressionNode Value) : StatementNode(Tokens);
-public record IfNode(IEnumerable<Token> Tokens, ExpressionNode Condition, BlockNode Body, Optional<Variant<IfNode, BlockNode>> Else) : StatementNode(Tokens);
-public record VariableDeclarationNode(IEnumerable<Token> Tokens, string Name, Optional<NubType> ExplicitType, Optional<ExpressionNode> Assignment) : StatementNode(Tokens);
-public record ContinueNode(IEnumerable<Token> Tokens) : StatementNode(Tokens);
-public record BreakNode(IEnumerable<Token> Tokens) : StatementNode(Tokens);
-public record WhileNode(IEnumerable<Token> Tokens, ExpressionNode Condition, BlockNode Body) : StatementNode(Tokens);

src/compiler/Syntax/Parsing/Parser.cs

@@ -1,7 +1,7 @@
 using System.Diagnostics.CodeAnalysis;
 using Common;
 using Syntax.Diagnostics;
-using Syntax.Parsing.Node;
+using Syntax.Node;
 using Syntax.Tokenization;
 using Syntax.Typing;
 
@@ -56,15 +56,6 @@ public static class Parser
         var startIndex = _index;
         List<ModifierToken> modifiers = [];
 
-        List<string> documentationParts = [];
-        while (_index < _tokens.Count() && _tokens.ElementAt(_index) is DocumentationToken commentToken)
-        {
-            documentationParts.Add(commentToken.Documentation);
-            _index++;
-        }
-
-        var documentation = documentationParts.Count == 0 ? null : string.Join('\n', documentationParts);
-
         while (TryExpectModifier(out var modifier))
         {
             modifiers.Add(modifier);
@@ -73,10 +64,10 @@ public static class Parser
         var keyword = ExpectSymbol();
         return keyword.Symbol switch
         {
-            Symbol.Func => ParseFuncDefinition(startIndex, modifiers, Optional.OfNullable(documentation)),
+            Symbol.Func => ParseFuncDefinition(startIndex, modifiers),
-            Symbol.Struct => ParseStruct(startIndex, modifiers, Optional.OfNullable(documentation)),
+            Symbol.Struct => ParseStruct(startIndex, modifiers),
-            Symbol.Trait => ParseTrait(startIndex, modifiers, Optional.OfNullable(documentation)),
+            Symbol.Trait => ParseTrait(startIndex, modifiers),
-            Symbol.Impl => ParseImplementation(startIndex, modifiers, Optional.OfNullable(documentation)),
+            Symbol.Impl => ParseImplementation(startIndex, modifiers),
             _ => throw new ParseException(Diagnostic
                 .Error($"Expected 'func' or 'struct', but found '{keyword.Symbol}'")
                 .WithHelp("Valid definition keywords are 'func' and 'struct'")
@@ -85,7 +76,7 @@ public static class Parser
         };
     }
 
-    private static DefinitionNode ParseFuncDefinition(int startIndex, List<ModifierToken> modifiers, Optional<string> documentation)
+    private static DefinitionNode ParseFuncDefinition(int startIndex, List<ModifierToken> modifiers)
     {
         var name = ExpectIdentifier();
         List<FuncParameter> parameters = [];
@@ -128,7 +119,7 @@ public static class Parser
                 callName = ExpectIdentifier().Value;
             }
 
-            return new ExternFuncDefinitionNode(GetTokensForNode(startIndex), documentation, _namespace, name.Value, callName, parameters, returnType);
+            return new ExternFuncDefinitionNode(GetTokensForNode(startIndex), _namespace, name.Value, callName, parameters, returnType);
         }
 
         var body = ParseBlock();
@@ -143,10 +134,10 @@ public static class Parser
                 .Build());
         }
 
-        return new LocalFuncDefinitionNode(GetTokensForNode(startIndex), documentation, _namespace, name.Value, parameters, body, returnType, exported);
+        return new LocalFuncDefinitionNode(GetTokensForNode(startIndex), _namespace, name.Value, parameters, body, returnType, exported);
     }
 
-    private static StructDefinitionNode ParseStruct(int startIndex, List<ModifierToken> modifiers, Optional<string> documentation)
+    private static StructDefinitionNode ParseStruct(int startIndex, List<ModifierToken> modifiers)
     {
         var name = ExpectIdentifier().Value;
 
@@ -179,10 +170,10 @@ public static class Parser
                 .Build());
         }
 
-        return new StructDefinitionNode(GetTokensForNode(startIndex), documentation, _namespace, name, variables);
+        return new StructDefinitionNode(GetTokensForNode(startIndex), _namespace, name, variables);
     }
 
-    private static TraitDefinitionNode ParseTrait(int startIndex, List<ModifierToken> modifiers, Optional<string> documentation)
+    private static TraitDefinitionNode ParseTrait(int startIndex, List<ModifierToken> modifiers)
     {
         var name = ExpectIdentifier().Value;
 
@@ -226,10 +217,10 @@ public static class Parser
             functions.Add(new TraitFunc(funcName, parameters, returnType));
         }
 
-        return new TraitDefinitionNode(GetTokensForNode(startIndex), documentation, _namespace, name, functions);
+        return new TraitDefinitionNode(GetTokensForNode(startIndex), _namespace, name, functions);
     }
 
-    private static TraitImplementationDefinitionNode ParseImplementation(int startIndex, List<ModifierToken> modifiers, Optional<string> documentation)
+    private static TraitImplementationDefinitionNode ParseImplementation(int startIndex, List<ModifierToken> modifiers)
     {
         var traitType = ParseType();
         ExpectSymbol(Symbol.For);
@@ -280,7 +271,7 @@ public static class Parser
                 .Build());
         }
 
-        return new TraitImplementationDefinitionNode(GetTokensForNode(startIndex), documentation, _namespace, traitType, forType, functions);
+        return new TraitImplementationDefinitionNode(GetTokensForNode(startIndex), _namespace, traitType, forType, functions);
     }
 
     private static FuncParameter ParseFuncParameter()
@@ -905,11 +896,6 @@ public static class Parser
     private static Optional<Token> Peek(int offset = 0)
     {
         var peekIndex = _index + offset;
-        while (peekIndex < _tokens.Count() && _tokens.ElementAt(peekIndex) is DocumentationToken)
-        {
-            peekIndex++;
-        }
-
         if (peekIndex < _tokens.Count())
         {
             return _tokens.ElementAt(peekIndex);
@@ -920,11 +906,6 @@ public static class Parser
 
     private static void Next()
     {
-        while (_index < _tokens.Count() && _tokens.ElementAt(_index) is DocumentationToken)
-        {
-            _index++;
-        }
-
         _index++;
     }
 

src/compiler/Syntax/Parsing/SyntaxTree.cs

@@ -1,4 +1,4 @@
-using Syntax.Parsing.Node;
+using Syntax.Node;
 
 namespace Syntax.Parsing;
 

src/compiler/Syntax/Tokenization/DocumentationToken.cs

@@ -1,6 +0,0 @@
-namespace Syntax.Tokenization;
-
-public class DocumentationToken(SourceSpan span, string documentation) : Token(span)
-{
-    public string Documentation { get; } = documentation;
-}

src/compiler/Syntax/Tokenization/Tokenizer.cs

@@ -81,17 +81,8 @@ public static class Tokenizer
         return tokens;
     }
 
-    private static void ConsumeWhitespace()
-    {
-        while (Peek().TryGetValue(out var character) && char.IsWhiteSpace(character))
-        {
-            Next();
-        }
-    }
-
     private static Optional<Token> ParseToken()
     {
-        ConsumeWhitespace();
         var startIndex = _index;
 
         if (!Peek().TryGetValue(out var current))
@@ -99,31 +90,23 @@ public static class Tokenizer
             return Optional<Token>.Empty();
         }
 
+        if (Peek().TryGetValue(out var character) && char.IsWhiteSpace(character))
+        {
+            Next();
+
+            return ParseToken();
+        }
+
         if (current == '/' && Peek(1).TryGetValue(out var nextChar) && nextChar == '/')
         {
             Next();
             Next();
 
-            if (Peek().TryGetValue(out var thirdChar) && thirdChar == '/')
+            while (Peek().TryGetValue(out var ch) && ch != '\n')
-            {
-                Next();
-                var buffer = string.Empty;
-                while (Peek().TryGetValue(out var character) && character != '\n')
-                {
-                    buffer += character;
-                    Next();
-                }
-
-                Next();
-                return new DocumentationToken(CreateSpan(startIndex), buffer);
-            }
-
-            while (Peek().TryGetValue(out var character) && character != '\n')
             {
                 Next();
             }
 
-            Next();
             return ParseToken();
         }
 
@@ -278,8 +261,14 @@ public static class Tokenizer
         return Optional<char>.Empty();
     }
 
-    private static void Next()
+    private static Optional<char> Next()
     {
+        if (_index < _sourceText.Content.Length)
+        {
+            return _sourceText.Content[_index++];
+        }
+
         _index++;
+        return Optional<char>.Empty();
     }
 }

src/compiler/Syntax/Typing/Binder.cs

@@ -1,10 +1,9 @@
 using Common;
 using Syntax.Diagnostics;
+using Syntax.Node;
 using Syntax.Parsing;
-using Syntax.Parsing.Node;
 using Syntax.Tokenization;
-using Syntax.Typing.BoundNode;
+using UnaryExpressionNode = Syntax.Node.UnaryExpressionNode;
-using UnaryExpressionNode = Syntax.Parsing.Node.UnaryExpressionNode;
 
 namespace Syntax.Typing;
 
@@ -66,7 +65,7 @@ public static class Binder
             functions.Add(new BoundImplementationFuncNode(function.Tokens, function.Name, parameters, function.ReturnType, BindBlock(function.Body)));
         }
 
-        return new BoundTraitImplementationDefinitionNode(node.Tokens, node.Documentation, node.Namespace, node.TraitType, node.ForType, functions);
+        return new BoundTraitImplementationDefinitionNode(node.Tokens, node.Namespace, node.TraitType, node.ForType, functions);
     }
 
     private static BoundTraitDefinitionNode BindTraitDefinition(TraitDefinitionNode node)
@@ -85,7 +84,7 @@ public static class Binder
             functions.Add(new BountTraitFunc(func.Name, parameters, func.ReturnType));
         }
 
-        return new BoundTraitDefinitionNode(node.Tokens, node.Documentation, node.Namespace, node.Name, functions);
+        return new BoundTraitDefinitionNode(node.Tokens, node.Namespace, node.Name, functions);
     }
 
     private static BoundStructDefinitionNode BindStruct(StructDefinitionNode node)
@@ -116,7 +115,7 @@ public static class Binder
             structFields.Add(new BoundStructField(structField.Name, structField.Type, value));
         }
 
-        return new BoundStructDefinitionNode(node.Tokens, node.Documentation, node.Namespace, node.Name, structFields);
+        return new BoundStructDefinitionNode(node.Tokens, node.Namespace, node.Name, structFields);
     }
 
     private static BoundExternFuncDefinitionNode BindExternFuncDefinition(ExternFuncDefinitionNode node)
@@ -128,7 +127,7 @@ public static class Binder
             parameters.Add(new BoundFuncParameter(parameter.Name, parameter.Type));
         }
 
-        return new BoundExternFuncDefinitionNode(node.Tokens, node.Documentation, node.Namespace, node.Name, node.CallName, parameters, node.ReturnType);
+        return new BoundExternFuncDefinitionNode(node.Tokens, node.Namespace, node.Name, node.CallName, parameters, node.ReturnType);
     }
 
     private static BoundLocalFuncDefinitionNode BindLocalFuncDefinition(LocalFuncDefinitionNode node)
@@ -146,7 +145,7 @@ public static class Binder
 
         var body = BindBlock(node.Body);
 
-        return new BoundLocalFuncDefinitionNode(node.Tokens, node.Documentation, node.Namespace, node.Name, parameters, body, node.ReturnType, node.Exported);
+        return new BoundLocalFuncDefinitionNode(node.Tokens, node.Namespace, node.Name, parameters, body, node.ReturnType, node.Exported);
     }
 
     private static BoundBlockNode BindBlock(BlockNode node)

src/compiler/Syntax/Typing/BoundNode/BoundDefinition.cs

@@ -1,20 +0,0 @@
-using Common;
-using Syntax.Tokenization;
-
-namespace Syntax.Typing.BoundNode;
-
-public abstract record BoundDefinitionNode(IEnumerable<Token> Tokens, Optional<string> Documentation, string Namespace) : BoundNode(Tokens);
-
-public record BoundFuncParameter(string Name, NubType Type);
-public abstract record BoundFuncDefinition(IEnumerable<Token> Tokens, Optional<string> Documentation, string Namespace, string Name, List<BoundFuncParameter> Parameters, NubType ReturnType) : BoundDefinitionNode(Tokens, Documentation, Namespace);
-public record BoundLocalFuncDefinitionNode(IEnumerable<Token> Tokens, Optional<string> Documentation, string Namespace, string Name, List<BoundFuncParameter> Parameters, BoundBlockNode Body, NubType ReturnType, bool Exported) : BoundFuncDefinition(Tokens, Documentation, Namespace, Name, Parameters, ReturnType);
-public record BoundExternFuncDefinitionNode(IEnumerable<Token> Tokens, Optional<string> Documentation, string Namespace, string Name, string CallName, List<BoundFuncParameter> Parameters, NubType ReturnType) : BoundFuncDefinition(Tokens, Documentation, Namespace, Name, Parameters, ReturnType);
-
-public record BoundStructField(string Name, NubType Type, Optional<BoundExpressionNode> Value);
-public record BoundStructDefinitionNode(IEnumerable<Token> Tokens, Optional<string> Documentation, string Namespace, string Name, List<BoundStructField> Fields) : BoundDefinitionNode(Tokens, Documentation, Namespace);
-
-public record BountTraitFunc(string Name, List<BoundFuncParameter> Parameters, NubType ReturnType);
-public record BoundTraitDefinitionNode(IEnumerable<Token> Tokens, Optional<string> Documentation, string Namespace, string Name, List<BountTraitFunc> Functions) : BoundDefinitionNode(Tokens, Documentation, Namespace);
-
-public record BoundImplementationFuncNode(IEnumerable<Token> Tokens, string Name, List<BoundFuncParameter> Parameters, NubType ReturnType, BoundBlockNode Body) : BoundNode(Tokens);
-public record BoundTraitImplementationDefinitionNode(IEnumerable<Token> Tokens, Optional<string> Documentation, string Namespace, NubType TraitType, NubType ForType, List<BoundImplementationFuncNode> Functions) : BoundDefinitionNode(Tokens, Documentation, Namespace);

src/compiler/Syntax/Typing/BoundNode/BoundNode.cs

@@ -1,6 +0,0 @@
-using Syntax.Tokenization;
-
-namespace Syntax.Typing.BoundNode;
-
-public abstract record BoundNode(IEnumerable<Token> Tokens);
-public record BoundBlockNode(IEnumerable<Token> Tokens, List<BoundStatementNode> Statements) : BoundNode(Tokens);

src/compiler/Syntax/Typing/BoundSyntaxTree.cs

@@ -1,4 +1,4 @@
-using Syntax.Typing.BoundNode;
+using Syntax.Node;
 
 namespace Syntax.Typing;