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

36
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 public readonly struct Variant<T1, T2> where T1 : notnull where T2 : notnull
{ {
@@ -6,12 +8,12 @@ public readonly struct Variant<T1, T2> where T1 : notnull where T2 : notnull
{ {
throw new InvalidOperationException("Variant must be initialized with a value"); throw new InvalidOperationException("Variant must be initialized with a value");
} }
public Variant(T1 value) public Variant(T1 value)
{ {
_value = value; _value = value;
} }
public Variant(T2 value) public Variant(T2 value)
{ {
_value = value; _value = value;
@@ -33,7 +35,7 @@ public readonly struct Variant<T1, T2> where T1 : notnull where T2 : notnull
throw new InvalidCastException(); throw new InvalidCastException();
} }
} }
public T Match<T>(Func<T1, T> on1, Func<T2, T> on2) public T Match<T>(Func<T1, T> on1, Func<T2, T> on2)
{ {
return _value switch return _value switch
@@ -43,7 +45,31 @@ public readonly struct Variant<T1, T2> where T1 : notnull where T2 : notnull
_ => throw new InvalidCastException() _ => throw new InvalidCastException()
}; };
} }
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>(T1 value) => new(value);
public static implicit operator Variant<T1, T2>(T2 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 public sealed class Binder
{ {
private readonly ParseTree _parseTree; private readonly SyntaxTree _syntaxTree;
private readonly DefinitionTable _definitionTable; private readonly DefinitionTable _definitionTable;
private readonly Stack<Scope> _scopes = []; private readonly Stack<Scope> _scopes = [];
@@ -16,9 +16,9 @@ public sealed class Binder
private Scope Scope => _scopes.Peek(); private Scope Scope => _scopes.Peek();
public Binder(ParseTree parseTree, DefinitionTable definitionTable) public Binder(SyntaxTree syntaxTree, DefinitionTable definitionTable)
{ {
_parseTree = parseTree; _syntaxTree = syntaxTree;
_definitionTable = definitionTable; _definitionTable = definitionTable;
} }
@@ -30,7 +30,7 @@ public sealed class Binder
var diagnostics = new List<Diagnostic>(); var diagnostics = new List<Diagnostic>();
var definitions = new List<BoundDefinition>(); var definitions = new List<BoundDefinition>();
foreach (var definition in _parseTree.Definitions) foreach (var definition in _syntaxTree.Definitions)
{ {
try 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) private BoundDefinition BindDefinition(DefinitionSyntax node)
@@ -309,7 +309,7 @@ public sealed class Binder
private BoundExpression BindIdentifier(IdentifierSyntax expression) 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(); var localFuncs = _definitionTable.LookupLocalFunc(@namespace, expression.Name).ToArray();
if (localFuncs.Length > 0) 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; private readonly List<DefinitionSyntax> _definitions;
public DefinitionTable(IEnumerable<ParseTree> syntaxTrees) public DefinitionTable(IEnumerable<SyntaxTree> syntaxTrees)
{ {
_definitions = syntaxTrees.SelectMany(x => x.Definitions).ToList(); _definitions = syntaxTrees.SelectMany(x => x.Definitions).ToList();
} }

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

@@ -1,30 +1,77 @@
using NubLang.Syntax.Generics.Node;
using NubLang.Syntax.Parsing.Node; using NubLang.Syntax.Parsing.Node;
namespace NubLang.Syntax.Generics; namespace NubLang.Syntax.Generics;
public class GenericInstantiator 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)
{ {
switch (definition) var definitions = new List<DefinitionSyntax>();
foreach (var definition in syntaxTree.Definitions)
{ {
default: if (definition.Parameters.Any())
throw new ArgumentOutOfRangeException(nameof(definition)); {
switch (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));
}
}
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 new UnboundTree(_parseTree.Namespace, unboundDefinitions, _parseTree.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; 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 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 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; 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 IReadOnlyList<Token> _tokens;
private readonly List<Diagnostic> _diagnostics = []; private readonly List<Diagnostic> _diagnostics = [];
private readonly List<GenericParameter> _genericParameters = []; private List<GenericParameter> _genericParameters = [];
private int _tokenIndex; private int _tokenIndex;
public Parser(IReadOnlyList<Token> tokens) public Parser(IReadOnlyList<Token> tokens)
@@ -21,10 +21,10 @@ public sealed class Parser
_tokens = tokens; _tokens = tokens;
} }
public ParseTree Parse() public SyntaxTree Parse()
{ {
_diagnostics.Clear(); _diagnostics.Clear();
_genericParameters.Clear(); _genericParameters = [];
_tokenIndex = 0; _tokenIndex = 0;
if (TryExpectSymbol(Symbol.Namespace)) if (TryExpectSymbol(Symbol.Namespace))
@@ -36,7 +36,7 @@ public sealed class Parser
while (Peek().HasValue) while (Peek().HasValue)
{ {
_genericParameters.Clear(); _genericParameters = [];
var startIndex = _tokenIndex; var startIndex = _tokenIndex;
try 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) private FuncSignatureSyntax ParseFuncSignature(FuncParameterSyntax? thisArg = null)
@@ -140,17 +140,17 @@ public sealed class Parser
return new FuncParameterSyntax(GetTokens(startIndex), name.Value, type); 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(); var keyword = ExpectSymbol();
return keyword.Symbol switch 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()) _ => 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; var callName = name.Value;
@@ -161,18 +161,18 @@ public sealed class Parser
var signature = ParseFuncSignature(); 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 signature = ParseFuncSignature();
var body = ParseBlock(); 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); ExpectSymbol(Symbol.OpenBrace);
@@ -188,7 +188,7 @@ public sealed class Parser
if (TryExpectSymbol(Symbol.Func)) if (TryExpectSymbol(Symbol.Func))
{ {
var funcName = ExpectIdentifier().Value; 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 funcSignature = ParseFuncSignature(thisArg);
var funcBody = ParseBlock(); 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); ExpectSymbol(Symbol.OpenBrace);
@@ -232,7 +232,7 @@ public sealed class Parser
functions.Add(new InterfaceFuncSyntax(GetTokens(funcStartIndex), funcName, signature)); 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() 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);
} }
} }