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-22 20:03:22 +02:00
parent be495ee337
commit 4581af2a24
17 changed files with 494 additions and 238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/compiler/NubLang.CLI/Program.cs
View File

@@ -7,6 +7,7 @@ using NubLang.Generation;
using NubLang.Generation.QBE;
using NubLang.Syntax.Binding;
using NubLang.Syntax.Binding.Node;
using NubLang.Syntax.Generics;
using NubLang.Syntax.Parsing;
using NubLang.Syntax.Parsing.Node;
using NubLang.Syntax.Tokenization;
@@ -67,7 +68,7 @@ for (var i = 0; i < args.Length; i++)
}
var diagnostics = new List<Diagnostic>();
var syntaxTrees = new Dictionary<string, ParseTree>();
var syntaxTrees = new Dictionary<string, SyntaxTree>();
foreach (var file in options.Files)
{
@@ -94,6 +95,9 @@ foreach (var file in options.Files)
syntaxTrees[file] = syntaxTree;
}
var genericInstantiator = new GenericInstantiator(syntaxTrees.Values);
genericInstantiator.Visit();
var definitionTable = new DefinitionTable(syntaxTrees.Values);
var boundSyntaxTrees = new Dictionary<string, BoundSyntaxTree>();

28
src/compiler/NubLang.Common/Variant.cs
View File

@@ -1,4 +1,6 @@
namespace NubLang.Common;
using System.Diagnostics.CodeAnalysis;
namespace NubLang.Common;
public readonly struct Variant<T1, T2> where T1 : notnull where T2 : notnull
{
@@ -44,6 +46,30 @@ public readonly struct Variant<T1, T2> where T1 : notnull where T2 : notnull
};
}
public bool IsCase1([NotNullWhen(true)] out T1? value)
{
if (_value is T1 converted)
{
value = converted;
return true;
}
value = default;
return false;
}
public bool IsCase2([NotNullWhen(true)] out T2? value)
{
if (_value is T2 converted)
{
value = converted;
return true;
}
value = default;
return false;
}
public static implicit operator Variant<T1, T2>(T1 value) => new(value);
public static implicit operator Variant<T1, T2>(T2 value) => new(value);
}

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

@@ -8,7 +8,7 @@ namespace NubLang.Syntax.Binding;
public sealed class Binder
{
private readonly ParseTree _parseTree;
private readonly SyntaxTree _syntaxTree;
private readonly DefinitionTable _definitionTable;
private readonly Stack<Scope> _scopes = [];
@@ -16,9 +16,9 @@ public sealed class Binder
private Scope Scope => _scopes.Peek();
public Binder(ParseTree parseTree, DefinitionTable definitionTable)
public Binder(SyntaxTree syntaxTree, DefinitionTable definitionTable)
{
_parseTree = parseTree;
_syntaxTree = syntaxTree;
_definitionTable = definitionTable;
}
@@ -30,7 +30,7 @@ public sealed class Binder
var diagnostics = new List<Diagnostic>();
var definitions = new List<BoundDefinition>();
foreach (var definition in _parseTree.Definitions)
foreach (var definition in _syntaxTree.Definitions)
{
try
{
@@ -42,7 +42,7 @@ public sealed class Binder
}
}
return new BoundSyntaxTree(_parseTree.Namespace, definitions, diagnostics);
return new BoundSyntaxTree(_syntaxTree.Namespace, definitions, diagnostics);
}
private BoundDefinition BindDefinition(DefinitionSyntax node)
@@ -309,7 +309,7 @@ public sealed class Binder
private BoundExpression BindIdentifier(IdentifierSyntax expression)
{
var @namespace = expression.Namespace.Or(_parseTree.Namespace);
var @namespace = expression.Namespace.Or(_syntaxTree.Namespace);
var localFuncs = _definitionTable.LookupLocalFunc(@namespace, expression.Name).ToArray();
if (localFuncs.Length > 0)
{

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

@@ -6,7 +6,7 @@ public class DefinitionTable
{
private readonly List<DefinitionSyntax> _definitions;
public DefinitionTable(IEnumerable<ParseTree> syntaxTrees)
public DefinitionTable(IEnumerable<SyntaxTree> syntaxTrees)
{
_definitions = syntaxTrees.SelectMany(x => x.Definitions).ToList();
}

67
src/compiler/NubLang/Syntax/Generics/GenericInstantiator.cs
View File

@@ -1,30 +1,77 @@
using NubLang.Syntax.Generics.Node;
using NubLang.Syntax.Parsing.Node;
namespace NubLang.Syntax.Generics;
public class GenericInstantiator
{
private readonly ParseTree _parseTree;
private readonly IEnumerable<SyntaxTree> _syntaxTrees;
private readonly Queue<GenericStructQueue> _structQueue = [];
public GenericInstantiator(ParseTree parseTree)
public GenericInstantiator(IEnumerable<SyntaxTree> syntaxTrees)
{
_parseTree = parseTree;
_syntaxTrees = syntaxTrees;
}
public UnboundTree Visit()
public IEnumerable<SyntaxTree> Visit()
{
var unboundDefinitions = new List<UnboundDefinition>();
_structQueue.Clear();
foreach (var definition in _parseTree.Definitions)
var syntaxTrees = new List<SyntaxTree>();
foreach (var syntaxTree in _syntaxTrees)
{
var definitions = new List<DefinitionSyntax>();
foreach (var definition in syntaxTree.Definitions)
{
if (definition.Parameters.Any())
{
switch (definition)
{
default:
throw new ArgumentOutOfRangeException(nameof(definition));
case StructSyntax structSyntax:
{
var usages = _syntaxTrees
.SelectMany(x => x.GetDescendants())
.OfType<CustomTypeSyntax>()
.Where(x => x.Namespace == structSyntax.Namespace)
.Where(x => x.Name == structSyntax.Name);
foreach (var usage in usages)
{
if (!_structQueue.Any(x => x.Type.Namespace == usage.Namespace && x.Type.Name == usage.Name))
{
_structQueue.Enqueue(new GenericStructQueue(structSyntax, usage, false));
}
}
return new UnboundTree(_parseTree.Namespace, unboundDefinitions, _parseTree.Diagnostics);
break;
}
default:
{
throw new ArgumentOutOfRangeException(nameof(definition));
}
}
}
else
{
definitions.Add(definition);
}
}
while (_structQueue.TryDequeue(out var item))
{
definitions.Add(new StructSyntax(item.Type.Tokens, item.Struct.Namespace, [], item.Type.MangledName(), item.Struct.Fields, item.Struct.Functions));
}
syntaxTrees.Add(new SyntaxTree(syntaxTree.Tokens, syntaxTree.Namespace, definitions, syntaxTree.Diagnostics));
}
return syntaxTrees;
}
}
public class GenericStructQueue(StructSyntax @struct, CustomTypeSyntax type, bool created)
{
public StructSyntax Struct { get; init; } = @struct;
public CustomTypeSyntax Type { get; init; } = type;
public bool Created { get; set; } = created;
}

26
src/compiler/NubLang/Syntax/Generics/Node/DefinitionSyntax.cs
View File

@@ -1,26 +0,0 @@
using NubLang.Common;
using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Generics.Node;
public record UnboundGenericParameter(IReadOnlyList<Token> Tokens, string Name) : UnboundNode(Tokens);
public abstract record UnboundDefinition(IReadOnlyList<Token> Tokens, string Namespace, IReadOnlyList<UnboundGenericParameter> Parameters) : UnboundNode(Tokens);
public record UnboundFuncParameter(IReadOnlyList<Token> Tokens, string Name, UnboundType Type) : UnboundNode(Tokens);
public record UnboundFuncSignature(IReadOnlyList<Token> Tokens, IReadOnlyList<UnboundFuncParameter> Parameters, UnboundType ReturnType) : UnboundNode(Tokens);
public record UnboundLocalFunc(IReadOnlyList<Token> Tokens, string Namespace, IReadOnlyList<UnboundGenericParameter> Parameters, string Name, UnboundFuncSignature Signature, UnboundBlock Body) : UnboundDefinition(Tokens, Namespace, Parameters);
public record UnboundExternFunc(IReadOnlyList<Token> Tokens, string Namespace, IReadOnlyList<UnboundGenericParameter> Parameters, string Name, string CallName, UnboundFuncSignature Signature) : UnboundDefinition(Tokens, Namespace, Parameters);
public record UnboundStructField(IReadOnlyList<Token> Tokens, int Index, string Name, UnboundType Type, Optional<UnboundExpression> Value) : UnboundNode(Tokens);
public record UnboundStructFunc(IReadOnlyList<Token> Tokens, string Name, UnboundFuncSignature Signature, UnboundBlock Body) : UnboundNode(Tokens);
public record UnboundStruct(IReadOnlyList<Token> Tokens, string Namespace, IReadOnlyList<UnboundGenericParameter> Parameters, string Name, IReadOnlyList<UnboundStructField> Fields, IReadOnlyList<UnboundStructFunc> Funcs) : UnboundDefinition(Tokens, Namespace, Parameters);
public record UnboundInterfaceFunc(IReadOnlyList<Token> Tokens, string Name, UnboundFuncSignature Signature) : UnboundNode(Tokens);
public record UnboundInterface(IReadOnlyList<Token> Tokens, string Namespace, IReadOnlyList<UnboundGenericParameter> Parameters, string Name, IReadOnlyList<UnboundInterfaceFunc> Functions) : UnboundDefinition(Tokens, Namespace, Parameters);

52
src/compiler/NubLang/Syntax/Generics/Node/ExpressionSyntax.cs
View File

@@ -1,52 +0,0 @@
using NubLang.Common;
using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Generics.Node;
public enum UnboundUnaryOperator
{
Negate,
Invert
}
public enum UnboundBinaryOperator
{
Equal,
NotEqual,
GreaterThan,
GreaterThanOrEqual,
LessThan,
LessThanOrEqual,
Plus,
Minus,
Multiply,
Divide
}
public abstract record UnboundExpression(IReadOnlyList<Token> Tokens) : UnboundNode(Tokens);
public record UnboundBinaryExpression(IReadOnlyList<Token> Tokens, UnboundExpression Left, UnboundBinaryOperator Operator, UnboundExpression Right) : UnboundExpression(Tokens);
public record UnboundUnaryExpression(IReadOnlyList<Token> Tokens, UnboundUnaryOperator Operator, UnboundExpression Operand) : UnboundExpression(Tokens);
public record UnboundFuncCall(IReadOnlyList<Token> Tokens, UnboundExpression Expression, IReadOnlyList<UnboundExpression> Parameters) : UnboundExpression(Tokens);
public record UnboundIdentifier(IReadOnlyList<Token> Tokens, Optional<string> Namespace, string Name) : UnboundExpression(Tokens);
public record UnboundArrayInitializer(IReadOnlyList<Token> Tokens, UnboundExpression Capacity, UnboundType ElementType) : UnboundExpression(Tokens);
public record UnboundArrayIndexAccess(IReadOnlyList<Token> Tokens, UnboundExpression Target, UnboundExpression Index) : UnboundExpression(Tokens);
public record UnboundArrowFuncParameter(IReadOnlyList<Token> Tokens, string Name) : UnboundExpression(Tokens);
public record UnboundArrowFunc(IReadOnlyList<Token> Tokens, IReadOnlyList<UnboundArrowFuncParameter> Parameters, UnboundBlock Body) : UnboundExpression(Tokens);
public record UnboundAddressOf(IReadOnlyList<Token> Tokens, UnboundExpression Expression) : UnboundExpression(Tokens);
public record UnboundLiteral(IReadOnlyList<Token> Tokens, string Value, LiteralKind Kind) : UnboundExpression(Tokens);
public record UnboundMemberAccess(IReadOnlyList<Token> Tokens, UnboundExpression Target, string Member) : UnboundExpression(Tokens);
public record UnboundStructInitializer(IReadOnlyList<Token> Tokens, UnboundType StructType, Dictionary<string, UnboundExpression> Initializers) : UnboundExpression(Tokens);
public record UnboundDereference(IReadOnlyList<Token> Tokens, UnboundExpression Expression) : UnboundExpression(Tokens);

22
src/compiler/NubLang/Syntax/Generics/Node/StatementSyntax.cs
View File

@@ -1,22 +0,0 @@
using NubLang.Common;
using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Generics.Node;
public record UnboundStatement(IReadOnlyList<Token> Tokens) : UnboundNode(Tokens);
public record UnboundStatementExpression(IReadOnlyList<Token> Tokens, UnboundExpression Expression) : UnboundStatement(Tokens);
public record UnboundReturn(IReadOnlyList<Token> Tokens, Optional<UnboundExpression> Value) : UnboundStatement(Tokens);
public record UnboundAssignment(IReadOnlyList<Token> Tokens, UnboundExpression Target, UnboundExpression Value) : UnboundStatement(Tokens);
public record UnboundIf(IReadOnlyList<Token> Tokens, UnboundExpression Condition, UnboundBlock Body, Optional<Variant<UnboundIf, UnboundBlock>> Else) : UnboundStatement(Tokens);
public record UnboundVariableDeclaration(IReadOnlyList<Token> Tokens, string Name, Optional<UnboundType> ExplicitType, Optional<UnboundExpression> Assignment) : UnboundStatement(Tokens);
public record UnboundContinue(IReadOnlyList<Token> Tokens) : UnboundStatement(Tokens);
public record UnboundBreak(IReadOnlyList<Token> Tokens) : UnboundStatement(Tokens);
public record UnboundWhile(IReadOnlyList<Token> Tokens, UnboundExpression Condition, UnboundBlock Body) : UnboundStatement(Tokens);

36
src/compiler/NubLang/Syntax/Generics/Node/TypeSyntax.cs
View File

@@ -1,36 +0,0 @@
using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Generics.Node;
public enum UnboundPrimitiveTypeKind
{
I64,
I32,
I16,
I8,
U64,
U32,
U16,
U8,
F64,
F32,
Bool
}
public abstract record UnboundType(IReadOnlyList<Token> Tokens) : UnboundNode(Tokens);
public record UnboundFuncType(IReadOnlyList<Token> Tokens, IReadOnlyList<UnboundType> Parameters, UnboundType ReturnType) : UnboundType(Tokens);
public record UnboundPointerType(IReadOnlyList<Token> Tokens, UnboundType BaseType) : UnboundType(Tokens);
public record UnboundVoidType(IReadOnlyList<Token> Tokens) : UnboundType(Tokens);
public record UnboundPrimitiveType(IReadOnlyList<Token> Tokens, UnboundPrimitiveTypeKind SyntaxKind) : UnboundType(Tokens);
public record UnboundCStringType(IReadOnlyList<Token> Tokens) : UnboundType(Tokens);
public record UnboundStringType(IReadOnlyList<Token> Tokens) : UnboundType(Tokens);
public record UnboundCustomType(IReadOnlyList<Token> Tokens, string Namespace, string Name, IReadOnlyList<UnboundType> Arguments) : UnboundType(Tokens);
public record UnboundArrayType(IReadOnlyList<Token> Tokens, UnboundType BaseType) : UnboundType(Tokens);

10
src/compiler/NubLang/Syntax/Generics/Node/UnboundTree.cs
View File

@@ -1,10 +0,0 @@
using NubLang.Diagnostics;
using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Generics.Node;
public record UnboundTree(string Namespace, IReadOnlyList<UnboundDefinition> Definitions, IReadOnlyList<Diagnostic> Diagnostics);
public abstract record UnboundNode(IReadOnlyList<Token> Tokens);
public record UnboundBlock(IReadOnlyList<Token> Tokens, IReadOnlyList<UnboundStatement> Statements) : UnboundNode(Tokens);

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

@@ -3,24 +3,123 @@ using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Parsing.Node;
public record GenericParameter(IReadOnlyList<Token> Tokens, string Name) : SyntaxNode(Tokens);
public record GenericParameter(IReadOnlyList<Token> Tokens, string Name) : SyntaxNode(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren() => [];
}
public abstract record DefinitionSyntax(IReadOnlyList<Token> Tokens, string Namespace, IReadOnlyList<GenericParameter> Parameters) : SyntaxNode(Tokens);
public record FuncParameterSyntax(IReadOnlyList<Token> Tokens, string Name, TypeSyntax Type) : SyntaxNode(Tokens);
public record FuncParameterSyntax(IReadOnlyList<Token> Tokens, string Name, TypeSyntax Type) : SyntaxNode(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
yield return Type;
}
}
public record FuncSignatureSyntax(IReadOnlyList<Token> Tokens, IReadOnlyList<FuncParameterSyntax> Parameters, TypeSyntax ReturnType) : SyntaxNode(Tokens);
public record FuncSignatureSyntax(IReadOnlyList<Token> Tokens, IReadOnlyList<FuncParameterSyntax> Parameters, TypeSyntax ReturnType) : SyntaxNode(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
foreach (var parameter in Parameters)
{
yield return parameter;
}
public record LocalFuncSyntax(IReadOnlyList<Token> Tokens, string Namespace, IReadOnlyList<GenericParameter> Parameters, string Name, FuncSignatureSyntax Signature, BlockSyntax Body) : DefinitionSyntax(Tokens, Namespace, Parameters);
yield return ReturnType;
}
}
public record ExternFuncSyntax(IReadOnlyList<Token> Tokens, string Namespace, IReadOnlyList<GenericParameter> Parameters, string Name, string CallName, FuncSignatureSyntax Signature) : DefinitionSyntax(Tokens, Namespace, Parameters);
public record LocalFuncSyntax(IReadOnlyList<Token> Tokens, string Namespace, IReadOnlyList<GenericParameter> Parameters, string Name, FuncSignatureSyntax Signature, BlockSyntax Body) : DefinitionSyntax(Tokens, Namespace, Parameters)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
foreach (var parameter in Parameters)
{
yield return parameter;
}
public record StructFieldSyntax(IReadOnlyList<Token> Tokens, int Index, string Name, TypeSyntax Type, Optional<ExpressionSyntax> Value) : SyntaxNode(Tokens);
yield return Signature;
yield return Body;
}
}
public record StructFuncSyntax(IReadOnlyList<Token> Tokens, string Name, FuncSignatureSyntax Signature, BlockSyntax Body) : SyntaxNode(Tokens);
public record ExternFuncSyntax(IReadOnlyList<Token> Tokens, string Namespace, IReadOnlyList<GenericParameter> Parameters, string Name, string CallName, FuncSignatureSyntax Signature) : DefinitionSyntax(Tokens, Namespace, Parameters)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
foreach (var parameter in Parameters)
{
yield return parameter;
}
public record StructSyntax(IReadOnlyList<Token> Tokens, string Namespace, IReadOnlyList<GenericParameter> Parameters, string Name, IReadOnlyList<StructFieldSyntax> Fields, IReadOnlyList<StructFuncSyntax> Funcs) : DefinitionSyntax(Tokens, Namespace, Parameters);
yield return Signature;
}
}
public record InterfaceFuncSyntax(IReadOnlyList<Token> Tokens, string Name, FuncSignatureSyntax Signature) : SyntaxNode(Tokens);
public record StructFieldSyntax(IReadOnlyList<Token> Tokens, int Index, string Name, TypeSyntax Type, Optional<ExpressionSyntax> Value) : SyntaxNode(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
yield return Type;
if (Value.HasValue)
{
yield return Value.Value;
}
}
}
public record InterfaceSyntax(IReadOnlyList<Token> Tokens, string Namespace, IReadOnlyList<GenericParameter> Parameters, string Name, IReadOnlyList<InterfaceFuncSyntax> Functions) : DefinitionSyntax(Tokens, Namespace, Parameters);
public record StructFuncSyntax(IReadOnlyList<Token> Tokens, string Name, FuncSignatureSyntax Signature, BlockSyntax Body) : SyntaxNode(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
yield return Signature;
yield return Body;
}
}
public record StructSyntax(IReadOnlyList<Token> Tokens, string Namespace, IReadOnlyList<GenericParameter> Parameters, string Name, IReadOnlyList<StructFieldSyntax> Fields, IReadOnlyList<StructFuncSyntax> Functions) : DefinitionSyntax(Tokens, Namespace, Parameters)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
foreach (var parameter in Parameters)
{
yield return parameter;
}
foreach (var field in Fields)
{
yield return field;
}
foreach (var func in Functions)
{
yield return func;
}
}
}
public record InterfaceFuncSyntax(IReadOnlyList<Token> Tokens, string Name, FuncSignatureSyntax Signature) : SyntaxNode(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
yield return Signature;
}
}
public record InterfaceSyntax(IReadOnlyList<Token> Tokens, string Namespace, IReadOnlyList<GenericParameter> Parameters, string Name, IReadOnlyList<InterfaceFuncSyntax> Functions) : DefinitionSyntax(Tokens, Namespace, Parameters)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
foreach (var parameter in Parameters)
{
yield return parameter;
}
foreach (var func in Functions)
{
yield return func;
}
}
}

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

@@ -25,28 +25,113 @@ public enum BinaryOperator
public abstract record ExpressionSyntax(IReadOnlyList<Token> Tokens) : SyntaxNode(Tokens);
public record BinaryExpressionSyntax(IReadOnlyList<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 override IEnumerable<SyntaxNode> GetChildren()
{
yield return Left;
yield return Right;
}
}
public record UnaryExpressionSyntax(IReadOnlyList<Token> Tokens, UnaryOperator Operator, ExpressionSyntax Operand) : ExpressionSyntax(Tokens);
public record UnaryExpressionSyntax(IReadOnlyList<Token> Tokens, UnaryOperator Operator, ExpressionSyntax Operand) : ExpressionSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
yield return Operand;
}
}
public record FuncCallSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Expression, IReadOnlyList<ExpressionSyntax> Parameters) : ExpressionSyntax(Tokens);
public record FuncCallSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Expression, IReadOnlyList<ExpressionSyntax> Parameters) : ExpressionSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
yield return Expression;
foreach (var parameter in Parameters)
{
yield return parameter;
}
}
}
public record IdentifierSyntax(IReadOnlyList<Token> Tokens, Optional<string> Namespace, string Name) : ExpressionSyntax(Tokens);
public record IdentifierSyntax(IReadOnlyList<Token> Tokens, Optional<string> Namespace, string Name) : ExpressionSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren() => [];
}
public record ArrayInitializerSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Capacity, TypeSyntax ElementType) : ExpressionSyntax(Tokens);
public record ArrayInitializerSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Capacity, TypeSyntax ElementType) : ExpressionSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
yield return Capacity;
yield return ElementType;
}
}
public record ArrayIndexAccessSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Target, ExpressionSyntax Index) : ExpressionSyntax(Tokens);
public record ArrayIndexAccessSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Target, ExpressionSyntax Index) : ExpressionSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
yield return Target;
yield return Index;
}
}
public record ArrowFuncParameterSyntax(IReadOnlyList<Token> Tokens, string Name) : ExpressionSyntax(Tokens);
public record ArrowFuncParameterSyntax(IReadOnlyList<Token> Tokens, string Name) : ExpressionSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren() => [];
}
public record ArrowFuncSyntax(IReadOnlyList<Token> Tokens, IReadOnlyList<ArrowFuncParameterSyntax> Parameters, BlockSyntax Body) : ExpressionSyntax(Tokens);
public record ArrowFuncSyntax(IReadOnlyList<Token> Tokens, IReadOnlyList<ArrowFuncParameterSyntax> Parameters, BlockSyntax Body) : ExpressionSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
foreach (var parameter in Parameters)
{
yield return parameter;
}
public record AddressOfSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Expression) : ExpressionSyntax(Tokens);
yield return Body;
}
}
public record LiteralSyntax(IReadOnlyList<Token> Tokens, string Value, LiteralKind Kind) : ExpressionSyntax(Tokens);
public record AddressOfSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Expression) : ExpressionSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
yield return Expression;
}
}
public record MemberAccessSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Target, string Member) : ExpressionSyntax(Tokens);
public record LiteralSyntax(IReadOnlyList<Token> Tokens, string Value, LiteralKind Kind) : ExpressionSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren() => [];
}
public record StructInitializerSyntax(IReadOnlyList<Token> Tokens, TypeSyntax StructType, Dictionary<string, ExpressionSyntax> Initializers) : ExpressionSyntax(Tokens);
public record MemberAccessSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Target, string Member) : ExpressionSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
yield return Target;
}
}
public record DereferenceSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Expression) : ExpressionSyntax(Tokens);
public record StructInitializerSyntax(IReadOnlyList<Token> Tokens, TypeSyntax StructType, Dictionary<string, ExpressionSyntax> Initializers) : ExpressionSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
yield return StructType;
foreach (var initializer in Initializers)
{
yield return initializer.Value;
}
}
}
public record DereferenceSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Expression) : ExpressionSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
yield return Expression;
}
}

10
src/compiler/NubLang/Syntax/Parsing/Node/ParseTree.cs
View File

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

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

@@ -3,20 +3,83 @@ using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Parsing.Node;
public record StatementSyntax(IReadOnlyList<Token> Tokens) : SyntaxNode(Tokens);
public abstract record StatementSyntax(IReadOnlyList<Token> Tokens) : SyntaxNode(Tokens);
public record StatementExpressionSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Expression) : StatementSyntax(Tokens);
public record StatementExpressionSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Expression) : StatementSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
yield return Expression;
}
}
public record ReturnSyntax(IReadOnlyList<Token> Tokens, Optional<ExpressionSyntax> Value) : StatementSyntax(Tokens);
public record ReturnSyntax(IReadOnlyList<Token> Tokens, Optional<ExpressionSyntax> Value) : StatementSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
if (Value.HasValue)
{
yield return Value.Value;
}
}
}
public record AssignmentSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Target, ExpressionSyntax Value) : StatementSyntax(Tokens);
public record AssignmentSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Target, ExpressionSyntax Value) : StatementSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
yield return Target;
yield return Value;
}
}
public record IfSyntax(IReadOnlyList<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 override IEnumerable<SyntaxNode> GetChildren()
{
yield return Condition;
yield return Body;
if (Else.HasValue)
{
if (Else.Value.IsCase1(out var elseIf))
{
yield return elseIf;
}
else if (Else.Value.IsCase2(out var @else))
{
yield return @else;
}
}
}
}
public record VariableDeclarationSyntax(IReadOnlyList<Token> Tokens, string Name, Optional<TypeSyntax> ExplicitType, Optional<ExpressionSyntax> Assignment) : StatementSyntax(Tokens);
public record VariableDeclarationSyntax(IReadOnlyList<Token> Tokens, string Name, Optional<TypeSyntax> ExplicitType, Optional<ExpressionSyntax> Assignment) : StatementSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
if (ExplicitType.HasValue)
{
yield return ExplicitType.Value;
}
public record ContinueSyntax(IReadOnlyList<Token> Tokens) : StatementSyntax(Tokens);
if (Assignment.HasValue)
{
yield return Assignment.Value;
}
}
}
public record BreakSyntax(IReadOnlyList<Token> Tokens) : StatementSyntax(Tokens);
public record ContinueSyntax(IReadOnlyList<Token> Tokens) : StatementSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren() => [];
}
public record WhileSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Condition, BlockSyntax Body) : StatementSyntax(Tokens);
public record BreakSyntax(IReadOnlyList<Token> Tokens) : StatementSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren() => [];
}
public record WhileSyntax(IReadOnlyList<Token> Tokens, ExpressionSyntax Condition, BlockSyntax Body) : StatementSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren() => [];
}

41
src/compiler/NubLang/Syntax/Parsing/Node/SyntaxNode.cs Normal file
View File

@@ -0,0 +1,41 @@
using NubLang.Diagnostics;
using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Parsing.Node;
public abstract record SyntaxNode(IReadOnlyList<Token> Tokens)
{
public abstract IEnumerable<SyntaxNode> GetChildren();
public IEnumerable<SyntaxNode> GetDescendants()
{
yield return this;
foreach (var child in GetChildren())
{
foreach (var desc in child.GetDescendants())
{
yield return desc;
}
}
}
}
public record SyntaxTree(IReadOnlyList<Token> Tokens, string Namespace, IReadOnlyList<DefinitionSyntax> Definitions, IReadOnlyList<Diagnostic> Diagnostics) : SyntaxNode(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
foreach (var definition in Definitions)
{
yield return definition;
}
}
}
public record BlockSyntax(IReadOnlyList<Token> Tokens, IReadOnlyList<StatementSyntax> Statements) : SyntaxNode(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
return Statements;
}
}

65
src/compiler/NubLang/Syntax/Parsing/Node/TypeSyntax.cs
View File

@@ -36,20 +36,67 @@ public abstract record TypeSyntax(IReadOnlyList<Token> Tokens) : SyntaxNode(Toke
}
}
public record FuncTypeSyntax(IReadOnlyList<Token> Tokens, IReadOnlyList<TypeSyntax> Parameters, TypeSyntax ReturnType) : TypeSyntax(Tokens);
public record FuncTypeSyntax(IReadOnlyList<Token> Tokens, IReadOnlyList<TypeSyntax> Parameters, TypeSyntax ReturnType) : TypeSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
foreach (var parameter in Parameters)
{
yield return parameter;
}
public record PointerTypeSyntax(IReadOnlyList<Token> Tokens, TypeSyntax BaseType) : TypeSyntax(Tokens);
yield return ReturnType;
}
}
public record VoidTypeSyntax(IReadOnlyList<Token> Tokens) : TypeSyntax(Tokens);
public record PointerTypeSyntax(IReadOnlyList<Token> Tokens, TypeSyntax BaseType) : TypeSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
yield return BaseType;
}
}
public record PrimitiveTypeSyntax(IReadOnlyList<Token> Tokens, PrimitiveTypeSyntaxKind SyntaxKind) : TypeSyntax(Tokens);
public record VoidTypeSyntax(IReadOnlyList<Token> Tokens) : TypeSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren() => [];
}
public record CStringTypeSyntax(IReadOnlyList<Token> Tokens) : TypeSyntax(Tokens);
public record PrimitiveTypeSyntax(IReadOnlyList<Token> Tokens, PrimitiveTypeSyntaxKind SyntaxKind) : TypeSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren() => [];
}
public record StringTypeSyntax(IReadOnlyList<Token> Tokens) : TypeSyntax(Tokens);
public record CStringTypeSyntax(IReadOnlyList<Token> Tokens) : TypeSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren() => [];
}
public record CustomTypeSyntax(IReadOnlyList<Token> Tokens, string Namespace, string Name, IReadOnlyList<TypeSyntax> Arguments) : TypeSyntax(Tokens);
public record StringTypeSyntax(IReadOnlyList<Token> Tokens) : TypeSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren() => [];
}
public record GenericTypeSyntax(IReadOnlyList<Token> Tokens, string Name) : TypeSyntax(Tokens);
public record CustomTypeSyntax(IReadOnlyList<Token> Tokens, string Namespace, string Name, IReadOnlyList<TypeSyntax> Arguments) : TypeSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
foreach (var argument in Arguments)
{
yield return argument;
}
}
}
public record ArrayTypeSyntax(IReadOnlyList<Token> Tokens, TypeSyntax BaseType) : TypeSyntax(Tokens);
public record GenericTypeSyntax(IReadOnlyList<Token> Tokens, string Name) : TypeSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren() => [];
}
public record ArrayTypeSyntax(IReadOnlyList<Token> Tokens, TypeSyntax BaseType) : TypeSyntax(Tokens)
{
public override IEnumerable<SyntaxNode> GetChildren()
{
yield return BaseType;
}
}

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

@@ -12,7 +12,7 @@ public sealed class Parser
private readonly IReadOnlyList<Token> _tokens;
private readonly List<Diagnostic> _diagnostics = [];
private readonly List<GenericParameter> _genericParameters = [];
private List<GenericParameter> _genericParameters = [];
private int _tokenIndex;
public Parser(IReadOnlyList<Token> tokens)
@@ -21,10 +21,10 @@ public sealed class Parser
_tokens = tokens;
}
public ParseTree Parse()
public SyntaxTree Parse()
{
_diagnostics.Clear();
_genericParameters.Clear();
_genericParameters = [];
_tokenIndex = 0;
if (TryExpectSymbol(Symbol.Namespace))
@@ -36,7 +36,7 @@ public sealed class Parser
while (Peek().HasValue)
{
_genericParameters.Clear();
_genericParameters = [];
var startIndex = _tokenIndex;
try
@@ -95,7 +95,7 @@ public sealed class Parser
}
}
return new ParseTree(_namespace, definitions, _diagnostics);
return new SyntaxTree(_tokens, _namespace, definitions, _diagnostics);
}
private FuncSignatureSyntax ParseFuncSignature(FuncParameterSyntax? thisArg = null)
@@ -140,17 +140,17 @@ public sealed class Parser
return new FuncParameterSyntax(GetTokens(startIndex), name.Value, type);
}
private DefinitionSyntax ParseExtern(int startIndex, IdentifierToken name, IReadOnlyList<GenericParameter> templateParameters)
private DefinitionSyntax ParseExtern(int startIndex, IdentifierToken name, IReadOnlyList<GenericParameter> genericParameters)
{
var keyword = ExpectSymbol();
return keyword.Symbol switch
{
Symbol.Func => ParseExternFunc(startIndex, name, templateParameters),
Symbol.Func => ParseExternFunc(startIndex, name, genericParameters),
_ => throw new ParseException(Diagnostic.Error($"Unexpected symbol {keyword.Symbol} after extern declaration").At(keyword).Build())
};
}
private ExternFuncSyntax ParseExternFunc(int startIndex, IdentifierToken name, IReadOnlyList<GenericParameter> templateParameters)
private ExternFuncSyntax ParseExternFunc(int startIndex, IdentifierToken name, IReadOnlyList<GenericParameter> genericParameters)
{
var callName = name.Value;
@@ -161,18 +161,18 @@ public sealed class Parser
var signature = ParseFuncSignature();
return new ExternFuncSyntax(GetTokens(startIndex), _namespace, templateParameters, name.Value, callName, signature);
return new ExternFuncSyntax(GetTokens(startIndex), _namespace, genericParameters, name.Value, callName, signature);
}
private LocalFuncSyntax ParseFunc(int startIndex, IdentifierToken name, IReadOnlyList<GenericParameter> templateParameters)
private LocalFuncSyntax ParseFunc(int startIndex, IdentifierToken name, IReadOnlyList<GenericParameter> genericParameters)
{
var signature = ParseFuncSignature();
var body = ParseBlock();
return new LocalFuncSyntax(GetTokens(startIndex), _namespace, templateParameters, name.Value, signature, body);
return new LocalFuncSyntax(GetTokens(startIndex), _namespace, genericParameters, name.Value, signature, body);
}
private DefinitionSyntax ParseStruct(int startIndex, IdentifierToken name, IReadOnlyList<GenericParameter> templateParameters)
private DefinitionSyntax ParseStruct(int startIndex, IdentifierToken name, IReadOnlyList<GenericParameter> genericParameters)
{
ExpectSymbol(Symbol.OpenBrace);
@@ -188,7 +188,7 @@ public sealed class Parser
if (TryExpectSymbol(Symbol.Func))
{
var funcName = ExpectIdentifier().Value;
var thisArg = new FuncParameterSyntax([], "this", new CustomTypeSyntax([], _namespace, name.Value, templateParameters.Select(x => new GenericTypeSyntax(x.Tokens, x.Name)).ToList()));
var thisArg = new FuncParameterSyntax([], "this", new CustomTypeSyntax([], _namespace, name.Value, genericParameters.Select(x => new GenericTypeSyntax(x.Tokens, x.Name)).ToList()));
var funcSignature = ParseFuncSignature(thisArg);
var funcBody = ParseBlock();
@@ -211,10 +211,10 @@ public sealed class Parser
}
}
return new StructSyntax(GetTokens(startIndex), _namespace, templateParameters, name.Value, fields, funcs);
return new StructSyntax(GetTokens(startIndex), _namespace, genericParameters, name.Value, fields, funcs);
}
private InterfaceSyntax ParseInterface(int startIndex, IdentifierToken name, IReadOnlyList<GenericParameter> templateParameters)
private InterfaceSyntax ParseInterface(int startIndex, IdentifierToken name, IReadOnlyList<GenericParameter> genericParameters)
{
ExpectSymbol(Symbol.OpenBrace);
@@ -232,7 +232,7 @@ public sealed class Parser
functions.Add(new InterfaceFuncSyntax(GetTokens(funcStartIndex), funcName, signature));
}
return new InterfaceSyntax(GetTokens(startIndex), _namespace, templateParameters, name.Value, functions);
return new InterfaceSyntax(GetTokens(startIndex), _namespace, genericParameters, name.Value, functions);
}
private StatementSyntax ParseStatement()
@@ -689,7 +689,7 @@ public sealed class Parser
}
}
return new CustomTypeSyntax(GetTokens(startIndex), name.Value, @namespace, parameters);
return new CustomTypeSyntax(GetTokens(startIndex), @namespace, name.Value, parameters);
}
}