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

...

Browse Source
This commit is contained in:
nub31
2025-07-02 18:58:28 +02:00
parent 6003fa2f51
commit a5e8ae9b8b
9 changed files with 91 additions and 274 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
example/src/main.nub
View File

@@ -1,6 +1,25 @@
namespace main
export func main(args: []cstring): i64 {
c::puts("test")
struct Human
{
name: cstring
age: i64
}
func test() {
}
export func main(args: []cstring): i64
{
let x: []cstring
x = [2]cstring
x[0] = "test1"
x[1] = "test2"
c::puts(x[1])
return 0
}

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

@@ -12,6 +12,7 @@ const string BIN_DIR = "bin";
const string INT_DIR = "bin-int";
var INT_BUILTIN_DIR = Path.Join(INT_DIR, "builtin");
var INT_OBJECT_DIR = Path.Join(INT_DIR, "obj");
var INT_DEBUG_DIR = Path.Join(INT_DIR, "debug");
if (Directory.Exists(INT_DIR))
{
@@ -21,6 +22,7 @@ if (Directory.Exists(INT_DIR))
Directory.CreateDirectory(BIN_DIR);
Directory.CreateDirectory(INT_BUILTIN_DIR);
Directory.CreateDirectory(INT_OBJECT_DIR);
Directory.CreateDirectory(INT_DEBUG_DIR);
var options = new Options();
@@ -116,14 +118,20 @@ var objectFiles = new List<string>();
foreach (var file in options.Files)
{
var outFileName = $"{HexString.CreateUnique(8)}_{Path.GetFileNameWithoutExtension(file)}";
var ssa = QBEGenerator.Emit(boundSyntaxTrees[file], boundDefinitionTable);
File.WriteAllText(Path.Join(INT_DEBUG_DIR, $"{outFileName}.ssa"), ssa);
var asm = await QBE.Invoke(ssa);
if (asm == null)
{
return 1;
}
var fileName = Path.Join(INT_OBJECT_DIR, $"{HexString.CreateUnique(8)}_{Path.GetFileNameWithoutExtension(file)}.o");
File.WriteAllText(Path.Join(INT_DEBUG_DIR, $"{outFileName}.s"), asm);
var fileName = Path.Join(INT_OBJECT_DIR, $"{outFileName}.o");
var asmSuccess = await GCC.Assemble(asm, fileName);
if (!asmSuccess)
{

162
src/compiler/Generation/QBE/QBEGenerator.cs
View File

@@ -477,8 +477,8 @@ public static class QBEGenerator
{
switch (statement)
{
case BoundArrayIndexAssignmentNode arrayIndexAssignment:
EmitArrayIndexAssignment(arrayIndexAssignment);
case BoundAssignmentNode assignment:
EmitAssignment(assignment);
break;
case BoundBreakNode:
EmitBreak();
@@ -486,15 +486,9 @@ public static class QBEGenerator
case BoundContinueNode:
EmitContinue();
break;
case BoundDereferenceAssignmentNode dereferenceAssignment:
EmitDereferenceAssignment(dereferenceAssignment);
break;
case BoundIfNode ifStatement:
EmitIf(ifStatement);
break;
case BoundMemberAssignmentNode memberAssignment:
EmitMemberAssignment(memberAssignment);
break;
case BoundReturnNode @return:
EmitReturn(@return);
break;
@@ -504,9 +498,6 @@ public static class QBEGenerator
case BoundVariableDeclarationNode variableDeclaration:
EmitVariableDeclaration(variableDeclaration);
break;
case BoundVariableAssignmentNode variableAssignment:
EmitVariableAssignment(variableAssignment);
break;
case BoundWhileNode whileStatement:
EmitWhile(whileStatement);
break;
@@ -515,30 +506,16 @@ public static class QBEGenerator
}
}
private static void EmitArrayIndexAssignment(BoundArrayIndexAssignmentNode arrayIndexAssignment)
private static void EmitAssignment(BoundAssignmentNode assignment)
{
var array = EmitUnwrap(EmitExpression(arrayIndexAssignment.ArrayIndexAccess.Array));
var index = EmitUnwrap(EmitExpression(arrayIndexAssignment.ArrayIndexAccess.Index));
EmitArrayBoundsCheck(array, index);
var value = EmitUnwrap(EmitExpression(arrayIndexAssignment.Value));
var expression = EmitExpression(assignment.Expression);
if (expression.Kind != ValKind.Pointer)
{
throw new UnreachableException();
}
switch (arrayIndexAssignment.ArrayIndexAccess.Array.Type)
{
case NubArrayType arrayType:
{
var pointer = VarName();
_builder.AppendLine($" {pointer} =l mul {index}, {SizeOf(arrayType.ElementType)}");
_builder.AppendLine($" {pointer} =l add {pointer}, 8");
_builder.AppendLine($" {pointer} =l add {array}, {pointer}");
EmitCopy(arrayType.ElementType, value, pointer);
break;
}
default:
{
throw new ArgumentOutOfRangeException();
}
}
var value = EmitUnwrap(EmitExpression(assignment.Value));
EmitCopy(assignment.Value.Type, value, expression.Name);
}
private static void EmitBlock(BoundBlockNode block, List<Variable>? variables = null)
@@ -578,13 +555,6 @@ public static class QBEGenerator
_codeIsReachable = false;
}
private static void EmitDereferenceAssignment(BoundDereferenceAssignmentNode dereferenceAssignment)
{
var pointer = EmitUnwrap(EmitExpression(dereferenceAssignment.Dereference.Expression));
var value = EmitUnwrap(EmitExpression(dereferenceAssignment.Value));
EmitCopy(dereferenceAssignment.Value.Type, value, pointer);
}
private static void EmitIf(BoundIfNode ifStatement)
{
var trueLabel = LabelName();
@@ -609,24 +579,6 @@ public static class QBEGenerator
_builder.AppendLine(endLabel);
}
private static void EmitMemberAssignment(BoundMemberAssignmentNode memberAssignment)
{
var structType = memberAssignment.MemberAccess.Expression.Type as NubStructType;
Debug.Assert(structType != null);
var structDefinition = _definitionTable.LookupStruct(structType.Namespace, structType.Name).GetValue();
var offset = OffsetOf(structDefinition, memberAssignment.MemberAccess.Member);
var item = EmitUnwrap(EmitExpression(memberAssignment.MemberAccess.Expression));
var pointer = VarName();
_builder.AppendLine($" {pointer} =l add {item}, {offset}");
var value = EmitUnwrap(EmitExpression(memberAssignment.Value));
EmitCopy(memberAssignment.Value.Type, value, pointer);
}
private static void EmitReturn(BoundReturnNode @return)
{
if (@return.Value.HasValue)
@@ -647,13 +599,6 @@ public static class QBEGenerator
_variables.Push(new Variable(variableDeclaration.Name, new Val(tmp, variableDeclaration.Type, ValKind.Pointer)));
}
private static void EmitVariableAssignment(BoundVariableAssignmentNode variableAssignment)
{
var value = EmitUnwrap(EmitExpression(variableAssignment.Value));
var variable = _variables.Single(x => x.Name == variableAssignment.Identifier.Name);
EmitCopy(variableAssignment.Value.Type, value, variable.Val.Name);
}
private static void EmitWhile(BoundWhileNode whileStatement)
{
var conditionLabel = LabelName();
@@ -685,7 +630,6 @@ public static class QBEGenerator
BoundArrayInitializerNode arrayInitializer => EmitArrayInitializer(arrayInitializer),
BoundBinaryExpressionNode binaryExpression => EmitBinaryExpression(binaryExpression),
BoundDereferenceNode dereference => EmitDereference(dereference),
BoundFixedArrayInitializerNode fixedArrayInitializer => EmitFixedArrayInitializer(fixedArrayInitializer),
BoundFuncCallNode funcCallExpression => EmitFuncCall(funcCallExpression),
BoundIdentifierNode identifier => EmitIdentifier(identifier),
BoundLiteralNode literal => EmitLiteral(literal),
@@ -703,31 +647,18 @@ public static class QBEGenerator
return new Val(name, anonymousFunc.Type, ValKind.Func);
}
private static string EmitArrayIndexPointer(BoundArrayIndexAccessNode arrayIndexAccess)
private static Val EmitArrayIndexAccess(BoundArrayIndexAccessNode arrayIndexAccess)
{
var array = EmitUnwrap(EmitExpression(arrayIndexAccess.Array));
var index = EmitUnwrap(EmitExpression(arrayIndexAccess.Index));
EmitArrayBoundsCheck(array, index);
var elementType = arrayIndexAccess.Array.Type switch
{
NubArrayType arrayType => arrayType.ElementType,
_ => throw new ArgumentOutOfRangeException()
};
var elementType = ((NubArrayType)arrayIndexAccess.Array.Type).ElementType;
var pointer = VarName();
_builder.AppendLine($" {pointer} =l mul {index}, {SizeOf(elementType)}");
_builder.AppendLine($" {pointer} =l add {pointer}, 8");
_builder.AppendLine($" {pointer} =l add {array}, {pointer}");
return pointer;
}
private static Val EmitArrayIndexAccess(BoundArrayIndexAccessNode arrayIndexAccess)
{
var pointer = EmitArrayIndexPointer(arrayIndexAccess);
var outputName = VarName();
_builder.AppendLine($" {outputName} {QBEAssign(arrayIndexAccess.Type)} {QBELoad(arrayIndexAccess.Type)} {pointer}");
return new Val(outputName, arrayIndexAccess.Type, ValKind.Immediate);
return new Val(pointer, arrayIndexAccess.Type, ValKind.Pointer);
}
private static void EmitArrayBoundsCheck(string array, string index)
@@ -785,31 +716,13 @@ public static class QBEGenerator
private static Val EmitAddressOf(BoundAddressOfNode addressOf)
{
switch (addressOf.Expression)
var value = EmitExpression(addressOf.Expression);
if (value.Kind != ValKind.Pointer)
{
case BoundArrayIndexAccessNode arrayIndexAccess:
{
var pointer = EmitArrayIndexPointer(arrayIndexAccess);
return new Val(pointer, addressOf.Type, ValKind.Immediate);
}
case BoundDereferenceNode dereference:
{
return EmitExpression(dereference.Expression);
}
case BoundIdentifierNode identifier:
{
if (identifier.Namespace.HasValue)
{
throw new NotSupportedException("There is nothing to address in another namespace");
throw new UnreachableException();
}
return _variables.Single(x => x.Name == identifier.Name).Val;
}
default:
{
throw new ArgumentOutOfRangeException();
}
}
return value;
}
private static Val EmitBinaryExpression(BoundBinaryExpressionNode binaryExpression)
@@ -1217,19 +1130,27 @@ public static class QBEGenerator
if (memberAccess.Member == "count")
{
_builder.AppendLine($" {output} =l loadl {item}");
break;
return new Val(output, memberAccess.Type, ValKind.Immediate);
}
throw new UnreachableException();
break;
}
case NubStringType:
{
if (memberAccess.Member == "count")
{
_builder.AppendLine($" {output} =l call $nub_string_length(l {item})");
return new Val(output, memberAccess.Type, ValKind.Immediate);
}
break;
}
case NubCStringType:
{
if (memberAccess.Member == "count")
{
_builder.AppendLine($" {output} =l call $nub_cstring_length(l {item})");
return new Val(output, memberAccess.Type, ValKind.Immediate);
}
break;
}
case NubStructType structType:
@@ -1237,35 +1158,12 @@ public static class QBEGenerator
var structDefinition = _definitionTable.LookupStruct(structType.Namespace, structType.Name).GetValue();
var offset = OffsetOf(structDefinition, memberAccess.Member);
var offsetName = VarName();
_builder.AppendLine($" {offsetName} =l add {item}, {offset}");
_builder.AppendLine($" {output} {QBEAssign(memberAccess.Type)} {QBELoad(memberAccess.Type)} {item}");
break;
}
default:
{
throw new ArgumentOutOfRangeException();
_builder.AppendLine($" {output} =l add {item}, {offset}");
return new Val(output, memberAccess.Type, ValKind.Pointer);
}
}
return new Val(output, memberAccess.Type, ValKind.Immediate);
}
private static Val EmitFixedArrayInitializer(BoundFixedArrayInitializerNode fixedArrayInitializer)
{
var totalSize = SizeOf(fixedArrayInitializer.Type);
var outputName = VarName();
_builder.AppendLine($" {outputName} =l alloc8 {totalSize}");
_builder.AppendLine($" storel {fixedArrayInitializer.Capacity}, {outputName}");
var dataPtr = VarName();
_builder.AppendLine($" {dataPtr} =l add {outputName}, 8");
var dataSize = totalSize - 8;
_builder.AppendLine($" call $nub_memset(l {dataPtr}, w 0, l {dataSize})");
return new Val(outputName, fixedArrayInitializer.Type, ValKind.Immediate);
throw new UnreachableException();
}
private static Val EmitFuncCall(BoundFuncCallNode funcCall)

10
src/compiler/Syntax/Parsing/Node/Expression.cs
View File

@@ -5,7 +5,6 @@ using Syntax.Typing;
namespace Syntax.Parsing.Node;
public abstract record ExpressionNode(IEnumerable<Token> Tokens) : Node(Tokens);
public abstract record LValueNode(IEnumerable<Token> Tokens) : ExpressionNode(Tokens);
public record BinaryExpressionNode(IEnumerable<Token> Tokens, ExpressionNode Left, BinaryExpressionOperator Operator, ExpressionNode Right) : ExpressionNode(Tokens);
@@ -32,13 +31,12 @@ public enum UnaryExpressionOperator
}
public record FuncCallNode(IEnumerable<Token> Tokens, ExpressionNode Expression, List<ExpressionNode> Parameters) : ExpressionNode(Tokens);
public record IdentifierNode(IEnumerable<Token> Tokens, Optional<string> Namespace, string Name) : LValueNode(Tokens);
public record IdentifierNode(IEnumerable<Token> Tokens, Optional<string> Namespace, string Name) : ExpressionNode(Tokens);
public record ArrayInitializerNode(IEnumerable<Token> Tokens, ExpressionNode Capacity, NubType ElementType) : ExpressionNode(Tokens);
public record ArrayIndexAccessNode(IEnumerable<Token> Tokens, ExpressionNode Array, ExpressionNode Index) : LValueNode(Tokens);
public record ArrayIndexAccessNode(IEnumerable<Token> Tokens, ExpressionNode Array, ExpressionNode Index) : ExpressionNode(Tokens);
public record AnonymousFuncNode(IEnumerable<Token> Tokens, List<FuncParameter> Parameters, BlockNode Body, NubType ReturnType) : ExpressionNode(Tokens);
public record AddressOfNode(IEnumerable<Token> Tokens, LValueNode Expression) : ExpressionNode(Tokens);
public record FixedArrayInitializerNode(IEnumerable<Token> Tokens, NubType ElementType, int Capacity) : ExpressionNode(Tokens);
public record AddressOfNode(IEnumerable<Token> Tokens, ExpressionNode Expression) : ExpressionNode(Tokens);
public record LiteralNode(IEnumerable<Token> Tokens, string Literal, LiteralKind Kind) : ExpressionNode(Tokens);
public record MemberAccessNode(IEnumerable<Token> Tokens, ExpressionNode Expression, string Member) : ExpressionNode(Tokens);
public record StructInitializerNode(IEnumerable<Token> Tokens, NubStructType StructType, Dictionary<string, ExpressionNode> Initializers) : ExpressionNode(Tokens);
public record DereferenceNode(IEnumerable<Token> Tokens, ExpressionNode Expression) : LValueNode(Tokens);
public record DereferenceNode(IEnumerable<Token> Tokens, ExpressionNode Expression) : ExpressionNode(Tokens);

5
src/compiler/Syntax/Parsing/Node/Statement.cs
View File

@@ -7,12 +7,9 @@ namespace Syntax.Parsing.Node;
public record StatementNode(IEnumerable<Token> Tokens) : Node(Tokens);
public record StatementExpressionNode(IEnumerable<Token> Tokens, ExpressionNode Expression) : StatementNode(Tokens);
public record ReturnNode(IEnumerable<Token> Tokens, Optional<ExpressionNode> Value) : StatementNode(Tokens);
public record MemberAssignmentNode(IEnumerable<Token> Tokens, MemberAccessNode MemberAccess, ExpressionNode Value) : StatementNode(Tokens);
public record AssignmentNode(IEnumerable<Token> Tokens, ExpressionNode Expression, ExpressionNode Value) : StatementNode(Tokens);
public record IfNode(IEnumerable<Token> Tokens, ExpressionNode Condition, BlockNode Body, Optional<Variant<IfNode, BlockNode>> Else) : StatementNode(Tokens);
public record DereferenceAssignmentNode(IEnumerable<Token> Tokens, DereferenceNode Dereference, ExpressionNode Value) : StatementNode(Tokens);
public record VariableAssignmentNode(IEnumerable<Token> Tokens, IdentifierNode Identifier, ExpressionNode Value) : StatementNode(Tokens);
public record VariableDeclarationNode(IEnumerable<Token> Tokens, string Name, NubType Type) : StatementNode(Tokens);
public record ContinueNode(IEnumerable<Token> Tokens) : StatementNode(Tokens);
public record BreakNode(IEnumerable<Token> Tokens) : StatementNode(Tokens);
public record ArrayIndexAssignmentNode(IEnumerable<Token> Tokens, ArrayIndexAccessNode ArrayIndexAccess, ExpressionNode Value) : StatementNode(Tokens);
public record WhileNode(IEnumerable<Token> Tokens, ExpressionNode Condition, BlockNode Body) : StatementNode(Tokens);

85
src/compiler/Syntax/Parsing/Parser.cs
View File

@@ -222,46 +222,10 @@ public static class Parser
{
var expr = ParseExpression();
if (Peek().TryGetValue(out var token))
if (TryExpectSymbol(Symbol.Assign))
{
if (token is SymbolToken symbol)
{
switch (symbol.Symbol)
{
case Symbol.Assign:
{
switch (expr)
{
case MemberAccessNode memberAccess:
{
Next();
var value = ParseExpression();
return new MemberAssignmentNode(GetTokensForNode(startIndex), memberAccess, value);
}
case ArrayIndexAccessNode arrayIndexAccess:
{
Next();
var value = ParseExpression();
return new ArrayIndexAssignmentNode(GetTokensForNode(startIndex), arrayIndexAccess, value);
}
case IdentifierNode identifier:
{
Next();
var value = ParseExpression();
return new VariableAssignmentNode(GetTokensForNode(startIndex), identifier, value);
}
case DereferenceNode dereference:
{
Next();
var value = ParseExpression();
return new DereferenceAssignmentNode(GetTokensForNode(startIndex), dereference, value);
}
}
break;
}
}
}
return new AssignmentNode(GetTokensForNode(startIndex), expr, value);
}
return new StatementExpressionNode(GetTokensForNode(startIndex), expr);
@@ -471,20 +435,6 @@ public static class Parser
expr = expression;
break;
}
case Symbol.Ampersand:
{
var expression = ParsePrimaryExpression();
if (expression is not LValueNode lValue)
{
throw new ParseException(Diagnostic
.Error("& symbol can only be used on lvalues")
.At(expression)
.Build());
}
expr = new AddressOfNode(GetTokensForNode(startIndex), lValue);
break;
}
case Symbol.Minus:
{
var expression = ParsePrimaryExpression();
@@ -498,36 +448,11 @@ public static class Parser
break;
}
case Symbol.OpenBracket:
{
if (Peek().TryGetValue(out var capacityToken) && capacityToken is LiteralToken { Kind: LiteralKind.Integer } literalToken)
{
var capacity = int.Parse(literalToken.Value);
Next();
ExpectSymbol(Symbol.CloseBracket);
var elementType = ParseType();
if (capacity > 0)
{
expr = new FixedArrayInitializerNode(GetTokensForNode(startIndex), elementType, capacity);
}
else
{
throw new ParseException(Diagnostic
.Error("Fixed array size must be a positive integer")
.WithHelp("Use a positive integer literal for the array size")
.At(literalToken)
.Build());
}
}
else
{
var capacity = ParseExpression();
ExpectSymbol(Symbol.CloseBracket);
var type = ParseType();
expr = new ArrayInitializerNode(GetTokensForNode(startIndex), capacity, type);
}
break;
}
case Symbol.Alloc:
@@ -583,6 +508,12 @@ public static class Parser
{
while (true)
{
if (TryExpectSymbol(Symbol.Ampersand))
{
expr = new AddressOfNode(GetTokensForNode(startIndex), expr);
break;
}
if (TryExpectSymbol(Symbol.Caret))
{
expr = new DereferenceNode(GetTokensForNode(startIndex), expr);

41
src/compiler/Syntax/Typing/Binder.cs
View File

@@ -124,26 +124,23 @@ public static class Binder
{
return node switch
{
ArrayIndexAssignmentNode statement => BindArrayIndex(statement),
AssignmentNode statement => BindAssignment(statement),
BreakNode statement => BindBreak(statement),
ContinueNode statement => BindContinue(statement),
DereferenceAssignmentNode statement => BindDereferenceAssignment(statement),
IfNode statement => BindIf(statement),
MemberAssignmentNode statement => BindMemberAssignment(statement),
ReturnNode statement => BindReturn(statement),
StatementExpressionNode statement => BindStatementExpression(statement),
VariableAssignmentNode statement => BindVariableAssignment(statement),
VariableDeclarationNode statement => BindVariableDeclaration(statement),
WhileNode statement => BindWhile(statement),
_ => throw new ArgumentOutOfRangeException(nameof(node))
};
}
private static BoundArrayIndexAssignmentNode BindArrayIndex(ArrayIndexAssignmentNode statement)
private static BoundStatementNode BindAssignment(AssignmentNode statement)
{
var boundArrayIndex = BindArrayIndexAccess(statement.ArrayIndexAccess);
var elementType = ((NubArrayType)boundArrayIndex.Type).ElementType;
return new BoundArrayIndexAssignmentNode(statement.Tokens, boundArrayIndex, BindExpression(statement.Value, elementType));
var expression = BindExpression(statement.Expression);
var value = BindExpression(statement.Value, expression.Type);
return new BoundAssignmentNode(statement.Tokens, expression, value);
}
private static BoundBreakNode BindBreak(BreakNode statement)
@@ -156,13 +153,6 @@ public static class Binder
return new BoundContinueNode(statement.Tokens);
}
private static BoundDereferenceAssignmentNode BindDereferenceAssignment(DereferenceAssignmentNode statement)
{
var boundDereference = BindDereference(statement.Dereference);
var dereferenceBaseType = ((NubPointerType)boundDereference.Type).BaseType;
return new BoundDereferenceAssignmentNode(statement.Tokens, boundDereference, BindExpression(statement.Value, dereferenceBaseType));
}
private static BoundIfNode BindIf(IfNode statement)
{
var elseStatement = Optional.Empty<Variant<BoundIfNode, BoundBlockNode>>();
@@ -179,13 +169,6 @@ public static class Binder
return new BoundIfNode(statement.Tokens, BindExpression(statement.Condition, NubPrimitiveType.Bool), BindBlock(statement.Body), elseStatement);
}
private static BoundMemberAssignmentNode BindMemberAssignment(MemberAssignmentNode statement)
{
var boundMemberAccess = BindMemberAccess(statement.MemberAccess);
var elementType = ((NubArrayType)boundMemberAccess.Type).ElementType;
return new BoundMemberAssignmentNode(statement.Tokens, boundMemberAccess, BindExpression(statement.Value, elementType));
}
private static BoundReturnNode BindReturn(ReturnNode statement)
{
var value = Optional.Empty<BoundExpressionNode>();
@@ -203,12 +186,6 @@ public static class Binder
return new BoundStatementExpressionNode(statement.Tokens, BindExpression(statement.Expression));
}
private static BoundVariableAssignmentNode BindVariableAssignment(VariableAssignmentNode statement)
{
var variableType = _variables[statement.Identifier.Name];
return new BoundVariableAssignmentNode(statement.Tokens, BindIdentifier(statement.Identifier), BindExpression(statement.Value, variableType));
}
private static BoundVariableDeclarationNode BindVariableDeclaration(VariableDeclarationNode statement)
{
_variables[statement.Name] = statement.Type;
@@ -230,7 +207,6 @@ public static class Binder
ArrayInitializerNode expression => BindArrayInitializer(expression),
BinaryExpressionNode expression => BindBinaryExpression(expression),
DereferenceNode expression => BindDereference(expression),
FixedArrayInitializerNode expression => BindFixedArrayInitializer(expression),
FuncCallNode expression => BindFuncCall(expression),
IdentifierNode expression => BindIdentifier(expression),
LiteralNode expression => BindLiteral(expression, expectedType),
@@ -243,7 +219,7 @@ public static class Binder
private static BoundAddressOfNode BindAddressOf(AddressOfNode expression)
{
var inner = (BoundLValueNode)BindExpression(expression.Expression);
var inner = BindExpression(expression.Expression);
return new BoundAddressOfNode(expression.Tokens, new NubPointerType(inner.Type), inner);
}
@@ -291,11 +267,6 @@ public static class Binder
return new BoundDereferenceNode(expression.Tokens, dereferencedType, boundExpression);
}
private static BoundFixedArrayInitializerNode BindFixedArrayInitializer(FixedArrayInitializerNode expression)
{
return new BoundFixedArrayInitializerNode(expression.Tokens, new NubArrayType(expression.ElementType), expression.ElementType, expression.Capacity);
}
private static BoundFuncCallNode BindFuncCall(FuncCallNode expression)
{
var boundExpression = BindExpression(expression.Expression);

10
src/compiler/Syntax/Typing/BoundNode/Expression.cs
View File

@@ -5,17 +5,15 @@ using Syntax.Tokenization;
namespace Syntax.Typing.BoundNode;
public abstract record BoundExpressionNode(IEnumerable<Token> Tokens, NubType Type) : BoundNode(Tokens);
public abstract record BoundLValueNode(IEnumerable<Token> Tokens, NubType Type) : BoundExpressionNode(Tokens, Type);
public record BoundBinaryExpressionNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Left, BinaryExpressionOperator Operator, BoundExpressionNode Right) : BoundExpressionNode(Tokens, Type);
public record BoundUnaryExpressionNode(IEnumerable<Token> Tokens, NubType Type, UnaryExpressionOperator Operator, BoundExpressionNode Operand) : BoundExpressionNode(Tokens, Type);
public record BoundFuncCallNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Expression, List<BoundExpressionNode> Parameters) : BoundExpressionNode(Tokens, Type);
public record BoundIdentifierNode(IEnumerable<Token> Tokens, NubType Type, Optional<string> Namespace, string Name) : BoundLValueNode(Tokens, Type);
public record BoundIdentifierNode(IEnumerable<Token> Tokens, NubType Type, Optional<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 Array, BoundExpressionNode Index) : BoundLValueNode(Tokens, Type);
public record BoundArrayIndexAccessNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Array, BoundExpressionNode Index) : BoundExpressionNode(Tokens, Type);
public record BoundAnonymousFuncNode(IEnumerable<Token> Tokens, NubType Type, List<BoundFuncParameter> Parameters, BoundBlockNode Body, NubType ReturnType) : BoundExpressionNode(Tokens, Type);
public record BoundAddressOfNode(IEnumerable<Token> Tokens, NubType Type, BoundLValueNode Expression) : BoundExpressionNode(Tokens, Type);
public record BoundFixedArrayInitializerNode(IEnumerable<Token> Tokens, NubType Type, NubType ElementType, int Capacity) : 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 BoundMemberAccessNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Expression, string Member) : BoundExpressionNode(Tokens, Type);
public record BoundStructInitializerNode(IEnumerable<Token> Tokens, NubType Type, NubStructType StructType, Dictionary<string, BoundExpressionNode> Initializers) : BoundExpressionNode(Tokens, Type);
public record BoundDereferenceNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Expression) : BoundLValueNode(Tokens, Type);
public record BoundDereferenceNode(IEnumerable<Token> Tokens, NubType Type, BoundExpressionNode Expression) : BoundExpressionNode(Tokens, Type);

5
src/compiler/Syntax/Typing/BoundNode/Statement.cs
View File

@@ -6,12 +6,9 @@ namespace Syntax.Typing.BoundNode;
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 BoundMemberAssignmentNode(IEnumerable<Token> Tokens, BoundMemberAccessNode MemberAccess, BoundExpressionNode Value) : BoundStatementNode(Tokens);
public record BoundAssignmentNode(IEnumerable<Token> Tokens, BoundExpressionNode Expression, BoundExpressionNode Value) : BoundStatementNode(Tokens);
public record BoundIfNode(IEnumerable<Token> Tokens, BoundExpressionNode Condition, BoundBlockNode Body, Optional<Variant<BoundIfNode, BoundBlockNode>> Else) : BoundStatementNode(Tokens);
public record BoundDereferenceAssignmentNode(IEnumerable<Token> Tokens, BoundDereferenceNode Dereference, BoundExpressionNode Value) : BoundStatementNode(Tokens);
public record BoundVariableAssignmentNode(IEnumerable<Token> Tokens, BoundIdentifierNode Identifier, BoundExpressionNode Value) : BoundStatementNode(Tokens);
public record BoundVariableDeclarationNode(IEnumerable<Token> Tokens, string Name, NubType Type) : BoundStatementNode(Tokens);
public record BoundContinueNode(IEnumerable<Token> Tokens) : BoundStatementNode(Tokens);
public record BoundBreakNode(IEnumerable<Token> Tokens) : BoundStatementNode(Tokens);
public record BoundArrayIndexAssignmentNode(IEnumerable<Token> Tokens, BoundArrayIndexAccessNode ArrayIndexAccess, BoundExpressionNode Value) : BoundStatementNode(Tokens);
public record BoundWhileNode(IEnumerable<Token> Tokens, BoundExpressionNode Condition, BoundBlockNode Body) : BoundStatementNode(Tokens);