nub31/nub-lang-archive
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 98ac4d789e
commit 7ee76f43cb
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;
using NubLang.Diagnostics; using NubLang.Diagnostics;
using NubLang.Generation.QBE; using NubLang.Generation.QBE;
using NubLang.Syntax.Node; using NubLang.Syntax.Binding.Node;
using NubLang.Syntax.Parsing; using NubLang.Syntax.Parsing;
using NubLang.Syntax.Parsing.Node; using NubLang.Syntax.Parsing.Node;
using NubLang.Syntax.Tokenization; 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; using NubLang.Syntax.Parsing.Node;
namespace NubLang; namespace NubLang;
@@ -62,74 +62,74 @@ public sealed class DefinitionTable
public sealed class BoundDefinitionTable public sealed class BoundDefinitionTable
{ {
private readonly List<BoundDefinitionNode> _definitions; private readonly List<BoundDefinition> _definitions;
public BoundDefinitionTable(IEnumerable<BoundSyntaxTree> syntaxTrees) public BoundDefinitionTable(IEnumerable<BoundSyntaxTree> syntaxTrees)
{ {
_definitions = syntaxTrees.SelectMany(x => x.Definitions).ToList(); _definitions = syntaxTrees.SelectMany(x => x.Definitions).ToList();
} }
public BoundLocalFuncNode LookupLocalFunc(string @namespace, string name) public BoundLocalFunc LookupLocalFunc(string @namespace, string name)
{ {
return _definitions return _definitions
.OfType<BoundLocalFuncNode>() .OfType<BoundLocalFunc>()
.First(x => x.Namespace == @namespace && x.Name == name); .First(x => x.Namespace == @namespace && x.Name == name);
} }
public BoundExternFuncNode LookupExternFunc(string @namespace, string name) public BoundExternFunc LookupExternFunc(string @namespace, string name)
{ {
return _definitions return _definitions
.OfType<BoundExternFuncNode>() .OfType<BoundExternFunc>()
.First(x => x.Namespace == @namespace && x.Name == name); .First(x => x.Namespace == @namespace && x.Name == name);
} }
public BoundStructNode LookupStruct(string @namespace, string name) public BoundStruct LookupStruct(string @namespace, string name)
{ {
return _definitions return _definitions
.OfType<BoundStructNode>() .OfType<BoundStruct>()
.First(x => x.Namespace == @namespace && x.Name == name); .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 return _definitions
.OfType<BoundTraitImplNode>() .OfType<BoundTraitImpl>()
.Where(x => x.ForType == itemType); .Where(x => x.ForType == itemType);
} }
public BoundTraitFuncImplNode LookupTraitFuncImpl(NubType forType, string name) public BoundTraitFuncImpl LookupTraitFuncImpl(NubType forType, string name)
{ {
return _definitions return _definitions
.OfType<BoundTraitImplNode>() .OfType<BoundTraitImpl>()
.Where(x => x.ForType == forType) .Where(x => x.ForType == forType)
.SelectMany(x => x.Functions) .SelectMany(x => x.Functions)
.First(x => x.Name == name); .First(x => x.Name == name);
} }
public BoundTraitNode LookupTrait(string @namespace, string name) public BoundTrait LookupTrait(string @namespace, string name)
{ {
return _definitions return _definitions
.OfType<BoundTraitNode>() .OfType<BoundTrait>()
.First(x => x.Namespace == @namespace && x.Name == name); .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); 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.Diagnostics.CodeAnalysis;
using System.Globalization; using System.Globalization;
using System.Text; using System.Text;
using NubLang.Syntax.Node; using NubLang.Syntax.Binding.Node;
using NubLang.Syntax.Tokenization; using NubLang.Syntax.Tokenization;
namespace NubLang.Generation.QBE; namespace NubLang.Generation.QBE;
@@ -17,8 +17,8 @@ public static class QBEGenerator
private static List<StringLiteral> _stringLiterals = []; private static List<StringLiteral> _stringLiterals = [];
private static Stack<string> _breakLabels = []; private static Stack<string> _breakLabels = [];
private static Stack<string> _continueLabels = []; private static Stack<string> _continueLabels = [];
private static Queue<(BoundAnonymousFuncNode Func, string Name)> _anonymousFunctions = []; private static Queue<(BoundAnonymousFunc Func, string Name)> _anonymousFunctions = [];
private static Dictionary<BoundTraitFuncImplNode, string> _implFunctions = []; private static Dictionary<BoundTraitFuncImpl, string> _implFunctions = [];
private static Stack<Variable> _variables = []; private static Stack<Variable> _variables = [];
private static Stack<int> _variableScopes = []; private static Stack<int> _variableScopes = [];
private static int _tmpIndex; private static int _tmpIndex;
@@ -64,7 +64,7 @@ public static class QBEGenerator
_writer.NewLine(); _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); EmitFuncDefinition(funcDef, LocalFuncName(funcDef), funcDef.Parameters, funcDef.ReturnType, funcDef.Body, funcDef.Exported);
_writer.NewLine(); _writer.NewLine();
@@ -116,12 +116,12 @@ public static class QBEGenerator
return $"$string{++_stringLiteralIndex}"; return $"$string{++_stringLiteralIndex}";
} }
private static string LocalFuncName(BoundLocalFuncNode funcDef) private static string LocalFuncName(BoundLocalFunc funcDef)
{ {
return funcDef.Exported ? $"${funcDef.Name}" : $"${funcDef.Namespace}_{funcDef.Name}"; return funcDef.Exported ? $"${funcDef.Name}" : $"${funcDef.Namespace}_{funcDef.Name}";
} }
private static string ExternFuncName(BoundExternFuncNode funcDef) private static string ExternFuncName(BoundExternFunc funcDef)
{ {
return $"${funcDef.CallName}"; return $"${funcDef.CallName}";
} }
@@ -227,23 +227,23 @@ public static class QBEGenerator
return size; return size;
} }
private static bool EmitTryMoveInto(BoundExpressionNode source, string destinationPointer) private static bool EmitTryMoveInto(BoundExpression source, string destinationPointer)
{ {
switch (source) switch (source)
{ {
case BoundArrayInitializerNode arrayInitializer: case BoundArrayInitializer arrayInitializer:
{ {
_writer.WriteDebugLocation(arrayInitializer); _writer.WriteDebugLocation(arrayInitializer);
EmitStore(source.Type, EmitUnwrap(EmitArrayInitializer(arrayInitializer)), destinationPointer); EmitStore(source.Type, EmitUnwrap(EmitArrayInitializer(arrayInitializer)), destinationPointer);
return true; return true;
} }
case BoundStructInitializerNode structInitializer: case BoundStructInitializer structInitializer:
{ {
_writer.WriteDebugLocation(structInitializer); _writer.WriteDebugLocation(structInitializer);
EmitStructInitializer(structInitializer, destinationPointer); EmitStructInitializer(structInitializer, destinationPointer);
return true; return true;
} }
case BoundLiteralNode { Kind: LiteralKind.String } literal: case BoundLiteral { Kind: LiteralKind.String } literal:
{ {
_writer.WriteDebugLocation(literal); _writer.WriteDebugLocation(literal);
EmitStore(source.Type, EmitUnwrap(EmitLiteral(literal)), destinationPointer); EmitStore(source.Type, EmitUnwrap(EmitLiteral(literal)), destinationPointer);
@@ -254,7 +254,7 @@ public static class QBEGenerator
return false; 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 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)) 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) switch (source)
{ {
case BoundArrayInitializerNode: case BoundArrayInitializer:
case BoundStructInitializerNode: case BoundStructInitializer:
case BoundLiteralNode { Kind: LiteralKind.String }: case BoundLiteral { Kind: LiteralKind.String }:
{ {
destination = EmitUnwrap(EmitExpression(source)); destination = EmitUnwrap(EmitExpression(source));
return true; return true;
@@ -309,7 +309,7 @@ public static class QBEGenerator
return false; 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 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)) if (EmitTryCreateWithoutCopy(source, out var uncopiedValue))
@@ -391,7 +391,7 @@ public static class QBEGenerator
return "l"; 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(); _variables.Clear();
_variableScopes.Clear(); _variableScopes.Clear();
@@ -424,7 +424,7 @@ public static class QBEGenerator
EmitBlock(body, parameterVars); EmitBlock(body, parameterVars);
if (body.Statements.LastOrDefault() is not BoundReturnNode) if (body.Statements.LastOrDefault() is not BoundReturn)
{ {
if (returnType is NubVoidType) if (returnType is NubVoidType)
{ {
@@ -435,7 +435,7 @@ public static class QBEGenerator
_writer.EndFunction(); _writer.EndFunction();
} }
private static void EmitStructDefinition(BoundStructNode structDef) private static void EmitStructDefinition(BoundStruct structDef)
{ {
_writer.WriteLine($"type {CustomTypeName(structDef.Namespace, structDef.Name)} = {{ "); _writer.WriteLine($"type {CustomTypeName(structDef.Namespace, structDef.Name)} = {{ ");
@@ -456,7 +456,7 @@ public static class QBEGenerator
_writer.WriteLine("}"); _writer.WriteLine("}");
return; return;
string StructDefQBEType(BoundStructFieldNode field) string StructDefQBEType(BoundStructField field)
{ {
if (field.Type.IsSimpleType(out var simpleType, out var complexType)) 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)} = {{"); _writer.WriteLine($"type {CustomTypeName(traitDef.Namespace, traitDef.Name)} = {{");
@@ -493,34 +493,34 @@ public static class QBEGenerator
_writer.WriteLine("}"); _writer.WriteLine("}");
} }
private static void EmitStatement(BoundStatementNode statement) private static void EmitStatement(BoundStatement statement)
{ {
_writer.WriteDebugLocation(statement); _writer.WriteDebugLocation(statement);
switch (statement) switch (statement)
{ {
case BoundAssignmentNode assignment: case BoundAssignment assignment:
EmitAssignment(assignment); EmitAssignment(assignment);
break; break;
case BoundBreakNode: case BoundBreak:
EmitBreak(); EmitBreak();
break; break;
case BoundContinueNode: case BoundContinue:
EmitContinue(); EmitContinue();
break; break;
case BoundIfNode ifStatement: case BoundIf ifStatement:
EmitIf(ifStatement); EmitIf(ifStatement);
break; break;
case BoundReturnNode @return: case BoundReturn @return:
EmitReturn(@return); EmitReturn(@return);
break; break;
case BoundStatementExpressionNode statementExpression: case BoundStatementExpression statementExpression:
EmitExpression(statementExpression.Expression); EmitExpression(statementExpression.Expression);
break; break;
case BoundVariableDeclarationNode variableDeclaration: case BoundVariableDeclaration variableDeclaration:
EmitVariableDeclaration(variableDeclaration); EmitVariableDeclaration(variableDeclaration);
break; break;
case BoundWhileNode whileStatement: case BoundWhile whileStatement:
EmitWhile(whileStatement); EmitWhile(whileStatement);
break; break;
default: 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); var destination = EmitExpression(assignment.Target);
Debug.Assert(destination.Kind == ValKind.Pointer); Debug.Assert(destination.Kind == ValKind.Pointer);
@@ -572,7 +572,7 @@ public static class QBEGenerator
_codeIsReachable = false; _codeIsReachable = false;
} }
private static void EmitIf(BoundIfNode ifStatement) private static void EmitIf(BoundIf ifStatement)
{ {
var trueLabel = LabelName(); var trueLabel = LabelName();
var falseLabel = LabelName(); var falseLabel = LabelName();
@@ -596,7 +596,7 @@ public static class QBEGenerator
_writer.WriteLine(endLabel); _writer.WriteLine(endLabel);
} }
private static void EmitReturn(BoundReturnNode @return) private static void EmitReturn(BoundReturn @return)
{ {
if (@return.Value.HasValue) 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}"; var name = $"%{variableDeclaration.Name}";
_writer.Indented($"{name} =l alloc8 8"); _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))); _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 conditionLabel = LabelName();
var iterationLabel = LabelName(); var iterationLabel = LabelName();
@@ -644,39 +644,39 @@ public static class QBEGenerator
_breakLabels.Pop(); _breakLabels.Pop();
} }
private static Val EmitExpression(BoundExpressionNode expression) private static Val EmitExpression(BoundExpression expression)
{ {
_writer.WriteDebugLocation(expression); _writer.WriteDebugLocation(expression);
return expression switch return expression switch
{ {
BoundArrayInitializerNode arrayInitializer => EmitArrayInitializer(arrayInitializer), BoundArrayInitializer arrayInitializer => EmitArrayInitializer(arrayInitializer),
BoundStructInitializerNode structInitializer => EmitStructInitializer(structInitializer), BoundStructInitializer structInitializer => EmitStructInitializer(structInitializer),
BoundAddressOfNode addressOf => EmitAddressOf(addressOf), BoundAddressOf addressOf => EmitAddressOf(addressOf),
BoundDereferenceNode dereference => EmitDereference(dereference), BoundDereference dereference => EmitDereference(dereference),
BoundAnonymousFuncNode anonymousFunc => EmitAnonymousFunc(anonymousFunc), BoundAnonymousFunc anonymousFunc => EmitAnonymousFunc(anonymousFunc),
BoundBinaryExpressionNode binaryExpression => EmitBinaryExpression(binaryExpression), BoundBinaryExpression binaryExpression => EmitBinaryExpression(binaryExpression),
BoundFuncCallNode funcCallExpression => EmitFuncCall(funcCallExpression), BoundFuncCall funcCallExpression => EmitFuncCall(funcCallExpression),
BoundExternFuncIdentNode externFuncIdent => EmitExternFuncIdent(externFuncIdent), BoundExternFuncIdent externFuncIdent => EmitExternFuncIdent(externFuncIdent),
BoundLocalFuncIdentNode localFuncIdent => EmitLocalFuncIdent(localFuncIdent), BoundLocalFuncIdent localFuncIdent => EmitLocalFuncIdent(localFuncIdent),
BoundVariableIdentNode variableIdent => EmitVariableIdent(variableIdent), BoundVariableIdent variableIdent => EmitVariableIdent(variableIdent),
BoundLiteralNode literal => EmitLiteral(literal), BoundLiteral literal => EmitLiteral(literal),
BoundUnaryExpressionNode unaryExpression => EmitUnaryExpression(unaryExpression), BoundUnaryExpression unaryExpression => EmitUnaryExpression(unaryExpression),
BoundStructFieldAccessNode structFieldAccess => EmitStructFieldAccess(structFieldAccess), BoundStructFieldAccess structFieldAccess => EmitStructFieldAccess(structFieldAccess),
BoundTraitFuncAccessNode traitFuncAccess => EmitTraitFuncAccess(traitFuncAccess), BoundTraitFuncAccess traitFuncAccess => EmitTraitFuncAccess(traitFuncAccess),
BoundTraitImplFuncAccessNode traitImplFuncAccess => EmitTraitImplFuncAccess(traitImplFuncAccess), BoundTraitImplFuncAccess traitImplFuncAccess => EmitTraitImplFuncAccess(traitImplFuncAccess),
BoundArrayIndexAccessNode arrayIndex => EmitArrayIndexAccess(arrayIndex), BoundArrayIndexAccess arrayIndex => EmitArrayIndexAccess(arrayIndex),
_ => throw new ArgumentOutOfRangeException(nameof(expression)) _ => throw new ArgumentOutOfRangeException(nameof(expression))
}; };
} }
private static Val EmitAnonymousFunc(BoundAnonymousFuncNode anonymousFunc) private static Val EmitAnonymousFunc(BoundAnonymousFunc anonymousFunc)
{ {
var name = $"$anon_func{++_anonymousFuncIndex}"; var name = $"$anon_func{++_anonymousFuncIndex}";
_anonymousFunctions.Enqueue((anonymousFunc, name)); _anonymousFunctions.Enqueue((anonymousFunc, name));
return new Val(name, anonymousFunc.Type, ValKind.Direct); 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 array = EmitUnwrap(EmitExpression(arrayIndexAccess.Target));
var index = EmitUnwrap(EmitExpression(arrayIndexAccess.Index)); var index = EmitUnwrap(EmitExpression(arrayIndexAccess.Index));
@@ -716,7 +716,7 @@ public static class QBEGenerator
_writer.Indented(notOobLabel); _writer.Indented(notOobLabel);
} }
private static Val EmitArrayInitializer(BoundArrayInitializerNode arrayInitializer) private static Val EmitArrayInitializer(BoundArrayInitializer arrayInitializer)
{ {
var capacity = EmitUnwrap(EmitExpression(arrayInitializer.Capacity)); var capacity = EmitUnwrap(EmitExpression(arrayInitializer.Capacity));
var elementSize = arrayInitializer.ElementType.Size(_definitionTable); var elementSize = arrayInitializer.ElementType.Size(_definitionTable);
@@ -737,12 +737,12 @@ public static class QBEGenerator
return new Val(arrayPointer, arrayInitializer.Type, ValKind.Direct); 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))); 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); var value = EmitExpression(addressOf.Expression);
if (value.Kind != ValKind.Pointer) if (value.Kind != ValKind.Pointer)
@@ -753,7 +753,7 @@ public static class QBEGenerator
return new Val(value.Name, addressOf.Type, ValKind.Direct); 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 left = EmitUnwrap(EmitExpression(binaryExpression.Left));
var right = EmitUnwrap(EmitExpression(binaryExpression.Right)); 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); var func = _definitionTable.LookupExternFunc(externFuncIdent.Namespace, externFuncIdent.Name);
return new Val(ExternFuncName(func), externFuncIdent.Type, ValKind.Direct); 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); var func = _definitionTable.LookupExternFunc(localFuncIdent.Namespace, localFuncIdent.Name);
return new Val(ExternFuncName(func), localFuncIdent.Type, ValKind.Direct); 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; return _variables.Single(v => v.Name == variableIdent.Name).Val;
} }
private static Val EmitLiteral(BoundLiteralNode literal) private static Val EmitLiteral(BoundLiteral literal)
{ {
switch (literal.Kind) 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}"); 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); 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); 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 operand = EmitUnwrap(EmitExpression(unaryExpression.Operand));
var outputName = TmpName(); 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"); 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)); var target = EmitUnwrap(EmitExpression(structFieldAccess.Target));
@@ -1053,12 +1053,12 @@ public static class QBEGenerator
return new Val(output, structFieldAccess.Type, ValKind.Pointer); return new Val(output, structFieldAccess.Type, ValKind.Pointer);
} }
private static Val EmitTraitFuncAccess(BoundTraitFuncAccessNode traitFuncAccess) private static Val EmitTraitFuncAccess(BoundTraitFuncAccess traitFuncAccess)
{ {
throw new NotImplementedException(); throw new NotImplementedException();
} }
private static Val EmitTraitImplFuncAccess(BoundTraitImplFuncAccessNode traitImplFuncAccess) private static Val EmitTraitImplFuncAccess(BoundTraitImplFuncAccess traitImplFuncAccess)
{ {
var target = EmitExpression(traitImplFuncAccess.Target); var target = EmitExpression(traitImplFuncAccess.Target);
@@ -1069,7 +1069,7 @@ public static class QBEGenerator
return new Val(name, traitImplFuncAccess.Type, ValKind.Direct, new MethodCallContext(target)); 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 expression = EmitExpression(funcCall.Expression);
var funcPointer = EmitUnwrap(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; var offset = 0;

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

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

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

@@ -1,6 +1,6 @@
using Common; using Common;
using NubLang.Diagnostics; using NubLang.Diagnostics;
using NubLang.Syntax.Node; using NubLang.Syntax.Binding.Node;
using NubLang.Syntax.Parsing.Node; using NubLang.Syntax.Parsing.Node;
using NubLang.Syntax.Tokenization; using NubLang.Syntax.Tokenization;
@@ -28,7 +28,7 @@ public sealed class Binder
_functionReturnType = null; _functionReturnType = null;
var diagnostics = new List<Diagnostic>(); var diagnostics = new List<Diagnostic>();
var definitions = new List<BoundDefinitionNode>(); var definitions = new List<BoundDefinition>();
foreach (var definition in _syntaxTree.Definitions) foreach (var definition in _syntaxTree.Definitions)
{ {
@@ -45,7 +45,7 @@ public sealed class Binder
return new BoundSyntaxTree(_syntaxTree.Namespace, definitions, diagnostics); return new BoundSyntaxTree(_syntaxTree.Namespace, definitions, diagnostics);
} }
private BoundDefinitionNode BindTopLevel(DefinitionSyntax node) private BoundDefinition BindTopLevel(DefinitionSyntax node)
{ {
return node switch return node switch
{ {
@@ -58,98 +58,98 @@ public sealed class Binder
}; };
} }
private BoundTraitImplNode BindTraitImplementation(TraitImplSyntax node) private BoundTraitImpl BindTraitImplementation(TraitImplSyntax node)
{ {
_variables.Clear(); _variables.Clear();
var functions = new List<BoundTraitFuncImplNode>(); var functions = new List<BoundTraitFuncImpl>();
foreach (var function in node.Functions) foreach (var function in node.Functions)
{ {
var parameters = new List<BoundFuncParameterNode>(); var parameters = new List<BoundFuncParameter>();
foreach (var parameter in function.Parameters) foreach (var parameter in function.Parameters)
{ {
_variables[parameter.Name] = parameter.Type; _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) foreach (var function in node.Functions)
{ {
var parameters = new List<BoundFuncParameterNode>(); var parameters = new List<BoundFuncParameter>();
foreach (var parameter in function.Parameters) 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) foreach (var field in node.Fields)
{ {
var value = Optional.Empty<BoundExpressionNode>(); var value = Optional.Empty<BoundExpression>();
if (field.Value.HasValue) if (field.Value.HasValue)
{ {
value = BindExpression(field.Value.Value, field.Type); 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) 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(); _variables.Clear();
_functionReturnType = node.ReturnType; _functionReturnType = node.ReturnType;
var parameters = new List<BoundFuncParameterNode>(); var parameters = new List<BoundFuncParameter>();
foreach (var parameter in node.Parameters) foreach (var parameter in node.Parameters)
{ {
_variables[parameter.Name] = parameter.Type; _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); 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) private BoundBlock BindBlock(BlockSyntax node)
{ {
var statements = new List<BoundStatementNode>(); var statements = new List<BoundStatement>();
foreach (var statement in node.Statements) foreach (var statement in node.Statements)
{ {
@@ -159,7 +159,7 @@ public sealed class Binder
return new BoundBlock(node.Tokens, statements); return new BoundBlock(node.Tokens, statements);
} }
private BoundStatementNode BindStatement(StatementSyntax node) private BoundStatement BindStatement(StatementSyntax node)
{ {
return node switch 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 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 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) if (statement.Else.HasValue)
{ {
elseStatement = statement.Else.Value.Match<Variant<BoundIfNode, BoundBlock>> elseStatement = statement.Else.Value.Match<Variant<BoundIf, BoundBlock>>
( (
elseIf => BindIf(elseIf), elseIf => BindIf(elseIf),
@else => BindBlock(@else) @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) if (statement.Value.HasValue)
{ {
value = BindExpression(statement.Value.Value, _functionReturnType); 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; NubType? type = null;
@@ -234,7 +234,7 @@ public sealed class Binder
type = statement.ExplicitType.Value; type = statement.ExplicitType.Value;
} }
var assignment = Optional<BoundExpressionNode>.Empty(); var assignment = Optional<BoundExpression>.Empty();
if (statement.Assignment.HasValue) if (statement.Assignment.HasValue)
{ {
var boundValue = BindExpression(statement.Assignment.Value, type); var boundValue = BindExpression(statement.Assignment.Value, type);
@@ -249,15 +249,15 @@ public sealed class Binder
_variables[statement.Name] = type; _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 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); 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) 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); 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 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 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 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, 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 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 BoundDereference(expression.Tokens, dereferencedType, boundExpression);
} }
private BoundFuncCallNode BindFuncCall(FuncCallSyntax expression) private BoundFuncCall BindFuncCall(FuncCallSyntax expression)
{ {
var boundExpression = BindExpression(expression.Expression); var boundExpression = BindExpression(expression.Expression);
var funcType = (NubFuncType)boundExpression.Type; var funcType = (NubFuncType)boundExpression.Type;
var parameters = new List<BoundExpressionNode>(); var parameters = new List<BoundExpression>();
foreach (var (i, parameter) in expression.Parameters.Index()) foreach (var (i, parameter) in expression.Parameters.Index())
{ {
@@ -343,10 +343,10 @@ public sealed class Binder
parameters.Add(BindExpression(parameter, expectedType)); 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 @namespace = expression.Namespace.Or(_syntaxTree.Namespace);
var localFuncs = _definitionTable.LookupLocalFunc(@namespace, expression.Name).ToArray(); var localFuncs = _definitionTable.LookupLocalFunc(@namespace, expression.Name).ToArray();
@@ -360,7 +360,7 @@ public sealed class Binder
var localFunc = localFuncs[0]; var localFunc = localFuncs[0];
var type = new NubFuncType(localFunc.ReturnType, localFunc.Parameters.Select(p => p.Type).ToList()); 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(); var externFuncs = _definitionTable.LookupExternFunc(@namespace, expression.Name).ToArray();
@@ -374,18 +374,18 @@ public sealed class Binder
var externFunc = externFuncs[0]; var externFunc = externFuncs[0];
var type = new NubFuncType(externFunc.ReturnType, externFunc.Parameters.Select(p => p.Type).ToList()); 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) 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()); 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 var type = expectedType ?? expression.Kind switch
{ {
@@ -396,10 +396,10 @@ public sealed class Binder
_ => throw new ArgumentOutOfRangeException() _ => 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); var boundExpression = BindExpression(expression.Target);
@@ -414,7 +414,7 @@ public sealed class Binder
var impl = traitFuncImpls[0]; var impl = traitFuncImpls[0];
var type = new NubFuncType(impl.ReturnType, impl.Parameters.Select(p => p.Type).ToList()); 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) if (boundExpression.Type is NubCustomType customType)
@@ -440,7 +440,7 @@ public sealed class Binder
var traitFunc = traitFuncs[0]; var traitFunc = traitFuncs[0];
var type = new NubFuncType(traitFunc.ReturnType, traitFunc.Parameters.Select(p => p.Type).ToList()); 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]; 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()); 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) if (expression.StructType is not NubCustomType structType)
{ {
@@ -493,7 +493,7 @@ public sealed class Binder
var @struct = structs[0]; var @struct = structs[0];
var initializers = new Dictionary<string, BoundExpressionNode>(); var initializers = new Dictionary<string, BoundExpression>();
foreach (var (field, initializer) in expression.Initializers) foreach (var (field, initializer) in expression.Initializers)
{ {
@@ -512,10 +512,10 @@ public sealed class Binder
initializers[field] = BindExpression(initializer, fields[0].Type); 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); var boundOperand = BindExpression(expression.Operand);
@@ -548,7 +548,7 @@ public sealed class Binder
throw new NotImplementedException("Diagnostics not implemented"); 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) 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.Diagnostics;
using NubLang.Syntax.Tokenization; 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 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);