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

Node -> none

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

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

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