diff --git a/Parser/Internal/SyntaxFactory.Generated.cs b/Parser/Internal/SyntaxFactory.Generated.cs index 833aaf2..fe84e55 100644 --- a/Parser/Internal/SyntaxFactory.Generated.cs +++ b/Parser/Internal/SyntaxFactory.Generated.cs @@ -3,198 +3,84 @@ namespace Parser.Internal { internal partial class SyntaxFactory { - public FileSyntaxNode FileSyntax( - SyntaxList statementList, - SyntaxToken endOfFile) + public FileSyntaxNode FileSyntax(SyntaxList statementList, SyntaxToken endOfFile) { - return new FileSyntaxNode( - statementList, - endOfFile); + return new FileSyntaxNode(statementList, endOfFile); } - public FunctionDeclarationSyntaxNode FunctionDeclarationSyntax( - SyntaxToken functionKeyword, - FunctionOutputDescriptionSyntaxNode? outputDescription, - SyntaxToken name, - FunctionInputDescriptionSyntaxNode? inputDescription, - SyntaxList commas, - SyntaxList body, - EndKeywordSyntaxNode? endKeyword) + public FunctionDeclarationSyntaxNode FunctionDeclarationSyntax(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, SyntaxToken name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, SyntaxList body, EndKeywordSyntaxNode? endKeyword) { - return new FunctionDeclarationSyntaxNode( - functionKeyword, - outputDescription, - name, - inputDescription, - commas, - body, - endKeyword); + return new FunctionDeclarationSyntaxNode(functionKeyword, outputDescription, name, inputDescription, commas, body, endKeyword); } - public FunctionOutputDescriptionSyntaxNode FunctionOutputDescriptionSyntax( - SyntaxList outputList, - SyntaxToken assignmentSign) + public FunctionOutputDescriptionSyntaxNode FunctionOutputDescriptionSyntax(SyntaxList outputList, SyntaxToken assignmentSign) { - return new FunctionOutputDescriptionSyntaxNode( - outputList, - assignmentSign); + return new FunctionOutputDescriptionSyntaxNode(outputList, assignmentSign); } - public FunctionInputDescriptionSyntaxNode FunctionInputDescriptionSyntax( - SyntaxToken openingBracket, - SyntaxList parameterList, - SyntaxToken closingBracket) + public FunctionInputDescriptionSyntaxNode FunctionInputDescriptionSyntax(SyntaxToken openingBracket, SyntaxList parameterList, SyntaxToken closingBracket) { - return new FunctionInputDescriptionSyntaxNode( - openingBracket, - parameterList, - closingBracket); + return new FunctionInputDescriptionSyntaxNode(openingBracket, parameterList, closingBracket); } - public SwitchStatementSyntaxNode SwitchStatementSyntax( - SyntaxToken switchKeyword, - ExpressionSyntaxNode switchExpression, - SyntaxList optionalCommas, - SyntaxList cases, - SyntaxToken endKeyword) + public SwitchStatementSyntaxNode SwitchStatementSyntax(SyntaxToken switchKeyword, ExpressionSyntaxNode switchExpression, SyntaxList optionalCommas, SyntaxList cases, SyntaxToken endKeyword) { - return new SwitchStatementSyntaxNode( - switchKeyword, - switchExpression, - optionalCommas, - cases, - endKeyword); + return new SwitchStatementSyntaxNode(switchKeyword, switchExpression, optionalCommas, cases, endKeyword); } - public SwitchCaseSyntaxNode SwitchCaseSyntax( - SyntaxToken caseKeyword, - ExpressionSyntaxNode caseIdentifier, - SyntaxList optionalCommas, - SyntaxList body) + public SwitchCaseSyntaxNode SwitchCaseSyntax(SyntaxToken caseKeyword, ExpressionSyntaxNode caseIdentifier, SyntaxList optionalCommas, SyntaxList body) { - return new SwitchCaseSyntaxNode( - caseKeyword, - caseIdentifier, - optionalCommas, - body); + return new SwitchCaseSyntaxNode(caseKeyword, caseIdentifier, optionalCommas, body); } - public WhileStatementSyntaxNode WhileStatementSyntax( - SyntaxToken whileKeyword, - ExpressionSyntaxNode condition, - SyntaxList optionalCommas, - SyntaxList body, - SyntaxToken endKeyword) + public WhileStatementSyntaxNode WhileStatementSyntax(SyntaxToken whileKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, SyntaxList body, SyntaxToken endKeyword) { - return new WhileStatementSyntaxNode( - whileKeyword, - condition, - optionalCommas, - body, - endKeyword); + return new WhileStatementSyntaxNode(whileKeyword, condition, optionalCommas, body, endKeyword); } - public ElseifClause ElseifClause( - SyntaxToken elseifKeyword, - ExpressionSyntaxNode condition, - SyntaxList optionalCommas, - SyntaxList body) + public ElseifClause ElseifClause(SyntaxToken elseifKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, SyntaxList body) { - return new ElseifClause( - elseifKeyword, - condition, - optionalCommas, - body); + return new ElseifClause(elseifKeyword, condition, optionalCommas, body); } - public ElseClause ElseClause( - SyntaxToken elseKeyword, - SyntaxList body) + public ElseClause ElseClause(SyntaxToken elseKeyword, SyntaxList body) { - return new ElseClause( - elseKeyword, - body); + return new ElseClause(elseKeyword, body); } - public IfStatementSyntaxNode IfStatementSyntax( - SyntaxToken ifKeyword, - ExpressionSyntaxNode condition, - SyntaxList optionalCommas, - SyntaxList body, - SyntaxList elseifClauses, - ElseClause? elseClause, - SyntaxToken endKeyword) + public IfStatementSyntaxNode IfStatementSyntax(SyntaxToken ifKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, SyntaxList body, SyntaxList elseifClauses, ElseClause? elseClause, SyntaxToken endKeyword) { - return new IfStatementSyntaxNode( - ifKeyword, - condition, - optionalCommas, - body, - elseifClauses, - elseClause, - endKeyword); + return new IfStatementSyntaxNode(ifKeyword, condition, optionalCommas, body, elseifClauses, elseClause, endKeyword); } - public ForStatementSyntaxNode ForStatementSyntax( - SyntaxToken forKeyword, - AssignmentExpressionSyntaxNode assignment, - SyntaxList optionalCommas, - SyntaxList body, - SyntaxToken endKeyword) + public ForStatementSyntaxNode ForStatementSyntax(SyntaxToken forKeyword, AssignmentExpressionSyntaxNode assignment, SyntaxList optionalCommas, SyntaxList body, SyntaxToken endKeyword) { - return new ForStatementSyntaxNode( - forKeyword, - assignment, - optionalCommas, - body, - endKeyword); + return new ForStatementSyntaxNode(forKeyword, assignment, optionalCommas, body, endKeyword); } - public AssignmentExpressionSyntaxNode AssignmentExpressionSyntax( - ExpressionSyntaxNode lhs, - SyntaxToken assignmentSign, - ExpressionSyntaxNode rhs) + public AssignmentExpressionSyntaxNode AssignmentExpressionSyntax(ExpressionSyntaxNode lhs, SyntaxToken assignmentSign, ExpressionSyntaxNode rhs) { - return new AssignmentExpressionSyntaxNode( - lhs, - assignmentSign, - rhs); + return new AssignmentExpressionSyntaxNode(lhs, assignmentSign, rhs); } - public CatchClauseSyntaxNode CatchClauseSyntax( - SyntaxToken catchKeyword, - SyntaxList catchBody) + public CatchClauseSyntaxNode CatchClauseSyntax(SyntaxToken catchKeyword, SyntaxList catchBody) { - return new CatchClauseSyntaxNode( - catchKeyword, - catchBody); + return new CatchClauseSyntaxNode(catchKeyword, catchBody); } - public TryCatchStatementSyntaxNode TryCatchStatementSyntax( - SyntaxToken tryKeyword, - SyntaxList tryBody, - CatchClauseSyntaxNode? catchClause, - SyntaxToken endKeyword) + public TryCatchStatementSyntaxNode TryCatchStatementSyntax(SyntaxToken tryKeyword, SyntaxList tryBody, CatchClauseSyntaxNode? catchClause, SyntaxToken endKeyword) { - return new TryCatchStatementSyntaxNode( - tryKeyword, - tryBody, - catchClause, - endKeyword); + return new TryCatchStatementSyntaxNode(tryKeyword, tryBody, catchClause, endKeyword); } - public ExpressionStatementSyntaxNode ExpressionStatementSyntax( - ExpressionSyntaxNode expression) + public ExpressionStatementSyntaxNode ExpressionStatementSyntax(ExpressionSyntaxNode expression) { - return new ExpressionStatementSyntaxNode( - expression); + return new ExpressionStatementSyntaxNode(expression); } - public EmptyStatementSyntaxNode EmptyStatementSyntax( - SyntaxToken semicolon) + public EmptyStatementSyntaxNode EmptyStatementSyntax(SyntaxToken semicolon) { - return new EmptyStatementSyntaxNode( - semicolon); + return new EmptyStatementSyntaxNode(semicolon); } public EmptyExpressionSyntaxNode EmptyExpressionSyntax() @@ -202,362 +88,174 @@ namespace Parser.Internal return new EmptyExpressionSyntaxNode(); } - public UnaryPrefixOperationExpressionSyntaxNode UnaryPrefixOperationExpressionSyntax( - SyntaxToken operation, - ExpressionSyntaxNode operand) + public UnaryPrefixOperationExpressionSyntaxNode UnaryPrefixOperationExpressionSyntax(SyntaxToken operation, ExpressionSyntaxNode operand) { - return new UnaryPrefixOperationExpressionSyntaxNode( - operation, - operand); + return new UnaryPrefixOperationExpressionSyntaxNode(operation, operand); } - public CompoundNameSyntaxNode CompoundNameSyntax( - SyntaxList nodes) + public CompoundNameSyntaxNode CompoundNameSyntax(SyntaxList nodes) { - return new CompoundNameSyntaxNode( - nodes); + return new CompoundNameSyntaxNode(nodes); } - public NamedFunctionHandleSyntaxNode NamedFunctionHandleSyntax( - SyntaxToken atSign, - CompoundNameSyntaxNode functionName) + public NamedFunctionHandleSyntaxNode NamedFunctionHandleSyntax(SyntaxToken atSign, CompoundNameSyntaxNode functionName) { - return new NamedFunctionHandleSyntaxNode( - atSign, - functionName); + return new NamedFunctionHandleSyntaxNode(atSign, functionName); } - public LambdaSyntaxNode LambdaSyntax( - SyntaxToken atSign, - FunctionInputDescriptionSyntaxNode input, - ExpressionSyntaxNode body) + public LambdaSyntaxNode LambdaSyntax(SyntaxToken atSign, FunctionInputDescriptionSyntaxNode input, ExpressionSyntaxNode body) { - return new LambdaSyntaxNode( - atSign, - input, - body); + return new LambdaSyntaxNode(atSign, input, body); } - public BinaryOperationExpressionSyntaxNode BinaryOperationExpressionSyntax( - ExpressionSyntaxNode lhs, - SyntaxToken operation, - ExpressionSyntaxNode rhs) + public BinaryOperationExpressionSyntaxNode BinaryOperationExpressionSyntax(ExpressionSyntaxNode lhs, SyntaxToken operation, ExpressionSyntaxNode rhs) { - return new BinaryOperationExpressionSyntaxNode( - lhs, - operation, - rhs); + return new BinaryOperationExpressionSyntaxNode(lhs, operation, rhs); } - public IdentifierNameSyntaxNode IdentifierNameSyntax( - SyntaxToken name) + public IdentifierNameSyntaxNode IdentifierNameSyntax(SyntaxToken name) { - return new IdentifierNameSyntaxNode( - name); + return new IdentifierNameSyntaxNode(name); } - public NumberLiteralSyntaxNode NumberLiteralSyntax( - SyntaxToken number) + public NumberLiteralSyntaxNode NumberLiteralSyntax(SyntaxToken number) { - return new NumberLiteralSyntaxNode( - number); + return new NumberLiteralSyntaxNode(number); } - public StringLiteralSyntaxNode StringLiteralSyntax( - SyntaxToken stringToken) + public StringLiteralSyntaxNode StringLiteralSyntax(SyntaxToken stringToken) { - return new StringLiteralSyntaxNode( - stringToken); + return new StringLiteralSyntaxNode(stringToken); } - public DoubleQuotedStringLiteralSyntaxNode DoubleQuotedStringLiteralSyntax( - SyntaxToken stringToken) + public DoubleQuotedStringLiteralSyntaxNode DoubleQuotedStringLiteralSyntax(SyntaxToken stringToken) { - return new DoubleQuotedStringLiteralSyntaxNode( - stringToken); + return new DoubleQuotedStringLiteralSyntaxNode(stringToken); } - public UnquotedStringLiteralSyntaxNode UnquotedStringLiteralSyntax( - SyntaxToken stringToken) + public UnquotedStringLiteralSyntaxNode UnquotedStringLiteralSyntax(SyntaxToken stringToken) { - return new UnquotedStringLiteralSyntaxNode( - stringToken); + return new UnquotedStringLiteralSyntaxNode(stringToken); } - public ArrayLiteralExpressionSyntaxNode ArrayLiteralExpressionSyntax( - SyntaxToken openingSquareBracket, - SyntaxList nodes, - SyntaxToken closingSquareBracket) + public ArrayLiteralExpressionSyntaxNode ArrayLiteralExpressionSyntax(SyntaxToken openingSquareBracket, SyntaxList nodes, SyntaxToken closingSquareBracket) { - return new ArrayLiteralExpressionSyntaxNode( - openingSquareBracket, - nodes, - closingSquareBracket); + return new ArrayLiteralExpressionSyntaxNode(openingSquareBracket, nodes, closingSquareBracket); } - public CellArrayLiteralExpressionSyntaxNode CellArrayLiteralExpressionSyntax( - SyntaxToken openingBrace, - SyntaxList nodes, - SyntaxToken closingBrace) + public CellArrayLiteralExpressionSyntaxNode CellArrayLiteralExpressionSyntax(SyntaxToken openingBrace, SyntaxList nodes, SyntaxToken closingBrace) { - return new CellArrayLiteralExpressionSyntaxNode( - openingBrace, - nodes, - closingBrace); + return new CellArrayLiteralExpressionSyntaxNode(openingBrace, nodes, closingBrace); } - public ParenthesizedExpressionSyntaxNode ParenthesizedExpressionSyntax( - SyntaxToken openingBracket, - ExpressionSyntaxNode expression, - SyntaxToken closingBracket) + public ParenthesizedExpressionSyntaxNode ParenthesizedExpressionSyntax(SyntaxToken openingBracket, ExpressionSyntaxNode expression, SyntaxToken closingBracket) { - return new ParenthesizedExpressionSyntaxNode( - openingBracket, - expression, - closingBracket); + return new ParenthesizedExpressionSyntaxNode(openingBracket, expression, closingBracket); } - public CellArrayElementAccessExpressionSyntaxNode CellArrayElementAccessExpressionSyntax( - ExpressionSyntaxNode expression, - SyntaxToken openingBrace, - SyntaxList nodes, - SyntaxToken closingBrace) + public CellArrayElementAccessExpressionSyntaxNode CellArrayElementAccessExpressionSyntax(ExpressionSyntaxNode expression, SyntaxToken openingBrace, SyntaxList nodes, SyntaxToken closingBrace) { - return new CellArrayElementAccessExpressionSyntaxNode( - expression, - openingBrace, - nodes, - closingBrace); + return new CellArrayElementAccessExpressionSyntaxNode(expression, openingBrace, nodes, closingBrace); } - public FunctionCallExpressionSyntaxNode FunctionCallExpressionSyntax( - ExpressionSyntaxNode functionName, - SyntaxToken openingBracket, - SyntaxList nodes, - SyntaxToken closingBracket) + public FunctionCallExpressionSyntaxNode FunctionCallExpressionSyntax(ExpressionSyntaxNode functionName, SyntaxToken openingBracket, SyntaxList nodes, SyntaxToken closingBracket) { - return new FunctionCallExpressionSyntaxNode( - functionName, - openingBracket, - nodes, - closingBracket); + return new FunctionCallExpressionSyntaxNode(functionName, openingBracket, nodes, closingBracket); } - public MemberAccessSyntaxNode MemberAccessSyntax( - SyntaxNode leftOperand, - SyntaxToken dot, - SyntaxNode rightOperand) + public MemberAccessSyntaxNode MemberAccessSyntax(SyntaxNode leftOperand, SyntaxToken dot, SyntaxNode rightOperand) { - return new MemberAccessSyntaxNode( - leftOperand, - dot, - rightOperand); + return new MemberAccessSyntaxNode(leftOperand, dot, rightOperand); } - public UnaryPostixOperationExpressionSyntaxNode UnaryPostixOperationExpressionSyntax( - ExpressionSyntaxNode operand, - SyntaxToken operation) + public UnaryPostixOperationExpressionSyntaxNode UnaryPostixOperationExpressionSyntax(ExpressionSyntaxNode operand, SyntaxToken operation) { - return new UnaryPostixOperationExpressionSyntaxNode( - operand, - operation); + return new UnaryPostixOperationExpressionSyntaxNode(operand, operation); } - public IndirectMemberAccessSyntaxNode IndirectMemberAccessSyntax( - SyntaxToken openingBracket, - ExpressionSyntaxNode expression, - SyntaxToken closingBracket) + public IndirectMemberAccessSyntaxNode IndirectMemberAccessSyntax(SyntaxToken openingBracket, ExpressionSyntaxNode expression, SyntaxToken closingBracket) { - return new IndirectMemberAccessSyntaxNode( - openingBracket, - expression, - closingBracket); + return new IndirectMemberAccessSyntaxNode(openingBracket, expression, closingBracket); } - public CommandExpressionSyntaxNode CommandExpressionSyntax( - IdentifierNameSyntaxNode commandName, - SyntaxList arguments) + public CommandExpressionSyntaxNode CommandExpressionSyntax(IdentifierNameSyntaxNode commandName, SyntaxList arguments) { - return new CommandExpressionSyntaxNode( - commandName, - arguments); + return new CommandExpressionSyntaxNode(commandName, arguments); } - public BaseClassInvokationSyntaxNode BaseClassInvokationSyntax( - ExpressionSyntaxNode methodName, - SyntaxToken atSign, - ExpressionSyntaxNode baseClassNameAndArguments) + public BaseClassInvokationSyntaxNode BaseClassInvokationSyntax(ExpressionSyntaxNode methodName, SyntaxToken atSign, ExpressionSyntaxNode baseClassNameAndArguments) { - return new BaseClassInvokationSyntaxNode( - methodName, - atSign, - baseClassNameAndArguments); + return new BaseClassInvokationSyntaxNode(methodName, atSign, baseClassNameAndArguments); } - public AttributeAssignmentSyntaxNode AttributeAssignmentSyntax( - SyntaxToken assignmentSign, - ExpressionSyntaxNode value) + public AttributeAssignmentSyntaxNode AttributeAssignmentSyntax(SyntaxToken assignmentSign, ExpressionSyntaxNode value) { - return new AttributeAssignmentSyntaxNode( - assignmentSign, - value); + return new AttributeAssignmentSyntaxNode(assignmentSign, value); } - public AttributeSyntaxNode AttributeSyntax( - IdentifierNameSyntaxNode name, - AttributeAssignmentSyntaxNode? assignment) + public AttributeSyntaxNode AttributeSyntax(IdentifierNameSyntaxNode name, AttributeAssignmentSyntaxNode? assignment) { - return new AttributeSyntaxNode( - name, - assignment); + return new AttributeSyntaxNode(name, assignment); } - public AttributeListSyntaxNode AttributeListSyntax( - SyntaxToken openingBracket, - SyntaxList nodes, - SyntaxToken closingBracket) + public AttributeListSyntaxNode AttributeListSyntax(SyntaxToken openingBracket, SyntaxList nodes, SyntaxToken closingBracket) { - return new AttributeListSyntaxNode( - openingBracket, - nodes, - closingBracket); + return new AttributeListSyntaxNode(openingBracket, nodes, closingBracket); } - public MethodDefinitionSyntaxNode MethodDefinitionSyntax( - SyntaxToken functionKeyword, - FunctionOutputDescriptionSyntaxNode? outputDescription, - CompoundNameSyntaxNode name, - FunctionInputDescriptionSyntaxNode? inputDescription, - SyntaxList commas, - SyntaxList body, - EndKeywordSyntaxNode? endKeyword) + public MethodDefinitionSyntaxNode MethodDefinitionSyntax(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList 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, CompoundNameSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription) { - return new AbstractMethodDeclarationSyntaxNode( - outputDescription, - name, - inputDescription); + return new AbstractMethodDeclarationSyntaxNode(outputDescription, name, inputDescription); } - public MethodsListSyntaxNode MethodsListSyntax( - SyntaxToken methodsKeyword, - AttributeListSyntaxNode? attributes, - SyntaxList methods, - SyntaxToken endKeyword) + public MethodsListSyntaxNode MethodsListSyntax(SyntaxToken methodsKeyword, AttributeListSyntaxNode? attributes, SyntaxList methods, SyntaxToken endKeyword) { - return new MethodsListSyntaxNode( - methodsKeyword, - attributes, - methods, - endKeyword); + return new MethodsListSyntaxNode(methodsKeyword, attributes, methods, endKeyword); } - public PropertiesListSyntaxNode PropertiesListSyntax( - SyntaxToken propertiesKeyword, - AttributeListSyntaxNode? attributes, - SyntaxList properties, - SyntaxToken endKeyword) + public PropertiesListSyntaxNode PropertiesListSyntax(SyntaxToken propertiesKeyword, AttributeListSyntaxNode? attributes, SyntaxList properties, SyntaxToken endKeyword) { - return new PropertiesListSyntaxNode( - propertiesKeyword, - attributes, - properties, - endKeyword); + return new PropertiesListSyntaxNode(propertiesKeyword, attributes, properties, endKeyword); } - public BaseClassListSyntaxNode BaseClassListSyntax( - SyntaxToken lessSign, - SyntaxList baseClasses) + public BaseClassListSyntaxNode BaseClassListSyntax(SyntaxToken lessSign, SyntaxList baseClasses) { - 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, IdentifierNameSyntaxNode 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); } - public EnumerationItemValueSyntaxNode EnumerationItemValueSyntax( - SyntaxToken openingBracket, - SyntaxList values, - SyntaxToken closingBracket) + public EnumerationItemValueSyntaxNode EnumerationItemValueSyntax(SyntaxToken openingBracket, SyntaxList values, SyntaxToken closingBracket) { - return new EnumerationItemValueSyntaxNode( - openingBracket, - values, - closingBracket); + return new EnumerationItemValueSyntaxNode(openingBracket, values, closingBracket); } - public EnumerationItemSyntaxNode EnumerationItemSyntax( - IdentifierNameSyntaxNode name, - EnumerationItemValueSyntaxNode? values, - SyntaxList commas) + public EnumerationItemSyntaxNode EnumerationItemSyntax(IdentifierNameSyntaxNode name, EnumerationItemValueSyntaxNode? values, SyntaxList commas) { - return new EnumerationItemSyntaxNode( - name, - values, - commas); + return new EnumerationItemSyntaxNode(name, values, commas); } - public EnumerationListSyntaxNode EnumerationListSyntax( - SyntaxToken enumerationKeyword, - AttributeListSyntaxNode? attributes, - SyntaxList items, - SyntaxToken endKeyword) + public EnumerationListSyntaxNode EnumerationListSyntax(SyntaxToken enumerationKeyword, AttributeListSyntaxNode? attributes, SyntaxList items, SyntaxToken endKeyword) { - return new EnumerationListSyntaxNode( - enumerationKeyword, - attributes, - items, - endKeyword); + return new EnumerationListSyntaxNode(enumerationKeyword, attributes, items, endKeyword); } - public EventsListSyntaxNode EventsListSyntax( - SyntaxToken eventsKeyword, - AttributeListSyntaxNode? attributes, - SyntaxList events, - SyntaxToken endKeyword) + public EventsListSyntaxNode EventsListSyntax(SyntaxToken eventsKeyword, AttributeListSyntaxNode? attributes, SyntaxList events, SyntaxToken endKeyword) { - return new EventsListSyntaxNode( - eventsKeyword, - attributes, - events, - endKeyword); + return new EventsListSyntaxNode(eventsKeyword, attributes, events, endKeyword); } - public EndKeywordSyntaxNode EndKeywordSyntax( - SyntaxToken endKeyword) + public EndKeywordSyntaxNode EndKeywordSyntax(SyntaxToken endKeyword) { - return new EndKeywordSyntaxNode( - endKeyword); + return new EndKeywordSyntaxNode(endKeyword); } } } \ No newline at end of file diff --git a/Parser/Internal/SyntaxNode.Generated.cs b/Parser/Internal/SyntaxNode.Generated.cs index 594154d..32742dd 100644 --- a/Parser/Internal/SyntaxNode.Generated.cs +++ b/Parser/Internal/SyntaxNode.Generated.cs @@ -5,10 +5,7 @@ namespace Parser.Internal { internal readonly SyntaxList _statementList; internal readonly SyntaxToken _endOfFile; - - internal FileSyntaxNode( - SyntaxList statementList, - SyntaxToken endOfFile) : base(TokenKind.File) + internal FileSyntaxNode(SyntaxList statementList, SyntaxToken endOfFile): base(TokenKind.File) { Slots = 2; this.AdjustWidth(statementList); @@ -17,10 +14,7 @@ namespace Parser.Internal _endOfFile = endOfFile; } - internal FileSyntaxNode( - SyntaxList statementList, - SyntaxToken endOfFile, - TokenDiagnostic[] diagnostics) : base(TokenKind.File, diagnostics) + internal FileSyntaxNode(SyntaxList statementList, SyntaxToken endOfFile, TokenDiagnostic[] diagnostics): base(TokenKind.File, diagnostics) { Slots = 2; this.AdjustWidth(statementList); @@ -41,12 +35,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _statementList; - case 1: return _endOfFile; - default: return null; + 0 => _statementList, 1 => _endOfFile, _ => null } + + ; } } @@ -59,15 +53,7 @@ namespace Parser.Internal internal readonly SyntaxList _commas; internal readonly SyntaxList _body; internal readonly EndKeywordSyntaxNode? _endKeyword; - - internal FunctionDeclarationSyntaxNode( - SyntaxToken functionKeyword, - FunctionOutputDescriptionSyntaxNode? outputDescription, - SyntaxToken name, - FunctionInputDescriptionSyntaxNode? inputDescription, - SyntaxList commas, - SyntaxList body, - EndKeywordSyntaxNode? endKeyword) : base(TokenKind.FunctionDeclaration) + internal FunctionDeclarationSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, SyntaxToken name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, SyntaxList body, EndKeywordSyntaxNode? endKeyword): base(TokenKind.FunctionDeclaration) { Slots = 7; this.AdjustWidth(functionKeyword); @@ -86,15 +72,7 @@ namespace Parser.Internal _endKeyword = endKeyword; } - internal FunctionDeclarationSyntaxNode( - SyntaxToken functionKeyword, - FunctionOutputDescriptionSyntaxNode? outputDescription, - SyntaxToken name, - FunctionInputDescriptionSyntaxNode? inputDescription, - SyntaxList commas, - SyntaxList body, - EndKeywordSyntaxNode? endKeyword, - TokenDiagnostic[] diagnostics) : base(TokenKind.FunctionDeclaration, diagnostics) + internal FunctionDeclarationSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, SyntaxToken name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, SyntaxList body, EndKeywordSyntaxNode? endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.FunctionDeclaration, diagnostics) { Slots = 7; this.AdjustWidth(functionKeyword); @@ -125,17 +103,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _functionKeyword; - case 1: return _outputDescription; - case 2: return _name; - case 3: return _inputDescription; - case 4: return _commas; - case 5: return _body; - case 6: return _endKeyword; - default: return null; + 0 => _functionKeyword, 1 => _outputDescription, 2 => _name, 3 => _inputDescription, 4 => _commas, 5 => _body, 6 => _endKeyword, _ => null } + + ; } } @@ -143,10 +116,7 @@ namespace Parser.Internal { internal readonly SyntaxList _outputList; internal readonly SyntaxToken _assignmentSign; - - internal FunctionOutputDescriptionSyntaxNode( - SyntaxList outputList, - SyntaxToken assignmentSign) : base(TokenKind.FunctionOutputDescription) + internal FunctionOutputDescriptionSyntaxNode(SyntaxList outputList, SyntaxToken assignmentSign): base(TokenKind.FunctionOutputDescription) { Slots = 2; this.AdjustWidth(outputList); @@ -155,10 +125,7 @@ namespace Parser.Internal _assignmentSign = assignmentSign; } - internal FunctionOutputDescriptionSyntaxNode( - SyntaxList outputList, - SyntaxToken assignmentSign, - TokenDiagnostic[] diagnostics) : base(TokenKind.FunctionOutputDescription, diagnostics) + internal FunctionOutputDescriptionSyntaxNode(SyntaxList outputList, SyntaxToken assignmentSign, TokenDiagnostic[] diagnostics): base(TokenKind.FunctionOutputDescription, diagnostics) { Slots = 2; this.AdjustWidth(outputList); @@ -179,12 +146,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _outputList; - case 1: return _assignmentSign; - default: return null; + 0 => _outputList, 1 => _assignmentSign, _ => null } + + ; } } @@ -193,11 +160,7 @@ namespace Parser.Internal internal readonly SyntaxToken _openingBracket; internal readonly SyntaxList _parameterList; internal readonly SyntaxToken _closingBracket; - - internal FunctionInputDescriptionSyntaxNode( - SyntaxToken openingBracket, - SyntaxList parameterList, - SyntaxToken closingBracket) : base(TokenKind.FunctionInputDescription) + internal FunctionInputDescriptionSyntaxNode(SyntaxToken openingBracket, SyntaxList parameterList, SyntaxToken closingBracket): base(TokenKind.FunctionInputDescription) { Slots = 3; this.AdjustWidth(openingBracket); @@ -208,11 +171,7 @@ namespace Parser.Internal _closingBracket = closingBracket; } - internal FunctionInputDescriptionSyntaxNode( - SyntaxToken openingBracket, - SyntaxList parameterList, - SyntaxToken closingBracket, - TokenDiagnostic[] diagnostics) : base(TokenKind.FunctionInputDescription, diagnostics) + internal FunctionInputDescriptionSyntaxNode(SyntaxToken openingBracket, SyntaxList parameterList, SyntaxToken closingBracket, TokenDiagnostic[] diagnostics): base(TokenKind.FunctionInputDescription, diagnostics) { Slots = 3; this.AdjustWidth(openingBracket); @@ -235,13 +194,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _openingBracket; - case 1: return _parameterList; - case 2: return _closingBracket; - default: return null; + 0 => _openingBracket, 1 => _parameterList, 2 => _closingBracket, _ => null } + + ; } } @@ -252,13 +210,7 @@ namespace Parser.Internal internal readonly SyntaxList _optionalCommas; internal readonly SyntaxList _cases; internal readonly SyntaxToken _endKeyword; - - internal SwitchStatementSyntaxNode( - SyntaxToken switchKeyword, - ExpressionSyntaxNode switchExpression, - SyntaxList optionalCommas, - SyntaxList cases, - SyntaxToken endKeyword) : base(TokenKind.SwitchStatement) + internal SwitchStatementSyntaxNode(SyntaxToken switchKeyword, ExpressionSyntaxNode switchExpression, SyntaxList optionalCommas, SyntaxList cases, SyntaxToken endKeyword): base(TokenKind.SwitchStatement) { Slots = 5; this.AdjustWidth(switchKeyword); @@ -273,13 +225,7 @@ namespace Parser.Internal _endKeyword = endKeyword; } - internal SwitchStatementSyntaxNode( - SyntaxToken switchKeyword, - ExpressionSyntaxNode switchExpression, - SyntaxList optionalCommas, - SyntaxList cases, - SyntaxToken endKeyword, - TokenDiagnostic[] diagnostics) : base(TokenKind.SwitchStatement, diagnostics) + internal SwitchStatementSyntaxNode(SyntaxToken switchKeyword, ExpressionSyntaxNode switchExpression, SyntaxList optionalCommas, SyntaxList cases, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.SwitchStatement, diagnostics) { Slots = 5; this.AdjustWidth(switchKeyword); @@ -306,15 +252,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _switchKeyword; - case 1: return _switchExpression; - case 2: return _optionalCommas; - case 3: return _cases; - case 4: return _endKeyword; - default: return null; + 0 => _switchKeyword, 1 => _switchExpression, 2 => _optionalCommas, 3 => _cases, 4 => _endKeyword, _ => null } + + ; } } @@ -324,12 +267,7 @@ namespace Parser.Internal internal readonly ExpressionSyntaxNode _caseIdentifier; internal readonly SyntaxList _optionalCommas; internal readonly SyntaxList _body; - - internal SwitchCaseSyntaxNode( - SyntaxToken caseKeyword, - ExpressionSyntaxNode caseIdentifier, - SyntaxList optionalCommas, - SyntaxList body) : base(TokenKind.SwitchCase) + internal SwitchCaseSyntaxNode(SyntaxToken caseKeyword, ExpressionSyntaxNode caseIdentifier, SyntaxList optionalCommas, SyntaxList body): base(TokenKind.SwitchCase) { Slots = 4; this.AdjustWidth(caseKeyword); @@ -342,12 +280,7 @@ namespace Parser.Internal _body = body; } - internal SwitchCaseSyntaxNode( - SyntaxToken caseKeyword, - ExpressionSyntaxNode caseIdentifier, - SyntaxList optionalCommas, - SyntaxList body, - TokenDiagnostic[] diagnostics) : base(TokenKind.SwitchCase, diagnostics) + internal SwitchCaseSyntaxNode(SyntaxToken caseKeyword, ExpressionSyntaxNode caseIdentifier, SyntaxList optionalCommas, SyntaxList body, TokenDiagnostic[] diagnostics): base(TokenKind.SwitchCase, diagnostics) { Slots = 4; this.AdjustWidth(caseKeyword); @@ -372,14 +305,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _caseKeyword; - case 1: return _caseIdentifier; - case 2: return _optionalCommas; - case 3: return _body; - default: return null; + 0 => _caseKeyword, 1 => _caseIdentifier, 2 => _optionalCommas, 3 => _body, _ => null } + + ; } } @@ -390,13 +321,7 @@ namespace Parser.Internal internal readonly SyntaxList _optionalCommas; internal readonly SyntaxList _body; internal readonly SyntaxToken _endKeyword; - - internal WhileStatementSyntaxNode( - SyntaxToken whileKeyword, - ExpressionSyntaxNode condition, - SyntaxList optionalCommas, - SyntaxList body, - SyntaxToken endKeyword) : base(TokenKind.WhileStatement) + internal WhileStatementSyntaxNode(SyntaxToken whileKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, SyntaxList body, SyntaxToken endKeyword): base(TokenKind.WhileStatement) { Slots = 5; this.AdjustWidth(whileKeyword); @@ -411,13 +336,7 @@ namespace Parser.Internal _endKeyword = endKeyword; } - internal WhileStatementSyntaxNode( - SyntaxToken whileKeyword, - ExpressionSyntaxNode condition, - SyntaxList optionalCommas, - SyntaxList body, - SyntaxToken endKeyword, - TokenDiagnostic[] diagnostics) : base(TokenKind.WhileStatement, diagnostics) + internal WhileStatementSyntaxNode(SyntaxToken whileKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, SyntaxList body, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.WhileStatement, diagnostics) { Slots = 5; this.AdjustWidth(whileKeyword); @@ -444,15 +363,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _whileKeyword; - case 1: return _condition; - case 2: return _optionalCommas; - case 3: return _body; - case 4: return _endKeyword; - default: return null; + 0 => _whileKeyword, 1 => _condition, 2 => _optionalCommas, 3 => _body, 4 => _endKeyword, _ => null } + + ; } } @@ -462,12 +378,7 @@ namespace Parser.Internal internal readonly ExpressionSyntaxNode _condition; internal readonly SyntaxList _optionalCommas; internal readonly SyntaxList _body; - - internal ElseifClause( - SyntaxToken elseifKeyword, - ExpressionSyntaxNode condition, - SyntaxList optionalCommas, - SyntaxList body) : base(TokenKind.ElseifClause) + internal ElseifClause(SyntaxToken elseifKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, SyntaxList body): base(TokenKind.ElseifClause) { Slots = 4; this.AdjustWidth(elseifKeyword); @@ -480,12 +391,7 @@ namespace Parser.Internal _body = body; } - internal ElseifClause( - SyntaxToken elseifKeyword, - ExpressionSyntaxNode condition, - SyntaxList optionalCommas, - SyntaxList body, - TokenDiagnostic[] diagnostics) : base(TokenKind.ElseifClause, diagnostics) + internal ElseifClause(SyntaxToken elseifKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, SyntaxList body, TokenDiagnostic[] diagnostics): base(TokenKind.ElseifClause, diagnostics) { Slots = 4; this.AdjustWidth(elseifKeyword); @@ -510,14 +416,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _elseifKeyword; - case 1: return _condition; - case 2: return _optionalCommas; - case 3: return _body; - default: return null; + 0 => _elseifKeyword, 1 => _condition, 2 => _optionalCommas, 3 => _body, _ => null } + + ; } } @@ -525,10 +429,7 @@ namespace Parser.Internal { internal readonly SyntaxToken _elseKeyword; internal readonly SyntaxList _body; - - internal ElseClause( - SyntaxToken elseKeyword, - SyntaxList body) : base(TokenKind.ElseClause) + internal ElseClause(SyntaxToken elseKeyword, SyntaxList body): base(TokenKind.ElseClause) { Slots = 2; this.AdjustWidth(elseKeyword); @@ -537,10 +438,7 @@ namespace Parser.Internal _body = body; } - internal ElseClause( - SyntaxToken elseKeyword, - SyntaxList body, - TokenDiagnostic[] diagnostics) : base(TokenKind.ElseClause, diagnostics) + internal ElseClause(SyntaxToken elseKeyword, SyntaxList body, TokenDiagnostic[] diagnostics): base(TokenKind.ElseClause, diagnostics) { Slots = 2; this.AdjustWidth(elseKeyword); @@ -561,12 +459,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _elseKeyword; - case 1: return _body; - default: return null; + 0 => _elseKeyword, 1 => _body, _ => null } + + ; } } @@ -579,15 +477,7 @@ namespace Parser.Internal internal readonly SyntaxList _elseifClauses; internal readonly ElseClause? _elseClause; internal readonly SyntaxToken _endKeyword; - - internal IfStatementSyntaxNode( - SyntaxToken ifKeyword, - ExpressionSyntaxNode condition, - SyntaxList optionalCommas, - SyntaxList body, - SyntaxList elseifClauses, - ElseClause? elseClause, - SyntaxToken endKeyword) : base(TokenKind.IfStatement) + internal IfStatementSyntaxNode(SyntaxToken ifKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, SyntaxList body, SyntaxList elseifClauses, ElseClause? elseClause, SyntaxToken endKeyword): base(TokenKind.IfStatement) { Slots = 7; this.AdjustWidth(ifKeyword); @@ -606,15 +496,7 @@ namespace Parser.Internal _endKeyword = endKeyword; } - internal IfStatementSyntaxNode( - SyntaxToken ifKeyword, - ExpressionSyntaxNode condition, - SyntaxList optionalCommas, - SyntaxList body, - SyntaxList elseifClauses, - ElseClause? elseClause, - SyntaxToken endKeyword, - TokenDiagnostic[] diagnostics) : base(TokenKind.IfStatement, diagnostics) + internal IfStatementSyntaxNode(SyntaxToken ifKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, SyntaxList body, SyntaxList elseifClauses, ElseClause? elseClause, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.IfStatement, diagnostics) { Slots = 7; this.AdjustWidth(ifKeyword); @@ -645,17 +527,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _ifKeyword; - case 1: return _condition; - case 2: return _optionalCommas; - case 3: return _body; - case 4: return _elseifClauses; - case 5: return _elseClause; - case 6: return _endKeyword; - default: return null; + 0 => _ifKeyword, 1 => _condition, 2 => _optionalCommas, 3 => _body, 4 => _elseifClauses, 5 => _elseClause, 6 => _endKeyword, _ => null } + + ; } } @@ -666,13 +543,7 @@ namespace Parser.Internal internal readonly SyntaxList _optionalCommas; internal readonly SyntaxList _body; internal readonly SyntaxToken _endKeyword; - - internal ForStatementSyntaxNode( - SyntaxToken forKeyword, - AssignmentExpressionSyntaxNode assignment, - SyntaxList optionalCommas, - SyntaxList body, - SyntaxToken endKeyword) : base(TokenKind.ForStatement) + internal ForStatementSyntaxNode(SyntaxToken forKeyword, AssignmentExpressionSyntaxNode assignment, SyntaxList optionalCommas, SyntaxList body, SyntaxToken endKeyword): base(TokenKind.ForStatement) { Slots = 5; this.AdjustWidth(forKeyword); @@ -687,13 +558,7 @@ namespace Parser.Internal _endKeyword = endKeyword; } - internal ForStatementSyntaxNode( - SyntaxToken forKeyword, - AssignmentExpressionSyntaxNode assignment, - SyntaxList optionalCommas, - SyntaxList body, - SyntaxToken endKeyword, - TokenDiagnostic[] diagnostics) : base(TokenKind.ForStatement, diagnostics) + internal ForStatementSyntaxNode(SyntaxToken forKeyword, AssignmentExpressionSyntaxNode assignment, SyntaxList optionalCommas, SyntaxList body, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.ForStatement, diagnostics) { Slots = 5; this.AdjustWidth(forKeyword); @@ -720,15 +585,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _forKeyword; - case 1: return _assignment; - case 2: return _optionalCommas; - case 3: return _body; - case 4: return _endKeyword; - default: return null; + 0 => _forKeyword, 1 => _assignment, 2 => _optionalCommas, 3 => _body, 4 => _endKeyword, _ => null } + + ; } } @@ -737,11 +599,7 @@ namespace Parser.Internal internal readonly ExpressionSyntaxNode _lhs; internal readonly SyntaxToken _assignmentSign; internal readonly ExpressionSyntaxNode _rhs; - - internal AssignmentExpressionSyntaxNode( - ExpressionSyntaxNode lhs, - SyntaxToken assignmentSign, - ExpressionSyntaxNode rhs) : base(TokenKind.AssignmentExpression) + internal AssignmentExpressionSyntaxNode(ExpressionSyntaxNode lhs, SyntaxToken assignmentSign, ExpressionSyntaxNode rhs): base(TokenKind.AssignmentExpression) { Slots = 3; this.AdjustWidth(lhs); @@ -752,11 +610,7 @@ namespace Parser.Internal _rhs = rhs; } - internal AssignmentExpressionSyntaxNode( - ExpressionSyntaxNode lhs, - SyntaxToken assignmentSign, - ExpressionSyntaxNode rhs, - TokenDiagnostic[] diagnostics) : base(TokenKind.AssignmentExpression, diagnostics) + internal AssignmentExpressionSyntaxNode(ExpressionSyntaxNode lhs, SyntaxToken assignmentSign, ExpressionSyntaxNode rhs, TokenDiagnostic[] diagnostics): base(TokenKind.AssignmentExpression, diagnostics) { Slots = 3; this.AdjustWidth(lhs); @@ -779,13 +633,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _lhs; - case 1: return _assignmentSign; - case 2: return _rhs; - default: return null; + 0 => _lhs, 1 => _assignmentSign, 2 => _rhs, _ => null } + + ; } } @@ -793,10 +646,7 @@ namespace Parser.Internal { internal readonly SyntaxToken _catchKeyword; internal readonly SyntaxList _catchBody; - - internal CatchClauseSyntaxNode( - SyntaxToken catchKeyword, - SyntaxList catchBody) : base(TokenKind.CatchClause) + internal CatchClauseSyntaxNode(SyntaxToken catchKeyword, SyntaxList catchBody): base(TokenKind.CatchClause) { Slots = 2; this.AdjustWidth(catchKeyword); @@ -805,10 +655,7 @@ namespace Parser.Internal _catchBody = catchBody; } - internal CatchClauseSyntaxNode( - SyntaxToken catchKeyword, - SyntaxList catchBody, - TokenDiagnostic[] diagnostics) : base(TokenKind.CatchClause, diagnostics) + internal CatchClauseSyntaxNode(SyntaxToken catchKeyword, SyntaxList catchBody, TokenDiagnostic[] diagnostics): base(TokenKind.CatchClause, diagnostics) { Slots = 2; this.AdjustWidth(catchKeyword); @@ -829,12 +676,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _catchKeyword; - case 1: return _catchBody; - default: return null; + 0 => _catchKeyword, 1 => _catchBody, _ => null } + + ; } } @@ -844,12 +691,7 @@ namespace Parser.Internal internal readonly SyntaxList _tryBody; internal readonly CatchClauseSyntaxNode? _catchClause; internal readonly SyntaxToken _endKeyword; - - internal TryCatchStatementSyntaxNode( - SyntaxToken tryKeyword, - SyntaxList tryBody, - CatchClauseSyntaxNode? catchClause, - SyntaxToken endKeyword) : base(TokenKind.TryCatchStatement) + internal TryCatchStatementSyntaxNode(SyntaxToken tryKeyword, SyntaxList tryBody, CatchClauseSyntaxNode? catchClause, SyntaxToken endKeyword): base(TokenKind.TryCatchStatement) { Slots = 4; this.AdjustWidth(tryKeyword); @@ -862,12 +704,7 @@ namespace Parser.Internal _endKeyword = endKeyword; } - internal TryCatchStatementSyntaxNode( - SyntaxToken tryKeyword, - SyntaxList tryBody, - CatchClauseSyntaxNode? catchClause, - SyntaxToken endKeyword, - TokenDiagnostic[] diagnostics) : base(TokenKind.TryCatchStatement, diagnostics) + internal TryCatchStatementSyntaxNode(SyntaxToken tryKeyword, SyntaxList tryBody, CatchClauseSyntaxNode? catchClause, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.TryCatchStatement, diagnostics) { Slots = 4; this.AdjustWidth(tryKeyword); @@ -892,32 +729,26 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _tryKeyword; - case 1: return _tryBody; - case 2: return _catchClause; - case 3: return _endKeyword; - default: return null; + 0 => _tryKeyword, 1 => _tryBody, 2 => _catchClause, 3 => _endKeyword, _ => null } + + ; } } internal class ExpressionStatementSyntaxNode : StatementSyntaxNode { internal readonly ExpressionSyntaxNode _expression; - - internal ExpressionStatementSyntaxNode( - ExpressionSyntaxNode expression) : base(TokenKind.ExpressionStatement) + internal ExpressionStatementSyntaxNode(ExpressionSyntaxNode expression): base(TokenKind.ExpressionStatement) { Slots = 1; this.AdjustWidth(expression); _expression = expression; } - internal ExpressionStatementSyntaxNode( - ExpressionSyntaxNode expression, - TokenDiagnostic[] diagnostics) : base(TokenKind.ExpressionStatement, diagnostics) + internal ExpressionStatementSyntaxNode(ExpressionSyntaxNode expression, TokenDiagnostic[] diagnostics): base(TokenKind.ExpressionStatement, diagnostics) { Slots = 1; this.AdjustWidth(expression); @@ -936,29 +767,26 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _expression; - default: return null; + 0 => _expression, _ => null } + + ; } } internal class EmptyStatementSyntaxNode : StatementSyntaxNode { internal readonly SyntaxToken _semicolon; - - internal EmptyStatementSyntaxNode( - SyntaxToken semicolon) : base(TokenKind.EmptyStatement) + internal EmptyStatementSyntaxNode(SyntaxToken semicolon): base(TokenKind.EmptyStatement) { Slots = 1; this.AdjustWidth(semicolon); _semicolon = semicolon; } - internal EmptyStatementSyntaxNode( - SyntaxToken semicolon, - TokenDiagnostic[] diagnostics) : base(TokenKind.EmptyStatement, diagnostics) + internal EmptyStatementSyntaxNode(SyntaxToken semicolon, TokenDiagnostic[] diagnostics): base(TokenKind.EmptyStatement, diagnostics) { Slots = 1; this.AdjustWidth(semicolon); @@ -977,24 +805,23 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _semicolon; - default: return null; + 0 => _semicolon, _ => null } + + ; } } internal class EmptyExpressionSyntaxNode : ExpressionSyntaxNode { - - internal EmptyExpressionSyntaxNode() : base(TokenKind.EmptyExpression) + internal EmptyExpressionSyntaxNode(): base(TokenKind.EmptyExpression) { Slots = 0; } - internal EmptyExpressionSyntaxNode( - TokenDiagnostic[] diagnostics) : base(TokenKind.EmptyExpression, diagnostics) + internal EmptyExpressionSyntaxNode(TokenDiagnostic[] diagnostics): base(TokenKind.EmptyExpression, diagnostics) { Slots = 0; } @@ -1011,10 +838,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - default: return null; + _ => null } + + ; } } @@ -1022,10 +851,7 @@ namespace Parser.Internal { internal readonly SyntaxToken _operation; internal readonly ExpressionSyntaxNode _operand; - - internal UnaryPrefixOperationExpressionSyntaxNode( - SyntaxToken operation, - ExpressionSyntaxNode operand) : base(TokenKind.UnaryPrefixOperationExpression) + internal UnaryPrefixOperationExpressionSyntaxNode(SyntaxToken operation, ExpressionSyntaxNode operand): base(TokenKind.UnaryPrefixOperationExpression) { Slots = 2; this.AdjustWidth(operation); @@ -1034,10 +860,7 @@ namespace Parser.Internal _operand = operand; } - internal UnaryPrefixOperationExpressionSyntaxNode( - SyntaxToken operation, - ExpressionSyntaxNode operand, - TokenDiagnostic[] diagnostics) : base(TokenKind.UnaryPrefixOperationExpression, diagnostics) + internal UnaryPrefixOperationExpressionSyntaxNode(SyntaxToken operation, ExpressionSyntaxNode operand, TokenDiagnostic[] diagnostics): base(TokenKind.UnaryPrefixOperationExpression, diagnostics) { Slots = 2; this.AdjustWidth(operation); @@ -1058,30 +881,26 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _operation; - case 1: return _operand; - default: return null; + 0 => _operation, 1 => _operand, _ => null } + + ; } } internal class CompoundNameSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxList _nodes; - - internal CompoundNameSyntaxNode( - SyntaxList nodes) : base(TokenKind.CompoundName) + internal CompoundNameSyntaxNode(SyntaxList nodes): base(TokenKind.CompoundName) { Slots = 1; this.AdjustWidth(nodes); _nodes = nodes; } - internal CompoundNameSyntaxNode( - SyntaxList nodes, - TokenDiagnostic[] diagnostics) : base(TokenKind.CompoundName, diagnostics) + internal CompoundNameSyntaxNode(SyntaxList nodes, TokenDiagnostic[] diagnostics): base(TokenKind.CompoundName, diagnostics) { Slots = 1; this.AdjustWidth(nodes); @@ -1100,11 +919,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _nodes; - default: return null; + 0 => _nodes, _ => null } + + ; } } @@ -1112,10 +932,7 @@ namespace Parser.Internal { internal readonly SyntaxToken _atSign; internal readonly CompoundNameSyntaxNode _functionName; - - internal NamedFunctionHandleSyntaxNode( - SyntaxToken atSign, - CompoundNameSyntaxNode functionName) : base(TokenKind.NamedFunctionHandle) + internal NamedFunctionHandleSyntaxNode(SyntaxToken atSign, CompoundNameSyntaxNode functionName): base(TokenKind.NamedFunctionHandle) { Slots = 2; this.AdjustWidth(atSign); @@ -1124,10 +941,7 @@ namespace Parser.Internal _functionName = functionName; } - internal NamedFunctionHandleSyntaxNode( - SyntaxToken atSign, - CompoundNameSyntaxNode functionName, - TokenDiagnostic[] diagnostics) : base(TokenKind.NamedFunctionHandle, diagnostics) + internal NamedFunctionHandleSyntaxNode(SyntaxToken atSign, CompoundNameSyntaxNode functionName, TokenDiagnostic[] diagnostics): base(TokenKind.NamedFunctionHandle, diagnostics) { Slots = 2; this.AdjustWidth(atSign); @@ -1148,12 +962,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _atSign; - case 1: return _functionName; - default: return null; + 0 => _atSign, 1 => _functionName, _ => null } + + ; } } @@ -1162,11 +976,7 @@ namespace Parser.Internal internal readonly SyntaxToken _atSign; internal readonly FunctionInputDescriptionSyntaxNode _input; internal readonly ExpressionSyntaxNode _body; - - internal LambdaSyntaxNode( - SyntaxToken atSign, - FunctionInputDescriptionSyntaxNode input, - ExpressionSyntaxNode body) : base(TokenKind.Lambda) + internal LambdaSyntaxNode(SyntaxToken atSign, FunctionInputDescriptionSyntaxNode input, ExpressionSyntaxNode body): base(TokenKind.Lambda) { Slots = 3; this.AdjustWidth(atSign); @@ -1177,11 +987,7 @@ namespace Parser.Internal _body = body; } - internal LambdaSyntaxNode( - SyntaxToken atSign, - FunctionInputDescriptionSyntaxNode input, - ExpressionSyntaxNode body, - TokenDiagnostic[] diagnostics) : base(TokenKind.Lambda, diagnostics) + internal LambdaSyntaxNode(SyntaxToken atSign, FunctionInputDescriptionSyntaxNode input, ExpressionSyntaxNode body, TokenDiagnostic[] diagnostics): base(TokenKind.Lambda, diagnostics) { Slots = 3; this.AdjustWidth(atSign); @@ -1204,13 +1010,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _atSign; - case 1: return _input; - case 2: return _body; - default: return null; + 0 => _atSign, 1 => _input, 2 => _body, _ => null } + + ; } } @@ -1219,11 +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.BinaryOperation) { Slots = 3; this.AdjustWidth(lhs); @@ -1234,11 +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.BinaryOperation, diagnostics) { Slots = 3; this.AdjustWidth(lhs); @@ -1261,31 +1058,26 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _lhs; - case 1: return _operation; - case 2: return _rhs; - default: return null; + 0 => _lhs, 1 => _operation, 2 => _rhs, _ => null } + + ; } } internal class IdentifierNameSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _name; - - internal IdentifierNameSyntaxNode( - SyntaxToken name) : base(TokenKind.IdentifierName) + internal IdentifierNameSyntaxNode(SyntaxToken name): base(TokenKind.IdentifierName) { Slots = 1; this.AdjustWidth(name); _name = name; } - internal IdentifierNameSyntaxNode( - SyntaxToken name, - TokenDiagnostic[] diagnostics) : base(TokenKind.IdentifierName, diagnostics) + internal IdentifierNameSyntaxNode(SyntaxToken name, TokenDiagnostic[] diagnostics): base(TokenKind.IdentifierName, diagnostics) { Slots = 1; this.AdjustWidth(name); @@ -1304,29 +1096,26 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _name; - default: return null; + 0 => _name, _ => null } + + ; } } internal class NumberLiteralSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _number; - - internal NumberLiteralSyntaxNode( - SyntaxToken number) : base(TokenKind.NumberLiteralExpression) + internal NumberLiteralSyntaxNode(SyntaxToken number): base(TokenKind.NumberLiteralExpression) { Slots = 1; this.AdjustWidth(number); _number = number; } - internal NumberLiteralSyntaxNode( - SyntaxToken number, - TokenDiagnostic[] diagnostics) : base(TokenKind.NumberLiteralExpression, diagnostics) + internal NumberLiteralSyntaxNode(SyntaxToken number, TokenDiagnostic[] diagnostics): base(TokenKind.NumberLiteralExpression, diagnostics) { Slots = 1; this.AdjustWidth(number); @@ -1345,29 +1134,26 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _number; - default: return null; + 0 => _number, _ => null } + + ; } } internal class StringLiteralSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _stringToken; - - internal StringLiteralSyntaxNode( - SyntaxToken stringToken) : base(TokenKind.StringLiteralExpression) + internal StringLiteralSyntaxNode(SyntaxToken stringToken): base(TokenKind.StringLiteralExpression) { Slots = 1; this.AdjustWidth(stringToken); _stringToken = stringToken; } - internal StringLiteralSyntaxNode( - SyntaxToken stringToken, - TokenDiagnostic[] diagnostics) : base(TokenKind.StringLiteralExpression, diagnostics) + internal StringLiteralSyntaxNode(SyntaxToken stringToken, TokenDiagnostic[] diagnostics): base(TokenKind.StringLiteralExpression, diagnostics) { Slots = 1; this.AdjustWidth(stringToken); @@ -1386,29 +1172,26 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _stringToken; - default: return null; + 0 => _stringToken, _ => null } + + ; } } internal class DoubleQuotedStringLiteralSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _stringToken; - - internal DoubleQuotedStringLiteralSyntaxNode( - SyntaxToken stringToken) : base(TokenKind.DoubleQuotedStringLiteralExpression) + internal DoubleQuotedStringLiteralSyntaxNode(SyntaxToken stringToken): base(TokenKind.DoubleQuotedStringLiteralExpression) { Slots = 1; this.AdjustWidth(stringToken); _stringToken = stringToken; } - internal DoubleQuotedStringLiteralSyntaxNode( - SyntaxToken stringToken, - TokenDiagnostic[] diagnostics) : base(TokenKind.DoubleQuotedStringLiteralExpression, diagnostics) + internal DoubleQuotedStringLiteralSyntaxNode(SyntaxToken stringToken, TokenDiagnostic[] diagnostics): base(TokenKind.DoubleQuotedStringLiteralExpression, diagnostics) { Slots = 1; this.AdjustWidth(stringToken); @@ -1427,29 +1210,26 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _stringToken; - default: return null; + 0 => _stringToken, _ => null } + + ; } } internal class UnquotedStringLiteralSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _stringToken; - - internal UnquotedStringLiteralSyntaxNode( - SyntaxToken stringToken) : base(TokenKind.UnquotedStringLiteralExpression) + internal UnquotedStringLiteralSyntaxNode(SyntaxToken stringToken): base(TokenKind.UnquotedStringLiteralExpression) { Slots = 1; this.AdjustWidth(stringToken); _stringToken = stringToken; } - internal UnquotedStringLiteralSyntaxNode( - SyntaxToken stringToken, - TokenDiagnostic[] diagnostics) : base(TokenKind.UnquotedStringLiteralExpression, diagnostics) + internal UnquotedStringLiteralSyntaxNode(SyntaxToken stringToken, TokenDiagnostic[] diagnostics): base(TokenKind.UnquotedStringLiteralExpression, diagnostics) { Slots = 1; this.AdjustWidth(stringToken); @@ -1468,11 +1248,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _stringToken; - default: return null; + 0 => _stringToken, _ => null } + + ; } } @@ -1481,11 +1262,7 @@ namespace Parser.Internal internal readonly SyntaxToken _openingSquareBracket; internal readonly SyntaxList _nodes; internal readonly SyntaxToken _closingSquareBracket; - - internal ArrayLiteralExpressionSyntaxNode( - SyntaxToken openingSquareBracket, - SyntaxList nodes, - SyntaxToken closingSquareBracket) : base(TokenKind.ArrayLiteralExpression) + internal ArrayLiteralExpressionSyntaxNode(SyntaxToken openingSquareBracket, SyntaxList nodes, SyntaxToken closingSquareBracket): base(TokenKind.ArrayLiteralExpression) { Slots = 3; this.AdjustWidth(openingSquareBracket); @@ -1496,11 +1273,7 @@ namespace Parser.Internal _closingSquareBracket = closingSquareBracket; } - internal ArrayLiteralExpressionSyntaxNode( - SyntaxToken openingSquareBracket, - SyntaxList nodes, - SyntaxToken closingSquareBracket, - TokenDiagnostic[] diagnostics) : base(TokenKind.ArrayLiteralExpression, diagnostics) + internal ArrayLiteralExpressionSyntaxNode(SyntaxToken openingSquareBracket, SyntaxList nodes, SyntaxToken closingSquareBracket, TokenDiagnostic[] diagnostics): base(TokenKind.ArrayLiteralExpression, diagnostics) { Slots = 3; this.AdjustWidth(openingSquareBracket); @@ -1523,13 +1296,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _openingSquareBracket; - case 1: return _nodes; - case 2: return _closingSquareBracket; - default: return null; + 0 => _openingSquareBracket, 1 => _nodes, 2 => _closingSquareBracket, _ => null } + + ; } } @@ -1538,11 +1310,7 @@ namespace Parser.Internal internal readonly SyntaxToken _openingBrace; internal readonly SyntaxList _nodes; internal readonly SyntaxToken _closingBrace; - - internal CellArrayLiteralExpressionSyntaxNode( - SyntaxToken openingBrace, - SyntaxList nodes, - SyntaxToken closingBrace) : base(TokenKind.CellArrayLiteralExpression) + internal CellArrayLiteralExpressionSyntaxNode(SyntaxToken openingBrace, SyntaxList nodes, SyntaxToken closingBrace): base(TokenKind.CellArrayLiteralExpression) { Slots = 3; this.AdjustWidth(openingBrace); @@ -1553,11 +1321,7 @@ namespace Parser.Internal _closingBrace = closingBrace; } - internal CellArrayLiteralExpressionSyntaxNode( - SyntaxToken openingBrace, - SyntaxList nodes, - SyntaxToken closingBrace, - TokenDiagnostic[] diagnostics) : base(TokenKind.CellArrayLiteralExpression, diagnostics) + internal CellArrayLiteralExpressionSyntaxNode(SyntaxToken openingBrace, SyntaxList nodes, SyntaxToken closingBrace, TokenDiagnostic[] diagnostics): base(TokenKind.CellArrayLiteralExpression, diagnostics) { Slots = 3; this.AdjustWidth(openingBrace); @@ -1580,13 +1344,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _openingBrace; - case 1: return _nodes; - case 2: return _closingBrace; - default: return null; + 0 => _openingBrace, 1 => _nodes, 2 => _closingBrace, _ => null } + + ; } } @@ -1595,11 +1358,7 @@ namespace Parser.Internal internal readonly SyntaxToken _openingBracket; internal readonly ExpressionSyntaxNode _expression; internal readonly SyntaxToken _closingBracket; - - internal ParenthesizedExpressionSyntaxNode( - SyntaxToken openingBracket, - ExpressionSyntaxNode expression, - SyntaxToken closingBracket) : base(TokenKind.ParenthesizedExpression) + internal ParenthesizedExpressionSyntaxNode(SyntaxToken openingBracket, ExpressionSyntaxNode expression, SyntaxToken closingBracket): base(TokenKind.ParenthesizedExpression) { Slots = 3; this.AdjustWidth(openingBracket); @@ -1610,11 +1369,7 @@ namespace Parser.Internal _closingBracket = closingBracket; } - internal ParenthesizedExpressionSyntaxNode( - SyntaxToken openingBracket, - ExpressionSyntaxNode expression, - SyntaxToken closingBracket, - TokenDiagnostic[] diagnostics) : base(TokenKind.ParenthesizedExpression, diagnostics) + internal ParenthesizedExpressionSyntaxNode(SyntaxToken openingBracket, ExpressionSyntaxNode expression, SyntaxToken closingBracket, TokenDiagnostic[] diagnostics): base(TokenKind.ParenthesizedExpression, diagnostics) { Slots = 3; this.AdjustWidth(openingBracket); @@ -1637,13 +1392,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _openingBracket; - case 1: return _expression; - case 2: return _closingBracket; - default: return null; + 0 => _openingBracket, 1 => _expression, 2 => _closingBracket, _ => null } + + ; } } @@ -1653,12 +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.CellArrayElementAccess) { Slots = 4; this.AdjustWidth(expression); @@ -1671,12 +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.CellArrayElementAccess, diagnostics) { Slots = 4; this.AdjustWidth(expression); @@ -1701,14 +1445,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _expression; - case 1: return _openingBrace; - case 2: return _nodes; - case 3: return _closingBrace; - default: return null; + 0 => _expression, 1 => _openingBrace, 2 => _nodes, 3 => _closingBrace, _ => null } + + ; } } @@ -1718,12 +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.FunctionCall) { Slots = 4; this.AdjustWidth(functionName); @@ -1736,12 +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.FunctionCall, diagnostics) { Slots = 4; this.AdjustWidth(functionName); @@ -1766,14 +1498,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _functionName; - case 1: return _openingBracket; - case 2: return _nodes; - case 3: return _closingBracket; - default: return null; + 0 => _functionName, 1 => _openingBracket, 2 => _nodes, 3 => _closingBracket, _ => null } + + ; } } @@ -1782,11 +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.MemberAccess) { Slots = 3; this.AdjustWidth(leftOperand); @@ -1797,11 +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.MemberAccess, diagnostics) { Slots = 3; this.AdjustWidth(leftOperand); @@ -1824,13 +1546,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _leftOperand; - case 1: return _dot; - case 2: return _rightOperand; - default: return null; + 0 => _leftOperand, 1 => _dot, 2 => _rightOperand, _ => null } + + ; } } @@ -1838,10 +1559,7 @@ namespace Parser.Internal { internal readonly ExpressionSyntaxNode _operand; internal readonly SyntaxToken _operation; - - internal UnaryPostixOperationExpressionSyntaxNode( - ExpressionSyntaxNode operand, - SyntaxToken operation) : base(TokenKind.UnaryPostfixOperationExpression) + internal UnaryPostixOperationExpressionSyntaxNode(ExpressionSyntaxNode operand, SyntaxToken operation): base(TokenKind.UnaryPostfixOperationExpression) { Slots = 2; this.AdjustWidth(operand); @@ -1850,10 +1568,7 @@ namespace Parser.Internal _operation = operation; } - internal UnaryPostixOperationExpressionSyntaxNode( - ExpressionSyntaxNode operand, - SyntaxToken operation, - TokenDiagnostic[] diagnostics) : base(TokenKind.UnaryPostfixOperationExpression, diagnostics) + internal UnaryPostixOperationExpressionSyntaxNode(ExpressionSyntaxNode operand, SyntaxToken operation, TokenDiagnostic[] diagnostics): base(TokenKind.UnaryPostfixOperationExpression, diagnostics) { Slots = 2; this.AdjustWidth(operand); @@ -1874,12 +1589,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _operand; - case 1: return _operation; - default: return null; + 0 => _operand, 1 => _operation, _ => null } + + ; } } @@ -1888,11 +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.IndirectMemberAccess) { Slots = 3; this.AdjustWidth(openingBracket); @@ -1903,11 +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.IndirectMemberAccess, diagnostics) { Slots = 3; this.AdjustWidth(openingBracket); @@ -1930,13 +1637,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _openingBracket; - case 1: return _expression; - case 2: return _closingBracket; - default: return null; + 0 => _openingBracket, 1 => _expression, 2 => _closingBracket, _ => null } + + ; } } @@ -1944,10 +1650,7 @@ namespace Parser.Internal { internal readonly IdentifierNameSyntaxNode _commandName; internal readonly SyntaxList _arguments; - - internal CommandExpressionSyntaxNode( - IdentifierNameSyntaxNode commandName, - SyntaxList arguments) : base(TokenKind.Command) + internal CommandExpressionSyntaxNode(IdentifierNameSyntaxNode commandName, SyntaxList arguments): base(TokenKind.Command) { Slots = 2; this.AdjustWidth(commandName); @@ -1956,10 +1659,7 @@ namespace Parser.Internal _arguments = arguments; } - internal CommandExpressionSyntaxNode( - IdentifierNameSyntaxNode commandName, - SyntaxList arguments, - TokenDiagnostic[] diagnostics) : base(TokenKind.Command, diagnostics) + internal CommandExpressionSyntaxNode(IdentifierNameSyntaxNode commandName, SyntaxList arguments, TokenDiagnostic[] diagnostics): base(TokenKind.Command, diagnostics) { Slots = 2; this.AdjustWidth(commandName); @@ -1980,12 +1680,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _commandName; - case 1: return _arguments; - default: return null; + 0 => _commandName, 1 => _arguments, _ => null } + + ; } } @@ -1994,11 +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.ClassInvokation) { Slots = 3; this.AdjustWidth(methodName); @@ -2009,11 +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.ClassInvokation, diagnostics) { Slots = 3; this.AdjustWidth(methodName); @@ -2036,13 +1728,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _methodName; - case 1: return _atSign; - case 2: return _baseClassNameAndArguments; - default: return null; + 0 => _methodName, 1 => _atSign, 2 => _baseClassNameAndArguments, _ => null } + + ; } } @@ -2050,10 +1741,7 @@ namespace Parser.Internal { internal readonly SyntaxToken _assignmentSign; internal readonly ExpressionSyntaxNode _value; - - internal AttributeAssignmentSyntaxNode( - SyntaxToken assignmentSign, - ExpressionSyntaxNode value) : base(TokenKind.AttributeAssignment) + internal AttributeAssignmentSyntaxNode(SyntaxToken assignmentSign, ExpressionSyntaxNode value): base(TokenKind.AttributeAssignment) { Slots = 2; this.AdjustWidth(assignmentSign); @@ -2062,10 +1750,7 @@ namespace Parser.Internal _value = value; } - internal AttributeAssignmentSyntaxNode( - SyntaxToken assignmentSign, - ExpressionSyntaxNode value, - TokenDiagnostic[] diagnostics) : base(TokenKind.AttributeAssignment, diagnostics) + internal AttributeAssignmentSyntaxNode(SyntaxToken assignmentSign, ExpressionSyntaxNode value, TokenDiagnostic[] diagnostics): base(TokenKind.AttributeAssignment, diagnostics) { Slots = 2; this.AdjustWidth(assignmentSign); @@ -2086,12 +1771,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _assignmentSign; - case 1: return _value; - default: return null; + 0 => _assignmentSign, 1 => _value, _ => null } + + ; } } @@ -2099,10 +1784,7 @@ namespace Parser.Internal { internal readonly IdentifierNameSyntaxNode _name; internal readonly AttributeAssignmentSyntaxNode? _assignment; - - internal AttributeSyntaxNode( - IdentifierNameSyntaxNode name, - AttributeAssignmentSyntaxNode? assignment) : base(TokenKind.Attribute) + internal AttributeSyntaxNode(IdentifierNameSyntaxNode name, AttributeAssignmentSyntaxNode? assignment): base(TokenKind.Attribute) { Slots = 2; this.AdjustWidth(name); @@ -2111,10 +1793,7 @@ namespace Parser.Internal _assignment = assignment; } - internal AttributeSyntaxNode( - IdentifierNameSyntaxNode name, - AttributeAssignmentSyntaxNode? assignment, - TokenDiagnostic[] diagnostics) : base(TokenKind.Attribute, diagnostics) + internal AttributeSyntaxNode(IdentifierNameSyntaxNode name, AttributeAssignmentSyntaxNode? assignment, TokenDiagnostic[] diagnostics): base(TokenKind.Attribute, diagnostics) { Slots = 2; this.AdjustWidth(name); @@ -2135,12 +1814,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _name; - case 1: return _assignment; - default: return null; + 0 => _name, 1 => _assignment, _ => null } + + ; } } @@ -2149,11 +1828,7 @@ namespace Parser.Internal internal readonly SyntaxToken _openingBracket; internal readonly SyntaxList _nodes; internal readonly SyntaxToken _closingBracket; - - internal AttributeListSyntaxNode( - SyntaxToken openingBracket, - SyntaxList nodes, - SyntaxToken closingBracket) : base(TokenKind.AttributeList) + internal AttributeListSyntaxNode(SyntaxToken openingBracket, SyntaxList nodes, SyntaxToken closingBracket): base(TokenKind.AttributeList) { Slots = 3; this.AdjustWidth(openingBracket); @@ -2164,11 +1839,7 @@ namespace Parser.Internal _closingBracket = closingBracket; } - internal AttributeListSyntaxNode( - SyntaxToken openingBracket, - SyntaxList nodes, - SyntaxToken closingBracket, - TokenDiagnostic[] diagnostics) : base(TokenKind.AttributeList, diagnostics) + internal AttributeListSyntaxNode(SyntaxToken openingBracket, SyntaxList nodes, SyntaxToken closingBracket, TokenDiagnostic[] diagnostics): base(TokenKind.AttributeList, diagnostics) { Slots = 3; this.AdjustWidth(openingBracket); @@ -2191,13 +1862,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _openingBracket; - case 1: return _nodes; - case 2: return _closingBracket; - default: return null; + 0 => _openingBracket, 1 => _nodes, 2 => _closingBracket, _ => null } + + ; } } @@ -2210,15 +1880,7 @@ namespace Parser.Internal internal readonly SyntaxList _commas; internal readonly SyntaxList _body; internal readonly EndKeywordSyntaxNode? _endKeyword; - - internal MethodDefinitionSyntaxNode( - SyntaxToken functionKeyword, - FunctionOutputDescriptionSyntaxNode? outputDescription, - CompoundNameSyntaxNode name, - FunctionInputDescriptionSyntaxNode? inputDescription, - SyntaxList commas, - SyntaxList body, - EndKeywordSyntaxNode? endKeyword) : base(TokenKind.MethodDefinition) + internal MethodDefinitionSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, SyntaxList body, EndKeywordSyntaxNode? endKeyword): base(TokenKind.MethodDefinition) { Slots = 7; this.AdjustWidth(functionKeyword); @@ -2237,15 +1899,7 @@ namespace Parser.Internal _endKeyword = endKeyword; } - internal MethodDefinitionSyntaxNode( - SyntaxToken functionKeyword, - FunctionOutputDescriptionSyntaxNode? outputDescription, - CompoundNameSyntaxNode name, - FunctionInputDescriptionSyntaxNode? inputDescription, - SyntaxList commas, - SyntaxList body, - EndKeywordSyntaxNode? endKeyword, - TokenDiagnostic[] diagnostics) : base(TokenKind.MethodDefinition, diagnostics) + internal MethodDefinitionSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, SyntaxList body, EndKeywordSyntaxNode? endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.MethodDefinition, diagnostics) { Slots = 7; this.AdjustWidth(functionKeyword); @@ -2276,17 +1930,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _functionKeyword; - case 1: return _outputDescription; - case 2: return _name; - case 3: return _inputDescription; - case 4: return _commas; - case 5: return _body; - case 6: return _endKeyword; - default: return null; + 0 => _functionKeyword, 1 => _outputDescription, 2 => _name, 3 => _inputDescription, 4 => _commas, 5 => _body, 6 => _endKeyword, _ => null } + + ; } } @@ -2295,11 +1944,7 @@ namespace Parser.Internal internal readonly FunctionOutputDescriptionSyntaxNode? _outputDescription; internal readonly CompoundNameSyntaxNode _name; internal readonly FunctionInputDescriptionSyntaxNode? _inputDescription; - - internal AbstractMethodDeclarationSyntaxNode( - FunctionOutputDescriptionSyntaxNode? outputDescription, - CompoundNameSyntaxNode name, - FunctionInputDescriptionSyntaxNode? inputDescription) : base(TokenKind.AbstractMethodDeclaration) + internal AbstractMethodDeclarationSyntaxNode(FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription): base(TokenKind.AbstractMethodDeclaration) { Slots = 3; this.AdjustWidth(outputDescription); @@ -2310,11 +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, CompoundNameSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, TokenDiagnostic[] diagnostics): base(TokenKind.AbstractMethodDeclaration, diagnostics) { Slots = 3; this.AdjustWidth(outputDescription); @@ -2337,13 +1978,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _outputDescription; - case 1: return _name; - case 2: return _inputDescription; - default: return null; + 0 => _outputDescription, 1 => _name, 2 => _inputDescription, _ => null } + + ; } } @@ -2353,12 +1993,7 @@ namespace Parser.Internal internal readonly AttributeListSyntaxNode? _attributes; internal readonly SyntaxList _methods; internal readonly SyntaxToken _endKeyword; - - internal MethodsListSyntaxNode( - SyntaxToken methodsKeyword, - AttributeListSyntaxNode? attributes, - SyntaxList methods, - SyntaxToken endKeyword) : base(TokenKind.MethodsList) + internal MethodsListSyntaxNode(SyntaxToken methodsKeyword, AttributeListSyntaxNode? attributes, SyntaxList methods, SyntaxToken endKeyword): base(TokenKind.MethodsList) { Slots = 4; this.AdjustWidth(methodsKeyword); @@ -2371,12 +2006,7 @@ namespace Parser.Internal _endKeyword = endKeyword; } - internal MethodsListSyntaxNode( - SyntaxToken methodsKeyword, - AttributeListSyntaxNode? attributes, - SyntaxList methods, - SyntaxToken endKeyword, - TokenDiagnostic[] diagnostics) : base(TokenKind.MethodsList, diagnostics) + internal MethodsListSyntaxNode(SyntaxToken methodsKeyword, AttributeListSyntaxNode? attributes, SyntaxList methods, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.MethodsList, diagnostics) { Slots = 4; this.AdjustWidth(methodsKeyword); @@ -2401,14 +2031,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _methodsKeyword; - case 1: return _attributes; - case 2: return _methods; - case 3: return _endKeyword; - default: return null; + 0 => _methodsKeyword, 1 => _attributes, 2 => _methods, 3 => _endKeyword, _ => null } + + ; } } @@ -2418,12 +2046,7 @@ namespace Parser.Internal internal readonly AttributeListSyntaxNode? _attributes; internal readonly SyntaxList _properties; internal readonly SyntaxToken _endKeyword; - - internal PropertiesListSyntaxNode( - SyntaxToken propertiesKeyword, - AttributeListSyntaxNode? attributes, - SyntaxList properties, - SyntaxToken endKeyword) : base(TokenKind.PropertiesList) + internal PropertiesListSyntaxNode(SyntaxToken propertiesKeyword, AttributeListSyntaxNode? attributes, SyntaxList properties, SyntaxToken endKeyword): base(TokenKind.PropertiesList) { Slots = 4; this.AdjustWidth(propertiesKeyword); @@ -2436,12 +2059,7 @@ namespace Parser.Internal _endKeyword = endKeyword; } - internal PropertiesListSyntaxNode( - SyntaxToken propertiesKeyword, - AttributeListSyntaxNode? attributes, - SyntaxList properties, - SyntaxToken endKeyword, - TokenDiagnostic[] diagnostics) : base(TokenKind.PropertiesList, diagnostics) + internal PropertiesListSyntaxNode(SyntaxToken propertiesKeyword, AttributeListSyntaxNode? attributes, SyntaxList properties, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.PropertiesList, diagnostics) { Slots = 4; this.AdjustWidth(propertiesKeyword); @@ -2466,14 +2084,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _propertiesKeyword; - case 1: return _attributes; - case 2: return _properties; - case 3: return _endKeyword; - default: return null; + 0 => _propertiesKeyword, 1 => _attributes, 2 => _properties, 3 => _endKeyword, _ => null } + + ; } } @@ -2481,10 +2097,7 @@ namespace Parser.Internal { internal readonly SyntaxToken _lessSign; internal readonly SyntaxList _baseClasses; - - internal BaseClassListSyntaxNode( - SyntaxToken lessSign, - SyntaxList baseClasses) : base(TokenKind.BaseClassList) + internal BaseClassListSyntaxNode(SyntaxToken lessSign, SyntaxList baseClasses): base(TokenKind.BaseClassList) { Slots = 2; this.AdjustWidth(lessSign); @@ -2493,10 +2106,7 @@ namespace Parser.Internal _baseClasses = baseClasses; } - internal BaseClassListSyntaxNode( - SyntaxToken lessSign, - SyntaxList baseClasses, - TokenDiagnostic[] diagnostics) : base(TokenKind.BaseClassList, diagnostics) + internal BaseClassListSyntaxNode(SyntaxToken lessSign, SyntaxList baseClasses, TokenDiagnostic[] diagnostics): base(TokenKind.BaseClassList, diagnostics) { Slots = 2; this.AdjustWidth(lessSign); @@ -2517,12 +2127,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _lessSign; - case 1: return _baseClasses; - default: return null; + 0 => _lessSign, 1 => _baseClasses, _ => null } + + ; } } @@ -2534,14 +2144,7 @@ namespace Parser.Internal 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, IdentifierNameSyntaxNode className, BaseClassListSyntaxNode? baseClassList, SyntaxList nodes, SyntaxToken endKeyword): base(TokenKind.ClassDeclaration) { Slots = 6; this.AdjustWidth(classdefKeyword); @@ -2558,14 +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, IdentifierNameSyntaxNode className, BaseClassListSyntaxNode? baseClassList, SyntaxList nodes, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.ClassDeclaration, diagnostics) { Slots = 6; this.AdjustWidth(classdefKeyword); @@ -2594,16 +2190,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _classdefKeyword; - case 1: return _attributes; - case 2: return _className; - case 3: return _baseClassList; - case 4: return _nodes; - case 5: return _endKeyword; - default: return null; + 0 => _classdefKeyword, 1 => _attributes, 2 => _className, 3 => _baseClassList, 4 => _nodes, 5 => _endKeyword, _ => null } + + ; } } @@ -2612,11 +2204,7 @@ namespace Parser.Internal internal readonly SyntaxToken _openingBracket; internal readonly SyntaxList _values; internal readonly SyntaxToken _closingBracket; - - internal EnumerationItemValueSyntaxNode( - SyntaxToken openingBracket, - SyntaxList values, - SyntaxToken closingBracket) : base(TokenKind.EnumerationItemValue) + internal EnumerationItemValueSyntaxNode(SyntaxToken openingBracket, SyntaxList values, SyntaxToken closingBracket): base(TokenKind.EnumerationItemValue) { Slots = 3; this.AdjustWidth(openingBracket); @@ -2627,11 +2215,7 @@ namespace Parser.Internal _closingBracket = closingBracket; } - internal EnumerationItemValueSyntaxNode( - SyntaxToken openingBracket, - SyntaxList values, - SyntaxToken closingBracket, - TokenDiagnostic[] diagnostics) : base(TokenKind.EnumerationItemValue, diagnostics) + internal EnumerationItemValueSyntaxNode(SyntaxToken openingBracket, SyntaxList values, SyntaxToken closingBracket, TokenDiagnostic[] diagnostics): base(TokenKind.EnumerationItemValue, diagnostics) { Slots = 3; this.AdjustWidth(openingBracket); @@ -2654,13 +2238,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _openingBracket; - case 1: return _values; - case 2: return _closingBracket; - default: return null; + 0 => _openingBracket, 1 => _values, 2 => _closingBracket, _ => null } + + ; } } @@ -2669,11 +2252,7 @@ namespace Parser.Internal internal readonly IdentifierNameSyntaxNode _name; internal readonly EnumerationItemValueSyntaxNode? _values; internal readonly SyntaxList _commas; - - internal EnumerationItemSyntaxNode( - IdentifierNameSyntaxNode name, - EnumerationItemValueSyntaxNode? values, - SyntaxList commas) : base(TokenKind.EnumerationItem) + internal EnumerationItemSyntaxNode(IdentifierNameSyntaxNode name, EnumerationItemValueSyntaxNode? values, SyntaxList commas): base(TokenKind.EnumerationItem) { Slots = 3; this.AdjustWidth(name); @@ -2684,11 +2263,7 @@ namespace Parser.Internal _commas = commas; } - internal EnumerationItemSyntaxNode( - IdentifierNameSyntaxNode name, - EnumerationItemValueSyntaxNode? values, - SyntaxList commas, - TokenDiagnostic[] diagnostics) : base(TokenKind.EnumerationItem, diagnostics) + internal EnumerationItemSyntaxNode(IdentifierNameSyntaxNode name, EnumerationItemValueSyntaxNode? values, SyntaxList commas, TokenDiagnostic[] diagnostics): base(TokenKind.EnumerationItem, diagnostics) { Slots = 3; this.AdjustWidth(name); @@ -2711,13 +2286,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _name; - case 1: return _values; - case 2: return _commas; - default: return null; + 0 => _name, 1 => _values, 2 => _commas, _ => null } + + ; } } @@ -2727,12 +2301,7 @@ namespace Parser.Internal internal readonly AttributeListSyntaxNode? _attributes; internal readonly SyntaxList _items; internal readonly SyntaxToken _endKeyword; - - internal EnumerationListSyntaxNode( - SyntaxToken enumerationKeyword, - AttributeListSyntaxNode? attributes, - SyntaxList items, - SyntaxToken endKeyword) : base(TokenKind.EnumerationList) + internal EnumerationListSyntaxNode(SyntaxToken enumerationKeyword, AttributeListSyntaxNode? attributes, SyntaxList items, SyntaxToken endKeyword): base(TokenKind.EnumerationList) { Slots = 4; this.AdjustWidth(enumerationKeyword); @@ -2745,12 +2314,7 @@ namespace Parser.Internal _endKeyword = endKeyword; } - internal EnumerationListSyntaxNode( - SyntaxToken enumerationKeyword, - AttributeListSyntaxNode? attributes, - SyntaxList items, - SyntaxToken endKeyword, - TokenDiagnostic[] diagnostics) : base(TokenKind.EnumerationList, diagnostics) + internal EnumerationListSyntaxNode(SyntaxToken enumerationKeyword, AttributeListSyntaxNode? attributes, SyntaxList items, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.EnumerationList, diagnostics) { Slots = 4; this.AdjustWidth(enumerationKeyword); @@ -2775,14 +2339,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _enumerationKeyword; - case 1: return _attributes; - case 2: return _items; - case 3: return _endKeyword; - default: return null; + 0 => _enumerationKeyword, 1 => _attributes, 2 => _items, 3 => _endKeyword, _ => null } + + ; } } @@ -2792,12 +2354,7 @@ namespace Parser.Internal internal readonly AttributeListSyntaxNode? _attributes; internal readonly SyntaxList _events; internal readonly SyntaxToken _endKeyword; - - internal EventsListSyntaxNode( - SyntaxToken eventsKeyword, - AttributeListSyntaxNode? attributes, - SyntaxList events, - SyntaxToken endKeyword) : base(TokenKind.EventsList) + internal EventsListSyntaxNode(SyntaxToken eventsKeyword, AttributeListSyntaxNode? attributes, SyntaxList events, SyntaxToken endKeyword): base(TokenKind.EventsList) { Slots = 4; this.AdjustWidth(eventsKeyword); @@ -2810,12 +2367,7 @@ namespace Parser.Internal _endKeyword = endKeyword; } - internal EventsListSyntaxNode( - SyntaxToken eventsKeyword, - AttributeListSyntaxNode? attributes, - SyntaxList events, - SyntaxToken endKeyword, - TokenDiagnostic[] diagnostics) : base(TokenKind.EventsList, diagnostics) + internal EventsListSyntaxNode(SyntaxToken eventsKeyword, AttributeListSyntaxNode? attributes, SyntaxList events, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.EventsList, diagnostics) { Slots = 4; this.AdjustWidth(eventsKeyword); @@ -2840,32 +2392,26 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _eventsKeyword; - case 1: return _attributes; - case 2: return _events; - case 3: return _endKeyword; - default: return null; + 0 => _eventsKeyword, 1 => _attributes, 2 => _events, 3 => _endKeyword, _ => null } + + ; } } internal class EndKeywordSyntaxNode : SyntaxNode { internal readonly SyntaxToken _endKeyword; - - internal EndKeywordSyntaxNode( - SyntaxToken endKeyword) : base(TokenKind.EndKeyword) + internal EndKeywordSyntaxNode(SyntaxToken endKeyword): base(TokenKind.EndKeyword) { Slots = 1; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } - internal EndKeywordSyntaxNode( - SyntaxToken endKeyword, - TokenDiagnostic[] diagnostics) : base(TokenKind.EndKeyword, diagnostics) + internal EndKeywordSyntaxNode(SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.EndKeyword, diagnostics) { Slots = 1; this.AdjustWidth(endKeyword); @@ -2884,11 +2430,12 @@ namespace Parser.Internal public override GreenNode? GetSlot(int i) { - switch (i) + return i switch { - case 0: return _endKeyword; - default: return null; + 0 => _endKeyword, _ => null } + + ; } } -} +} \ No newline at end of file diff --git a/Parser/SyntaxNode.Generated.cs b/Parser/SyntaxNode.Generated.cs index d3f5bec..105fac7 100644 --- a/Parser/SyntaxNode.Generated.cs +++ b/Parser/SyntaxNode.Generated.cs @@ -4,14 +4,16 @@ namespace Parser public class FileSyntaxNode : SyntaxNode { private SyntaxNode? _statementList; - - internal FileSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal FileSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken EndOfFile { - get { return new SyntaxToken(this, ((Parser.Internal.FileSyntaxNode)_green)._endOfFile, this.GetChildPosition(1)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.FileSyntaxNode)_green)._endOfFile, this.GetChildPosition(1)); + } } public SyntaxNodeOrTokenList StatementList @@ -19,27 +21,24 @@ namespace Parser get { var red = this.GetRed(ref this._statementList!, 0); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("statementList cannot be null"); + return red is null ? throw new System.Exception("statementList cannot be null.") : (SyntaxNodeOrTokenList)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 0: return GetRed(ref _statementList!, 0); - default: return null; + 0 => GetRed(ref _statementList!, 0), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitFile(this); } - } public class FunctionDeclarationSyntaxNode : StatementSyntaxNode @@ -49,19 +48,24 @@ namespace Parser private SyntaxNode? _commas; private SyntaxNode? _body; private SyntaxNode? _endKeyword; - - internal FunctionDeclarationSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal FunctionDeclarationSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken FunctionKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.FunctionDeclarationSyntaxNode)_green)._functionKeyword, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.FunctionDeclarationSyntaxNode)_green)._functionKeyword, this.GetChildPosition(0)); + } } public SyntaxToken Name { - get { return new SyntaxToken(this, ((Parser.Internal.FunctionDeclarationSyntaxNode)_green)._name, this.GetChildPosition(2)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.FunctionDeclarationSyntaxNode)_green)._name, this.GetChildPosition(2)); + } } public FunctionOutputDescriptionSyntaxNode? OutputDescription @@ -69,10 +73,7 @@ namespace Parser get { var red = this.GetRed(ref this._outputDescription, 1); - if (red != null) - return (FunctionOutputDescriptionSyntaxNode)red; - - return default(FunctionOutputDescriptionSyntaxNode); + return red is null ? default : (FunctionOutputDescriptionSyntaxNode)red; } } @@ -81,10 +82,7 @@ namespace Parser get { var red = this.GetRed(ref this._inputDescription, 3); - if (red != null) - return (FunctionInputDescriptionSyntaxNode)red; - - return default(FunctionInputDescriptionSyntaxNode); + return red is null ? default : (FunctionInputDescriptionSyntaxNode)red; } } @@ -93,10 +91,7 @@ namespace Parser get { var red = this.GetRed(ref this._commas!, 4); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("commas cannot be null"); + return red is null ? throw new System.Exception("commas cannot be null.") : (SyntaxNodeOrTokenList)red; } } @@ -105,10 +100,7 @@ namespace Parser get { var red = this.GetRed(ref this._body!, 5); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("body cannot be null"); + return red is null ? throw new System.Exception("body cannot be null.") : (SyntaxNodeOrTokenList)red; } } @@ -117,44 +109,39 @@ namespace Parser get { var red = this.GetRed(ref this._endKeyword, 6); - if (red != null) - return (EndKeywordSyntaxNode)red; - - return default(EndKeywordSyntaxNode); + return red is null ? default : (EndKeywordSyntaxNode)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _outputDescription, 1); - case 3: return GetRed(ref _inputDescription, 3); - case 4: return GetRed(ref _commas!, 4); - case 5: return GetRed(ref _body!, 5); - case 6: return GetRed(ref _endKeyword, 6); - default: return null; + 1 => GetRed(ref _outputDescription, 1), 3 => GetRed(ref _inputDescription, 3), 4 => GetRed(ref _commas!, 4), 5 => GetRed(ref _body!, 5), 6 => GetRed(ref _endKeyword, 6), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitFunctionDeclaration(this); } - } public class FunctionOutputDescriptionSyntaxNode : SyntaxNode { private SyntaxNode? _outputList; - - internal FunctionOutputDescriptionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal FunctionOutputDescriptionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken AssignmentSign { - get { return new SyntaxToken(this, ((Parser.Internal.FunctionOutputDescriptionSyntaxNode)_green)._assignmentSign, this.GetChildPosition(1)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.FunctionOutputDescriptionSyntaxNode)_green)._assignmentSign, this.GetChildPosition(1)); + } } public SyntaxNodeOrTokenList OutputList @@ -162,45 +149,47 @@ namespace Parser get { var red = this.GetRed(ref this._outputList!, 0); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("outputList cannot be null"); + return red is null ? throw new System.Exception("outputList cannot be null.") : (SyntaxNodeOrTokenList)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 0: return GetRed(ref _outputList!, 0); - default: return null; + 0 => GetRed(ref _outputList!, 0), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitFunctionOutputDescription(this); } - } public class FunctionInputDescriptionSyntaxNode : SyntaxNode { private SyntaxNode? _parameterList; - - internal FunctionInputDescriptionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal FunctionInputDescriptionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken OpeningBracket { - get { return new SyntaxToken(this, ((Parser.Internal.FunctionInputDescriptionSyntaxNode)_green)._openingBracket, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.FunctionInputDescriptionSyntaxNode)_green)._openingBracket, this.GetChildPosition(0)); + } } public SyntaxToken ClosingBracket { - get { return new SyntaxToken(this, ((Parser.Internal.FunctionInputDescriptionSyntaxNode)_green)._closingBracket, this.GetChildPosition(2)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.FunctionInputDescriptionSyntaxNode)_green)._closingBracket, this.GetChildPosition(2)); + } } public SyntaxNodeOrTokenList ParameterList @@ -208,27 +197,24 @@ namespace Parser get { var red = this.GetRed(ref this._parameterList!, 1); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("parameterList cannot be null"); + return red is null ? throw new System.Exception("parameterList cannot be null.") : (SyntaxNodeOrTokenList)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _parameterList!, 1); - default: return null; + 1 => GetRed(ref _parameterList!, 1), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitFunctionInputDescription(this); } - } public class SwitchStatementSyntaxNode : StatementSyntaxNode @@ -236,19 +222,24 @@ namespace Parser private SyntaxNode? _switchExpression; private SyntaxNode? _optionalCommas; private SyntaxNode? _cases; - - internal SwitchStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal SwitchStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken SwitchKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.SwitchStatementSyntaxNode)_green)._switchKeyword, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.SwitchStatementSyntaxNode)_green)._switchKeyword, this.GetChildPosition(0)); + } } public SyntaxToken EndKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.SwitchStatementSyntaxNode)_green)._endKeyword, this.GetChildPosition(4)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.SwitchStatementSyntaxNode)_green)._endKeyword, this.GetChildPosition(4)); + } } public ExpressionSyntaxNode SwitchExpression @@ -256,10 +247,7 @@ namespace Parser get { var red = this.GetRed(ref this._switchExpression!, 1); - if (red != null) - return (ExpressionSyntaxNode)red; - - throw new System.Exception("switchExpression cannot be null"); + return red is null ? throw new System.Exception("switchExpression cannot be null.") : (ExpressionSyntaxNode)red; } } @@ -268,10 +256,7 @@ namespace Parser get { var red = this.GetRed(ref this._optionalCommas!, 2); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("optionalCommas cannot be null"); + return red is null ? throw new System.Exception("optionalCommas cannot be null.") : (SyntaxNodeOrTokenList)red; } } @@ -280,29 +265,24 @@ namespace Parser get { var red = this.GetRed(ref this._cases!, 3); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("cases cannot be null"); + return red is null ? throw new System.Exception("cases cannot be null.") : (SyntaxNodeOrTokenList)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _switchExpression!, 1); - case 2: return GetRed(ref _optionalCommas!, 2); - case 3: return GetRed(ref _cases!, 3); - default: return null; + 1 => GetRed(ref _switchExpression!, 1), 2 => GetRed(ref _optionalCommas!, 2), 3 => GetRed(ref _cases!, 3), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitSwitchStatement(this); } - } public class SwitchCaseSyntaxNode : SyntaxNode @@ -310,14 +290,16 @@ namespace Parser private SyntaxNode? _caseIdentifier; private SyntaxNode? _optionalCommas; private SyntaxNode? _body; - - internal SwitchCaseSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal SwitchCaseSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken CaseKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.SwitchCaseSyntaxNode)_green)._caseKeyword, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.SwitchCaseSyntaxNode)_green)._caseKeyword, this.GetChildPosition(0)); + } } public ExpressionSyntaxNode CaseIdentifier @@ -325,10 +307,7 @@ namespace Parser get { var red = this.GetRed(ref this._caseIdentifier!, 1); - if (red != null) - return (ExpressionSyntaxNode)red; - - throw new System.Exception("caseIdentifier cannot be null"); + return red is null ? throw new System.Exception("caseIdentifier cannot be null.") : (ExpressionSyntaxNode)red; } } @@ -337,10 +316,7 @@ namespace Parser get { var red = this.GetRed(ref this._optionalCommas!, 2); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("optionalCommas cannot be null"); + return red is null ? throw new System.Exception("optionalCommas cannot be null.") : (SyntaxNodeOrTokenList)red; } } @@ -349,29 +325,24 @@ namespace Parser get { var red = this.GetRed(ref this._body!, 3); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("body cannot be null"); + return red is null ? throw new System.Exception("body cannot be null.") : (SyntaxNodeOrTokenList)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _caseIdentifier!, 1); - case 2: return GetRed(ref _optionalCommas!, 2); - case 3: return GetRed(ref _body!, 3); - default: return null; + 1 => GetRed(ref _caseIdentifier!, 1), 2 => GetRed(ref _optionalCommas!, 2), 3 => GetRed(ref _body!, 3), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitSwitchCase(this); } - } public class WhileStatementSyntaxNode : StatementSyntaxNode @@ -379,19 +350,24 @@ namespace Parser private SyntaxNode? _condition; private SyntaxNode? _optionalCommas; private SyntaxNode? _body; - - internal WhileStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal WhileStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken WhileKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.WhileStatementSyntaxNode)_green)._whileKeyword, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.WhileStatementSyntaxNode)_green)._whileKeyword, this.GetChildPosition(0)); + } } public SyntaxToken EndKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.WhileStatementSyntaxNode)_green)._endKeyword, this.GetChildPosition(4)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.WhileStatementSyntaxNode)_green)._endKeyword, this.GetChildPosition(4)); + } } public ExpressionSyntaxNode Condition @@ -399,10 +375,7 @@ namespace Parser get { var red = this.GetRed(ref this._condition!, 1); - if (red != null) - return (ExpressionSyntaxNode)red; - - throw new System.Exception("condition cannot be null"); + return red is null ? throw new System.Exception("condition cannot be null.") : (ExpressionSyntaxNode)red; } } @@ -411,10 +384,7 @@ namespace Parser get { var red = this.GetRed(ref this._optionalCommas!, 2); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("optionalCommas cannot be null"); + return red is null ? throw new System.Exception("optionalCommas cannot be null.") : (SyntaxNodeOrTokenList)red; } } @@ -423,29 +393,24 @@ namespace Parser get { var red = this.GetRed(ref this._body!, 3); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("body cannot be null"); + return red is null ? throw new System.Exception("body cannot be null.") : (SyntaxNodeOrTokenList)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _condition!, 1); - case 2: return GetRed(ref _optionalCommas!, 2); - case 3: return GetRed(ref _body!, 3); - default: return null; + 1 => GetRed(ref _condition!, 1), 2 => GetRed(ref _optionalCommas!, 2), 3 => GetRed(ref _body!, 3), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitWhileStatement(this); } - } public class ElseifClause : SyntaxNode @@ -453,14 +418,16 @@ namespace Parser private SyntaxNode? _condition; private SyntaxNode? _optionalCommas; private SyntaxNode? _body; - - internal ElseifClause(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal ElseifClause(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken ElseifKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.ElseifClause)_green)._elseifKeyword, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.ElseifClause)_green)._elseifKeyword, this.GetChildPosition(0)); + } } public ExpressionSyntaxNode Condition @@ -468,10 +435,7 @@ namespace Parser get { var red = this.GetRed(ref this._condition!, 1); - if (red != null) - return (ExpressionSyntaxNode)red; - - throw new System.Exception("condition cannot be null"); + return red is null ? throw new System.Exception("condition cannot be null.") : (ExpressionSyntaxNode)red; } } @@ -480,10 +444,7 @@ namespace Parser get { var red = this.GetRed(ref this._optionalCommas!, 2); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("optionalCommas cannot be null"); + return red is null ? throw new System.Exception("optionalCommas cannot be null.") : (SyntaxNodeOrTokenList)red; } } @@ -492,42 +453,39 @@ namespace Parser get { var red = this.GetRed(ref this._body!, 3); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("body cannot be null"); + return red is null ? throw new System.Exception("body cannot be null.") : (SyntaxNodeOrTokenList)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _condition!, 1); - case 2: return GetRed(ref _optionalCommas!, 2); - case 3: return GetRed(ref _body!, 3); - default: return null; + 1 => GetRed(ref _condition!, 1), 2 => GetRed(ref _optionalCommas!, 2), 3 => GetRed(ref _body!, 3), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitElseifClause(this); } - } public class ElseClause : SyntaxNode { private SyntaxNode? _body; - - internal ElseClause(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal ElseClause(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken ElseKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.ElseClause)_green)._elseKeyword, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.ElseClause)_green)._elseKeyword, this.GetChildPosition(0)); + } } public SyntaxNodeOrTokenList Body @@ -535,27 +493,24 @@ namespace Parser get { var red = this.GetRed(ref this._body!, 1); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("body cannot be null"); + return red is null ? throw new System.Exception("body cannot be null.") : (SyntaxNodeOrTokenList)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _body!, 1); - default: return null; + 1 => GetRed(ref _body!, 1), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitElseClause(this); } - } public class IfStatementSyntaxNode : StatementSyntaxNode @@ -565,19 +520,24 @@ namespace Parser private SyntaxNode? _body; private SyntaxNode? _elseifClauses; private SyntaxNode? _elseClause; - - internal IfStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal IfStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken IfKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.IfStatementSyntaxNode)_green)._ifKeyword, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.IfStatementSyntaxNode)_green)._ifKeyword, this.GetChildPosition(0)); + } } public SyntaxToken EndKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.IfStatementSyntaxNode)_green)._endKeyword, this.GetChildPosition(6)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.IfStatementSyntaxNode)_green)._endKeyword, this.GetChildPosition(6)); + } } public ExpressionSyntaxNode Condition @@ -585,10 +545,7 @@ namespace Parser get { var red = this.GetRed(ref this._condition!, 1); - if (red != null) - return (ExpressionSyntaxNode)red; - - throw new System.Exception("condition cannot be null"); + return red is null ? throw new System.Exception("condition cannot be null.") : (ExpressionSyntaxNode)red; } } @@ -597,10 +554,7 @@ namespace Parser get { var red = this.GetRed(ref this._optionalCommas!, 2); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("optionalCommas cannot be null"); + return red is null ? throw new System.Exception("optionalCommas cannot be null.") : (SyntaxNodeOrTokenList)red; } } @@ -609,10 +563,7 @@ namespace Parser get { var red = this.GetRed(ref this._body!, 3); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("body cannot be null"); + return red is null ? throw new System.Exception("body cannot be null.") : (SyntaxNodeOrTokenList)red; } } @@ -621,10 +572,7 @@ namespace Parser get { var red = this.GetRed(ref this._elseifClauses!, 4); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("elseifClauses cannot be null"); + return red is null ? throw new System.Exception("elseifClauses cannot be null.") : (SyntaxNodeOrTokenList)red; } } @@ -633,31 +581,24 @@ namespace Parser get { var red = this.GetRed(ref this._elseClause, 5); - if (red != null) - return (ElseClause)red; - - return default(ElseClause); + return red is null ? default : (ElseClause)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _condition!, 1); - case 2: return GetRed(ref _optionalCommas!, 2); - case 3: return GetRed(ref _body!, 3); - case 4: return GetRed(ref _elseifClauses!, 4); - case 5: return GetRed(ref _elseClause, 5); - default: return null; + 1 => GetRed(ref _condition!, 1), 2 => GetRed(ref _optionalCommas!, 2), 3 => GetRed(ref _body!, 3), 4 => GetRed(ref _elseifClauses!, 4), 5 => GetRed(ref _elseClause, 5), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitIfStatement(this); } - } public class ForStatementSyntaxNode : StatementSyntaxNode @@ -665,19 +606,24 @@ namespace Parser private SyntaxNode? _assignment; private SyntaxNode? _optionalCommas; private SyntaxNode? _body; - - internal ForStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal ForStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken ForKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.ForStatementSyntaxNode)_green)._forKeyword, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.ForStatementSyntaxNode)_green)._forKeyword, this.GetChildPosition(0)); + } } public SyntaxToken EndKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.ForStatementSyntaxNode)_green)._endKeyword, this.GetChildPosition(4)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.ForStatementSyntaxNode)_green)._endKeyword, this.GetChildPosition(4)); + } } public AssignmentExpressionSyntaxNode Assignment @@ -685,10 +631,7 @@ namespace Parser get { var red = this.GetRed(ref this._assignment!, 1); - if (red != null) - return (AssignmentExpressionSyntaxNode)red; - - throw new System.Exception("assignment cannot be null"); + return red is null ? throw new System.Exception("assignment cannot be null.") : (AssignmentExpressionSyntaxNode)red; } } @@ -697,10 +640,7 @@ namespace Parser get { var red = this.GetRed(ref this._optionalCommas!, 2); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("optionalCommas cannot be null"); + return red is null ? throw new System.Exception("optionalCommas cannot be null.") : (SyntaxNodeOrTokenList)red; } } @@ -709,43 +649,40 @@ namespace Parser get { var red = this.GetRed(ref this._body!, 3); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("body cannot be null"); + return red is null ? throw new System.Exception("body cannot be null.") : (SyntaxNodeOrTokenList)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _assignment!, 1); - case 2: return GetRed(ref _optionalCommas!, 2); - case 3: return GetRed(ref _body!, 3); - default: return null; + 1 => GetRed(ref _assignment!, 1), 2 => GetRed(ref _optionalCommas!, 2), 3 => GetRed(ref _body!, 3), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitForStatement(this); } - } public class AssignmentExpressionSyntaxNode : ExpressionSyntaxNode { private SyntaxNode? _lhs; private SyntaxNode? _rhs; - - internal AssignmentExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal AssignmentExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken AssignmentSign { - get { return new SyntaxToken(this, ((Parser.Internal.AssignmentExpressionSyntaxNode)_green)._assignmentSign, this.GetChildPosition(1)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.AssignmentExpressionSyntaxNode)_green)._assignmentSign, this.GetChildPosition(1)); + } } public ExpressionSyntaxNode Lhs @@ -753,10 +690,7 @@ namespace Parser get { var red = this.GetRed(ref this._lhs!, 0); - if (red != null) - return (ExpressionSyntaxNode)red; - - throw new System.Exception("lhs cannot be null"); + return red is null ? throw new System.Exception("lhs cannot be null.") : (ExpressionSyntaxNode)red; } } @@ -765,41 +699,39 @@ namespace Parser get { var red = this.GetRed(ref this._rhs!, 2); - if (red != null) - return (ExpressionSyntaxNode)red; - - throw new System.Exception("rhs cannot be null"); + return red is null ? throw new System.Exception("rhs cannot be null.") : (ExpressionSyntaxNode)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 0: return GetRed(ref _lhs!, 0); - case 2: return GetRed(ref _rhs!, 2); - default: return null; + 0 => GetRed(ref _lhs!, 0), 2 => GetRed(ref _rhs!, 2), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitAssignmentExpression(this); } - } public class CatchClauseSyntaxNode : SyntaxNode { private SyntaxNode? _catchBody; - - internal CatchClauseSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal CatchClauseSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken CatchKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.CatchClauseSyntaxNode)_green)._catchKeyword, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.CatchClauseSyntaxNode)_green)._catchKeyword, this.GetChildPosition(0)); + } } public SyntaxNodeOrTokenList CatchBody @@ -807,46 +739,48 @@ namespace Parser get { var red = this.GetRed(ref this._catchBody!, 1); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("catchBody cannot be null"); + return red is null ? throw new System.Exception("catchBody cannot be null.") : (SyntaxNodeOrTokenList)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _catchBody!, 1); - default: return null; + 1 => GetRed(ref _catchBody!, 1), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitCatchClause(this); } - } public class TryCatchStatementSyntaxNode : StatementSyntaxNode { private SyntaxNode? _tryBody; private SyntaxNode? _catchClause; - - internal TryCatchStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal TryCatchStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken TryKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.TryCatchStatementSyntaxNode)_green)._tryKeyword, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.TryCatchStatementSyntaxNode)_green)._tryKeyword, this.GetChildPosition(0)); + } } public SyntaxToken EndKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.TryCatchStatementSyntaxNode)_green)._endKeyword, this.GetChildPosition(3)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.TryCatchStatementSyntaxNode)_green)._endKeyword, this.GetChildPosition(3)); + } } public SyntaxNodeOrTokenList TryBody @@ -854,10 +788,7 @@ namespace Parser get { var red = this.GetRed(ref this._tryBody!, 1); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("tryBody cannot be null"); + return red is null ? throw new System.Exception("tryBody cannot be null.") : (SyntaxNodeOrTokenList)red; } } @@ -866,130 +797,123 @@ namespace Parser get { var red = this.GetRed(ref this._catchClause, 2); - if (red != null) - return (CatchClauseSyntaxNode)red; - - return default(CatchClauseSyntaxNode); + return red is null ? default : (CatchClauseSyntaxNode)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _tryBody!, 1); - case 2: return GetRed(ref _catchClause, 2); - default: return null; + 1 => GetRed(ref _tryBody!, 1), 2 => GetRed(ref _catchClause, 2), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitTryCatchStatement(this); } - } public class ExpressionStatementSyntaxNode : StatementSyntaxNode { private SyntaxNode? _expression; - - internal ExpressionStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal ExpressionStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } - public ExpressionSyntaxNode Expression { get { var red = this.GetRed(ref this._expression!, 0); - if (red != null) - return (ExpressionSyntaxNode)red; - - throw new System.Exception("expression cannot be null"); + return red is null ? throw new System.Exception("expression cannot be null.") : (ExpressionSyntaxNode)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 0: return GetRed(ref _expression!, 0); - default: return null; + 0 => GetRed(ref _expression!, 0), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitExpressionStatement(this); } - } public class EmptyStatementSyntaxNode : StatementSyntaxNode { - - internal EmptyStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal EmptyStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken Semicolon { - get { return new SyntaxToken(this, ((Parser.Internal.EmptyStatementSyntaxNode)_green)._semicolon, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.EmptyStatementSyntaxNode)_green)._semicolon, this.GetChildPosition(0)); + } } - internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - default: return null; + _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitEmptyStatement(this); } - } public class EmptyExpressionSyntaxNode : ExpressionSyntaxNode { - - internal EmptyExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal EmptyExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } - - internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - default: return null; + _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitEmptyExpression(this); } - } public class UnaryPrefixOperationExpressionSyntaxNode : ExpressionSyntaxNode { private SyntaxNode? _operand; - - internal UnaryPrefixOperationExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal UnaryPrefixOperationExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken Operation { - get { return new SyntaxToken(this, ((Parser.Internal.UnaryPrefixOperationExpressionSyntaxNode)_green)._operation, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.UnaryPrefixOperationExpressionSyntaxNode)_green)._operation, this.GetChildPosition(0)); + } } public ExpressionSyntaxNode Operand @@ -997,77 +921,71 @@ namespace Parser get { var red = this.GetRed(ref this._operand!, 1); - if (red != null) - return (ExpressionSyntaxNode)red; - - throw new System.Exception("operand cannot be null"); + return red is null ? throw new System.Exception("operand cannot be null.") : (ExpressionSyntaxNode)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _operand!, 1); - default: return null; + 1 => GetRed(ref _operand!, 1), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitUnaryPrefixOperationExpression(this); } - } public class CompoundNameSyntaxNode : ExpressionSyntaxNode { private SyntaxNode? _nodes; - - internal CompoundNameSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal CompoundNameSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } - public SyntaxNodeOrTokenList Nodes { get { var red = this.GetRed(ref this._nodes!, 0); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("nodes cannot be null"); + return red is null ? throw new System.Exception("nodes cannot be null.") : (SyntaxNodeOrTokenList)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 0: return GetRed(ref _nodes!, 0); - default: return null; + 0 => GetRed(ref _nodes!, 0), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitCompoundName(this); } - } public class NamedFunctionHandleSyntaxNode : FunctionHandleSyntaxNode { private SyntaxNode? _functionName; - - internal NamedFunctionHandleSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal NamedFunctionHandleSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken AtSign { - get { return new SyntaxToken(this, ((Parser.Internal.NamedFunctionHandleSyntaxNode)_green)._atSign, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.NamedFunctionHandleSyntaxNode)_green)._atSign, this.GetChildPosition(0)); + } } public CompoundNameSyntaxNode FunctionName @@ -1075,41 +993,40 @@ namespace Parser get { var red = this.GetRed(ref this._functionName!, 1); - if (red != null) - return (CompoundNameSyntaxNode)red; - - throw new System.Exception("functionName cannot be null"); + return red is null ? throw new System.Exception("functionName cannot be null.") : (CompoundNameSyntaxNode)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _functionName!, 1); - default: return null; + 1 => GetRed(ref _functionName!, 1), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitNamedFunctionHandle(this); } - } public class LambdaSyntaxNode : FunctionHandleSyntaxNode { private SyntaxNode? _input; private SyntaxNode? _body; - - internal LambdaSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal LambdaSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken AtSign { - get { return new SyntaxToken(this, ((Parser.Internal.LambdaSyntaxNode)_green)._atSign, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.LambdaSyntaxNode)_green)._atSign, this.GetChildPosition(0)); + } } public FunctionInputDescriptionSyntaxNode Input @@ -1117,10 +1034,7 @@ namespace Parser get { var red = this.GetRed(ref this._input!, 1); - if (red != null) - return (FunctionInputDescriptionSyntaxNode)red; - - throw new System.Exception("input cannot be null"); + return red is null ? throw new System.Exception("input cannot be null.") : (FunctionInputDescriptionSyntaxNode)red; } } @@ -1129,42 +1043,40 @@ namespace Parser get { var red = this.GetRed(ref this._body!, 2); - if (red != null) - return (ExpressionSyntaxNode)red; - - throw new System.Exception("body cannot be null"); + return red is null ? throw new System.Exception("body cannot be null.") : (ExpressionSyntaxNode)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _input!, 1); - case 2: return GetRed(ref _body!, 2); - default: return null; + 1 => GetRed(ref _input!, 1), 2 => GetRed(ref _body!, 2), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitLambda(this); } - } public class BinaryOperationExpressionSyntaxNode : ExpressionSyntaxNode { private SyntaxNode? _lhs; private SyntaxNode? _rhs; - - internal BinaryOperationExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal BinaryOperationExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken Operation { - get { return new SyntaxToken(this, ((Parser.Internal.BinaryOperationExpressionSyntaxNode)_green)._operation, this.GetChildPosition(1)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.BinaryOperationExpressionSyntaxNode)_green)._operation, this.GetChildPosition(1)); + } } public ExpressionSyntaxNode Lhs @@ -1172,10 +1084,7 @@ namespace Parser get { var red = this.GetRed(ref this._lhs!, 0); - if (red != null) - return (ExpressionSyntaxNode)red; - - throw new System.Exception("lhs cannot be null"); + return red is null ? throw new System.Exception("lhs cannot be null.") : (ExpressionSyntaxNode)red; } } @@ -1184,186 +1093,197 @@ namespace Parser get { var red = this.GetRed(ref this._rhs!, 2); - if (red != null) - return (ExpressionSyntaxNode)red; - - throw new System.Exception("rhs cannot be null"); + return red is null ? throw new System.Exception("rhs cannot be null.") : (ExpressionSyntaxNode)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 0: return GetRed(ref _lhs!, 0); - case 2: return GetRed(ref _rhs!, 2); - default: return null; + 0 => GetRed(ref _lhs!, 0), 2 => GetRed(ref _rhs!, 2), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitBinaryOperationExpression(this); } - } public class IdentifierNameSyntaxNode : ExpressionSyntaxNode { - - internal IdentifierNameSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal IdentifierNameSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken Name { - get { return new SyntaxToken(this, ((Parser.Internal.IdentifierNameSyntaxNode)_green)._name, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.IdentifierNameSyntaxNode)_green)._name, this.GetChildPosition(0)); + } } - internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - default: return null; + _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitIdentifierName(this); } - } public class NumberLiteralSyntaxNode : ExpressionSyntaxNode { - - internal NumberLiteralSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal NumberLiteralSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken Number { - get { return new SyntaxToken(this, ((Parser.Internal.NumberLiteralSyntaxNode)_green)._number, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.NumberLiteralSyntaxNode)_green)._number, this.GetChildPosition(0)); + } } - internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - default: return null; + _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitNumberLiteral(this); } - } public class StringLiteralSyntaxNode : ExpressionSyntaxNode { - - internal StringLiteralSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal StringLiteralSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken StringToken { - get { return new SyntaxToken(this, ((Parser.Internal.StringLiteralSyntaxNode)_green)._stringToken, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.StringLiteralSyntaxNode)_green)._stringToken, this.GetChildPosition(0)); + } } - internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - default: return null; + _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitStringLiteral(this); } - } public class DoubleQuotedStringLiteralSyntaxNode : ExpressionSyntaxNode { - - internal DoubleQuotedStringLiteralSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal DoubleQuotedStringLiteralSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken StringToken { - get { return new SyntaxToken(this, ((Parser.Internal.DoubleQuotedStringLiteralSyntaxNode)_green)._stringToken, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.DoubleQuotedStringLiteralSyntaxNode)_green)._stringToken, this.GetChildPosition(0)); + } } - internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - default: return null; + _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitDoubleQuotedStringLiteral(this); } - } public class UnquotedStringLiteralSyntaxNode : ExpressionSyntaxNode { - - internal UnquotedStringLiteralSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal UnquotedStringLiteralSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken StringToken { - get { return new SyntaxToken(this, ((Parser.Internal.UnquotedStringLiteralSyntaxNode)_green)._stringToken, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.UnquotedStringLiteralSyntaxNode)_green)._stringToken, this.GetChildPosition(0)); + } } - internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - default: return null; + _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitUnquotedStringLiteral(this); } - } public class ArrayLiteralExpressionSyntaxNode : ExpressionSyntaxNode { private SyntaxNode? _nodes; - - internal ArrayLiteralExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal ArrayLiteralExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken OpeningSquareBracket { - get { return new SyntaxToken(this, ((Parser.Internal.ArrayLiteralExpressionSyntaxNode)_green)._openingSquareBracket, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.ArrayLiteralExpressionSyntaxNode)_green)._openingSquareBracket, this.GetChildPosition(0)); + } } public SyntaxToken ClosingSquareBracket { - get { return new SyntaxToken(this, ((Parser.Internal.ArrayLiteralExpressionSyntaxNode)_green)._closingSquareBracket, this.GetChildPosition(2)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.ArrayLiteralExpressionSyntaxNode)_green)._closingSquareBracket, this.GetChildPosition(2)); + } } public SyntaxNodeOrTokenList Nodes @@ -1371,45 +1291,47 @@ namespace Parser get { var red = this.GetRed(ref this._nodes!, 1); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("nodes cannot be null"); + return red is null ? throw new System.Exception("nodes cannot be null.") : (SyntaxNodeOrTokenList)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _nodes!, 1); - default: return null; + 1 => GetRed(ref _nodes!, 1), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitArrayLiteralExpression(this); } - } public class CellArrayLiteralExpressionSyntaxNode : ExpressionSyntaxNode { private SyntaxNode? _nodes; - - internal CellArrayLiteralExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal CellArrayLiteralExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken OpeningBrace { - get { return new SyntaxToken(this, ((Parser.Internal.CellArrayLiteralExpressionSyntaxNode)_green)._openingBrace, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.CellArrayLiteralExpressionSyntaxNode)_green)._openingBrace, this.GetChildPosition(0)); + } } public SyntaxToken ClosingBrace { - get { return new SyntaxToken(this, ((Parser.Internal.CellArrayLiteralExpressionSyntaxNode)_green)._closingBrace, this.GetChildPosition(2)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.CellArrayLiteralExpressionSyntaxNode)_green)._closingBrace, this.GetChildPosition(2)); + } } public SyntaxNodeOrTokenList Nodes @@ -1417,45 +1339,47 @@ namespace Parser get { var red = this.GetRed(ref this._nodes!, 1); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("nodes cannot be null"); + return red is null ? throw new System.Exception("nodes cannot be null.") : (SyntaxNodeOrTokenList)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _nodes!, 1); - default: return null; + 1 => GetRed(ref _nodes!, 1), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitCellArrayLiteralExpression(this); } - } public class ParenthesizedExpressionSyntaxNode : ExpressionSyntaxNode { private SyntaxNode? _expression; - - internal ParenthesizedExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal ParenthesizedExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken OpeningBracket { - get { return new SyntaxToken(this, ((Parser.Internal.ParenthesizedExpressionSyntaxNode)_green)._openingBracket, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.ParenthesizedExpressionSyntaxNode)_green)._openingBracket, this.GetChildPosition(0)); + } } public SyntaxToken ClosingBracket { - get { return new SyntaxToken(this, ((Parser.Internal.ParenthesizedExpressionSyntaxNode)_green)._closingBracket, this.GetChildPosition(2)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.ParenthesizedExpressionSyntaxNode)_green)._closingBracket, this.GetChildPosition(2)); + } } public ExpressionSyntaxNode Expression @@ -1463,46 +1387,48 @@ namespace Parser get { var red = this.GetRed(ref this._expression!, 1); - if (red != null) - return (ExpressionSyntaxNode)red; - - throw new System.Exception("expression cannot be null"); + return red is null ? throw new System.Exception("expression cannot be null.") : (ExpressionSyntaxNode)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _expression!, 1); - default: return null; + 1 => GetRed(ref _expression!, 1), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitParenthesizedExpression(this); } - } public class CellArrayElementAccessExpressionSyntaxNode : ExpressionSyntaxNode { private SyntaxNode? _expression; private SyntaxNode? _nodes; - - internal CellArrayElementAccessExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal CellArrayElementAccessExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken OpeningBrace { - get { return new SyntaxToken(this, ((Parser.Internal.CellArrayElementAccessExpressionSyntaxNode)_green)._openingBrace, this.GetChildPosition(1)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.CellArrayElementAccessExpressionSyntaxNode)_green)._openingBrace, this.GetChildPosition(1)); + } } public SyntaxToken ClosingBrace { - get { return new SyntaxToken(this, ((Parser.Internal.CellArrayElementAccessExpressionSyntaxNode)_green)._closingBrace, this.GetChildPosition(3)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.CellArrayElementAccessExpressionSyntaxNode)_green)._closingBrace, this.GetChildPosition(3)); + } } public ExpressionSyntaxNode Expression @@ -1510,10 +1436,7 @@ namespace Parser get { var red = this.GetRed(ref this._expression!, 0); - if (red != null) - return (ExpressionSyntaxNode)red; - - throw new System.Exception("expression cannot be null"); + return red is null ? throw new System.Exception("expression cannot be null.") : (ExpressionSyntaxNode)red; } } @@ -1522,47 +1445,48 @@ namespace Parser get { var red = this.GetRed(ref this._nodes!, 2); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("nodes cannot be null"); + return red is null ? throw new System.Exception("nodes cannot be null.") : (SyntaxNodeOrTokenList)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 0: return GetRed(ref _expression!, 0); - case 2: return GetRed(ref _nodes!, 2); - default: return null; + 0 => GetRed(ref _expression!, 0), 2 => GetRed(ref _nodes!, 2), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitCellArrayElementAccessExpression(this); } - } public class FunctionCallExpressionSyntaxNode : ExpressionSyntaxNode { private SyntaxNode? _functionName; private SyntaxNode? _nodes; - - internal FunctionCallExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal FunctionCallExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken OpeningBracket { - get { return new SyntaxToken(this, ((Parser.Internal.FunctionCallExpressionSyntaxNode)_green)._openingBracket, this.GetChildPosition(1)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.FunctionCallExpressionSyntaxNode)_green)._openingBracket, this.GetChildPosition(1)); + } } public SyntaxToken ClosingBracket { - get { return new SyntaxToken(this, ((Parser.Internal.FunctionCallExpressionSyntaxNode)_green)._closingBracket, this.GetChildPosition(3)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.FunctionCallExpressionSyntaxNode)_green)._closingBracket, this.GetChildPosition(3)); + } } public ExpressionSyntaxNode FunctionName @@ -1570,10 +1494,7 @@ namespace Parser get { var red = this.GetRed(ref this._functionName!, 0); - if (red != null) - return (ExpressionSyntaxNode)red; - - throw new System.Exception("functionName cannot be null"); + return red is null ? throw new System.Exception("functionName cannot be null.") : (ExpressionSyntaxNode)red; } } @@ -1582,42 +1503,40 @@ namespace Parser get { var red = this.GetRed(ref this._nodes!, 2); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("nodes cannot be null"); + return red is null ? throw new System.Exception("nodes cannot be null.") : (SyntaxNodeOrTokenList)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 0: return GetRed(ref _functionName!, 0); - case 2: return GetRed(ref _nodes!, 2); - default: return null; + 0 => GetRed(ref _functionName!, 0), 2 => GetRed(ref _nodes!, 2), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitFunctionCallExpression(this); } - } public class MemberAccessSyntaxNode : ExpressionSyntaxNode { private SyntaxNode? _leftOperand; private SyntaxNode? _rightOperand; - - internal MemberAccessSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal MemberAccessSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken Dot { - get { return new SyntaxToken(this, ((Parser.Internal.MemberAccessSyntaxNode)_green)._dot, this.GetChildPosition(1)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.MemberAccessSyntaxNode)_green)._dot, this.GetChildPosition(1)); + } } public SyntaxNode LeftOperand @@ -1625,10 +1544,7 @@ namespace Parser get { var red = this.GetRed(ref this._leftOperand!, 0); - if (red != null) - return (SyntaxNode)red; - - throw new System.Exception("leftOperand cannot be null"); + return red is null ? throw new System.Exception("leftOperand cannot be null.") : (SyntaxNode)red; } } @@ -1637,41 +1553,39 @@ namespace Parser get { var red = this.GetRed(ref this._rightOperand!, 2); - if (red != null) - return (SyntaxNode)red; - - throw new System.Exception("rightOperand cannot be null"); + return red is null ? throw new System.Exception("rightOperand cannot be null.") : (SyntaxNode)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 0: return GetRed(ref _leftOperand!, 0); - case 2: return GetRed(ref _rightOperand!, 2); - default: return null; + 0 => GetRed(ref _leftOperand!, 0), 2 => GetRed(ref _rightOperand!, 2), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitMemberAccess(this); } - } public class UnaryPostixOperationExpressionSyntaxNode : ExpressionSyntaxNode { private SyntaxNode? _operand; - - internal UnaryPostixOperationExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal UnaryPostixOperationExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken Operation { - get { return new SyntaxToken(this, ((Parser.Internal.UnaryPostixOperationExpressionSyntaxNode)_green)._operation, this.GetChildPosition(1)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.UnaryPostixOperationExpressionSyntaxNode)_green)._operation, this.GetChildPosition(1)); + } } public ExpressionSyntaxNode Operand @@ -1679,45 +1593,47 @@ namespace Parser get { var red = this.GetRed(ref this._operand!, 0); - if (red != null) - return (ExpressionSyntaxNode)red; - - throw new System.Exception("operand cannot be null"); + return red is null ? throw new System.Exception("operand cannot be null.") : (ExpressionSyntaxNode)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 0: return GetRed(ref _operand!, 0); - default: return null; + 0 => GetRed(ref _operand!, 0), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitUnaryPostixOperationExpression(this); } - } public class IndirectMemberAccessSyntaxNode : ExpressionSyntaxNode { private SyntaxNode? _expression; - - internal IndirectMemberAccessSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal IndirectMemberAccessSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken OpeningBracket { - get { return new SyntaxToken(this, ((Parser.Internal.IndirectMemberAccessSyntaxNode)_green)._openingBracket, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.IndirectMemberAccessSyntaxNode)_green)._openingBracket, this.GetChildPosition(0)); + } } public SyntaxToken ClosingBracket { - get { return new SyntaxToken(this, ((Parser.Internal.IndirectMemberAccessSyntaxNode)_green)._closingBracket, this.GetChildPosition(2)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.IndirectMemberAccessSyntaxNode)_green)._closingBracket, this.GetChildPosition(2)); + } } public ExpressionSyntaxNode Expression @@ -1725,48 +1641,40 @@ namespace Parser get { var red = this.GetRed(ref this._expression!, 1); - if (red != null) - return (ExpressionSyntaxNode)red; - - throw new System.Exception("expression cannot be null"); + return red is null ? throw new System.Exception("expression cannot be null.") : (ExpressionSyntaxNode)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _expression!, 1); - default: return null; + 1 => GetRed(ref _expression!, 1), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitIndirectMemberAccess(this); } - } public class CommandExpressionSyntaxNode : ExpressionSyntaxNode { private SyntaxNode? _commandName; private SyntaxNode? _arguments; - - internal CommandExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal CommandExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } - public IdentifierNameSyntaxNode CommandName { get { var red = this.GetRed(ref this._commandName!, 0); - if (red != null) - return (IdentifierNameSyntaxNode)red; - - throw new System.Exception("commandName cannot be null"); + return red is null ? throw new System.Exception("commandName cannot be null.") : (IdentifierNameSyntaxNode)red; } } @@ -1775,42 +1683,40 @@ namespace Parser get { var red = this.GetRed(ref this._arguments!, 1); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("arguments cannot be null"); + return red is null ? throw new System.Exception("arguments cannot be null.") : (SyntaxNodeOrTokenList)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 0: return GetRed(ref _commandName!, 0); - case 1: return GetRed(ref _arguments!, 1); - default: return null; + 0 => GetRed(ref _commandName!, 0), 1 => GetRed(ref _arguments!, 1), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitCommandExpression(this); } - } public class BaseClassInvokationSyntaxNode : ExpressionSyntaxNode { private SyntaxNode? _methodName; private SyntaxNode? _baseClassNameAndArguments; - - internal BaseClassInvokationSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal BaseClassInvokationSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken AtSign { - get { return new SyntaxToken(this, ((Parser.Internal.BaseClassInvokationSyntaxNode)_green)._atSign, this.GetChildPosition(1)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.BaseClassInvokationSyntaxNode)_green)._atSign, this.GetChildPosition(1)); + } } public ExpressionSyntaxNode MethodName @@ -1818,10 +1724,7 @@ namespace Parser get { var red = this.GetRed(ref this._methodName!, 0); - if (red != null) - return (ExpressionSyntaxNode)red; - - throw new System.Exception("methodName cannot be null"); + return red is null ? throw new System.Exception("methodName cannot be null.") : (ExpressionSyntaxNode)red; } } @@ -1830,41 +1733,39 @@ namespace Parser get { var red = this.GetRed(ref this._baseClassNameAndArguments!, 2); - if (red != null) - return (ExpressionSyntaxNode)red; - - throw new System.Exception("baseClassNameAndArguments cannot be null"); + return red is null ? throw new System.Exception("baseClassNameAndArguments cannot be null.") : (ExpressionSyntaxNode)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 0: return GetRed(ref _methodName!, 0); - case 2: return GetRed(ref _baseClassNameAndArguments!, 2); - default: return null; + 0 => GetRed(ref _methodName!, 0), 2 => GetRed(ref _baseClassNameAndArguments!, 2), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitBaseClassInvokation(this); } - } public class AttributeAssignmentSyntaxNode : SyntaxNode { private SyntaxNode? _value; - - internal AttributeAssignmentSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal AttributeAssignmentSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken AssignmentSign { - get { return new SyntaxToken(this, ((Parser.Internal.AttributeAssignmentSyntaxNode)_green)._assignmentSign, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.AttributeAssignmentSyntaxNode)_green)._assignmentSign, this.GetChildPosition(0)); + } } public ExpressionSyntaxNode Value @@ -1872,48 +1773,40 @@ namespace Parser get { var red = this.GetRed(ref this._value!, 1); - if (red != null) - return (ExpressionSyntaxNode)red; - - throw new System.Exception("value cannot be null"); + return red is null ? throw new System.Exception("value cannot be null.") : (ExpressionSyntaxNode)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _value!, 1); - default: return null; + 1 => GetRed(ref _value!, 1), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitAttributeAssignment(this); } - } public class AttributeSyntaxNode : SyntaxNode { private SyntaxNode? _name; private SyntaxNode? _assignment; - - internal AttributeSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal AttributeSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } - public IdentifierNameSyntaxNode Name { get { var red = this.GetRed(ref this._name!, 0); - if (red != null) - return (IdentifierNameSyntaxNode)red; - - throw new System.Exception("name cannot be null"); + return red is null ? throw new System.Exception("name cannot be null.") : (IdentifierNameSyntaxNode)red; } } @@ -1922,46 +1815,47 @@ namespace Parser get { var red = this.GetRed(ref this._assignment, 1); - if (red != null) - return (AttributeAssignmentSyntaxNode)red; - - return default(AttributeAssignmentSyntaxNode); + return red is null ? default : (AttributeAssignmentSyntaxNode)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 0: return GetRed(ref _name!, 0); - case 1: return GetRed(ref _assignment, 1); - default: return null; + 0 => GetRed(ref _name!, 0), 1 => GetRed(ref _assignment, 1), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitAttribute(this); } - } public class AttributeListSyntaxNode : SyntaxNode { private SyntaxNode? _nodes; - - internal AttributeListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal AttributeListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken OpeningBracket { - get { return new SyntaxToken(this, ((Parser.Internal.AttributeListSyntaxNode)_green)._openingBracket, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.AttributeListSyntaxNode)_green)._openingBracket, this.GetChildPosition(0)); + } } public SyntaxToken ClosingBracket { - get { return new SyntaxToken(this, ((Parser.Internal.AttributeListSyntaxNode)_green)._closingBracket, this.GetChildPosition(2)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.AttributeListSyntaxNode)_green)._closingBracket, this.GetChildPosition(2)); + } } public SyntaxNodeOrTokenList Nodes @@ -1969,27 +1863,24 @@ namespace Parser get { var red = this.GetRed(ref this._nodes!, 1); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("nodes cannot be null"); + return red is null ? throw new System.Exception("nodes cannot be null.") : (SyntaxNodeOrTokenList)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _nodes!, 1); - default: return null; + 1 => GetRed(ref _nodes!, 1), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitAttributeList(this); } - } public class MethodDefinitionSyntaxNode : MethodDeclarationSyntaxNode @@ -2000,14 +1891,16 @@ namespace Parser private SyntaxNode? _commas; private SyntaxNode? _body; private SyntaxNode? _endKeyword; - - internal MethodDefinitionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal MethodDefinitionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken FunctionKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.MethodDefinitionSyntaxNode)_green)._functionKeyword, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.MethodDefinitionSyntaxNode)_green)._functionKeyword, this.GetChildPosition(0)); + } } public FunctionOutputDescriptionSyntaxNode? OutputDescription @@ -2015,10 +1908,7 @@ namespace Parser get { var red = this.GetRed(ref this._outputDescription, 1); - if (red != null) - return (FunctionOutputDescriptionSyntaxNode)red; - - return default(FunctionOutputDescriptionSyntaxNode); + return red is null ? default : (FunctionOutputDescriptionSyntaxNode)red; } } @@ -2027,10 +1917,7 @@ namespace Parser get { var red = this.GetRed(ref this._name!, 2); - if (red != null) - return (CompoundNameSyntaxNode)red; - - throw new System.Exception("name cannot be null"); + return red is null ? throw new System.Exception("name cannot be null.") : (CompoundNameSyntaxNode)red; } } @@ -2039,10 +1926,7 @@ namespace Parser get { var red = this.GetRed(ref this._inputDescription, 3); - if (red != null) - return (FunctionInputDescriptionSyntaxNode)red; - - return default(FunctionInputDescriptionSyntaxNode); + return red is null ? default : (FunctionInputDescriptionSyntaxNode)red; } } @@ -2051,10 +1935,7 @@ namespace Parser get { var red = this.GetRed(ref this._commas!, 4); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("commas cannot be null"); + return red is null ? throw new System.Exception("commas cannot be null.") : (SyntaxNodeOrTokenList)red; } } @@ -2063,10 +1944,7 @@ namespace Parser get { var red = this.GetRed(ref this._body!, 5); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("body cannot be null"); + return red is null ? throw new System.Exception("body cannot be null.") : (SyntaxNodeOrTokenList)red; } } @@ -2075,32 +1953,24 @@ namespace Parser get { var red = this.GetRed(ref this._endKeyword, 6); - if (red != null) - return (EndKeywordSyntaxNode)red; - - return default(EndKeywordSyntaxNode); + return red is null ? default : (EndKeywordSyntaxNode)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _outputDescription, 1); - case 2: return GetRed(ref _name!, 2); - case 3: return GetRed(ref _inputDescription, 3); - case 4: return GetRed(ref _commas!, 4); - case 5: return GetRed(ref _body!, 5); - case 6: return GetRed(ref _endKeyword, 6); - default: return null; + 1 => GetRed(ref _outputDescription, 1), 2 => GetRed(ref _name!, 2), 3 => GetRed(ref _inputDescription, 3), 4 => GetRed(ref _commas!, 4), 5 => GetRed(ref _body!, 5), 6 => GetRed(ref _endKeyword, 6), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitMethodDefinition(this); } - } public class AbstractMethodDeclarationSyntaxNode : MethodDeclarationSyntaxNode @@ -2108,21 +1978,16 @@ namespace Parser private SyntaxNode? _outputDescription; private SyntaxNode? _name; private SyntaxNode? _inputDescription; - - internal AbstractMethodDeclarationSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal AbstractMethodDeclarationSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } - public FunctionOutputDescriptionSyntaxNode? OutputDescription { get { var red = this.GetRed(ref this._outputDescription, 0); - if (red != null) - return (FunctionOutputDescriptionSyntaxNode)red; - - return default(FunctionOutputDescriptionSyntaxNode); + return red is null ? default : (FunctionOutputDescriptionSyntaxNode)red; } } @@ -2131,10 +1996,7 @@ namespace Parser get { var red = this.GetRed(ref this._name!, 1); - if (red != null) - return (CompoundNameSyntaxNode)red; - - throw new System.Exception("name cannot be null"); + return red is null ? throw new System.Exception("name cannot be null.") : (CompoundNameSyntaxNode)red; } } @@ -2143,48 +2005,48 @@ namespace Parser get { var red = this.GetRed(ref this._inputDescription, 2); - if (red != null) - return (FunctionInputDescriptionSyntaxNode)red; - - return default(FunctionInputDescriptionSyntaxNode); + return red is null ? default : (FunctionInputDescriptionSyntaxNode)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 0: return GetRed(ref _outputDescription, 0); - case 1: return GetRed(ref _name!, 1); - case 2: return GetRed(ref _inputDescription, 2); - default: return null; + 0 => GetRed(ref _outputDescription, 0), 1 => GetRed(ref _name!, 1), 2 => GetRed(ref _inputDescription, 2), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitAbstractMethodDeclaration(this); } - } public class MethodsListSyntaxNode : SyntaxNode { private SyntaxNode? _attributes; private SyntaxNode? _methods; - - internal MethodsListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal MethodsListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken MethodsKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.MethodsListSyntaxNode)_green)._methodsKeyword, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.MethodsListSyntaxNode)_green)._methodsKeyword, this.GetChildPosition(0)); + } } public SyntaxToken EndKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.MethodsListSyntaxNode)_green)._endKeyword, this.GetChildPosition(3)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.MethodsListSyntaxNode)_green)._endKeyword, this.GetChildPosition(3)); + } } public AttributeListSyntaxNode? Attributes @@ -2192,10 +2054,7 @@ namespace Parser get { var red = this.GetRed(ref this._attributes, 1); - if (red != null) - return (AttributeListSyntaxNode)red; - - return default(AttributeListSyntaxNode); + return red is null ? default : (AttributeListSyntaxNode)red; } } @@ -2204,47 +2063,48 @@ namespace Parser get { var red = this.GetRed(ref this._methods!, 2); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("methods cannot be null"); + return red is null ? throw new System.Exception("methods cannot be null.") : (SyntaxNodeOrTokenList)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _attributes, 1); - case 2: return GetRed(ref _methods!, 2); - default: return null; + 1 => GetRed(ref _attributes, 1), 2 => GetRed(ref _methods!, 2), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitMethodsList(this); } - } public class PropertiesListSyntaxNode : SyntaxNode { private SyntaxNode? _attributes; private SyntaxNode? _properties; - - internal PropertiesListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal PropertiesListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken PropertiesKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.PropertiesListSyntaxNode)_green)._propertiesKeyword, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.PropertiesListSyntaxNode)_green)._propertiesKeyword, this.GetChildPosition(0)); + } } public SyntaxToken EndKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.PropertiesListSyntaxNode)_green)._endKeyword, this.GetChildPosition(3)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.PropertiesListSyntaxNode)_green)._endKeyword, this.GetChildPosition(3)); + } } public AttributeListSyntaxNode? Attributes @@ -2252,10 +2112,7 @@ namespace Parser get { var red = this.GetRed(ref this._attributes, 1); - if (red != null) - return (AttributeListSyntaxNode)red; - - return default(AttributeListSyntaxNode); + return red is null ? default : (AttributeListSyntaxNode)red; } } @@ -2264,41 +2121,39 @@ namespace Parser get { var red = this.GetRed(ref this._properties!, 2); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("properties cannot be null"); + return red is null ? throw new System.Exception("properties cannot be null.") : (SyntaxNodeOrTokenList)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _attributes, 1); - case 2: return GetRed(ref _properties!, 2); - default: return null; + 1 => GetRed(ref _attributes, 1), 2 => GetRed(ref _properties!, 2), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitPropertiesList(this); } - } public class BaseClassListSyntaxNode : SyntaxNode { private SyntaxNode? _baseClasses; - - internal BaseClassListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal BaseClassListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken LessSign { - get { return new SyntaxToken(this, ((Parser.Internal.BaseClassListSyntaxNode)_green)._lessSign, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.BaseClassListSyntaxNode)_green)._lessSign, this.GetChildPosition(0)); + } } public SyntaxNodeOrTokenList BaseClasses @@ -2306,27 +2161,24 @@ namespace Parser get { var red = this.GetRed(ref this._baseClasses!, 1); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("baseClasses cannot be null"); + return red is null ? throw new System.Exception("baseClasses cannot be null.") : (SyntaxNodeOrTokenList)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _baseClasses!, 1); - default: return null; + 1 => GetRed(ref _baseClasses!, 1), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitBaseClassList(this); } - } public class ClassDeclarationSyntaxNode : StatementSyntaxNode @@ -2335,19 +2187,24 @@ namespace Parser private SyntaxNode? _className; private SyntaxNode? _baseClassList; private SyntaxNode? _nodes; - - internal ClassDeclarationSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal ClassDeclarationSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken ClassdefKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.ClassDeclarationSyntaxNode)_green)._classdefKeyword, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.ClassDeclarationSyntaxNode)_green)._classdefKeyword, this.GetChildPosition(0)); + } } public SyntaxToken EndKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.ClassDeclarationSyntaxNode)_green)._endKeyword, this.GetChildPosition(5)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.ClassDeclarationSyntaxNode)_green)._endKeyword, this.GetChildPosition(5)); + } } public AttributeListSyntaxNode? Attributes @@ -2355,10 +2212,7 @@ namespace Parser get { var red = this.GetRed(ref this._attributes, 1); - if (red != null) - return (AttributeListSyntaxNode)red; - - return default(AttributeListSyntaxNode); + return red is null ? default : (AttributeListSyntaxNode)red; } } @@ -2367,10 +2221,7 @@ namespace Parser get { var red = this.GetRed(ref this._className!, 2); - if (red != null) - return (IdentifierNameSyntaxNode)red; - - throw new System.Exception("className cannot be null"); + return red is null ? throw new System.Exception("className cannot be null.") : (IdentifierNameSyntaxNode)red; } } @@ -2379,10 +2230,7 @@ namespace Parser get { var red = this.GetRed(ref this._baseClassList, 3); - if (red != null) - return (BaseClassListSyntaxNode)red; - - return default(BaseClassListSyntaxNode); + return red is null ? default : (BaseClassListSyntaxNode)red; } } @@ -2391,48 +2239,47 @@ namespace Parser get { var red = this.GetRed(ref this._nodes!, 4); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("nodes cannot be null"); + return red is null ? throw new System.Exception("nodes cannot be null.") : (SyntaxNodeOrTokenList)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _attributes, 1); - case 2: return GetRed(ref _className!, 2); - case 3: return GetRed(ref _baseClassList, 3); - case 4: return GetRed(ref _nodes!, 4); - default: return null; + 1 => GetRed(ref _attributes, 1), 2 => GetRed(ref _className!, 2), 3 => GetRed(ref _baseClassList, 3), 4 => GetRed(ref _nodes!, 4), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitClassDeclaration(this); } - } public class EnumerationItemValueSyntaxNode : SyntaxNode { private SyntaxNode? _values; - - internal EnumerationItemValueSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal EnumerationItemValueSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken OpeningBracket { - get { return new SyntaxToken(this, ((Parser.Internal.EnumerationItemValueSyntaxNode)_green)._openingBracket, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.EnumerationItemValueSyntaxNode)_green)._openingBracket, this.GetChildPosition(0)); + } } public SyntaxToken ClosingBracket { - get { return new SyntaxToken(this, ((Parser.Internal.EnumerationItemValueSyntaxNode)_green)._closingBracket, this.GetChildPosition(2)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.EnumerationItemValueSyntaxNode)_green)._closingBracket, this.GetChildPosition(2)); + } } public SyntaxNodeOrTokenList Values @@ -2440,27 +2287,24 @@ namespace Parser get { var red = this.GetRed(ref this._values!, 1); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("values cannot be null"); + return red is null ? throw new System.Exception("values cannot be null.") : (SyntaxNodeOrTokenList)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _values!, 1); - default: return null; + 1 => GetRed(ref _values!, 1), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitEnumerationItemValue(this); } - } public class EnumerationItemSyntaxNode : SyntaxNode @@ -2468,21 +2312,16 @@ namespace Parser private SyntaxNode? _name; private SyntaxNode? _values; private SyntaxNode? _commas; - - internal EnumerationItemSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal EnumerationItemSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } - public IdentifierNameSyntaxNode Name { get { var red = this.GetRed(ref this._name!, 0); - if (red != null) - return (IdentifierNameSyntaxNode)red; - - throw new System.Exception("name cannot be null"); + return red is null ? throw new System.Exception("name cannot be null.") : (IdentifierNameSyntaxNode)red; } } @@ -2491,10 +2330,7 @@ namespace Parser get { var red = this.GetRed(ref this._values, 1); - if (red != null) - return (EnumerationItemValueSyntaxNode)red; - - return default(EnumerationItemValueSyntaxNode); + return red is null ? default : (EnumerationItemValueSyntaxNode)red; } } @@ -2503,48 +2339,48 @@ namespace Parser get { var red = this.GetRed(ref this._commas!, 2); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("commas cannot be null"); + return red is null ? throw new System.Exception("commas cannot be null.") : (SyntaxNodeOrTokenList)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 0: return GetRed(ref _name!, 0); - case 1: return GetRed(ref _values, 1); - case 2: return GetRed(ref _commas!, 2); - default: return null; + 0 => GetRed(ref _name!, 0), 1 => GetRed(ref _values, 1), 2 => GetRed(ref _commas!, 2), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitEnumerationItem(this); } - } public class EnumerationListSyntaxNode : SyntaxNode { private SyntaxNode? _attributes; private SyntaxNode? _items; - - internal EnumerationListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal EnumerationListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken EnumerationKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.EnumerationListSyntaxNode)_green)._enumerationKeyword, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.EnumerationListSyntaxNode)_green)._enumerationKeyword, this.GetChildPosition(0)); + } } public SyntaxToken EndKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.EnumerationListSyntaxNode)_green)._endKeyword, this.GetChildPosition(3)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.EnumerationListSyntaxNode)_green)._endKeyword, this.GetChildPosition(3)); + } } public AttributeListSyntaxNode? Attributes @@ -2552,10 +2388,7 @@ namespace Parser get { var red = this.GetRed(ref this._attributes, 1); - if (red != null) - return (AttributeListSyntaxNode)red; - - return default(AttributeListSyntaxNode); + return red is null ? default : (AttributeListSyntaxNode)red; } } @@ -2564,47 +2397,48 @@ namespace Parser get { var red = this.GetRed(ref this._items!, 2); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("items cannot be null"); + return red is null ? throw new System.Exception("items cannot be null.") : (SyntaxNodeOrTokenList)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _attributes, 1); - case 2: return GetRed(ref _items!, 2); - default: return null; + 1 => GetRed(ref _attributes, 1), 2 => GetRed(ref _items!, 2), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitEnumerationList(this); } - } public class EventsListSyntaxNode : SyntaxNode { private SyntaxNode? _attributes; private SyntaxNode? _events; - - internal EventsListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal EventsListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken EventsKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.EventsListSyntaxNode)_green)._eventsKeyword, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.EventsListSyntaxNode)_green)._eventsKeyword, this.GetChildPosition(0)); + } } public SyntaxToken EndKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.EventsListSyntaxNode)_green)._endKeyword, this.GetChildPosition(3)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.EventsListSyntaxNode)_green)._endKeyword, this.GetChildPosition(3)); + } } public AttributeListSyntaxNode? Attributes @@ -2612,10 +2446,7 @@ namespace Parser get { var red = this.GetRed(ref this._attributes, 1); - if (red != null) - return (AttributeListSyntaxNode)red; - - return default(AttributeListSyntaxNode); + return red is null ? default : (AttributeListSyntaxNode)red; } } @@ -2624,55 +2455,53 @@ namespace Parser get { var red = this.GetRed(ref this._events!, 2); - if (red != null) - return (SyntaxNodeOrTokenList)red; - - throw new System.Exception("events cannot be null"); + return red is null ? throw new System.Exception("events cannot be null.") : (SyntaxNodeOrTokenList)red; } } internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - case 1: return GetRed(ref _attributes, 1); - case 2: return GetRed(ref _events!, 2); - default: return null; + 1 => GetRed(ref _attributes, 1), 2 => GetRed(ref _events!, 2), _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitEventsList(this); } - } public class EndKeywordSyntaxNode : SyntaxNode { - - internal EndKeywordSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position) + internal EndKeywordSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position): base(parent, green, position) { } public SyntaxToken EndKeyword { - get { return new SyntaxToken(this, ((Parser.Internal.EndKeywordSyntaxNode)_green)._endKeyword, this.GetChildPosition(0)); } + get + { + return new SyntaxToken(this, ((Parser.Internal.EndKeywordSyntaxNode)_green)._endKeyword, this.GetChildPosition(0)); + } } - internal override SyntaxNode? GetNode(int i) { - switch (i) + return i switch { - default: return null; + _ => null } + + ; } public override void Accept(SyntaxVisitor visitor) { visitor.VisitEndKeyword(this); } - } -} +} \ No newline at end of file diff --git a/Parser/SyntaxVisitor.Generated.cs b/Parser/SyntaxVisitor.Generated.cs index c3f5585..3ee82f6 100644 --- a/Parser/SyntaxVisitor.Generated.cs +++ b/Parser/SyntaxVisitor.Generated.cs @@ -258,4 +258,4 @@ namespace Parser DefaultVisit(node); } } -}; \ No newline at end of file +} \ No newline at end of file diff --git a/SyntaxGenerator/DtoExtensions.cs b/SyntaxGenerator/DtoExtensions.cs new file mode 100644 index 0000000..a5bf940 --- /dev/null +++ b/SyntaxGenerator/DtoExtensions.cs @@ -0,0 +1,10 @@ +namespace SyntaxGenerator +{ + public static class DtoExtensions + { + public static string GetPrivateFieldName(this FieldDescription field) + { + return "_" + field.FieldName; + } + } +} \ No newline at end of file diff --git a/SyntaxGenerator/FieldDescription.cs b/SyntaxGenerator/FieldDescription.cs new file mode 100644 index 0000000..3cebc6d --- /dev/null +++ b/SyntaxGenerator/FieldDescription.cs @@ -0,0 +1,17 @@ +using System.Xml.Serialization; + +namespace SyntaxGenerator +{ + + public class FieldDescription + { + [XmlAttribute("Type")] + public string FieldType { get; set; } + + [XmlAttribute("Name")] + public string FieldName { get; set; } + + [XmlAttribute("Nullable")] + public bool FieldIsNullable { get; set; } + } +} \ No newline at end of file diff --git a/SyntaxGenerator/GenerateSyntax.cs b/SyntaxGenerator/GenerateSyntax.cs index 24fb42a..847da49 100644 --- a/SyntaxGenerator/GenerateSyntax.cs +++ b/SyntaxGenerator/GenerateSyntax.cs @@ -2,15 +2,19 @@ using System.Collections.Generic; using System.IO; using System.Linq; -using System.Xml; using System.Xml.Serialization; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Syntax; + +using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; +using static SyntaxGenerator.SyntaxExtensions; namespace SyntaxGenerator { public class GenerateSyntax { private const string SyntaxTokenClassName = "SyntaxToken"; - private const string InternalNamespace = "Parser.Internal"; private const string OuterNamespace = "Parser"; private static readonly List<(string visitorMethodName, string className)> Visitors = new List<(string, string)>(); @@ -31,197 +35,447 @@ namespace SyntaxGenerator } } - public static void TestOutput() + private static MemberDeclarationSyntax GenerateInternalFieldDeclaration(FieldDescription field) { - var field1 = new FieldDescription - { - FieldType = "SyntaxToken", - FieldName = "functionKeyword" - }; - var field2 = new FieldDescription - { - FieldType = "FunctionOutputDescriptionSyntaxNode", - FieldName = "outputDescription" - }; - var syntaxNode = new SyntaxNodeDescription - { - ClassName = "FunctionDeclarationSyntaxNode", - BaseClassName = "StatementSyntaxNode", - Fields = new[] {field1, field2} - }; - var syntax = new SyntaxDescription - { - Nodes = new[] {syntaxNode, syntaxNode} - }; - var serializer = new XmlSerializer(typeof(SyntaxDescription)); - using (var writer = new StreamWriter("output.xml")) - { - serializer.Serialize(writer, syntax); - } + return FieldDeclaration( + VariableDeclaration(FullFieldType(field)) + .WithVariables( + SingletonSeparatedList( + VariableDeclarator( + Identifier(field.GetPrivateFieldName()))))) + .WithModifiers( + TokenList( + Token(SyntaxKind.InternalKeyword), + Token(SyntaxKind.ReadOnlyKeyword))); } - private static string GenerateInternalFieldDeclaration(FieldDescription field) + private static MemberDeclarationSyntax GeneratePrivateFieldDeclaration(FieldDescription field) { - return $" internal readonly {FullFieldType(field)} _{field.FieldName};\n"; + return + FieldDeclaration( + VariableDeclaration(NullableType(IdentifierName("SyntaxNode"))) + .WithVariables( + SingletonSeparatedList( + VariableDeclarator( + Identifier( + field.GetPrivateFieldName()))))) + .WithModifiers( + TokenList( + Token(SyntaxKind.PrivateKeyword))); } - private static string GeneratePrivateFieldDeclaration(FieldDescription field) + private static IEnumerable GenerateFieldAssignmentInsideConstructor(FieldDescription field) { - //var typeDeclaration = field.FieldIsNullable ? "SyntaxNode?" : "SyntaxNode"; - var typeDeclaration = "SyntaxNode?"; - return $" private {typeDeclaration} _{field.FieldName};\n"; + yield return + ExpressionStatement( + InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + ThisExpression(), + IdentifierName("AdjustWidth"))) + .WithArgumentList( + SingleArgument( + IdentifierName(field.FieldName)))); + yield return + ExpressionStatement( + AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + IdentifierName(field.GetPrivateFieldName()), + IdentifierName(field.FieldName))); } - private static string GenerateFieldAssignmentInsideConstructor(FieldDescription field) + private static MemberDeclarationSyntax GenerateInternalConstructorSimple(SyntaxNodeDescription node) { - var widthAdjustment = $" this.AdjustWidth({field.FieldName});\n"; - var fieldAssignment = $" _{field.FieldName} = {field.FieldName};\n"; - return widthAdjustment + fieldAssignment; + return + ConstructorDeclaration( + Identifier(node.ClassName)) + .WithModifiers( + TokenList( + Token(SyntaxKind.InternalKeyword))) + .WithParameterList( + ParameterList( + IntersperseWithCommas( + node.Fields.Select( + field => + Parameter(Identifier(field.FieldName)) + .WithType(FullFieldType(field)))))) + .WithInitializer( + ConstructorInitializer( + SyntaxKind.BaseConstructorInitializer, + SingleArgument( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + IdentifierName("TokenKind"), + IdentifierName(node.TokenKindName))))) + .WithBody( + Block( + node.Fields.SelectMany(GenerateFieldAssignmentInsideConstructor) + .Prepend( + ExpressionStatement( + AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + IdentifierName("Slots"), + LiteralExpression( + SyntaxKind.NumericLiteralExpression, + Literal(node.Fields.Length))))))); } - private static string GenerateInternalConstructorSimple(SyntaxNodeDescription node) + private static MemberDeclarationSyntax GenerateInternalConstructorWithDiagnostics(SyntaxNodeDescription node) { - var arguments = string.Join( - ",", - node.Fields.Select(field => $"\n {FullFieldType(field)} {field.FieldName}")); - - var header = - $" internal {node.ClassName}({arguments}) : base(TokenKind.{node.TokenKindName})"; - var slotsAssignment = $" Slots = {node.Fields.Length};"; - var assignments = string.Join( - "", - node.Fields.Select(GenerateFieldAssignmentInsideConstructor)); - return header + "\n {\n" + slotsAssignment + "\n" + assignments + " }\n"; + return + ConstructorDeclaration( + Identifier(node.ClassName)) + .WithModifiers( + TokenList( + Token(SyntaxKind.InternalKeyword))) + .WithParameterList( + ParameterList( + IntersperseWithCommas( + node.Fields.Select( + field => + Parameter(Identifier(field.FieldName)) + .WithType(FullFieldType(field))) + .Append( + Parameter( + Identifier("diagnostics")) + .WithType( + ArrayType( + IdentifierName("TokenDiagnostic")) + .WithRankSpecifiers( + SingletonList( + ArrayRankSpecifier( + SingletonSeparatedList( + OmittedArraySizeExpression()))))))))) + .WithInitializer( + ConstructorInitializer( + SyntaxKind.BaseConstructorInitializer, + SeveralArguments( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + IdentifierName("TokenKind"), + IdentifierName(node.TokenKindName)), + IdentifierName("diagnostics")))) + .WithBody( + Block( + node.Fields.SelectMany(GenerateFieldAssignmentInsideConstructor) + .Prepend( + ExpressionStatement( + AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + IdentifierName("Slots"), + LiteralExpression( + SyntaxKind.NumericLiteralExpression, + Literal(node.Fields.Length))))))); } - private static string GenerateInternalConstructorWithDiagnostics(SyntaxNodeDescription node) + private static IEnumerable GenerateInternalConstructors(SyntaxNodeDescription node) { - var arguments = string.Join( - ",", - node.Fields - .Select(field => $"\n {FullFieldType(field)} {field.FieldName}") - .Concat(new[] { $"\n TokenDiagnostic[] diagnostics" })); - var header = - $" internal {node.ClassName}({arguments}) : base(TokenKind.{node.TokenKindName}, diagnostics)"; - var slotsAssignment = $" Slots = {node.Fields.Length};"; - var assignments = string.Join( - "", - node.Fields.Select(GenerateFieldAssignmentInsideConstructor)); - return header + "\n {\n" + slotsAssignment + "\n" + assignments + " }\n"; + yield return GenerateInternalConstructorSimple(node); + yield return GenerateInternalConstructorWithDiagnostics(node); } - private static string GenerateInternalConstructors(SyntaxNodeDescription node) + private static MemberDeclarationSyntax GenerateConstructor(SyntaxNodeDescription node) { - return GenerateInternalConstructorSimple(node) + "\n" + GenerateInternalConstructorWithDiagnostics(node); + return + ConstructorDeclaration( + Identifier(node.ClassName)) + .WithModifiers( + TokenList( + Token(SyntaxKind.InternalKeyword))) + .WithParameterList( + ParameterList( + IntersperseWithCommas( + Parameter( + Identifier("parent")) + .WithType( + IdentifierName("SyntaxNode")), + Parameter( + Identifier("green")) + .WithType( + QualifiedName( + IdentifierName("Internal"), + IdentifierName("GreenNode"))), + Parameter( + Identifier("position")) + .WithType( + PredefinedType( + Token(SyntaxKind.IntKeyword)))))) + .WithInitializer( + ConstructorInitializer( + SyntaxKind.BaseConstructorInitializer, + SeveralArguments( + IdentifierName("parent"), + IdentifierName("green"), + IdentifierName("position")))) + .WithBody( + Block()); } - private static string GenerateConstructor(SyntaxNodeDescription node) + private static MemberDeclarationSyntax GenerateInternalSetDiagnostics(SyntaxNodeDescription node) { - var arguments = "SyntaxNode parent, Internal.GreenNode green, int position"; - var header = - $" internal {node.ClassName}({arguments}) : base(parent, green, position)\n"; - return header + " {\n }\n"; + return + MethodDeclaration( + IdentifierName("GreenNode"), + Identifier("SetDiagnostics")) + .WithModifiers( + TokenList( + new[]{ + Token(SyntaxKind.PublicKeyword), + Token(SyntaxKind.OverrideKeyword)})) + .WithParameterList( + ParameterList( + SingletonSeparatedList( + Parameter( + Identifier("diagnostics")) + .WithType( + ArrayType( + IdentifierName("TokenDiagnostic")) + .WithRankSpecifiers( + SingletonList( + ArrayRankSpecifier( + SingletonSeparatedList( + OmittedArraySizeExpression())))))))) + .WithBody( + Block( + SingletonList( + ReturnStatement( + ObjectCreationExpression( + IdentifierName(node.ClassName)) + .WithArgumentList( + SeveralArguments( + node.Fields.Select( + f => IdentifierName(f.GetPrivateFieldName())) + .Append(IdentifierName("diagnostics")))))))); } - private static string GenerateInternalSetDiagnostics(SyntaxNodeDescription node) + private static MethodDeclarationSyntax GenerateInternalGetSlot(SyntaxNodeDescription node) { - var header = $" public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics)"; - var arguments = string.Join( - ", ", - node.Fields - .Select(field => "_" + field.FieldName) - .Concat(new[] { "diagnostics" })); - var text = $" return new {node.ClassName}({arguments});"; - return header + "\n {\n" + text + "\n }\n"; - } - - private static string GenerateInternalGetSlot(SyntaxNodeDescription node) - { - var header = $" public override GreenNode? GetSlot(int i)\n"; - var cases = string.Join( - "", - node.Fields.Select((f, i) => $" case {i}: return _{f.FieldName};\n")); - var defaultCase = " default: return null;\n"; - return header - + " {\n switch (i)\n {\n" - + cases - + defaultCase - + " }\n" - + " }\n"; + return + MethodDeclaration( + NullableType( + IdentifierName("GreenNode")), + Identifier("GetSlot")) + .WithModifiers( + TokenList( + new[]{ + Token(SyntaxKind.PublicKeyword), + Token(SyntaxKind.OverrideKeyword)})) + .WithParameterList( + ParameterList( + SingletonSeparatedList( + Parameter( + Identifier("i")) + .WithType( + PredefinedType( + Token(SyntaxKind.IntKeyword)))))) + .WithBody( + Block( + SingletonList( + ReturnStatement( + SwitchExpression( + IdentifierName("i")) + .WithArms( + IntersperseWithCommas( + node.Fields + .Select((f, i) => SwitchExpressionArm( + ConstantPattern( + LiteralExpression( + SyntaxKind.NumericLiteralExpression, + Literal(i))), + IdentifierName(f.GetPrivateFieldName()))) + .Append( + SwitchExpressionArm( + DiscardPattern(), + LiteralExpression( + SyntaxKind.NullLiteralExpression))))))))); } - private static string GenerateGetSlot(SyntaxNodeDescription node, List<(FieldDescription field, int index)> pairs) + private static MemberDeclarationSyntax GenerateGetSlot(List<(FieldDescription field, int index)> pairs) { - var header = $" internal override SyntaxNode? GetNode(int i)\n"; - - string GetFieldNameWithPossibleBang(FieldDescription field) + static ArgumentSyntax GetFieldNameWithPossibleBang(FieldDescription field) { - return field.FieldIsNullable ? field.FieldName : field.FieldName + "!"; + var name = IdentifierName(field.GetPrivateFieldName()); + return field.FieldIsNullable + ? Argument(name) + : Argument( + PostfixUnaryExpression(SyntaxKind.SuppressNullableWarningExpression, + name)); } - var cases = string.Join( - "", - pairs.Select(pair => $" case {pair.index}: return GetRed(ref _{GetFieldNameWithPossibleBang(pair.field)}, {pair.index});\n")); - var defaultCase = " default: return null;\n"; - return header - + " {\n switch (i)\n {\n" - + cases - + defaultCase - + " }\n" - + " }\n"; + return + MethodDeclaration( + NullableType( + IdentifierName("SyntaxNode")), + Identifier("GetNode")) + .WithModifiers( + TokenList( + new[]{ + Token(SyntaxKind.InternalKeyword), + Token(SyntaxKind.OverrideKeyword)})) + .WithParameterList( + ParameterList( + SingletonSeparatedList( + Parameter( + Identifier("i")) + .WithType( + PredefinedType( + Token(SyntaxKind.IntKeyword)))))) + .WithBody( + Block( + SingletonList( + ReturnStatement( + SwitchExpression( + IdentifierName("i")) + .WithArms( + IntersperseWithCommas( + pairs.Select(pair => + SwitchExpressionArm( + ConstantPattern( + LiteralExpression( + SyntaxKind.NumericLiteralExpression, + Literal(pair.index))), + InvocationExpression( + IdentifierName("GetRed")) + .WithArgumentList( + ArgumentList( + IntersperseWithCommas( + GetFieldNameWithPossibleBang(pair.field) + .WithRefKindKeyword( + Token(SyntaxKind.RefKeyword)), + Argument( + LiteralExpression( + SyntaxKind.NumericLiteralExpression, + Literal(pair.index)))))))) + .Append( + SwitchExpressionArm( + DiscardPattern(), + LiteralExpression( + SyntaxKind.NullLiteralExpression))))))))); } - private static string GenerateCreateRed(SyntaxNodeDescription node) + private static MemberDeclarationSyntax GenerateCreateRed(SyntaxNodeDescription node) { - var header = $" internal override {OuterNamespace}.SyntaxNode CreateRed({OuterNamespace}.SyntaxNode parent, int position)\n"; - var text = $" return new {OuterNamespace}.{node.ClassName}(parent, this, position);\n"; - return header + " {\n" + text + " }\n"; + return + MethodDeclaration( + QualifiedName( + IdentifierName(OuterNamespace), + IdentifierName("SyntaxNode")), + Identifier("CreateRed")) + .WithModifiers( + TokenList( + new[]{ + Token(SyntaxKind.InternalKeyword), + Token(SyntaxKind.OverrideKeyword)})) + .WithParameterList( + ParameterList( + IntersperseWithCommas( + Parameter( + Identifier("parent")) + .WithType( + QualifiedName( + IdentifierName(OuterNamespace), + IdentifierName("SyntaxNode"))), + Parameter( + Identifier("position")) + .WithType( + PredefinedType( + Token(SyntaxKind.IntKeyword)))))) + .WithBody( + Block( + SingletonList( + ReturnStatement( + ObjectCreationExpression( + QualifiedName( + IdentifierName(OuterNamespace), + IdentifierName(node.ClassName))) + .WithArgumentList( + SeveralArguments( + IdentifierName("parent"), + ThisExpression(), + IdentifierName("position"))))))); } - private static string GenerateInternalClass(SyntaxNodeDescription node) + private static MemberDeclarationSyntax GenerateInternalClass(SyntaxNodeDescription node) { - var header = $" internal class {node.ClassName}"; + var classDeclaration = + ClassDeclaration(node.ClassName) + .WithModifiers( + TokenList(Token(SyntaxKind.InternalKeyword))); if (node.BaseClassName != null) { - header += $" : {node.BaseClassName}"; + classDeclaration = classDeclaration + .WithBaseList( + BaseList( + SingletonSeparatedList( + SimpleBaseType(IdentifierName(node.BaseClassName))))); } - var fields = string.Join( - "", - node.Fields.Select(GenerateInternalFieldDeclaration)); - var constructor = GenerateInternalConstructors(node); - var getSlot = GenerateInternalGetSlot(node); - var createRed = GenerateCreateRed(node); - var setDiagnostics = GenerateInternalSetDiagnostics(node); - return - header - + "\n {\n" - + fields + "\n" - + constructor + "\n" - + createRed + "\n" - + setDiagnostics + "\n" - + getSlot + " }\n"; + return classDeclaration + .WithMembers( + List( + node.Fields + .Select(GenerateInternalFieldDeclaration) + .Concat(GenerateInternalConstructors(node)) + .Append(GenerateCreateRed(node)) + .Append(GenerateInternalSetDiagnostics(node)) + .Append(GenerateInternalGetSlot(node)))); } private static string Capitalize(string s) { - return s[0].ToString().ToUpper() + s.Substring(1, s.Length - 1); + return s[0].ToString().ToUpper() + s[1..]; } - private static string GenerateTokenAccessor(SyntaxNodeDescription node, FieldDescription field, int index) + private static MemberDeclarationSyntax GenerateTokenAccessor(SyntaxNodeDescription node, FieldDescription field, int index) { - var header = $" public SyntaxToken {Capitalize(field.FieldName)}\n"; - var text = - $" get {{ return new SyntaxToken(this, (({InternalNamespace}.{node.ClassName})_green)._{field.FieldName}, this.GetChildPosition({index})); }}"; - return header + " {\n" + text + "\n }\n"; - } + return + PropertyDeclaration( + IdentifierName("SyntaxToken"), + Identifier(Capitalize(field.FieldName))) + .WithModifiers( + TokenList( + Token(SyntaxKind.PublicKeyword))) + .WithAccessorList( + AccessorList( + SingletonList( + AccessorDeclaration( + SyntaxKind.GetAccessorDeclaration) + .WithBody( + Block( + SingletonList( + ReturnStatement( + ObjectCreationExpression( + IdentifierName("SyntaxToken")) + .WithArgumentList( + SeveralArguments( + ThisExpression(), + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + ParenthesizedExpression( + CastExpression( + QualifiedName( + GetInternalNamespace(), + IdentifierName(node.ClassName)), + IdentifierName("_green"))), + IdentifierName(field.GetPrivateFieldName())), + InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + ThisExpression(), + IdentifierName("GetChildPosition"))) + .WithArgumentList( + SingleArgument( + LiteralExpression( + SyntaxKind.NumericLiteralExpression, + Literal(index))))))))))))); +} private static bool IsList(string type) { return type.StartsWith("SyntaxList"); } - private static string GenerateNodeAccessor(SyntaxNodeDescription node, FieldDescription field, int index) + private static MemberDeclarationSyntax GenerateNodeAccessor(FieldDescription field, int index) { var type = field.FieldType; if (IsList(type)) @@ -229,17 +483,80 @@ namespace SyntaxGenerator type = "SyntaxNodeOrTokenList"; } - var typeName = type + (field.FieldIsNullable ? "?" : ""); - var header = $" public {typeName} {Capitalize(field.FieldName)}\n {{\n get\n {{\n"; - var defaultReturnStatement = field.FieldIsNullable ? $"return default({type});" : $"throw new System.Exception(\"{field.FieldName} cannot be null\");"; + return + PropertyDeclaration( + field.FieldIsNullable ? (TypeSyntax)NullableType(IdentifierName(type)) : IdentifierName(type), + Identifier(Capitalize(field.FieldName))) + .WithModifiers( + TokenList( + Token(SyntaxKind.PublicKeyword))) + .WithAccessorList( + AccessorList( + SingletonList( + AccessorDeclaration( + SyntaxKind.GetAccessorDeclaration) + .WithBody( + Block( + LocalDeclarationStatement( + VariableDeclaration( + IdentifierName("var")) + .WithVariables( + SingletonSeparatedList( + VariableDeclarator( + Identifier("red")) + .WithInitializer( + EqualsValueClause( + InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + ThisExpression(), + IdentifierName("GetRed"))) + .WithArgumentList( + ArgumentList( + IntersperseWithCommas( + Argument( + field.FieldIsNullable + ? (ExpressionSyntax)MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + ThisExpression(), + IdentifierName(field.GetPrivateFieldName())) + : PostfixUnaryExpression( + SyntaxKind.SuppressNullableWarningExpression, + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + ThisExpression(), + IdentifierName(field.GetPrivateFieldName())))) + .WithRefKindKeyword( + Token(SyntaxKind.RefKeyword)), + Argument( + LiteralExpression( + SyntaxKind.NumericLiteralExpression, + Literal(index))))))))))), + ReturnStatement( + ConditionalExpression( + IsPatternExpression( + IdentifierName("red"), + ConstantPattern( + LiteralExpression( + SyntaxKind.NullLiteralExpression))), - var fieldNameWithPossibleBang = field.FieldIsNullable ? field.FieldName : field.FieldName + "!"; - var text = - $" var red = this.GetRed(ref this._{fieldNameWithPossibleBang}, {index});\n" - + $" if (red != null)\n" - + $" return ({type})red;\n\n" - + $" {defaultReturnStatement}\n"; - return header + text + " }\n }\n"; + field.FieldIsNullable + ? (ExpressionSyntax)LiteralExpression( + SyntaxKind.DefaultLiteralExpression, + Token(SyntaxKind.DefaultKeyword)) + : ThrowExpression( + ObjectCreationExpression( + QualifiedName( + IdentifierName("System"), + IdentifierName("Exception"))) + .WithArgumentList( + SingleArgument( + LiteralExpression( + SyntaxKind.StringLiteralExpression, + Literal($"{field.FieldName} cannot be null."))))), + CastExpression( + IdentifierName(type), + IdentifierName("red"))))))))); } private static string ConvertClassNameToVisitorName(string name) @@ -252,23 +569,56 @@ namespace SyntaxGenerator return "Visit" + name; } - private static string GenerateAccessMethod(SyntaxNodeDescription node) + private static MemberDeclarationSyntax GenerateAccessMethod(SyntaxNodeDescription node) { var visitorName = ConvertClassNameToVisitorName(node.ClassName); Visitors.Add((visitorName, node.ClassName)); - var header = $" public override void Accept(SyntaxVisitor visitor)\n"; - var body = $" visitor.{visitorName}(this);\n"; - return header + " {\n" + body + " }\n"; + return + MethodDeclaration( + PredefinedType( + Token(SyntaxKind.VoidKeyword)), + Identifier("Accept")) + .WithModifiers( + TokenList( + new[]{ + Token(SyntaxKind.PublicKeyword), + Token(SyntaxKind.OverrideKeyword)})) + .WithParameterList( + ParameterList( + SingletonSeparatedList( + Parameter( + Identifier("visitor")) + .WithType( + IdentifierName("SyntaxVisitor"))))) + .WithBody( + Block( + SingletonList( + ExpressionStatement( + InvocationExpression( + MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + IdentifierName("visitor"), + IdentifierName(visitorName))) + .WithArgumentList( + SingleArgument( + ThisExpression())))))); } - private static string GenerateClass(SyntaxNodeDescription node) + private static MemberDeclarationSyntax GenerateClass(SyntaxNodeDescription node) { - var header = $" public class {node.ClassName}"; + var classDeclaration = + ClassDeclaration(node.ClassName) + .WithModifiers( + TokenList( + Token(SyntaxKind.PublicKeyword))); if (node.BaseClassName != null) { - header += $" : {node.BaseClassName}"; + classDeclaration = classDeclaration + .WithBaseList( + BaseList( + SingletonSeparatedList( + SimpleBaseType(IdentifierName(node.BaseClassName))))); } - var tokenSlots = node.Fields .Select((f, i) => (field: f, index: i)) .Where(pair => pair.field.FieldType == SyntaxTokenClassName) @@ -277,135 +627,241 @@ namespace SyntaxGenerator .Select((f, i) => (field: f, index: i)) .Where(pair => pair.field.FieldType != SyntaxTokenClassName) .ToList(); - var fields = string.Join( - "", - nodeSlots.Select(pair => GeneratePrivateFieldDeclaration(pair.field))); - var constructor = GenerateConstructor(node); - var tokenAccessors = - string.Join( - "\n", - tokenSlots.Select(pair => GenerateTokenAccessor(node, pair.field, pair.index))); - var nodeAccessors = - string.Join( - "\n", - nodeSlots.Select(pair => GenerateNodeAccessor(node, pair.field, pair.index))); - var getSlot = GenerateGetSlot(node, nodeSlots); - var access = GenerateAccessMethod(node); - return - header - + "\n {\n" - + fields + "\n" - + constructor + "\n" - + tokenAccessors + "\n" - + nodeAccessors + "\n" - + getSlot + "\n" - + access + "\n" - + " }\n"; + + return classDeclaration + .WithMembers( + List( + nodeSlots + .Select(pair => GeneratePrivateFieldDeclaration(pair.field)) + .Append(GenerateConstructor(node)) + .Concat(tokenSlots.Select(pair => GenerateTokenAccessor(node, pair.field, pair.index))) + .Concat(nodeSlots.Select(pair => GenerateNodeAccessor(pair.field, pair.index))) + .Append(GenerateGetSlot(nodeSlots)) + .Append(GenerateAccessMethod(node)))); } private static string GenerateInternalSyntaxNodeFile(SyntaxDescription syntax) { - var header = $"#nullable enable\nnamespace {InternalNamespace}\n"; - var classes = string.Join( - "\n", - syntax.Nodes.Select(GenerateInternalClass) - ); - return header + "{\n" + classes + "}\n"; + return GenerateInternalSyntaxNodeCompilationUnit(syntax).NormalizeWhitespace().ToFullString(); + } + + private static NameSyntax GetInternalNamespace() + { + return QualifiedName( + IdentifierName("Parser"), + IdentifierName("Internal")); + } + + private static NamespaceDeclarationSyntax GetOuterNamespace() + { + return NamespaceDeclaration( + IdentifierName("Parser")); + } + + private static CompilationUnitSyntax GenerateInternalSyntaxNodeCompilationUnit(SyntaxDescription syntax) + { + return CompilationUnit() + .WithMembers( + SingletonList( + NamespaceDeclaration( + GetInternalNamespace()) + .WithNamespaceKeyword( + Token( + TriviaList( + Trivia( + NullableDirectiveTrivia( + Token(SyntaxKind.EnableKeyword), + true))), + SyntaxKind.NamespaceKeyword, + TriviaList())) + .WithMembers( + List( + syntax.Nodes.Select(GenerateInternalClass))))); } private static string GenerateSyntaxNodeFile(SyntaxDescription syntax) { - var header = $"#nullable enable\nnamespace {OuterNamespace}\n"; - var classes = string.Join( - "\n", - syntax.Nodes.Select(GenerateClass) - ); - return header + "{\n" + classes + "}\n"; + return GenerateSyntaxNodeCompilationUnit(syntax).NormalizeWhitespace().ToFullString(); + } + + private static CompilationUnitSyntax GenerateSyntaxNodeCompilationUnit(SyntaxDescription syntax) + { + return CompilationUnit() + .WithMembers( + SingletonList( + GetOuterNamespace() + .WithNamespaceKeyword( + Token( + TriviaList( + Trivia( + NullableDirectiveTrivia( + Token(SyntaxKind.EnableKeyword), + true))), + SyntaxKind.NamespaceKeyword, + TriviaList())) + .WithMembers( + List( + syntax.Nodes.Select(GenerateClass))))); } private static string FactoryMethodNameFromClassName(string className) { - if (className.EndsWith("Node")) - { - return className.Substring(0, className.Length - 4); - } - else - { - return className; - } + return className.EndsWith("Node") ? className[0..^4] : className; } - private static string FullFieldType(FieldDescription field) + private static TypeSyntax FullFieldType(FieldDescription field) { - return field.FieldIsNullable ? field.FieldType + "?" : field.FieldType; + return field.FieldIsNullable + ? (TypeSyntax)NullableType(IdentifierName(field.FieldType)) + : IdentifierName(field.FieldType); } - private static string GenerateFactoryMethod(SyntaxNodeDescription node) + private static MemberDeclarationSyntax GenerateFactoryMethod(SyntaxNodeDescription node) { - var methodName = FactoryMethodNameFromClassName(node.ClassName); - var header = $" public {node.ClassName} {methodName}"; - var arguments = string.Join( - ", ", - node.Fields.Select(field => $"\n {FullFieldType(field)} {field.FieldName}")); - var constructorParameters = string.Join( - ", ", - node.Fields.Select(field => $"\n {field.FieldName}")); - var returnStatement = - $" return new {node.ClassName}({constructorParameters});\n"; - - return header + "(" + arguments + ")\n {\n" + returnStatement + " }\n"; + return + MethodDeclaration( + IdentifierName(node.ClassName), + Identifier(FactoryMethodNameFromClassName(node.ClassName))) + .WithModifiers( + TokenList( + Token(SyntaxKind.PublicKeyword))) + .WithParameterList( + ParameterList( + IntersperseWithCommas( + node.Fields.Select( + field => Parameter( + Identifier(field.FieldName)) + .WithType(FullFieldType(field)))))) + .WithBody( + Block( + SingletonList( + ReturnStatement( + ObjectCreationExpression( + IdentifierName(node.ClassName)) + .WithArgumentList( + SeveralArguments( + node.Fields.Select( + field => IdentifierName(field.FieldName)))))))); } private static string GenerateSyntaxFactoryFile(SyntaxDescription syntax) { - var header = $"#nullable enable\nnamespace {InternalNamespace}\n{{\n internal partial class SyntaxFactory\n"; - var methods = string.Join( - "\n", - syntax.Nodes.Select(GenerateFactoryMethod) - ); - return header + " {\n" + methods + " }\n}"; + return GenerateSyntaxFactoryCompilationUnit(syntax).NormalizeWhitespace().ToFullString(); } - private static string GenerateVisitor((string visitorMethodName, string className) info) + private static CompilationUnitSyntax GenerateSyntaxFactoryCompilationUnit(SyntaxDescription syntax) { - var header = $" public virtual void {info.visitorMethodName}({info.className} node)\n"; - var body = $" DefaultVisit(node);\n"; - return header + " {\n" + body + " }\n"; + return CompilationUnit() + .WithMembers( + SingletonList( + NamespaceDeclaration( + GetInternalNamespace()) + .WithNamespaceKeyword( + Token( + TriviaList( + Trivia( + NullableDirectiveTrivia( + Token(SyntaxKind.EnableKeyword), + true))), + SyntaxKind.NamespaceKeyword, + TriviaList())) + .WithMembers( + SingletonList( + ClassDeclaration("SyntaxFactory") + .WithModifiers( + TokenList( + Token(SyntaxKind.InternalKeyword), + Token(SyntaxKind.PartialKeyword))) + .WithMembers( + List( + syntax.Nodes.Select(GenerateFactoryMethod))))))); } - private static string GenerateSyntaxVisitorFile(SyntaxDescription syntax) + private static MemberDeclarationSyntax GenerateVisitor((string visitorMethodName, string className) info) { - var header = $"#nullable enable\nnamespace {OuterNamespace}\n{{\n public partial class SyntaxVisitor\n"; - var methods = string.Join( - "\n", - Visitors.Select(GenerateVisitor)); - return header + " {\n" + methods + " }\n};"; + return + MethodDeclaration( + PredefinedType( + Token(SyntaxKind.VoidKeyword)), + Identifier(info.visitorMethodName)) + .WithModifiers( + TokenList( + new[]{ + Token(SyntaxKind.PublicKeyword), + Token(SyntaxKind.VirtualKeyword)})) + .WithParameterList( + ParameterList( + SingletonSeparatedList( + Parameter( + Identifier("node")) + .WithType( + IdentifierName(info.className))))) + .WithBody( + Block( + SingletonList( + ExpressionStatement( + InvocationExpression( + IdentifierName("DefaultVisit")) + .WithArgumentList( + SingleArgument( + IdentifierName("node"))))))); } + private static string GenerateSyntaxVisitorFile() + { + return GenerateSyntaxVisitorCompilationUnit().NormalizeWhitespace().ToFullString(); + } + + private static CompilationUnitSyntax GenerateSyntaxVisitorCompilationUnit() + { + return + CompilationUnit() + .WithMembers( + SingletonList( + GetOuterNamespace() + .WithNamespaceKeyword( + Token( + TriviaList( + Trivia( + NullableDirectiveTrivia( + Token(SyntaxKind.EnableKeyword), + true))), + SyntaxKind.NamespaceKeyword, + TriviaList())) + .WithMembers( + SingletonList( + ClassDeclaration("SyntaxVisitor") + .WithModifiers( + TokenList( + Token(SyntaxKind.PublicKeyword), + Token(SyntaxKind.PartialKeyword))) + .WithMembers( + List( + Visitors.Select(GenerateVisitor))))))); + + } public static void Input() { var serializer = new XmlSerializer(typeof(SyntaxDescription)); - using (var stream = new FileStream("input.xml", FileMode.Open)) + using var stream = new FileStream("input.xml", FileMode.Open); + if (!(serializer.Deserialize(stream) is SyntaxDescription syntax)) { - if (!(serializer.Deserialize(stream) is SyntaxDescription syntax)) - { - Console.WriteLine("Couldn't deserialize syntax."); - return; - } + Console.WriteLine("Couldn't deserialize syntax."); + return; + } - var internalSyntaxNodePath = Path.Combine(_outputPath, "Internal", "SyntaxNode.Generated.cs"); - File.WriteAllText(internalSyntaxNodePath, GenerateInternalSyntaxNodeFile(syntax)); - var internalSyntaxFactoryPath = Path.Combine(_outputPath, "Internal", "SyntaxFactory.Generated.cs"); - File.WriteAllText(internalSyntaxFactoryPath, GenerateSyntaxFactoryFile(syntax)); - var syntaxNodePath = Path.Combine(_outputPath, "SyntaxNode.Generated.cs"); - File.WriteAllText(syntaxNodePath, GenerateSyntaxNodeFile(syntax)); - var syntaxVisitorPath = Path.Combine(_outputPath, "SyntaxVisitor.Generated.cs"); - File.WriteAllText(syntaxVisitorPath, GenerateSyntaxVisitorFile(syntax)); - } + var internalSyntaxNodePath = Path.Combine(_outputPath, "Internal", "SyntaxNode.Generated.cs"); + File.WriteAllText(internalSyntaxNodePath, GenerateInternalSyntaxNodeFile(syntax)); + var internalSyntaxFactoryPath = Path.Combine(_outputPath, "Internal", "SyntaxFactory.Generated.cs"); + File.WriteAllText(internalSyntaxFactoryPath, GenerateSyntaxFactoryFile(syntax)); + var syntaxNodePath = Path.Combine(_outputPath, "SyntaxNode.Generated.cs"); + File.WriteAllText(syntaxNodePath, GenerateSyntaxNodeFile(syntax)); + var syntaxVisitorPath = Path.Combine(_outputPath, "SyntaxVisitor.Generated.cs"); + File.WriteAllText(syntaxVisitorPath, GenerateSyntaxVisitorFile()); } - static void Main(string[] args) + static void Main() { Console.Write("Generating syntax..."); Input(); diff --git a/SyntaxGenerator/SyntaxDescription.cs b/SyntaxGenerator/SyntaxDescription.cs new file mode 100644 index 0000000..409971d --- /dev/null +++ b/SyntaxGenerator/SyntaxDescription.cs @@ -0,0 +1,11 @@ +using System.Xml.Serialization; + +namespace SyntaxGenerator +{ + [XmlRoot(ElementName = "Syntax")] + public class SyntaxDescription + { + [XmlElement(ElementName = "Class")] + public SyntaxNodeDescription[] Nodes { get; set; } + } +} \ No newline at end of file diff --git a/SyntaxGenerator/SyntaxExtensions.cs b/SyntaxGenerator/SyntaxExtensions.cs new file mode 100644 index 0000000..443be0b --- /dev/null +++ b/SyntaxGenerator/SyntaxExtensions.cs @@ -0,0 +1,63 @@ +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using System.Collections.Generic; +using System.Linq; +using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; + +namespace SyntaxGenerator +{ + public static class SyntaxExtensions + { + public static ArgumentListSyntax SingleArgument(ExpressionSyntax expression) + { + return + ArgumentList( + SingletonSeparatedList( + Argument(expression))); + } + + public static ArgumentListSyntax SeveralArguments(IEnumerable expressions) + { + return ArgumentList( + IntersperseWithCommas( + expressions.Select(e => Argument(e)))); + } + + public static ArgumentListSyntax SeveralArguments(params ExpressionSyntax[] expressions) + { + return SeveralArguments((IEnumerable)expressions); + } + + public static IEnumerable IntersperseWithCommas(IEnumerable tokens) + { + var first = true; + foreach (var token in tokens) + { + if (first) + { + yield return token; + first = false; + } + else + { + yield return Token(SyntaxKind.CommaToken); + yield return token; + } + } + } + + public static SeparatedSyntaxList IntersperseWithCommas(IEnumerable tokens) + where TNode : SyntaxNode + { + return SeparatedList( + IntersperseWithCommas(tokens.Select(token => (SyntaxNodeOrToken)token))); + } + + public static SeparatedSyntaxList IntersperseWithCommas(params TNode[] tokens) + where TNode : SyntaxNode + { + return IntersperseWithCommas((IEnumerable)tokens); + } + } +} \ No newline at end of file diff --git a/SyntaxGenerator/SyntaxGenerator.csproj b/SyntaxGenerator/SyntaxGenerator.csproj index 5b8db53..ab61595 100644 --- a/SyntaxGenerator/SyntaxGenerator.csproj +++ b/SyntaxGenerator/SyntaxGenerator.csproj @@ -3,6 +3,9 @@ Exe netcoreapp3.0 + + + PreserveNewest diff --git a/SyntaxGenerator/SyntaxNodeDescription.cs b/SyntaxGenerator/SyntaxNodeDescription.cs index 9f60038..ef102a2 100644 --- a/SyntaxGenerator/SyntaxNodeDescription.cs +++ b/SyntaxGenerator/SyntaxNodeDescription.cs @@ -2,19 +2,14 @@ namespace SyntaxGenerator { - [XmlRoot(ElementName = "Syntax")] - public class SyntaxDescription - { - [XmlElement(ElementName = "Class")] - public SyntaxNodeDescription[] Nodes { get; set; } - } - public class SyntaxNodeDescription { [XmlAttribute("Name")] public string ClassName { get; set; } + [XmlAttribute("BaseClass")] public string BaseClassName { get; set; } + [XmlAttribute("Kind")] public string TokenKindName { get; set; } @@ -27,14 +22,4 @@ namespace SyntaxGenerator private FieldDescription[] _fields = new FieldDescription[0]; } - - public class FieldDescription - { - [XmlAttribute("Type")] - public string FieldType { get; set; } - [XmlAttribute("Name")] - public string FieldName { get; set; } - [XmlAttribute("Nullable")] - public bool FieldIsNullable { get; set; } - } } \ No newline at end of file