#nullable enable namespace Parser.Internal { internal class FileSyntaxNode : SyntaxNode { internal readonly BlockStatementSyntaxNode? _body; internal readonly SyntaxToken _endOfFile; internal FileSyntaxNode(BlockStatementSyntaxNode? body, SyntaxToken endOfFile): base(TokenKind.File) { Slots = 2; this.AdjustWidth(body); _body = body; this.AdjustWidth(endOfFile); _endOfFile = endOfFile; } internal FileSyntaxNode(BlockStatementSyntaxNode? body, SyntaxToken endOfFile, TokenDiagnostic[] diagnostics): base(TokenKind.File, diagnostics) { Slots = 2; this.AdjustWidth(body); _body = body; this.AdjustWidth(endOfFile); _endOfFile = endOfFile; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.FileSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new FileSyntaxNode(_body, _endOfFile, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _body, 1 => _endOfFile, _ => null } ; } } internal class BlockStatementSyntaxNode : StatementSyntaxNode { internal readonly SyntaxList _statements; internal BlockStatementSyntaxNode(SyntaxList statements): base(TokenKind.BlockStatement) { Slots = 1; this.AdjustWidth(statements); _statements = statements; } internal BlockStatementSyntaxNode(SyntaxList statements, TokenDiagnostic[] diagnostics): base(TokenKind.BlockStatement, diagnostics) { Slots = 1; this.AdjustWidth(statements); _statements = statements; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.BlockStatementSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new BlockStatementSyntaxNode(_statements, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _statements, _ => null } ; } } internal class FunctionDeclarationSyntaxNode : StatementSyntaxNode { internal readonly SyntaxToken _functionKeyword; internal readonly FunctionOutputDescriptionSyntaxNode? _outputDescription; internal readonly SyntaxToken _name; internal readonly FunctionInputDescriptionSyntaxNode? _inputDescription; internal readonly SyntaxList _commas; internal readonly StatementSyntaxNode _body; internal readonly EndKeywordSyntaxNode? _endKeyword; internal FunctionDeclarationSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, SyntaxToken name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, StatementSyntaxNode body, EndKeywordSyntaxNode? endKeyword): base(TokenKind.FunctionDeclaration) { Slots = 7; this.AdjustWidth(functionKeyword); _functionKeyword = functionKeyword; this.AdjustWidth(outputDescription); _outputDescription = outputDescription; this.AdjustWidth(name); _name = name; this.AdjustWidth(inputDescription); _inputDescription = inputDescription; this.AdjustWidth(commas); _commas = commas; this.AdjustWidth(body); _body = body; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } internal FunctionDeclarationSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, SyntaxToken name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, StatementSyntaxNode body, EndKeywordSyntaxNode? endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.FunctionDeclaration, diagnostics) { Slots = 7; this.AdjustWidth(functionKeyword); _functionKeyword = functionKeyword; this.AdjustWidth(outputDescription); _outputDescription = outputDescription; this.AdjustWidth(name); _name = name; this.AdjustWidth(inputDescription); _inputDescription = inputDescription; this.AdjustWidth(commas); _commas = commas; this.AdjustWidth(body); _body = body; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.FunctionDeclarationSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new FunctionDeclarationSyntaxNode(_functionKeyword, _outputDescription, _name, _inputDescription, _commas, _body, _endKeyword, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _functionKeyword, 1 => _outputDescription, 2 => _name, 3 => _inputDescription, 4 => _commas, 5 => _body, 6 => _endKeyword, _ => null } ; } } internal class FunctionOutputDescriptionSyntaxNode : SyntaxNode { internal readonly SyntaxList _outputList; internal readonly SyntaxToken _assignmentSign; internal FunctionOutputDescriptionSyntaxNode(SyntaxList outputList, SyntaxToken assignmentSign): base(TokenKind.FunctionOutputDescription) { Slots = 2; this.AdjustWidth(outputList); _outputList = outputList; this.AdjustWidth(assignmentSign); _assignmentSign = assignmentSign; } internal FunctionOutputDescriptionSyntaxNode(SyntaxList outputList, SyntaxToken assignmentSign, TokenDiagnostic[] diagnostics): base(TokenKind.FunctionOutputDescription, diagnostics) { Slots = 2; this.AdjustWidth(outputList); _outputList = outputList; this.AdjustWidth(assignmentSign); _assignmentSign = assignmentSign; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.FunctionOutputDescriptionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new FunctionOutputDescriptionSyntaxNode(_outputList, _assignmentSign, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _outputList, 1 => _assignmentSign, _ => null } ; } } internal class FunctionInputDescriptionSyntaxNode : SyntaxNode { internal readonly SyntaxToken _openingBracket; internal readonly SyntaxList _parameterList; internal readonly SyntaxToken _closingBracket; internal FunctionInputDescriptionSyntaxNode(SyntaxToken openingBracket, SyntaxList parameterList, SyntaxToken closingBracket): base(TokenKind.FunctionInputDescription) { Slots = 3; this.AdjustWidth(openingBracket); _openingBracket = openingBracket; this.AdjustWidth(parameterList); _parameterList = parameterList; this.AdjustWidth(closingBracket); _closingBracket = closingBracket; } internal FunctionInputDescriptionSyntaxNode(SyntaxToken openingBracket, SyntaxList parameterList, SyntaxToken closingBracket, TokenDiagnostic[] diagnostics): base(TokenKind.FunctionInputDescription, diagnostics) { Slots = 3; this.AdjustWidth(openingBracket); _openingBracket = openingBracket; this.AdjustWidth(parameterList); _parameterList = parameterList; this.AdjustWidth(closingBracket); _closingBracket = closingBracket; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.FunctionInputDescriptionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new FunctionInputDescriptionSyntaxNode(_openingBracket, _parameterList, _closingBracket, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _openingBracket, 1 => _parameterList, 2 => _closingBracket, _ => null } ; } } internal class SwitchStatementSyntaxNode : StatementSyntaxNode { internal readonly SyntaxToken _switchKeyword; internal readonly ExpressionSyntaxNode _switchExpression; 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) { Slots = 5; this.AdjustWidth(switchKeyword); _switchKeyword = switchKeyword; this.AdjustWidth(switchExpression); _switchExpression = switchExpression; this.AdjustWidth(optionalCommas); _optionalCommas = optionalCommas; this.AdjustWidth(cases); _cases = cases; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } internal SwitchStatementSyntaxNode(SyntaxToken switchKeyword, ExpressionSyntaxNode switchExpression, SyntaxList optionalCommas, SyntaxList cases, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.SwitchStatement, diagnostics) { Slots = 5; this.AdjustWidth(switchKeyword); _switchKeyword = switchKeyword; this.AdjustWidth(switchExpression); _switchExpression = switchExpression; this.AdjustWidth(optionalCommas); _optionalCommas = optionalCommas; this.AdjustWidth(cases); _cases = cases; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.SwitchStatementSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new SwitchStatementSyntaxNode(_switchKeyword, _switchExpression, _optionalCommas, _cases, _endKeyword, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _switchKeyword, 1 => _switchExpression, 2 => _optionalCommas, 3 => _cases, 4 => _endKeyword, _ => null } ; } } internal class SwitchCaseSyntaxNode : SyntaxNode { internal readonly SyntaxToken _caseKeyword; internal readonly ExpressionSyntaxNode _caseIdentifier; internal readonly SyntaxList _optionalCommas; internal readonly StatementSyntaxNode _body; internal SwitchCaseSyntaxNode(SyntaxToken caseKeyword, ExpressionSyntaxNode caseIdentifier, SyntaxList optionalCommas, StatementSyntaxNode body): base(TokenKind.SwitchCase) { Slots = 4; this.AdjustWidth(caseKeyword); _caseKeyword = caseKeyword; this.AdjustWidth(caseIdentifier); _caseIdentifier = caseIdentifier; this.AdjustWidth(optionalCommas); _optionalCommas = optionalCommas; this.AdjustWidth(body); _body = body; } internal SwitchCaseSyntaxNode(SyntaxToken caseKeyword, ExpressionSyntaxNode caseIdentifier, SyntaxList optionalCommas, StatementSyntaxNode body, TokenDiagnostic[] diagnostics): base(TokenKind.SwitchCase, diagnostics) { Slots = 4; this.AdjustWidth(caseKeyword); _caseKeyword = caseKeyword; this.AdjustWidth(caseIdentifier); _caseIdentifier = caseIdentifier; this.AdjustWidth(optionalCommas); _optionalCommas = optionalCommas; this.AdjustWidth(body); _body = body; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.SwitchCaseSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new SwitchCaseSyntaxNode(_caseKeyword, _caseIdentifier, _optionalCommas, _body, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _caseKeyword, 1 => _caseIdentifier, 2 => _optionalCommas, 3 => _body, _ => null } ; } } internal class WhileStatementSyntaxNode : StatementSyntaxNode { internal readonly SyntaxToken _whileKeyword; internal readonly ExpressionSyntaxNode _condition; internal readonly SyntaxList _optionalCommas; internal readonly StatementSyntaxNode _body; internal readonly SyntaxToken _endKeyword; internal WhileStatementSyntaxNode(SyntaxToken whileKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, StatementSyntaxNode body, SyntaxToken endKeyword): base(TokenKind.WhileStatement) { Slots = 5; this.AdjustWidth(whileKeyword); _whileKeyword = whileKeyword; this.AdjustWidth(condition); _condition = condition; this.AdjustWidth(optionalCommas); _optionalCommas = optionalCommas; this.AdjustWidth(body); _body = body; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } internal WhileStatementSyntaxNode(SyntaxToken whileKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, StatementSyntaxNode body, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.WhileStatement, diagnostics) { Slots = 5; this.AdjustWidth(whileKeyword); _whileKeyword = whileKeyword; this.AdjustWidth(condition); _condition = condition; this.AdjustWidth(optionalCommas); _optionalCommas = optionalCommas; this.AdjustWidth(body); _body = body; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.WhileStatementSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new WhileStatementSyntaxNode(_whileKeyword, _condition, _optionalCommas, _body, _endKeyword, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _whileKeyword, 1 => _condition, 2 => _optionalCommas, 3 => _body, 4 => _endKeyword, _ => null } ; } } internal class ElseifClause : SyntaxNode { internal readonly SyntaxToken _elseifKeyword; internal readonly ExpressionSyntaxNode _condition; internal readonly SyntaxList _optionalCommas; internal readonly StatementSyntaxNode _body; internal ElseifClause(SyntaxToken elseifKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, StatementSyntaxNode body): base(TokenKind.ElseifClause) { Slots = 4; this.AdjustWidth(elseifKeyword); _elseifKeyword = elseifKeyword; this.AdjustWidth(condition); _condition = condition; this.AdjustWidth(optionalCommas); _optionalCommas = optionalCommas; this.AdjustWidth(body); _body = body; } internal ElseifClause(SyntaxToken elseifKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, StatementSyntaxNode body, TokenDiagnostic[] diagnostics): base(TokenKind.ElseifClause, diagnostics) { Slots = 4; this.AdjustWidth(elseifKeyword); _elseifKeyword = elseifKeyword; this.AdjustWidth(condition); _condition = condition; this.AdjustWidth(optionalCommas); _optionalCommas = optionalCommas; this.AdjustWidth(body); _body = body; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.ElseifClause(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new ElseifClause(_elseifKeyword, _condition, _optionalCommas, _body, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _elseifKeyword, 1 => _condition, 2 => _optionalCommas, 3 => _body, _ => null } ; } } internal class ElseClause : SyntaxNode { internal readonly SyntaxToken _elseKeyword; internal readonly StatementSyntaxNode _body; internal ElseClause(SyntaxToken elseKeyword, StatementSyntaxNode body): base(TokenKind.ElseClause) { Slots = 2; this.AdjustWidth(elseKeyword); _elseKeyword = elseKeyword; this.AdjustWidth(body); _body = body; } internal ElseClause(SyntaxToken elseKeyword, StatementSyntaxNode body, TokenDiagnostic[] diagnostics): base(TokenKind.ElseClause, diagnostics) { Slots = 2; this.AdjustWidth(elseKeyword); _elseKeyword = elseKeyword; this.AdjustWidth(body); _body = body; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.ElseClause(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new ElseClause(_elseKeyword, _body, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _elseKeyword, 1 => _body, _ => null } ; } } internal class IfStatementSyntaxNode : StatementSyntaxNode { internal readonly SyntaxToken _ifKeyword; internal readonly ExpressionSyntaxNode _condition; internal readonly SyntaxList _optionalCommas; internal readonly StatementSyntaxNode _body; internal readonly SyntaxList _elseifClauses; internal readonly ElseClause? _elseClause; internal readonly SyntaxToken _endKeyword; internal IfStatementSyntaxNode(SyntaxToken ifKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, StatementSyntaxNode body, SyntaxList elseifClauses, ElseClause? elseClause, SyntaxToken endKeyword): base(TokenKind.IfStatement) { Slots = 7; this.AdjustWidth(ifKeyword); _ifKeyword = ifKeyword; this.AdjustWidth(condition); _condition = condition; this.AdjustWidth(optionalCommas); _optionalCommas = optionalCommas; this.AdjustWidth(body); _body = body; this.AdjustWidth(elseifClauses); _elseifClauses = elseifClauses; this.AdjustWidth(elseClause); _elseClause = elseClause; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } internal IfStatementSyntaxNode(SyntaxToken ifKeyword, ExpressionSyntaxNode condition, SyntaxList optionalCommas, StatementSyntaxNode body, SyntaxList elseifClauses, ElseClause? elseClause, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.IfStatement, diagnostics) { Slots = 7; this.AdjustWidth(ifKeyword); _ifKeyword = ifKeyword; this.AdjustWidth(condition); _condition = condition; this.AdjustWidth(optionalCommas); _optionalCommas = optionalCommas; this.AdjustWidth(body); _body = body; this.AdjustWidth(elseifClauses); _elseifClauses = elseifClauses; this.AdjustWidth(elseClause); _elseClause = elseClause; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.IfStatementSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new IfStatementSyntaxNode(_ifKeyword, _condition, _optionalCommas, _body, _elseifClauses, _elseClause, _endKeyword, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _ifKeyword, 1 => _condition, 2 => _optionalCommas, 3 => _body, 4 => _elseifClauses, 5 => _elseClause, 6 => _endKeyword, _ => null } ; } } internal class ForStatementSyntaxNode : StatementSyntaxNode { internal readonly SyntaxToken _forKeyword; internal readonly AssignmentExpressionSyntaxNode _assignment; internal readonly SyntaxList _optionalCommas; internal readonly StatementSyntaxNode _body; internal readonly SyntaxToken _endKeyword; internal ForStatementSyntaxNode(SyntaxToken forKeyword, AssignmentExpressionSyntaxNode assignment, SyntaxList optionalCommas, StatementSyntaxNode body, SyntaxToken endKeyword): base(TokenKind.ForStatement) { Slots = 5; this.AdjustWidth(forKeyword); _forKeyword = forKeyword; this.AdjustWidth(assignment); _assignment = assignment; this.AdjustWidth(optionalCommas); _optionalCommas = optionalCommas; this.AdjustWidth(body); _body = body; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } internal ForStatementSyntaxNode(SyntaxToken forKeyword, AssignmentExpressionSyntaxNode assignment, SyntaxList optionalCommas, StatementSyntaxNode body, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.ForStatement, diagnostics) { Slots = 5; this.AdjustWidth(forKeyword); _forKeyword = forKeyword; this.AdjustWidth(assignment); _assignment = assignment; this.AdjustWidth(optionalCommas); _optionalCommas = optionalCommas; this.AdjustWidth(body); _body = body; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.ForStatementSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new ForStatementSyntaxNode(_forKeyword, _assignment, _optionalCommas, _body, _endKeyword, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _forKeyword, 1 => _assignment, 2 => _optionalCommas, 3 => _body, 4 => _endKeyword, _ => null } ; } } internal class AssignmentExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly ExpressionSyntaxNode _lhs; internal readonly SyntaxToken _assignmentSign; internal readonly ExpressionSyntaxNode _rhs; internal AssignmentExpressionSyntaxNode(ExpressionSyntaxNode lhs, SyntaxToken assignmentSign, ExpressionSyntaxNode rhs): base(TokenKind.AssignmentExpression) { Slots = 3; this.AdjustWidth(lhs); _lhs = lhs; this.AdjustWidth(assignmentSign); _assignmentSign = assignmentSign; this.AdjustWidth(rhs); _rhs = rhs; } internal AssignmentExpressionSyntaxNode(ExpressionSyntaxNode lhs, SyntaxToken assignmentSign, ExpressionSyntaxNode rhs, TokenDiagnostic[] diagnostics): base(TokenKind.AssignmentExpression, diagnostics) { Slots = 3; this.AdjustWidth(lhs); _lhs = lhs; this.AdjustWidth(assignmentSign); _assignmentSign = assignmentSign; this.AdjustWidth(rhs); _rhs = rhs; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.AssignmentExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new AssignmentExpressionSyntaxNode(_lhs, _assignmentSign, _rhs, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _lhs, 1 => _assignmentSign, 2 => _rhs, _ => null } ; } } internal class CatchClauseSyntaxNode : SyntaxNode { internal readonly SyntaxToken _catchKeyword; internal readonly SyntaxList _catchBody; internal CatchClauseSyntaxNode(SyntaxToken catchKeyword, SyntaxList catchBody): base(TokenKind.CatchClause) { Slots = 2; this.AdjustWidth(catchKeyword); _catchKeyword = catchKeyword; this.AdjustWidth(catchBody); _catchBody = catchBody; } internal CatchClauseSyntaxNode(SyntaxToken catchKeyword, SyntaxList catchBody, TokenDiagnostic[] diagnostics): base(TokenKind.CatchClause, diagnostics) { Slots = 2; this.AdjustWidth(catchKeyword); _catchKeyword = catchKeyword; this.AdjustWidth(catchBody); _catchBody = catchBody; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.CatchClauseSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new CatchClauseSyntaxNode(_catchKeyword, _catchBody, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _catchKeyword, 1 => _catchBody, _ => null } ; } } internal class TryCatchStatementSyntaxNode : StatementSyntaxNode { internal readonly SyntaxToken _tryKeyword; internal readonly StatementSyntaxNode _tryBody; internal readonly CatchClauseSyntaxNode? _catchClause; internal readonly SyntaxToken _endKeyword; internal TryCatchStatementSyntaxNode(SyntaxToken tryKeyword, StatementSyntaxNode tryBody, CatchClauseSyntaxNode? catchClause, SyntaxToken endKeyword): base(TokenKind.TryCatchStatement) { Slots = 4; this.AdjustWidth(tryKeyword); _tryKeyword = tryKeyword; this.AdjustWidth(tryBody); _tryBody = tryBody; this.AdjustWidth(catchClause); _catchClause = catchClause; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } internal TryCatchStatementSyntaxNode(SyntaxToken tryKeyword, StatementSyntaxNode tryBody, CatchClauseSyntaxNode? catchClause, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.TryCatchStatement, diagnostics) { Slots = 4; this.AdjustWidth(tryKeyword); _tryKeyword = tryKeyword; this.AdjustWidth(tryBody); _tryBody = tryBody; this.AdjustWidth(catchClause); _catchClause = catchClause; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.TryCatchStatementSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new TryCatchStatementSyntaxNode(_tryKeyword, _tryBody, _catchClause, _endKeyword, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _tryKeyword, 1 => _tryBody, 2 => _catchClause, 3 => _endKeyword, _ => null } ; } } internal class ExpressionStatementSyntaxNode : StatementSyntaxNode { internal readonly ExpressionSyntaxNode _expression; internal readonly TrailingSemicolonSyntaxNode? _semicolon; internal ExpressionStatementSyntaxNode(ExpressionSyntaxNode expression, TrailingSemicolonSyntaxNode? semicolon): base(TokenKind.ExpressionStatement) { Slots = 2; this.AdjustWidth(expression); _expression = expression; this.AdjustWidth(semicolon); _semicolon = semicolon; } internal ExpressionStatementSyntaxNode(ExpressionSyntaxNode expression, TrailingSemicolonSyntaxNode? semicolon, TokenDiagnostic[] diagnostics): base(TokenKind.ExpressionStatement, diagnostics) { Slots = 2; this.AdjustWidth(expression); _expression = expression; this.AdjustWidth(semicolon); _semicolon = semicolon; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.ExpressionStatementSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new ExpressionStatementSyntaxNode(_expression, _semicolon, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _expression, 1 => _semicolon, _ => null } ; } } internal class TrailingSemicolonSyntaxNode : SyntaxNode { internal readonly SyntaxToken _semicolon; internal TrailingSemicolonSyntaxNode(SyntaxToken semicolon): base(TokenKind.TrailingSemicolon) { Slots = 1; this.AdjustWidth(semicolon); _semicolon = semicolon; } internal TrailingSemicolonSyntaxNode(SyntaxToken semicolon, TokenDiagnostic[] diagnostics): base(TokenKind.TrailingSemicolon, diagnostics) { Slots = 1; this.AdjustWidth(semicolon); _semicolon = semicolon; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.TrailingSemicolonSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new TrailingSemicolonSyntaxNode(_semicolon, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _semicolon, _ => null } ; } } internal class EmptyStatementSyntaxNode : StatementSyntaxNode { internal readonly SyntaxToken _semicolon; internal EmptyStatementSyntaxNode(SyntaxToken semicolon): base(TokenKind.EmptyStatement) { Slots = 1; this.AdjustWidth(semicolon); _semicolon = semicolon; } internal EmptyStatementSyntaxNode(SyntaxToken semicolon, TokenDiagnostic[] diagnostics): base(TokenKind.EmptyStatement, diagnostics) { Slots = 1; this.AdjustWidth(semicolon); _semicolon = semicolon; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.EmptyStatementSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new EmptyStatementSyntaxNode(_semicolon, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _semicolon, _ => null } ; } } internal class EmptyExpressionSyntaxNode : ExpressionSyntaxNode { internal EmptyExpressionSyntaxNode(): base(TokenKind.EmptyExpression) { Slots = 0; } internal EmptyExpressionSyntaxNode(TokenDiagnostic[] diagnostics): base(TokenKind.EmptyExpression, diagnostics) { Slots = 0; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.EmptyExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new EmptyExpressionSyntaxNode(diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { _ => null } ; } } internal class UnaryPrefixOperationExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _operation; internal readonly ExpressionSyntaxNode _operand; internal UnaryPrefixOperationExpressionSyntaxNode(SyntaxToken operation, ExpressionSyntaxNode operand): base(TokenKind.UnaryPrefixOperationExpression) { Slots = 2; this.AdjustWidth(operation); _operation = operation; this.AdjustWidth(operand); _operand = operand; } internal UnaryPrefixOperationExpressionSyntaxNode(SyntaxToken operation, ExpressionSyntaxNode operand, TokenDiagnostic[] diagnostics): base(TokenKind.UnaryPrefixOperationExpression, diagnostics) { Slots = 2; this.AdjustWidth(operation); _operation = operation; this.AdjustWidth(operand); _operand = operand; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.UnaryPrefixOperationExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new UnaryPrefixOperationExpressionSyntaxNode(_operation, _operand, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _operation, 1 => _operand, _ => null } ; } } internal class CompoundNameExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxList _nodes; internal CompoundNameExpressionSyntaxNode(SyntaxList nodes): base(TokenKind.CompoundNameExpression) { Slots = 1; this.AdjustWidth(nodes); _nodes = nodes; } internal CompoundNameExpressionSyntaxNode(SyntaxList nodes, TokenDiagnostic[] diagnostics): base(TokenKind.CompoundNameExpression, diagnostics) { Slots = 1; this.AdjustWidth(nodes); _nodes = nodes; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.CompoundNameExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new CompoundNameExpressionSyntaxNode(_nodes, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _nodes, _ => null } ; } } internal class NamedFunctionHandleExpressionSyntaxNode : FunctionHandleExpressionSyntaxNode { internal readonly SyntaxToken _atSign; internal readonly CompoundNameExpressionSyntaxNode _functionName; internal NamedFunctionHandleExpressionSyntaxNode(SyntaxToken atSign, CompoundNameExpressionSyntaxNode functionName): base(TokenKind.NamedFunctionHandleExpression) { Slots = 2; this.AdjustWidth(atSign); _atSign = atSign; this.AdjustWidth(functionName); _functionName = functionName; } internal NamedFunctionHandleExpressionSyntaxNode(SyntaxToken atSign, CompoundNameExpressionSyntaxNode functionName, TokenDiagnostic[] diagnostics): base(TokenKind.NamedFunctionHandleExpression, diagnostics) { Slots = 2; this.AdjustWidth(atSign); _atSign = atSign; this.AdjustWidth(functionName); _functionName = functionName; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.NamedFunctionHandleExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new NamedFunctionHandleExpressionSyntaxNode(_atSign, _functionName, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _atSign, 1 => _functionName, _ => null } ; } } internal class LambdaExpressionSyntaxNode : FunctionHandleExpressionSyntaxNode { internal readonly SyntaxToken _atSign; internal readonly FunctionInputDescriptionSyntaxNode _input; internal readonly ExpressionSyntaxNode _body; internal LambdaExpressionSyntaxNode(SyntaxToken atSign, FunctionInputDescriptionSyntaxNode input, ExpressionSyntaxNode body): base(TokenKind.LambdaExpression) { Slots = 3; this.AdjustWidth(atSign); _atSign = atSign; this.AdjustWidth(input); _input = input; this.AdjustWidth(body); _body = body; } internal LambdaExpressionSyntaxNode(SyntaxToken atSign, FunctionInputDescriptionSyntaxNode input, ExpressionSyntaxNode body, TokenDiagnostic[] diagnostics): base(TokenKind.LambdaExpression, diagnostics) { Slots = 3; this.AdjustWidth(atSign); _atSign = atSign; this.AdjustWidth(input); _input = input; this.AdjustWidth(body); _body = body; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.LambdaExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new LambdaExpressionSyntaxNode(_atSign, _input, _body, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _atSign, 1 => _input, 2 => _body, _ => null } ; } } internal class BinaryOperationExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly ExpressionSyntaxNode _lhs; internal readonly SyntaxToken _operation; internal readonly ExpressionSyntaxNode _rhs; internal BinaryOperationExpressionSyntaxNode(ExpressionSyntaxNode lhs, SyntaxToken operation, ExpressionSyntaxNode rhs): base(TokenKind.BinaryOperationExpression) { Slots = 3; this.AdjustWidth(lhs); _lhs = lhs; this.AdjustWidth(operation); _operation = operation; this.AdjustWidth(rhs); _rhs = rhs; } internal BinaryOperationExpressionSyntaxNode(ExpressionSyntaxNode lhs, SyntaxToken operation, ExpressionSyntaxNode rhs, TokenDiagnostic[] diagnostics): base(TokenKind.BinaryOperationExpression, diagnostics) { Slots = 3; this.AdjustWidth(lhs); _lhs = lhs; this.AdjustWidth(operation); _operation = operation; this.AdjustWidth(rhs); _rhs = rhs; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.BinaryOperationExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new BinaryOperationExpressionSyntaxNode(_lhs, _operation, _rhs, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _lhs, 1 => _operation, 2 => _rhs, _ => null } ; } } internal class IdentifierNameExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _name; internal IdentifierNameExpressionSyntaxNode(SyntaxToken name): base(TokenKind.IdentifierNameExpression) { Slots = 1; this.AdjustWidth(name); _name = name; } internal IdentifierNameExpressionSyntaxNode(SyntaxToken name, TokenDiagnostic[] diagnostics): base(TokenKind.IdentifierNameExpression, diagnostics) { Slots = 1; this.AdjustWidth(name); _name = name; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.IdentifierNameExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new IdentifierNameExpressionSyntaxNode(_name, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _name, _ => null } ; } } internal class NumberLiteralExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _number; internal NumberLiteralExpressionSyntaxNode(SyntaxToken number): base(TokenKind.NumberLiteralExpression) { Slots = 1; this.AdjustWidth(number); _number = number; } internal NumberLiteralExpressionSyntaxNode(SyntaxToken number, TokenDiagnostic[] diagnostics): base(TokenKind.NumberLiteralExpression, diagnostics) { Slots = 1; this.AdjustWidth(number); _number = number; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.NumberLiteralExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new NumberLiteralExpressionSyntaxNode(_number, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _number, _ => null } ; } } internal class StringLiteralExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _stringToken; internal StringLiteralExpressionSyntaxNode(SyntaxToken stringToken): base(TokenKind.StringLiteralExpression) { Slots = 1; this.AdjustWidth(stringToken); _stringToken = stringToken; } internal StringLiteralExpressionSyntaxNode(SyntaxToken stringToken, TokenDiagnostic[] diagnostics): base(TokenKind.StringLiteralExpression, diagnostics) { Slots = 1; this.AdjustWidth(stringToken); _stringToken = stringToken; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.StringLiteralExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new StringLiteralExpressionSyntaxNode(_stringToken, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _stringToken, _ => null } ; } } internal class DoubleQuotedStringLiteralExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _stringToken; internal DoubleQuotedStringLiteralExpressionSyntaxNode(SyntaxToken stringToken): base(TokenKind.DoubleQuotedStringLiteralExpression) { Slots = 1; this.AdjustWidth(stringToken); _stringToken = stringToken; } internal DoubleQuotedStringLiteralExpressionSyntaxNode(SyntaxToken stringToken, TokenDiagnostic[] diagnostics): base(TokenKind.DoubleQuotedStringLiteralExpression, diagnostics) { Slots = 1; this.AdjustWidth(stringToken); _stringToken = stringToken; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.DoubleQuotedStringLiteralExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new DoubleQuotedStringLiteralExpressionSyntaxNode(_stringToken, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _stringToken, _ => null } ; } } internal class UnquotedStringLiteralExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _stringToken; internal UnquotedStringLiteralExpressionSyntaxNode(SyntaxToken stringToken): base(TokenKind.UnquotedStringLiteralExpression) { Slots = 1; this.AdjustWidth(stringToken); _stringToken = stringToken; } internal UnquotedStringLiteralExpressionSyntaxNode(SyntaxToken stringToken, TokenDiagnostic[] diagnostics): base(TokenKind.UnquotedStringLiteralExpression, diagnostics) { Slots = 1; this.AdjustWidth(stringToken); _stringToken = stringToken; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.UnquotedStringLiteralExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new UnquotedStringLiteralExpressionSyntaxNode(_stringToken, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _stringToken, _ => null } ; } } internal class ArrayLiteralExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _openingSquareBracket; internal readonly SyntaxList _nodes; internal readonly SyntaxToken _closingSquareBracket; internal ArrayLiteralExpressionSyntaxNode(SyntaxToken openingSquareBracket, SyntaxList nodes, SyntaxToken closingSquareBracket): base(TokenKind.ArrayLiteralExpression) { Slots = 3; this.AdjustWidth(openingSquareBracket); _openingSquareBracket = openingSquareBracket; this.AdjustWidth(nodes); _nodes = nodes; this.AdjustWidth(closingSquareBracket); _closingSquareBracket = closingSquareBracket; } internal ArrayLiteralExpressionSyntaxNode(SyntaxToken openingSquareBracket, SyntaxList nodes, SyntaxToken closingSquareBracket, TokenDiagnostic[] diagnostics): base(TokenKind.ArrayLiteralExpression, diagnostics) { Slots = 3; this.AdjustWidth(openingSquareBracket); _openingSquareBracket = openingSquareBracket; this.AdjustWidth(nodes); _nodes = nodes; this.AdjustWidth(closingSquareBracket); _closingSquareBracket = closingSquareBracket; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.ArrayLiteralExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new ArrayLiteralExpressionSyntaxNode(_openingSquareBracket, _nodes, _closingSquareBracket, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _openingSquareBracket, 1 => _nodes, 2 => _closingSquareBracket, _ => null } ; } } internal class CellArrayLiteralExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _openingBrace; internal readonly SyntaxList _nodes; internal readonly SyntaxToken _closingBrace; internal CellArrayLiteralExpressionSyntaxNode(SyntaxToken openingBrace, SyntaxList nodes, SyntaxToken closingBrace): base(TokenKind.CellArrayLiteralExpression) { Slots = 3; this.AdjustWidth(openingBrace); _openingBrace = openingBrace; this.AdjustWidth(nodes); _nodes = nodes; this.AdjustWidth(closingBrace); _closingBrace = closingBrace; } internal CellArrayLiteralExpressionSyntaxNode(SyntaxToken openingBrace, SyntaxList nodes, SyntaxToken closingBrace, TokenDiagnostic[] diagnostics): base(TokenKind.CellArrayLiteralExpression, diagnostics) { Slots = 3; this.AdjustWidth(openingBrace); _openingBrace = openingBrace; this.AdjustWidth(nodes); _nodes = nodes; this.AdjustWidth(closingBrace); _closingBrace = closingBrace; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.CellArrayLiteralExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new CellArrayLiteralExpressionSyntaxNode(_openingBrace, _nodes, _closingBrace, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _openingBrace, 1 => _nodes, 2 => _closingBrace, _ => null } ; } } internal class ParenthesizedExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _openingBracket; internal readonly ExpressionSyntaxNode _expression; internal readonly SyntaxToken _closingBracket; internal ParenthesizedExpressionSyntaxNode(SyntaxToken openingBracket, ExpressionSyntaxNode expression, SyntaxToken closingBracket): base(TokenKind.ParenthesizedExpression) { Slots = 3; this.AdjustWidth(openingBracket); _openingBracket = openingBracket; this.AdjustWidth(expression); _expression = expression; this.AdjustWidth(closingBracket); _closingBracket = closingBracket; } internal ParenthesizedExpressionSyntaxNode(SyntaxToken openingBracket, ExpressionSyntaxNode expression, SyntaxToken closingBracket, TokenDiagnostic[] diagnostics): base(TokenKind.ParenthesizedExpression, diagnostics) { Slots = 3; this.AdjustWidth(openingBracket); _openingBracket = openingBracket; this.AdjustWidth(expression); _expression = expression; this.AdjustWidth(closingBracket); _closingBracket = closingBracket; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.ParenthesizedExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new ParenthesizedExpressionSyntaxNode(_openingBracket, _expression, _closingBracket, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _openingBracket, 1 => _expression, 2 => _closingBracket, _ => null } ; } } internal class CellArrayElementAccessExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly ExpressionSyntaxNode _expression; internal readonly SyntaxToken _openingBrace; internal readonly SyntaxList _nodes; internal readonly SyntaxToken _closingBrace; internal CellArrayElementAccessExpressionSyntaxNode(ExpressionSyntaxNode expression, SyntaxToken openingBrace, SyntaxList nodes, SyntaxToken closingBrace): base(TokenKind.CellArrayElementAccessExpression) { Slots = 4; this.AdjustWidth(expression); _expression = expression; this.AdjustWidth(openingBrace); _openingBrace = openingBrace; this.AdjustWidth(nodes); _nodes = nodes; this.AdjustWidth(closingBrace); _closingBrace = closingBrace; } internal CellArrayElementAccessExpressionSyntaxNode(ExpressionSyntaxNode expression, SyntaxToken openingBrace, SyntaxList nodes, SyntaxToken closingBrace, TokenDiagnostic[] diagnostics): base(TokenKind.CellArrayElementAccessExpression, diagnostics) { Slots = 4; this.AdjustWidth(expression); _expression = expression; this.AdjustWidth(openingBrace); _openingBrace = openingBrace; this.AdjustWidth(nodes); _nodes = nodes; this.AdjustWidth(closingBrace); _closingBrace = closingBrace; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.CellArrayElementAccessExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new CellArrayElementAccessExpressionSyntaxNode(_expression, _openingBrace, _nodes, _closingBrace, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _expression, 1 => _openingBrace, 2 => _nodes, 3 => _closingBrace, _ => null } ; } } internal class FunctionCallExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly ExpressionSyntaxNode _functionName; internal readonly SyntaxToken _openingBracket; internal readonly SyntaxList _nodes; internal readonly SyntaxToken _closingBracket; internal FunctionCallExpressionSyntaxNode(ExpressionSyntaxNode functionName, SyntaxToken openingBracket, SyntaxList nodes, SyntaxToken closingBracket): base(TokenKind.FunctionCallExpression) { Slots = 4; this.AdjustWidth(functionName); _functionName = functionName; this.AdjustWidth(openingBracket); _openingBracket = openingBracket; this.AdjustWidth(nodes); _nodes = nodes; this.AdjustWidth(closingBracket); _closingBracket = closingBracket; } internal FunctionCallExpressionSyntaxNode(ExpressionSyntaxNode functionName, SyntaxToken openingBracket, SyntaxList nodes, SyntaxToken closingBracket, TokenDiagnostic[] diagnostics): base(TokenKind.FunctionCallExpression, diagnostics) { Slots = 4; this.AdjustWidth(functionName); _functionName = functionName; this.AdjustWidth(openingBracket); _openingBracket = openingBracket; this.AdjustWidth(nodes); _nodes = nodes; this.AdjustWidth(closingBracket); _closingBracket = closingBracket; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.FunctionCallExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new FunctionCallExpressionSyntaxNode(_functionName, _openingBracket, _nodes, _closingBracket, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _functionName, 1 => _openingBracket, 2 => _nodes, 3 => _closingBracket, _ => null } ; } } internal class MemberAccessExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxNode _leftOperand; internal readonly SyntaxToken _dot; internal readonly SyntaxNode _rightOperand; internal MemberAccessExpressionSyntaxNode(SyntaxNode leftOperand, SyntaxToken dot, SyntaxNode rightOperand): base(TokenKind.MemberAccessExpression) { Slots = 3; this.AdjustWidth(leftOperand); _leftOperand = leftOperand; this.AdjustWidth(dot); _dot = dot; this.AdjustWidth(rightOperand); _rightOperand = rightOperand; } internal MemberAccessExpressionSyntaxNode(SyntaxNode leftOperand, SyntaxToken dot, SyntaxNode rightOperand, TokenDiagnostic[] diagnostics): base(TokenKind.MemberAccessExpression, diagnostics) { Slots = 3; this.AdjustWidth(leftOperand); _leftOperand = leftOperand; this.AdjustWidth(dot); _dot = dot; this.AdjustWidth(rightOperand); _rightOperand = rightOperand; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.MemberAccessExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new MemberAccessExpressionSyntaxNode(_leftOperand, _dot, _rightOperand, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _leftOperand, 1 => _dot, 2 => _rightOperand, _ => null } ; } } internal class UnaryPostfixOperationExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly ExpressionSyntaxNode _operand; internal readonly SyntaxToken _operation; internal UnaryPostfixOperationExpressionSyntaxNode(ExpressionSyntaxNode operand, SyntaxToken operation): base(TokenKind.UnaryPostfixOperationExpression) { Slots = 2; this.AdjustWidth(operand); _operand = operand; this.AdjustWidth(operation); _operation = operation; } internal UnaryPostfixOperationExpressionSyntaxNode(ExpressionSyntaxNode operand, SyntaxToken operation, TokenDiagnostic[] diagnostics): base(TokenKind.UnaryPostfixOperationExpression, diagnostics) { Slots = 2; this.AdjustWidth(operand); _operand = operand; this.AdjustWidth(operation); _operation = operation; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.UnaryPostfixOperationExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new UnaryPostfixOperationExpressionSyntaxNode(_operand, _operation, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _operand, 1 => _operation, _ => null } ; } } internal class IndirectMemberAccessExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _openingBracket; internal readonly ExpressionSyntaxNode _expression; internal readonly SyntaxToken _closingBracket; internal IndirectMemberAccessExpressionSyntaxNode(SyntaxToken openingBracket, ExpressionSyntaxNode expression, SyntaxToken closingBracket): base(TokenKind.IndirectMemberAccessExpression) { Slots = 3; this.AdjustWidth(openingBracket); _openingBracket = openingBracket; this.AdjustWidth(expression); _expression = expression; this.AdjustWidth(closingBracket); _closingBracket = closingBracket; } internal IndirectMemberAccessExpressionSyntaxNode(SyntaxToken openingBracket, ExpressionSyntaxNode expression, SyntaxToken closingBracket, TokenDiagnostic[] diagnostics): base(TokenKind.IndirectMemberAccessExpression, diagnostics) { Slots = 3; this.AdjustWidth(openingBracket); _openingBracket = openingBracket; this.AdjustWidth(expression); _expression = expression; this.AdjustWidth(closingBracket); _closingBracket = closingBracket; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.IndirectMemberAccessExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new IndirectMemberAccessExpressionSyntaxNode(_openingBracket, _expression, _closingBracket, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _openingBracket, 1 => _expression, 2 => _closingBracket, _ => null } ; } } internal class CommandExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _commandName; internal readonly SyntaxList _arguments; internal CommandExpressionSyntaxNode(SyntaxToken commandName, SyntaxList arguments): base(TokenKind.CommandExpression) { Slots = 2; this.AdjustWidth(commandName); _commandName = commandName; this.AdjustWidth(arguments); _arguments = arguments; } internal CommandExpressionSyntaxNode(SyntaxToken commandName, SyntaxList arguments, TokenDiagnostic[] diagnostics): base(TokenKind.CommandExpression, diagnostics) { Slots = 2; this.AdjustWidth(commandName); _commandName = commandName; this.AdjustWidth(arguments); _arguments = arguments; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.CommandExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new CommandExpressionSyntaxNode(_commandName, _arguments, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _commandName, 1 => _arguments, _ => null } ; } } internal class ClassInvokationExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly ExpressionSyntaxNode _methodName; internal readonly SyntaxToken _atSign; internal readonly ExpressionSyntaxNode _baseClassNameAndArguments; internal ClassInvokationExpressionSyntaxNode(ExpressionSyntaxNode methodName, SyntaxToken atSign, ExpressionSyntaxNode baseClassNameAndArguments): base(TokenKind.ClassInvokationExpression) { Slots = 3; this.AdjustWidth(methodName); _methodName = methodName; this.AdjustWidth(atSign); _atSign = atSign; this.AdjustWidth(baseClassNameAndArguments); _baseClassNameAndArguments = baseClassNameAndArguments; } internal ClassInvokationExpressionSyntaxNode(ExpressionSyntaxNode methodName, SyntaxToken atSign, ExpressionSyntaxNode baseClassNameAndArguments, TokenDiagnostic[] diagnostics): base(TokenKind.ClassInvokationExpression, diagnostics) { Slots = 3; this.AdjustWidth(methodName); _methodName = methodName; this.AdjustWidth(atSign); _atSign = atSign; this.AdjustWidth(baseClassNameAndArguments); _baseClassNameAndArguments = baseClassNameAndArguments; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.ClassInvokationExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new ClassInvokationExpressionSyntaxNode(_methodName, _atSign, _baseClassNameAndArguments, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _methodName, 1 => _atSign, 2 => _baseClassNameAndArguments, _ => null } ; } } internal class AttributeAssignmentSyntaxNode : SyntaxNode { internal readonly SyntaxToken _assignmentSign; internal readonly ExpressionSyntaxNode _value; internal AttributeAssignmentSyntaxNode(SyntaxToken assignmentSign, ExpressionSyntaxNode value): base(TokenKind.AttributeAssignment) { Slots = 2; this.AdjustWidth(assignmentSign); _assignmentSign = assignmentSign; this.AdjustWidth(value); _value = value; } internal AttributeAssignmentSyntaxNode(SyntaxToken assignmentSign, ExpressionSyntaxNode value, TokenDiagnostic[] diagnostics): base(TokenKind.AttributeAssignment, diagnostics) { Slots = 2; this.AdjustWidth(assignmentSign); _assignmentSign = assignmentSign; this.AdjustWidth(value); _value = value; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.AttributeAssignmentSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new AttributeAssignmentSyntaxNode(_assignmentSign, _value, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _assignmentSign, 1 => _value, _ => null } ; } } internal class AttributeSyntaxNode : SyntaxNode { internal readonly SyntaxToken _name; internal readonly AttributeAssignmentSyntaxNode? _assignment; internal AttributeSyntaxNode(SyntaxToken name, AttributeAssignmentSyntaxNode? assignment): base(TokenKind.Attribute) { Slots = 2; this.AdjustWidth(name); _name = name; this.AdjustWidth(assignment); _assignment = assignment; } internal AttributeSyntaxNode(SyntaxToken name, AttributeAssignmentSyntaxNode? assignment, TokenDiagnostic[] diagnostics): base(TokenKind.Attribute, diagnostics) { Slots = 2; this.AdjustWidth(name); _name = name; this.AdjustWidth(assignment); _assignment = assignment; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.AttributeSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new AttributeSyntaxNode(_name, _assignment, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _name, 1 => _assignment, _ => null } ; } } internal class AttributeListSyntaxNode : SyntaxNode { internal readonly SyntaxToken _openingBracket; internal readonly SyntaxList _nodes; internal readonly SyntaxToken _closingBracket; internal AttributeListSyntaxNode(SyntaxToken openingBracket, SyntaxList nodes, SyntaxToken closingBracket): base(TokenKind.AttributeList) { Slots = 3; this.AdjustWidth(openingBracket); _openingBracket = openingBracket; this.AdjustWidth(nodes); _nodes = nodes; this.AdjustWidth(closingBracket); _closingBracket = closingBracket; } internal AttributeListSyntaxNode(SyntaxToken openingBracket, SyntaxList nodes, SyntaxToken closingBracket, TokenDiagnostic[] diagnostics): base(TokenKind.AttributeList, diagnostics) { Slots = 3; this.AdjustWidth(openingBracket); _openingBracket = openingBracket; this.AdjustWidth(nodes); _nodes = nodes; this.AdjustWidth(closingBracket); _closingBracket = closingBracket; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.AttributeListSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new AttributeListSyntaxNode(_openingBracket, _nodes, _closingBracket, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _openingBracket, 1 => _nodes, 2 => _closingBracket, _ => null } ; } } internal class ConcreteMethodDeclarationSyntaxNode : MethodDeclarationSyntaxNode { internal readonly SyntaxToken _functionKeyword; internal readonly FunctionOutputDescriptionSyntaxNode? _outputDescription; internal readonly CompoundNameExpressionSyntaxNode _name; internal readonly FunctionInputDescriptionSyntaxNode? _inputDescription; internal readonly SyntaxList _commas; internal readonly StatementSyntaxNode _body; internal readonly EndKeywordSyntaxNode? _endKeyword; internal ConcreteMethodDeclarationSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, StatementSyntaxNode body, EndKeywordSyntaxNode? endKeyword): base(TokenKind.ConcreteMethodDeclaration) { Slots = 7; this.AdjustWidth(functionKeyword); _functionKeyword = functionKeyword; this.AdjustWidth(outputDescription); _outputDescription = outputDescription; this.AdjustWidth(name); _name = name; this.AdjustWidth(inputDescription); _inputDescription = inputDescription; this.AdjustWidth(commas); _commas = commas; this.AdjustWidth(body); _body = body; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } internal ConcreteMethodDeclarationSyntaxNode(SyntaxToken functionKeyword, FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, SyntaxList commas, StatementSyntaxNode body, EndKeywordSyntaxNode? endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.ConcreteMethodDeclaration, diagnostics) { Slots = 7; this.AdjustWidth(functionKeyword); _functionKeyword = functionKeyword; this.AdjustWidth(outputDescription); _outputDescription = outputDescription; this.AdjustWidth(name); _name = name; this.AdjustWidth(inputDescription); _inputDescription = inputDescription; this.AdjustWidth(commas); _commas = commas; this.AdjustWidth(body); _body = body; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.ConcreteMethodDeclarationSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new ConcreteMethodDeclarationSyntaxNode(_functionKeyword, _outputDescription, _name, _inputDescription, _commas, _body, _endKeyword, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _functionKeyword, 1 => _outputDescription, 2 => _name, 3 => _inputDescription, 4 => _commas, 5 => _body, 6 => _endKeyword, _ => null } ; } } internal class AbstractMethodDeclarationSyntaxNode : MethodDeclarationSyntaxNode { internal readonly FunctionOutputDescriptionSyntaxNode? _outputDescription; internal readonly CompoundNameExpressionSyntaxNode _name; internal readonly FunctionInputDescriptionSyntaxNode? _inputDescription; internal AbstractMethodDeclarationSyntaxNode(FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription): base(TokenKind.AbstractMethodDeclaration) { Slots = 3; this.AdjustWidth(outputDescription); _outputDescription = outputDescription; this.AdjustWidth(name); _name = name; this.AdjustWidth(inputDescription); _inputDescription = inputDescription; } internal AbstractMethodDeclarationSyntaxNode(FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameExpressionSyntaxNode name, FunctionInputDescriptionSyntaxNode? inputDescription, TokenDiagnostic[] diagnostics): base(TokenKind.AbstractMethodDeclaration, diagnostics) { Slots = 3; this.AdjustWidth(outputDescription); _outputDescription = outputDescription; this.AdjustWidth(name); _name = name; this.AdjustWidth(inputDescription); _inputDescription = inputDescription; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.AbstractMethodDeclarationSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new AbstractMethodDeclarationSyntaxNode(_outputDescription, _name, _inputDescription, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _outputDescription, 1 => _name, 2 => _inputDescription, _ => null } ; } } internal class MethodsListSyntaxNode : SyntaxNode { internal readonly SyntaxToken _methodsKeyword; 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) { Slots = 4; this.AdjustWidth(methodsKeyword); _methodsKeyword = methodsKeyword; this.AdjustWidth(attributes); _attributes = attributes; this.AdjustWidth(methods); _methods = methods; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } internal MethodsListSyntaxNode(SyntaxToken methodsKeyword, AttributeListSyntaxNode? attributes, SyntaxList methods, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.MethodsList, diagnostics) { Slots = 4; this.AdjustWidth(methodsKeyword); _methodsKeyword = methodsKeyword; this.AdjustWidth(attributes); _attributes = attributes; this.AdjustWidth(methods); _methods = methods; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.MethodsListSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new MethodsListSyntaxNode(_methodsKeyword, _attributes, _methods, _endKeyword, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _methodsKeyword, 1 => _attributes, 2 => _methods, 3 => _endKeyword, _ => null } ; } } internal class PropertiesListSyntaxNode : SyntaxNode { internal readonly SyntaxToken _propertiesKeyword; 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) { Slots = 4; this.AdjustWidth(propertiesKeyword); _propertiesKeyword = propertiesKeyword; this.AdjustWidth(attributes); _attributes = attributes; this.AdjustWidth(properties); _properties = properties; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } internal PropertiesListSyntaxNode(SyntaxToken propertiesKeyword, AttributeListSyntaxNode? attributes, SyntaxList properties, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.PropertiesList, diagnostics) { Slots = 4; this.AdjustWidth(propertiesKeyword); _propertiesKeyword = propertiesKeyword; this.AdjustWidth(attributes); _attributes = attributes; this.AdjustWidth(properties); _properties = properties; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.PropertiesListSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new PropertiesListSyntaxNode(_propertiesKeyword, _attributes, _properties, _endKeyword, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _propertiesKeyword, 1 => _attributes, 2 => _properties, 3 => _endKeyword, _ => null } ; } } internal class BaseClassListSyntaxNode : SyntaxNode { internal readonly SyntaxToken _lessSign; internal readonly SyntaxList _baseClasses; internal BaseClassListSyntaxNode(SyntaxToken lessSign, SyntaxList baseClasses): base(TokenKind.BaseClassList) { Slots = 2; this.AdjustWidth(lessSign); _lessSign = lessSign; this.AdjustWidth(baseClasses); _baseClasses = baseClasses; } internal BaseClassListSyntaxNode(SyntaxToken lessSign, SyntaxList baseClasses, TokenDiagnostic[] diagnostics): base(TokenKind.BaseClassList, diagnostics) { Slots = 2; this.AdjustWidth(lessSign); _lessSign = lessSign; this.AdjustWidth(baseClasses); _baseClasses = baseClasses; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.BaseClassListSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new BaseClassListSyntaxNode(_lessSign, _baseClasses, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _lessSign, 1 => _baseClasses, _ => null } ; } } internal class ClassDeclarationSyntaxNode : StatementSyntaxNode { internal readonly SyntaxToken _classdefKeyword; internal readonly AttributeListSyntaxNode? _attributes; internal readonly SyntaxToken _className; internal readonly BaseClassListSyntaxNode? _baseClassList; internal readonly SyntaxList _nodes; internal readonly SyntaxToken _endKeyword; internal ClassDeclarationSyntaxNode(SyntaxToken classdefKeyword, AttributeListSyntaxNode? attributes, SyntaxToken className, BaseClassListSyntaxNode? baseClassList, SyntaxList nodes, SyntaxToken endKeyword): base(TokenKind.ClassDeclaration) { Slots = 6; this.AdjustWidth(classdefKeyword); _classdefKeyword = classdefKeyword; this.AdjustWidth(attributes); _attributes = attributes; this.AdjustWidth(className); _className = className; this.AdjustWidth(baseClassList); _baseClassList = baseClassList; this.AdjustWidth(nodes); _nodes = nodes; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } internal ClassDeclarationSyntaxNode(SyntaxToken classdefKeyword, AttributeListSyntaxNode? attributes, SyntaxToken className, BaseClassListSyntaxNode? baseClassList, SyntaxList nodes, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.ClassDeclaration, diagnostics) { Slots = 6; this.AdjustWidth(classdefKeyword); _classdefKeyword = classdefKeyword; this.AdjustWidth(attributes); _attributes = attributes; this.AdjustWidth(className); _className = className; this.AdjustWidth(baseClassList); _baseClassList = baseClassList; this.AdjustWidth(nodes); _nodes = nodes; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.ClassDeclarationSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new ClassDeclarationSyntaxNode(_classdefKeyword, _attributes, _className, _baseClassList, _nodes, _endKeyword, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _classdefKeyword, 1 => _attributes, 2 => _className, 3 => _baseClassList, 4 => _nodes, 5 => _endKeyword, _ => null } ; } } internal class EnumerationItemValueSyntaxNode : SyntaxNode { internal readonly SyntaxToken _openingBracket; internal readonly SyntaxList _values; internal readonly SyntaxToken _closingBracket; internal EnumerationItemValueSyntaxNode(SyntaxToken openingBracket, SyntaxList values, SyntaxToken closingBracket): base(TokenKind.EnumerationItemValue) { Slots = 3; this.AdjustWidth(openingBracket); _openingBracket = openingBracket; this.AdjustWidth(values); _values = values; this.AdjustWidth(closingBracket); _closingBracket = closingBracket; } internal EnumerationItemValueSyntaxNode(SyntaxToken openingBracket, SyntaxList values, SyntaxToken closingBracket, TokenDiagnostic[] diagnostics): base(TokenKind.EnumerationItemValue, diagnostics) { Slots = 3; this.AdjustWidth(openingBracket); _openingBracket = openingBracket; this.AdjustWidth(values); _values = values; this.AdjustWidth(closingBracket); _closingBracket = closingBracket; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.EnumerationItemValueSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new EnumerationItemValueSyntaxNode(_openingBracket, _values, _closingBracket, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _openingBracket, 1 => _values, 2 => _closingBracket, _ => null } ; } } internal class EnumerationItemSyntaxNode : SyntaxNode { internal readonly SyntaxToken _name; internal readonly EnumerationItemValueSyntaxNode? _values; internal readonly SyntaxList _commas; internal EnumerationItemSyntaxNode(SyntaxToken name, EnumerationItemValueSyntaxNode? values, SyntaxList commas): base(TokenKind.EnumerationItem) { Slots = 3; this.AdjustWidth(name); _name = name; this.AdjustWidth(values); _values = values; this.AdjustWidth(commas); _commas = commas; } internal EnumerationItemSyntaxNode(SyntaxToken name, EnumerationItemValueSyntaxNode? values, SyntaxList commas, TokenDiagnostic[] diagnostics): base(TokenKind.EnumerationItem, diagnostics) { Slots = 3; this.AdjustWidth(name); _name = name; this.AdjustWidth(values); _values = values; this.AdjustWidth(commas); _commas = commas; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.EnumerationItemSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new EnumerationItemSyntaxNode(_name, _values, _commas, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _name, 1 => _values, 2 => _commas, _ => null } ; } } internal class EnumerationListSyntaxNode : SyntaxNode { internal readonly SyntaxToken _enumerationKeyword; 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) { Slots = 4; this.AdjustWidth(enumerationKeyword); _enumerationKeyword = enumerationKeyword; this.AdjustWidth(attributes); _attributes = attributes; this.AdjustWidth(items); _items = items; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } internal EnumerationListSyntaxNode(SyntaxToken enumerationKeyword, AttributeListSyntaxNode? attributes, SyntaxList items, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.EnumerationList, diagnostics) { Slots = 4; this.AdjustWidth(enumerationKeyword); _enumerationKeyword = enumerationKeyword; this.AdjustWidth(attributes); _attributes = attributes; this.AdjustWidth(items); _items = items; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.EnumerationListSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new EnumerationListSyntaxNode(_enumerationKeyword, _attributes, _items, _endKeyword, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _enumerationKeyword, 1 => _attributes, 2 => _items, 3 => _endKeyword, _ => null } ; } } internal class EventsListSyntaxNode : SyntaxNode { internal readonly SyntaxToken _eventsKeyword; 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) { Slots = 4; this.AdjustWidth(eventsKeyword); _eventsKeyword = eventsKeyword; this.AdjustWidth(attributes); _attributes = attributes; this.AdjustWidth(events); _events = events; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } internal EventsListSyntaxNode(SyntaxToken eventsKeyword, AttributeListSyntaxNode? attributes, SyntaxList events, SyntaxToken endKeyword, TokenDiagnostic[] diagnostics): base(TokenKind.EventsList, diagnostics) { Slots = 4; this.AdjustWidth(eventsKeyword); _eventsKeyword = eventsKeyword; this.AdjustWidth(attributes); _attributes = attributes; this.AdjustWidth(events); _events = events; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.EventsListSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new EventsListSyntaxNode(_eventsKeyword, _attributes, _events, _endKeyword, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _eventsKeyword, 1 => _attributes, 2 => _events, 3 => _endKeyword, _ => null } ; } } internal class EndKeywordSyntaxNode : SyntaxNode { internal readonly SyntaxToken _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) { Slots = 1; this.AdjustWidth(endKeyword); _endKeyword = endKeyword; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.EndKeywordSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new EndKeywordSyntaxNode(_endKeyword, diagnostics); } public override GreenNode? GetSlot(int i) { return i switch { 0 => _endKeyword, _ => null } ; } } }