mahalex/MParser
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rename token kinds & syntax nodes

Browse Source
This commit is contained in:
Alexander Luzgarev 2020-07-14 14:38:59 +02:00
parent 8c1ddb0cf7
commit e1a7ea36c9
15 changed files with 366 additions and 302 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
ConsoleDemo/DumbWalker.cs
View File

@ -22,8 +22,8 @@ namespace ConsoleDemo
{
switch (lhs.Kind)
{
case TokenKind.IdentifierName:
var name = ((IdentifierNameSyntaxNode) lhs).Name.Text;
case TokenKind.IdentifierNameExpression:
var name = ((IdentifierNameExpressionSyntaxNode) lhs).Name.Text;
Console.WriteLine($"Adding variable assignment for {name}");
_variableAssignments.Add(name, new Variable());
break;
@ -66,8 +66,8 @@ namespace ConsoleDemo
{
switch (node.Kind)
{
case TokenKind.IdentifierName:
var name = (IdentifierNameSyntaxNode) node;
case TokenKind.IdentifierNameExpression:
var name = (IdentifierNameExpressionSyntaxNode) node;
if (_context.FindFunction(name.Name.Text))
{
return true;
@ -90,7 +90,7 @@ namespace ConsoleDemo
Variable assignment;
switch (node.Kind)
{
case TokenKind.IdentifierName:
case TokenKind.IdentifierNameExpression:
assignment = _variableAssignments.Find(node.Text);
if (assignment != null || node.Text == "end")
{
@ -98,12 +98,12 @@ namespace ConsoleDemo
}
break;
case TokenKind.FunctionCall:
case TokenKind.FunctionCallExpression:
var functionCall = (FunctionCallExpressionSyntaxNode)node;
return
(IsDefined(functionCall.FunctionName) && IsDefined(functionCall.Nodes)) ||
(IsDefinedFunctionName(functionCall.FunctionName) && IsDefined(functionCall.Nodes));
case TokenKind.CellArrayElementAccess:
case TokenKind.CellArrayElementAccessExpression:
var cellArrayElementAccess = (CellArrayElementAccessExpressionSyntaxNode) node;
return IsDefined(cellArrayElementAccess.Expression) && IsDefined(cellArrayElementAccess.Nodes);
case TokenKind.List:
@ -113,7 +113,7 @@ namespace ConsoleDemo
return true;
case TokenKind.StringLiteralExpression:
return true;
case TokenKind.BinaryOperation:
case TokenKind.BinaryOperationExpression:
var binaryOperation = (BinaryOperationExpressionSyntaxNode) node;
return IsDefined(binaryOperation.Lhs) && IsDefined(binaryOperation.Rhs);
case TokenKind.UnaryPrefixOperationExpression:
@ -139,7 +139,7 @@ namespace ConsoleDemo
{
var parameterAsNode = parameter.AsNode();
Console.WriteLine($"Parameter node: {parameterAsNode}");
if (parameterAsNode.Kind == TokenKind.IdentifierName)
if (parameterAsNode.Kind == TokenKind.IdentifierNameExpression)
{
Console.WriteLine($"Adding variable assignment for {parameterAsNode.Text}");
_variableAssignments.Add(parameterAsNode.Text, new Variable());

8
ConsoleDemo/PrettyPrinter.cs
View File

@ -274,7 +274,7 @@ namespace ProjectConsole
OutputBracket(node.ClosingBrace);
}
public override void VisitIdentifierName(IdentifierNameSyntaxNode node)
public override void VisitIdentifierNameExpression(IdentifierNameExpressionSyntaxNode node)
{
OutputIdentifier(node.Name);
}
@ -410,7 +410,7 @@ namespace ProjectConsole
OutputBracket(node.ClosingBrace);
}
public override void VisitCompoundName(CompoundNameSyntaxNode node)
public override void VisitCompoundNameExpression(CompoundNameExpressionSyntaxNode node)
{
Visit(node.Nodes);
}
@ -479,14 +479,14 @@ namespace ProjectConsole
OutputBracket(node.ClosingBracket);
}
public override void VisitLambda(LambdaSyntaxNode node)
public override void VisitLambdaExpression(LambdaExpressionSyntaxNode node)
{
OutputOperator(node.AtSign);
Visit(node.Input);
Visit(node.Body);
}
public override void VisitNamedFunctionHandle(NamedFunctionHandleSyntaxNode node)
public override void VisitNamedFunctionHandleExpression(NamedFunctionHandleExpressionSyntaxNode node)
{
OutputOperator(node.AtSign);
Visit(node.FunctionName);

8
ConsoleDemo/UsageGathering.cs
View File

@ -49,8 +49,8 @@ namespace ConsoleDemo
{
switch (lhs.Kind)
{
case TokenKind.IdentifierName:
var name = ((IdentifierNameSyntaxNode)lhs).Name.Text;
case TokenKind.IdentifierNameExpression:
var name = ((IdentifierNameExpressionSyntaxNode)lhs).Name.Text;
Console.WriteLine($"Adding variable assignment for {name}");
_variableAssignments.Add(name, new Variable());
break;
@ -100,7 +100,7 @@ namespace ConsoleDemo
{
var parameterAsNode = parameter.AsNode();
Console.WriteLine($"Parameter node: {parameterAsNode}");
if (parameterAsNode.Kind == TokenKind.IdentifierName)
if (parameterAsNode.Kind == TokenKind.IdentifierNameExpression)
{
Console.WriteLine($"Adding variable assignment for {parameterAsNode.Text}");
_variableAssignments.Add(parameterAsNode.Text, new Variable());
@ -131,7 +131,7 @@ namespace ConsoleDemo
{
var parameterAsNode = parameter.AsNode();
Console.WriteLine($"Parameter node: {parameterAsNode}");
if (parameterAsNode.Kind == TokenKind.IdentifierName)
if (parameterAsNode.Kind == TokenKind.IdentifierNameExpression)
{
Console.WriteLine($"Adding variable assignment for {parameterAsNode.Text}");
_variableAssignments.Add(parameterAsNode.Text, new Variable());

8
MApplication/ColoringVisitor.cs
View File

@ -221,7 +221,7 @@ namespace MApplication
AddToken(node.ClosingBrace, _scheme.Bracket);
}
public override void VisitIdentifierName(IdentifierNameSyntaxNode node)
public override void VisitIdentifierNameExpression(IdentifierNameExpressionSyntaxNode node)
{
AddToken(node.Name, _scheme.Identifier);
}
@ -357,7 +357,7 @@ namespace MApplication
AddToken(node.ClosingBrace, _scheme.Bracket);
}
public override void VisitCompoundName(CompoundNameSyntaxNode node)
public override void VisitCompoundNameExpression(CompoundNameExpressionSyntaxNode node)
{
Visit(node.Nodes);
}
@ -426,14 +426,14 @@ namespace MApplication
AddToken(node.ClosingBracket, _scheme.Bracket);
}
public override void VisitLambda(LambdaSyntaxNode node)
public override void VisitLambdaExpression(LambdaExpressionSyntaxNode node)
{
AddToken(node.AtSign, _scheme.Operator);
Visit(node.Input);
Visit(node.Body);
}
public override void VisitNamedFunctionHandle(NamedFunctionHandleSyntaxNode node)
public override void VisitNamedFunctionHandleExpression(NamedFunctionHandleExpressionSyntaxNode node)
{
AddToken(node.AtSign, _scheme.Operator);
Visit(node.FunctionName);

119
Parser/Evaluator.cs
View File

@ -43,28 +43,28 @@ namespace Parser
{
return statement.Kind switch
{
TokenKind.ExpressionStatement =>
EvaluateExpressionStatement((ExpressionStatementSyntaxNode)statement),
TokenKind.MethodDefinition =>
EvaluateMethodDefinition((MethodDefinitionSyntaxNode)statement),
TokenKind.AbstractMethodDeclaration =>
EvaluateAbstractMethodDeclaration((AbstractMethodDeclarationSyntaxNode)statement),
TokenKind.FunctionDeclaration =>
EvaluateFunctionDeclaration((FunctionDeclarationSyntaxNode)statement),
TokenKind.SwitchStatement =>
EvaluateSwitchStatement((SwitchStatementSyntaxNode)statement),
TokenKind.WhileStatement =>
EvaluateWhileStatement((WhileStatementSyntaxNode)statement),
TokenKind.IfStatement =>
EvaluateIfStatement((IfStatementSyntaxNode)statement),
TokenKind.ForStatement =>
EvaluateForStatement((ForStatementSyntaxNode)statement),
TokenKind.TryCatchStatement =>
EvaluateTryCatchStatement((TryCatchStatementSyntaxNode)statement),
TokenKind.EmptyStatement =>
EvaluateEmptyStatement((EmptyStatementSyntaxNode)statement),
TokenKind.ClassDeclaration =>
EvaluateClassDeclaration((ClassDeclarationSyntaxNode)statement),
TokenKind.EmptyStatement =>
EvaluateEmptyStatement((EmptyStatementSyntaxNode)statement),
TokenKind.ExpressionStatement =>
EvaluateExpressionStatement((ExpressionStatementSyntaxNode)statement),
TokenKind.ForStatement =>
EvaluateForStatement((ForStatementSyntaxNode)statement),
TokenKind.FunctionDeclaration =>
EvaluateFunctionDeclaration((FunctionDeclarationSyntaxNode)statement),
TokenKind.IfStatement =>
EvaluateIfStatement((IfStatementSyntaxNode)statement),
TokenKind.ConcreteMethodDeclaration =>
EvaluateMethodDefinition((MethodDefinitionSyntaxNode)statement),
TokenKind.SwitchStatement =>
EvaluateSwitchStatement((SwitchStatementSyntaxNode)statement),
TokenKind.TryCatchStatement =>
EvaluateTryCatchStatement((TryCatchStatementSyntaxNode)statement),
TokenKind.WhileStatement =>
EvaluateWhileStatement((WhileStatementSyntaxNode)statement),
_ => throw new NotImplementedException($"Invalid statement kind '{statement.Kind}'."),
};
}
@ -128,52 +128,59 @@ namespace Parser
{
return expression.Kind switch
{
TokenKind.Lambda =>
EvaluateLambda((LambdaSyntaxNode)expression),
TokenKind.AssignmentExpression =>
EvaluateAssignmentExpression((AssignmentExpressionSyntaxNode)expression),
TokenKind.EmptyExpression =>
EvaluateEmptyExpression((EmptyExpressionSyntaxNode)expression),
TokenKind.UnaryPrefixOperationExpression =>
EvaluateUnaryPrefixOperationExpression((UnaryPrefixOperationExpressionSyntaxNode)expression),
TokenKind.CompoundName =>
EvaluateCompoundName((CompoundNameSyntaxNode)expression),
TokenKind.BinaryOperation =>
EvaluateBinaryOperation((BinaryOperationExpressionSyntaxNode)expression),
TokenKind.IdentifierName =>
EvaluateIdentifierName((IdentifierNameSyntaxNode)expression),
TokenKind.NumberLiteralExpression =>
EvaluateNumberLiteralExpression((NumberLiteralSyntaxNode)expression),
TokenKind.StringLiteralExpression =>
EvaluateStringLiteralExpression((StringLiteralSyntaxNode)expression),
TokenKind.DoubleQuotedStringLiteralExpression =>
EvaluateDoubleQuotedStringLiteralExpression((DoubleQuotedStringLiteralSyntaxNode)expression),
TokenKind.UnquotedStringLiteralExpression =>
EvaluateUnquotedStringLiteralExpression((UnquotedStringLiteralSyntaxNode)expression),
TokenKind.ArrayLiteralExpression =>
EvaluateArrayLiteralExpression((ArrayLiteralExpressionSyntaxNode)expression),
TokenKind.AssignmentExpression =>
EvaluateAssignmentExpression((AssignmentExpressionSyntaxNode)expression),
TokenKind.BinaryOperationExpression =>
EvaluateBinaryOperation((BinaryOperationExpressionSyntaxNode)expression),
TokenKind.CellArrayElementAccessExpression =>
EvaluateCellArrayElementAccess((CellArrayElementAccessExpressionSyntaxNode)expression),
TokenKind.CellArrayLiteralExpression =>
EvaluateCellArrayLiteralExpression((CellArrayLiteralExpressionSyntaxNode)expression),
TokenKind.ParenthesizedExpression =>
EvaluateNamedFunctionHandle((NamedFunctionHandleSyntaxNode)expression),
TokenKind.CellArrayElementAccess =>
EvaluateCellArrayElementAccess((CellArrayElementAccessExpressionSyntaxNode)expression),
TokenKind.FunctionCall =>
TokenKind.ClassInvokationExpression =>
EvaluateClassInvokation((BaseClassInvokationSyntaxNode)expression),
TokenKind.CommandExpression =>
EvaluateCommand((CommandExpressionSyntaxNode)expression),
TokenKind.CompoundNameExpression =>
EvaluateCompoundName((CompoundNameExpressionSyntaxNode)expression),
TokenKind.DoubleQuotedStringLiteralExpression =>
EvaluateDoubleQuotedStringLiteralExpression((DoubleQuotedStringLiteralSyntaxNode)expression),
TokenKind.EmptyExpression =>
EvaluateEmptyExpression((EmptyExpressionSyntaxNode)expression),
TokenKind.FunctionCallExpression =>
EvaluateFunctionCall((FunctionCallExpressionSyntaxNode)expression),
TokenKind.MemberAccess =>
TokenKind.IdentifierNameExpression =>
EvaluateIdentifierNameExpression((IdentifierNameExpressionSyntaxNode)expression),
TokenKind.IndirectMemberAccessExpression =>
EvaluateIndirectMemberAccess((IndirectMemberAccessSyntaxNode)expression),
TokenKind.LambdaExpression =>
EvaluateLambdaExpression((LambdaExpressionSyntaxNode)expression),
TokenKind.MemberAccessExpression =>
EvaluateMemberAccess((MemberAccessSyntaxNode)expression),
TokenKind.NamedFunctionHandleExpression =>
EvaluateNamedFunctionHandleExpression((NamedFunctionHandleExpressionSyntaxNode)expression),
TokenKind.NumberLiteralExpression =>
EvaluateNumberLiteralExpression((NumberLiteralSyntaxNode)expression),
TokenKind.ParenthesizedExpression =>
EvaluateParenthesizedExpression((ParenthesizedExpressionSyntaxNode)expression),
TokenKind.StringLiteralExpression =>
EvaluateStringLiteralExpression((StringLiteralSyntaxNode)expression),
TokenKind.UnaryPrefixOperationExpression =>
EvaluateUnaryPrefixOperationExpression((UnaryPrefixOperationExpressionSyntaxNode)expression),
TokenKind.UnaryPostfixOperationExpression =>
EvaluateUnaryPostfixOperationExpression((UnaryPostixOperationExpressionSyntaxNode)expression),
TokenKind.IndirectMemberAccess =>
EvaluateIndirectMemberAccess((IndirectMemberAccessSyntaxNode)expression),
TokenKind.Command =>
EvaluateCommand((CommandExpressionSyntaxNode)expression),
TokenKind.ClassInvokation =>
EvaluateClassInvokation((BaseClassInvokationSyntaxNode)expression),
TokenKind.UnquotedStringLiteralExpression =>
EvaluateUnquotedStringLiteralExpression((UnquotedStringLiteralSyntaxNode)expression),
_ => throw new NotImplementedException($"Invalid expression kind '{expression.Kind}'."),
};
}
private MObject? EvaluateParenthesizedExpression(ParenthesizedExpressionSyntaxNode expression)
{
throw new NotImplementedException();
}
private MObject? EvaluateClassInvokation(BaseClassInvokationSyntaxNode expression)
{
throw new NotImplementedException();
@ -239,7 +246,7 @@ namespace Parser
throw new NotImplementedException();
}
private MObject? EvaluateIdentifierName(IdentifierNameSyntaxNode expression)
private MObject? EvaluateIdentifierNameExpression(IdentifierNameExpressionSyntaxNode expression)
{
throw new NotImplementedException();
}
@ -249,7 +256,7 @@ namespace Parser
throw new NotImplementedException();
}
private MObject? EvaluateCompoundName(CompoundNameSyntaxNode expression)
private MObject? EvaluateCompoundName(CompoundNameExpressionSyntaxNode expression)
{
throw new NotImplementedException();
}
@ -269,12 +276,12 @@ namespace Parser
throw new NotImplementedException();
}
private MObject? EvaluateLambda(LambdaSyntaxNode expression)
private MObject? EvaluateLambdaExpression(LambdaExpressionSyntaxNode expression)
{
throw new NotImplementedException();
}
private MObject? EvaluateNamedFunctionHandle(NamedFunctionHandleSyntaxNode expression)
private MObject? EvaluateNamedFunctionHandleExpression(NamedFunctionHandleExpressionSyntaxNode expression)
{
throw new NotImplementedException();
}

32
Parser/Internal/MParserGreen.cs
View File

@ -113,7 +113,7 @@ namespace Parser.Internal
}
firstToken = false;
outputs.Add(Factory.IdentifierNameSyntax(EatToken(TokenKind.IdentifierToken)));
outputs.Add(Factory.IdentifierNameExpressionSyntax(EatToken(TokenKind.IdentifierToken)));
}
return outputs.ToList();
@ -141,7 +141,7 @@ namespace Parser.Internal
if (PeekToken(1).Kind == TokenKind.EqualsToken)
{
var identifierToken = EatIdentifier();
builder.Add(Factory.IdentifierNameSyntax(identifierToken));
builder.Add(Factory.IdentifierNameExpressionSyntax(identifierToken));
assignmentSign = EatToken(TokenKind.EqualsToken);
}
else
@ -180,7 +180,7 @@ namespace Parser.Internal
else
{
var identifierToken = EatToken(TokenKind.IdentifierToken);
builder.Add(Factory.IdentifierNameSyntax(identifierToken));
builder.Add(Factory.IdentifierNameExpressionSyntax(identifierToken));
}
}
@ -329,7 +329,7 @@ namespace Parser.Internal
break;
default:
var id = EatToken(TokenKind.IdentifierToken);
expression = Factory.IdentifierNameSyntax(id);
expression = Factory.IdentifierNameExpressionSyntax(id);
break;
}
@ -377,7 +377,7 @@ namespace Parser.Internal
closingBracket);
break;
case TokenKind.DotToken: // member access
if (expression is IdentifierNameSyntaxNode
if (expression is IdentifierNameExpressionSyntaxNode
|| expression is MemberAccessSyntaxNode
|| expression is FunctionCallExpressionSyntaxNode
|| expression is CellArrayElementAccessExpressionSyntaxNode)
@ -414,7 +414,7 @@ namespace Parser.Internal
private CommandExpressionSyntaxNode ParseCommandExpression(ExpressionSyntaxNode expression)
{
if (expression is IdentifierNameSyntaxNode idNameNode)
if (expression is IdentifierNameExpressionSyntaxNode idNameNode)
{
var builder = new SyntaxListBuilder<UnquotedStringLiteralSyntaxNode>();
while (CurrentToken.Kind == TokenKind.UnquotedStringLiteralToken)
@ -434,7 +434,7 @@ namespace Parser.Internal
private BaseClassInvokationSyntaxNode ParseBaseClassInvokation(ExpressionSyntaxNode expression)
{
if (expression is IdentifierNameSyntaxNode methodName
if (expression is IdentifierNameExpressionSyntaxNode methodName
&& !expression.TrailingTrivia.Any())
{
var atToken = EatToken();
@ -463,7 +463,7 @@ namespace Parser.Internal
{
if (CurrentToken.Kind == TokenKind.IdentifierToken)
{
return Factory.IdentifierNameSyntax(EatToken());
return Factory.IdentifierNameExpressionSyntax(EatToken());
}
if (CurrentToken.Kind == TokenKind.OpenParenthesisToken)
{
@ -523,7 +523,7 @@ namespace Parser.Internal
closeParen);
}
private CompoundNameSyntaxNode ParseCompoundName()
private CompoundNameExpressionSyntaxNode ParseCompoundName()
{
var lastToken = EatToken(TokenKind.IdentifierToken);
var firstName = lastToken;
@ -538,16 +538,16 @@ namespace Parser.Internal
builder.Add(lastToken);
}
return Factory.CompoundNameSyntax(builder.ToList());
return Factory.CompoundNameExpressionSyntax(builder.ToList());
}
private FunctionHandleSyntaxNode ParseFunctionHandle()
private FunctionHandleExpressionSyntaxNode ParseFunctionHandle()
{
var atSign = EatToken();
if (CurrentToken.Kind == TokenKind.IdentifierToken)
{
var compoundName = ParseCompoundName();
return Factory.NamedFunctionHandleSyntax(
return Factory.NamedFunctionHandleExpressionSyntax(
atSign,
compoundName);
}
@ -563,7 +563,7 @@ namespace Parser.Internal
{
throw new Exception($"Lambda expression body cannot be empty.");
}
return Factory.LambdaSyntax(atSign, inputs, body);
return Factory.LambdaExpressionSyntax(atSign, inputs, body);
}
throw new ParsingException($"Unexpected token {CurrentToken} while parsing function handle at {CurrentPosition}.");
}
@ -866,7 +866,7 @@ namespace Parser.Internal
private AttributeSyntaxNode ParseAttribute()
{
var name = Factory.IdentifierNameSyntax(EatToken(TokenKind.IdentifierToken));
var name = Factory.IdentifierNameExpressionSyntax(EatToken(TokenKind.IdentifierToken));
var assignment = ParseAttributeAssignment();
return Factory.AttributeSyntax(name, assignment);
}
@ -1023,7 +1023,7 @@ namespace Parser.Internal
private EnumerationItemSyntaxNode ParseEnumerationItem()
{
var name = Factory.IdentifierNameSyntax(EatToken());
var name = Factory.IdentifierNameExpressionSyntax(EatToken());
var values = ParseEnumerationValue();
var commas = ParseOptionalCommas();
return Factory.EnumerationItemSyntax(name, values, commas);
@ -1104,7 +1104,7 @@ namespace Parser.Internal
{
attributes = ParseAttributesList();
}
var className = Factory.IdentifierNameSyntax(EatToken(TokenKind.IdentifierToken));
var className = Factory.IdentifierNameExpressionSyntax(EatToken(TokenKind.IdentifierToken));
BaseClassListSyntaxNode? baseClassList = null;
if (CurrentToken.Kind == TokenKind.LessToken)
{

28
Parser/Internal/SyntaxFactory.Generated.cs
View File

@ -93,19 +93,19 @@ namespace Parser.Internal
return new UnaryPrefixOperationExpressionSyntaxNode(operation, operand);
}
public CompoundNameSyntaxNode CompoundNameSyntax(SyntaxList nodes)
public CompoundNameExpressionSyntaxNode CompoundNameExpressionSyntax(SyntaxList nodes)
{
return new CompoundNameSyntaxNode(nodes);
return new CompoundNameExpressionSyntaxNode(nodes);
}
public NamedFunctionHandleSyntaxNode NamedFunctionHandleSyntax(SyntaxToken atSign, CompoundNameSyntaxNode functionName)
public NamedFunctionHandleExpressionSyntaxNode NamedFunctionHandleExpressionSyntax(SyntaxToken atSign, CompoundNameExpressionSyntaxNode functionName)
{
return new NamedFunctionHandleSyntaxNode(atSign, functionName);
return new NamedFunctionHandleExpressionSyntaxNode(atSign, functionName);
}
public LambdaSyntaxNode LambdaSyntax(SyntaxToken atSign, FunctionInputDescriptionSyntaxNode input, ExpressionSyntaxNode body)
public LambdaExpressionSyntaxNode LambdaExpressionSyntax(SyntaxToken atSign, FunctionInputDescriptionSyntaxNode input, ExpressionSyntaxNode body)
{
return new LambdaSyntaxNode(atSign, input, body);
return new LambdaExpressionSyntaxNode(atSign, input, body);
}
public BinaryOperationExpressionSyntaxNode BinaryOperationExpressionSyntax(ExpressionSyntaxNode lhs, SyntaxToken operation, ExpressionSyntaxNode rhs)
@ -113,9 +113,9 @@ namespace Parser.Internal
return new BinaryOperationExpressionSyntaxNode(lhs, operation, rhs);
}
public IdentifierNameSyntaxNode IdentifierNameSyntax(SyntaxToken name)
public IdentifierNameExpressionSyntaxNode IdentifierNameExpressionSyntax(SyntaxToken name)
{
return new IdentifierNameSyntaxNode(name);
return new IdentifierNameExpressionSyntaxNode(name);
}
public NumberLiteralSyntaxNode NumberLiteralSyntax(SyntaxToken number)
@ -178,7 +178,7 @@ namespace Parser.Internal
return new IndirectMemberAccessSyntaxNode(openingBracket, expression, closingBracket);
}
public CommandExpressionSyntaxNode CommandExpressionSyntax(IdentifierNameSyntaxNode commandName, SyntaxList<UnquotedStringLiteralSyntaxNode> arguments)
public CommandExpressionSyntaxNode CommandExpressionSyntax(IdentifierNameExpressionSyntaxNode commandName, SyntaxList<UnquotedStringLiteralSyntaxNode> arguments)
{
return new CommandExpressionSyntaxNode(commandName, arguments);
}
@ -193,7 +193,7 @@ namespace Parser.Internal
return new AttributeAssignmentSyntaxNode(assignmentSign, value);
}
public AttributeSyntaxNode AttributeSyntax(IdentifierNameSyntaxNode name, AttributeAssignmentSyntaxNode? assignment)
public AttributeSyntaxNode AttributeSyntax(IdentifierNameExpressionSyntaxNode name, AttributeAssignmentSyntaxNode? assignment)
{
return new AttributeSyntaxNode(name, assignment);
}
@ -203,12 +203,12 @@ namespace Parser.Internal
return new AttributeListSyntaxNode(openingBracket, nodes, closingBracket);
}
public MethodDefinitionSyntaxNode MethodDefinitionSyntax(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList<SyntaxToken> commas, SyntaxList body, EndKeywordSyntaxNode? endKeyword)
public MethodDefinitionSyntaxNode MethodDefinitionSyntax(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList<SyntaxToken> commas, SyntaxList body, EndKeywordSyntaxNode? endKeyword)
{
return new MethodDefinitionSyntaxNode(functionKeyword, outputDescription, name, inputDescription, commas, body, endKeyword);
}
public AbstractMethodDeclarationSyntaxNode AbstractMethodDeclarationSyntax(FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription)
public AbstractMethodDeclarationSyntaxNode AbstractMethodDeclarationSyntax(FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription)
{
return new AbstractMethodDeclarationSyntaxNode(outputDescription, name, inputDescription);
}
@ -228,7 +228,7 @@ namespace Parser.Internal
return new BaseClassListSyntaxNode(lessSign, baseClasses);
}
public ClassDeclarationSyntaxNode ClassDeclarationSyntax(SyntaxToken classdefKeyword, AttributeListSyntaxNode? attributes, IdentifierNameSyntaxNode className, BaseClassListSyntaxNode? baseClassList, SyntaxList nodes, SyntaxToken endKeyword)
public ClassDeclarationSyntaxNode ClassDeclarationSyntax(SyntaxToken classdefKeyword, AttributeListSyntaxNode? attributes, IdentifierNameExpressionSyntaxNode className, BaseClassListSyntaxNode? baseClassList, SyntaxList nodes, SyntaxToken endKeyword)
{
return new ClassDeclarationSyntaxNode(classdefKeyword, attributes, className, baseClassList, nodes, endKeyword);
}
@ -238,7 +238,7 @@ namespace Parser.Internal
return new EnumerationItemValueSyntaxNode(openingBracket, values, closingBracket);
}
public EnumerationItemSyntaxNode EnumerationItemSyntax(IdentifierNameSyntaxNode name, EnumerationItemValueSyntaxNode? values, SyntaxList<SyntaxToken> commas)
public EnumerationItemSyntaxNode EnumerationItemSyntax(IdentifierNameExpressionSyntaxNode name, EnumerationItemValueSyntaxNode? values, SyntaxList<SyntaxToken> commas)
{
return new EnumerationItemSyntaxNode(name, values, commas);
}

102
Parser/Internal/SyntaxNode.Generated.cs
View File

@ -890,17 +890,17 @@ namespace Parser.Internal
}
}
internal class CompoundNameSyntaxNode : ExpressionSyntaxNode
internal class CompoundNameExpressionSyntaxNode : ExpressionSyntaxNode
{
internal readonly SyntaxList _nodes;
internal CompoundNameSyntaxNode(SyntaxList nodes): base(TokenKind.CompoundName)
internal CompoundNameExpressionSyntaxNode(SyntaxList nodes): base(TokenKind.CompoundNameExpression)
{
Slots = 1;
this.AdjustWidth(nodes);
_nodes = nodes;
}
internal CompoundNameSyntaxNode(SyntaxList nodes, TokenDiagnostic[] diagnostics): base(TokenKind.CompoundName, diagnostics)
internal CompoundNameExpressionSyntaxNode(SyntaxList nodes, TokenDiagnostic[] diagnostics): base(TokenKind.CompoundNameExpression, diagnostics)
{
Slots = 1;
this.AdjustWidth(nodes);
@ -909,12 +909,12 @@ namespace Parser.Internal
internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position)
{
return new Parser.CompoundNameSyntaxNode(parent, this, position);
return new Parser.CompoundNameExpressionSyntaxNode(parent, this, position);
}
public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics)
{
return new CompoundNameSyntaxNode(_nodes, diagnostics);
return new CompoundNameExpressionSyntaxNode(_nodes, diagnostics);
}
public override GreenNode? GetSlot(int i)
@ -928,11 +928,11 @@ namespace Parser.Internal
}
}
internal class NamedFunctionHandleSyntaxNode : FunctionHandleSyntaxNode
internal class NamedFunctionHandleExpressionSyntaxNode : FunctionHandleExpressionSyntaxNode
{
internal readonly SyntaxToken _atSign;
internal readonly CompoundNameSyntaxNode _functionName;
internal NamedFunctionHandleSyntaxNode(SyntaxToken atSign, CompoundNameSyntaxNode functionName): base(TokenKind.NamedFunctionHandle)
internal readonly CompoundNameExpressionSyntaxNode _functionName;
internal NamedFunctionHandleExpressionSyntaxNode(SyntaxToken atSign, CompoundNameExpressionSyntaxNode functionName): base(TokenKind.NamedFunctionHandleExpression)
{
Slots = 2;
this.AdjustWidth(atSign);
@ -941,7 +941,7 @@ namespace Parser.Internal
_functionName = functionName;
}
internal NamedFunctionHandleSyntaxNode(SyntaxToken atSign, CompoundNameSyntaxNode functionName, TokenDiagnostic[] diagnostics): base(TokenKind.NamedFunctionHandle, diagnostics)
internal NamedFunctionHandleExpressionSyntaxNode(SyntaxToken atSign, CompoundNameExpressionSyntaxNode functionName, TokenDiagnostic[] diagnostics): base(TokenKind.NamedFunctionHandleExpression, diagnostics)
{
Slots = 2;
this.AdjustWidth(atSign);
@ -952,12 +952,12 @@ namespace Parser.Internal
internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position)
{
return new Parser.NamedFunctionHandleSyntaxNode(parent, this, position);
return new Parser.NamedFunctionHandleExpressionSyntaxNode(parent, this, position);
}
public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics)
{
return new NamedFunctionHandleSyntaxNode(_atSign, _functionName, diagnostics);
return new NamedFunctionHandleExpressionSyntaxNode(_atSign, _functionName, diagnostics);
}
public override GreenNode? GetSlot(int i)
@ -971,12 +971,12 @@ namespace Parser.Internal
}
}
internal class LambdaSyntaxNode : FunctionHandleSyntaxNode
internal class LambdaExpressionSyntaxNode : FunctionHandleExpressionSyntaxNode
{
internal readonly SyntaxToken _atSign;
internal readonly FunctionInputDescriptionSyntaxNode _input;
internal readonly ExpressionSyntaxNode _body;
internal LambdaSyntaxNode(SyntaxToken atSign, FunctionInputDescriptionSyntaxNode input, ExpressionSyntaxNode body): base(TokenKind.Lambda)
internal LambdaExpressionSyntaxNode(SyntaxToken atSign, FunctionInputDescriptionSyntaxNode input, ExpressionSyntaxNode body): base(TokenKind.LambdaExpression)
{
Slots = 3;
this.AdjustWidth(atSign);
@ -987,7 +987,7 @@ namespace Parser.Internal
_body = body;
}
internal LambdaSyntaxNode(SyntaxToken atSign, FunctionInputDescriptionSyntaxNode input, ExpressionSyntaxNode body, TokenDiagnostic[] diagnostics): base(TokenKind.Lambda, diagnostics)
internal LambdaExpressionSyntaxNode(SyntaxToken atSign, FunctionInputDescriptionSyntaxNode input, ExpressionSyntaxNode body, TokenDiagnostic[] diagnostics): base(TokenKind.LambdaExpression, diagnostics)
{
Slots = 3;
this.AdjustWidth(atSign);
@ -1000,12 +1000,12 @@ namespace Parser.Internal
internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position)
{
return new Parser.LambdaSyntaxNode(parent, this, position);
return new Parser.LambdaExpressionSyntaxNode(parent, this, position);
}
public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics)
{
return new LambdaSyntaxNode(_atSign, _input, _body, diagnostics);
return new LambdaExpressionSyntaxNode(_atSign, _input, _body, diagnostics);
}
public override GreenNode? GetSlot(int i)
@ -1024,7 +1024,7 @@ namespace Parser.Internal
internal readonly ExpressionSyntaxNode _lhs;
internal readonly SyntaxToken _operation;
internal readonly ExpressionSyntaxNode _rhs;
internal BinaryOperationExpressionSyntaxNode(ExpressionSyntaxNode lhs, SyntaxToken operation, ExpressionSyntaxNode rhs): base(TokenKind.BinaryOperation)
internal BinaryOperationExpressionSyntaxNode(ExpressionSyntaxNode lhs, SyntaxToken operation, ExpressionSyntaxNode rhs): base(TokenKind.BinaryOperationExpression)
{
Slots = 3;
this.AdjustWidth(lhs);
@ -1035,7 +1035,7 @@ namespace Parser.Internal
_rhs = rhs;
}
internal BinaryOperationExpressionSyntaxNode(ExpressionSyntaxNode lhs, SyntaxToken operation, ExpressionSyntaxNode rhs, TokenDiagnostic[] diagnostics): base(TokenKind.BinaryOperation, diagnostics)
internal BinaryOperationExpressionSyntaxNode(ExpressionSyntaxNode lhs, SyntaxToken operation, ExpressionSyntaxNode rhs, TokenDiagnostic[] diagnostics): base(TokenKind.BinaryOperationExpression, diagnostics)
{
Slots = 3;
this.AdjustWidth(lhs);
@ -1067,17 +1067,17 @@ namespace Parser.Internal
}
}
internal class IdentifierNameSyntaxNode : ExpressionSyntaxNode
internal class IdentifierNameExpressionSyntaxNode : ExpressionSyntaxNode
{
internal readonly SyntaxToken _name;
internal IdentifierNameSyntaxNode(SyntaxToken name): base(TokenKind.IdentifierName)
internal IdentifierNameExpressionSyntaxNode(SyntaxToken name): base(TokenKind.IdentifierNameExpression)
{
Slots = 1;
this.AdjustWidth(name);
_name = name;
}
internal IdentifierNameSyntaxNode(SyntaxToken name, TokenDiagnostic[] diagnostics): base(TokenKind.IdentifierName, diagnostics)
internal IdentifierNameExpressionSyntaxNode(SyntaxToken name, TokenDiagnostic[] diagnostics): base(TokenKind.IdentifierNameExpression, diagnostics)
{
Slots = 1;
this.AdjustWidth(name);
@ -1086,12 +1086,12 @@ namespace Parser.Internal
internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position)
{
return new Parser.IdentifierNameSyntaxNode(parent, this, position);
return new Parser.IdentifierNameExpressionSyntaxNode(parent, this, position);
}
public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics)
{
return new IdentifierNameSyntaxNode(_name, diagnostics);
return new IdentifierNameExpressionSyntaxNode(_name, diagnostics);
}
public override GreenNode? GetSlot(int i)
@ -1407,7 +1407,7 @@ namespace Parser.Internal
internal readonly SyntaxToken _openingBrace;
internal readonly SyntaxList _nodes;
internal readonly SyntaxToken _closingBrace;
internal CellArrayElementAccessExpressionSyntaxNode(ExpressionSyntaxNode expression, SyntaxToken openingBrace, SyntaxList nodes, SyntaxToken closingBrace): base(TokenKind.CellArrayElementAccess)
internal CellArrayElementAccessExpressionSyntaxNode(ExpressionSyntaxNode expression, SyntaxToken openingBrace, SyntaxList nodes, SyntaxToken closingBrace): base(TokenKind.CellArrayElementAccessExpression)
{
Slots = 4;
this.AdjustWidth(expression);
@ -1420,7 +1420,7 @@ namespace Parser.Internal
_closingBrace = closingBrace;
}
internal CellArrayElementAccessExpressionSyntaxNode(ExpressionSyntaxNode expression, SyntaxToken openingBrace, SyntaxList nodes, SyntaxToken closingBrace, TokenDiagnostic[] diagnostics): base(TokenKind.CellArrayElementAccess, diagnostics)
internal CellArrayElementAccessExpressionSyntaxNode(ExpressionSyntaxNode expression, SyntaxToken openingBrace, SyntaxList nodes, SyntaxToken closingBrace, TokenDiagnostic[] diagnostics): base(TokenKind.CellArrayElementAccessExpression, diagnostics)
{
Slots = 4;
this.AdjustWidth(expression);
@ -1460,7 +1460,7 @@ namespace Parser.Internal
internal readonly SyntaxToken _openingBracket;
internal readonly SyntaxList _nodes;
internal readonly SyntaxToken _closingBracket;
internal FunctionCallExpressionSyntaxNode(ExpressionSyntaxNode functionName, SyntaxToken openingBracket, SyntaxList nodes, SyntaxToken closingBracket): base(TokenKind.FunctionCall)
internal FunctionCallExpressionSyntaxNode(ExpressionSyntaxNode functionName, SyntaxToken openingBracket, SyntaxList nodes, SyntaxToken closingBracket): base(TokenKind.FunctionCallExpression)
{
Slots = 4;
this.AdjustWidth(functionName);
@ -1473,7 +1473,7 @@ namespace Parser.Internal
_closingBracket = closingBracket;
}
internal FunctionCallExpressionSyntaxNode(ExpressionSyntaxNode functionName, SyntaxToken openingBracket, SyntaxList nodes, SyntaxToken closingBracket, TokenDiagnostic[] diagnostics): base(TokenKind.FunctionCall, diagnostics)
internal FunctionCallExpressionSyntaxNode(ExpressionSyntaxNode functionName, SyntaxToken openingBracket, SyntaxList nodes, SyntaxToken closingBracket, TokenDiagnostic[] diagnostics): base(TokenKind.FunctionCallExpression, diagnostics)
{
Slots = 4;
this.AdjustWidth(functionName);
@ -1512,7 +1512,7 @@ namespace Parser.Internal
internal readonly SyntaxNode _leftOperand;
internal readonly SyntaxToken _dot;
internal readonly SyntaxNode _rightOperand;
internal MemberAccessSyntaxNode(SyntaxNode leftOperand, SyntaxToken dot, SyntaxNode rightOperand): base(TokenKind.MemberAccess)
internal MemberAccessSyntaxNode(SyntaxNode leftOperand, SyntaxToken dot, SyntaxNode rightOperand): base(TokenKind.MemberAccessExpression)
{
Slots = 3;
this.AdjustWidth(leftOperand);
@ -1523,7 +1523,7 @@ namespace Parser.Internal
_rightOperand = rightOperand;
}
internal MemberAccessSyntaxNode(SyntaxNode leftOperand, SyntaxToken dot, SyntaxNode rightOperand, TokenDiagnostic[] diagnostics): base(TokenKind.MemberAccess, diagnostics)
internal MemberAccessSyntaxNode(SyntaxNode leftOperand, SyntaxToken dot, SyntaxNode rightOperand, TokenDiagnostic[] diagnostics): base(TokenKind.MemberAccessExpression, diagnostics)
{
Slots = 3;
this.AdjustWidth(leftOperand);
@ -1603,7 +1603,7 @@ namespace Parser.Internal
internal readonly SyntaxToken _openingBracket;
internal readonly ExpressionSyntaxNode _expression;
internal readonly SyntaxToken _closingBracket;
internal IndirectMemberAccessSyntaxNode(SyntaxToken openingBracket, ExpressionSyntaxNode expression, SyntaxToken closingBracket): base(TokenKind.IndirectMemberAccess)
internal IndirectMemberAccessSyntaxNode(SyntaxToken openingBracket, ExpressionSyntaxNode expression, SyntaxToken closingBracket): base(TokenKind.IndirectMemberAccessExpression)
{
Slots = 3;
this.AdjustWidth(openingBracket);
@ -1614,7 +1614,7 @@ namespace Parser.Internal
_closingBracket = closingBracket;
}
internal IndirectMemberAccessSyntaxNode(SyntaxToken openingBracket, ExpressionSyntaxNode expression, SyntaxToken closingBracket, TokenDiagnostic[] diagnostics): base(TokenKind.IndirectMemberAccess, diagnostics)
internal IndirectMemberAccessSyntaxNode(SyntaxToken openingBracket, ExpressionSyntaxNode expression, SyntaxToken closingBracket, TokenDiagnostic[] diagnostics): base(TokenKind.IndirectMemberAccessExpression, diagnostics)
{
Slots = 3;
this.AdjustWidth(openingBracket);
@ -1648,9 +1648,9 @@ namespace Parser.Internal
internal class CommandExpressionSyntaxNode : ExpressionSyntaxNode
{
internal readonly IdentifierNameSyntaxNode _commandName;
internal readonly IdentifierNameExpressionSyntaxNode _commandName;
internal readonly SyntaxList<UnquotedStringLiteralSyntaxNode> _arguments;
internal CommandExpressionSyntaxNode(IdentifierNameSyntaxNode commandName, SyntaxList<UnquotedStringLiteralSyntaxNode> arguments): base(TokenKind.Command)
internal CommandExpressionSyntaxNode(IdentifierNameExpressionSyntaxNode commandName, SyntaxList<UnquotedStringLiteralSyntaxNode> arguments): base(TokenKind.CommandExpression)
{
Slots = 2;
this.AdjustWidth(commandName);
@ -1659,7 +1659,7 @@ namespace Parser.Internal
_arguments = arguments;
}
internal CommandExpressionSyntaxNode(IdentifierNameSyntaxNode commandName, SyntaxList<UnquotedStringLiteralSyntaxNode> arguments, TokenDiagnostic[] diagnostics): base(TokenKind.Command, diagnostics)
internal CommandExpressionSyntaxNode(IdentifierNameExpressionSyntaxNode commandName, SyntaxList<UnquotedStringLiteralSyntaxNode> arguments, TokenDiagnostic[] diagnostics): base(TokenKind.CommandExpression, diagnostics)
{
Slots = 2;
this.AdjustWidth(commandName);
@ -1694,7 +1694,7 @@ namespace Parser.Internal
internal readonly ExpressionSyntaxNode _methodName;
internal readonly SyntaxToken _atSign;
internal readonly ExpressionSyntaxNode _baseClassNameAndArguments;
internal BaseClassInvokationSyntaxNode(ExpressionSyntaxNode methodName, SyntaxToken atSign, ExpressionSyntaxNode baseClassNameAndArguments): base(TokenKind.ClassInvokation)
internal BaseClassInvokationSyntaxNode(ExpressionSyntaxNode methodName, SyntaxToken atSign, ExpressionSyntaxNode baseClassNameAndArguments): base(TokenKind.ClassInvokationExpression)
{
Slots = 3;
this.AdjustWidth(methodName);
@ -1705,7 +1705,7 @@ namespace Parser.Internal
_baseClassNameAndArguments = baseClassNameAndArguments;
}
internal BaseClassInvokationSyntaxNode(ExpressionSyntaxNode methodName, SyntaxToken atSign, ExpressionSyntaxNode baseClassNameAndArguments, TokenDiagnostic[] diagnostics): base(TokenKind.ClassInvokation, diagnostics)
internal BaseClassInvokationSyntaxNode(ExpressionSyntaxNode methodName, SyntaxToken atSign, ExpressionSyntaxNode baseClassNameAndArguments, TokenDiagnostic[] diagnostics): base(TokenKind.ClassInvokationExpression, diagnostics)
{
Slots = 3;
this.AdjustWidth(methodName);
@ -1782,9 +1782,9 @@ namespace Parser.Internal
internal class AttributeSyntaxNode : SyntaxNode
{
internal readonly IdentifierNameSyntaxNode _name;
internal readonly IdentifierNameExpressionSyntaxNode _name;
internal readonly AttributeAssignmentSyntaxNode? _assignment;
internal AttributeSyntaxNode(IdentifierNameSyntaxNode name, AttributeAssignmentSyntaxNode? assignment): base(TokenKind.Attribute)
internal AttributeSyntaxNode(IdentifierNameExpressionSyntaxNode name, AttributeAssignmentSyntaxNode? assignment): base(TokenKind.Attribute)
{
Slots = 2;
this.AdjustWidth(name);
@ -1793,7 +1793,7 @@ namespace Parser.Internal
_assignment = assignment;
}
internal AttributeSyntaxNode(IdentifierNameSyntaxNode name, AttributeAssignmentSyntaxNode? assignment, TokenDiagnostic[] diagnostics): base(TokenKind.Attribute, diagnostics)
internal AttributeSyntaxNode(IdentifierNameExpressionSyntaxNode name, AttributeAssignmentSyntaxNode? assignment, TokenDiagnostic[] diagnostics): base(TokenKind.Attribute, diagnostics)
{
Slots = 2;
this.AdjustWidth(name);
@ -1875,12 +1875,12 @@ namespace Parser.Internal
{
internal readonly SyntaxToken _functionKeyword;
internal readonly FunctionOutputDescriptionSyntaxNode? _outputDescription;
internal readonly CompoundNameSyntaxNode _name;
internal readonly CompoundNameExpressionSyntaxNode _name;
internal readonly FunctionInputDescriptionSyntaxNode? _inputDescription;
internal readonly SyntaxList<SyntaxToken> _commas;
internal readonly SyntaxList _body;
internal readonly EndKeywordSyntaxNode? _endKeyword;
internal MethodDefinitionSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList<SyntaxToken> commas, SyntaxList body, EndKeywordSyntaxNode? endKeyword): base(TokenKind.MethodDefinition)
internal MethodDefinitionSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList<SyntaxToken> commas, SyntaxList body, EndKeywordSyntaxNode? endKeyword): base(TokenKind.ConcreteMethodDeclaration)
{
Slots = 7;
this.AdjustWidth(functionKeyword);
@ -1899,7 +1899,7 @@ namespace Parser.Internal
_endKeyword = endKeyword;
}
internal MethodDefinitionSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList<SyntaxToken> commas, SyntaxList body, EndKeywordSyntaxNode? endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.MethodDefinition, diagnostics)
internal MethodDefinitionSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList<SyntaxToken> commas, SyntaxList body, EndKeywordSyntaxNode? endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.ConcreteMethodDeclaration, diagnostics)
{
Slots = 7;
this.AdjustWidth(functionKeyword);
@ -1942,9 +1942,9 @@ namespace Parser.Internal
internal class AbstractMethodDeclarationSyntaxNode : MethodDeclarationSyntaxNode
{
internal readonly FunctionOutputDescriptionSyntaxNode? _outputDescription;
internal readonly CompoundNameSyntaxNode _name;
internal readonly CompoundNameExpressionSyntaxNode _name;
internal readonly FunctionInputDescriptionSyntaxNode? _inputDescription;
internal AbstractMethodDeclarationSyntaxNode(FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription): base(TokenKind.AbstractMethodDeclaration)
internal AbstractMethodDeclarationSyntaxNode(FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription): base(TokenKind.AbstractMethodDeclaration)
{
Slots = 3;
this.AdjustWidth(outputDescription);
@ -1955,7 +1955,7 @@ namespace Parser.Internal
_inputDescription = inputDescription;
}
internal AbstractMethodDeclarationSyntaxNode(FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, TokenDiagnostic[] diagnostics): base(TokenKind.AbstractMethodDeclaration, diagnostics)
internal AbstractMethodDeclarationSyntaxNode(FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, TokenDiagnostic[] diagnostics): base(TokenKind.AbstractMethodDeclaration, diagnostics)
{
Slots = 3;
this.AdjustWidth(outputDescription);
@ -2140,11 +2140,11 @@ namespace Parser.Internal
{
internal readonly SyntaxToken _classdefKeyword;
internal readonly AttributeListSyntaxNode? _attributes;
internal readonly IdentifierNameSyntaxNode _className;
internal readonly IdentifierNameExpressionSyntaxNode _className;
internal readonly BaseClassListSyntaxNode? _baseClassList;
internal readonly SyntaxList _nodes;
internal readonly SyntaxToken _endKeyword;
internal ClassDeclarationSyntaxNode(SyntaxToken classdefKeyword, AttributeListSyntaxNode? attributes, IdentifierNameSyntaxNode className, BaseClassListSyntaxNode? baseClassList, SyntaxList nodes, SyntaxToken endKeyword): base(TokenKind.ClassDeclaration)
internal ClassDeclarationSyntaxNode(SyntaxToken classdefKeyword, AttributeListSyntaxNode? attributes, IdentifierNameExpressionSyntaxNode className, BaseClassListSyntaxNode? baseClassList, SyntaxList nodes, SyntaxToken endKeyword): base(TokenKind.ClassDeclaration)
{
Slots = 6;
this.AdjustWidth(classdefKeyword);
@ -2161,7 +2161,7 @@ namespace Parser.Internal
_endKeyword = endKeyword;
}
internal ClassDeclarationSyntaxNode(SyntaxToken classdefKeyword, AttributeListSyntaxNode? attributes, IdentifierNameSyntaxNode className, BaseClassListSyntaxNode? baseClassList, SyntaxList nodes, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.ClassDeclaration, diagnostics)
internal ClassDeclarationSyntaxNode(SyntaxToken classdefKeyword, AttributeListSyntaxNode? attributes, IdentifierNameExpressionSyntaxNode className, BaseClassListSyntaxNode? baseClassList, SyntaxList nodes, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.ClassDeclaration, diagnostics)
{
Slots = 6;
this.AdjustWidth(classdefKeyword);
@ -2249,10 +2249,10 @@ namespace Parser.Internal
internal class EnumerationItemSyntaxNode : SyntaxNode
{
internal readonly IdentifierNameSyntaxNode _name;
internal readonly IdentifierNameExpressionSyntaxNode _name;
internal readonly EnumerationItemValueSyntaxNode? _values;
internal readonly SyntaxList<SyntaxToken> _commas;
internal EnumerationItemSyntaxNode(IdentifierNameSyntaxNode name, EnumerationItemValueSyntaxNode? values, SyntaxList<SyntaxToken> commas): base(TokenKind.EnumerationItem)
internal EnumerationItemSyntaxNode(IdentifierNameExpressionSyntaxNode name, EnumerationItemValueSyntaxNode? values, SyntaxList<SyntaxToken> commas): base(TokenKind.EnumerationItem)
{
Slots = 3;
this.AdjustWidth(name);
@ -2263,7 +2263,7 @@ namespace Parser.Internal
_commas = commas;
}
internal EnumerationItemSyntaxNode(IdentifierNameSyntaxNode name, EnumerationItemValueSyntaxNode? values, SyntaxList<SyntaxToken> commas, TokenDiagnostic[] diagnostics): base(TokenKind.EnumerationItem, diagnostics)
internal EnumerationItemSyntaxNode(IdentifierNameExpressionSyntaxNode name, EnumerationItemValueSyntaxNode? values, SyntaxList<SyntaxToken> commas, TokenDiagnostic[] diagnostics): base(TokenKind.EnumerationItem, diagnostics)
{
Slots = 3;
this.AdjustWidth(name);

6
Parser/Internal/SyntaxNode.cs
View File

@ -79,13 +79,13 @@ namespace Parser.Internal
}
}
internal abstract class FunctionHandleSyntaxNode : ExpressionSyntaxNode
internal abstract class FunctionHandleExpressionSyntaxNode : ExpressionSyntaxNode
{
protected FunctionHandleSyntaxNode(TokenKind kind) : base(kind)
protected FunctionHandleExpressionSyntaxNode(TokenKind kind) : base(kind)
{
}
protected FunctionHandleSyntaxNode(TokenKind kind, TokenDiagnostic[] diagnostics) : base(kind, diagnostics)
protected FunctionHandleExpressionSyntaxNode(TokenKind kind, TokenDiagnostic[] diagnostics) : base(kind, diagnostics)
{
}
}

38
SyntaxGenerator/input.xml → Parser/SyntaxDefinition.xml
View File

@ -95,24 +95,24 @@
<Field Type="SyntaxToken" Name="operation" />
<Field Type="ExpressionSyntaxNode" Name="operand" />
</Class>
<Class Name="CompoundNameSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="CompoundName">
<Class Name="CompoundNameExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="CompoundNameExpression">
<Field Type="SyntaxList" Name="nodes" />
</Class>
<Class Name="NamedFunctionHandleSyntaxNode" BaseClass="FunctionHandleSyntaxNode" Kind="NamedFunctionHandle">
<Class Name="NamedFunctionHandleExpressionSyntaxNode" BaseClass="FunctionHandleExpressionSyntaxNode" Kind="NamedFunctionHandleExpression">
<Field Type="SyntaxToken" Name="atSign" />
<Field Type="CompoundNameSyntaxNode" Name="functionName" />
<Field Type="CompoundNameExpressionSyntaxNode" Name="functionName" />
</Class>
<Class Name="LambdaSyntaxNode" BaseClass="FunctionHandleSyntaxNode" Kind="Lambda">
<Class Name="LambdaExpressionSyntaxNode" BaseClass="FunctionHandleExpressionSyntaxNode" Kind="LambdaExpression">
<Field Type="SyntaxToken" Name="atSign" />
<Field Type="FunctionInputDescriptionSyntaxNode" Name="input" />
<Field Type="ExpressionSyntaxNode" Name="body" />
</Class>
<Class Name="BinaryOperationExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="BinaryOperation">
<Class Name="BinaryOperationExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="BinaryOperationExpression">
<Field Type="ExpressionSyntaxNode" Name="lhs" />
<Field Type="SyntaxToken" Name="operation" />
<Field Type="ExpressionSyntaxNode" Name="rhs" />
</Class>
<Class Name="IdentifierNameSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="IdentifierName">
<Class Name="IdentifierNameExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="IdentifierNameExpression">
<Field Type="SyntaxToken" Name="name" />
</Class>
<Class Name="NumberLiteralSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="NumberLiteralExpression">
@ -142,19 +142,19 @@
<Field Type="ExpressionSyntaxNode" Name="expression" />
<Field Type="SyntaxToken" Name="closingBracket" />
</Class>
<Class Name="CellArrayElementAccessExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="CellArrayElementAccess">
<Class Name="CellArrayElementAccessExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="CellArrayElementAccessExpression">
<Field Type="ExpressionSyntaxNode" Name="expression" />
<Field Type="SyntaxToken" Name="openingBrace" />
<Field Type="SyntaxList" Name="nodes" />
<Field Type="SyntaxToken" Name="closingBrace" />
</Class>
<Class Name="FunctionCallExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="FunctionCall">
<Class Name="FunctionCallExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="FunctionCallExpression">
<Field Type="ExpressionSyntaxNode" Name="functionName" />
<Field Type="SyntaxToken" Name="openingBracket" />
<Field Type="SyntaxList" Name="nodes" />
<Field Type="SyntaxToken" Name="closingBracket" />
</Class>
<Class Name="MemberAccessSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="MemberAccess">
<Class Name="MemberAccessSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="MemberAccessExpression">
<Field Type="SyntaxNode" Name="leftOperand" />
<Field Type="SyntaxToken" Name="dot" />
<Field Type="SyntaxNode" Name="rightOperand" />
@ -163,16 +163,16 @@
<Field Type="ExpressionSyntaxNode" Name="operand" />
<Field Type="SyntaxToken" Name="operation" />
</Class>
<Class Name="IndirectMemberAccessSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="IndirectMemberAccess">
<Class Name="IndirectMemberAccessSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="IndirectMemberAccessExpression">
<Field Type="SyntaxToken" Name="openingBracket" />
<Field Type="ExpressionSyntaxNode" Name="expression" />
<Field Type="SyntaxToken" Name="closingBracket" />
</Class>
<Class Name="CommandExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="Command">
<Field Type="IdentifierNameSyntaxNode" Name="commandName" />
<Class Name="CommandExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="CommandExpression">
<Field Type="IdentifierNameExpressionSyntaxNode" Name="commandName" />
<Field Type="SyntaxList&lt;UnquotedStringLiteralSyntaxNode&gt;" Name="arguments" />
</Class>
<Class Name="BaseClassInvokationSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="ClassInvokation">
<Class Name="BaseClassInvokationSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="ClassInvokationExpression">
<Field Type="ExpressionSyntaxNode" Name="methodName" />
<Field Type="SyntaxToken" Name="atSign" />
<Field Type="ExpressionSyntaxNode" Name="baseClassNameAndArguments" />
@ -182,7 +182,7 @@
<Field Type="ExpressionSyntaxNode" Name="value" />
</Class>
<Class Name="AttributeSyntaxNode" BaseClass="SyntaxNode" Kind="Attribute">
<Field Type="IdentifierNameSyntaxNode" Name="name" />
<Field Type="IdentifierNameExpressionSyntaxNode" Name="name" />
<Field Type="AttributeAssignmentSyntaxNode" Name="assignment" Nullable="true" />
</Class>
<Class Name="AttributeListSyntaxNode" BaseClass="SyntaxNode" Kind="AttributeList">
@ -190,10 +190,10 @@
<Field Type="SyntaxList" Name="nodes" />
<Field Type="SyntaxToken" Name="closingBracket" />
</Class>
<Class Name="MethodDefinitionSyntaxNode" BaseClass="MethodDeclarationSyntaxNode" Kind="MethodDefinition">
<Class Name="MethodDefinitionSyntaxNode" BaseClass="MethodDeclarationSyntaxNode" Kind="ConcreteMethodDeclaration">
<Field Type="SyntaxToken" Name="functionKeyword" />
<Field Type="FunctionOutputDescriptionSyntaxNode" Name="outputDescription" Nullable="true" />
<Field Type="CompoundNameSyntaxNode" Name="name" />
<Field Type="CompoundNameExpressionSyntaxNode" Name="name" />
<Field Type="FunctionInputDescriptionSyntaxNode" Name="inputDescription" Nullable="true"/>
<Field Type="SyntaxList&lt;SyntaxToken&gt;" Name="commas" />
<Field Type="SyntaxList" Name="body" />
@ -201,7 +201,7 @@
</Class>
<Class Name="AbstractMethodDeclarationSyntaxNode" BaseClass="MethodDeclarationSyntaxNode" Kind="AbstractMethodDeclaration">
<Field Type="FunctionOutputDescriptionSyntaxNode" Name="outputDescription" Nullable="true" />
<Field Type="CompoundNameSyntaxNode" Name="name" />
<Field Type="CompoundNameExpressionSyntaxNode" Name="name" />
<Field Type="FunctionInputDescriptionSyntaxNode" Name="inputDescription" Nullable="true"/>
</Class>
<Class Name="MethodsListSyntaxNode" BaseClass="SyntaxNode" Kind="MethodsList">
@ -223,7 +223,7 @@
<Class Name="ClassDeclarationSyntaxNode" BaseClass="StatementSyntaxNode" Kind="ClassDeclaration">
<Field Type="SyntaxToken" Name="classdefKeyword" />
<Field Type="AttributeListSyntaxNode" Name="attributes" Nullable="true" />
<Field Type="IdentifierNameSyntaxNode" Name="className" />
<Field Type="IdentifierNameExpressionSyntaxNode" Name="className" />
<Field Type="BaseClassListSyntaxNode" Name="baseClassList" Nullable="true" />
<Field Type="SyntaxList" Name="nodes" />
<Field Type="SyntaxToken" Name="endKeyword" />
@ -234,7 +234,7 @@
<Field Type="SyntaxToken" Name="closingBracket" />
</Class>
<Class Name="EnumerationItemSyntaxNode" BaseClass="SyntaxNode" Kind="EnumerationItem">
<Field Type="IdentifierNameSyntaxNode" Name="name" />
<Field Type="IdentifierNameExpressionSyntaxNode" Name="name" />
<Field Type="EnumerationItemValueSyntaxNode" Name="values" Nullable="true"/>
<Field Type="SyntaxList&lt;SyntaxToken&gt;" Name="commas" />
</Class>

58
Parser/SyntaxNode.Generated.cs
View File

@ -941,10 +941,10 @@ namespace Parser
}
}
public class CompoundNameSyntaxNode : ExpressionSyntaxNode
public class CompoundNameExpressionSyntaxNode : ExpressionSyntaxNode
{
private SyntaxNode? _nodes;
internal CompoundNameSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position)
internal CompoundNameExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position)
{
}
@ -969,14 +969,14 @@ namespace Parser
public override void Accept(SyntaxVisitor visitor)
{
visitor.VisitCompoundName(this);
visitor.VisitCompoundNameExpression(this);
}
}
public class NamedFunctionHandleSyntaxNode : FunctionHandleSyntaxNode
public class NamedFunctionHandleExpressionSyntaxNode : FunctionHandleExpressionSyntaxNode
{
private SyntaxNode? _functionName;
internal NamedFunctionHandleSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position)
internal NamedFunctionHandleExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position)
{
}
@ -984,16 +984,16 @@ namespace Parser
{
get
{
return new SyntaxToken(this, ((Parser.Internal.NamedFunctionHandleSyntaxNode)_green)._atSign, this.GetChildPosition(0));
return new SyntaxToken(this, ((Parser.Internal.NamedFunctionHandleExpressionSyntaxNode)_green)._atSign, this.GetChildPosition(0));
}
}
public CompoundNameSyntaxNode FunctionName
public CompoundNameExpressionSyntaxNode FunctionName
{
get
{
var red = this.GetRed(ref this._functionName!, 1);
return red is null ? throw new System.Exception("functionName cannot be null.") : (CompoundNameSyntaxNode)red;
return red is null ? throw new System.Exception("functionName cannot be null.") : (CompoundNameExpressionSyntaxNode)red;
}
}
@ -1009,15 +1009,15 @@ namespace Parser
public override void Accept(SyntaxVisitor visitor)
{
visitor.VisitNamedFunctionHandle(this);
visitor.VisitNamedFunctionHandleExpression(this);
}
}
public class LambdaSyntaxNode : FunctionHandleSyntaxNode
public class LambdaExpressionSyntaxNode : FunctionHandleExpressionSyntaxNode
{
private SyntaxNode? _input;
private SyntaxNode? _body;
internal LambdaSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position)
internal LambdaExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position)
{
}
@ -1025,7 +1025,7 @@ namespace Parser
{
get
{
return new SyntaxToken(this, ((Parser.Internal.LambdaSyntaxNode)_green)._atSign, this.GetChildPosition(0));
return new SyntaxToken(this, ((Parser.Internal.LambdaExpressionSyntaxNode)_green)._atSign, this.GetChildPosition(0));
}
}
@ -1059,7 +1059,7 @@ namespace Parser
public override void Accept(SyntaxVisitor visitor)
{
visitor.VisitLambda(this);
visitor.VisitLambdaExpression(this);
}
}
@ -1113,9 +1113,9 @@ namespace Parser
}
}
public class IdentifierNameSyntaxNode : ExpressionSyntaxNode
public class IdentifierNameExpressionSyntaxNode : ExpressionSyntaxNode
{
internal IdentifierNameSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position)
internal IdentifierNameExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position)
{
}
@ -1123,7 +1123,7 @@ namespace Parser
{
get
{
return new SyntaxToken(this, ((Parser.Internal.IdentifierNameSyntaxNode)_green)._name, this.GetChildPosition(0));
return new SyntaxToken(this, ((Parser.Internal.IdentifierNameExpressionSyntaxNode)_green)._name, this.GetChildPosition(0));
}
}
@ -1139,7 +1139,7 @@ namespace Parser
public override void Accept(SyntaxVisitor visitor)
{
visitor.VisitIdentifierName(this);
visitor.VisitIdentifierNameExpression(this);
}
}
@ -1669,12 +1669,12 @@ namespace Parser
{
}
public IdentifierNameSyntaxNode CommandName
public IdentifierNameExpressionSyntaxNode CommandName
{
get
{
var red = this.GetRed(ref this._commandName!, 0);
return red is null ? throw new System.Exception("commandName cannot be null.") : (IdentifierNameSyntaxNode)red;
return red is null ? throw new System.Exception("commandName cannot be null.") : (IdentifierNameExpressionSyntaxNode)red;
}
}
@ -1801,12 +1801,12 @@ namespace Parser
{
}
public IdentifierNameSyntaxNode Name
public IdentifierNameExpressionSyntaxNode Name
{
get
{
var red = this.GetRed(ref this._name!, 0);
return red is null ? throw new System.Exception("name cannot be null.") : (IdentifierNameSyntaxNode)red;
return red is null ? throw new System.Exception("name cannot be null.") : (IdentifierNameExpressionSyntaxNode)red;
}
}
@ -1912,12 +1912,12 @@ namespace Parser
}
}
public CompoundNameSyntaxNode Name
public CompoundNameExpressionSyntaxNode Name
{
get
{
var red = this.GetRed(ref this._name!, 2);
return red is null ? throw new System.Exception("name cannot be null.") : (CompoundNameSyntaxNode)red;
return red is null ? throw new System.Exception("name cannot be null.") : (CompoundNameExpressionSyntaxNode)red;
}
}
@ -1991,12 +1991,12 @@ namespace Parser
}
}
public CompoundNameSyntaxNode Name
public CompoundNameExpressionSyntaxNode Name
{
get
{
var red = this.GetRed(ref this._name!, 1);
return red is null ? throw new System.Exception("name cannot be null.") : (CompoundNameSyntaxNode)red;
return red is null ? throw new System.Exception("name cannot be null.") : (CompoundNameExpressionSyntaxNode)red;
}
}
@ -2216,12 +2216,12 @@ namespace Parser
}
}
public IdentifierNameSyntaxNode ClassName
public IdentifierNameExpressionSyntaxNode ClassName
{
get
{
var red = this.GetRed(ref this._className!, 2);
return red is null ? throw new System.Exception("className cannot be null.") : (IdentifierNameSyntaxNode)red;
return red is null ? throw new System.Exception("className cannot be null.") : (IdentifierNameExpressionSyntaxNode)red;
}
}
@ -2316,12 +2316,12 @@ namespace Parser
{
}
public IdentifierNameSyntaxNode Name
public IdentifierNameExpressionSyntaxNode Name
{
get
{
var red = this.GetRed(ref this._name!, 0);
return red is null ? throw new System.Exception("name cannot be null.") : (IdentifierNameSyntaxNode)red;
return red is null ? throw new System.Exception("name cannot be null.") : (IdentifierNameExpressionSyntaxNode)red;
}
}

4
Parser/SyntaxNode.cs
View File

@ -141,9 +141,9 @@ namespace Parser
}
}
public abstract class FunctionHandleSyntaxNode : ExpressionSyntaxNode
public abstract class FunctionHandleExpressionSyntaxNode : ExpressionSyntaxNode
{
internal FunctionHandleSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
internal FunctionHandleExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
{
}
}

8
Parser/SyntaxVisitor.Generated.cs
View File

@ -93,17 +93,17 @@ namespace Parser
DefaultVisit(node);
}
public virtual void VisitCompoundName(CompoundNameSyntaxNode node)
public virtual void VisitCompoundNameExpression(CompoundNameExpressionSyntaxNode node)
{
DefaultVisit(node);
}
public virtual void VisitNamedFunctionHandle(NamedFunctionHandleSyntaxNode node)
public virtual void VisitNamedFunctionHandleExpression(NamedFunctionHandleExpressionSyntaxNode node)
{
DefaultVisit(node);
}
public virtual void VisitLambda(LambdaSyntaxNode node)
public virtual void VisitLambdaExpression(LambdaExpressionSyntaxNode node)
{
DefaultVisit(node);
}
@ -113,7 +113,7 @@ namespace Parser
DefaultVisit(node);
}
public virtual void VisitIdentifierName(IdentifierNameSyntaxNode node)
public virtual void VisitIdentifierNameExpression(IdentifierNameExpressionSyntaxNode node)
{
DefaultVisit(node);
}

228
Parser/TokenKind.cs
View File

@ -3,7 +3,9 @@
// We use the same set of kinds for syntax tokens & syntax nodes.
public enum TokenKind
{
// SYNTAX TOKENS
// *****************
// * SYNTAX TOKENS *
// *****************
None = 0,
BadToken = 1,
@ -123,31 +125,54 @@
UnaryNot = 59,
UnaryQuestionMark = 60,
// SYNTAX NODES
// ****************
// * SYNTAX NODES *
// ****************
// The whole file.
File = 100,
// a list of syntax nodes and/or tokens.
List,
// STATEMENTS
// The name ends with "Declaration" or "Statement".
// result = abstractMethod(object)
AbstractMethodDeclaration,
// classdef MyClass < BaseClass, AnotherBaseClass
// properties
// y
// end
// methods
// <...>
// end
// end
ClassDeclaration,
// function result = method(obj)
// <...>
// end
ConcreteMethodDeclaration,
//
EmptyStatement,
// a = 5;
ExpressionStatement,
// for a = 1:5
// process(a);
// end
ForStatement,
// [output1, output2] = function(input1, input2)
// <...>
// end
FunctionDeclaration,
// (input1, input2)
FunctionInputDescription,
// [output1, output2] =
FunctionOutputDescription,
// switch a
// case 1
// <...>
// end
SwitchStatement,
// case 1
// doSomething();
SwitchCase,
// while a < 10
// doSomething();
// end
WhileStatement,
// if a < 5
// doSomething();
// elseif a > 10
@ -156,84 +181,125 @@
// GiveUp();
// end
IfStatement,
// elseif a > 10
// doSomethingElse();
ElseifClause,
// else
// GiveUp();
ElseClause,
// for a = 1:5
// process(a);
// switch a
// case 1
// <...>
// end
ForStatement,
// a = 1:5
AssignmentExpression,
// catch e
// dealWithIt(e);
// end
CatchClause,
SwitchStatement,
// try
// somethingWeird();
// catch e
// dealWithIt(e);
// end
TryCatchStatement,
// a = 5;
ExpressionStatement,
//
EmptyStatement,
//
EmptyExpression,
// -13
UnaryPrefixOperationExpression,
// some.complex.name
CompoundName,
// @func
NamedFunctionHandle,
// @(x) x + 1
Lambda,
// +
BinaryOperation,
// a
IdentifierName,
// 123
NumberLiteralExpression,
// 'abc'
StringLiteralExpression,
// "abc"
DoubleQuotedStringLiteralExpression,
// abc
UnquotedStringLiteralExpression,
// while a < 10
// doSomething();
// end
WhileStatement,
// EXPRESSIONS
// The name ends with "Expression".
// [1, 2; 3 4]
ArrayLiteralExpression,
// a = 1:5
AssignmentExpression,
// +
BinaryOperationExpression,
// abc{2}
CellArrayElementAccessExpression,
// {1, 3, 'abc'}
CellArrayLiteralExpression,
// method@SuperClass(object)
ClassInvokationExpression,
// cd some/+folder/
CommandExpression,
// some.complex.name
CompoundNameExpression,
// "abc"
DoubleQuotedStringLiteralExpression,
//
EmptyExpression,
// doSomething(5)
FunctionCallExpression,
// a
IdentifierNameExpression,
// struct.(field)
IndirectMemberAccessExpression,
// @(x) x + 1
LambdaExpression,
// object.member
MemberAccessExpression,
// @func
NamedFunctionHandleExpression,
// 123
NumberLiteralExpression,
// (1 + 2 * 3)
ParenthesizedExpression,
// abc{2}
CellArrayElementAccess,
// doSomething(5)
FunctionCall,
// object.member
MemberAccess,
// 'abc'
StringLiteralExpression,
// -13
UnaryPrefixOperationExpression,
// [1 2 3]'
UnaryPostfixOperationExpression,
// struct.(field)
IndirectMemberAccess,
// cd some/+folder/
Command,
// method@SuperClass(object)
ClassInvokation,
// abc
UnquotedStringLiteralExpression,
// PARTS OF STATEMENTS & EXPRESSIONS
// (input1, input2)
FunctionInputDescription,
// [output1, output2] =
FunctionOutputDescription,
// case 1
// doSomething();
SwitchCase,
// elseif a > 10
// doSomethingElse();
ElseifClause,
// else
// GiveUp();
ElseClause,
// catch e
// dealWithIt(e);
// end
CatchClause,
// = true
AttributeAssignment,
// Sealed = true
Attribute,
// (Sealed = true)
AttributeList,
// function result = method(obj)
// <...>
// end
MethodDefinition,
// methods
// function result = method(obj)
// <...>
@ -247,15 +313,7 @@
PropertiesList,
// < BaseClass, AnotherBaseClass
BaseClassList,
// classdef MyClass < BaseClass, AnotherBaseClass
// properties
// y
// end
// methods
// <...>
// end
// end
ClassDeclaration,
// (1)
EnumerationItemValue,
// One (1)
@ -265,8 +323,6 @@
// Two (2)
// end
EnumerationList,
// result = abstractMethod(object)
AbstractMethodDeclaration,
// events
// ToggleSomething
// end

3
SyntaxGenerator/GenerateSyntax.cs
View File

@ -844,7 +844,8 @@ namespace SyntaxGenerator
public static void Input()
{
var serializer = new XmlSerializer(typeof(SyntaxDescription));
using var stream = new FileStream("input.xml", FileMode.Open);
var syntaxDefinitionFileName = Path.Combine(_outputPath, "SyntaxDefinition.xml");
using var stream = new FileStream(syntaxDefinitionFileName, FileMode.Open);
if (!(serializer.Deserialize(stream) is SyntaxDescription syntax))
{
Console.WriteLine("Couldn't deserialize syntax.");