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

8
ConsoleDemo/PrettyPrinter.cs
View File

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

8
ConsoleDemo/UsageGathering.cs
View File

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

8
MApplication/ColoringVisitor.cs
View File

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

119
Parser/Evaluator.cs
View File

@ -43,28 +43,28 @@ namespace Parser
{ {
return statement.Kind switch return statement.Kind switch
{ {
TokenKind.ExpressionStatement =>
EvaluateExpressionStatement((ExpressionStatementSyntaxNode)statement),
TokenKind.MethodDefinition =>
EvaluateMethodDefinition((MethodDefinitionSyntaxNode)statement),
TokenKind.AbstractMethodDeclaration => TokenKind.AbstractMethodDeclaration =>
EvaluateAbstractMethodDeclaration((AbstractMethodDeclarationSyntaxNode)statement), 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 => TokenKind.ClassDeclaration =>
EvaluateClassDeclaration((ClassDeclarationSyntaxNode)statement), 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}'."), _ => throw new NotImplementedException($"Invalid statement kind '{statement.Kind}'."),
}; };
} }
@ -128,52 +128,59 @@ namespace Parser
{ {
return expression.Kind switch 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 => TokenKind.ArrayLiteralExpression =>
EvaluateArrayLiteralExpression((ArrayLiteralExpressionSyntaxNode)expression), EvaluateArrayLiteralExpression((ArrayLiteralExpressionSyntaxNode)expression),
TokenKind.AssignmentExpression =>
EvaluateAssignmentExpression((AssignmentExpressionSyntaxNode)expression),
TokenKind.BinaryOperationExpression =>
EvaluateBinaryOperation((BinaryOperationExpressionSyntaxNode)expression),
TokenKind.CellArrayElementAccessExpression =>
EvaluateCellArrayElementAccess((CellArrayElementAccessExpressionSyntaxNode)expression),
TokenKind.CellArrayLiteralExpression => TokenKind.CellArrayLiteralExpression =>
EvaluateCellArrayLiteralExpression((CellArrayLiteralExpressionSyntaxNode)expression), EvaluateCellArrayLiteralExpression((CellArrayLiteralExpressionSyntaxNode)expression),
TokenKind.ParenthesizedExpression => TokenKind.ClassInvokationExpression =>
EvaluateNamedFunctionHandle((NamedFunctionHandleSyntaxNode)expression), EvaluateClassInvokation((BaseClassInvokationSyntaxNode)expression),
TokenKind.CellArrayElementAccess => TokenKind.CommandExpression =>
EvaluateCellArrayElementAccess((CellArrayElementAccessExpressionSyntaxNode)expression), EvaluateCommand((CommandExpressionSyntaxNode)expression),
TokenKind.FunctionCall => TokenKind.CompoundNameExpression =>
EvaluateCompoundName((CompoundNameExpressionSyntaxNode)expression),
TokenKind.DoubleQuotedStringLiteralExpression =>
EvaluateDoubleQuotedStringLiteralExpression((DoubleQuotedStringLiteralSyntaxNode)expression),
TokenKind.EmptyExpression =>
EvaluateEmptyExpression((EmptyExpressionSyntaxNode)expression),
TokenKind.FunctionCallExpression =>
EvaluateFunctionCall((FunctionCallExpressionSyntaxNode)expression), 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), 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 => TokenKind.UnaryPostfixOperationExpression =>
EvaluateUnaryPostfixOperationExpression((UnaryPostixOperationExpressionSyntaxNode)expression), EvaluateUnaryPostfixOperationExpression((UnaryPostixOperationExpressionSyntaxNode)expression),
TokenKind.IndirectMemberAccess => TokenKind.UnquotedStringLiteralExpression =>
EvaluateIndirectMemberAccess((IndirectMemberAccessSyntaxNode)expression), EvaluateUnquotedStringLiteralExpression((UnquotedStringLiteralSyntaxNode)expression),
TokenKind.Command =>
EvaluateCommand((CommandExpressionSyntaxNode)expression),
TokenKind.ClassInvokation =>
EvaluateClassInvokation((BaseClassInvokationSyntaxNode)expression),
_ => throw new NotImplementedException($"Invalid expression kind '{expression.Kind}'."), _ => throw new NotImplementedException($"Invalid expression kind '{expression.Kind}'."),
}; };
} }
private MObject? EvaluateParenthesizedExpression(ParenthesizedExpressionSyntaxNode expression)
{
throw new NotImplementedException();
}
private MObject? EvaluateClassInvokation(BaseClassInvokationSyntaxNode expression) private MObject? EvaluateClassInvokation(BaseClassInvokationSyntaxNode expression)
{ {
throw new NotImplementedException(); throw new NotImplementedException();
@ -239,7 +246,7 @@ namespace Parser
throw new NotImplementedException(); throw new NotImplementedException();
} }
private MObject? EvaluateIdentifierName(IdentifierNameSyntaxNode expression) private MObject? EvaluateIdentifierNameExpression(IdentifierNameExpressionSyntaxNode expression)
{ {
throw new NotImplementedException(); throw new NotImplementedException();
} }
@ -249,7 +256,7 @@ namespace Parser
throw new NotImplementedException(); throw new NotImplementedException();
} }
private MObject? EvaluateCompoundName(CompoundNameSyntaxNode expression) private MObject? EvaluateCompoundName(CompoundNameExpressionSyntaxNode expression)
{ {
throw new NotImplementedException(); throw new NotImplementedException();
} }
@ -269,12 +276,12 @@ namespace Parser
throw new NotImplementedException(); throw new NotImplementedException();
} }
private MObject? EvaluateLambda(LambdaSyntaxNode expression) private MObject? EvaluateLambdaExpression(LambdaExpressionSyntaxNode expression)
{ {
throw new NotImplementedException(); throw new NotImplementedException();
} }
private MObject? EvaluateNamedFunctionHandle(NamedFunctionHandleSyntaxNode expression) private MObject? EvaluateNamedFunctionHandleExpression(NamedFunctionHandleExpressionSyntaxNode expression)
{ {
throw new NotImplementedException(); throw new NotImplementedException();
} }

32
Parser/Internal/MParserGreen.cs
View File

@ -113,7 +113,7 @@ namespace Parser.Internal
} }
firstToken = false; firstToken = false;
outputs.Add(Factory.IdentifierNameSyntax(EatToken(TokenKind.IdentifierToken))); outputs.Add(Factory.IdentifierNameExpressionSyntax(EatToken(TokenKind.IdentifierToken)));
} }
return outputs.ToList(); return outputs.ToList();
@ -141,7 +141,7 @@ namespace Parser.Internal
if (PeekToken(1).Kind == TokenKind.EqualsToken) if (PeekToken(1).Kind == TokenKind.EqualsToken)
{ {
var identifierToken = EatIdentifier(); var identifierToken = EatIdentifier();
builder.Add(Factory.IdentifierNameSyntax(identifierToken)); builder.Add(Factory.IdentifierNameExpressionSyntax(identifierToken));
assignmentSign = EatToken(TokenKind.EqualsToken); assignmentSign = EatToken(TokenKind.EqualsToken);
} }
else else
@ -180,7 +180,7 @@ namespace Parser.Internal
else else
{ {
var identifierToken = EatToken(TokenKind.IdentifierToken); var identifierToken = EatToken(TokenKind.IdentifierToken);
builder.Add(Factory.IdentifierNameSyntax(identifierToken)); builder.Add(Factory.IdentifierNameExpressionSyntax(identifierToken));
} }
} }
@ -329,7 +329,7 @@ namespace Parser.Internal
break; break;
default: default:
var id = EatToken(TokenKind.IdentifierToken); var id = EatToken(TokenKind.IdentifierToken);
expression = Factory.IdentifierNameSyntax(id); expression = Factory.IdentifierNameExpressionSyntax(id);
break; break;
} }
@ -377,7 +377,7 @@ namespace Parser.Internal
closingBracket); closingBracket);
break; break;
case TokenKind.DotToken: // member access case TokenKind.DotToken: // member access
if (expression is IdentifierNameSyntaxNode if (expression is IdentifierNameExpressionSyntaxNode
|| expression is MemberAccessSyntaxNode || expression is MemberAccessSyntaxNode
|| expression is FunctionCallExpressionSyntaxNode || expression is FunctionCallExpressionSyntaxNode
|| expression is CellArrayElementAccessExpressionSyntaxNode) || expression is CellArrayElementAccessExpressionSyntaxNode)
@ -414,7 +414,7 @@ namespace Parser.Internal
private CommandExpressionSyntaxNode ParseCommandExpression(ExpressionSyntaxNode expression) private CommandExpressionSyntaxNode ParseCommandExpression(ExpressionSyntaxNode expression)
{ {
if (expression is IdentifierNameSyntaxNode idNameNode) if (expression is IdentifierNameExpressionSyntaxNode idNameNode)
{ {
var builder = new SyntaxListBuilder<UnquotedStringLiteralSyntaxNode>(); var builder = new SyntaxListBuilder<UnquotedStringLiteralSyntaxNode>();
while (CurrentToken.Kind == TokenKind.UnquotedStringLiteralToken) while (CurrentToken.Kind == TokenKind.UnquotedStringLiteralToken)
@ -434,7 +434,7 @@ namespace Parser.Internal
private BaseClassInvokationSyntaxNode ParseBaseClassInvokation(ExpressionSyntaxNode expression) private BaseClassInvokationSyntaxNode ParseBaseClassInvokation(ExpressionSyntaxNode expression)
{ {
if (expression is IdentifierNameSyntaxNode methodName if (expression is IdentifierNameExpressionSyntaxNode methodName
&& !expression.TrailingTrivia.Any()) && !expression.TrailingTrivia.Any())
{ {
var atToken = EatToken(); var atToken = EatToken();
@ -463,7 +463,7 @@ namespace Parser.Internal
{ {
if (CurrentToken.Kind == TokenKind.IdentifierToken) if (CurrentToken.Kind == TokenKind.IdentifierToken)
{ {
return Factory.IdentifierNameSyntax(EatToken()); return Factory.IdentifierNameExpressionSyntax(EatToken());
} }
if (CurrentToken.Kind == TokenKind.OpenParenthesisToken) if (CurrentToken.Kind == TokenKind.OpenParenthesisToken)
{ {
@ -523,7 +523,7 @@ namespace Parser.Internal
closeParen); closeParen);
} }
private CompoundNameSyntaxNode ParseCompoundName() private CompoundNameExpressionSyntaxNode ParseCompoundName()
{ {
var lastToken = EatToken(TokenKind.IdentifierToken); var lastToken = EatToken(TokenKind.IdentifierToken);
var firstName = lastToken; var firstName = lastToken;
@ -538,16 +538,16 @@ namespace Parser.Internal
builder.Add(lastToken); builder.Add(lastToken);
} }
return Factory.CompoundNameSyntax(builder.ToList()); return Factory.CompoundNameExpressionSyntax(builder.ToList());
} }
private FunctionHandleSyntaxNode ParseFunctionHandle() private FunctionHandleExpressionSyntaxNode ParseFunctionHandle()
{ {
var atSign = EatToken(); var atSign = EatToken();
if (CurrentToken.Kind == TokenKind.IdentifierToken) if (CurrentToken.Kind == TokenKind.IdentifierToken)
{ {
var compoundName = ParseCompoundName(); var compoundName = ParseCompoundName();
return Factory.NamedFunctionHandleSyntax( return Factory.NamedFunctionHandleExpressionSyntax(
atSign, atSign,
compoundName); compoundName);
} }
@ -563,7 +563,7 @@ namespace Parser.Internal
{ {
throw new Exception($"Lambda expression body cannot be empty."); 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}."); throw new ParsingException($"Unexpected token {CurrentToken} while parsing function handle at {CurrentPosition}.");
} }
@ -866,7 +866,7 @@ namespace Parser.Internal
private AttributeSyntaxNode ParseAttribute() private AttributeSyntaxNode ParseAttribute()
{ {
var name = Factory.IdentifierNameSyntax(EatToken(TokenKind.IdentifierToken)); var name = Factory.IdentifierNameExpressionSyntax(EatToken(TokenKind.IdentifierToken));
var assignment = ParseAttributeAssignment(); var assignment = ParseAttributeAssignment();
return Factory.AttributeSyntax(name, assignment); return Factory.AttributeSyntax(name, assignment);
} }
@ -1023,7 +1023,7 @@ namespace Parser.Internal
private EnumerationItemSyntaxNode ParseEnumerationItem() private EnumerationItemSyntaxNode ParseEnumerationItem()
{ {
var name = Factory.IdentifierNameSyntax(EatToken()); var name = Factory.IdentifierNameExpressionSyntax(EatToken());
var values = ParseEnumerationValue(); var values = ParseEnumerationValue();
var commas = ParseOptionalCommas(); var commas = ParseOptionalCommas();
return Factory.EnumerationItemSyntax(name, values, commas); return Factory.EnumerationItemSyntax(name, values, commas);
@ -1104,7 +1104,7 @@ namespace Parser.Internal
{ {
attributes = ParseAttributesList(); attributes = ParseAttributesList();
} }
var className = Factory.IdentifierNameSyntax(EatToken(TokenKind.IdentifierToken)); var className = Factory.IdentifierNameExpressionSyntax(EatToken(TokenKind.IdentifierToken));
BaseClassListSyntaxNode? baseClassList = null; BaseClassListSyntaxNode? baseClassList = null;
if (CurrentToken.Kind == TokenKind.LessToken) 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); 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) public BinaryOperationExpressionSyntaxNode BinaryOperationExpressionSyntax(ExpressionSyntaxNode lhs, SyntaxToken operation, ExpressionSyntaxNode rhs)
@ -113,9 +113,9 @@ namespace Parser.Internal
return new BinaryOperationExpressionSyntaxNode(lhs, operation, rhs); 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) public NumberLiteralSyntaxNode NumberLiteralSyntax(SyntaxToken number)
@ -178,7 +178,7 @@ namespace Parser.Internal
return new IndirectMemberAccessSyntaxNode(openingBracket, expression, closingBracket); 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); return new CommandExpressionSyntaxNode(commandName, arguments);
} }
@ -193,7 +193,7 @@ namespace Parser.Internal
return new AttributeAssignmentSyntaxNode(assignmentSign, value); return new AttributeAssignmentSyntaxNode(assignmentSign, value);
} }
public AttributeSyntaxNode AttributeSyntax(IdentifierNameSyntaxNode name, AttributeAssignmentSyntaxNode? assignment) public AttributeSyntaxNode AttributeSyntax(IdentifierNameExpressionSyntaxNode name, AttributeAssignmentSyntaxNode? assignment)
{ {
return new AttributeSyntaxNode(name, assignment); return new AttributeSyntaxNode(name, assignment);
} }
@ -203,12 +203,12 @@ namespace Parser.Internal
return new AttributeListSyntaxNode(openingBracket, nodes, closingBracket); 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); 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); return new AbstractMethodDeclarationSyntaxNode(outputDescription, name, inputDescription);
} }
@ -228,7 +228,7 @@ namespace Parser.Internal
return new BaseClassListSyntaxNode(lessSign, baseClasses); 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); return new ClassDeclarationSyntaxNode(classdefKeyword, attributes, className, baseClassList, nodes, endKeyword);
} }
@ -238,7 +238,7 @@ namespace Parser.Internal
return new EnumerationItemValueSyntaxNode(openingBracket, values, closingBracket); 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); 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 readonly SyntaxList _nodes;
internal CompoundNameSyntaxNode(SyntaxList nodes): base(TokenKind.CompoundName) internal CompoundNameExpressionSyntaxNode(SyntaxList nodes): base(TokenKind.CompoundNameExpression)
{ {
Slots = 1; Slots = 1;
this.AdjustWidth(nodes); this.AdjustWidth(nodes);
_nodes = 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; Slots = 1;
this.AdjustWidth(nodes); this.AdjustWidth(nodes);
@ -909,12 +909,12 @@ namespace Parser.Internal
internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) 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) public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics)
{ {
return new CompoundNameSyntaxNode(_nodes, diagnostics); return new CompoundNameExpressionSyntaxNode(_nodes, diagnostics);
} }
public override GreenNode? GetSlot(int i) 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 SyntaxToken _atSign;
internal readonly CompoundNameSyntaxNode _functionName; internal readonly CompoundNameExpressionSyntaxNode _functionName;
internal NamedFunctionHandleSyntaxNode(SyntaxToken atSign, CompoundNameSyntaxNode functionName): base(TokenKind.NamedFunctionHandle) internal NamedFunctionHandleExpressionSyntaxNode(SyntaxToken atSign, CompoundNameExpressionSyntaxNode functionName): base(TokenKind.NamedFunctionHandleExpression)
{ {
Slots = 2; Slots = 2;
this.AdjustWidth(atSign); this.AdjustWidth(atSign);
@ -941,7 +941,7 @@ namespace Parser.Internal
_functionName = functionName; _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; Slots = 2;
this.AdjustWidth(atSign); this.AdjustWidth(atSign);
@ -952,12 +952,12 @@ namespace Parser.Internal
internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) 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) public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics)
{ {
return new NamedFunctionHandleSyntaxNode(_atSign, _functionName, diagnostics); return new NamedFunctionHandleExpressionSyntaxNode(_atSign, _functionName, diagnostics);
} }
public override GreenNode? GetSlot(int i) 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 SyntaxToken _atSign;
internal readonly FunctionInputDescriptionSyntaxNode _input; internal readonly FunctionInputDescriptionSyntaxNode _input;
internal readonly ExpressionSyntaxNode _body; 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; Slots = 3;
this.AdjustWidth(atSign); this.AdjustWidth(atSign);
@ -987,7 +987,7 @@ namespace Parser.Internal
_body = body; _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; Slots = 3;
this.AdjustWidth(atSign); this.AdjustWidth(atSign);
@ -1000,12 +1000,12 @@ namespace Parser.Internal
internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) 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) 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) public override GreenNode? GetSlot(int i)
@ -1024,7 +1024,7 @@ namespace Parser.Internal
internal readonly ExpressionSyntaxNode _lhs; internal readonly ExpressionSyntaxNode _lhs;
internal readonly SyntaxToken _operation; internal readonly SyntaxToken _operation;
internal readonly ExpressionSyntaxNode _rhs; 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; Slots = 3;
this.AdjustWidth(lhs); this.AdjustWidth(lhs);
@ -1035,7 +1035,7 @@ namespace Parser.Internal
_rhs = rhs; _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; Slots = 3;
this.AdjustWidth(lhs); this.AdjustWidth(lhs);
@ -1067,17 +1067,17 @@ namespace Parser.Internal
} }
} }
internal class IdentifierNameSyntaxNode : ExpressionSyntaxNode internal class IdentifierNameExpressionSyntaxNode : ExpressionSyntaxNode
{ {
internal readonly SyntaxToken _name; internal readonly SyntaxToken _name;
internal IdentifierNameSyntaxNode(SyntaxToken name): base(TokenKind.IdentifierName) internal IdentifierNameExpressionSyntaxNode(SyntaxToken name): base(TokenKind.IdentifierNameExpression)
{ {
Slots = 1; Slots = 1;
this.AdjustWidth(name); this.AdjustWidth(name);
_name = 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; Slots = 1;
this.AdjustWidth(name); this.AdjustWidth(name);
@ -1086,12 +1086,12 @@ namespace Parser.Internal
internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) 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) public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics)
{ {
return new IdentifierNameSyntaxNode(_name, diagnostics); return new IdentifierNameExpressionSyntaxNode(_name, diagnostics);
} }
public override GreenNode? GetSlot(int i) public override GreenNode? GetSlot(int i)
@ -1407,7 +1407,7 @@ namespace Parser.Internal
internal readonly SyntaxToken _openingBrace; internal readonly SyntaxToken _openingBrace;
internal readonly SyntaxList _nodes; internal readonly SyntaxList _nodes;
internal readonly SyntaxToken _closingBrace; 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; Slots = 4;
this.AdjustWidth(expression); this.AdjustWidth(expression);
@ -1420,7 +1420,7 @@ namespace Parser.Internal
_closingBrace = closingBrace; _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; Slots = 4;
this.AdjustWidth(expression); this.AdjustWidth(expression);
@ -1460,7 +1460,7 @@ namespace Parser.Internal
internal readonly SyntaxToken _openingBracket; internal readonly SyntaxToken _openingBracket;
internal readonly SyntaxList _nodes; internal readonly SyntaxList _nodes;
internal readonly SyntaxToken _closingBracket; 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; Slots = 4;
this.AdjustWidth(functionName); this.AdjustWidth(functionName);
@ -1473,7 +1473,7 @@ namespace Parser.Internal
_closingBracket = closingBracket; _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; Slots = 4;
this.AdjustWidth(functionName); this.AdjustWidth(functionName);
@ -1512,7 +1512,7 @@ namespace Parser.Internal
internal readonly SyntaxNode _leftOperand; internal readonly SyntaxNode _leftOperand;
internal readonly SyntaxToken _dot; internal readonly SyntaxToken _dot;
internal readonly SyntaxNode _rightOperand; 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; Slots = 3;
this.AdjustWidth(leftOperand); this.AdjustWidth(leftOperand);
@ -1523,7 +1523,7 @@ namespace Parser.Internal
_rightOperand = rightOperand; _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; Slots = 3;
this.AdjustWidth(leftOperand); this.AdjustWidth(leftOperand);
@ -1603,7 +1603,7 @@ namespace Parser.Internal
internal readonly SyntaxToken _openingBracket; internal readonly SyntaxToken _openingBracket;
internal readonly ExpressionSyntaxNode _expression; internal readonly ExpressionSyntaxNode _expression;
internal readonly SyntaxToken _closingBracket; 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; Slots = 3;
this.AdjustWidth(openingBracket); this.AdjustWidth(openingBracket);
@ -1614,7 +1614,7 @@ namespace Parser.Internal
_closingBracket = closingBracket; _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; Slots = 3;
this.AdjustWidth(openingBracket); this.AdjustWidth(openingBracket);
@ -1648,9 +1648,9 @@ namespace Parser.Internal
internal class CommandExpressionSyntaxNode : ExpressionSyntaxNode internal class CommandExpressionSyntaxNode : ExpressionSyntaxNode
{ {
internal readonly IdentifierNameSyntaxNode _commandName; internal readonly IdentifierNameExpressionSyntaxNode _commandName;
internal readonly SyntaxList<UnquotedStringLiteralSyntaxNode> _arguments; 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; Slots = 2;
this.AdjustWidth(commandName); this.AdjustWidth(commandName);
@ -1659,7 +1659,7 @@ namespace Parser.Internal
_arguments = arguments; _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; Slots = 2;
this.AdjustWidth(commandName); this.AdjustWidth(commandName);
@ -1694,7 +1694,7 @@ namespace Parser.Internal
internal readonly ExpressionSyntaxNode _methodName; internal readonly ExpressionSyntaxNode _methodName;
internal readonly SyntaxToken _atSign; internal readonly SyntaxToken _atSign;
internal readonly ExpressionSyntaxNode _baseClassNameAndArguments; 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; Slots = 3;
this.AdjustWidth(methodName); this.AdjustWidth(methodName);
@ -1705,7 +1705,7 @@ namespace Parser.Internal
_baseClassNameAndArguments = baseClassNameAndArguments; _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; Slots = 3;
this.AdjustWidth(methodName); this.AdjustWidth(methodName);
@ -1782,9 +1782,9 @@ namespace Parser.Internal
internal class AttributeSyntaxNode : SyntaxNode internal class AttributeSyntaxNode : SyntaxNode
{ {
internal readonly IdentifierNameSyntaxNode _name; internal readonly IdentifierNameExpressionSyntaxNode _name;
internal readonly AttributeAssignmentSyntaxNode? _assignment; internal readonly AttributeAssignmentSyntaxNode? _assignment;
internal AttributeSyntaxNode(IdentifierNameSyntaxNode name, AttributeAssignmentSyntaxNode? assignment): base(TokenKind.Attribute) internal AttributeSyntaxNode(IdentifierNameExpressionSyntaxNode name, AttributeAssignmentSyntaxNode? assignment): base(TokenKind.Attribute)
{ {
Slots = 2; Slots = 2;
this.AdjustWidth(name); this.AdjustWidth(name);
@ -1793,7 +1793,7 @@ namespace Parser.Internal
_assignment = assignment; _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; Slots = 2;
this.AdjustWidth(name); this.AdjustWidth(name);
@ -1875,12 +1875,12 @@ namespace Parser.Internal
{ {
internal readonly SyntaxToken _functionKeyword; internal readonly SyntaxToken _functionKeyword;
internal readonly FunctionOutputDescriptionSyntaxNode? _outputDescription; internal readonly FunctionOutputDescriptionSyntaxNode? _outputDescription;
internal readonly CompoundNameSyntaxNode _name; internal readonly CompoundNameExpressionSyntaxNode _name;
internal readonly FunctionInputDescriptionSyntaxNode? _inputDescription; internal readonly FunctionInputDescriptionSyntaxNode? _inputDescription;
internal readonly SyntaxList<SyntaxToken> _commas; internal readonly SyntaxList<SyntaxToken> _commas;
internal readonly SyntaxList _body; internal readonly SyntaxList _body;
internal readonly EndKeywordSyntaxNode? _endKeyword; 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; Slots = 7;
this.AdjustWidth(functionKeyword); this.AdjustWidth(functionKeyword);
@ -1899,7 +1899,7 @@ namespace Parser.Internal
_endKeyword = endKeyword; _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; Slots = 7;
this.AdjustWidth(functionKeyword); this.AdjustWidth(functionKeyword);
@ -1942,9 +1942,9 @@ namespace Parser.Internal
internal class AbstractMethodDeclarationSyntaxNode : MethodDeclarationSyntaxNode internal class AbstractMethodDeclarationSyntaxNode : MethodDeclarationSyntaxNode
{ {
internal readonly FunctionOutputDescriptionSyntaxNode? _outputDescription; internal readonly FunctionOutputDescriptionSyntaxNode? _outputDescription;
internal readonly CompoundNameSyntaxNode _name; internal readonly CompoundNameExpressionSyntaxNode _name;
internal readonly FunctionInputDescriptionSyntaxNode? _inputDescription; 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; Slots = 3;
this.AdjustWidth(outputDescription); this.AdjustWidth(outputDescription);
@ -1955,7 +1955,7 @@ namespace Parser.Internal
_inputDescription = inputDescription; _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; Slots = 3;
this.AdjustWidth(outputDescription); this.AdjustWidth(outputDescription);
@ -2140,11 +2140,11 @@ namespace Parser.Internal
{ {
internal readonly SyntaxToken _classdefKeyword; internal readonly SyntaxToken _classdefKeyword;
internal readonly AttributeListSyntaxNode? _attributes; internal readonly AttributeListSyntaxNode? _attributes;
internal readonly IdentifierNameSyntaxNode _className; internal readonly IdentifierNameExpressionSyntaxNode _className;
internal readonly BaseClassListSyntaxNode? _baseClassList; internal readonly BaseClassListSyntaxNode? _baseClassList;
internal readonly SyntaxList _nodes; internal readonly SyntaxList _nodes;
internal readonly SyntaxToken _endKeyword; 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; Slots = 6;
this.AdjustWidth(classdefKeyword); this.AdjustWidth(classdefKeyword);
@ -2161,7 +2161,7 @@ namespace Parser.Internal
_endKeyword = endKeyword; _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; Slots = 6;
this.AdjustWidth(classdefKeyword); this.AdjustWidth(classdefKeyword);
@ -2249,10 +2249,10 @@ namespace Parser.Internal
internal class EnumerationItemSyntaxNode : SyntaxNode internal class EnumerationItemSyntaxNode : SyntaxNode
{ {
internal readonly IdentifierNameSyntaxNode _name; internal readonly IdentifierNameExpressionSyntaxNode _name;
internal readonly EnumerationItemValueSyntaxNode? _values; internal readonly EnumerationItemValueSyntaxNode? _values;
internal readonly SyntaxList<SyntaxToken> _commas; 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; Slots = 3;
this.AdjustWidth(name); this.AdjustWidth(name);
@ -2263,7 +2263,7 @@ namespace Parser.Internal
_commas = commas; _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; Slots = 3;
this.AdjustWidth(name); 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="SyntaxToken" Name="operation" />
<Field Type="ExpressionSyntaxNode" Name="operand" /> <Field Type="ExpressionSyntaxNode" Name="operand" />
</Class> </Class>
<Class Name="CompoundNameSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="CompoundName"> <Class Name="CompoundNameExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="CompoundNameExpression">
<Field Type="SyntaxList" Name="nodes" /> <Field Type="SyntaxList" Name="nodes" />
</Class> </Class>
<Class Name="NamedFunctionHandleSyntaxNode" BaseClass="FunctionHandleSyntaxNode" Kind="NamedFunctionHandle"> <Class Name="NamedFunctionHandleExpressionSyntaxNode" BaseClass="FunctionHandleExpressionSyntaxNode" Kind="NamedFunctionHandleExpression">
<Field Type="SyntaxToken" Name="atSign" /> <Field Type="SyntaxToken" Name="atSign" />
<Field Type="CompoundNameSyntaxNode" Name="functionName" /> <Field Type="CompoundNameExpressionSyntaxNode" Name="functionName" />
</Class> </Class>
<Class Name="LambdaSyntaxNode" BaseClass="FunctionHandleSyntaxNode" Kind="Lambda"> <Class Name="LambdaExpressionSyntaxNode" BaseClass="FunctionHandleExpressionSyntaxNode" Kind="LambdaExpression">
<Field Type="SyntaxToken" Name="atSign" /> <Field Type="SyntaxToken" Name="atSign" />
<Field Type="FunctionInputDescriptionSyntaxNode" Name="input" /> <Field Type="FunctionInputDescriptionSyntaxNode" Name="input" />
<Field Type="ExpressionSyntaxNode" Name="body" /> <Field Type="ExpressionSyntaxNode" Name="body" />
</Class> </Class>
<Class Name="BinaryOperationExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="BinaryOperation"> <Class Name="BinaryOperationExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="BinaryOperationExpression">
<Field Type="ExpressionSyntaxNode" Name="lhs" /> <Field Type="ExpressionSyntaxNode" Name="lhs" />
<Field Type="SyntaxToken" Name="operation" /> <Field Type="SyntaxToken" Name="operation" />
<Field Type="ExpressionSyntaxNode" Name="rhs" /> <Field Type="ExpressionSyntaxNode" Name="rhs" />
</Class> </Class>
<Class Name="IdentifierNameSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="IdentifierName"> <Class Name="IdentifierNameExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="IdentifierNameExpression">
<Field Type="SyntaxToken" Name="name" /> <Field Type="SyntaxToken" Name="name" />
</Class> </Class>
<Class Name="NumberLiteralSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="NumberLiteralExpression"> <Class Name="NumberLiteralSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="NumberLiteralExpression">
@ -142,19 +142,19 @@
<Field Type="ExpressionSyntaxNode" Name="expression" /> <Field Type="ExpressionSyntaxNode" Name="expression" />
<Field Type="SyntaxToken" Name="closingBracket" /> <Field Type="SyntaxToken" Name="closingBracket" />
</Class> </Class>
<Class Name="CellArrayElementAccessExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="CellArrayElementAccess"> <Class Name="CellArrayElementAccessExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="CellArrayElementAccessExpression">
<Field Type="ExpressionSyntaxNode" Name="expression" /> <Field Type="ExpressionSyntaxNode" Name="expression" />
<Field Type="SyntaxToken" Name="openingBrace" /> <Field Type="SyntaxToken" Name="openingBrace" />
<Field Type="SyntaxList" Name="nodes" /> <Field Type="SyntaxList" Name="nodes" />
<Field Type="SyntaxToken" Name="closingBrace" /> <Field Type="SyntaxToken" Name="closingBrace" />
</Class> </Class>
<Class Name="FunctionCallExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="FunctionCall"> <Class Name="FunctionCallExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="FunctionCallExpression">
<Field Type="ExpressionSyntaxNode" Name="functionName" /> <Field Type="ExpressionSyntaxNode" Name="functionName" />
<Field Type="SyntaxToken" Name="openingBracket" /> <Field Type="SyntaxToken" Name="openingBracket" />
<Field Type="SyntaxList" Name="nodes" /> <Field Type="SyntaxList" Name="nodes" />
<Field Type="SyntaxToken" Name="closingBracket" /> <Field Type="SyntaxToken" Name="closingBracket" />
</Class> </Class>
<Class Name="MemberAccessSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="MemberAccess"> <Class Name="MemberAccessSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="MemberAccessExpression">
<Field Type="SyntaxNode" Name="leftOperand" /> <Field Type="SyntaxNode" Name="leftOperand" />
<Field Type="SyntaxToken" Name="dot" /> <Field Type="SyntaxToken" Name="dot" />
<Field Type="SyntaxNode" Name="rightOperand" /> <Field Type="SyntaxNode" Name="rightOperand" />
@ -163,16 +163,16 @@
<Field Type="ExpressionSyntaxNode" Name="operand" /> <Field Type="ExpressionSyntaxNode" Name="operand" />
<Field Type="SyntaxToken" Name="operation" /> <Field Type="SyntaxToken" Name="operation" />
</Class> </Class>
<Class Name="IndirectMemberAccessSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="IndirectMemberAccess"> <Class Name="IndirectMemberAccessSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="IndirectMemberAccessExpression">
<Field Type="SyntaxToken" Name="openingBracket" /> <Field Type="SyntaxToken" Name="openingBracket" />
<Field Type="ExpressionSyntaxNode" Name="expression" /> <Field Type="ExpressionSyntaxNode" Name="expression" />
<Field Type="SyntaxToken" Name="closingBracket" /> <Field Type="SyntaxToken" Name="closingBracket" />
</Class> </Class>
<Class Name="CommandExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="Command"> <Class Name="CommandExpressionSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="CommandExpression">
<Field Type="IdentifierNameSyntaxNode" Name="commandName" /> <Field Type="IdentifierNameExpressionSyntaxNode" Name="commandName" />
<Field Type="SyntaxList&lt;UnquotedStringLiteralSyntaxNode&gt;" Name="arguments" /> <Field Type="SyntaxList&lt;UnquotedStringLiteralSyntaxNode&gt;" Name="arguments" />
</Class> </Class>
<Class Name="BaseClassInvokationSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="ClassInvokation"> <Class Name="BaseClassInvokationSyntaxNode" BaseClass="ExpressionSyntaxNode" Kind="ClassInvokationExpression">
<Field Type="ExpressionSyntaxNode" Name="methodName" /> <Field Type="ExpressionSyntaxNode" Name="methodName" />
<Field Type="SyntaxToken" Name="atSign" /> <Field Type="SyntaxToken" Name="atSign" />
<Field Type="ExpressionSyntaxNode" Name="baseClassNameAndArguments" /> <Field Type="ExpressionSyntaxNode" Name="baseClassNameAndArguments" />
@ -182,7 +182,7 @@
<Field Type="ExpressionSyntaxNode" Name="value" /> <Field Type="ExpressionSyntaxNode" Name="value" />
</Class> </Class>
<Class Name="AttributeSyntaxNode" BaseClass="SyntaxNode" Kind="Attribute"> <Class Name="AttributeSyntaxNode" BaseClass="SyntaxNode" Kind="Attribute">
<Field Type="IdentifierNameSyntaxNode" Name="name" /> <Field Type="IdentifierNameExpressionSyntaxNode" Name="name" />
<Field Type="AttributeAssignmentSyntaxNode" Name="assignment" Nullable="true" /> <Field Type="AttributeAssignmentSyntaxNode" Name="assignment" Nullable="true" />
</Class> </Class>
<Class Name="AttributeListSyntaxNode" BaseClass="SyntaxNode" Kind="AttributeList"> <Class Name="AttributeListSyntaxNode" BaseClass="SyntaxNode" Kind="AttributeList">
@ -190,10 +190,10 @@
<Field Type="SyntaxList" Name="nodes" /> <Field Type="SyntaxList" Name="nodes" />
<Field Type="SyntaxToken" Name="closingBracket" /> <Field Type="SyntaxToken" Name="closingBracket" />
</Class> </Class>
<Class Name="MethodDefinitionSyntaxNode" BaseClass="MethodDeclarationSyntaxNode" Kind="MethodDefinition"> <Class Name="MethodDefinitionSyntaxNode" BaseClass="MethodDeclarationSyntaxNode" Kind="ConcreteMethodDeclaration">
<Field Type="SyntaxToken" Name="functionKeyword" /> <Field Type="SyntaxToken" Name="functionKeyword" />
<Field Type="FunctionOutputDescriptionSyntaxNode" Name="outputDescription" Nullable="true" /> <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="FunctionInputDescriptionSyntaxNode" Name="inputDescription" Nullable="true"/>
<Field Type="SyntaxList&lt;SyntaxToken&gt;" Name="commas" /> <Field Type="SyntaxList&lt;SyntaxToken&gt;" Name="commas" />
<Field Type="SyntaxList" Name="body" /> <Field Type="SyntaxList" Name="body" />
@ -201,7 +201,7 @@
</Class> </Class>
<Class Name="AbstractMethodDeclarationSyntaxNode" BaseClass="MethodDeclarationSyntaxNode" Kind="AbstractMethodDeclaration"> <Class Name="AbstractMethodDeclarationSyntaxNode" BaseClass="MethodDeclarationSyntaxNode" Kind="AbstractMethodDeclaration">
<Field Type="FunctionOutputDescriptionSyntaxNode" Name="outputDescription" Nullable="true" /> <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="FunctionInputDescriptionSyntaxNode" Name="inputDescription" Nullable="true"/>
</Class> </Class>
<Class Name="MethodsListSyntaxNode" BaseClass="SyntaxNode" Kind="MethodsList"> <Class Name="MethodsListSyntaxNode" BaseClass="SyntaxNode" Kind="MethodsList">
@ -223,7 +223,7 @@
<Class Name="ClassDeclarationSyntaxNode" BaseClass="StatementSyntaxNode" Kind="ClassDeclaration"> <Class Name="ClassDeclarationSyntaxNode" BaseClass="StatementSyntaxNode" Kind="ClassDeclaration">
<Field Type="SyntaxToken" Name="classdefKeyword" /> <Field Type="SyntaxToken" Name="classdefKeyword" />
<Field Type="AttributeListSyntaxNode" Name="attributes" Nullable="true" /> <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="BaseClassListSyntaxNode" Name="baseClassList" Nullable="true" />
<Field Type="SyntaxList" Name="nodes" /> <Field Type="SyntaxList" Name="nodes" />
<Field Type="SyntaxToken" Name="endKeyword" /> <Field Type="SyntaxToken" Name="endKeyword" />
@ -234,7 +234,7 @@
<Field Type="SyntaxToken" Name="closingBracket" /> <Field Type="SyntaxToken" Name="closingBracket" />
</Class> </Class>
<Class Name="EnumerationItemSyntaxNode" BaseClass="SyntaxNode" Kind="EnumerationItem"> <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="EnumerationItemValueSyntaxNode" Name="values" Nullable="true"/>
<Field Type="SyntaxList&lt;SyntaxToken&gt;" Name="commas" /> <Field Type="SyntaxList&lt;SyntaxToken&gt;" Name="commas" />
</Class> </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; 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) public override void Accept(SyntaxVisitor visitor)
{ {
visitor.VisitCompoundName(this); visitor.VisitCompoundNameExpression(this);
} }
} }
public class NamedFunctionHandleSyntaxNode : FunctionHandleSyntaxNode public class NamedFunctionHandleExpressionSyntaxNode : FunctionHandleExpressionSyntaxNode
{ {
private SyntaxNode? _functionName; 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 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 get
{ {
var red = this.GetRed(ref this._functionName!, 1); 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) 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? _input;
private SyntaxNode? _body; 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 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) 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 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) 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 get
{ {
var red = this.GetRed(ref this._commandName!, 0); 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 get
{ {
var red = this.GetRed(ref this._name!, 0); 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 get
{ {
var red = this.GetRed(ref this._name!, 2); 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 get
{ {
var red = this.GetRed(ref this._name!, 1); 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 get
{ {
var red = this.GetRed(ref this._className!, 2); 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 get
{ {
var red = this.GetRed(ref this._name!, 0); 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); DefaultVisit(node);
} }
public virtual void VisitCompoundName(CompoundNameSyntaxNode node) public virtual void VisitCompoundNameExpression(CompoundNameExpressionSyntaxNode node)
{ {
DefaultVisit(node); DefaultVisit(node);
} }
public virtual void VisitNamedFunctionHandle(NamedFunctionHandleSyntaxNode node) public virtual void VisitNamedFunctionHandleExpression(NamedFunctionHandleExpressionSyntaxNode node)
{ {
DefaultVisit(node); DefaultVisit(node);
} }
public virtual void VisitLambda(LambdaSyntaxNode node) public virtual void VisitLambdaExpression(LambdaExpressionSyntaxNode node)
{ {
DefaultVisit(node); DefaultVisit(node);
} }
@ -113,7 +113,7 @@ namespace Parser
DefaultVisit(node); DefaultVisit(node);
} }
public virtual void VisitIdentifierName(IdentifierNameSyntaxNode node) public virtual void VisitIdentifierNameExpression(IdentifierNameExpressionSyntaxNode node)
{ {
DefaultVisit(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. // We use the same set of kinds for syntax tokens & syntax nodes.
public enum TokenKind public enum TokenKind
{ {
// SYNTAX TOKENS // *****************
// * SYNTAX TOKENS *
// *****************
None = 0, None = 0,
BadToken = 1, BadToken = 1,
@ -123,31 +125,54 @@
UnaryNot = 59, UnaryNot = 59,
UnaryQuestionMark = 60, UnaryQuestionMark = 60,
// SYNTAX NODES // ****************
// * SYNTAX NODES *
// ****************
// The whole file. // The whole file.
File = 100, File = 100,
// a list of syntax nodes and/or tokens. // a list of syntax nodes and/or tokens.
List, 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) // [output1, output2] = function(input1, input2)
// <...> // <...>
// end // end
FunctionDeclaration, 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 // if a < 5
// doSomething(); // doSomething();
// elseif a > 10 // elseif a > 10
@ -156,84 +181,125 @@
// GiveUp(); // GiveUp();
// end // end
IfStatement, IfStatement,
// elseif a > 10
// doSomethingElse(); // switch a
ElseifClause, // case 1
// else // <...>
// GiveUp();
ElseClause,
// for a = 1:5
// process(a);
// end // end
ForStatement, SwitchStatement,
// a = 1:5
AssignmentExpression,
// catch e
// dealWithIt(e);
// end
CatchClause,
// try // try
// somethingWeird(); // somethingWeird();
// catch e // catch e
// dealWithIt(e); // dealWithIt(e);
// end // end
TryCatchStatement, TryCatchStatement,
// a = 5;
ExpressionStatement, // while a < 10
// // doSomething();
EmptyStatement, // end
// WhileStatement,
EmptyExpression,
// -13
UnaryPrefixOperationExpression, // EXPRESSIONS
// some.complex.name // The name ends with "Expression".
CompoundName,
// @func
NamedFunctionHandle,
// @(x) x + 1
Lambda,
// +
BinaryOperation,
// a
IdentifierName,
// 123
NumberLiteralExpression,
// 'abc'
StringLiteralExpression,
// "abc"
DoubleQuotedStringLiteralExpression,
// abc
UnquotedStringLiteralExpression,
// [1, 2; 3 4] // [1, 2; 3 4]
ArrayLiteralExpression, ArrayLiteralExpression,
// a = 1:5
AssignmentExpression,
// +
BinaryOperationExpression,
// abc{2}
CellArrayElementAccessExpression,
// {1, 3, 'abc'} // {1, 3, 'abc'}
CellArrayLiteralExpression, 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) // (1 + 2 * 3)
ParenthesizedExpression, ParenthesizedExpression,
// abc{2}
CellArrayElementAccess, // 'abc'
// doSomething(5) StringLiteralExpression,
FunctionCall,
// object.member // -13
MemberAccess, UnaryPrefixOperationExpression,
// [1 2 3]' // [1 2 3]'
UnaryPostfixOperationExpression, UnaryPostfixOperationExpression,
// struct.(field)
IndirectMemberAccess, // abc
// cd some/+folder/ UnquotedStringLiteralExpression,
Command,
// method@SuperClass(object)
ClassInvokation, // 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 // = true
AttributeAssignment, AttributeAssignment,
// Sealed = true // Sealed = true
Attribute, Attribute,
// (Sealed = true) // (Sealed = true)
AttributeList, AttributeList,
// function result = method(obj)
// <...>
// end
MethodDefinition,
// methods // methods
// function result = method(obj) // function result = method(obj)
// <...> // <...>
@ -247,15 +313,7 @@
PropertiesList, PropertiesList,
// < BaseClass, AnotherBaseClass // < BaseClass, AnotherBaseClass
BaseClassList, BaseClassList,
// classdef MyClass < BaseClass, AnotherBaseClass
// properties
// y
// end
// methods
// <...>
// end
// end
ClassDeclaration,
// (1) // (1)
EnumerationItemValue, EnumerationItemValue,
// One (1) // One (1)
@ -265,8 +323,6 @@
// Two (2) // Two (2)
// end // end
EnumerationList, EnumerationList,
// result = abstractMethod(object)
AbstractMethodDeclaration,
// events // events
// ToggleSomething // ToggleSomething
// end // end

3
SyntaxGenerator/GenerateSyntax.cs
View File

@ -844,7 +844,8 @@ namespace SyntaxGenerator
public static void Input() public static void Input()
{ {
var serializer = new XmlSerializer(typeof(SyntaxDescription)); 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)) if (!(serializer.Deserialize(stream) is SyntaxDescription syntax))
{ {
Console.WriteLine("Couldn't deserialize syntax."); Console.WriteLine("Couldn't deserialize syntax.");