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() // human.print()
let x = 23 print_result(12, func(num) { return num == 12 })
print_result(12, func(num) { return num == x })
return 0 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) private Val EmitVariableIdent(BoundVariableIdent variableIdent)
{ {
return _variables.Single(v => v.Name == variableIdent.Name).Val; return Scope.Lookup(variableIdent.Name);
} }
private Val EmitLiteral(BoundLiteral literal) 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); 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() private void EmitBreak()
{ {
_writer.Indented($"jmp {_breakLabels.Peek()}"); _writer.Indented($"jmp {_breakLabels.Peek()}");
@@ -132,7 +107,7 @@ public partial class QBEGenerator
EmitStore(variableDeclaration.Assignment.Value.Type, value, name); 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) private void EmitWhile(BoundWhile whileStatement)

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

@@ -12,14 +12,13 @@ public partial class QBEGenerator
private readonly BoundDefinitionTable _definitionTable; private readonly BoundDefinitionTable _definitionTable;
private readonly QBEWriter _writer; private readonly QBEWriter _writer;
private List<CStringLiteral> _cStringLiterals = []; private readonly List<CStringLiteral> _cStringLiterals = [];
private List<StringLiteral> _stringLiterals = []; private readonly List<StringLiteral> _stringLiterals = [];
private Stack<string> _breakLabels = []; private readonly Stack<string> _breakLabels = [];
private Stack<string> _continueLabels = []; private readonly Stack<string> _continueLabels = [];
private Queue<(BoundAnonymousFunc Func, string Name)> _anonymousFunctions = []; private readonly Queue<(BoundAnonymousFunc Func, string Name)> _anonymousFunctions = [];
private Dictionary<BoundTraitFuncImpl, string> _implFunctions = []; private readonly Dictionary<BoundTraitFuncImpl, string> _implFunctions = [];
private Stack<Variable> _variables = []; private readonly Stack<Scope> _scopes = [];
private Stack<int> _variableScopes = [];
private int _tmpIndex; private int _tmpIndex;
private int _labelIndex; private int _labelIndex;
private int _anonymousFuncIndex; private int _anonymousFuncIndex;
@@ -28,6 +27,8 @@ public partial class QBEGenerator
private int _implFuncNameIndex; private int _implFuncNameIndex;
private bool _codeIsReachable = true; private bool _codeIsReachable = true;
private Scope Scope => _scopes.Peek();
public QBEGenerator(BoundSyntaxTree syntaxTree, BoundDefinitionTable definitionTable, string file) public QBEGenerator(BoundSyntaxTree syntaxTree, BoundDefinitionTable definitionTable, string file)
{ {
_syntaxTree = syntaxTree; _syntaxTree = syntaxTree;
@@ -37,14 +38,13 @@ public partial class QBEGenerator
public string Emit() public string Emit()
{ {
_cStringLiterals = []; _cStringLiterals.Clear();
_stringLiterals = []; _stringLiterals.Clear();
_breakLabels = []; _breakLabels.Clear();
_continueLabels = []; _continueLabels.Clear();
_anonymousFunctions = []; _anonymousFunctions.Clear();
_implFunctions = []; _implFunctions.Clear();
_variables = []; _scopes.Clear();
_variableScopes = [];
_tmpIndex = 0; _tmpIndex = 0;
_labelIndex = 0; _labelIndex = 0;
_anonymousFuncIndex = 0; _anonymousFuncIndex = 0;
@@ -347,18 +347,15 @@ public partial class QBEGenerator
return "l"; 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; _labelIndex = 0;
_tmpIndex = 0; _tmpIndex = 0;
var builder = new StringBuilder(); var builder = new StringBuilder();
builder.Append("export function "); builder.Append("export function ");
if (returnType is not NubVoidType) if (returnType is not NubVoidType)
{ {
builder.Append(FuncQBETypeName(returnType) + ' '); builder.Append(FuncQBETypeName(returnType) + ' ');
@@ -366,15 +363,16 @@ public partial class QBEGenerator
builder.Append(name); builder.Append(name);
var parameterStrings = parameterArray.Select(x => FuncQBETypeName(x.Type) + $" %{x.Name}"); builder.Append($"({string.Join(", ", parameters.Select(x => FuncQBETypeName(x.Type) + $" %{x.Name}"))})");
builder.Append($"({string.Join(", ", parameterStrings)})");
_writer.StartFunction(builder.ToString()); _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) if (body.Statements.LastOrDefault() is not BoundReturn)
{ {
@@ -445,6 +443,20 @@ public partial class QBEGenerator
_writer.WriteLine("}"); _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) private string EmitUnwrap(Val val)
{ {
return val.Kind switch return val.Kind switch
@@ -525,29 +537,49 @@ public partial class QBEGenerator
#endregion #endregion
} }
internal class StringLiteral(string value, string name) public class StringLiteral(string value, string name)
{ {
public string Value { get; } = value; public string Value { get; } = value;
public string Name { get; } = name; 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 Value { get; } = value;
public string Name { get; } = name; 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; private readonly Dictionary<string, Val> _variables = [];
public Val Val { get; } = val;
public Val Lookup(string name)
{
var variable = _variables.GetValueOrDefault(name);
if (variable != null)
{
return variable;
} }
internal record Val(string Name, NubType Type, ValKind Kind, MethodCallContext? FuncCallContext = null); return parent?.Lookup(name) ?? throw new UnreachableException($"Variable '{name}' not found");
}
internal record MethodCallContext(Val ThisArg); public void Declare(string name, Val value)
{
_variables.Add(name, value);
}
internal enum ValKind public Scope SubScope()
{
return new Scope(this);
}
}
public record MethodCallContext(Val ThisArg);
public enum ValKind
{ {
Pointer, Pointer,
Direct, 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); 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); _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; 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 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; 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; 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; 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 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; 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; 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 public sealed class Parser
{ {
private string _namespace; private string _namespace;
private readonly IEnumerable<Token> _tokens; private readonly IReadOnlyList<Token> _tokens;
private readonly List<Diagnostic> _diagnostics = []; private readonly List<Diagnostic> _diagnostics = [];
private int _tokenIndex; private int _tokenIndex;
public Parser(IEnumerable<Token> tokens) public Parser(IReadOnlyList<Token> tokens)
{ {
_namespace = "default"; _namespace = "default";
_tokens = tokens; _tokens = tokens;
@@ -815,9 +815,9 @@ public sealed class Parser
_tokenIndex++; _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; _sourceText = sourceText;
} }
public IEnumerable<Token> Tokenize(out IEnumerable<Diagnostic> diagnostics) public IReadOnlyList<Token> Tokenize(out IReadOnlyList<Diagnostic> diagnostics)
{ {
_index = 0; _index = 0;