nub31/nub-lang-archive
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Clean

Browse Source
This commit is contained in:
nub31
2025-07-05 15:41:01 +02:00
parent efceb3b68b
commit ccb0929d4c
21 changed files with 158 additions and 270 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/compiler/Generation/QBE/QBEGenerator.cs
View File

@@ -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;

2
src/compiler/Generation/QBE/QBEWriter.cs
View File

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

73
src/compiler/Syntax/DefinitionTable.cs
View File

@@ -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>();
}
}

2
src/compiler/Syntax/Diagnostics/ConsoleColors.cs
View File

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

3
src/compiler/Syntax/Diagnostics/Diagnostic.cs
View File

@@ -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;

38
src/compiler/Syntax/Node/Definition.cs Normal file
View File

@@ -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);

51
src/compiler/Syntax/Typing/BoundNode/BoundExpression.cs → src/compiler/Syntax/Node/Expression.cs
View File

@@ -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 BoundDereferenceNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Expression) : 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);

9
src/compiler/Syntax/Node/Node.cs Normal file
View File

@@ -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);

23
src/compiler/Syntax/Typing/BoundNode/BoundStatement.cs → src/compiler/Syntax/Node/Statement.cs
View File

@@ -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 BoundWhileNode(IEnumerable<Token> Tokens, BoundExpressionNode Condition, BoundBlockNode Body) : 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);

22
src/compiler/Syntax/Parsing/Node/Definition.cs
View File

@@ -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);

42
src/compiler/Syntax/Parsing/Node/Expression.cs
View File

@@ -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);

6
src/compiler/Syntax/Parsing/Node/Node.cs
View File

@@ -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);

15
src/compiler/Syntax/Parsing/Node/Statement.cs
View File

@@ -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);

47
src/compiler/Syntax/Parsing/Parser.cs
View File

@@ -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.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<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++;
}

2
src/compiler/Syntax/Parsing/SyntaxTree.cs
View File

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

6
src/compiler/Syntax/Tokenization/DocumentationToken.cs
View File

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

41
src/compiler/Syntax/Tokenization/Tokenizer.cs
View File

@@ -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 == '/')
{
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<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();
}
}

15
src/compiler/Syntax/Typing/Binder.cs
View File

@@ -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)

20
src/compiler/Syntax/Typing/BoundNode/BoundDefinition.cs
View File

@@ -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);

6
src/compiler/Syntax/Typing/BoundNode/BoundNode.cs
View File

@@ -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);

2
src/compiler/Syntax/Typing/BoundSyntaxTree.cs
View File

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