diff --git a/src/compiler/Generation/QBE/QBEGenerator.cs b/src/compiler/Generation/QBE/QBEGenerator.cs index d2335c4..17b580a 100644 --- a/src/compiler/Generation/QBE/QBEGenerator.cs +++ b/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; diff --git a/src/compiler/Generation/QBE/QBEWriter.cs b/src/compiler/Generation/QBE/QBEWriter.cs index 8a0a4c6..9d50c26 100644 --- a/src/compiler/Generation/QBE/QBEWriter.cs +++ b/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; diff --git a/src/compiler/Syntax/DefinitionTable.cs b/src/compiler/Syntax/DefinitionTable.cs index 1f8cd25..75aa445 100644 --- a/src/compiler/Syntax/DefinitionTable.cs +++ b/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.Empty(); } - - public IEnumerable GetStructs() - { - return _syntaxTrees - .SelectMany(c => c.Definitions) - .OfType(); - } - - public IEnumerable GetFunctions() - { - return _syntaxTrees - .SelectMany(c => c.Definitions) - .OfType(); - } - - public IEnumerable GetLocalFunctions() - { - return _syntaxTrees - .SelectMany(c => c.Definitions) - .OfType(); - } - - public IEnumerable GetExternFunctions() - { - return _syntaxTrees - .SelectMany(c => c.Definitions) - .OfType(); - } - - public IEnumerable GetTraits() - { - return _syntaxTrees - .SelectMany(c => c.Definitions) - .OfType(); - } - - public IEnumerable GetTraitImplementations() - { - return _syntaxTrees - .SelectMany(c => c.Definitions) - .OfType(); - } } public class BoundDefinitionTable @@ -192,38 +149,10 @@ public class BoundDefinitionTable .OfType(); } - public IEnumerable GetFunctions() - { - return _syntaxTrees - .SelectMany(c => c.Definitions) - .OfType(); - } - - public IEnumerable GetLocalFunctions() - { - return _syntaxTrees - .SelectMany(c => c.Definitions) - .OfType(); - } - - public IEnumerable GetExternFunctions() - { - return _syntaxTrees - .SelectMany(c => c.Definitions) - .OfType(); - } - public IEnumerable GetTraits() { return _syntaxTrees .SelectMany(c => c.Definitions) .OfType(); } - - public IEnumerable GetTraitImplementations() - { - return _syntaxTrees - .SelectMany(c => c.Definitions) - .OfType(); - } } \ No newline at end of file diff --git a/src/compiler/Syntax/Diagnostics/ConsoleColors.cs b/src/compiler/Syntax/Diagnostics/ConsoleColors.cs index ea4979d..d963905 100644 --- a/src/compiler/Syntax/Diagnostics/ConsoleColors.cs +++ b/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: diff --git a/src/compiler/Syntax/Diagnostics/Diagnostic.cs b/src/compiler/Syntax/Diagnostics/Diagnostic.cs index 4ba1ee3..db4ee55 100644 --- a/src/compiler/Syntax/Diagnostics/Diagnostic.cs +++ b/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; diff --git a/src/compiler/Syntax/Node/Definition.cs b/src/compiler/Syntax/Node/Definition.cs new file mode 100644 index 0000000..732f667 --- /dev/null +++ b/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 Tokens, string Namespace) : Node(Tokens); +public abstract record BoundDefinitionNode(IEnumerable Tokens, string Namespace) : BoundNode(Tokens); + +public record FuncParameter(string Name, NubType Type); +public record BoundFuncParameter(string Name, NubType Type); + +public abstract record FuncDefinition(IEnumerable Tokens, string Namespace, string Name, List Parameters, NubType ReturnType) : DefinitionNode(Tokens, Namespace); +public abstract record BoundFuncDefinition(IEnumerable Tokens, string Namespace, string Name, List Parameters, NubType ReturnType) : BoundDefinitionNode(Tokens, Namespace); + +public record LocalFuncDefinitionNode(IEnumerable Tokens, string Namespace, string Name, List Parameters, BlockNode Body, NubType ReturnType, bool Exported) : FuncDefinition(Tokens, Namespace, Name, Parameters, ReturnType); +public record BoundLocalFuncDefinitionNode(IEnumerable Tokens, string Namespace, string Name, List Parameters, BoundBlockNode Body, NubType ReturnType, bool Exported) : BoundFuncDefinition(Tokens, Namespace, Name, Parameters, ReturnType); + +public record ExternFuncDefinitionNode(IEnumerable Tokens, string Namespace, string Name, string CallName, List Parameters, NubType ReturnType) : FuncDefinition(Tokens, Namespace, Name, Parameters, ReturnType); +public record BoundExternFuncDefinitionNode(IEnumerable Tokens, string Namespace, string Name, string CallName, List Parameters, NubType ReturnType) : BoundFuncDefinition(Tokens, Namespace, Name, Parameters, ReturnType); + +public record StructField(string Name, NubType Type, Optional Value); +public record BoundStructField(string Name, NubType Type, Optional Value); + +public record StructDefinitionNode(IEnumerable Tokens, string Namespace, string Name, List Fields) : DefinitionNode(Tokens, Namespace); +public record BoundStructDefinitionNode(IEnumerable Tokens, string Namespace, string Name, List Fields) : BoundDefinitionNode(Tokens, Namespace); + +public record TraitFunc(string Name, List Parameters, NubType ReturnType); +public record BountTraitFunc(string Name, List Parameters, NubType ReturnType); + +public record TraitDefinitionNode(IEnumerable Tokens, string Namespace, string Name, List Functions) : DefinitionNode(Tokens, Namespace); +public record BoundTraitDefinitionNode(IEnumerable Tokens, string Namespace, string Name, List Functions) : BoundDefinitionNode(Tokens, Namespace); + +public record ImplementationFuncNode(IEnumerable Tokens, string Name, List Parameters, NubType ReturnType, BlockNode Body) : BoundNode(Tokens); +public record BoundImplementationFuncNode(IEnumerable Tokens, string Name, List Parameters, NubType ReturnType, BoundBlockNode Body) : BoundNode(Tokens); + +public record BoundTraitImplementationDefinitionNode(IEnumerable Tokens, string Namespace, NubType TraitType, NubType ForType, List Functions) : BoundDefinitionNode(Tokens, Namespace); +public record TraitImplementationDefinitionNode(IEnumerable Tokens, string Namespace, NubType TraitType, NubType ForType, List Functions) : DefinitionNode(Tokens, Namespace); \ No newline at end of file diff --git a/src/compiler/Syntax/Typing/BoundNode/BoundExpression.cs b/src/compiler/Syntax/Node/Expression.cs similarity index 51% rename from src/compiler/Syntax/Typing/BoundNode/BoundExpression.cs rename to src/compiler/Syntax/Node/Expression.cs index 2dc8efe..8f6945d 100644 --- a/src/compiler/Syntax/Typing/BoundNode/BoundExpression.cs +++ b/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 Tokens) : Node(Tokens); public abstract record BoundExpressionNode(IEnumerable Tokens, NubType Type) : BoundNode(Tokens); + +public record BinaryExpressionNode(IEnumerable Tokens, ExpressionNode Left, BinaryExpressionOperator Operator, ExpressionNode Right) : ExpressionNode(Tokens); public record BoundBinaryExpressionNode(IEnumerable Tokens, NubType Type, BoundExpressionNode Left, BinaryExpressionOperator Operator, BoundExpressionNode Right) : BoundExpressionNode(Tokens, Type); + +public record UnaryExpressionNode(IEnumerable Tokens, UnaryExpressionOperator Operator, ExpressionNode Operand) : ExpressionNode(Tokens); public record BoundUnaryExpressionNode(IEnumerable Tokens, NubType Type, UnaryExpressionOperator Operator, BoundExpressionNode Operand) : BoundExpressionNode(Tokens, Type); + +public record FuncCallNode(IEnumerable Tokens, ExpressionNode Expression, List Parameters) : ExpressionNode(Tokens); public record BoundFuncCallNode(IEnumerable Tokens, NubType Type, BoundExpressionNode Expression, List Parameters) : BoundExpressionNode(Tokens, Type); + +public record IdentifierNode(IEnumerable Tokens, Optional Namespace, string Name) : ExpressionNode(Tokens); public record BoundIdentifierNode(IEnumerable Tokens, NubType Type, Optional Namespace, string Name) : BoundExpressionNode(Tokens, Type); + +public record ArrayInitializerNode(IEnumerable Tokens, ExpressionNode Capacity, NubType ElementType) : ExpressionNode(Tokens); public record BoundArrayInitializerNode(IEnumerable Tokens, NubType Type, BoundExpressionNode Capacity, NubType ElementType) : BoundExpressionNode(Tokens, Type); + +public record ArrayIndexAccessNode(IEnumerable Tokens, ExpressionNode Array, ExpressionNode Index) : ExpressionNode(Tokens); public record BoundArrayIndexAccessNode(IEnumerable Tokens, NubType Type, BoundExpressionNode Array, BoundExpressionNode Index) : BoundExpressionNode(Tokens, Type); + +public record AnonymousFuncNode(IEnumerable Tokens, List Parameters, BlockNode Body, NubType ReturnType) : ExpressionNode(Tokens); public record BoundAnonymousFuncNode(IEnumerable Tokens, NubType Type, List Parameters, BoundBlockNode Body, NubType ReturnType) : BoundExpressionNode(Tokens, Type); + +public record AddressOfNode(IEnumerable Tokens, ExpressionNode Expression) : ExpressionNode(Tokens); public record BoundAddressOfNode(IEnumerable Tokens, NubType Type, BoundExpressionNode Expression) : BoundExpressionNode(Tokens, Type); + +public record LiteralNode(IEnumerable Tokens, string Literal, LiteralKind Kind) : ExpressionNode(Tokens); public record BoundLiteralNode(IEnumerable Tokens, NubType Type, string Literal, LiteralKind Kind) : BoundExpressionNode(Tokens, Type); + +public record MemberAccessNode(IEnumerable Tokens, ExpressionNode Expression, string Member) : ExpressionNode(Tokens); public record BoundMemberAccessNode(IEnumerable Tokens, NubType Type, BoundExpressionNode Expression, string Member) : BoundExpressionNode(Tokens, Type); + +public record StructInitializerNode(IEnumerable Tokens, NubType StructType, Dictionary Initializers) : ExpressionNode(Tokens); public record BoundStructInitializerNode(IEnumerable Tokens, NubType Type, NubType StructType, Dictionary Initializers) : BoundExpressionNode(Tokens, Type); -public record BoundDereferenceNode(IEnumerable Tokens, NubType Type, BoundExpressionNode Expression) : BoundExpressionNode(Tokens, Type); + +public record DereferenceNode(IEnumerable Tokens, ExpressionNode Expression) : ExpressionNode(Tokens); +public record BoundDereferenceNode(IEnumerable Tokens, NubType Type, BoundExpressionNode Expression) : BoundExpressionNode(Tokens, Type); \ No newline at end of file diff --git a/src/compiler/Syntax/Node/Node.cs b/src/compiler/Syntax/Node/Node.cs new file mode 100644 index 0000000..b9ce43e --- /dev/null +++ b/src/compiler/Syntax/Node/Node.cs @@ -0,0 +1,9 @@ +using Syntax.Tokenization; + +namespace Syntax.Node; + +public abstract record Node(IEnumerable Tokens); +public abstract record BoundNode(IEnumerable Tokens); + +public record BlockNode(IEnumerable Tokens, List Statements) : Node(Tokens); +public record BoundBlockNode(IEnumerable Tokens, List Statements) : BoundNode(Tokens); \ No newline at end of file diff --git a/src/compiler/Syntax/Typing/BoundNode/BoundStatement.cs b/src/compiler/Syntax/Node/Statement.cs similarity index 52% rename from src/compiler/Syntax/Typing/BoundNode/BoundStatement.cs rename to src/compiler/Syntax/Node/Statement.cs index ef5da00..e216814 100644 --- a/src/compiler/Syntax/Typing/BoundNode/BoundStatement.cs +++ b/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 Tokens) : Node(Tokens); public record BoundStatementNode(IEnumerable Tokens) : BoundNode(Tokens); + +public record StatementExpressionNode(IEnumerable Tokens, ExpressionNode Expression) : StatementNode(Tokens); public record BoundStatementExpressionNode(IEnumerable Tokens, BoundExpressionNode Expression) : BoundStatementNode(Tokens); + +public record ReturnNode(IEnumerable Tokens, Optional Value) : StatementNode(Tokens); public record BoundReturnNode(IEnumerable Tokens, Optional Value) : BoundStatementNode(Tokens); + +public record AssignmentNode(IEnumerable Tokens, ExpressionNode Expression, ExpressionNode Value) : StatementNode(Tokens); public record BoundAssignmentNode(IEnumerable Tokens, BoundExpressionNode Expression, BoundExpressionNode Value) : BoundStatementNode(Tokens); + +public record IfNode(IEnumerable Tokens, ExpressionNode Condition, BlockNode Body, Optional> Else) : StatementNode(Tokens); public record BoundIfNode(IEnumerable Tokens, BoundExpressionNode Condition, BoundBlockNode Body, Optional> Else) : BoundStatementNode(Tokens); + +public record VariableDeclarationNode(IEnumerable Tokens, string Name, Optional ExplicitType, Optional Assignment) : StatementNode(Tokens); public record BoundVariableDeclarationNode(IEnumerable Tokens, string Name, Optional ExplicitType, Optional Assignment, NubType Type) : BoundStatementNode(Tokens); + +public record ContinueNode(IEnumerable Tokens) : StatementNode(Tokens); public record BoundContinueNode(IEnumerable Tokens) : BoundStatementNode(Tokens); + +public record BreakNode(IEnumerable Tokens) : StatementNode(Tokens); public record BoundBreakNode(IEnumerable Tokens) : BoundStatementNode(Tokens); -public record BoundWhileNode(IEnumerable Tokens, BoundExpressionNode Condition, BoundBlockNode Body) : BoundStatementNode(Tokens); + +public record WhileNode(IEnumerable Tokens, ExpressionNode Condition, BlockNode Body) : StatementNode(Tokens); +public record BoundWhileNode(IEnumerable Tokens, BoundExpressionNode Condition, BoundBlockNode Body) : BoundStatementNode(Tokens); \ No newline at end of file diff --git a/src/compiler/Syntax/Parsing/Node/Definition.cs b/src/compiler/Syntax/Parsing/Node/Definition.cs deleted file mode 100644 index 8455a38..0000000 --- a/src/compiler/Syntax/Parsing/Node/Definition.cs +++ /dev/null @@ -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 Tokens, Optional Documentation, string Namespace) : Node(Tokens); - -public record FuncParameter(string Name, NubType Type); -public abstract record FuncDefinition(IEnumerable Tokens, Optional Documentation, string Namespace, string Name, List Parameters, NubType ReturnType) : DefinitionNode(Tokens, Documentation, Namespace); -public record LocalFuncDefinitionNode(IEnumerable Tokens, Optional Documentation, string Namespace, string Name, List Parameters, BlockNode Body, NubType ReturnType, bool Exported) : FuncDefinition(Tokens, Documentation, Namespace, Name, Parameters, ReturnType); -public record ExternFuncDefinitionNode(IEnumerable Tokens, Optional Documentation, string Namespace, string Name, string CallName, List Parameters, NubType ReturnType) : FuncDefinition(Tokens, Documentation, Namespace, Name, Parameters, ReturnType); - -public record StructField(string Name, NubType Type, Optional Value); -public record StructDefinitionNode(IEnumerable Tokens, Optional Documentation, string Namespace, string Name, List Fields) : DefinitionNode(Tokens, Documentation, Namespace); - -public record TraitFunc(string Name, List Parameters, NubType ReturnType); -public record TraitDefinitionNode(IEnumerable Tokens, Optional Documentation, string Namespace, string Name, List Functions) : DefinitionNode(Tokens, Documentation, Namespace); - -public record ImplementationFuncNode(IEnumerable Tokens, string Name, List Parameters, NubType ReturnType, BlockNode Body) : BoundNode(Tokens); -public record TraitImplementationDefinitionNode(IEnumerable Tokens, Optional Documentation, string Namespace, NubType TraitType, NubType ForType, List Functions) : DefinitionNode(Tokens, Documentation, Namespace); \ No newline at end of file diff --git a/src/compiler/Syntax/Parsing/Node/Expression.cs b/src/compiler/Syntax/Parsing/Node/Expression.cs deleted file mode 100644 index b56f835..0000000 --- a/src/compiler/Syntax/Parsing/Node/Expression.cs +++ /dev/null @@ -1,42 +0,0 @@ -using Common; -using Syntax.Tokenization; -using Syntax.Typing; - -namespace Syntax.Parsing.Node; - -public abstract record ExpressionNode(IEnumerable Tokens) : Node(Tokens); - -public record BinaryExpressionNode(IEnumerable 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 Tokens, UnaryExpressionOperator Operator, ExpressionNode Operand) : ExpressionNode(Tokens); - -public enum UnaryExpressionOperator -{ - Negate, - Invert -} - -public record FuncCallNode(IEnumerable Tokens, ExpressionNode Expression, List Parameters) : ExpressionNode(Tokens); -public record IdentifierNode(IEnumerable Tokens, Optional Namespace, string Name) : ExpressionNode(Tokens); -public record ArrayInitializerNode(IEnumerable Tokens, ExpressionNode Capacity, NubType ElementType) : ExpressionNode(Tokens); -public record ArrayIndexAccessNode(IEnumerable Tokens, ExpressionNode Array, ExpressionNode Index) : ExpressionNode(Tokens); -public record AnonymousFuncNode(IEnumerable Tokens, List Parameters, BlockNode Body, NubType ReturnType) : ExpressionNode(Tokens); -public record AddressOfNode(IEnumerable Tokens, ExpressionNode Expression) : ExpressionNode(Tokens); -public record LiteralNode(IEnumerable Tokens, string Literal, LiteralKind Kind) : ExpressionNode(Tokens); -public record MemberAccessNode(IEnumerable Tokens, ExpressionNode Expression, string Member) : ExpressionNode(Tokens); -public record StructInitializerNode(IEnumerable Tokens, NubType StructType, Dictionary Initializers) : ExpressionNode(Tokens); -public record DereferenceNode(IEnumerable Tokens, ExpressionNode Expression) : ExpressionNode(Tokens); diff --git a/src/compiler/Syntax/Parsing/Node/Node.cs b/src/compiler/Syntax/Parsing/Node/Node.cs deleted file mode 100644 index 5d4357e..0000000 --- a/src/compiler/Syntax/Parsing/Node/Node.cs +++ /dev/null @@ -1,6 +0,0 @@ -using Syntax.Tokenization; - -namespace Syntax.Parsing.Node; - -public abstract record Node(IEnumerable Tokens); -public record BlockNode(IEnumerable Tokens, List Statements) : Node(Tokens); diff --git a/src/compiler/Syntax/Parsing/Node/Statement.cs b/src/compiler/Syntax/Parsing/Node/Statement.cs deleted file mode 100644 index eee6a77..0000000 --- a/src/compiler/Syntax/Parsing/Node/Statement.cs +++ /dev/null @@ -1,15 +0,0 @@ -using Common; -using Syntax.Tokenization; -using Syntax.Typing; - -namespace Syntax.Parsing.Node; - -public record StatementNode(IEnumerable Tokens) : Node(Tokens); -public record StatementExpressionNode(IEnumerable Tokens, ExpressionNode Expression) : StatementNode(Tokens); -public record ReturnNode(IEnumerable Tokens, Optional Value) : StatementNode(Tokens); -public record AssignmentNode(IEnumerable Tokens, ExpressionNode Expression, ExpressionNode Value) : StatementNode(Tokens); -public record IfNode(IEnumerable Tokens, ExpressionNode Condition, BlockNode Body, Optional> Else) : StatementNode(Tokens); -public record VariableDeclarationNode(IEnumerable Tokens, string Name, Optional ExplicitType, Optional Assignment) : StatementNode(Tokens); -public record ContinueNode(IEnumerable Tokens) : StatementNode(Tokens); -public record BreakNode(IEnumerable Tokens) : StatementNode(Tokens); -public record WhileNode(IEnumerable Tokens, ExpressionNode Condition, BlockNode Body) : StatementNode(Tokens); diff --git a/src/compiler/Syntax/Parsing/Parser.cs b/src/compiler/Syntax/Parsing/Parser.cs index 0434a83..27c0ed1 100644 --- a/src/compiler/Syntax/Parsing/Parser.cs +++ b/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 modifiers = []; - List 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.Struct => ParseStruct(startIndex, modifiers, Optional.OfNullable(documentation)), - Symbol.Trait => ParseTrait(startIndex, modifiers, Optional.OfNullable(documentation)), - Symbol.Impl => ParseImplementation(startIndex, modifiers, Optional.OfNullable(documentation)), + Symbol.Func => ParseFuncDefinition(startIndex, modifiers), + Symbol.Struct => ParseStruct(startIndex, modifiers), + Symbol.Trait => ParseTrait(startIndex, modifiers), + 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 modifiers, Optional documentation) + private static DefinitionNode ParseFuncDefinition(int startIndex, List modifiers) { var name = ExpectIdentifier(); List 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 modifiers, Optional documentation) + private static StructDefinitionNode ParseStruct(int startIndex, List 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 modifiers, Optional documentation) + private static TraitDefinitionNode ParseTrait(int startIndex, List 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 modifiers, Optional documentation) + private static TraitImplementationDefinitionNode ParseImplementation(int startIndex, List 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 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++; } diff --git a/src/compiler/Syntax/Parsing/SyntaxTree.cs b/src/compiler/Syntax/Parsing/SyntaxTree.cs index c36babc..4865724 100644 --- a/src/compiler/Syntax/Parsing/SyntaxTree.cs +++ b/src/compiler/Syntax/Parsing/SyntaxTree.cs @@ -1,4 +1,4 @@ -using Syntax.Parsing.Node; +using Syntax.Node; namespace Syntax.Parsing; diff --git a/src/compiler/Syntax/Tokenization/DocumentationToken.cs b/src/compiler/Syntax/Tokenization/DocumentationToken.cs deleted file mode 100644 index 54a0e51..0000000 --- a/src/compiler/Syntax/Tokenization/DocumentationToken.cs +++ /dev/null @@ -1,6 +0,0 @@ -namespace Syntax.Tokenization; - -public class DocumentationToken(SourceSpan span, string documentation) : Token(span) -{ - public string Documentation { get; } = documentation; -} \ No newline at end of file diff --git a/src/compiler/Syntax/Tokenization/Tokenizer.cs b/src/compiler/Syntax/Tokenization/Tokenizer.cs index aeb0aff..de4b3a7 100644 --- a/src/compiler/Syntax/Tokenization/Tokenizer.cs +++ b/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 ParseToken() { - ConsumeWhitespace(); var startIndex = _index; if (!Peek().TryGetValue(out var current)) @@ -99,31 +90,23 @@ public static class Tokenizer return Optional.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 == '/') - { - 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') + while (Peek().TryGetValue(out var ch) && ch != '\n') { Next(); } - Next(); return ParseToken(); } @@ -278,8 +261,14 @@ public static class Tokenizer return Optional.Empty(); } - private static void Next() + private static Optional Next() { + if (_index < _sourceText.Content.Length) + { + return _sourceText.Content[_index++]; + } + _index++; + return Optional.Empty(); } } \ No newline at end of file diff --git a/src/compiler/Syntax/Typing/Binder.cs b/src/compiler/Syntax/Typing/Binder.cs index 565cbc3..19eec9e 100644 --- a/src/compiler/Syntax/Typing/Binder.cs +++ b/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.Parsing.Node.UnaryExpressionNode; +using UnaryExpressionNode = Syntax.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) diff --git a/src/compiler/Syntax/Typing/BoundNode/BoundDefinition.cs b/src/compiler/Syntax/Typing/BoundNode/BoundDefinition.cs deleted file mode 100644 index c37131f..0000000 --- a/src/compiler/Syntax/Typing/BoundNode/BoundDefinition.cs +++ /dev/null @@ -1,20 +0,0 @@ -using Common; -using Syntax.Tokenization; - -namespace Syntax.Typing.BoundNode; - -public abstract record BoundDefinitionNode(IEnumerable Tokens, Optional Documentation, string Namespace) : BoundNode(Tokens); - -public record BoundFuncParameter(string Name, NubType Type); -public abstract record BoundFuncDefinition(IEnumerable Tokens, Optional Documentation, string Namespace, string Name, List Parameters, NubType ReturnType) : BoundDefinitionNode(Tokens, Documentation, Namespace); -public record BoundLocalFuncDefinitionNode(IEnumerable Tokens, Optional Documentation, string Namespace, string Name, List Parameters, BoundBlockNode Body, NubType ReturnType, bool Exported) : BoundFuncDefinition(Tokens, Documentation, Namespace, Name, Parameters, ReturnType); -public record BoundExternFuncDefinitionNode(IEnumerable Tokens, Optional Documentation, string Namespace, string Name, string CallName, List Parameters, NubType ReturnType) : BoundFuncDefinition(Tokens, Documentation, Namespace, Name, Parameters, ReturnType); - -public record BoundStructField(string Name, NubType Type, Optional Value); -public record BoundStructDefinitionNode(IEnumerable Tokens, Optional Documentation, string Namespace, string Name, List Fields) : BoundDefinitionNode(Tokens, Documentation, Namespace); - -public record BountTraitFunc(string Name, List Parameters, NubType ReturnType); -public record BoundTraitDefinitionNode(IEnumerable Tokens, Optional Documentation, string Namespace, string Name, List Functions) : BoundDefinitionNode(Tokens, Documentation, Namespace); - -public record BoundImplementationFuncNode(IEnumerable Tokens, string Name, List Parameters, NubType ReturnType, BoundBlockNode Body) : BoundNode(Tokens); -public record BoundTraitImplementationDefinitionNode(IEnumerable Tokens, Optional Documentation, string Namespace, NubType TraitType, NubType ForType, List Functions) : BoundDefinitionNode(Tokens, Documentation, Namespace); \ No newline at end of file diff --git a/src/compiler/Syntax/Typing/BoundNode/BoundNode.cs b/src/compiler/Syntax/Typing/BoundNode/BoundNode.cs deleted file mode 100644 index 6030c31..0000000 --- a/src/compiler/Syntax/Typing/BoundNode/BoundNode.cs +++ /dev/null @@ -1,6 +0,0 @@ -using Syntax.Tokenization; - -namespace Syntax.Typing.BoundNode; - -public abstract record BoundNode(IEnumerable Tokens); -public record BoundBlockNode(IEnumerable Tokens, List Statements) : BoundNode(Tokens); diff --git a/src/compiler/Syntax/Typing/BoundSyntaxTree.cs b/src/compiler/Syntax/Typing/BoundSyntaxTree.cs index 30c04fd..6e80811 100644 --- a/src/compiler/Syntax/Typing/BoundSyntaxTree.cs +++ b/src/compiler/Syntax/Typing/BoundSyntaxTree.cs @@ -1,4 +1,4 @@ -using Syntax.Typing.BoundNode; +using Syntax.Node; namespace Syntax.Typing;