diff --git a/src/compiler/CLI/Program.cs b/src/compiler/CLI/Program.cs index 53069f3..8a8e0db 100644 --- a/src/compiler/CLI/Program.cs +++ b/src/compiler/CLI/Program.cs @@ -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; diff --git a/src/compiler/NubLang/DefinitionTable.cs b/src/compiler/NubLang/DefinitionTable.cs index 709015f..01e8408 100644 --- a/src/compiler/NubLang/DefinitionTable.cs +++ b/src/compiler/NubLang/DefinitionTable.cs @@ -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 _definitions; + private readonly List _definitions; public BoundDefinitionTable(IEnumerable 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() + .OfType() .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() + .OfType() .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() + .OfType() .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 LookupTraitImpls(NubType itemType) + public IEnumerable LookupTraitImpls(NubType itemType) { return _definitions - .OfType() + .OfType() .Where(x => x.ForType == itemType); } - public BoundTraitFuncImplNode LookupTraitFuncImpl(NubType forType, string name) + public BoundTraitFuncImpl LookupTraitFuncImpl(NubType forType, string name) { return _definitions - .OfType() + .OfType() .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() + .OfType() .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 GetStructs() + public IEnumerable GetStructs() { - return _definitions.OfType(); + return _definitions.OfType(); } - public IEnumerable GetTraits() + public IEnumerable GetTraits() { - return _definitions.OfType(); + return _definitions.OfType(); } } \ No newline at end of file diff --git a/src/compiler/NubLang/Generation/QBE/QBEGenerator.cs b/src/compiler/NubLang/Generation/QBE/QBEGenerator.cs index ae4ca6f..1a9744e 100644 --- a/src/compiler/NubLang/Generation/QBE/QBEGenerator.cs +++ b/src/compiler/NubLang/Generation/QBE/QBEGenerator.cs @@ -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 _stringLiterals = []; private static Stack _breakLabels = []; private static Stack _continueLabels = []; - private static Queue<(BoundAnonymousFuncNode Func, string Name)> _anonymousFunctions = []; - private static Dictionary _implFunctions = []; + private static Queue<(BoundAnonymousFunc Func, string Name)> _anonymousFunctions = []; + private static Dictionary _implFunctions = []; private static Stack _variables = []; private static Stack _variableScopes = []; private static int _tmpIndex; @@ -64,7 +64,7 @@ public static class QBEGenerator _writer.NewLine(); } - foreach (var funcDef in _syntaxTree.Definitions.OfType()) + foreach (var funcDef in _syntaxTree.Definitions.OfType()) { 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 parameters, NubType returnType, BoundBlock body, bool exported) + private static void EmitFuncDefinition(BoundNode debugNode, string name, List 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; diff --git a/src/compiler/NubLang/Generation/QBE/QBEWriter.cs b/src/compiler/NubLang/Generation/QBE/QBEWriter.cs index 8408924..08e1a59 100644 --- a/src/compiler/NubLang/Generation/QBE/QBEWriter.cs +++ b/src/compiler/NubLang/Generation/QBE/QBEWriter.cs @@ -1,5 +1,5 @@ using System.Text; -using NubLang.Syntax.Node; +using NubLang.Syntax.Binding.Node; namespace NubLang.Generation.QBE; diff --git a/src/compiler/NubLang/Syntax/Binding/Binder.cs b/src/compiler/NubLang/Syntax/Binding/Binder.cs index 5b0f9f5..cbdf78b 100644 --- a/src/compiler/NubLang/Syntax/Binding/Binder.cs +++ b/src/compiler/NubLang/Syntax/Binding/Binder.cs @@ -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(); - var definitions = new List(); + var definitions = new List(); 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(); + var functions = new List(); foreach (var function in node.Functions) { - var parameters = new List(); + var parameters = new List(); 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(); + var functions = new List(); foreach (var function in node.Functions) { - var parameters = new List(); + var parameters = new List(); 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(); + var structFields = new List(); foreach (var field in node.Fields) { - var value = Optional.Empty(); + var value = Optional.Empty(); 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(); + var parameters = new List(); 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(); + var parameters = new List(); 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(); + var statements = new List(); 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>(); + var elseStatement = Optional.Empty>(); if (statement.Else.HasValue) { - elseStatement = statement.Else.Value.Match> + elseStatement = statement.Else.Value.Match> ( 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(); + var value = Optional.Empty(); 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.Empty(); + var assignment = Optional.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(); + var parameters = new List(); 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(); + var parameters = new List(); 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(); + var initializers = new Dictionary(); 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) diff --git a/src/compiler/NubLang/Syntax/Binding/Node/Definition.cs b/src/compiler/NubLang/Syntax/Binding/Node/Definition.cs new file mode 100644 index 0000000..ae72af1 --- /dev/null +++ b/src/compiler/NubLang/Syntax/Binding/Node/Definition.cs @@ -0,0 +1,26 @@ +using Common; +using NubLang.Syntax.Tokenization; + +namespace NubLang.Syntax.Binding.Node; + +public abstract record BoundDefinition(IEnumerable Tokens, string Namespace) : BoundNode(Tokens); + +public abstract record BoundDefinitionMember(IEnumerable Tokens) : BoundNode(Tokens); + +public record BoundFuncParameter(IEnumerable Tokens, string Name, NubType Type) : BoundDefinitionMember(Tokens); + +public record BoundLocalFunc(IEnumerable Tokens, string Namespace, string Name, List Parameters, BoundBlock Body, NubType ReturnType, bool Exported) : BoundDefinition(Tokens, Namespace); + +public record BoundExternFunc(IEnumerable Tokens, string Namespace, string Name, string CallName, List Parameters, NubType ReturnType) : BoundDefinition(Tokens, Namespace); + +public record BoundStructField(IEnumerable Tokens, int Index, string Name, NubType Type, Optional Value) : BoundDefinitionMember(Tokens); + +public record BoundStruct(IEnumerable Tokens, string Namespace, string Name, List Fields) : BoundDefinition(Tokens, Namespace); + +public record BoundTraitFunc(IEnumerable Tokens, string Name, List Parameters, NubType ReturnType) : BoundDefinitionMember(Tokens); + +public record BoundTrait(IEnumerable Tokens, string Namespace, string Name, List Functions) : BoundDefinition(Tokens, Namespace); + +public record BoundTraitFuncImpl(IEnumerable Tokens, string Name, List Parameters, NubType ReturnType, BoundBlock Body) : BoundDefinitionMember(Tokens); + +public record BoundTraitImpl(IEnumerable Tokens, string Namespace, NubType TraitType, NubType ForType, List Functions) : BoundDefinition(Tokens, Namespace); \ No newline at end of file diff --git a/src/compiler/NubLang/Syntax/Binding/Node/Expression.cs b/src/compiler/NubLang/Syntax/Binding/Node/Expression.cs new file mode 100644 index 0000000..ea0c0ba --- /dev/null +++ b/src/compiler/NubLang/Syntax/Binding/Node/Expression.cs @@ -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 Tokens, NubType Type) : BoundNode(Tokens); + +public record BoundBinaryExpression(IEnumerable Tokens, NubType Type, BoundExpression Left, BoundBinaryOperator Operator, BoundExpression Right) : BoundExpression(Tokens, Type); + +public record BoundUnaryExpression(IEnumerable Tokens, NubType Type, BoundUnaryOperator Operator, BoundExpression Operand) : BoundExpression(Tokens, Type); + +public record BoundFuncCall(IEnumerable Tokens, NubType Type, BoundExpression Expression, List Parameters) : BoundExpression(Tokens, Type); + +public record BoundVariableIdent(IEnumerable Tokens, NubType Type, string Name) : BoundExpression(Tokens, Type); + +public record BoundLocalFuncIdent(IEnumerable Tokens, NubType Type, string Namespace, string Name) : BoundExpression(Tokens, Type); + +public record BoundExternFuncIdent(IEnumerable Tokens, NubType Type, string Namespace, string Name) : BoundExpression(Tokens, Type); + +public record BoundArrayInitializer(IEnumerable Tokens, NubType Type, BoundExpression Capacity, NubType ElementType) : BoundExpression(Tokens, Type); + +public record BoundArrayIndexAccess(IEnumerable Tokens, NubType Type, BoundExpression Target, BoundExpression Index) : BoundExpression(Tokens, Type); + +public record BoundAnonymousFunc(IEnumerable Tokens, NubType Type, List Parameters, BoundBlock Body, NubType ReturnType) : BoundExpression(Tokens, Type); + +public record BoundAddressOf(IEnumerable Tokens, NubType Type, BoundExpression Expression) : BoundExpression(Tokens, Type); + +public record BoundLiteral(IEnumerable Tokens, NubType Type, string Literal, LiteralKind Kind) : BoundExpression(Tokens, Type); + +public record BoundStructFieldAccess(IEnumerable Tokens, NubType Type, NubCustomType StructType, BoundExpression Target, string Field) : BoundExpression(Tokens, Type); + +public record BoundTraitImplFuncAccess(IEnumerable Tokens, NubType Type, BoundExpression Target, string FuncName) : BoundExpression(Tokens, Type); + +public record BoundTraitFuncAccess(IEnumerable Tokens, NubType Type, NubCustomType TraitType, BoundExpression Target, string FuncName) : BoundExpression(Tokens, Type); + +public record BoundStructInitializer(IEnumerable Tokens, NubType Type, NubCustomType StructType, Dictionary Initializers) : BoundExpression(Tokens, Type); + +public record BoundDereference(IEnumerable Tokens, NubType Type, BoundExpression Expression) : BoundExpression(Tokens, Type); \ No newline at end of file diff --git a/src/compiler/NubLang/Syntax/Binding/Node/Statement.cs b/src/compiler/NubLang/Syntax/Binding/Node/Statement.cs new file mode 100644 index 0000000..cb526d6 --- /dev/null +++ b/src/compiler/NubLang/Syntax/Binding/Node/Statement.cs @@ -0,0 +1,22 @@ +using Common; +using NubLang.Syntax.Tokenization; + +namespace NubLang.Syntax.Binding.Node; + +public record BoundStatement(IEnumerable Tokens) : BoundNode(Tokens); + +public record BoundStatementExpression(IEnumerable Tokens, BoundExpression Expression) : BoundStatement(Tokens); + +public record BoundReturn(IEnumerable Tokens, Optional Value) : BoundStatement(Tokens); + +public record BoundAssignment(IEnumerable Tokens, BoundExpression Target, BoundExpression Value) : BoundStatement(Tokens); + +public record BoundIf(IEnumerable Tokens, BoundExpression Condition, BoundBlock Body, Optional> Else) : BoundStatement(Tokens); + +public record BoundVariableDeclaration(IEnumerable Tokens, string Name, Optional Assignment, NubType Type) : BoundStatement(Tokens); + +public record BoundContinue(IEnumerable Tokens) : BoundStatement(Tokens); + +public record BoundBreak(IEnumerable Tokens) : BoundStatement(Tokens); + +public record BoundWhile(IEnumerable Tokens, BoundExpression Condition, BoundBlock Body) : BoundStatement(Tokens); \ No newline at end of file diff --git a/src/compiler/NubLang/Syntax/Node/SyntaxTree.cs b/src/compiler/NubLang/Syntax/Binding/Node/SyntaxTree.cs similarity index 64% rename from src/compiler/NubLang/Syntax/Node/SyntaxTree.cs rename to src/compiler/NubLang/Syntax/Binding/Node/SyntaxTree.cs index 614ba8c..1ceb66a 100644 --- a/src/compiler/NubLang/Syntax/Node/SyntaxTree.cs +++ b/src/compiler/NubLang/Syntax/Binding/Node/SyntaxTree.cs @@ -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 Definitions, IEnumerable Diagnostics); +public record BoundSyntaxTree(string Namespace, IEnumerable Definitions, IEnumerable Diagnostics); public abstract record BoundNode(IEnumerable Tokens); -public record BoundBlock(IEnumerable Tokens, List Statements) : BoundNode(Tokens); \ No newline at end of file +public record BoundBlock(IEnumerable Tokens, List Statements) : BoundNode(Tokens); \ No newline at end of file diff --git a/src/compiler/NubLang/Syntax/Node/Definition.cs b/src/compiler/NubLang/Syntax/Node/Definition.cs deleted file mode 100644 index 0fa80bf..0000000 --- a/src/compiler/NubLang/Syntax/Node/Definition.cs +++ /dev/null @@ -1,26 +0,0 @@ -using Common; -using NubLang.Syntax.Tokenization; - -namespace NubLang.Syntax.Node; - -public abstract record BoundDefinitionNode(IEnumerable Tokens, string Namespace) : BoundNode(Tokens); - -public abstract record BoundDefinitionMemberNode(IEnumerable Tokens) : BoundNode(Tokens); - -public record BoundFuncParameterNode(IEnumerable Tokens, string Name, NubType Type) : BoundDefinitionMemberNode(Tokens); - -public record BoundLocalFuncNode(IEnumerable Tokens, string Namespace, string Name, List Parameters, BoundBlock Body, NubType ReturnType, bool Exported) : BoundDefinitionNode(Tokens, Namespace); - -public record BoundExternFuncNode(IEnumerable Tokens, string Namespace, string Name, string CallName, List Parameters, NubType ReturnType) : BoundDefinitionNode(Tokens, Namespace); - -public record BoundStructFieldNode(IEnumerable Tokens, int Index, string Name, NubType Type, Optional Value) : BoundDefinitionMemberNode(Tokens); - -public record BoundStructNode(IEnumerable Tokens, string Namespace, string Name, List Fields) : BoundDefinitionNode(Tokens, Namespace); - -public record BoundTraitFuncNode(IEnumerable Tokens, string Name, List Parameters, NubType ReturnType) : BoundDefinitionMemberNode(Tokens); - -public record BoundTraitNode(IEnumerable Tokens, string Namespace, string Name, List Functions) : BoundDefinitionNode(Tokens, Namespace); - -public record BoundTraitFuncImplNode(IEnumerable Tokens, string Name, List Parameters, NubType ReturnType, BoundBlock Body) : BoundDefinitionMemberNode(Tokens); - -public record BoundTraitImplNode(IEnumerable Tokens, string Namespace, NubType TraitType, NubType ForType, List Functions) : BoundDefinitionNode(Tokens, Namespace); \ No newline at end of file diff --git a/src/compiler/NubLang/Syntax/Node/Expression.cs b/src/compiler/NubLang/Syntax/Node/Expression.cs deleted file mode 100644 index 5c9a4c7..0000000 --- a/src/compiler/NubLang/Syntax/Node/Expression.cs +++ /dev/null @@ -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 Tokens, NubType Type) : BoundNode(Tokens); - -public record BoundBinaryExpressionNode(IEnumerable Tokens, NubType Type, BoundExpressionNode Left, BoundBinaryOperator Operator, BoundExpressionNode Right) : BoundExpressionNode(Tokens, Type); - -public record BoundUnaryExpressionNode(IEnumerable Tokens, NubType Type, BoundUnaryOperator Operator, BoundExpressionNode Operand) : BoundExpressionNode(Tokens, Type); - -public record BoundFuncCallNode(IEnumerable Tokens, NubType Type, BoundExpressionNode Expression, List Parameters) : BoundExpressionNode(Tokens, Type); - -public record BoundVariableIdentNode(IEnumerable Tokens, NubType Type, string Name) : BoundExpressionNode(Tokens, Type); - -public record BoundLocalFuncIdentNode(IEnumerable Tokens, NubType Type, string Namespace, string Name) : BoundExpressionNode(Tokens, Type); - -public record BoundExternFuncIdentNode(IEnumerable Tokens, NubType Type, string Namespace, string Name) : BoundExpressionNode(Tokens, Type); - -public record BoundArrayInitializerNode(IEnumerable Tokens, NubType Type, BoundExpressionNode Capacity, NubType ElementType) : BoundExpressionNode(Tokens, Type); - -public record BoundArrayIndexAccessNode(IEnumerable Tokens, NubType Type, BoundExpressionNode Target, BoundExpressionNode Index) : BoundExpressionNode(Tokens, Type); - -public record BoundAnonymousFuncNode(IEnumerable Tokens, NubType Type, List Parameters, BoundBlock Body, NubType ReturnType) : BoundExpressionNode(Tokens, Type); - -public record BoundAddressOfNode(IEnumerable Tokens, NubType Type, BoundExpressionNode Expression) : BoundExpressionNode(Tokens, Type); - -public record BoundLiteralNode(IEnumerable Tokens, NubType Type, string Literal, LiteralKind Kind) : BoundExpressionNode(Tokens, Type); - -public record BoundStructFieldAccessNode(IEnumerable Tokens, NubType Type, NubCustomType StructType, BoundExpressionNode Target, string Field) : BoundExpressionNode(Tokens, Type); - -public record BoundTraitImplFuncAccessNode(IEnumerable Tokens, NubType Type, BoundExpressionNode Target, string FuncName) : BoundExpressionNode(Tokens, Type); - -public record BoundTraitFuncAccessNode(IEnumerable Tokens, NubType Type, NubCustomType TraitType, BoundExpressionNode Target, string FuncName) : BoundExpressionNode(Tokens, Type); - -public record BoundStructInitializerNode(IEnumerable Tokens, NubType Type, NubCustomType StructType, Dictionary Initializers) : BoundExpressionNode(Tokens, Type); - -public record BoundDereferenceNode(IEnumerable Tokens, NubType Type, BoundExpressionNode Expression) : BoundExpressionNode(Tokens, Type); \ No newline at end of file diff --git a/src/compiler/NubLang/Syntax/Node/Statement.cs b/src/compiler/NubLang/Syntax/Node/Statement.cs deleted file mode 100644 index d72b982..0000000 --- a/src/compiler/NubLang/Syntax/Node/Statement.cs +++ /dev/null @@ -1,22 +0,0 @@ -using Common; -using NubLang.Syntax.Tokenization; - -namespace NubLang.Syntax.Node; - -public record BoundStatementNode(IEnumerable Tokens) : BoundNode(Tokens); - -public record BoundStatementExpressionNode(IEnumerable Tokens, BoundExpressionNode Expression) : BoundStatementNode(Tokens); - -public record BoundReturnNode(IEnumerable Tokens, Optional Value) : BoundStatementNode(Tokens); - -public record BoundAssignmentNode(IEnumerable Tokens, BoundExpressionNode Target, BoundExpressionNode Value) : BoundStatementNode(Tokens); - -public record BoundIfNode(IEnumerable Tokens, BoundExpressionNode Condition, BoundBlock Body, Optional> Else) : BoundStatementNode(Tokens); - -public record BoundVariableDeclarationNode(IEnumerable Tokens, string Name, Optional Assignment, NubType Type) : BoundStatementNode(Tokens); - -public record BoundContinueNode(IEnumerable Tokens) : BoundStatementNode(Tokens); - -public record BoundBreakNode(IEnumerable Tokens) : BoundStatementNode(Tokens); - -public record BoundWhileNode(IEnumerable Tokens, BoundExpressionNode Condition, BoundBlock Body) : BoundStatementNode(Tokens); \ No newline at end of file