nub31/nub-lang-archive
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-07 18:56:47 +02:00
parent fc46e1287f
commit 745720eeb3
15 changed files with 155 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
example/src/main.nub
View File

@@ -34,9 +34,7 @@ func main(args: []cstring): i64
// }
// human.print()
let x = 23
print_result(12, func(num) { return num == x })
print_result(12, func(num) { return num == 12 })
return 0
}

2
src/compiler/NubLang/Generation/QBE/QBEGenerator.Expression.cs
View File

@@ -238,7 +238,7 @@ public partial class QBEGenerator
private Val EmitVariableIdent(BoundVariableIdent variableIdent)
{
return _variables.Single(v => v.Name == variableIdent.Name).Val;
return Scope.Lookup(variableIdent.Name);
}
private Val EmitLiteral(BoundLiteral literal)

27
src/compiler/NubLang/Generation/QBE/QBEGenerator.Statement.cs
View File

@@ -47,31 +47,6 @@ public partial class QBEGenerator
EmitCopyIntoOrInitialize(assignment.Value, destination.Name);
}
private void EmitBlock(BoundBlock block, List<Variable>? variables = null)
{
_variableScopes.Push(_variables.Count);
if (variables != null)
{
foreach (var variable in variables)
{
_variables.Push(variable);
}
}
foreach (var statement in block.Statements.Where(_ => _codeIsReachable))
{
EmitStatement(statement);
}
var count = _variableScopes.Pop();
while (_variableScopes.Count > count)
{
_variableScopes.Pop();
}
_codeIsReachable = true;
}
private void EmitBreak()
{
_writer.Indented($"jmp {_breakLabels.Peek()}");
@@ -132,7 +107,7 @@ public partial class QBEGenerator
EmitStore(variableDeclaration.Assignment.Value.Type, value, name);
}
_variables.Push(new Variable(variableDeclaration.Name, new Val(name, variableDeclaration.Type, ValKind.Pointer)));
Scope.Declare(variableDeclaration.Name, new Val(name, variableDeclaration.Type, ValKind.Pointer));
}
private void EmitWhile(BoundWhile whileStatement)

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

@@ -12,14 +12,13 @@ public partial class QBEGenerator
private readonly BoundDefinitionTable _definitionTable;
private readonly QBEWriter _writer;
private List<CStringLiteral> _cStringLiterals = [];
private List<StringLiteral> _stringLiterals = [];
private Stack<string> _breakLabels = [];
private Stack<string> _continueLabels = [];
private Queue<(BoundAnonymousFunc Func, string Name)> _anonymousFunctions = [];
private Dictionary<BoundTraitFuncImpl, string> _implFunctions = [];
private Stack<Variable> _variables = [];
private Stack<int> _variableScopes = [];
private readonly List<CStringLiteral> _cStringLiterals = [];
private readonly List<StringLiteral> _stringLiterals = [];
private readonly Stack<string> _breakLabels = [];
private readonly Stack<string> _continueLabels = [];
private readonly Queue<(BoundAnonymousFunc Func, string Name)> _anonymousFunctions = [];
private readonly Dictionary<BoundTraitFuncImpl, string> _implFunctions = [];
private readonly Stack<Scope> _scopes = [];
private int _tmpIndex;
private int _labelIndex;
private int _anonymousFuncIndex;
@@ -28,6 +27,8 @@ public partial class QBEGenerator
private int _implFuncNameIndex;
private bool _codeIsReachable = true;
private Scope Scope => _scopes.Peek();
public QBEGenerator(BoundSyntaxTree syntaxTree, BoundDefinitionTable definitionTable, string file)
{
_syntaxTree = syntaxTree;
@@ -37,14 +38,13 @@ public partial class QBEGenerator
public string Emit()
{
_cStringLiterals = [];
_stringLiterals = [];
_breakLabels = [];
_continueLabels = [];
_anonymousFunctions = [];
_implFunctions = [];
_variables = [];
_variableScopes = [];
_cStringLiterals.Clear();
_stringLiterals.Clear();
_breakLabels.Clear();
_continueLabels.Clear();
_anonymousFunctions.Clear();
_implFunctions.Clear();
_scopes.Clear();
_tmpIndex = 0;
_labelIndex = 0;
_anonymousFuncIndex = 0;
@@ -347,18 +347,15 @@ public partial class QBEGenerator
return "l";
}
private void EmitFuncDefinition(string name, IEnumerable<BoundFuncParameter> parameters, NubType returnType, BoundBlock body)
private void EmitFuncDefinition(string name, IReadOnlyList<BoundFuncParameter> parameters, NubType returnType, BoundBlock body)
{
var parameterArray = parameters.ToArray();
_variables.Clear();
_variableScopes.Clear();
_labelIndex = 0;
_tmpIndex = 0;
var builder = new StringBuilder();
builder.Append("export function ");
if (returnType is not NubVoidType)
{
builder.Append(FuncQBETypeName(returnType) + ' ');
@@ -366,15 +363,16 @@ public partial class QBEGenerator
builder.Append(name);
var parameterStrings = parameterArray.Select(x => FuncQBETypeName(x.Type) + $" %{x.Name}");
builder.Append($"({string.Join(", ", parameterStrings)})");
builder.Append($"({string.Join(", ", parameters.Select(x => FuncQBETypeName(x.Type) + $" %{x.Name}"))})");
_writer.StartFunction(builder.ToString());
var parameterVars = parameterArray.Select(parameter => new Variable(parameter.Name, new Val("%" + parameter.Name, parameter.Type, ValKind.Direct))).ToList();
var scope = new Scope();
EmitBlock(body, parameterVars);
foreach (var parameter in parameters)
{
scope.Declare(parameter.Name, new Val("%" + parameter.Name, parameter.Type, ValKind.Direct));
}
if (body.Statements.LastOrDefault() is not BoundReturn)
{
@@ -445,6 +443,20 @@ public partial class QBEGenerator
_writer.WriteLine("}");
}
private void EmitBlock(BoundBlock block, Scope? scope = null)
{
_scopes.Push(scope ?? Scope.SubScope());
foreach (var statement in block.Statements.Where(_ => _codeIsReachable))
{
EmitStatement(statement);
}
_scopes.Pop();
_codeIsReachable = true;
}
private string EmitUnwrap(Val val)
{
return val.Kind switch
@@ -525,29 +537,49 @@ public partial class QBEGenerator
#endregion
}
internal class StringLiteral(string value, string name)
public class StringLiteral(string value, string name)
{
public string Value { get; } = value;
public string Name { get; } = name;
}
internal class CStringLiteral(string value, string name)
public class CStringLiteral(string value, string name)
{
public string Value { get; } = value;
public string Name { get; } = name;
}
internal class Variable(string name, Val val)
public record Val(string Name, NubType Type, ValKind Kind, MethodCallContext? FuncCallContext = null);
public class Scope(Scope? parent = null)
{
public string Name { get; } = name;
public Val Val { get; } = val;
private readonly Dictionary<string, Val> _variables = [];
public Val Lookup(string name)
{
var variable = _variables.GetValueOrDefault(name);
if (variable != null)
{
return variable;
}
return parent?.Lookup(name) ?? throw new UnreachableException($"Variable '{name}' not found");
}
public void Declare(string name, Val value)
{
_variables.Add(name, value);
}
public Scope SubScope()
{
return new Scope(this);
}
}
internal record Val(string Name, NubType Type, ValKind Kind, MethodCallContext? FuncCallContext = null);
public record MethodCallContext(Val ThisArg);
internal record MethodCallContext(Val ThisArg);
internal enum ValKind
public enum ValKind
{
Pointer,
Direct,

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

@@ -586,7 +586,7 @@ public sealed class Binder
return new BoundBlock(node.Tokens, statements);
}
private BoundBlock BindFuncBody(BlockSyntax block, NubType returnType, IEnumerable<BoundFuncParameter> parameters)
private BoundBlock BindFuncBody(BlockSyntax block, NubType returnType, IReadOnlyList<BoundFuncParameter> parameters)
{
_funcReturnTypes.Push(returnType);

24
src/compiler/NubLang/Syntax/Binding/Node/BoundDefinition.cs
View File

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

34
src/compiler/NubLang/Syntax/Binding/Node/BoundExpression.cs
View File

@@ -22,36 +22,36 @@ public enum BoundBinaryOperator
Divide
}
public abstract record BoundExpression(IEnumerable<Token> Tokens, NubType Type) : BoundNode(Tokens);
public abstract record BoundExpression(IReadOnlyList<Token> Tokens, NubType Type) : BoundNode(Tokens);
public record BoundBinaryExpression(IEnumerable<Token> Tokens, NubType Type, BoundExpression Left, BoundBinaryOperator Operator, BoundExpression Right) : BoundExpression(Tokens, Type);
public record BoundBinaryExpression(IReadOnlyList<Token> Tokens, NubType Type, BoundExpression Left, BoundBinaryOperator Operator, BoundExpression Right) : BoundExpression(Tokens, Type);
public record BoundUnaryExpression(IEnumerable<Token> Tokens, NubType Type, BoundUnaryOperator Operator, BoundExpression Operand) : BoundExpression(Tokens, Type);
public record BoundUnaryExpression(IReadOnlyList<Token> Tokens, NubType Type, BoundUnaryOperator Operator, BoundExpression Operand) : BoundExpression(Tokens, Type);
public record BoundFuncCall(IEnumerable<Token> Tokens, NubType Type, BoundExpression Expression, List<BoundExpression> Parameters) : BoundExpression(Tokens, Type);
public record BoundFuncCall(IReadOnlyList<Token> Tokens, NubType Type, BoundExpression Expression, IReadOnlyList<BoundExpression> Parameters) : BoundExpression(Tokens, Type);
public record BoundVariableIdent(IEnumerable<Token> Tokens, NubType Type, string Name) : BoundExpression(Tokens, Type);
public record BoundVariableIdent(IReadOnlyList<Token> Tokens, NubType Type, string Name) : BoundExpression(Tokens, Type);
public record BoundLocalFuncIdent(IEnumerable<Token> Tokens, NubType Type, string Namespace, string Name) : BoundExpression(Tokens, Type);
public record BoundLocalFuncIdent(IReadOnlyList<Token> Tokens, NubType Type, string Namespace, string Name) : BoundExpression(Tokens, Type);
public record BoundExternFuncIdent(IEnumerable<Token> Tokens, NubType Type, string Namespace, string Name) : BoundExpression(Tokens, Type);
public record BoundExternFuncIdent(IReadOnlyList<Token> Tokens, NubType Type, string Namespace, string Name) : BoundExpression(Tokens, Type);
public record BoundArrayInitializer(IEnumerable<Token> Tokens, NubType Type, BoundExpression Capacity, NubType ElementType) : BoundExpression(Tokens, Type);
public record BoundArrayInitializer(IReadOnlyList<Token> Tokens, NubType Type, BoundExpression Capacity, NubType ElementType) : BoundExpression(Tokens, Type);
public record BoundArrayIndexAccess(IEnumerable<Token> Tokens, NubType Type, BoundExpression Target, BoundExpression Index) : BoundExpression(Tokens, Type);
public record BoundArrayIndexAccess(IReadOnlyList<Token> Tokens, NubType Type, BoundExpression Target, BoundExpression Index) : BoundExpression(Tokens, Type);
public record BoundAnonymousFunc(IEnumerable<Token> Tokens, NubType Type, IEnumerable<BoundFuncParameter> Parameters, NubType ReturnType, BoundBlock Body) : BoundExpression(Tokens, Type);
public record BoundAnonymousFunc(IReadOnlyList<Token> Tokens, NubType Type, IReadOnlyList<BoundFuncParameter> Parameters, NubType ReturnType, BoundBlock Body) : BoundExpression(Tokens, Type);
public record BoundAddressOf(IEnumerable<Token> Tokens, NubType Type, BoundExpression Expression) : BoundExpression(Tokens, Type);
public record BoundAddressOf(IReadOnlyList<Token> Tokens, NubType Type, BoundExpression Expression) : BoundExpression(Tokens, Type);
public record BoundLiteral(IEnumerable<Token> Tokens, NubType Type, string Literal, LiteralKind Kind) : BoundExpression(Tokens, Type);
public record BoundLiteral(IReadOnlyList<Token> Tokens, NubType Type, string Literal, LiteralKind Kind) : BoundExpression(Tokens, Type);
public record BoundStructFieldAccess(IEnumerable<Token> Tokens, NubType Type, NubCustomType StructType, BoundExpression Target, string Field) : BoundExpression(Tokens, Type);
public record BoundStructFieldAccess(IReadOnlyList<Token> Tokens, NubType Type, NubCustomType StructType, BoundExpression Target, string Field) : BoundExpression(Tokens, Type);
public record BoundTraitImplFuncAccess(IEnumerable<Token> Tokens, NubType Type, BoundExpression Target, string FuncName) : BoundExpression(Tokens, Type);
public record BoundTraitImplFuncAccess(IReadOnlyList<Token> Tokens, NubType Type, BoundExpression Target, string FuncName) : BoundExpression(Tokens, Type);
public record BoundTraitFuncAccess(IEnumerable<Token> Tokens, NubType Type, NubCustomType TraitType, BoundExpression Target, string FuncName) : BoundExpression(Tokens, Type);
public record BoundTraitFuncAccess(IReadOnlyList<Token> Tokens, NubType Type, NubCustomType TraitType, BoundExpression Target, string FuncName) : BoundExpression(Tokens, Type);
public record BoundStructInitializer(IEnumerable<Token> Tokens, NubType Type, NubCustomType StructType, Dictionary<string, BoundExpression> Initializers) : BoundExpression(Tokens, Type);
public record BoundStructInitializer(IReadOnlyList<Token> Tokens, NubType Type, NubCustomType StructType, Dictionary<string, BoundExpression> Initializers) : BoundExpression(Tokens, Type);
public record BoundDereference(IEnumerable<Token> Tokens, NubType Type, BoundExpression Expression) : BoundExpression(Tokens, Type);
public record BoundDereference(IReadOnlyList<Token> Tokens, NubType Type, BoundExpression Expression) : BoundExpression(Tokens, Type);

18
src/compiler/NubLang/Syntax/Binding/Node/BoundStatement.cs
View File

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

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

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

24
src/compiler/NubLang/Syntax/Parsing/Node/DefinitionSyntax.cs
View File

@@ -3,26 +3,26 @@ using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Parsing.Node;
public abstract record DefinitionSyntax(IEnumerable<Token> Tokens, string Namespace) : SyntaxNode(Tokens);
public abstract record DefinitionSyntax(IReadOnlyList<Token> Tokens, string Namespace) : SyntaxNode(Tokens);
public abstract record DefinitionMemberSyntax(IEnumerable<Token> Tokens) : SyntaxNode(Tokens);
public abstract record DefinitionMemberSyntax(IReadOnlyList<Token> Tokens) : SyntaxNode(Tokens);
public record FuncParameterSyntax(IEnumerable<Token> Tokens, string Name, NubType Type) : DefinitionMemberSyntax(Tokens);
public record FuncParameterSyntax(IReadOnlyList<Token> Tokens, string Name, NubType Type) : DefinitionMemberSyntax(Tokens);
public record FuncSignatureSyntax(IEnumerable<Token> Tokens, IEnumerable<FuncParameterSyntax> Parameters, NubType ReturnType) : DefinitionMemberSyntax(Tokens);
public record FuncSignatureSyntax(IReadOnlyList<Token> Tokens, IReadOnlyList<FuncParameterSyntax> Parameters, NubType ReturnType) : DefinitionMemberSyntax(Tokens);
public record LocalFuncSyntax(IEnumerable<Token> Tokens, string Namespace, string Name, FuncSignatureSyntax Signature, BlockSyntax Body) : DefinitionSyntax(Tokens, Namespace);
public record LocalFuncSyntax(IReadOnlyList<Token> Tokens, string Namespace, string Name, FuncSignatureSyntax Signature, BlockSyntax Body) : DefinitionSyntax(Tokens, Namespace);
public record ExternFuncSyntax(IEnumerable<Token> Tokens, string Namespace, string Name, string CallName, FuncSignatureSyntax Signature) : DefinitionSyntax(Tokens, Namespace);
public record ExternFuncSyntax(IReadOnlyList<Token> Tokens, string Namespace, string Name, string CallName, FuncSignatureSyntax Signature) : DefinitionSyntax(Tokens, Namespace);
public record StructFieldSyntax(IEnumerable<Token> Tokens, int Index, string Name, NubType Type, Optional<ExpressionSyntax> Value) : DefinitionMemberSyntax(Tokens);
public record StructFieldSyntax(IReadOnlyList<Token> Tokens, int Index, string Name, NubType Type, Optional<ExpressionSyntax> Value) : DefinitionMemberSyntax(Tokens);
public record StructSyntax(IEnumerable<Token> Tokens, string Namespace, string Name, List<StructFieldSyntax> Fields) : DefinitionSyntax(Tokens, Namespace);
public record StructSyntax(IReadOnlyList<Token> Tokens, string Namespace, string Name, IReadOnlyList<StructFieldSyntax> Fields) : DefinitionSyntax(Tokens, Namespace);
public record TraitFuncSyntax(IEnumerable<Token> Tokens, string Name, FuncSignatureSyntax Signature) : DefinitionMemberSyntax(Tokens);
public record TraitFuncSyntax(IReadOnlyList<Token> Tokens, string Name, FuncSignatureSyntax Signature) : DefinitionMemberSyntax(Tokens);
public record TraitSyntax(IEnumerable<Token> Tokens, string Namespace, string Name, List<TraitFuncSyntax> Functions) : DefinitionSyntax(Tokens, Namespace);
public record TraitSyntax(IReadOnlyList<Token> Tokens, string Namespace, string Name, IReadOnlyList<TraitFuncSyntax> Functions) : DefinitionSyntax(Tokens, Namespace);
public record TraitFuncImplSyntax(IEnumerable<Token> Tokens, string Name, FuncSignatureSyntax Signature, BlockSyntax Body) : DefinitionMemberSyntax(Tokens);
public record TraitFuncImplSyntax(IReadOnlyList<Token> Tokens, string Name, FuncSignatureSyntax Signature, BlockSyntax Body) : DefinitionMemberSyntax(Tokens);
public record TraitImplSyntax(IEnumerable<Token> Tokens, string Namespace, NubType TraitType, NubType ForType, List<TraitFuncImplSyntax> Functions) : DefinitionSyntax(Tokens, Namespace);
public record TraitImplSyntax(IReadOnlyList<Token> Tokens, string Namespace, NubType TraitType, NubType ForType, IReadOnlyList<TraitFuncImplSyntax> Functions) : DefinitionSyntax(Tokens, Namespace);

28
src/compiler/NubLang/Syntax/Parsing/Node/ExpressionSyntax.cs
View File

@@ -23,30 +23,30 @@ public enum BinaryOperator
Divide
}
public abstract record ExpressionSyntax(IEnumerable<Token> Tokens) : SyntaxNode(Tokens);
public abstract record ExpressionSyntax(IReadOnlyList<Token> Tokens) : SyntaxNode(Tokens);
public record BinaryExpressionSyntax(IEnumerable<Token> Tokens, ExpressionSyntax Left, BinaryOperator Operator, ExpressionSyntax Right) : ExpressionSyntax(Tokens);
public record BinaryExpressionSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Left, BinaryOperator Operator, ExpressionSyntax Right) : ExpressionSyntax(Tokens);
public record UnaryExpressionSyntax(IEnumerable<Token> Tokens, UnaryOperator Operator, ExpressionSyntax Operand) : ExpressionSyntax(Tokens);
public record UnaryExpressionSyntax(IReadOnlyList<Token> Tokens, UnaryOperator Operator, ExpressionSyntax Operand) : ExpressionSyntax(Tokens);
public record FuncCallSyntax(IEnumerable<Token> Tokens, ExpressionSyntax Expression, List<ExpressionSyntax> Parameters) : ExpressionSyntax(Tokens);
public record FuncCallSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Expression, IReadOnlyList<ExpressionSyntax> Parameters) : ExpressionSyntax(Tokens);
public record IdentifierSyntax(IEnumerable<Token> Tokens, Optional<string> Namespace, string Name) : ExpressionSyntax(Tokens);
public record IdentifierSyntax(IReadOnlyList<Token> Tokens, Optional<string> Namespace, string Name) : ExpressionSyntax(Tokens);
public record ArrayInitializerSyntax(IEnumerable<Token> Tokens, ExpressionSyntax Capacity, NubType ElementType) : ExpressionSyntax(Tokens);
public record ArrayInitializerSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Capacity, NubType ElementType) : ExpressionSyntax(Tokens);
public record ArrayIndexAccessSyntax(IEnumerable<Token> Tokens, ExpressionSyntax Target, ExpressionSyntax Index) : ExpressionSyntax(Tokens);
public record ArrayIndexAccessSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Target, ExpressionSyntax Index) : ExpressionSyntax(Tokens);
public record AnonymousFuncParameterSyntax(IEnumerable<Token> Tokens, string Name) : ExpressionSyntax(Tokens);
public record AnonymousFuncParameterSyntax(IReadOnlyList<Token> Tokens, string Name) : ExpressionSyntax(Tokens);
public record AnonymousFuncSyntax(IEnumerable<Token> Tokens, List<AnonymousFuncParameterSyntax> Parameters, BlockSyntax Body) : ExpressionSyntax(Tokens);
public record AnonymousFuncSyntax(IReadOnlyList<Token> Tokens, IReadOnlyList<AnonymousFuncParameterSyntax> Parameters, BlockSyntax Body) : ExpressionSyntax(Tokens);
public record AddressOfSyntax(IEnumerable<Token> Tokens, ExpressionSyntax Expression) : ExpressionSyntax(Tokens);
public record AddressOfSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Expression) : ExpressionSyntax(Tokens);
public record LiteralSyntax(IEnumerable<Token> Tokens, string Literal, LiteralKind Kind) : ExpressionSyntax(Tokens);
public record LiteralSyntax(IReadOnlyList<Token> Tokens, string Literal, LiteralKind Kind) : ExpressionSyntax(Tokens);
public record MemberAccessSyntax(IEnumerable<Token> Tokens, ExpressionSyntax Target, string Member) : ExpressionSyntax(Tokens);
public record MemberAccessSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Target, string Member) : ExpressionSyntax(Tokens);
public record StructInitializerSyntax(IEnumerable<Token> Tokens, NubType StructType, Dictionary<string, ExpressionSyntax> Initializers) : ExpressionSyntax(Tokens);
public record StructInitializerSyntax(IReadOnlyList<Token> Tokens, NubType StructType, Dictionary<string, ExpressionSyntax> Initializers) : ExpressionSyntax(Tokens);
public record DereferenceSyntax(IEnumerable<Token> Tokens, ExpressionSyntax Expression) : ExpressionSyntax(Tokens);
public record DereferenceSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Expression) : ExpressionSyntax(Tokens);

18
src/compiler/NubLang/Syntax/Parsing/Node/StatementSyntax.cs
View File

@@ -3,20 +3,20 @@ using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Parsing.Node;
public record StatementSyntax(IEnumerable<Token> Tokens) : SyntaxNode(Tokens);
public record StatementSyntax(IReadOnlyList<Token> Tokens) : SyntaxNode(Tokens);
public record StatementExpressionSyntax(IEnumerable<Token> Tokens, ExpressionSyntax Expression) : StatementSyntax(Tokens);
public record StatementExpressionSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Expression) : StatementSyntax(Tokens);
public record ReturnSyntax(IEnumerable<Token> Tokens, Optional<ExpressionSyntax> Value) : StatementSyntax(Tokens);
public record ReturnSyntax(IReadOnlyList<Token> Tokens, Optional<ExpressionSyntax> Value) : StatementSyntax(Tokens);
public record AssignmentSyntax(IEnumerable<Token> Tokens, ExpressionSyntax Target, ExpressionSyntax Value) : StatementSyntax(Tokens);
public record AssignmentSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Target, ExpressionSyntax Value) : StatementSyntax(Tokens);
public record IfSyntax(IEnumerable<Token> Tokens, ExpressionSyntax Condition, BlockSyntax Body, Optional<Variant<IfSyntax, BlockSyntax>> Else) : StatementSyntax(Tokens);
public record IfSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Condition, BlockSyntax Body, Optional<Variant<IfSyntax, BlockSyntax>> Else) : StatementSyntax(Tokens);
public record VariableDeclarationSyntax(IEnumerable<Token> Tokens, string Name, Optional<NubType> ExplicitType, Optional<ExpressionSyntax> Assignment) : StatementSyntax(Tokens);
public record VariableDeclarationSyntax(IReadOnlyList<Token> Tokens, string Name, Optional<NubType> ExplicitType, Optional<ExpressionSyntax> Assignment) : StatementSyntax(Tokens);
public record ContinueSyntax(IEnumerable<Token> Tokens) : StatementSyntax(Tokens);
public record ContinueSyntax(IReadOnlyList<Token> Tokens) : StatementSyntax(Tokens);
public record BreakSyntax(IEnumerable<Token> Tokens) : StatementSyntax(Tokens);
public record BreakSyntax(IReadOnlyList<Token> Tokens) : StatementSyntax(Tokens);
public record WhileSyntax(IEnumerable<Token> Tokens, ExpressionSyntax Condition, BlockSyntax Body) : StatementSyntax(Tokens);
public record WhileSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Condition, BlockSyntax Body) : StatementSyntax(Tokens);

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

@@ -3,8 +3,8 @@ using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Parsing.Node;
public record SyntaxTree(string Namespace, IEnumerable<DefinitionSyntax> Definitions, IEnumerable<Diagnostic> Diagnostics);
public record SyntaxTree(string Namespace, IReadOnlyList<DefinitionSyntax> Definitions, IReadOnlyList<Diagnostic> Diagnostics);
public abstract record SyntaxNode(IEnumerable<Token> Tokens);
public abstract record SyntaxNode(IReadOnlyList<Token> Tokens);
public record BlockSyntax(IEnumerable<Token> Tokens, IEnumerable<StatementSyntax> Statements) : SyntaxNode(Tokens);
public record BlockSyntax(IReadOnlyList<Token> Tokens, IReadOnlyList<StatementSyntax> Statements) : SyntaxNode(Tokens);

8
src/compiler/NubLang/Syntax/Parsing/Parser.cs
View File

@@ -9,12 +9,12 @@ namespace NubLang.Syntax.Parsing;
public sealed class Parser
{
private string _namespace;
private readonly IEnumerable<Token> _tokens;
private readonly IReadOnlyList<Token> _tokens;
private readonly List<Diagnostic> _diagnostics = [];
private int _tokenIndex;
public Parser(IEnumerable<Token> tokens)
public Parser(IReadOnlyList<Token> tokens)
{
_namespace = "default";
_tokens = tokens;
@@ -815,9 +815,9 @@ public sealed class Parser
_tokenIndex++;
}
private IEnumerable<Token> GetTokens(int startIndex)
private List<Token> GetTokens(int startIndex)
{
return _tokens.Skip(startIndex).Take(Math.Min(_tokenIndex, _tokens.Count() - 1) - startIndex);
return _tokens.Skip(startIndex).Take(Math.Min(_tokenIndex, _tokens.Count() - 1) - startIndex).ToList();
}
}

2
src/compiler/NubLang/Syntax/Tokenization/Tokenizer.cs
View File

@@ -66,7 +66,7 @@ public sealed class Tokenizer
_sourceText = sourceText;
}
public IEnumerable<Token> Tokenize(out IEnumerable<Diagnostic> diagnostics)
public IReadOnlyList<Token> Tokenize(out IReadOnlyList<Diagnostic> diagnostics)
{
_index = 0;