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

rename node -> syntax

Browse Source
This commit is contained in:
nub31
2025-07-06 23:09:54 +02:00
parent 896d1fe1ea
commit eb13b94fa5
15 changed files with 373 additions and 271 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,7 +1,7 @@
using System.Diagnostics.CodeAnalysis;
using Common;
using NubLang.Diagnostics;
using NubLang.Syntax.Node;
using NubLang.Syntax.Parsing.Node;
using NubLang.Syntax.Tokenization;
namespace NubLang.Syntax.Parsing;
@@ -32,13 +32,13 @@ public sealed class Parser
_namespace = ExpectIdentifier().Value;
}
List<TopLevelNode> topLevelNodes = [];
List<DefinitionSyntax> definitions = [];
while (Peek().HasValue)
{
try
{
topLevelNodes.Add(ParseTopLevel());
definitions.Add(ParseTopLevel());
}
catch (ParseException ex)
{
@@ -47,10 +47,10 @@ public sealed class Parser
}
}
return new SyntaxTree(_namespace, topLevelNodes, _diagnostics);
return new SyntaxTree(_namespace, definitions, _diagnostics);
}
private TopLevelNode ParseTopLevel()
private DefinitionSyntax ParseTopLevel()
{
var startIndex = _tokenIndex;
List<ModifierToken> modifiers = [];
@@ -86,10 +86,10 @@ public sealed class Parser
return node;
}
private TopLevelNode ParseFunc(int startIndex, List<ModifierToken> modifiers)
private DefinitionSyntax ParseFunc(int startIndex, List<ModifierToken> modifiers)
{
var name = ExpectIdentifier();
List<FuncParameterNode> parameters = [];
List<FuncParameterSyntax> parameters = [];
ExpectSymbol(Symbol.OpenParen);
@@ -129,22 +129,22 @@ public sealed class Parser
callName = ExpectIdentifier().Value;
}
return new ExternFuncNode(GetTokensForNode(startIndex), _namespace, name.Value, callName, parameters, returnType);
return new ExternFuncSyntax(GetTokens(startIndex), _namespace, name.Value, callName, parameters, returnType);
}
var body = ParseBlock();
var exported = modifiers.RemoveAll(x => x.Modifier == Modifier.Export) > 0;
return new LocalFuncNode(GetTokensForNode(startIndex), _namespace, name.Value, parameters, body, returnType, exported);
return new LocalFuncSyntax(GetTokens(startIndex), _namespace, name.Value, parameters, body, returnType, exported);
}
private StructNode ParseStruct(int startIndex)
private StructSyntax ParseStruct(int startIndex)
{
var name = ExpectIdentifier().Value;
ExpectSymbol(Symbol.OpenBrace);
List<StructFieldNode> variables = [];
List<StructFieldSyntax> variables = [];
var fieldIndex = 0;
@@ -156,26 +156,26 @@ public sealed class Parser
ExpectSymbol(Symbol.Colon);
var variableType = ParseType();
var variableValue = Optional<ExpressionNode>.Empty();
var variableValue = Optional<ExpressionSyntax>.Empty();
if (TryExpectSymbol(Symbol.Assign))
{
variableValue = ParseExpression();
}
variables.Add(new StructFieldNode(GetTokensForNode(fieldStartIndex), fieldIndex++, variableName, variableType, variableValue));
variables.Add(new StructFieldSyntax(GetTokens(fieldStartIndex), fieldIndex++, variableName, variableType, variableValue));
}
return new StructNode(GetTokensForNode(startIndex), _namespace, name, variables);
return new StructSyntax(GetTokens(startIndex), _namespace, name, variables);
}
private TraitNode ParseTrait(int startIndex)
private TraitSyntax ParseTrait(int startIndex)
{
var name = ExpectIdentifier().Value;
ExpectSymbol(Symbol.OpenBrace);
List<TraitFuncNode> functions = [];
List<TraitFuncSyntax> functions = [];
while (!TryExpectSymbol(Symbol.CloseBrace))
{
@@ -184,7 +184,7 @@ public sealed class Parser
ExpectSymbol(Symbol.Func);
var funcName = ExpectIdentifier().Value;
var parameters = new List<FuncParameterNode>();
var parameters = new List<FuncParameterSyntax>();
ExpectSymbol(Symbol.OpenParen);
while (!TryExpectSymbol(Symbol.CloseParen))
@@ -203,19 +203,19 @@ public sealed class Parser
var returnType = TryExpectSymbol(Symbol.Colon) ? ParseType() : new NubVoidType();
functions.Add(new TraitFuncNode(GetTokensForNode(funcStartIndex), funcName, parameters, returnType));
functions.Add(new TraitFuncSyntax(GetTokens(funcStartIndex), funcName, parameters, returnType));
}
return new TraitNode(GetTokensForNode(startIndex), _namespace, name, functions);
return new TraitSyntax(GetTokens(startIndex), _namespace, name, functions);
}
private TraitImplNode ParseImplementation(int startIndex)
private TraitImplSyntax ParseImplementation(int startIndex)
{
var traitType = ParseType();
ExpectSymbol(Symbol.For);
var forType = ParseType();
List<TraitFuncImplNode> functions = [];
List<TraitFuncImplSyntax> functions = [];
ExpectSymbol(Symbol.OpenBrace);
while (!TryExpectSymbol(Symbol.CloseBrace))
@@ -223,7 +223,7 @@ public sealed class Parser
var funcStartIndex = _tokenIndex;
ExpectSymbol(Symbol.Func);
var functionName = ExpectIdentifier().Value;
var parameters = new List<FuncParameterNode>
var parameters = new List<FuncParameterSyntax>
{
new([], "this", forType)
};
@@ -248,23 +248,23 @@ public sealed class Parser
var body = ParseBlock();
functions.AddRange(new TraitFuncImplNode(GetTokensForNode(funcStartIndex), functionName, parameters, returnType, body));
functions.AddRange(new TraitFuncImplSyntax(GetTokens(funcStartIndex), functionName, parameters, returnType, body));
}
return new TraitImplNode(GetTokensForNode(startIndex), _namespace, traitType, forType, functions);
return new TraitImplSyntax(GetTokens(startIndex), _namespace, traitType, forType, functions);
}
private FuncParameterNode ParseFuncParameter()
private FuncParameterSyntax ParseFuncParameter()
{
var startIndex = _tokenIndex;
var name = ExpectIdentifier();
ExpectSymbol(Symbol.Colon);
var type = ParseType();
return new FuncParameterNode(GetTokensForNode(startIndex), name.Value, type);
return new FuncParameterSyntax(GetTokens(startIndex), name.Value, type);
}
private StatementNode ParseStatement()
private StatementSyntax ParseStatement()
{
var startIndex = _tokenIndex;
if (!Peek().TryGetValue(out var token))
@@ -297,20 +297,20 @@ public sealed class Parser
return ParseStatementExpression(startIndex);
}
private StatementNode ParseStatementExpression(int startIndex)
private StatementSyntax ParseStatementExpression(int startIndex)
{
var expr = ParseExpression();
if (TryExpectSymbol(Symbol.Assign))
{
var value = ParseExpression();
return new AssignmentNode(GetTokensForNode(startIndex), expr, value);
return new AssignmentSyntax(GetTokens(startIndex), expr, value);
}
return new StatementExpressionNode(GetTokensForNode(startIndex), expr);
return new StatementExpressionSyntax(GetTokens(startIndex), expr);
}
private VariableDeclarationNode ParseVariableDeclaration(int startIndex)
private VariableDeclarationSyntax ParseVariableDeclaration(int startIndex)
{
ExpectSymbol(Symbol.Let);
var name = ExpectIdentifier().Value;
@@ -321,68 +321,68 @@ public sealed class Parser
explicitType = ParseType();
}
var assignment = Optional<ExpressionNode>.Empty();
var assignment = Optional<ExpressionSyntax>.Empty();
if (TryExpectSymbol(Symbol.Assign))
{
assignment = ParseExpression();
}
return new VariableDeclarationNode(GetTokensForNode(startIndex), name, explicitType, assignment);
return new VariableDeclarationSyntax(GetTokens(startIndex), name, explicitType, assignment);
}
private StatementNode ParseBreak(int startIndex)
private StatementSyntax ParseBreak(int startIndex)
{
ExpectSymbol(Symbol.Break);
Next();
return new BreakNode(GetTokensForNode(startIndex));
return new BreakSyntax(GetTokens(startIndex));
}
private StatementNode ParseContinue(int startIndex)
private StatementSyntax ParseContinue(int startIndex)
{
ExpectSymbol(Symbol.Continue);
return new ContinueNode(GetTokensForNode(startIndex));
return new ContinueSyntax(GetTokens(startIndex));
}
private ReturnNode ParseReturn(int startIndex)
private ReturnSyntax ParseReturn(int startIndex)
{
ExpectSymbol(Symbol.Return);
var value = Optional<ExpressionNode>.Empty();
var value = Optional<ExpressionSyntax>.Empty();
if (_functionReturnType is not NubVoidType)
{
value = ParseExpression();
}
return new ReturnNode(GetTokensForNode(startIndex), value);
return new ReturnSyntax(GetTokens(startIndex), value);
}
private IfNode ParseIf(int startIndex)
private IfSyntax ParseIf(int startIndex)
{
ExpectSymbol(Symbol.If);
var condition = ParseExpression();
var body = ParseBlock();
var elseStatement = Optional<Variant<IfNode, BlockNode>>.Empty();
var elseStatement = Optional<Variant<IfSyntax, BlockSyntax>>.Empty();
if (TryExpectSymbol(Symbol.Else))
{
var newStartIndex = _tokenIndex;
elseStatement = TryExpectSymbol(Symbol.If)
? (Variant<IfNode, BlockNode>)ParseIf(newStartIndex)
: (Variant<IfNode, BlockNode>)ParseBlock();
? (Variant<IfSyntax, BlockSyntax>)ParseIf(newStartIndex)
: (Variant<IfSyntax, BlockSyntax>)ParseBlock();
}
return new IfNode(GetTokensForNode(startIndex), condition, body, elseStatement);
return new IfSyntax(GetTokens(startIndex), condition, body, elseStatement);
}
private WhileNode ParseWhile(int startIndex)
private WhileSyntax ParseWhile(int startIndex)
{
ExpectSymbol(Symbol.While);
var condition = ParseExpression();
var body = ParseBlock();
return new WhileNode(GetTokensForNode(startIndex), condition, body);
return new WhileSyntax(GetTokens(startIndex), condition, body);
}
private ExpressionNode ParseExpression(int precedence = 0)
private ExpressionSyntax ParseExpression(int precedence = 0)
{
var startIndex = _tokenIndex;
var left = ParsePrimaryExpression();
@@ -399,63 +399,63 @@ public sealed class Parser
Next();
var right = ParseExpression(GetBinaryOperatorPrecedence(op.Value) + 1);
left = new BinaryExpressionNode(GetTokensForNode(startIndex), left, op.Value, right);
left = new BinaryExpressionSyntax(GetTokens(startIndex), left, op.Value, right);
}
return left;
}
private int GetBinaryOperatorPrecedence(BinaryExpressionOperator binaryExpressionOperator)
private int GetBinaryOperatorPrecedence(BinaryOperator @operator)
{
return binaryExpressionOperator switch
return @operator switch
{
BinaryExpressionOperator.Multiply => 3,
BinaryExpressionOperator.Divide => 3,
BinaryExpressionOperator.Plus => 2,
BinaryExpressionOperator.Minus => 2,
BinaryExpressionOperator.GreaterThan => 1,
BinaryExpressionOperator.GreaterThanOrEqual => 1,
BinaryExpressionOperator.LessThan => 1,
BinaryExpressionOperator.LessThanOrEqual => 1,
BinaryExpressionOperator.Equal => 0,
BinaryExpressionOperator.NotEqual => 0,
_ => throw new ArgumentOutOfRangeException(nameof(binaryExpressionOperator), binaryExpressionOperator, null)
BinaryOperator.Multiply => 3,
BinaryOperator.Divide => 3,
BinaryOperator.Plus => 2,
BinaryOperator.Minus => 2,
BinaryOperator.GreaterThan => 1,
BinaryOperator.GreaterThanOrEqual => 1,
BinaryOperator.LessThan => 1,
BinaryOperator.LessThanOrEqual => 1,
BinaryOperator.Equal => 0,
BinaryOperator.NotEqual => 0,
_ => throw new ArgumentOutOfRangeException(nameof(@operator), @operator, null)
};
}
private bool TryGetBinaryOperator(Symbol symbol, [NotNullWhen(true)] out BinaryExpressionOperator? binaryExpressionOperator)
private bool TryGetBinaryOperator(Symbol symbol, [NotNullWhen(true)] out BinaryOperator? binaryExpressionOperator)
{
switch (symbol)
{
case Symbol.Equal:
binaryExpressionOperator = BinaryExpressionOperator.Equal;
binaryExpressionOperator = BinaryOperator.Equal;
return true;
case Symbol.NotEqual:
binaryExpressionOperator = BinaryExpressionOperator.NotEqual;
binaryExpressionOperator = BinaryOperator.NotEqual;
return true;
case Symbol.LessThan:
binaryExpressionOperator = BinaryExpressionOperator.LessThan;
binaryExpressionOperator = BinaryOperator.LessThan;
return true;
case Symbol.LessThanOrEqual:
binaryExpressionOperator = BinaryExpressionOperator.LessThanOrEqual;
binaryExpressionOperator = BinaryOperator.LessThanOrEqual;
return true;
case Symbol.GreaterThan:
binaryExpressionOperator = BinaryExpressionOperator.GreaterThan;
binaryExpressionOperator = BinaryOperator.GreaterThan;
return true;
case Symbol.GreaterThanOrEqual:
binaryExpressionOperator = BinaryExpressionOperator.GreaterThanOrEqual;
binaryExpressionOperator = BinaryOperator.GreaterThanOrEqual;
return true;
case Symbol.Plus:
binaryExpressionOperator = BinaryExpressionOperator.Plus;
binaryExpressionOperator = BinaryOperator.Plus;
return true;
case Symbol.Minus:
binaryExpressionOperator = BinaryExpressionOperator.Minus;
binaryExpressionOperator = BinaryOperator.Minus;
return true;
case Symbol.Star:
binaryExpressionOperator = BinaryExpressionOperator.Multiply;
binaryExpressionOperator = BinaryOperator.Multiply;
return true;
case Symbol.ForwardSlash:
binaryExpressionOperator = BinaryExpressionOperator.Divide;
binaryExpressionOperator = BinaryOperator.Divide;
return true;
default:
binaryExpressionOperator = null;
@@ -463,17 +463,17 @@ public sealed class Parser
}
}
private ExpressionNode ParsePrimaryExpression()
private ExpressionSyntax ParsePrimaryExpression()
{
var startIndex = _tokenIndex;
ExpressionNode expr;
ExpressionSyntax expr;
var token = ExpectToken();
switch (token)
{
case LiteralToken literal:
{
expr = new LiteralNode(GetTokensForNode(startIndex), literal.Value, literal.Kind);
expr = new LiteralSyntax(GetTokens(startIndex), literal.Value, literal.Kind);
break;
}
case IdentifierToken identifier:
@@ -486,7 +486,7 @@ public sealed class Parser
name = ExpectIdentifier().Value;
}
expr = new IdentifierNode(GetTokensForNode(startIndex), @namespace, name);
expr = new IdentifierSyntax(GetTokens(startIndex), @namespace, name);
break;
}
case SymbolToken symbolToken:
@@ -495,7 +495,7 @@ public sealed class Parser
{
case Symbol.Func:
{
List<FuncParameterNode> parameters = [];
List<FuncParameterSyntax> parameters = [];
ExpectSymbol(Symbol.OpenParen);
while (!TryExpectSymbol(Symbol.CloseParen))
{
@@ -515,7 +515,7 @@ public sealed class Parser
var body = ParseBlock();
expr = new AnonymousFuncNode(GetTokensForNode(startIndex), parameters, body, returnType);
expr = new AnonymousFuncSyntax(GetTokens(startIndex), parameters, body, returnType);
break;
}
case Symbol.OpenParen:
@@ -528,13 +528,13 @@ public sealed class Parser
case Symbol.Minus:
{
var expression = ParsePrimaryExpression();
expr = new UnaryExpressionNode(GetTokensForNode(startIndex), UnaryExpressionOperator.Negate, expression);
expr = new UnaryExpressionSyntax(GetTokens(startIndex), UnaryOperator.Negate, expression);
break;
}
case Symbol.Bang:
{
var expression = ParsePrimaryExpression();
expr = new UnaryExpressionNode(GetTokensForNode(startIndex), UnaryExpressionOperator.Invert, expression);
expr = new UnaryExpressionSyntax(GetTokens(startIndex), UnaryOperator.Invert, expression);
break;
}
case Symbol.OpenBracket:
@@ -542,13 +542,13 @@ public sealed class Parser
var capacity = ParseExpression();
ExpectSymbol(Symbol.CloseBracket);
var type = ParseType();
expr = new ArrayInitializerNode(GetTokensForNode(startIndex), capacity, type);
expr = new ArrayInitializerSyntax(GetTokens(startIndex), capacity, type);
break;
}
case Symbol.Alloc:
{
var type = ParseType();
Dictionary<string, ExpressionNode> initializers = [];
Dictionary<string, ExpressionSyntax> initializers = [];
ExpectSymbol(Symbol.OpenBrace);
while (!TryExpectSymbol(Symbol.CloseBrace))
{
@@ -558,7 +558,7 @@ public sealed class Parser
initializers.Add(name, value);
}
expr = new StructInitializerNode(GetTokensForNode(startIndex), type, initializers);
expr = new StructInitializerSyntax(GetTokens(startIndex), type, initializers);
break;
}
default:
@@ -586,26 +586,26 @@ public sealed class Parser
return ParsePostfixOperators(startIndex, expr);
}
private ExpressionNode ParsePostfixOperators(int startIndex, ExpressionNode expr)
private ExpressionSyntax ParsePostfixOperators(int startIndex, ExpressionSyntax expr)
{
while (true)
{
if (TryExpectSymbol(Symbol.Ampersand))
{
expr = new AddressOfNode(GetTokensForNode(startIndex), expr);
expr = new AddressOfSyntax(GetTokens(startIndex), expr);
break;
}
if (TryExpectSymbol(Symbol.Caret))
{
expr = new DereferenceNode(GetTokensForNode(startIndex), expr);
expr = new DereferenceSyntax(GetTokens(startIndex), expr);
continue;
}
if (TryExpectSymbol(Symbol.Period))
{
var structMember = ExpectIdentifier().Value;
expr = new MemberAccessNode(GetTokensForNode(startIndex), expr, structMember);
expr = new MemberAccessSyntax(GetTokens(startIndex), expr, structMember);
continue;
}
@@ -613,13 +613,13 @@ public sealed class Parser
{
var index = ParseExpression();
ExpectSymbol(Symbol.CloseBracket);
expr = new ArrayIndexAccessNode(GetTokensForNode(startIndex), expr, index);
expr = new ArrayIndexAccessSyntax(GetTokens(startIndex), expr, index);
continue;
}
if (TryExpectSymbol(Symbol.OpenParen))
{
var parameters = new List<ExpressionNode>();
var parameters = new List<ExpressionSyntax>();
while (!TryExpectSymbol(Symbol.CloseParen))
{
parameters.Add(ParseExpression());
@@ -633,7 +633,7 @@ public sealed class Parser
}
}
expr = new FuncCallNode(GetTokensForNode(startIndex), expr, parameters);
expr = new FuncCallSyntax(GetTokens(startIndex), expr, parameters);
continue;
}
@@ -643,11 +643,11 @@ public sealed class Parser
return expr;
}
private BlockNode ParseBlock()
private BlockSyntax ParseBlock()
{
var startIndex = _tokenIndex;
ExpectSymbol(Symbol.OpenBrace);
List<StatementNode> statements = [];
List<StatementSyntax> statements = [];
while (Peek().HasValue && !TryExpectSymbol(Symbol.CloseBrace))
{
try
@@ -661,7 +661,7 @@ public sealed class Parser
}
}
return new BlockNode(GetTokensForNode(startIndex), statements);
return new BlockSyntax(GetTokens(startIndex), statements);
}
private NubType ParseType()
@@ -892,7 +892,7 @@ public sealed class Parser
_tokenIndex++;
}
private IEnumerable<Token> GetTokensForNode(int startIndex)
private IEnumerable<Token> GetTokens(int startIndex)
{
return _tokens.Skip(startIndex).Take(Math.Min(_tokenIndex, _tokens.Count() - 1) - startIndex);
}