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

rename node -> syntax

Browse Source
This commit is contained in:
nub31
2025-07-06 23:09:54 +02:00
parent 8762b5e7e1
commit 98ac4d789e
15 changed files with 373 additions and 271 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/compiler/CLI/Program.cs
View File

@@ -5,6 +5,7 @@ using NubLang.Diagnostics;
using NubLang.Generation.QBE; using NubLang.Generation.QBE;
using NubLang.Syntax.Node; using NubLang.Syntax.Node;
using NubLang.Syntax.Parsing; using NubLang.Syntax.Parsing;
using NubLang.Syntax.Parsing.Node;
using NubLang.Syntax.Tokenization; using NubLang.Syntax.Tokenization;
using Binder = NubLang.Syntax.Binding.Binder; using Binder = NubLang.Syntax.Binding.Binder;

59
src/compiler/NubLang/DefinitionTable.cs
View File

@@ -1,59 +1,60 @@
using NubLang.Syntax.Node; using NubLang.Syntax.Node;
using NubLang.Syntax.Parsing.Node;
namespace NubLang; namespace NubLang;
public sealed class DefinitionTable public sealed class DefinitionTable
{ {
private readonly List<TopLevelNode> _topLevelNodes; private readonly List<DefinitionSyntax> _definitions;
public DefinitionTable(IEnumerable<SyntaxTree> syntaxTrees) public DefinitionTable(IEnumerable<SyntaxTree> syntaxTrees)
{ {
_topLevelNodes = syntaxTrees.SelectMany(x => x.TopLevelNodes).ToList(); _definitions = syntaxTrees.SelectMany(x => x.Definitions).ToList();
} }
public IEnumerable<LocalFuncNode> LookupLocalFunc(string @namespace, string name) public IEnumerable<LocalFuncSyntax> LookupLocalFunc(string @namespace, string name)
{ {
return _topLevelNodes return _definitions
.OfType<LocalFuncNode>() .OfType<LocalFuncSyntax>()
.Where(x => x.Namespace == @namespace && x.Name == name); .Where(x => x.Namespace == @namespace && x.Name == name);
} }
public IEnumerable<ExternFuncNode> LookupExternFunc(string @namespace, string name) public IEnumerable<ExternFuncSyntax> LookupExternFunc(string @namespace, string name)
{ {
return _topLevelNodes return _definitions
.OfType<ExternFuncNode>() .OfType<ExternFuncSyntax>()
.Where(x => x.Namespace == @namespace && x.Name == name); .Where(x => x.Namespace == @namespace && x.Name == name);
} }
public IEnumerable<StructNode> LookupStruct(string @namespace, string name) public IEnumerable<StructSyntax> LookupStruct(string @namespace, string name)
{ {
return _topLevelNodes return _definitions
.OfType<StructNode>() .OfType<StructSyntax>()
.Where(x => x.Namespace == @namespace && x.Name == name); .Where(x => x.Namespace == @namespace && x.Name == name);
} }
public IEnumerable<StructFieldNode> LookupStructField(StructNode structNode, string field) public IEnumerable<StructFieldSyntax> LookupStructField(StructSyntax structNode, string field)
{ {
return structNode.Fields.Where(x => x.Name == field); return structNode.Fields.Where(x => x.Name == field);
} }
public IEnumerable<TraitFuncImplNode> LookupTraitFuncImpl(NubType forType, string name) public IEnumerable<TraitFuncImplSyntax> LookupTraitFuncImpl(NubType forType, string name)
{ {
return _topLevelNodes return _definitions
.OfType<TraitImplNode>() .OfType<TraitImplSyntax>()
.Where(x => x.ForType == forType) .Where(x => x.ForType == forType)
.SelectMany(x => x.Functions) .SelectMany(x => x.Functions)
.Where(x => x.Name == name); .Where(x => x.Name == name);
} }
public IEnumerable<TraitNode> LookupTrait(string @namespace, string name) public IEnumerable<TraitSyntax> LookupTrait(string @namespace, string name)
{ {
return _topLevelNodes return _definitions
.OfType<TraitNode>() .OfType<TraitSyntax>()
.Where(x => x.Namespace == @namespace && x.Name == name); .Where(x => x.Namespace == @namespace && x.Name == name);
} }
public IEnumerable<TraitFuncNode> LookupTraitFunc(TraitNode trait, string name) public IEnumerable<TraitFuncSyntax> LookupTraitFunc(TraitSyntax trait, string name)
{ {
return trait.Functions.Where(x => x.Name == name); return trait.Functions.Where(x => x.Name == name);
} }
@@ -61,30 +62,30 @@ public sealed class DefinitionTable
public sealed class BoundDefinitionTable public sealed class BoundDefinitionTable
{ {
private readonly List<BoundTopLevelNode> _topLevelNodes; private readonly List<BoundDefinitionNode> _definitions;
public BoundDefinitionTable(IEnumerable<BoundSyntaxTree> syntaxTrees) public BoundDefinitionTable(IEnumerable<BoundSyntaxTree> syntaxTrees)
{ {
_topLevelNodes = syntaxTrees.SelectMany(x => x.TopLevelNodes).ToList(); _definitions = syntaxTrees.SelectMany(x => x.Definitions).ToList();
} }
public BoundLocalFuncNode LookupLocalFunc(string @namespace, string name) public BoundLocalFuncNode LookupLocalFunc(string @namespace, string name)
{ {
return _topLevelNodes return _definitions
.OfType<BoundLocalFuncNode>() .OfType<BoundLocalFuncNode>()
.First(x => x.Namespace == @namespace && x.Name == name); .First(x => x.Namespace == @namespace && x.Name == name);
} }
public BoundExternFuncNode LookupExternFunc(string @namespace, string name) public BoundExternFuncNode LookupExternFunc(string @namespace, string name)
{ {
return _topLevelNodes return _definitions
.OfType<BoundExternFuncNode>() .OfType<BoundExternFuncNode>()
.First(x => x.Namespace == @namespace && x.Name == name); .First(x => x.Namespace == @namespace && x.Name == name);
} }
public BoundStructNode LookupStruct(string @namespace, string name) public BoundStructNode LookupStruct(string @namespace, string name)
{ {
return _topLevelNodes return _definitions
.OfType<BoundStructNode>() .OfType<BoundStructNode>()
.First(x => x.Namespace == @namespace && x.Name == name); .First(x => x.Namespace == @namespace && x.Name == name);
} }
@@ -96,14 +97,14 @@ public sealed class BoundDefinitionTable
public IEnumerable<BoundTraitImplNode> LookupTraitImpls(NubType itemType) public IEnumerable<BoundTraitImplNode> LookupTraitImpls(NubType itemType)
{ {
return _topLevelNodes return _definitions
.OfType<BoundTraitImplNode>() .OfType<BoundTraitImplNode>()
.Where(x => x.ForType == itemType); .Where(x => x.ForType == itemType);
} }
public BoundTraitFuncImplNode LookupTraitFuncImpl(NubType forType, string name) public BoundTraitFuncImplNode LookupTraitFuncImpl(NubType forType, string name)
{ {
return _topLevelNodes return _definitions
.OfType<BoundTraitImplNode>() .OfType<BoundTraitImplNode>()
.Where(x => x.ForType == forType) .Where(x => x.ForType == forType)
.SelectMany(x => x.Functions) .SelectMany(x => x.Functions)
@@ -112,7 +113,7 @@ public sealed class BoundDefinitionTable
public BoundTraitNode LookupTrait(string @namespace, string name) public BoundTraitNode LookupTrait(string @namespace, string name)
{ {
return _topLevelNodes return _definitions
.OfType<BoundTraitNode>() .OfType<BoundTraitNode>()
.First(x => x.Namespace == @namespace && x.Name == name); .First(x => x.Namespace == @namespace && x.Name == name);
} }
@@ -124,11 +125,11 @@ public sealed class BoundDefinitionTable
public IEnumerable<BoundStructNode> GetStructs() public IEnumerable<BoundStructNode> GetStructs()
{ {
return _topLevelNodes.OfType<BoundStructNode>(); return _definitions.OfType<BoundStructNode>();
} }
public IEnumerable<BoundTraitNode> GetTraits() public IEnumerable<BoundTraitNode> GetTraits()
{ {
return _topLevelNodes.OfType<BoundTraitNode>(); return _definitions.OfType<BoundTraitNode>();
} }
} }

4
src/compiler/NubLang/Diagnostics/Diagnostic.cs
View File

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

40
src/compiler/NubLang/Generation/QBE/QBEGenerator.cs
View File

@@ -64,7 +64,7 @@ public static class QBEGenerator
_writer.NewLine(); _writer.NewLine();
} }
foreach (var funcDef in _syntaxTree.TopLevelNodes.OfType<BoundLocalFuncNode>()) foreach (var funcDef in _syntaxTree.Definitions.OfType<BoundLocalFuncNode>())
{ {
EmitFuncDefinition(funcDef, LocalFuncName(funcDef), funcDef.Parameters, funcDef.ReturnType, funcDef.Body, funcDef.Exported); EmitFuncDefinition(funcDef, LocalFuncName(funcDef), funcDef.Parameters, funcDef.ReturnType, funcDef.Body, funcDef.Exported);
_writer.NewLine(); _writer.NewLine();
@@ -766,15 +766,15 @@ public static class QBEGenerator
return new Val(outputName, binaryExpression.Type, ValKind.Direct); return new Val(outputName, binaryExpression.Type, ValKind.Direct);
} }
private static string EmitBinaryInstructionFor(BinaryExpressionOperator op, NubType type, string left, string right) private static string EmitBinaryInstructionFor(BoundBinaryOperator op, NubType type, string left, string right)
{ {
if (op is if (op is
BinaryExpressionOperator.Equal or BoundBinaryOperator.Equal or
BinaryExpressionOperator.NotEqual or BoundBinaryOperator.NotEqual or
BinaryExpressionOperator.GreaterThan or BoundBinaryOperator.GreaterThan or
BinaryExpressionOperator.GreaterThanOrEqual or BoundBinaryOperator.GreaterThanOrEqual or
BinaryExpressionOperator.LessThan or BoundBinaryOperator.LessThan or
BinaryExpressionOperator.LessThanOrEqual) BoundBinaryOperator.LessThanOrEqual)
{ {
char suffix; char suffix;
@@ -815,12 +815,12 @@ public static class QBEGenerator
throw new NotSupportedException($"Unsupported type '{simpleType}' for binary operator '{op}'"); throw new NotSupportedException($"Unsupported type '{simpleType}' for binary operator '{op}'");
} }
if (op is BinaryExpressionOperator.Equal) if (op is BoundBinaryOperator.Equal)
{ {
return "ceq" + suffix; return "ceq" + suffix;
} }
if (op is BinaryExpressionOperator.NotEqual) if (op is BoundBinaryOperator.NotEqual)
{ {
return "cne" + suffix; return "cne" + suffix;
} }
@@ -842,20 +842,20 @@ public static class QBEGenerator
return op switch return op switch
{ {
BinaryExpressionOperator.GreaterThan => 'c' + sign + "gt" + suffix, BoundBinaryOperator.GreaterThan => 'c' + sign + "gt" + suffix,
BinaryExpressionOperator.GreaterThanOrEqual => 'c' + sign + "ge" + suffix, BoundBinaryOperator.GreaterThanOrEqual => 'c' + sign + "ge" + suffix,
BinaryExpressionOperator.LessThan => 'c' + sign + "lt" + suffix, BoundBinaryOperator.LessThan => 'c' + sign + "lt" + suffix,
BinaryExpressionOperator.LessThanOrEqual => 'c' + sign + "le" + suffix, BoundBinaryOperator.LessThanOrEqual => 'c' + sign + "le" + suffix,
_ => throw new ArgumentOutOfRangeException(nameof(op), op, null) _ => throw new ArgumentOutOfRangeException(nameof(op), op, null)
}; };
} }
return op switch return op switch
{ {
BinaryExpressionOperator.Plus => "add", BoundBinaryOperator.Plus => "add",
BinaryExpressionOperator.Minus => "sub", BoundBinaryOperator.Minus => "sub",
BinaryExpressionOperator.Multiply => "mul", BoundBinaryOperator.Multiply => "mul",
BinaryExpressionOperator.Divide => "div", BoundBinaryOperator.Divide => "div",
_ => throw new ArgumentOutOfRangeException(nameof(op)) _ => throw new ArgumentOutOfRangeException(nameof(op))
}; };
} }
@@ -994,7 +994,7 @@ public static class QBEGenerator
switch (unaryExpression.Operator) switch (unaryExpression.Operator)
{ {
case UnaryExpressionOperator.Negate: case BoundUnaryOperator.Negate:
{ {
switch (unaryExpression.Operand.Type) switch (unaryExpression.Operand.Type)
{ {
@@ -1014,7 +1014,7 @@ public static class QBEGenerator
break; break;
} }
case UnaryExpressionOperator.Invert: case BoundUnaryOperator.Invert:
{ {
switch (unaryExpression.Operand.Type) switch (unaryExpression.Operand.Type)
{ {

154
src/compiler/NubLang/Syntax/Binding/Binder.cs
View File

@@ -1,8 +1,8 @@
using Common; using Common;
using NubLang.Diagnostics; using NubLang.Diagnostics;
using NubLang.Syntax.Node; using NubLang.Syntax.Node;
using NubLang.Syntax.Parsing.Node;
using NubLang.Syntax.Tokenization; using NubLang.Syntax.Tokenization;
using Node_UnaryExpressionNode = NubLang.Syntax.Node.UnaryExpressionNode;
namespace NubLang.Syntax.Binding; namespace NubLang.Syntax.Binding;
@@ -28,13 +28,13 @@ public sealed class Binder
_functionReturnType = null; _functionReturnType = null;
var diagnostics = new List<Diagnostic>(); var diagnostics = new List<Diagnostic>();
var topLevelNodes = new List<BoundTopLevelNode>(); var definitions = new List<BoundDefinitionNode>();
foreach (var topLevel in _syntaxTree.TopLevelNodes) foreach (var definition in _syntaxTree.Definitions)
{ {
try try
{ {
topLevelNodes.Add(BindTopLevel(topLevel)); definitions.Add(BindTopLevel(definition));
} }
catch (BindException e) catch (BindException e)
{ {
@@ -42,23 +42,23 @@ public sealed class Binder
} }
} }
return new BoundSyntaxTree(_syntaxTree.Namespace, topLevelNodes, diagnostics); return new BoundSyntaxTree(_syntaxTree.Namespace, definitions, diagnostics);
} }
private BoundTopLevelNode BindTopLevel(TopLevelNode node) private BoundDefinitionNode BindTopLevel(DefinitionSyntax node)
{ {
return node switch return node switch
{ {
ExternFuncNode topLevel => BindExternFuncDefinition(topLevel), ExternFuncSyntax topLevel => BindExternFuncDefinition(topLevel),
TraitImplNode topLevel => BindTraitImplementation(topLevel), TraitImplSyntax topLevel => BindTraitImplementation(topLevel),
TraitNode topLevel => BindTraitDefinition(topLevel), TraitSyntax topLevel => BindTraitDefinition(topLevel),
LocalFuncNode topLevel => BindLocalFuncDefinition(topLevel), LocalFuncSyntax topLevel => BindLocalFuncDefinition(topLevel),
StructNode topLevel => BindStruct(topLevel), StructSyntax topLevel => BindStruct(topLevel),
_ => throw new ArgumentOutOfRangeException(nameof(node)) _ => throw new ArgumentOutOfRangeException(nameof(node))
}; };
} }
private BoundTraitImplNode BindTraitImplementation(TraitImplNode node) private BoundTraitImplNode BindTraitImplementation(TraitImplSyntax node)
{ {
_variables.Clear(); _variables.Clear();
var functions = new List<BoundTraitFuncImplNode>(); var functions = new List<BoundTraitFuncImplNode>();
@@ -79,7 +79,7 @@ public sealed class Binder
return new BoundTraitImplNode(node.Tokens, node.Namespace, node.TraitType, node.ForType, functions); return new BoundTraitImplNode(node.Tokens, node.Namespace, node.TraitType, node.ForType, functions);
} }
private BoundTraitNode BindTraitDefinition(TraitNode node) private BoundTraitNode BindTraitDefinition(TraitSyntax node)
{ {
var functions = new List<BoundTraitFuncNode>(); var functions = new List<BoundTraitFuncNode>();
@@ -98,7 +98,7 @@ public sealed class Binder
return new BoundTraitNode(node.Tokens, node.Namespace, node.Name, functions); return new BoundTraitNode(node.Tokens, node.Namespace, node.Name, functions);
} }
private BoundStructNode BindStruct(StructNode node) private BoundStructNode BindStruct(StructSyntax node)
{ {
var structFields = new List<BoundStructFieldNode>(); var structFields = new List<BoundStructFieldNode>();
@@ -117,7 +117,7 @@ public sealed class Binder
return new BoundStructNode(node.Tokens, node.Namespace, node.Name, structFields); return new BoundStructNode(node.Tokens, node.Namespace, node.Name, structFields);
} }
private BoundExternFuncNode BindExternFuncDefinition(ExternFuncNode node) private BoundExternFuncNode BindExternFuncDefinition(ExternFuncSyntax node)
{ {
var parameters = new List<BoundFuncParameterNode>(); var parameters = new List<BoundFuncParameterNode>();
@@ -129,7 +129,7 @@ public sealed class Binder
return new BoundExternFuncNode(node.Tokens, node.Namespace, node.Name, node.CallName, parameters, node.ReturnType); return new BoundExternFuncNode(node.Tokens, node.Namespace, node.Name, node.CallName, parameters, node.ReturnType);
} }
private BoundLocalFuncNode BindLocalFuncDefinition(LocalFuncNode node) private BoundLocalFuncNode BindLocalFuncDefinition(LocalFuncSyntax node)
{ {
_variables.Clear(); _variables.Clear();
_functionReturnType = node.ReturnType; _functionReturnType = node.ReturnType;
@@ -147,7 +147,7 @@ public sealed class Binder
return new BoundLocalFuncNode(node.Tokens, node.Namespace, node.Name, parameters, body, node.ReturnType, node.Exported); return new BoundLocalFuncNode(node.Tokens, node.Namespace, node.Name, parameters, body, node.ReturnType, node.Exported);
} }
private BoundBlock BindBlock(BlockNode node) private BoundBlock BindBlock(BlockSyntax node)
{ {
var statements = new List<BoundStatementNode>(); var statements = new List<BoundStatementNode>();
@@ -159,40 +159,40 @@ public sealed class Binder
return new BoundBlock(node.Tokens, statements); return new BoundBlock(node.Tokens, statements);
} }
private BoundStatementNode BindStatement(StatementNode node) private BoundStatementNode BindStatement(StatementSyntax node)
{ {
return node switch return node switch
{ {
AssignmentNode statement => BindAssignment(statement), AssignmentSyntax statement => BindAssignment(statement),
BreakNode statement => BindBreak(statement), BreakSyntax statement => BindBreak(statement),
ContinueNode statement => BindContinue(statement), ContinueSyntax statement => BindContinue(statement),
IfNode statement => BindIf(statement), IfSyntax statement => BindIf(statement),
ReturnNode statement => BindReturn(statement), ReturnSyntax statement => BindReturn(statement),
StatementExpressionNode statement => BindStatementExpression(statement), StatementExpressionSyntax statement => BindStatementExpression(statement),
VariableDeclarationNode statement => BindVariableDeclaration(statement), VariableDeclarationSyntax statement => BindVariableDeclaration(statement),
WhileNode statement => BindWhile(statement), WhileSyntax statement => BindWhile(statement),
_ => throw new ArgumentOutOfRangeException(nameof(node)) _ => throw new ArgumentOutOfRangeException(nameof(node))
}; };
} }
private BoundStatementNode BindAssignment(AssignmentNode statement) private BoundStatementNode BindAssignment(AssignmentSyntax statement)
{ {
var expression = BindExpression(statement.Target); var expression = BindExpression(statement.Target);
var value = BindExpression(statement.Value, expression.Type); var value = BindExpression(statement.Value, expression.Type);
return new BoundAssignmentNode(statement.Tokens, expression, value); return new BoundAssignmentNode(statement.Tokens, expression, value);
} }
private BoundBreakNode BindBreak(BreakNode statement) private BoundBreakNode BindBreak(BreakSyntax statement)
{ {
return new BoundBreakNode(statement.Tokens); return new BoundBreakNode(statement.Tokens);
} }
private BoundContinueNode BindContinue(ContinueNode statement) private BoundContinueNode BindContinue(ContinueSyntax statement)
{ {
return new BoundContinueNode(statement.Tokens); return new BoundContinueNode(statement.Tokens);
} }
private BoundIfNode BindIf(IfNode statement) private BoundIfNode BindIf(IfSyntax statement)
{ {
var elseStatement = Optional.Empty<Variant<BoundIfNode, BoundBlock>>(); var elseStatement = Optional.Empty<Variant<BoundIfNode, BoundBlock>>();
@@ -208,7 +208,7 @@ public sealed class Binder
return new BoundIfNode(statement.Tokens, BindExpression(statement.Condition, new NubPrimitiveType(PrimitiveTypeKind.Bool)), BindBlock(statement.Body), elseStatement); return new BoundIfNode(statement.Tokens, BindExpression(statement.Condition, new NubPrimitiveType(PrimitiveTypeKind.Bool)), BindBlock(statement.Body), elseStatement);
} }
private BoundReturnNode BindReturn(ReturnNode statement) private BoundReturnNode BindReturn(ReturnSyntax statement)
{ {
var value = Optional.Empty<BoundExpressionNode>(); var value = Optional.Empty<BoundExpressionNode>();
@@ -220,12 +220,12 @@ public sealed class Binder
return new BoundReturnNode(statement.Tokens, value); return new BoundReturnNode(statement.Tokens, value);
} }
private BoundStatementExpressionNode BindStatementExpression(StatementExpressionNode statement) private BoundStatementExpressionNode BindStatementExpression(StatementExpressionSyntax statement)
{ {
return new BoundStatementExpressionNode(statement.Tokens, BindExpression(statement.Expression)); return new BoundStatementExpressionNode(statement.Tokens, BindExpression(statement.Expression));
} }
private BoundVariableDeclarationNode BindVariableDeclaration(VariableDeclarationNode statement) private BoundVariableDeclarationNode BindVariableDeclaration(VariableDeclarationSyntax statement)
{ {
NubType? type = null; NubType? type = null;
@@ -252,38 +252,38 @@ public sealed class Binder
return new BoundVariableDeclarationNode(statement.Tokens, statement.Name, assignment, type); return new BoundVariableDeclarationNode(statement.Tokens, statement.Name, assignment, type);
} }
private BoundWhileNode BindWhile(WhileNode statement) private BoundWhileNode BindWhile(WhileSyntax statement)
{ {
return new BoundWhileNode(statement.Tokens, BindExpression(statement.Condition, new NubPrimitiveType(PrimitiveTypeKind.Bool)), BindBlock(statement.Body)); return new BoundWhileNode(statement.Tokens, BindExpression(statement.Condition, new NubPrimitiveType(PrimitiveTypeKind.Bool)), BindBlock(statement.Body));
} }
private BoundExpressionNode BindExpression(ExpressionNode node, NubType? expectedType = null) private BoundExpressionNode BindExpression(ExpressionSyntax node, NubType? expectedType = null)
{ {
return node switch return node switch
{ {
AddressOfNode expression => BindAddressOf(expression), AddressOfSyntax expression => BindAddressOf(expression),
AnonymousFuncNode expression => BindAnonymousFunc(expression), AnonymousFuncSyntax expression => BindAnonymousFunc(expression),
ArrayIndexAccessNode expression => BindArrayIndexAccess(expression), ArrayIndexAccessSyntax expression => BindArrayIndexAccess(expression),
ArrayInitializerNode expression => BindArrayInitializer(expression), ArrayInitializerSyntax expression => BindArrayInitializer(expression),
BinaryExpressionNode expression => BindBinaryExpression(expression), BinaryExpressionSyntax expression => BindBinaryExpression(expression),
DereferenceNode expression => BindDereference(expression), DereferenceSyntax expression => BindDereference(expression),
FuncCallNode expression => BindFuncCall(expression), FuncCallSyntax expression => BindFuncCall(expression),
IdentifierNode expression => BindIdentifier(expression), IdentifierSyntax expression => BindIdentifier(expression),
LiteralNode expression => BindLiteral(expression, expectedType), LiteralSyntax expression => BindLiteral(expression, expectedType),
MemberAccessNode expression => BindMemberAccess(expression), MemberAccessSyntax expression => BindMemberAccess(expression),
StructInitializerNode expression => BindStructInitializer(expression), StructInitializerSyntax expression => BindStructInitializer(expression),
Node_UnaryExpressionNode expression => BindUnaryExpression(expression), UnaryExpressionSyntax expression => BindUnaryExpression(expression),
_ => throw new ArgumentOutOfRangeException(nameof(node)) _ => throw new ArgumentOutOfRangeException(nameof(node))
}; };
} }
private BoundAddressOfNode BindAddressOf(AddressOfNode expression) private BoundAddressOfNode BindAddressOf(AddressOfSyntax expression)
{ {
var inner = BindExpression(expression.Expression); var inner = BindExpression(expression.Expression);
return new BoundAddressOfNode(expression.Tokens, new NubPointerType(inner.Type), inner); return new BoundAddressOfNode(expression.Tokens, new NubPointerType(inner.Type), inner);
} }
private BoundAnonymousFuncNode BindAnonymousFunc(AnonymousFuncNode expression) private BoundAnonymousFuncNode BindAnonymousFunc(AnonymousFuncSyntax expression)
{ {
var parameters = new List<BoundFuncParameterNode>(); var parameters = new List<BoundFuncParameterNode>();
@@ -297,33 +297,33 @@ public sealed class Binder
return new BoundAnonymousFuncNode(expression.Tokens, new NubFuncType(expression.ReturnType, parameters.Select(x => x.Type).ToList()), parameters, body, expression.ReturnType); return new BoundAnonymousFuncNode(expression.Tokens, new NubFuncType(expression.ReturnType, parameters.Select(x => x.Type).ToList()), parameters, body, expression.ReturnType);
} }
private BoundArrayIndexAccessNode BindArrayIndexAccess(ArrayIndexAccessNode expression) private BoundArrayIndexAccessNode BindArrayIndexAccess(ArrayIndexAccessSyntax expression)
{ {
var boundArray = BindExpression(expression.Target); var boundArray = BindExpression(expression.Target);
var elementType = ((NubArrayType)boundArray.Type).ElementType; var elementType = ((NubArrayType)boundArray.Type).ElementType;
return new BoundArrayIndexAccessNode(expression.Tokens, elementType, boundArray, BindExpression(expression.Index, new NubPrimitiveType(PrimitiveTypeKind.U64))); return new BoundArrayIndexAccessNode(expression.Tokens, elementType, boundArray, BindExpression(expression.Index, new NubPrimitiveType(PrimitiveTypeKind.U64)));
} }
private BoundArrayInitializerNode BindArrayInitializer(ArrayInitializerNode expression) private BoundArrayInitializerNode BindArrayInitializer(ArrayInitializerSyntax expression)
{ {
return new BoundArrayInitializerNode(expression.Tokens, new NubArrayType(expression.ElementType), BindExpression(expression.Capacity, new NubPrimitiveType(PrimitiveTypeKind.U64)), expression.ElementType); return new BoundArrayInitializerNode(expression.Tokens, new NubArrayType(expression.ElementType), BindExpression(expression.Capacity, new NubPrimitiveType(PrimitiveTypeKind.U64)), expression.ElementType);
} }
private BoundBinaryExpressionNode BindBinaryExpression(BinaryExpressionNode expression) private BoundBinaryExpressionNode BindBinaryExpression(BinaryExpressionSyntax expression)
{ {
var boundLeft = BindExpression(expression.Left); var boundLeft = BindExpression(expression.Left);
var boundRight = BindExpression(expression.Right, boundLeft.Type); var boundRight = BindExpression(expression.Right, boundLeft.Type);
return new BoundBinaryExpressionNode(expression.Tokens, boundLeft.Type, boundLeft, expression.Operator, boundRight); return new BoundBinaryExpressionNode(expression.Tokens, boundLeft.Type, boundLeft, BindBinaryOperator(expression.Operator), boundRight);
} }
private BoundDereferenceNode BindDereference(DereferenceNode expression) private BoundDereferenceNode BindDereference(DereferenceSyntax expression)
{ {
var boundExpression = BindExpression(expression.Expression); var boundExpression = BindExpression(expression.Expression);
var dereferencedType = ((NubPointerType)boundExpression.Type).BaseType; var dereferencedType = ((NubPointerType)boundExpression.Type).BaseType;
return new BoundDereferenceNode(expression.Tokens, dereferencedType, boundExpression); return new BoundDereferenceNode(expression.Tokens, dereferencedType, boundExpression);
} }
private BoundFuncCallNode BindFuncCall(FuncCallNode expression) private BoundFuncCallNode BindFuncCall(FuncCallSyntax expression)
{ {
var boundExpression = BindExpression(expression.Expression); var boundExpression = BindExpression(expression.Expression);
@@ -346,7 +346,7 @@ public sealed class Binder
return new BoundFuncCallNode(expression.Tokens, funcType.ReturnType, boundExpression, parameters); return new BoundFuncCallNode(expression.Tokens, funcType.ReturnType, boundExpression, parameters);
} }
private BoundExpressionNode BindIdentifier(IdentifierNode expression) private BoundExpressionNode BindIdentifier(IdentifierSyntax expression)
{ {
var @namespace = expression.Namespace.Or(_syntaxTree.Namespace); var @namespace = expression.Namespace.Or(_syntaxTree.Namespace);
var localFuncs = _definitionTable.LookupLocalFunc(@namespace, expression.Name).ToArray(); var localFuncs = _definitionTable.LookupLocalFunc(@namespace, expression.Name).ToArray();
@@ -385,7 +385,7 @@ public sealed class Binder
throw new BindException(Diagnostic.Error($"No identifier with then name {(expression.Namespace.HasValue ? $"{expression.Namespace.Value}::" : "")}{expression.Name} exists").Build()); throw new BindException(Diagnostic.Error($"No identifier with then name {(expression.Namespace.HasValue ? $"{expression.Namespace.Value}::" : "")}{expression.Name} exists").Build());
} }
private BoundLiteralNode BindLiteral(LiteralNode expression, NubType? expectedType = null) private BoundLiteralNode BindLiteral(LiteralSyntax expression, NubType? expectedType = null)
{ {
var type = expectedType ?? expression.Kind switch var type = expectedType ?? expression.Kind switch
{ {
@@ -399,7 +399,7 @@ public sealed class Binder
return new BoundLiteralNode(expression.Tokens, type, expression.Literal, expression.Kind); return new BoundLiteralNode(expression.Tokens, type, expression.Literal, expression.Kind);
} }
private BoundExpressionNode BindMemberAccess(MemberAccessNode expression) private BoundExpressionNode BindMemberAccess(MemberAccessSyntax expression)
{ {
var boundExpression = BindExpression(expression.Target); var boundExpression = BindExpression(expression.Target);
@@ -472,7 +472,7 @@ public sealed class Binder
throw new BindException(Diagnostic.Error($"{boundExpression.Type} does not have a member with the name {expression.Member}").Build()); throw new BindException(Diagnostic.Error($"{boundExpression.Type} does not have a member with the name {expression.Member}").Build());
} }
private BoundStructInitializerNode BindStructInitializer(StructInitializerNode expression) private BoundStructInitializerNode BindStructInitializer(StructInitializerSyntax expression)
{ {
if (expression.StructType is not NubCustomType structType) if (expression.StructType is not NubCustomType structType)
{ {
@@ -515,7 +515,7 @@ public sealed class Binder
return new BoundStructInitializerNode(expression.Tokens, structType, new NubCustomType(@struct.Namespace, @struct.Name), initializers); return new BoundStructInitializerNode(expression.Tokens, structType, new NubCustomType(@struct.Namespace, @struct.Name), initializers);
} }
private BoundUnaryExpressionNode BindUnaryExpression(Node_UnaryExpressionNode expression) private BoundUnaryExpressionNode BindUnaryExpression(UnaryExpressionSyntax expression)
{ {
var boundOperand = BindExpression(expression.Operand); var boundOperand = BindExpression(expression.Operand);
@@ -523,7 +523,7 @@ public sealed class Binder
switch (expression.Operator) switch (expression.Operator)
{ {
case UnaryExpressionOperator.Negate: case UnaryOperator.Negate:
{ {
boundOperand = BindExpression(expression.Operand, new NubPrimitiveType(PrimitiveTypeKind.I64)); boundOperand = BindExpression(expression.Operand, new NubPrimitiveType(PrimitiveTypeKind.I64));
@@ -534,7 +534,7 @@ public sealed class Binder
break; break;
} }
case UnaryExpressionOperator.Invert: case UnaryOperator.Invert:
{ {
boundOperand = BindExpression(expression.Operand, new NubPrimitiveType(PrimitiveTypeKind.Bool)); boundOperand = BindExpression(expression.Operand, new NubPrimitiveType(PrimitiveTypeKind.Bool));
@@ -548,7 +548,35 @@ public sealed class Binder
throw new NotImplementedException("Diagnostics not implemented"); throw new NotImplementedException("Diagnostics not implemented");
} }
return new BoundUnaryExpressionNode(expression.Tokens, type, expression.Operator, boundOperand); return new BoundUnaryExpressionNode(expression.Tokens, type, BindBinaryOperator(expression.Operator), boundOperand);
}
private BoundBinaryOperator BindBinaryOperator(BinaryOperator op)
{
return op switch
{
BinaryOperator.Equal => BoundBinaryOperator.Equal,
BinaryOperator.NotEqual => BoundBinaryOperator.NotEqual,
BinaryOperator.GreaterThan => BoundBinaryOperator.GreaterThan,
BinaryOperator.GreaterThanOrEqual => BoundBinaryOperator.GreaterThanOrEqual,
BinaryOperator.LessThan => BoundBinaryOperator.LessThan,
BinaryOperator.LessThanOrEqual => BoundBinaryOperator.LessThanOrEqual,
BinaryOperator.Plus => BoundBinaryOperator.Plus,
BinaryOperator.Minus => BoundBinaryOperator.Minus,
BinaryOperator.Multiply => BoundBinaryOperator.Multiply,
BinaryOperator.Divide => BoundBinaryOperator.Divide,
_ => throw new ArgumentOutOfRangeException(nameof(op), op, null)
};
}
private BoundUnaryOperator BindBinaryOperator(UnaryOperator op)
{
return op switch
{
UnaryOperator.Negate => BoundUnaryOperator.Negate,
UnaryOperator.Invert => BoundUnaryOperator.Invert,
_ => throw new ArgumentOutOfRangeException(nameof(op), op, null)
};
} }
} }

33
src/compiler/NubLang/Syntax/Node/Definition.cs
View File

@@ -3,35 +3,24 @@ using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Node; namespace NubLang.Syntax.Node;
public record FuncParameterNode(IEnumerable<Token> Tokens, string Name, NubType Type) : DefinitionNode(Tokens); public abstract record BoundDefinitionNode(IEnumerable<Token> Tokens, string Namespace) : BoundNode(Tokens);
public record BoundFuncParameterNode(IEnumerable<Token> Tokens, string Name, NubType Type) : DefinitionNode(Tokens);
public abstract record TopLevelNode(IEnumerable<Token> Tokens, string Namespace) : Node(Tokens); public abstract record BoundDefinitionMemberNode(IEnumerable<Token> Tokens) : BoundNode(Tokens);
public abstract record BoundTopLevelNode(IEnumerable<Token> Tokens, string Namespace) : BoundNode(Tokens);
public abstract record DefinitionNode(IEnumerable<Token> Tokens) : Node(Tokens); public record BoundFuncParameterNode(IEnumerable<Token> Tokens, string Name, NubType Type) : BoundDefinitionMemberNode(Tokens);
public abstract record BoundDefinitionNode(IEnumerable<Token> Tokens) : BoundNode(Tokens);
public record LocalFuncNode(IEnumerable<Token> Tokens, string Namespace, string Name, List<FuncParameterNode> Parameters, BlockNode Body, NubType ReturnType, bool Exported) : TopLevelNode(Tokens, Namespace); public record BoundLocalFuncNode(IEnumerable<Token> Tokens, string Namespace, string Name, List<BoundFuncParameterNode> Parameters, BoundBlock Body, NubType ReturnType, bool Exported) : BoundDefinitionNode(Tokens, Namespace);
public record BoundLocalFuncNode(IEnumerable<Token> Tokens, string Namespace, string Name, List<BoundFuncParameterNode> Parameters, BoundBlock Body, NubType ReturnType, bool Exported) : BoundTopLevelNode(Tokens, Namespace);
public record ExternFuncNode(IEnumerable<Token> Tokens, string Namespace, string Name, string CallName, List<FuncParameterNode> Parameters, NubType ReturnType) : TopLevelNode(Tokens, Namespace); public record BoundExternFuncNode(IEnumerable<Token> Tokens, string Namespace, string Name, string CallName, List<BoundFuncParameterNode> Parameters, NubType ReturnType) : BoundDefinitionNode(Tokens, Namespace);
public record BoundExternFuncNode(IEnumerable<Token> Tokens, string Namespace, string Name, string CallName, List<BoundFuncParameterNode> Parameters, NubType ReturnType) : BoundTopLevelNode(Tokens, Namespace);
public record StructFieldNode(IEnumerable<Token> Tokens, int Index, string Name, NubType Type, Optional<ExpressionNode> Value) : DefinitionNode(Tokens); public record BoundStructFieldNode(IEnumerable<Token> Tokens, int Index, string Name, NubType Type, Optional<BoundExpressionNode> Value) : BoundDefinitionMemberNode(Tokens);
public record StructNode(IEnumerable<Token> Tokens, string Namespace, string Name, List<StructFieldNode> Fields) : TopLevelNode(Tokens, Namespace);
public record BoundStructFieldNode(IEnumerable<Token> Tokens, int Index, string Name, NubType Type, Optional<BoundExpressionNode> Value) : BoundDefinitionNode(Tokens); public record BoundStructNode(IEnumerable<Token> Tokens, string Namespace, string Name, List<BoundStructFieldNode> Fields) : BoundDefinitionNode(Tokens, Namespace);
public record BoundStructNode(IEnumerable<Token> Tokens, string Namespace, string Name, List<BoundStructFieldNode> Fields) : BoundTopLevelNode(Tokens, Namespace);
public record TraitFuncNode(IEnumerable<Token> Tokens, string Name, List<FuncParameterNode> Parameters, NubType ReturnType) : DefinitionNode(Tokens); public record BoundTraitFuncNode(IEnumerable<Token> Tokens, string Name, List<BoundFuncParameterNode> Parameters, NubType ReturnType) : BoundDefinitionMemberNode(Tokens);
public record TraitNode(IEnumerable<Token> Tokens, string Namespace, string Name, List<TraitFuncNode> Functions) : TopLevelNode(Tokens, Namespace);
public record BoundTraitFuncNode(IEnumerable<Token> Tokens, string Name, List<BoundFuncParameterNode> Parameters, NubType ReturnType) : BoundDefinitionNode(Tokens); public record BoundTraitNode(IEnumerable<Token> Tokens, string Namespace, string Name, List<BoundTraitFuncNode> Functions) : BoundDefinitionNode(Tokens, Namespace);
public record BoundTraitNode(IEnumerable<Token> Tokens, string Namespace, string Name, List<BoundTraitFuncNode> Functions) : BoundTopLevelNode(Tokens, Namespace);
public record TraitFuncImplNode(IEnumerable<Token> Tokens, string Name, List<FuncParameterNode> Parameters, NubType ReturnType, BlockNode Body) : DefinitionNode(Tokens); public record BoundTraitFuncImplNode(IEnumerable<Token> Tokens, string Name, List<BoundFuncParameterNode> Parameters, NubType ReturnType, BoundBlock Body) : BoundDefinitionMemberNode(Tokens);
public record TraitImplNode(IEnumerable<Token> Tokens, string Namespace, NubType TraitType, NubType ForType, List<TraitFuncImplNode> Functions) : TopLevelNode(Tokens, Namespace);
public record BoundTraitFuncImplNode(IEnumerable<Token> Tokens, string Name, List<BoundFuncParameterNode> Parameters, NubType ReturnType, BoundBlock Body) : BoundDefinitionNode(Tokens); public record BoundTraitImplNode(IEnumerable<Token> Tokens, string Namespace, NubType TraitType, NubType ForType, List<BoundTraitFuncImplNode> Functions) : BoundDefinitionNode(Tokens, Namespace);
public record BoundTraitImplNode(IEnumerable<Token> Tokens, string Namespace, NubType TraitType, NubType ForType, List<BoundTraitFuncImplNode> Functions) : BoundTopLevelNode(Tokens, Namespace);

28
src/compiler/NubLang/Syntax/Node/Expression.cs
View File

@@ -1,15 +1,14 @@
using Common; using NubLang.Syntax.Tokenization;
using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Node; namespace NubLang.Syntax.Node;
public enum UnaryExpressionOperator public enum BoundUnaryOperator
{ {
Negate, Negate,
Invert Invert
} }
public enum BinaryExpressionOperator public enum BoundBinaryOperator
{ {
Equal, Equal,
NotEqual, NotEqual,
@@ -23,45 +22,36 @@ public enum BinaryExpressionOperator
Divide Divide
} }
public abstract record ExpressionNode(IEnumerable<Token> Tokens) : Node(Tokens);
public abstract record BoundExpressionNode(IEnumerable<Token> Tokens, NubType Type) : BoundNode(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, BoundBinaryOperator Operator, BoundExpressionNode Right) : BoundExpressionNode(Tokens, Type);
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, BoundUnaryOperator Operator, BoundExpressionNode Operand) : BoundExpressionNode(Tokens, Type);
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 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 BoundVariableIdentNode(IEnumerable<Token> Tokens, NubType Type, string Name) : BoundExpressionNode(Tokens, Type); public record BoundVariableIdentNode(IEnumerable<Token> Tokens, NubType Type, string Name) : BoundExpressionNode(Tokens, Type);
public record BoundLocalFuncIdentNode(IEnumerable<Token> Tokens, NubType Type, string Namespace, string Name) : BoundExpressionNode(Tokens, Type); public record BoundLocalFuncIdentNode(IEnumerable<Token> Tokens, NubType Type, string Namespace, string Name) : BoundExpressionNode(Tokens, Type);
public record BoundExternFuncIdentNode(IEnumerable<Token> Tokens, NubType Type, string Namespace, string Name) : BoundExpressionNode(Tokens, Type); public record BoundExternFuncIdentNode(IEnumerable<Token> Tokens, NubType Type, 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 BoundArrayInitializerNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Capacity, NubType ElementType) : BoundExpressionNode(Tokens, Type);
public record ArrayIndexAccessNode(IEnumerable<Token> Tokens, ExpressionNode Target, ExpressionNode Index) : ExpressionNode(Tokens);
public record BoundArrayIndexAccessNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Target, BoundExpressionNode Index) : BoundExpressionNode(Tokens, Type); public record BoundArrayIndexAccessNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Target, BoundExpressionNode Index) : BoundExpressionNode(Tokens, Type);
public record AnonymousFuncNode(IEnumerable<Token> Tokens, List<FuncParameterNode> Parameters, BlockNode Body, NubType ReturnType) : ExpressionNode(Tokens);
public record BoundAnonymousFuncNode(IEnumerable<Token> Tokens, NubType Type, List<BoundFuncParameterNode> Parameters, BoundBlock Body, NubType ReturnType) : BoundExpressionNode(Tokens, Type); public record BoundAnonymousFuncNode(IEnumerable<Token> Tokens, NubType Type, List<BoundFuncParameterNode> Parameters, BoundBlock 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 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 BoundLiteralNode(IEnumerable<Token> Tokens, NubType Type, string Literal, LiteralKind Kind) : BoundExpressionNode(Tokens, Type);
public record MemberAccessNode(IEnumerable<Token> Tokens, ExpressionNode Target, string Member) : ExpressionNode(Tokens);
public record BoundStructFieldAccessNode(IEnumerable<Token> Tokens, NubType Type, NubCustomType StructType, BoundExpressionNode Target, string Field) : BoundExpressionNode(Tokens, Type); public record BoundStructFieldAccessNode(IEnumerable<Token> Tokens, NubType Type, NubCustomType StructType, BoundExpressionNode Target, string Field) : BoundExpressionNode(Tokens, Type);
public record BoundTraitImplFuncAccessNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Target, string FuncName) : BoundExpressionNode(Tokens, Type); public record BoundTraitImplFuncAccessNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Target, string FuncName) : BoundExpressionNode(Tokens, Type);
public record BoundTraitFuncAccessNode(IEnumerable<Token> Tokens, NubType Type, NubCustomType TraitType, BoundExpressionNode Target, string FuncName) : BoundExpressionNode(Tokens, Type); public record BoundTraitFuncAccessNode(IEnumerable<Token> Tokens, NubType Type, NubCustomType TraitType, BoundExpressionNode Target, string FuncName) : 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, NubCustomType StructType, Dictionary<string, BoundExpressionNode> Initializers) : BoundExpressionNode(Tokens, Type); public record BoundStructInitializerNode(IEnumerable<Token> Tokens, NubType Type, NubCustomType 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); public record BoundDereferenceNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Expression) : BoundExpressionNode(Tokens, Type);

9
src/compiler/NubLang/Syntax/Node/Node.cs
View File

@@ -1,9 +0,0 @@
using NubLang.Syntax.Tokenization;
namespace NubLang.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 BoundBlock(IEnumerable<Token> Tokens, List<BoundStatementNode> Statements) : BoundNode(Tokens);

10
src/compiler/NubLang/Syntax/Node/Statement.cs
View File

@@ -3,30 +3,20 @@ using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Node; namespace NubLang.Syntax.Node;
public record StatementNode(IEnumerable<Token> Tokens) : Node(Tokens);
public record BoundStatementNode(IEnumerable<Token> Tokens) : BoundNode(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 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 BoundReturnNode(IEnumerable<Token> Tokens, Optional<BoundExpressionNode> Value) : BoundStatementNode(Tokens);
public record AssignmentNode(IEnumerable<Token> Tokens, ExpressionNode Target, ExpressionNode Value) : StatementNode(Tokens);
public record BoundAssignmentNode(IEnumerable<Token> Tokens, BoundExpressionNode Target, BoundExpressionNode Value) : BoundStatementNode(Tokens); public record BoundAssignmentNode(IEnumerable<Token> Tokens, BoundExpressionNode Target, 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, BoundBlock Body, Optional<Variant<BoundIfNode, BoundBlock>> Else) : BoundStatementNode(Tokens); public record BoundIfNode(IEnumerable<Token> Tokens, BoundExpressionNode Condition, BoundBlock Body, Optional<Variant<BoundIfNode, BoundBlock>> 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<BoundExpressionNode> Assignment, NubType Type) : BoundStatementNode(Tokens); public record BoundVariableDeclarationNode(IEnumerable<Token> Tokens, string Name, 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 BoundContinueNode(IEnumerable<Token> Tokens) : BoundStatementNode(Tokens);
public record BreakNode(IEnumerable<Token> Tokens) : StatementNode(Tokens);
public record BoundBreakNode(IEnumerable<Token> Tokens) : BoundStatementNode(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, BoundBlock Body) : BoundStatementNode(Tokens); public record BoundWhileNode(IEnumerable<Token> Tokens, BoundExpressionNode Condition, BoundBlock Body) : BoundStatementNode(Tokens);

8
src/compiler/NubLang/Syntax/Node/SyntaxTree.cs
View File

@@ -1,6 +1,10 @@
using NubLang.Diagnostics; using NubLang.Diagnostics;
using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Node; namespace NubLang.Syntax.Node;
public record SyntaxTree(string Namespace, IEnumerable<TopLevelNode> TopLevelNodes, IEnumerable<Diagnostic> Diagnostics); public record BoundSyntaxTree(string Namespace, IEnumerable<BoundDefinitionNode> Definitions, IEnumerable<Diagnostic> Diagnostics);
public record BoundSyntaxTree(string Namespace, IEnumerable<BoundTopLevelNode> TopLevelNodes, IEnumerable<Diagnostic> Diagnostics);
public abstract record BoundNode(IEnumerable<Token> Tokens);
public record BoundBlock(IEnumerable<Token> Tokens, List<BoundStatementNode> Statements) : BoundNode(Tokens);

26
src/compiler/NubLang/Syntax/Parsing/Node/DefinitionSyntax.cs Normal file
View File

@@ -0,0 +1,26 @@
using Common;
using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Parsing.Node;
public abstract record DefinitionSyntax(IEnumerable<Token> Tokens, string Namespace) : SyntaxNode(Tokens);
public abstract record DefinitionMemberSyntax(IEnumerable<Token> Tokens) : SyntaxNode(Tokens);
public record FuncParameterSyntax(IEnumerable<Token> Tokens, string Name, NubType Type) : DefinitionMemberSyntax(Tokens);
public record LocalFuncSyntax(IEnumerable<Token> Tokens, string Namespace, string Name, List<FuncParameterSyntax> Parameters, BlockSyntax Body, NubType ReturnType, bool Exported) : DefinitionSyntax(Tokens, Namespace);
public record ExternFuncSyntax(IEnumerable<Token> Tokens, string Namespace, string Name, string CallName, List<FuncParameterSyntax> Parameters, NubType ReturnType) : DefinitionSyntax(Tokens, Namespace);
public record StructFieldSyntax(IEnumerable<Token> Tokens, int Index, string Name, NubType Type, Optional<ExpressionSyntax> Value) : DefinitionMemberSyntax(Tokens);
public record StructSyntax(IEnumerable<Token> Tokens, string Namespace, string Name, List<StructFieldSyntax> Fields) : DefinitionSyntax(Tokens, Namespace);
public record TraitFuncSyntax(IEnumerable<Token> Tokens, string Name, List<FuncParameterSyntax> Parameters, NubType ReturnType) : DefinitionMemberSyntax(Tokens);
public record TraitSyntax(IEnumerable<Token> Tokens, string Namespace, string Name, List<TraitFuncSyntax> Functions) : DefinitionSyntax(Tokens, Namespace);
public record TraitFuncImplSyntax(IEnumerable<Token> Tokens, string Name, List<FuncParameterSyntax> Parameters, NubType ReturnType, BlockSyntax Body) : DefinitionMemberSyntax(Tokens);
public record TraitImplSyntax(IEnumerable<Token> Tokens, string Namespace, NubType TraitType, NubType ForType, List<TraitFuncImplSyntax> Functions) : DefinitionSyntax(Tokens, Namespace);

50
src/compiler/NubLang/Syntax/Parsing/Node/ExpressionSyntax.cs Normal file
View File

@@ -0,0 +1,50 @@
using Common;
using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Parsing.Node;
public enum UnaryOperator
{
Negate,
Invert
}
public enum BinaryOperator
{
Equal,
NotEqual,
GreaterThan,
GreaterThanOrEqual,
LessThan,
LessThanOrEqual,
Plus,
Minus,
Multiply,
Divide
}
public abstract record ExpressionSyntax(IEnumerable<Token> Tokens) : SyntaxNode(Tokens);
public record BinaryExpressionSyntax(IEnumerable<Token> Tokens, ExpressionSyntax Left, BinaryOperator Operator, ExpressionSyntax Right) : ExpressionSyntax(Tokens);
public record UnaryExpressionSyntax(IEnumerable<Token> Tokens, UnaryOperator Operator, ExpressionSyntax Operand) : ExpressionSyntax(Tokens);
public record FuncCallSyntax(IEnumerable<Token> Tokens, ExpressionSyntax Expression, List<ExpressionSyntax> Parameters) : ExpressionSyntax(Tokens);
public record IdentifierSyntax(IEnumerable<Token> Tokens, Optional<string> Namespace, string Name) : ExpressionSyntax(Tokens);
public record ArrayInitializerSyntax(IEnumerable<Token> Tokens, ExpressionSyntax Capacity, NubType ElementType) : ExpressionSyntax(Tokens);
public record ArrayIndexAccessSyntax(IEnumerable<Token> Tokens, ExpressionSyntax Target, ExpressionSyntax Index) : ExpressionSyntax(Tokens);
public record AnonymousFuncSyntax(IEnumerable<Token> Tokens, List<FuncParameterSyntax> Parameters, BlockSyntax Body, NubType ReturnType) : ExpressionSyntax(Tokens);
public record AddressOfSyntax(IEnumerable<Token> Tokens, ExpressionSyntax Expression) : ExpressionSyntax(Tokens);
public record LiteralSyntax(IEnumerable<Token> Tokens, string Literal, LiteralKind Kind) : ExpressionSyntax(Tokens);
public record MemberAccessSyntax(IEnumerable<Token> Tokens, ExpressionSyntax Target, string Member) : ExpressionSyntax(Tokens);
public record StructInitializerSyntax(IEnumerable<Token> Tokens, NubType StructType, Dictionary<string, ExpressionSyntax> Initializers) : ExpressionSyntax(Tokens);
public record DereferenceSyntax(IEnumerable<Token> Tokens, ExpressionSyntax Expression) : ExpressionSyntax(Tokens);

22
src/compiler/NubLang/Syntax/Parsing/Node/StatementSyntax.cs Normal file
View File

@@ -0,0 +1,22 @@
using Common;
using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Parsing.Node;
public record StatementSyntax(IEnumerable<Token> Tokens) : SyntaxNode(Tokens);
public record StatementExpressionSyntax(IEnumerable<Token> Tokens, ExpressionSyntax Expression) : StatementSyntax(Tokens);
public record ReturnSyntax(IEnumerable<Token> Tokens, Optional<ExpressionSyntax> Value) : StatementSyntax(Tokens);
public record AssignmentSyntax(IEnumerable<Token> Tokens, ExpressionSyntax Target, ExpressionSyntax Value) : StatementSyntax(Tokens);
public record IfSyntax(IEnumerable<Token> Tokens, ExpressionSyntax Condition, BlockSyntax Body, Optional<Variant<IfSyntax, BlockSyntax>> Else) : StatementSyntax(Tokens);
public record VariableDeclarationSyntax(IEnumerable<Token> Tokens, string Name, Optional<NubType> ExplicitType, Optional<ExpressionSyntax> Assignment) : StatementSyntax(Tokens);
public record ContinueSyntax(IEnumerable<Token> Tokens) : StatementSyntax(Tokens);
public record BreakSyntax(IEnumerable<Token> Tokens) : StatementSyntax(Tokens);
public record WhileSyntax(IEnumerable<Token> Tokens, ExpressionSyntax Condition, BlockSyntax Body) : StatementSyntax(Tokens);

10
src/compiler/NubLang/Syntax/Parsing/Node/SyntaxTree.cs Normal file
View File

@@ -0,0 +1,10 @@
using NubLang.Diagnostics;
using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Parsing.Node;
public record SyntaxTree(string Namespace, IEnumerable<DefinitionSyntax> Definitions, IEnumerable<Diagnostic> Diagnostics);
public abstract record SyntaxNode(IEnumerable<Token> Tokens);
public record BlockSyntax(IEnumerable<Token> Tokens, IEnumerable<StatementSyntax> Statements) : SyntaxNode(Tokens);

190
src/compiler/NubLang/Syntax/Parsing/Parser.cs
View File

@@ -1,7 +1,7 @@
using System.Diagnostics.CodeAnalysis; using System.Diagnostics.CodeAnalysis;
using Common; using Common;
using NubLang.Diagnostics; using NubLang.Diagnostics;
using NubLang.Syntax.Node; using NubLang.Syntax.Parsing.Node;
using NubLang.Syntax.Tokenization; using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Parsing; namespace NubLang.Syntax.Parsing;
@@ -32,13 +32,13 @@ public sealed class Parser
_namespace = ExpectIdentifier().Value; _namespace = ExpectIdentifier().Value;
} }
List<TopLevelNode> topLevelNodes = []; List<DefinitionSyntax> definitions = [];
while (Peek().HasValue) while (Peek().HasValue)
{ {
try try
{ {
topLevelNodes.Add(ParseTopLevel()); definitions.Add(ParseTopLevel());
} }
catch (ParseException ex) catch (ParseException ex)
{ {
@@ -47,10 +47,10 @@ public sealed class Parser
} }
} }
return new SyntaxTree(_namespace, topLevelNodes, _diagnostics); return new SyntaxTree(_namespace, definitions, _diagnostics);
} }
private TopLevelNode ParseTopLevel() private DefinitionSyntax ParseTopLevel()
{ {
var startIndex = _tokenIndex; var startIndex = _tokenIndex;
List<ModifierToken> modifiers = []; List<ModifierToken> modifiers = [];
@@ -86,10 +86,10 @@ public sealed class Parser
return node; return node;
} }
private TopLevelNode ParseFunc(int startIndex, List<ModifierToken> modifiers) private DefinitionSyntax ParseFunc(int startIndex, List<ModifierToken> modifiers)
{ {
var name = ExpectIdentifier(); var name = ExpectIdentifier();
List<FuncParameterNode> parameters = []; List<FuncParameterSyntax> parameters = [];
ExpectSymbol(Symbol.OpenParen); ExpectSymbol(Symbol.OpenParen);
@@ -129,22 +129,22 @@ public sealed class Parser
callName = ExpectIdentifier().Value; callName = ExpectIdentifier().Value;
} }
return new ExternFuncNode(GetTokensForNode(startIndex), _namespace, name.Value, callName, parameters, returnType); return new ExternFuncSyntax(GetTokens(startIndex), _namespace, name.Value, callName, parameters, returnType);
} }
var body = ParseBlock(); var body = ParseBlock();
var exported = modifiers.RemoveAll(x => x.Modifier == Modifier.Export) > 0; var exported = modifiers.RemoveAll(x => x.Modifier == Modifier.Export) > 0;
return new LocalFuncNode(GetTokensForNode(startIndex), _namespace, name.Value, parameters, body, returnType, exported); return new LocalFuncSyntax(GetTokens(startIndex), _namespace, name.Value, parameters, body, returnType, exported);
} }
private StructNode ParseStruct(int startIndex) private StructSyntax ParseStruct(int startIndex)
{ {
var name = ExpectIdentifier().Value; var name = ExpectIdentifier().Value;
ExpectSymbol(Symbol.OpenBrace); ExpectSymbol(Symbol.OpenBrace);
List<StructFieldNode> variables = []; List<StructFieldSyntax> variables = [];
var fieldIndex = 0; var fieldIndex = 0;
@@ -156,26 +156,26 @@ public sealed class Parser
ExpectSymbol(Symbol.Colon); ExpectSymbol(Symbol.Colon);
var variableType = ParseType(); var variableType = ParseType();
var variableValue = Optional<ExpressionNode>.Empty(); var variableValue = Optional<ExpressionSyntax>.Empty();
if (TryExpectSymbol(Symbol.Assign)) if (TryExpectSymbol(Symbol.Assign))
{ {
variableValue = ParseExpression(); variableValue = ParseExpression();
} }
variables.Add(new StructFieldNode(GetTokensForNode(fieldStartIndex), fieldIndex++, variableName, variableType, variableValue)); variables.Add(new StructFieldSyntax(GetTokens(fieldStartIndex), fieldIndex++, variableName, variableType, variableValue));
} }
return new StructNode(GetTokensForNode(startIndex), _namespace, name, variables); return new StructSyntax(GetTokens(startIndex), _namespace, name, variables);
} }
private TraitNode ParseTrait(int startIndex) private TraitSyntax ParseTrait(int startIndex)
{ {
var name = ExpectIdentifier().Value; var name = ExpectIdentifier().Value;
ExpectSymbol(Symbol.OpenBrace); ExpectSymbol(Symbol.OpenBrace);
List<TraitFuncNode> functions = []; List<TraitFuncSyntax> functions = [];
while (!TryExpectSymbol(Symbol.CloseBrace)) while (!TryExpectSymbol(Symbol.CloseBrace))
{ {
@@ -184,7 +184,7 @@ public sealed class Parser
ExpectSymbol(Symbol.Func); ExpectSymbol(Symbol.Func);
var funcName = ExpectIdentifier().Value; var funcName = ExpectIdentifier().Value;
var parameters = new List<FuncParameterNode>(); var parameters = new List<FuncParameterSyntax>();
ExpectSymbol(Symbol.OpenParen); ExpectSymbol(Symbol.OpenParen);
while (!TryExpectSymbol(Symbol.CloseParen)) while (!TryExpectSymbol(Symbol.CloseParen))
@@ -203,19 +203,19 @@ public sealed class Parser
var returnType = TryExpectSymbol(Symbol.Colon) ? ParseType() : new NubVoidType(); var returnType = TryExpectSymbol(Symbol.Colon) ? ParseType() : new NubVoidType();
functions.Add(new TraitFuncNode(GetTokensForNode(funcStartIndex), funcName, parameters, returnType)); functions.Add(new TraitFuncSyntax(GetTokens(funcStartIndex), funcName, parameters, returnType));
} }
return new TraitNode(GetTokensForNode(startIndex), _namespace, name, functions); return new TraitSyntax(GetTokens(startIndex), _namespace, name, functions);
} }
private TraitImplNode ParseImplementation(int startIndex) private TraitImplSyntax ParseImplementation(int startIndex)
{ {
var traitType = ParseType(); var traitType = ParseType();
ExpectSymbol(Symbol.For); ExpectSymbol(Symbol.For);
var forType = ParseType(); var forType = ParseType();
List<TraitFuncImplNode> functions = []; List<TraitFuncImplSyntax> functions = [];
ExpectSymbol(Symbol.OpenBrace); ExpectSymbol(Symbol.OpenBrace);
while (!TryExpectSymbol(Symbol.CloseBrace)) while (!TryExpectSymbol(Symbol.CloseBrace))
@@ -223,7 +223,7 @@ public sealed class Parser
var funcStartIndex = _tokenIndex; var funcStartIndex = _tokenIndex;
ExpectSymbol(Symbol.Func); ExpectSymbol(Symbol.Func);
var functionName = ExpectIdentifier().Value; var functionName = ExpectIdentifier().Value;
var parameters = new List<FuncParameterNode> var parameters = new List<FuncParameterSyntax>
{ {
new([], "this", forType) new([], "this", forType)
}; };
@@ -248,23 +248,23 @@ public sealed class Parser
var body = ParseBlock(); var body = ParseBlock();
functions.AddRange(new TraitFuncImplNode(GetTokensForNode(funcStartIndex), functionName, parameters, returnType, body)); functions.AddRange(new TraitFuncImplSyntax(GetTokens(funcStartIndex), functionName, parameters, returnType, body));
} }
return new TraitImplNode(GetTokensForNode(startIndex), _namespace, traitType, forType, functions); return new TraitImplSyntax(GetTokens(startIndex), _namespace, traitType, forType, functions);
} }
private FuncParameterNode ParseFuncParameter() private FuncParameterSyntax ParseFuncParameter()
{ {
var startIndex = _tokenIndex; var startIndex = _tokenIndex;
var name = ExpectIdentifier(); var name = ExpectIdentifier();
ExpectSymbol(Symbol.Colon); ExpectSymbol(Symbol.Colon);
var type = ParseType(); var type = ParseType();
return new FuncParameterNode(GetTokensForNode(startIndex), name.Value, type); return new FuncParameterSyntax(GetTokens(startIndex), name.Value, type);
} }
private StatementNode ParseStatement() private StatementSyntax ParseStatement()
{ {
var startIndex = _tokenIndex; var startIndex = _tokenIndex;
if (!Peek().TryGetValue(out var token)) if (!Peek().TryGetValue(out var token))
@@ -297,20 +297,20 @@ public sealed class Parser
return ParseStatementExpression(startIndex); return ParseStatementExpression(startIndex);
} }
private StatementNode ParseStatementExpression(int startIndex) private StatementSyntax ParseStatementExpression(int startIndex)
{ {
var expr = ParseExpression(); var expr = ParseExpression();
if (TryExpectSymbol(Symbol.Assign)) if (TryExpectSymbol(Symbol.Assign))
{ {
var value = ParseExpression(); var value = ParseExpression();
return new AssignmentNode(GetTokensForNode(startIndex), expr, value); return new AssignmentSyntax(GetTokens(startIndex), expr, value);
} }
return new StatementExpressionNode(GetTokensForNode(startIndex), expr); return new StatementExpressionSyntax(GetTokens(startIndex), expr);
} }
private VariableDeclarationNode ParseVariableDeclaration(int startIndex) private VariableDeclarationSyntax ParseVariableDeclaration(int startIndex)
{ {
ExpectSymbol(Symbol.Let); ExpectSymbol(Symbol.Let);
var name = ExpectIdentifier().Value; var name = ExpectIdentifier().Value;
@@ -321,68 +321,68 @@ public sealed class Parser
explicitType = ParseType(); explicitType = ParseType();
} }
var assignment = Optional<ExpressionNode>.Empty(); var assignment = Optional<ExpressionSyntax>.Empty();
if (TryExpectSymbol(Symbol.Assign)) if (TryExpectSymbol(Symbol.Assign))
{ {
assignment = ParseExpression(); assignment = ParseExpression();
} }
return new VariableDeclarationNode(GetTokensForNode(startIndex), name, explicitType, assignment); return new VariableDeclarationSyntax(GetTokens(startIndex), name, explicitType, assignment);
} }
private StatementNode ParseBreak(int startIndex) private StatementSyntax ParseBreak(int startIndex)
{ {
ExpectSymbol(Symbol.Break); ExpectSymbol(Symbol.Break);
Next(); Next();
return new BreakNode(GetTokensForNode(startIndex)); return new BreakSyntax(GetTokens(startIndex));
} }
private StatementNode ParseContinue(int startIndex) private StatementSyntax ParseContinue(int startIndex)
{ {
ExpectSymbol(Symbol.Continue); ExpectSymbol(Symbol.Continue);
return new ContinueNode(GetTokensForNode(startIndex)); return new ContinueSyntax(GetTokens(startIndex));
} }
private ReturnNode ParseReturn(int startIndex) private ReturnSyntax ParseReturn(int startIndex)
{ {
ExpectSymbol(Symbol.Return); ExpectSymbol(Symbol.Return);
var value = Optional<ExpressionNode>.Empty(); var value = Optional<ExpressionSyntax>.Empty();
if (_functionReturnType is not NubVoidType) if (_functionReturnType is not NubVoidType)
{ {
value = ParseExpression(); value = ParseExpression();
} }
return new ReturnNode(GetTokensForNode(startIndex), value); return new ReturnSyntax(GetTokens(startIndex), value);
} }
private IfNode ParseIf(int startIndex) private IfSyntax ParseIf(int startIndex)
{ {
ExpectSymbol(Symbol.If); ExpectSymbol(Symbol.If);
var condition = ParseExpression(); var condition = ParseExpression();
var body = ParseBlock(); var body = ParseBlock();
var elseStatement = Optional<Variant<IfNode, BlockNode>>.Empty(); var elseStatement = Optional<Variant<IfSyntax, BlockSyntax>>.Empty();
if (TryExpectSymbol(Symbol.Else)) if (TryExpectSymbol(Symbol.Else))
{ {
var newStartIndex = _tokenIndex; var newStartIndex = _tokenIndex;
elseStatement = TryExpectSymbol(Symbol.If) elseStatement = TryExpectSymbol(Symbol.If)
? (Variant<IfNode, BlockNode>)ParseIf(newStartIndex) ? (Variant<IfSyntax, BlockSyntax>)ParseIf(newStartIndex)
: (Variant<IfNode, BlockNode>)ParseBlock(); : (Variant<IfSyntax, BlockSyntax>)ParseBlock();
} }
return new IfNode(GetTokensForNode(startIndex), condition, body, elseStatement); return new IfSyntax(GetTokens(startIndex), condition, body, elseStatement);
} }
private WhileNode ParseWhile(int startIndex) private WhileSyntax ParseWhile(int startIndex)
{ {
ExpectSymbol(Symbol.While); ExpectSymbol(Symbol.While);
var condition = ParseExpression(); var condition = ParseExpression();
var body = ParseBlock(); var body = ParseBlock();
return new WhileNode(GetTokensForNode(startIndex), condition, body); return new WhileSyntax(GetTokens(startIndex), condition, body);
} }
private ExpressionNode ParseExpression(int precedence = 0) private ExpressionSyntax ParseExpression(int precedence = 0)
{ {
var startIndex = _tokenIndex; var startIndex = _tokenIndex;
var left = ParsePrimaryExpression(); var left = ParsePrimaryExpression();
@@ -399,63 +399,63 @@ public sealed class Parser
Next(); Next();
var right = ParseExpression(GetBinaryOperatorPrecedence(op.Value) + 1); var right = ParseExpression(GetBinaryOperatorPrecedence(op.Value) + 1);
left = new BinaryExpressionNode(GetTokensForNode(startIndex), left, op.Value, right); left = new BinaryExpressionSyntax(GetTokens(startIndex), left, op.Value, right);
} }
return left; return left;
} }
private int GetBinaryOperatorPrecedence(BinaryExpressionOperator binaryExpressionOperator) private int GetBinaryOperatorPrecedence(BinaryOperator @operator)
{ {
return binaryExpressionOperator switch return @operator switch
{ {
BinaryExpressionOperator.Multiply => 3, BinaryOperator.Multiply => 3,
BinaryExpressionOperator.Divide => 3, BinaryOperator.Divide => 3,
BinaryExpressionOperator.Plus => 2, BinaryOperator.Plus => 2,
BinaryExpressionOperator.Minus => 2, BinaryOperator.Minus => 2,
BinaryExpressionOperator.GreaterThan => 1, BinaryOperator.GreaterThan => 1,
BinaryExpressionOperator.GreaterThanOrEqual => 1, BinaryOperator.GreaterThanOrEqual => 1,
BinaryExpressionOperator.LessThan => 1, BinaryOperator.LessThan => 1,
BinaryExpressionOperator.LessThanOrEqual => 1, BinaryOperator.LessThanOrEqual => 1,
BinaryExpressionOperator.Equal => 0, BinaryOperator.Equal => 0,
BinaryExpressionOperator.NotEqual => 0, BinaryOperator.NotEqual => 0,
_ => throw new ArgumentOutOfRangeException(nameof(binaryExpressionOperator), binaryExpressionOperator, null) _ => throw new ArgumentOutOfRangeException(nameof(@operator), @operator, null)
}; };
} }
private bool TryGetBinaryOperator(Symbol symbol, [NotNullWhen(true)] out BinaryExpressionOperator? binaryExpressionOperator) private bool TryGetBinaryOperator(Symbol symbol, [NotNullWhen(true)] out BinaryOperator? binaryExpressionOperator)
{ {
switch (symbol) switch (symbol)
{ {
case Symbol.Equal: case Symbol.Equal:
binaryExpressionOperator = BinaryExpressionOperator.Equal; binaryExpressionOperator = BinaryOperator.Equal;
return true; return true;
case Symbol.NotEqual: case Symbol.NotEqual:
binaryExpressionOperator = BinaryExpressionOperator.NotEqual; binaryExpressionOperator = BinaryOperator.NotEqual;
return true; return true;
case Symbol.LessThan: case Symbol.LessThan:
binaryExpressionOperator = BinaryExpressionOperator.LessThan; binaryExpressionOperator = BinaryOperator.LessThan;
return true; return true;
case Symbol.LessThanOrEqual: case Symbol.LessThanOrEqual:
binaryExpressionOperator = BinaryExpressionOperator.LessThanOrEqual; binaryExpressionOperator = BinaryOperator.LessThanOrEqual;
return true; return true;
case Symbol.GreaterThan: case Symbol.GreaterThan:
binaryExpressionOperator = BinaryExpressionOperator.GreaterThan; binaryExpressionOperator = BinaryOperator.GreaterThan;
return true; return true;
case Symbol.GreaterThanOrEqual: case Symbol.GreaterThanOrEqual:
binaryExpressionOperator = BinaryExpressionOperator.GreaterThanOrEqual; binaryExpressionOperator = BinaryOperator.GreaterThanOrEqual;
return true; return true;
case Symbol.Plus: case Symbol.Plus:
binaryExpressionOperator = BinaryExpressionOperator.Plus; binaryExpressionOperator = BinaryOperator.Plus;
return true; return true;
case Symbol.Minus: case Symbol.Minus:
binaryExpressionOperator = BinaryExpressionOperator.Minus; binaryExpressionOperator = BinaryOperator.Minus;
return true; return true;
case Symbol.Star: case Symbol.Star:
binaryExpressionOperator = BinaryExpressionOperator.Multiply; binaryExpressionOperator = BinaryOperator.Multiply;
return true; return true;
case Symbol.ForwardSlash: case Symbol.ForwardSlash:
binaryExpressionOperator = BinaryExpressionOperator.Divide; binaryExpressionOperator = BinaryOperator.Divide;
return true; return true;
default: default:
binaryExpressionOperator = null; binaryExpressionOperator = null;
@@ -463,17 +463,17 @@ public sealed class Parser
} }
} }
private ExpressionNode ParsePrimaryExpression() private ExpressionSyntax ParsePrimaryExpression()
{ {
var startIndex = _tokenIndex; var startIndex = _tokenIndex;
ExpressionNode expr; ExpressionSyntax expr;
var token = ExpectToken(); var token = ExpectToken();
switch (token) switch (token)
{ {
case LiteralToken literal: case LiteralToken literal:
{ {
expr = new LiteralNode(GetTokensForNode(startIndex), literal.Value, literal.Kind); expr = new LiteralSyntax(GetTokens(startIndex), literal.Value, literal.Kind);
break; break;
} }
case IdentifierToken identifier: case IdentifierToken identifier:
@@ -486,7 +486,7 @@ public sealed class Parser
name = ExpectIdentifier().Value; name = ExpectIdentifier().Value;
} }
expr = new IdentifierNode(GetTokensForNode(startIndex), @namespace, name); expr = new IdentifierSyntax(GetTokens(startIndex), @namespace, name);
break; break;
} }
case SymbolToken symbolToken: case SymbolToken symbolToken:
@@ -495,7 +495,7 @@ public sealed class Parser
{ {
case Symbol.Func: case Symbol.Func:
{ {
List<FuncParameterNode> parameters = []; List<FuncParameterSyntax> parameters = [];
ExpectSymbol(Symbol.OpenParen); ExpectSymbol(Symbol.OpenParen);
while (!TryExpectSymbol(Symbol.CloseParen)) while (!TryExpectSymbol(Symbol.CloseParen))
{ {
@@ -515,7 +515,7 @@ public sealed class Parser
var body = ParseBlock(); var body = ParseBlock();
expr = new AnonymousFuncNode(GetTokensForNode(startIndex), parameters, body, returnType); expr = new AnonymousFuncSyntax(GetTokens(startIndex), parameters, body, returnType);
break; break;
} }
case Symbol.OpenParen: case Symbol.OpenParen:
@@ -528,13 +528,13 @@ public sealed class Parser
case Symbol.Minus: case Symbol.Minus:
{ {
var expression = ParsePrimaryExpression(); var expression = ParsePrimaryExpression();
expr = new UnaryExpressionNode(GetTokensForNode(startIndex), UnaryExpressionOperator.Negate, expression); expr = new UnaryExpressionSyntax(GetTokens(startIndex), UnaryOperator.Negate, expression);
break; break;
} }
case Symbol.Bang: case Symbol.Bang:
{ {
var expression = ParsePrimaryExpression(); var expression = ParsePrimaryExpression();
expr = new UnaryExpressionNode(GetTokensForNode(startIndex), UnaryExpressionOperator.Invert, expression); expr = new UnaryExpressionSyntax(GetTokens(startIndex), UnaryOperator.Invert, expression);
break; break;
} }
case Symbol.OpenBracket: case Symbol.OpenBracket:
@@ -542,13 +542,13 @@ public sealed class Parser
var capacity = ParseExpression(); var capacity = ParseExpression();
ExpectSymbol(Symbol.CloseBracket); ExpectSymbol(Symbol.CloseBracket);
var type = ParseType(); var type = ParseType();
expr = new ArrayInitializerNode(GetTokensForNode(startIndex), capacity, type); expr = new ArrayInitializerSyntax(GetTokens(startIndex), capacity, type);
break; break;
} }
case Symbol.Alloc: case Symbol.Alloc:
{ {
var type = ParseType(); var type = ParseType();
Dictionary<string, ExpressionNode> initializers = []; Dictionary<string, ExpressionSyntax> initializers = [];
ExpectSymbol(Symbol.OpenBrace); ExpectSymbol(Symbol.OpenBrace);
while (!TryExpectSymbol(Symbol.CloseBrace)) while (!TryExpectSymbol(Symbol.CloseBrace))
{ {
@@ -558,7 +558,7 @@ public sealed class Parser
initializers.Add(name, value); initializers.Add(name, value);
} }
expr = new StructInitializerNode(GetTokensForNode(startIndex), type, initializers); expr = new StructInitializerSyntax(GetTokens(startIndex), type, initializers);
break; break;
} }
default: default:
@@ -586,26 +586,26 @@ public sealed class Parser
return ParsePostfixOperators(startIndex, expr); return ParsePostfixOperators(startIndex, expr);
} }
private ExpressionNode ParsePostfixOperators(int startIndex, ExpressionNode expr) private ExpressionSyntax ParsePostfixOperators(int startIndex, ExpressionSyntax expr)
{ {
while (true) while (true)
{ {
if (TryExpectSymbol(Symbol.Ampersand)) if (TryExpectSymbol(Symbol.Ampersand))
{ {
expr = new AddressOfNode(GetTokensForNode(startIndex), expr); expr = new AddressOfSyntax(GetTokens(startIndex), expr);
break; break;
} }
if (TryExpectSymbol(Symbol.Caret)) if (TryExpectSymbol(Symbol.Caret))
{ {
expr = new DereferenceNode(GetTokensForNode(startIndex), expr); expr = new DereferenceSyntax(GetTokens(startIndex), expr);
continue; continue;
} }
if (TryExpectSymbol(Symbol.Period)) if (TryExpectSymbol(Symbol.Period))
{ {
var structMember = ExpectIdentifier().Value; var structMember = ExpectIdentifier().Value;
expr = new MemberAccessNode(GetTokensForNode(startIndex), expr, structMember); expr = new MemberAccessSyntax(GetTokens(startIndex), expr, structMember);
continue; continue;
} }
@@ -613,13 +613,13 @@ public sealed class Parser
{ {
var index = ParseExpression(); var index = ParseExpression();
ExpectSymbol(Symbol.CloseBracket); ExpectSymbol(Symbol.CloseBracket);
expr = new ArrayIndexAccessNode(GetTokensForNode(startIndex), expr, index); expr = new ArrayIndexAccessSyntax(GetTokens(startIndex), expr, index);
continue; continue;
} }
if (TryExpectSymbol(Symbol.OpenParen)) if (TryExpectSymbol(Symbol.OpenParen))
{ {
var parameters = new List<ExpressionNode>(); var parameters = new List<ExpressionSyntax>();
while (!TryExpectSymbol(Symbol.CloseParen)) while (!TryExpectSymbol(Symbol.CloseParen))
{ {
parameters.Add(ParseExpression()); parameters.Add(ParseExpression());
@@ -633,7 +633,7 @@ public sealed class Parser
} }
} }
expr = new FuncCallNode(GetTokensForNode(startIndex), expr, parameters); expr = new FuncCallSyntax(GetTokens(startIndex), expr, parameters);
continue; continue;
} }
@@ -643,11 +643,11 @@ public sealed class Parser
return expr; return expr;
} }
private BlockNode ParseBlock() private BlockSyntax ParseBlock()
{ {
var startIndex = _tokenIndex; var startIndex = _tokenIndex;
ExpectSymbol(Symbol.OpenBrace); ExpectSymbol(Symbol.OpenBrace);
List<StatementNode> statements = []; List<StatementSyntax> statements = [];
while (Peek().HasValue && !TryExpectSymbol(Symbol.CloseBrace)) while (Peek().HasValue && !TryExpectSymbol(Symbol.CloseBrace))
{ {
try try
@@ -661,7 +661,7 @@ public sealed class Parser
} }
} }
return new BlockNode(GetTokensForNode(startIndex), statements); return new BlockSyntax(GetTokens(startIndex), statements);
} }
private NubType ParseType() private NubType ParseType()
@@ -892,7 +892,7 @@ public sealed class Parser
_tokenIndex++; _tokenIndex++;
} }
private IEnumerable<Token> GetTokensForNode(int startIndex) private IEnumerable<Token> GetTokens(int startIndex)
{ {
return _tokens.Skip(startIndex).Take(Math.Min(_tokenIndex, _tokens.Count() - 1) - startIndex); return _tokens.Skip(startIndex).Take(Math.Min(_tokenIndex, _tokens.Count() - 1) - startIndex);
} }