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

Node -> none

Browse Source
This commit is contained in:
nub31
2025-07-06 23:11:53 +02:00
parent eb13b94fa5
commit 28bd71b8bf
12 changed files with 283 additions and 283 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -3,7 +3,7 @@ using CLI;
using NubLang;
using NubLang.Diagnostics;
using NubLang.Generation.QBE;
using NubLang.Syntax.Node;
using NubLang.Syntax.Binding.Node;
using NubLang.Syntax.Parsing;
using NubLang.Syntax.Parsing.Node;
using NubLang.Syntax.Tokenization;

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

@@ -1,4 +1,4 @@
using NubLang.Syntax.Node;
using NubLang.Syntax.Binding.Node;
using NubLang.Syntax.Parsing.Node;
namespace NubLang;
@@ -62,74 +62,74 @@ public sealed class DefinitionTable
public sealed class BoundDefinitionTable
{
private readonly List<BoundDefinitionNode> _definitions;
private readonly List<BoundDefinition> _definitions;
public BoundDefinitionTable(IEnumerable<BoundSyntaxTree> syntaxTrees)
{
_definitions = syntaxTrees.SelectMany(x => x.Definitions).ToList();
}
public BoundLocalFuncNode LookupLocalFunc(string @namespace, string name)
public BoundLocalFunc LookupLocalFunc(string @namespace, string name)
{
return _definitions
.OfType<BoundLocalFuncNode>()
.OfType<BoundLocalFunc>()
.First(x => x.Namespace == @namespace && x.Name == name);
}
public BoundExternFuncNode LookupExternFunc(string @namespace, string name)
public BoundExternFunc LookupExternFunc(string @namespace, string name)
{
return _definitions
.OfType<BoundExternFuncNode>()
.OfType<BoundExternFunc>()
.First(x => x.Namespace == @namespace && x.Name == name);
}
public BoundStructNode LookupStruct(string @namespace, string name)
public BoundStruct LookupStruct(string @namespace, string name)
{
return _definitions
.OfType<BoundStructNode>()
.OfType<BoundStruct>()
.First(x => x.Namespace == @namespace && x.Name == name);
}
public BoundStructFieldNode LookupStructField(BoundStructNode structNode, string field)
public BoundStructField LookupStructField(BoundStruct @struct, string field)
{
return structNode.Fields.First(x => x.Name == field);
return @struct.Fields.First(x => x.Name == field);
}
public IEnumerable<BoundTraitImplNode> LookupTraitImpls(NubType itemType)
public IEnumerable<BoundTraitImpl> LookupTraitImpls(NubType itemType)
{
return _definitions
.OfType<BoundTraitImplNode>()
.OfType<BoundTraitImpl>()
.Where(x => x.ForType == itemType);
}
public BoundTraitFuncImplNode LookupTraitFuncImpl(NubType forType, string name)
public BoundTraitFuncImpl LookupTraitFuncImpl(NubType forType, string name)
{
return _definitions
.OfType<BoundTraitImplNode>()
.OfType<BoundTraitImpl>()
.Where(x => x.ForType == forType)
.SelectMany(x => x.Functions)
.First(x => x.Name == name);
}
public BoundTraitNode LookupTrait(string @namespace, string name)
public BoundTrait LookupTrait(string @namespace, string name)
{
return _definitions
.OfType<BoundTraitNode>()
.OfType<BoundTrait>()
.First(x => x.Namespace == @namespace && x.Name == name);
}
public BoundTraitFuncNode LookupTraitFunc(BoundTraitNode trait, string name)
public BoundTraitFunc LookupTraitFunc(BoundTrait trait, string name)
{
return trait.Functions.First(x => x.Name == name);
}
public IEnumerable<BoundStructNode> GetStructs()
public IEnumerable<BoundStruct> GetStructs()
{
return _definitions.OfType<BoundStructNode>();
return _definitions.OfType<BoundStruct>();
}
public IEnumerable<BoundTraitNode> GetTraits()
public IEnumerable<BoundTrait> GetTraits()
{
return _definitions.OfType<BoundTraitNode>();
return _definitions.OfType<BoundTrait>();
}
}

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

@@ -2,7 +2,7 @@
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Text;
using NubLang.Syntax.Node;
using NubLang.Syntax.Binding.Node;
using NubLang.Syntax.Tokenization;
namespace NubLang.Generation.QBE;
@@ -17,8 +17,8 @@ public static class QBEGenerator
private static List<StringLiteral> _stringLiterals = [];
private static Stack<string> _breakLabels = [];
private static Stack<string> _continueLabels = [];
private static Queue<(BoundAnonymousFuncNode Func, string Name)> _anonymousFunctions = [];
private static Dictionary<BoundTraitFuncImplNode, string> _implFunctions = [];
private static Queue<(BoundAnonymousFunc Func, string Name)> _anonymousFunctions = [];
private static Dictionary<BoundTraitFuncImpl, string> _implFunctions = [];
private static Stack<Variable> _variables = [];
private static Stack<int> _variableScopes = [];
private static int _tmpIndex;
@@ -64,7 +64,7 @@ public static class QBEGenerator
_writer.NewLine();
}
foreach (var funcDef in _syntaxTree.Definitions.OfType<BoundLocalFuncNode>())
foreach (var funcDef in _syntaxTree.Definitions.OfType<BoundLocalFunc>())
{
EmitFuncDefinition(funcDef, LocalFuncName(funcDef), funcDef.Parameters, funcDef.ReturnType, funcDef.Body, funcDef.Exported);
_writer.NewLine();
@@ -116,12 +116,12 @@ public static class QBEGenerator
return $"$string{++_stringLiteralIndex}";
}
private static string LocalFuncName(BoundLocalFuncNode funcDef)
private static string LocalFuncName(BoundLocalFunc funcDef)
{
return funcDef.Exported ? $"${funcDef.Name}" : $"${funcDef.Namespace}_{funcDef.Name}";
}
private static string ExternFuncName(BoundExternFuncNode funcDef)
private static string ExternFuncName(BoundExternFunc funcDef)
{
return $"${funcDef.CallName}";
}
@@ -227,23 +227,23 @@ public static class QBEGenerator
return size;
}
private static bool EmitTryMoveInto(BoundExpressionNode source, string destinationPointer)
private static bool EmitTryMoveInto(BoundExpression source, string destinationPointer)
{
switch (source)
{
case BoundArrayInitializerNode arrayInitializer:
case BoundArrayInitializer arrayInitializer:
{
_writer.WriteDebugLocation(arrayInitializer);
EmitStore(source.Type, EmitUnwrap(EmitArrayInitializer(arrayInitializer)), destinationPointer);
return true;
}
case BoundStructInitializerNode structInitializer:
case BoundStructInitializer structInitializer:
{
_writer.WriteDebugLocation(structInitializer);
EmitStructInitializer(structInitializer, destinationPointer);
return true;
}
case BoundLiteralNode { Kind: LiteralKind.String } literal:
case BoundLiteral { Kind: LiteralKind.String } literal:
{
_writer.WriteDebugLocation(literal);
EmitStore(source.Type, EmitUnwrap(EmitLiteral(literal)), destinationPointer);
@@ -254,7 +254,7 @@ public static class QBEGenerator
return false;
}
private static void EmitCopyIntoOrInitialize(BoundExpressionNode source, string destinationPointer)
private static void EmitCopyIntoOrInitialize(BoundExpression source, string destinationPointer)
{
// If the source is a value which is not used yet such as an array/struct initializer or literal, we can skip copying
if (EmitTryMoveInto(source, destinationPointer))
@@ -292,13 +292,13 @@ public static class QBEGenerator
}
}
private static bool EmitTryCreateWithoutCopy(BoundExpressionNode source, [NotNullWhen(true)] out string? destination)
private static bool EmitTryCreateWithoutCopy(BoundExpression source, [NotNullWhen(true)] out string? destination)
{
switch (source)
{
case BoundArrayInitializerNode:
case BoundStructInitializerNode:
case BoundLiteralNode { Kind: LiteralKind.String }:
case BoundArrayInitializer:
case BoundStructInitializer:
case BoundLiteral { Kind: LiteralKind.String }:
{
destination = EmitUnwrap(EmitExpression(source));
return true;
@@ -309,7 +309,7 @@ public static class QBEGenerator
return false;
}
private static string EmitCreateCopyOrInitialize(BoundExpressionNode source)
private static string EmitCreateCopyOrInitialize(BoundExpression source)
{
// If the source is a value which is not used yet such as an array/struct initializer or literal, we can skip copying
if (EmitTryCreateWithoutCopy(source, out var uncopiedValue))
@@ -391,7 +391,7 @@ public static class QBEGenerator
return "l";
}
private static void EmitFuncDefinition(BoundNode debugNode, string name, List<BoundFuncParameterNode> parameters, NubType returnType, BoundBlock body, bool exported)
private static void EmitFuncDefinition(BoundNode debugNode, string name, List<BoundFuncParameter> parameters, NubType returnType, BoundBlock body, bool exported)
{
_variables.Clear();
_variableScopes.Clear();
@@ -424,7 +424,7 @@ public static class QBEGenerator
EmitBlock(body, parameterVars);
if (body.Statements.LastOrDefault() is not BoundReturnNode)
if (body.Statements.LastOrDefault() is not BoundReturn)
{
if (returnType is NubVoidType)
{
@@ -435,7 +435,7 @@ public static class QBEGenerator
_writer.EndFunction();
}
private static void EmitStructDefinition(BoundStructNode structDef)
private static void EmitStructDefinition(BoundStruct structDef)
{
_writer.WriteLine($"type {CustomTypeName(structDef.Namespace, structDef.Name)} = {{ ");
@@ -456,7 +456,7 @@ public static class QBEGenerator
_writer.WriteLine("}");
return;
string StructDefQBEType(BoundStructFieldNode field)
string StructDefQBEType(BoundStructField field)
{
if (field.Type.IsSimpleType(out var simpleType, out var complexType))
{
@@ -481,7 +481,7 @@ public static class QBEGenerator
}
}
private static void EmitTraitVTable(BoundTraitNode traitDef)
private static void EmitTraitVTable(BoundTrait traitDef)
{
_writer.WriteLine($"type {CustomTypeName(traitDef.Namespace, traitDef.Name)} = {{");
@@ -493,34 +493,34 @@ public static class QBEGenerator
_writer.WriteLine("}");
}
private static void EmitStatement(BoundStatementNode statement)
private static void EmitStatement(BoundStatement statement)
{
_writer.WriteDebugLocation(statement);
switch (statement)
{
case BoundAssignmentNode assignment:
case BoundAssignment assignment:
EmitAssignment(assignment);
break;
case BoundBreakNode:
case BoundBreak:
EmitBreak();
break;
case BoundContinueNode:
case BoundContinue:
EmitContinue();
break;
case BoundIfNode ifStatement:
case BoundIf ifStatement:
EmitIf(ifStatement);
break;
case BoundReturnNode @return:
case BoundReturn @return:
EmitReturn(@return);
break;
case BoundStatementExpressionNode statementExpression:
case BoundStatementExpression statementExpression:
EmitExpression(statementExpression.Expression);
break;
case BoundVariableDeclarationNode variableDeclaration:
case BoundVariableDeclaration variableDeclaration:
EmitVariableDeclaration(variableDeclaration);
break;
case BoundWhileNode whileStatement:
case BoundWhile whileStatement:
EmitWhile(whileStatement);
break;
default:
@@ -528,7 +528,7 @@ public static class QBEGenerator
}
}
private static void EmitAssignment(BoundAssignmentNode assignment)
private static void EmitAssignment(BoundAssignment assignment)
{
var destination = EmitExpression(assignment.Target);
Debug.Assert(destination.Kind == ValKind.Pointer);
@@ -572,7 +572,7 @@ public static class QBEGenerator
_codeIsReachable = false;
}
private static void EmitIf(BoundIfNode ifStatement)
private static void EmitIf(BoundIf ifStatement)
{
var trueLabel = LabelName();
var falseLabel = LabelName();
@@ -596,7 +596,7 @@ public static class QBEGenerator
_writer.WriteLine(endLabel);
}
private static void EmitReturn(BoundReturnNode @return)
private static void EmitReturn(BoundReturn @return)
{
if (@return.Value.HasValue)
{
@@ -609,7 +609,7 @@ public static class QBEGenerator
}
}
private static void EmitVariableDeclaration(BoundVariableDeclarationNode variableDeclaration)
private static void EmitVariableDeclaration(BoundVariableDeclaration variableDeclaration)
{
var name = $"%{variableDeclaration.Name}";
_writer.Indented($"{name} =l alloc8 8");
@@ -623,7 +623,7 @@ public static class QBEGenerator
_variables.Push(new Variable(variableDeclaration.Name, new Val(name, variableDeclaration.Type, ValKind.Pointer)));
}
private static void EmitWhile(BoundWhileNode whileStatement)
private static void EmitWhile(BoundWhile whileStatement)
{
var conditionLabel = LabelName();
var iterationLabel = LabelName();
@@ -644,39 +644,39 @@ public static class QBEGenerator
_breakLabels.Pop();
}
private static Val EmitExpression(BoundExpressionNode expression)
private static Val EmitExpression(BoundExpression expression)
{
_writer.WriteDebugLocation(expression);
return expression switch
{
BoundArrayInitializerNode arrayInitializer => EmitArrayInitializer(arrayInitializer),
BoundStructInitializerNode structInitializer => EmitStructInitializer(structInitializer),
BoundAddressOfNode addressOf => EmitAddressOf(addressOf),
BoundDereferenceNode dereference => EmitDereference(dereference),
BoundAnonymousFuncNode anonymousFunc => EmitAnonymousFunc(anonymousFunc),
BoundBinaryExpressionNode binaryExpression => EmitBinaryExpression(binaryExpression),
BoundFuncCallNode funcCallExpression => EmitFuncCall(funcCallExpression),
BoundExternFuncIdentNode externFuncIdent => EmitExternFuncIdent(externFuncIdent),
BoundLocalFuncIdentNode localFuncIdent => EmitLocalFuncIdent(localFuncIdent),
BoundVariableIdentNode variableIdent => EmitVariableIdent(variableIdent),
BoundLiteralNode literal => EmitLiteral(literal),
BoundUnaryExpressionNode unaryExpression => EmitUnaryExpression(unaryExpression),
BoundStructFieldAccessNode structFieldAccess => EmitStructFieldAccess(structFieldAccess),
BoundTraitFuncAccessNode traitFuncAccess => EmitTraitFuncAccess(traitFuncAccess),
BoundTraitImplFuncAccessNode traitImplFuncAccess => EmitTraitImplFuncAccess(traitImplFuncAccess),
BoundArrayIndexAccessNode arrayIndex => EmitArrayIndexAccess(arrayIndex),
BoundArrayInitializer arrayInitializer => EmitArrayInitializer(arrayInitializer),
BoundStructInitializer structInitializer => EmitStructInitializer(structInitializer),
BoundAddressOf addressOf => EmitAddressOf(addressOf),
BoundDereference dereference => EmitDereference(dereference),
BoundAnonymousFunc anonymousFunc => EmitAnonymousFunc(anonymousFunc),
BoundBinaryExpression binaryExpression => EmitBinaryExpression(binaryExpression),
BoundFuncCall funcCallExpression => EmitFuncCall(funcCallExpression),
BoundExternFuncIdent externFuncIdent => EmitExternFuncIdent(externFuncIdent),
BoundLocalFuncIdent localFuncIdent => EmitLocalFuncIdent(localFuncIdent),
BoundVariableIdent variableIdent => EmitVariableIdent(variableIdent),
BoundLiteral literal => EmitLiteral(literal),
BoundUnaryExpression unaryExpression => EmitUnaryExpression(unaryExpression),
BoundStructFieldAccess structFieldAccess => EmitStructFieldAccess(structFieldAccess),
BoundTraitFuncAccess traitFuncAccess => EmitTraitFuncAccess(traitFuncAccess),
BoundTraitImplFuncAccess traitImplFuncAccess => EmitTraitImplFuncAccess(traitImplFuncAccess),
BoundArrayIndexAccess arrayIndex => EmitArrayIndexAccess(arrayIndex),
_ => throw new ArgumentOutOfRangeException(nameof(expression))
};
}
private static Val EmitAnonymousFunc(BoundAnonymousFuncNode anonymousFunc)
private static Val EmitAnonymousFunc(BoundAnonymousFunc anonymousFunc)
{
var name = $"$anon_func{++_anonymousFuncIndex}";
_anonymousFunctions.Enqueue((anonymousFunc, name));
return new Val(name, anonymousFunc.Type, ValKind.Direct);
}
private static Val EmitArrayIndexAccess(BoundArrayIndexAccessNode arrayIndexAccess)
private static Val EmitArrayIndexAccess(BoundArrayIndexAccess arrayIndexAccess)
{
var array = EmitUnwrap(EmitExpression(arrayIndexAccess.Target));
var index = EmitUnwrap(EmitExpression(arrayIndexAccess.Index));
@@ -716,7 +716,7 @@ public static class QBEGenerator
_writer.Indented(notOobLabel);
}
private static Val EmitArrayInitializer(BoundArrayInitializerNode arrayInitializer)
private static Val EmitArrayInitializer(BoundArrayInitializer arrayInitializer)
{
var capacity = EmitUnwrap(EmitExpression(arrayInitializer.Capacity));
var elementSize = arrayInitializer.ElementType.Size(_definitionTable);
@@ -737,12 +737,12 @@ public static class QBEGenerator
return new Val(arrayPointer, arrayInitializer.Type, ValKind.Direct);
}
private static Val EmitDereference(BoundDereferenceNode dereference)
private static Val EmitDereference(BoundDereference dereference)
{
return EmitLoad(dereference.Type, EmitUnwrap(EmitExpression(dereference.Expression)));
}
private static Val EmitAddressOf(BoundAddressOfNode addressOf)
private static Val EmitAddressOf(BoundAddressOf addressOf)
{
var value = EmitExpression(addressOf.Expression);
if (value.Kind != ValKind.Pointer)
@@ -753,7 +753,7 @@ public static class QBEGenerator
return new Val(value.Name, addressOf.Type, ValKind.Direct);
}
private static Val EmitBinaryExpression(BoundBinaryExpressionNode binaryExpression)
private static Val EmitBinaryExpression(BoundBinaryExpression binaryExpression)
{
var left = EmitUnwrap(EmitExpression(binaryExpression.Left));
var right = EmitUnwrap(EmitExpression(binaryExpression.Right));
@@ -860,24 +860,24 @@ public static class QBEGenerator
};
}
private static Val EmitExternFuncIdent(BoundExternFuncIdentNode externFuncIdent)
private static Val EmitExternFuncIdent(BoundExternFuncIdent externFuncIdent)
{
var func = _definitionTable.LookupExternFunc(externFuncIdent.Namespace, externFuncIdent.Name);
return new Val(ExternFuncName(func), externFuncIdent.Type, ValKind.Direct);
}
private static Val EmitLocalFuncIdent(BoundLocalFuncIdentNode localFuncIdent)
private static Val EmitLocalFuncIdent(BoundLocalFuncIdent localFuncIdent)
{
var func = _definitionTable.LookupExternFunc(localFuncIdent.Namespace, localFuncIdent.Name);
return new Val(ExternFuncName(func), localFuncIdent.Type, ValKind.Direct);
}
private static Val EmitVariableIdent(BoundVariableIdentNode variableIdent)
private static Val EmitVariableIdent(BoundVariableIdent variableIdent)
{
return _variables.Single(v => v.Name == variableIdent.Name).Val;
}
private static Val EmitLiteral(BoundLiteralNode literal)
private static Val EmitLiteral(BoundLiteral literal)
{
switch (literal.Kind)
{
@@ -959,7 +959,7 @@ public static class QBEGenerator
throw new NotSupportedException($"Cannot create literal of kind '{literal.Kind}' for type {literal.Type}");
}
private static Val EmitStructInitializer(BoundStructInitializerNode structInitializer, string? destination = null)
private static Val EmitStructInitializer(BoundStructInitializer structInitializer, string? destination = null)
{
var @struct = _definitionTable.LookupStruct(structInitializer.StructType.Namespace, structInitializer.StructType.Name);
@@ -987,7 +987,7 @@ public static class QBEGenerator
return new Val(destination, structInitializer.StructType, ValKind.Direct);
}
private static Val EmitUnaryExpression(BoundUnaryExpressionNode unaryExpression)
private static Val EmitUnaryExpression(BoundUnaryExpression unaryExpression)
{
var operand = EmitUnwrap(EmitExpression(unaryExpression.Operand));
var outputName = TmpName();
@@ -1034,7 +1034,7 @@ public static class QBEGenerator
throw new NotSupportedException($"Unary operator {unaryExpression.Operator} for type {unaryExpression.Operand.Type} not supported");
}
private static Val EmitStructFieldAccess(BoundStructFieldAccessNode structFieldAccess)
private static Val EmitStructFieldAccess(BoundStructFieldAccess structFieldAccess)
{
var target = EmitUnwrap(EmitExpression(structFieldAccess.Target));
@@ -1053,12 +1053,12 @@ public static class QBEGenerator
return new Val(output, structFieldAccess.Type, ValKind.Pointer);
}
private static Val EmitTraitFuncAccess(BoundTraitFuncAccessNode traitFuncAccess)
private static Val EmitTraitFuncAccess(BoundTraitFuncAccess traitFuncAccess)
{
throw new NotImplementedException();
}
private static Val EmitTraitImplFuncAccess(BoundTraitImplFuncAccessNode traitImplFuncAccess)
private static Val EmitTraitImplFuncAccess(BoundTraitImplFuncAccess traitImplFuncAccess)
{
var target = EmitExpression(traitImplFuncAccess.Target);
@@ -1069,7 +1069,7 @@ public static class QBEGenerator
return new Val(name, traitImplFuncAccess.Type, ValKind.Direct, new MethodCallContext(target));
}
private static Val EmitFuncCall(BoundFuncCallNode funcCall)
private static Val EmitFuncCall(BoundFuncCall funcCall)
{
var expression = EmitExpression(funcCall.Expression);
var funcPointer = EmitUnwrap(expression);
@@ -1111,7 +1111,7 @@ public static class QBEGenerator
};
}
private static int OffsetOf(BoundStructNode structDefinition, string member)
private static int OffsetOf(BoundStruct structDefinition, string member)
{
var offset = 0;

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

@@ -1,5 +1,5 @@
using System.Text;
using NubLang.Syntax.Node;
using NubLang.Syntax.Binding.Node;
namespace NubLang.Generation.QBE;

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

@@ -1,6 +1,6 @@
using Common;
using NubLang.Diagnostics;
using NubLang.Syntax.Node;
using NubLang.Syntax.Binding.Node;
using NubLang.Syntax.Parsing.Node;
using NubLang.Syntax.Tokenization;
@@ -28,7 +28,7 @@ public sealed class Binder
_functionReturnType = null;
var diagnostics = new List<Diagnostic>();
var definitions = new List<BoundDefinitionNode>();
var definitions = new List<BoundDefinition>();
foreach (var definition in _syntaxTree.Definitions)
{
@@ -45,7 +45,7 @@ public sealed class Binder
return new BoundSyntaxTree(_syntaxTree.Namespace, definitions, diagnostics);
}
private BoundDefinitionNode BindTopLevel(DefinitionSyntax node)
private BoundDefinition BindTopLevel(DefinitionSyntax node)
{
return node switch
{
@@ -58,98 +58,98 @@ public sealed class Binder
};
}
private BoundTraitImplNode BindTraitImplementation(TraitImplSyntax node)
private BoundTraitImpl BindTraitImplementation(TraitImplSyntax node)
{
_variables.Clear();
var functions = new List<BoundTraitFuncImplNode>();
var functions = new List<BoundTraitFuncImpl>();
foreach (var function in node.Functions)
{
var parameters = new List<BoundFuncParameterNode>();
var parameters = new List<BoundFuncParameter>();
foreach (var parameter in function.Parameters)
{
_variables[parameter.Name] = parameter.Type;
parameters.Add(new BoundFuncParameterNode(parameter.Tokens, parameter.Name, parameter.Type));
parameters.Add(new BoundFuncParameter(parameter.Tokens, parameter.Name, parameter.Type));
}
functions.Add(new BoundTraitFuncImplNode(function.Tokens, function.Name, parameters, function.ReturnType, BindBlock(function.Body)));
functions.Add(new BoundTraitFuncImpl(function.Tokens, function.Name, parameters, function.ReturnType, BindBlock(function.Body)));
}
return new BoundTraitImplNode(node.Tokens, node.Namespace, node.TraitType, node.ForType, functions);
return new BoundTraitImpl(node.Tokens, node.Namespace, node.TraitType, node.ForType, functions);
}
private BoundTraitNode BindTraitDefinition(TraitSyntax node)
private BoundTrait BindTraitDefinition(TraitSyntax node)
{
var functions = new List<BoundTraitFuncNode>();
var functions = new List<BoundTraitFunc>();
foreach (var function in node.Functions)
{
var parameters = new List<BoundFuncParameterNode>();
var parameters = new List<BoundFuncParameter>();
foreach (var parameter in function.Parameters)
{
parameters.Add(new BoundFuncParameterNode(parameter.Tokens, parameter.Name, parameter.Type));
parameters.Add(new BoundFuncParameter(parameter.Tokens, parameter.Name, parameter.Type));
}
functions.Add(new BoundTraitFuncNode(node.Tokens, function.Name, parameters, function.ReturnType));
functions.Add(new BoundTraitFunc(node.Tokens, function.Name, parameters, function.ReturnType));
}
return new BoundTraitNode(node.Tokens, node.Namespace, node.Name, functions);
return new BoundTrait(node.Tokens, node.Namespace, node.Name, functions);
}
private BoundStructNode BindStruct(StructSyntax node)
private BoundStruct BindStruct(StructSyntax node)
{
var structFields = new List<BoundStructFieldNode>();
var structFields = new List<BoundStructField>();
foreach (var field in node.Fields)
{
var value = Optional.Empty<BoundExpressionNode>();
var value = Optional.Empty<BoundExpression>();
if (field.Value.HasValue)
{
value = BindExpression(field.Value.Value, field.Type);
}
structFields.Add(new BoundStructFieldNode(field.Tokens, field.Index, field.Name, field.Type, value));
structFields.Add(new BoundStructField(field.Tokens, field.Index, field.Name, field.Type, value));
}
return new BoundStructNode(node.Tokens, node.Namespace, node.Name, structFields);
return new BoundStruct(node.Tokens, node.Namespace, node.Name, structFields);
}
private BoundExternFuncNode BindExternFuncDefinition(ExternFuncSyntax node)
private BoundExternFunc BindExternFuncDefinition(ExternFuncSyntax node)
{
var parameters = new List<BoundFuncParameterNode>();
var parameters = new List<BoundFuncParameter>();
foreach (var parameter in node.Parameters)
{
parameters.Add(new BoundFuncParameterNode(parameter.Tokens, parameter.Name, parameter.Type));
parameters.Add(new BoundFuncParameter(parameter.Tokens, parameter.Name, parameter.Type));
}
return new BoundExternFuncNode(node.Tokens, node.Namespace, node.Name, node.CallName, parameters, node.ReturnType);
return new BoundExternFunc(node.Tokens, node.Namespace, node.Name, node.CallName, parameters, node.ReturnType);
}
private BoundLocalFuncNode BindLocalFuncDefinition(LocalFuncSyntax node)
private BoundLocalFunc BindLocalFuncDefinition(LocalFuncSyntax node)
{
_variables.Clear();
_functionReturnType = node.ReturnType;
var parameters = new List<BoundFuncParameterNode>();
var parameters = new List<BoundFuncParameter>();
foreach (var parameter in node.Parameters)
{
_variables[parameter.Name] = parameter.Type;
parameters.Add(new BoundFuncParameterNode(parameter.Tokens, parameter.Name, parameter.Type));
parameters.Add(new BoundFuncParameter(parameter.Tokens, parameter.Name, parameter.Type));
}
var body = BindBlock(node.Body);
return new BoundLocalFuncNode(node.Tokens, node.Namespace, node.Name, parameters, body, node.ReturnType, node.Exported);
return new BoundLocalFunc(node.Tokens, node.Namespace, node.Name, parameters, body, node.ReturnType, node.Exported);
}
private BoundBlock BindBlock(BlockSyntax node)
{
var statements = new List<BoundStatementNode>();
var statements = new List<BoundStatement>();
foreach (var statement in node.Statements)
{
@@ -159,7 +159,7 @@ public sealed class Binder
return new BoundBlock(node.Tokens, statements);
}
private BoundStatementNode BindStatement(StatementSyntax node)
private BoundStatement BindStatement(StatementSyntax node)
{
return node switch
{
@@ -175,57 +175,57 @@ public sealed class Binder
};
}
private BoundStatementNode BindAssignment(AssignmentSyntax statement)
private BoundStatement BindAssignment(AssignmentSyntax statement)
{
var expression = BindExpression(statement.Target);
var value = BindExpression(statement.Value, expression.Type);
return new BoundAssignmentNode(statement.Tokens, expression, value);
return new BoundAssignment(statement.Tokens, expression, value);
}
private BoundBreakNode BindBreak(BreakSyntax statement)
private BoundBreak BindBreak(BreakSyntax statement)
{
return new BoundBreakNode(statement.Tokens);
return new BoundBreak(statement.Tokens);
}
private BoundContinueNode BindContinue(ContinueSyntax statement)
private BoundContinue BindContinue(ContinueSyntax statement)
{
return new BoundContinueNode(statement.Tokens);
return new BoundContinue(statement.Tokens);
}
private BoundIfNode BindIf(IfSyntax statement)
private BoundIf BindIf(IfSyntax statement)
{
var elseStatement = Optional.Empty<Variant<BoundIfNode, BoundBlock>>();
var elseStatement = Optional.Empty<Variant<BoundIf, BoundBlock>>();
if (statement.Else.HasValue)
{
elseStatement = statement.Else.Value.Match<Variant<BoundIfNode, BoundBlock>>
elseStatement = statement.Else.Value.Match<Variant<BoundIf, BoundBlock>>
(
elseIf => BindIf(elseIf),
@else => BindBlock(@else)
);
}
return new BoundIfNode(statement.Tokens, BindExpression(statement.Condition, new NubPrimitiveType(PrimitiveTypeKind.Bool)), BindBlock(statement.Body), elseStatement);
return new BoundIf(statement.Tokens, BindExpression(statement.Condition, new NubPrimitiveType(PrimitiveTypeKind.Bool)), BindBlock(statement.Body), elseStatement);
}
private BoundReturnNode BindReturn(ReturnSyntax statement)
private BoundReturn BindReturn(ReturnSyntax statement)
{
var value = Optional.Empty<BoundExpressionNode>();
var value = Optional.Empty<BoundExpression>();
if (statement.Value.HasValue)
{
value = BindExpression(statement.Value.Value, _functionReturnType);
}
return new BoundReturnNode(statement.Tokens, value);
return new BoundReturn(statement.Tokens, value);
}
private BoundStatementExpressionNode BindStatementExpression(StatementExpressionSyntax statement)
private BoundStatementExpression BindStatementExpression(StatementExpressionSyntax statement)
{
return new BoundStatementExpressionNode(statement.Tokens, BindExpression(statement.Expression));
return new BoundStatementExpression(statement.Tokens, BindExpression(statement.Expression));
}
private BoundVariableDeclarationNode BindVariableDeclaration(VariableDeclarationSyntax statement)
private BoundVariableDeclaration BindVariableDeclaration(VariableDeclarationSyntax statement)
{
NubType? type = null;
@@ -234,7 +234,7 @@ public sealed class Binder
type = statement.ExplicitType.Value;
}
var assignment = Optional<BoundExpressionNode>.Empty();
var assignment = Optional<BoundExpression>.Empty();
if (statement.Assignment.HasValue)
{
var boundValue = BindExpression(statement.Assignment.Value, type);
@@ -249,15 +249,15 @@ public sealed class Binder
_variables[statement.Name] = type;
return new BoundVariableDeclarationNode(statement.Tokens, statement.Name, assignment, type);
return new BoundVariableDeclaration(statement.Tokens, statement.Name, assignment, type);
}
private BoundWhileNode BindWhile(WhileSyntax statement)
private BoundWhile BindWhile(WhileSyntax statement)
{
return new BoundWhileNode(statement.Tokens, BindExpression(statement.Condition, new NubPrimitiveType(PrimitiveTypeKind.Bool)), BindBlock(statement.Body));
return new BoundWhile(statement.Tokens, BindExpression(statement.Condition, new NubPrimitiveType(PrimitiveTypeKind.Bool)), BindBlock(statement.Body));
}
private BoundExpressionNode BindExpression(ExpressionSyntax node, NubType? expectedType = null)
private BoundExpression BindExpression(ExpressionSyntax node, NubType? expectedType = null)
{
return node switch
{
@@ -277,59 +277,59 @@ public sealed class Binder
};
}
private BoundAddressOfNode BindAddressOf(AddressOfSyntax expression)
private BoundAddressOf BindAddressOf(AddressOfSyntax expression)
{
var inner = BindExpression(expression.Expression);
return new BoundAddressOfNode(expression.Tokens, new NubPointerType(inner.Type), inner);
return new BoundAddressOf(expression.Tokens, new NubPointerType(inner.Type), inner);
}
private BoundAnonymousFuncNode BindAnonymousFunc(AnonymousFuncSyntax expression)
private BoundAnonymousFunc BindAnonymousFunc(AnonymousFuncSyntax expression)
{
var parameters = new List<BoundFuncParameterNode>();
var parameters = new List<BoundFuncParameter>();
foreach (var parameter in expression.Parameters)
{
parameters.Add(new BoundFuncParameterNode(parameter.Tokens, parameter.Name, parameter.Type));
parameters.Add(new BoundFuncParameter(parameter.Tokens, parameter.Name, parameter.Type));
}
var body = BindBlock(expression.Body);
return new BoundAnonymousFuncNode(expression.Tokens, new NubFuncType(expression.ReturnType, parameters.Select(x => x.Type).ToList()), parameters, body, expression.ReturnType);
return new BoundAnonymousFunc(expression.Tokens, new NubFuncType(expression.ReturnType, parameters.Select(x => x.Type).ToList()), parameters, body, expression.ReturnType);
}
private BoundArrayIndexAccessNode BindArrayIndexAccess(ArrayIndexAccessSyntax expression)
private BoundArrayIndexAccess BindArrayIndexAccess(ArrayIndexAccessSyntax expression)
{
var boundArray = BindExpression(expression.Target);
var elementType = ((NubArrayType)boundArray.Type).ElementType;
return new BoundArrayIndexAccessNode(expression.Tokens, elementType, boundArray, BindExpression(expression.Index, new NubPrimitiveType(PrimitiveTypeKind.U64)));
return new BoundArrayIndexAccess(expression.Tokens, elementType, boundArray, BindExpression(expression.Index, new NubPrimitiveType(PrimitiveTypeKind.U64)));
}
private BoundArrayInitializerNode BindArrayInitializer(ArrayInitializerSyntax expression)
private BoundArrayInitializer BindArrayInitializer(ArrayInitializerSyntax expression)
{
return new BoundArrayInitializerNode(expression.Tokens, new NubArrayType(expression.ElementType), BindExpression(expression.Capacity, new NubPrimitiveType(PrimitiveTypeKind.U64)), expression.ElementType);
return new BoundArrayInitializer(expression.Tokens, new NubArrayType(expression.ElementType), BindExpression(expression.Capacity, new NubPrimitiveType(PrimitiveTypeKind.U64)), expression.ElementType);
}
private BoundBinaryExpressionNode BindBinaryExpression(BinaryExpressionSyntax expression)
private BoundBinaryExpression BindBinaryExpression(BinaryExpressionSyntax expression)
{
var boundLeft = BindExpression(expression.Left);
var boundRight = BindExpression(expression.Right, boundLeft.Type);
return new BoundBinaryExpressionNode(expression.Tokens, boundLeft.Type, boundLeft, BindBinaryOperator(expression.Operator), boundRight);
return new BoundBinaryExpression(expression.Tokens, boundLeft.Type, boundLeft, BindBinaryOperator(expression.Operator), boundRight);
}
private BoundDereferenceNode BindDereference(DereferenceSyntax expression)
private BoundDereference BindDereference(DereferenceSyntax expression)
{
var boundExpression = BindExpression(expression.Expression);
var dereferencedType = ((NubPointerType)boundExpression.Type).BaseType;
return new BoundDereferenceNode(expression.Tokens, dereferencedType, boundExpression);
return new BoundDereference(expression.Tokens, dereferencedType, boundExpression);
}
private BoundFuncCallNode BindFuncCall(FuncCallSyntax expression)
private BoundFuncCall BindFuncCall(FuncCallSyntax expression)
{
var boundExpression = BindExpression(expression.Expression);
var funcType = (NubFuncType)boundExpression.Type;
var parameters = new List<BoundExpressionNode>();
var parameters = new List<BoundExpression>();
foreach (var (i, parameter) in expression.Parameters.Index())
{
@@ -343,10 +343,10 @@ public sealed class Binder
parameters.Add(BindExpression(parameter, expectedType));
}
return new BoundFuncCallNode(expression.Tokens, funcType.ReturnType, boundExpression, parameters);
return new BoundFuncCall(expression.Tokens, funcType.ReturnType, boundExpression, parameters);
}
private BoundExpressionNode BindIdentifier(IdentifierSyntax expression)
private BoundExpression BindIdentifier(IdentifierSyntax expression)
{
var @namespace = expression.Namespace.Or(_syntaxTree.Namespace);
var localFuncs = _definitionTable.LookupLocalFunc(@namespace, expression.Name).ToArray();
@@ -360,7 +360,7 @@ public sealed class Binder
var localFunc = localFuncs[0];
var type = new NubFuncType(localFunc.ReturnType, localFunc.Parameters.Select(p => p.Type).ToList());
return new BoundLocalFuncIdentNode(expression.Tokens, type, @namespace, expression.Name);
return new BoundLocalFuncIdent(expression.Tokens, type, @namespace, expression.Name);
}
var externFuncs = _definitionTable.LookupExternFunc(@namespace, expression.Name).ToArray();
@@ -374,18 +374,18 @@ public sealed class Binder
var externFunc = externFuncs[0];
var type = new NubFuncType(externFunc.ReturnType, externFunc.Parameters.Select(p => p.Type).ToList());
return new BoundExternFuncIdentNode(expression.Tokens, type, @namespace, expression.Name);
return new BoundExternFuncIdent(expression.Tokens, type, @namespace, expression.Name);
}
if (!expression.Namespace.HasValue)
{
return new BoundVariableIdentNode(expression.Tokens, _variables[expression.Name], expression.Name);
return new BoundVariableIdent(expression.Tokens, _variables[expression.Name], expression.Name);
}
throw new BindException(Diagnostic.Error($"No identifier with then name {(expression.Namespace.HasValue ? $"{expression.Namespace.Value}::" : "")}{expression.Name} exists").Build());
}
private BoundLiteralNode BindLiteral(LiteralSyntax expression, NubType? expectedType = null)
private BoundLiteral BindLiteral(LiteralSyntax expression, NubType? expectedType = null)
{
var type = expectedType ?? expression.Kind switch
{
@@ -396,10 +396,10 @@ public sealed class Binder
_ => throw new ArgumentOutOfRangeException()
};
return new BoundLiteralNode(expression.Tokens, type, expression.Literal, expression.Kind);
return new BoundLiteral(expression.Tokens, type, expression.Literal, expression.Kind);
}
private BoundExpressionNode BindMemberAccess(MemberAccessSyntax expression)
private BoundExpression BindMemberAccess(MemberAccessSyntax expression)
{
var boundExpression = BindExpression(expression.Target);
@@ -414,7 +414,7 @@ public sealed class Binder
var impl = traitFuncImpls[0];
var type = new NubFuncType(impl.ReturnType, impl.Parameters.Select(p => p.Type).ToList());
return new BoundTraitImplFuncAccessNode(expression.Tokens, type, boundExpression, expression.Member);
return new BoundTraitImplFuncAccess(expression.Tokens, type, boundExpression, expression.Member);
}
if (boundExpression.Type is NubCustomType customType)
@@ -440,7 +440,7 @@ public sealed class Binder
var traitFunc = traitFuncs[0];
var type = new NubFuncType(traitFunc.ReturnType, traitFunc.Parameters.Select(p => p.Type).ToList());
return new BoundTraitFuncAccessNode(expression.Tokens, type, customType, boundExpression, expression.Member);
return new BoundTraitFuncAccess(expression.Tokens, type, customType, boundExpression, expression.Member);
}
}
@@ -464,7 +464,7 @@ public sealed class Binder
var field = fields[0];
return new BoundStructFieldAccessNode(expression.Tokens, field.Type, customType, boundExpression, expression.Member);
return new BoundStructFieldAccess(expression.Tokens, field.Type, customType, boundExpression, expression.Member);
}
}
}
@@ -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());
}
private BoundStructInitializerNode BindStructInitializer(StructInitializerSyntax expression)
private BoundStructInitializer BindStructInitializer(StructInitializerSyntax expression)
{
if (expression.StructType is not NubCustomType structType)
{
@@ -493,7 +493,7 @@ public sealed class Binder
var @struct = structs[0];
var initializers = new Dictionary<string, BoundExpressionNode>();
var initializers = new Dictionary<string, BoundExpression>();
foreach (var (field, initializer) in expression.Initializers)
{
@@ -512,10 +512,10 @@ public sealed class Binder
initializers[field] = BindExpression(initializer, fields[0].Type);
}
return new BoundStructInitializerNode(expression.Tokens, structType, new NubCustomType(@struct.Namespace, @struct.Name), initializers);
return new BoundStructInitializer(expression.Tokens, structType, new NubCustomType(@struct.Namespace, @struct.Name), initializers);
}
private BoundUnaryExpressionNode BindUnaryExpression(UnaryExpressionSyntax expression)
private BoundUnaryExpression BindUnaryExpression(UnaryExpressionSyntax expression)
{
var boundOperand = BindExpression(expression.Operand);
@@ -548,7 +548,7 @@ public sealed class Binder
throw new NotImplementedException("Diagnostics not implemented");
}
return new BoundUnaryExpressionNode(expression.Tokens, type, BindBinaryOperator(expression.Operator), boundOperand);
return new BoundUnaryExpression(expression.Tokens, type, BindBinaryOperator(expression.Operator), boundOperand);
}
private BoundBinaryOperator BindBinaryOperator(BinaryOperator op)

26
src/compiler/NubLang/Syntax/Binding/Node/Definition.cs Normal file
View File

@@ -0,0 +1,26 @@
using Common;
using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Binding.Node;
public abstract record BoundDefinition(IEnumerable<Token> Tokens, string Namespace) : BoundNode(Tokens);
public abstract record BoundDefinitionMember(IEnumerable<Token> Tokens) : BoundNode(Tokens);
public record BoundFuncParameter(IEnumerable<Token> Tokens, string Name, NubType Type) : BoundDefinitionMember(Tokens);
public record BoundLocalFunc(IEnumerable<Token> Tokens, string Namespace, string Name, List<BoundFuncParameter> Parameters, BoundBlock Body, NubType ReturnType, bool Exported) : BoundDefinition(Tokens, Namespace);
public record BoundExternFunc(IEnumerable<Token> Tokens, string Namespace, string Name, string CallName, List<BoundFuncParameter> Parameters, NubType ReturnType) : BoundDefinition(Tokens, Namespace);
public record BoundStructField(IEnumerable<Token> Tokens, int Index, string Name, NubType Type, Optional<BoundExpression> Value) : BoundDefinitionMember(Tokens);
public record BoundStruct(IEnumerable<Token> Tokens, string Namespace, string Name, List<BoundStructField> Fields) : BoundDefinition(Tokens, Namespace);
public record BoundTraitFunc(IEnumerable<Token> Tokens, string Name, List<BoundFuncParameter> Parameters, NubType ReturnType) : BoundDefinitionMember(Tokens);
public record BoundTrait(IEnumerable<Token> Tokens, string Namespace, string Name, List<BoundTraitFunc> Functions) : BoundDefinition(Tokens, Namespace);
public record BoundTraitFuncImpl(IEnumerable<Token> Tokens, string Name, List<BoundFuncParameter> Parameters, NubType ReturnType, BoundBlock Body) : BoundDefinitionMember(Tokens);
public record BoundTraitImpl(IEnumerable<Token> Tokens, string Namespace, NubType TraitType, NubType ForType, List<BoundTraitFuncImpl> Functions) : BoundDefinition(Tokens, Namespace);

57
src/compiler/NubLang/Syntax/Binding/Node/Expression.cs Normal file
View File

@@ -0,0 +1,57 @@
using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Binding.Node;
public enum BoundUnaryOperator
{
Negate,
Invert
}
public enum BoundBinaryOperator
{
Equal,
NotEqual,
GreaterThan,
GreaterThanOrEqual,
LessThan,
LessThanOrEqual,
Plus,
Minus,
Multiply,
Divide
}
public abstract record BoundExpression(IEnumerable<Token> Tokens, NubType Type) : BoundNode(Tokens);
public record BoundBinaryExpression(IEnumerable<Token> Tokens, NubType Type, BoundExpression Left, BoundBinaryOperator Operator, BoundExpression Right) : BoundExpression(Tokens, Type);
public record BoundUnaryExpression(IEnumerable<Token> Tokens, NubType Type, BoundUnaryOperator Operator, BoundExpression Operand) : BoundExpression(Tokens, Type);
public record BoundFuncCall(IEnumerable<Token> Tokens, NubType Type, BoundExpression Expression, List<BoundExpression> Parameters) : BoundExpression(Tokens, Type);
public record BoundVariableIdent(IEnumerable<Token> Tokens, NubType Type, string Name) : BoundExpression(Tokens, Type);
public record BoundLocalFuncIdent(IEnumerable<Token> Tokens, NubType Type, string Namespace, string Name) : BoundExpression(Tokens, Type);
public record BoundExternFuncIdent(IEnumerable<Token> Tokens, NubType Type, string Namespace, string Name) : BoundExpression(Tokens, Type);
public record BoundArrayInitializer(IEnumerable<Token> Tokens, NubType Type, BoundExpression Capacity, NubType ElementType) : BoundExpression(Tokens, Type);
public record BoundArrayIndexAccess(IEnumerable<Token> Tokens, NubType Type, BoundExpression Target, BoundExpression Index) : BoundExpression(Tokens, Type);
public record BoundAnonymousFunc(IEnumerable<Token> Tokens, NubType Type, List<BoundFuncParameter> Parameters, BoundBlock Body, NubType ReturnType) : BoundExpression(Tokens, Type);
public record BoundAddressOf(IEnumerable<Token> Tokens, NubType Type, BoundExpression Expression) : BoundExpression(Tokens, Type);
public record BoundLiteral(IEnumerable<Token> Tokens, NubType Type, string Literal, LiteralKind Kind) : BoundExpression(Tokens, Type);
public record BoundStructFieldAccess(IEnumerable<Token> Tokens, NubType Type, NubCustomType StructType, BoundExpression Target, string Field) : BoundExpression(Tokens, Type);
public record BoundTraitImplFuncAccess(IEnumerable<Token> Tokens, NubType Type, BoundExpression Target, string FuncName) : BoundExpression(Tokens, Type);
public record BoundTraitFuncAccess(IEnumerable<Token> Tokens, NubType Type, NubCustomType TraitType, BoundExpression Target, string FuncName) : BoundExpression(Tokens, Type);
public record BoundStructInitializer(IEnumerable<Token> Tokens, NubType Type, NubCustomType StructType, Dictionary<string, BoundExpression> Initializers) : BoundExpression(Tokens, Type);
public record BoundDereference(IEnumerable<Token> Tokens, NubType Type, BoundExpression Expression) : BoundExpression(Tokens, Type);

22
src/compiler/NubLang/Syntax/Binding/Node/Statement.cs Normal file
View File

@@ -0,0 +1,22 @@
using Common;
using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Binding.Node;
public record BoundStatement(IEnumerable<Token> Tokens) : BoundNode(Tokens);
public record BoundStatementExpression(IEnumerable<Token> Tokens, BoundExpression Expression) : BoundStatement(Tokens);
public record BoundReturn(IEnumerable<Token> Tokens, Optional<BoundExpression> Value) : BoundStatement(Tokens);
public record BoundAssignment(IEnumerable<Token> Tokens, BoundExpression Target, BoundExpression Value) : BoundStatement(Tokens);
public record BoundIf(IEnumerable<Token> Tokens, BoundExpression Condition, BoundBlock Body, Optional<Variant<BoundIf, BoundBlock>> Else) : BoundStatement(Tokens);
public record BoundVariableDeclaration(IEnumerable<Token> Tokens, string Name, Optional<BoundExpression> Assignment, NubType Type) : BoundStatement(Tokens);
public record BoundContinue(IEnumerable<Token> Tokens) : BoundStatement(Tokens);
public record BoundBreak(IEnumerable<Token> Tokens) : BoundStatement(Tokens);
public record BoundWhile(IEnumerable<Token> Tokens, BoundExpression Condition, BoundBlock Body) : BoundStatement(Tokens);

6
src/compiler/NubLang/Syntax/Node/SyntaxTree.cs → src/compiler/NubLang/Syntax/Binding/Node/SyntaxTree.cs
View File

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

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

@@ -1,26 +0,0 @@
using Common;
using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Node;
public abstract record BoundDefinitionNode(IEnumerable<Token> Tokens, string Namespace) : BoundNode(Tokens);
public abstract record BoundDefinitionMemberNode(IEnumerable<Token> Tokens) : BoundNode(Tokens);
public record BoundFuncParameterNode(IEnumerable<Token> Tokens, string Name, NubType Type) : BoundDefinitionMemberNode(Tokens);
public record BoundLocalFuncNode(IEnumerable<Token> Tokens, string Namespace, string Name, List<BoundFuncParameterNode> Parameters, BoundBlock Body, NubType ReturnType, bool Exported) : BoundDefinitionNode(Tokens, Namespace);
public record BoundExternFuncNode(IEnumerable<Token> Tokens, string Namespace, string Name, string CallName, List<BoundFuncParameterNode> Parameters, NubType ReturnType) : BoundDefinitionNode(Tokens, Namespace);
public record BoundStructFieldNode(IEnumerable<Token> Tokens, int Index, string Name, NubType Type, Optional<BoundExpressionNode> Value) : BoundDefinitionMemberNode(Tokens);
public record BoundStructNode(IEnumerable<Token> Tokens, string Namespace, string Name, List<BoundStructFieldNode> Fields) : BoundDefinitionNode(Tokens, Namespace);
public record BoundTraitFuncNode(IEnumerable<Token> Tokens, string Name, List<BoundFuncParameterNode> Parameters, NubType ReturnType) : BoundDefinitionMemberNode(Tokens);
public record BoundTraitNode(IEnumerable<Token> Tokens, string Namespace, string Name, List<BoundTraitFuncNode> Functions) : BoundDefinitionNode(Tokens, Namespace);
public record BoundTraitFuncImplNode(IEnumerable<Token> Tokens, string Name, List<BoundFuncParameterNode> Parameters, NubType ReturnType, BoundBlock Body) : BoundDefinitionMemberNode(Tokens);
public record BoundTraitImplNode(IEnumerable<Token> Tokens, string Namespace, NubType TraitType, NubType ForType, List<BoundTraitFuncImplNode> Functions) : BoundDefinitionNode(Tokens, Namespace);

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

@@ -1,57 +0,0 @@
using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Node;
public enum BoundUnaryOperator
{
Negate,
Invert
}
public enum BoundBinaryOperator
{
Equal,
NotEqual,
GreaterThan,
GreaterThanOrEqual,
LessThan,
LessThanOrEqual,
Plus,
Minus,
Multiply,
Divide
}
public abstract record BoundExpressionNode(IEnumerable<Token> Tokens, NubType Type) : BoundNode(Tokens);
public record BoundBinaryExpressionNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Left, BoundBinaryOperator Operator, BoundExpressionNode Right) : BoundExpressionNode(Tokens, Type);
public record BoundUnaryExpressionNode(IEnumerable<Token> Tokens, NubType Type, BoundUnaryOperator Operator, BoundExpressionNode Operand) : BoundExpressionNode(Tokens, Type);
public record BoundFuncCallNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Expression, List<BoundExpressionNode> Parameters) : 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 BoundExternFuncIdentNode(IEnumerable<Token> Tokens, NubType Type, string Namespace, string Name) : BoundExpressionNode(Tokens, Type);
public record BoundArrayInitializerNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Capacity, NubType ElementType) : BoundExpressionNode(Tokens, Type);
public record BoundArrayIndexAccessNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Target, BoundExpressionNode Index) : BoundExpressionNode(Tokens, Type);
public record BoundAnonymousFuncNode(IEnumerable<Token> Tokens, NubType Type, List<BoundFuncParameterNode> Parameters, BoundBlock Body, NubType ReturnType) : BoundExpressionNode(Tokens, Type);
public record BoundAddressOfNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Expression) : BoundExpressionNode(Tokens, Type);
public record BoundLiteralNode(IEnumerable<Token> Tokens, NubType Type, string Literal, LiteralKind Kind) : 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 BoundTraitFuncAccessNode(IEnumerable<Token> Tokens, NubType Type, NubCustomType TraitType, BoundExpressionNode Target, string FuncName) : BoundExpressionNode(Tokens, Type);
public record BoundStructInitializerNode(IEnumerable<Token> Tokens, NubType Type, NubCustomType StructType, Dictionary<string, BoundExpressionNode> Initializers) : BoundExpressionNode(Tokens, Type);
public record BoundDereferenceNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Expression) : BoundExpressionNode(Tokens, Type);

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

@@ -1,22 +0,0 @@
using Common;
using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Node;
public record BoundStatementNode(IEnumerable<Token> Tokens) : BoundNode(Tokens);
public record BoundStatementExpressionNode(IEnumerable<Token> Tokens, BoundExpressionNode Expression) : BoundStatementNode(Tokens);
public record BoundReturnNode(IEnumerable<Token> Tokens, Optional<BoundExpressionNode> Value) : BoundStatementNode(Tokens);
public record BoundAssignmentNode(IEnumerable<Token> Tokens, BoundExpressionNode Target, BoundExpressionNode Value) : BoundStatementNode(Tokens);
public record BoundIfNode(IEnumerable<Token> Tokens, BoundExpressionNode Condition, BoundBlock Body, Optional<Variant<BoundIfNode, BoundBlock>> Else) : BoundStatementNode(Tokens);
public record BoundVariableDeclarationNode(IEnumerable<Token> Tokens, string Name, Optional<BoundExpressionNode> Assignment, NubType Type) : BoundStatementNode(Tokens);
public record BoundContinueNode(IEnumerable<Token> Tokens) : BoundStatementNode(Tokens);
public record BoundBreakNode(IEnumerable<Token> Tokens) : BoundStatementNode(Tokens);
public record BoundWhileNode(IEnumerable<Token> Tokens, BoundExpressionNode Condition, BoundBlock Body) : BoundStatementNode(Tokens);