namespace Parser.Internal { internal class FileSyntaxNode : SyntaxNode { internal readonly SyntaxList _statementList; internal readonly SyntaxToken _endOfFile; internal FileSyntaxNode( SyntaxList statementList, SyntaxToken endOfFile) : base(TokenKind.File) { Slots = 2; this.AdjustWidth(statementList); _statementList = statementList; this.AdjustWidth(endOfFile); _endOfFile = endOfFile; } internal FileSyntaxNode( SyntaxList statementList, SyntaxToken endOfFile, TokenDiagnostic[] diagnostics) : base(TokenKind.File, diagnostics) { Slots = 2; this.AdjustWidth(statementList); _statementList = statementList; 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(_statementList, _endOfFile, diagnostics); } public override GreenNode? GetSlot(int i) { switch (i) { case 0: return _statementList; case 1: return _endOfFile; default: return 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 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) { 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, SyntaxList 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) { switch (i) { 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; } } } 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) { switch (i) { case 0: return _outputList; case 1: return _assignmentSign; default: return 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) { switch (i) { case 0: return _openingBracket; case 1: return _parameterList; case 2: return _closingBracket; default: return 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) { switch (i) { case 0: return _switchKeyword; case 1: return _switchExpression; case 2: return _optionalCommas; case 3: return _cases; case 4: return _endKeyword; default: return null; } } } internal class SwitchCaseSyntaxNode : SyntaxNode { internal readonly SyntaxToken _caseKeyword; 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) { 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, SyntaxList 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) { switch (i) { case 0: return _caseKeyword; case 1: return _caseIdentifier; case 2: return _optionalCommas; case 3: return _body; default: return null; } } } internal class WhileStatementSyntaxNode : StatementSyntaxNode { internal readonly SyntaxToken _whileKeyword; internal readonly ExpressionSyntaxNode _condition; 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) { 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, SyntaxList 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) { switch (i) { case 0: return _whileKeyword; case 1: return _condition; case 2: return _optionalCommas; case 3: return _body; case 4: return _endKeyword; default: return null; } } } internal class ElseifClause : SyntaxNode { internal readonly SyntaxToken _elseifKeyword; 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) { 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, SyntaxList 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) { switch (i) { case 0: return _elseifKeyword; case 1: return _condition; case 2: return _optionalCommas; case 3: return _body; default: return null; } } } internal class ElseClause : SyntaxNode { internal readonly SyntaxToken _elseKeyword; internal readonly SyntaxList _body; internal ElseClause( SyntaxToken elseKeyword, SyntaxList body) : base(TokenKind.ElseClause) { Slots = 2; this.AdjustWidth(elseKeyword); _elseKeyword = elseKeyword; this.AdjustWidth(body); _body = body; } internal ElseClause( SyntaxToken elseKeyword, SyntaxList 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) { switch (i) { case 0: return _elseKeyword; case 1: return _body; default: return null; } } } internal class IfStatementSyntaxNode : StatementSyntaxNode { internal readonly SyntaxToken _ifKeyword; internal readonly ExpressionSyntaxNode _condition; internal readonly SyntaxList _optionalCommas; internal readonly SyntaxList _body; 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) { 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, SyntaxList 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) { switch (i) { 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; } } } internal class ForStatementSyntaxNode : StatementSyntaxNode { internal readonly SyntaxToken _forKeyword; internal readonly AssignmentExpressionSyntaxNode _assignment; 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) { 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, SyntaxList 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) { switch (i) { case 0: return _forKeyword; case 1: return _assignment; case 2: return _optionalCommas; case 3: return _body; case 4: return _endKeyword; default: return 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) { switch (i) { case 0: return _lhs; case 1: return _assignmentSign; case 2: return _rhs; default: return 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) { switch (i) { case 0: return _catchKeyword; case 1: return _catchBody; default: return null; } } } internal class TryCatchStatementSyntaxNode : StatementSyntaxNode { internal readonly SyntaxToken _tryKeyword; 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) { 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, SyntaxList 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) { switch (i) { case 0: return _tryKeyword; case 1: return _tryBody; case 2: return _catchClause; case 3: return _endKeyword; default: return null; } } } internal class ExpressionStatementSyntaxNode : StatementSyntaxNode { internal readonly ExpressionSyntaxNode _expression; internal ExpressionStatementSyntaxNode( ExpressionSyntaxNode expression) : base(TokenKind.ExpressionStatement) { Slots = 1; this.AdjustWidth(expression); _expression = expression; } internal ExpressionStatementSyntaxNode( ExpressionSyntaxNode expression, TokenDiagnostic[] diagnostics) : base(TokenKind.ExpressionStatement, diagnostics) { Slots = 1; this.AdjustWidth(expression); _expression = expression; } 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, diagnostics); } public override GreenNode? GetSlot(int i) { switch (i) { case 0: return _expression; default: return 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) { switch (i) { case 0: return _semicolon; default: return 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) { switch (i) { default: return 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) { switch (i) { case 0: return _operation; case 1: return _operand; default: return null; } } } internal class CompoundNameSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxList _nodes; internal CompoundNameSyntaxNode( SyntaxList nodes) : base(TokenKind.CompoundName) { Slots = 1; this.AdjustWidth(nodes); _nodes = nodes; } internal CompoundNameSyntaxNode( SyntaxList nodes, TokenDiagnostic[] diagnostics) : base(TokenKind.CompoundName, diagnostics) { Slots = 1; this.AdjustWidth(nodes); _nodes = nodes; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.CompoundNameSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new CompoundNameSyntaxNode(_nodes, diagnostics); } public override GreenNode? GetSlot(int i) { switch (i) { case 0: return _nodes; default: return null; } } } internal class NamedFunctionHandleSyntaxNode : FunctionHandleSyntaxNode { internal readonly SyntaxToken _atSign; internal readonly CompoundNameSyntaxNode _functionName; internal NamedFunctionHandleSyntaxNode( SyntaxToken atSign, CompoundNameSyntaxNode functionName) : base(TokenKind.NamedFunctionHandle) { Slots = 2; this.AdjustWidth(atSign); _atSign = atSign; this.AdjustWidth(functionName); _functionName = functionName; } internal NamedFunctionHandleSyntaxNode( SyntaxToken atSign, CompoundNameSyntaxNode functionName, TokenDiagnostic[] diagnostics) : base(TokenKind.NamedFunctionHandle, 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.NamedFunctionHandleSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new NamedFunctionHandleSyntaxNode(_atSign, _functionName, diagnostics); } public override GreenNode? GetSlot(int i) { switch (i) { case 0: return _atSign; case 1: return _functionName; default: return null; } } } internal class LambdaSyntaxNode : FunctionHandleSyntaxNode { internal readonly SyntaxToken _atSign; internal readonly FunctionInputDescriptionSyntaxNode _input; internal readonly ExpressionSyntaxNode _body; internal LambdaSyntaxNode( SyntaxToken atSign, FunctionInputDescriptionSyntaxNode input, ExpressionSyntaxNode body) : base(TokenKind.Lambda) { Slots = 3; this.AdjustWidth(atSign); _atSign = atSign; this.AdjustWidth(input); _input = input; this.AdjustWidth(body); _body = body; } internal LambdaSyntaxNode( SyntaxToken atSign, FunctionInputDescriptionSyntaxNode input, ExpressionSyntaxNode body, TokenDiagnostic[] diagnostics) : base(TokenKind.Lambda, 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.LambdaSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new LambdaSyntaxNode(_atSign, _input, _body, diagnostics); } public override GreenNode? GetSlot(int i) { switch (i) { case 0: return _atSign; case 1: return _input; case 2: return _body; default: return 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.BinaryOperation) { 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.BinaryOperation, 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) { switch (i) { case 0: return _lhs; case 1: return _operation; case 2: return _rhs; default: return null; } } } internal class IdentifierNameSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _name; internal IdentifierNameSyntaxNode( SyntaxToken name) : base(TokenKind.IdentifierName) { Slots = 1; this.AdjustWidth(name); _name = name; } internal IdentifierNameSyntaxNode( SyntaxToken name, TokenDiagnostic[] diagnostics) : base(TokenKind.IdentifierName, diagnostics) { Slots = 1; this.AdjustWidth(name); _name = name; } internal override Parser.SyntaxNode CreateRed(Parser.SyntaxNode parent, int position) { return new Parser.IdentifierNameSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new IdentifierNameSyntaxNode(_name, diagnostics); } public override GreenNode? GetSlot(int i) { switch (i) { case 0: return _name; default: return null; } } } internal class NumberLiteralSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _number; internal NumberLiteralSyntaxNode( SyntaxToken number) : base(TokenKind.NumberLiteralExpression) { Slots = 1; this.AdjustWidth(number); _number = number; } internal NumberLiteralSyntaxNode( 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.NumberLiteralSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new NumberLiteralSyntaxNode(_number, diagnostics); } public override GreenNode? GetSlot(int i) { switch (i) { case 0: return _number; default: return null; } } } internal class StringLiteralSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _stringToken; internal StringLiteralSyntaxNode( SyntaxToken stringToken) : base(TokenKind.StringLiteralExpression) { Slots = 1; this.AdjustWidth(stringToken); _stringToken = stringToken; } internal StringLiteralSyntaxNode( 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.StringLiteralSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new StringLiteralSyntaxNode(_stringToken, diagnostics); } public override GreenNode? GetSlot(int i) { switch (i) { case 0: return _stringToken; default: return null; } } } internal class DoubleQuotedStringLiteralSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _stringToken; internal DoubleQuotedStringLiteralSyntaxNode( SyntaxToken stringToken) : base(TokenKind.DoubleQuotedStringLiteralExpression) { Slots = 1; this.AdjustWidth(stringToken); _stringToken = stringToken; } internal DoubleQuotedStringLiteralSyntaxNode( 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.DoubleQuotedStringLiteralSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new DoubleQuotedStringLiteralSyntaxNode(_stringToken, diagnostics); } public override GreenNode? GetSlot(int i) { switch (i) { case 0: return _stringToken; default: return null; } } } internal class UnquotedStringLiteralSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _stringToken; internal UnquotedStringLiteralSyntaxNode( SyntaxToken stringToken) : base(TokenKind.UnquotedStringLiteralExpression) { Slots = 1; this.AdjustWidth(stringToken); _stringToken = stringToken; } internal UnquotedStringLiteralSyntaxNode( 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.UnquotedStringLiteralSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new UnquotedStringLiteralSyntaxNode(_stringToken, diagnostics); } public override GreenNode? GetSlot(int i) { switch (i) { case 0: return _stringToken; default: return 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) { switch (i) { case 0: return _openingSquareBracket; case 1: return _nodes; case 2: return _closingSquareBracket; default: return 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) { switch (i) { case 0: return _openingBrace; case 1: return _nodes; case 2: return _closingBrace; default: return 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) { switch (i) { case 0: return _openingBracket; case 1: return _expression; case 2: return _closingBracket; default: return 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.CellArrayElementAccess) { 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.CellArrayElementAccess, 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) { switch (i) { case 0: return _expression; case 1: return _openingBrace; case 2: return _nodes; case 3: return _closingBrace; default: return 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.FunctionCall) { 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.FunctionCall, 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) { switch (i) { case 0: return _functionName; case 1: return _openingBracket; case 2: return _nodes; case 3: return _closingBracket; default: return null; } } } internal class MemberAccessSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxNode _leftOperand; internal readonly SyntaxToken _dot; internal readonly SyntaxNode _rightOperand; internal MemberAccessSyntaxNode( SyntaxNode leftOperand, SyntaxToken dot, SyntaxNode rightOperand) : base(TokenKind.MemberAccess) { Slots = 3; this.AdjustWidth(leftOperand); _leftOperand = leftOperand; this.AdjustWidth(dot); _dot = dot; this.AdjustWidth(rightOperand); _rightOperand = rightOperand; } internal MemberAccessSyntaxNode( SyntaxNode leftOperand, SyntaxToken dot, SyntaxNode rightOperand, TokenDiagnostic[] diagnostics) : base(TokenKind.MemberAccess, 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.MemberAccessSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new MemberAccessSyntaxNode(_leftOperand, _dot, _rightOperand, diagnostics); } public override GreenNode? GetSlot(int i) { switch (i) { case 0: return _leftOperand; case 1: return _dot; case 2: return _rightOperand; default: return null; } } } internal class UnaryPostixOperationExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly ExpressionSyntaxNode _operand; internal readonly SyntaxToken _operation; internal UnaryPostixOperationExpressionSyntaxNode( ExpressionSyntaxNode operand, SyntaxToken operation) : base(TokenKind.UnaryPostfixOperationExpression) { Slots = 2; this.AdjustWidth(operand); _operand = operand; this.AdjustWidth(operation); _operation = operation; } internal UnaryPostixOperationExpressionSyntaxNode( 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.UnaryPostixOperationExpressionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new UnaryPostixOperationExpressionSyntaxNode(_operand, _operation, diagnostics); } public override GreenNode? GetSlot(int i) { switch (i) { case 0: return _operand; case 1: return _operation; default: return null; } } } internal class IndirectMemberAccessSyntaxNode : ExpressionSyntaxNode { internal readonly SyntaxToken _openingBracket; internal readonly ExpressionSyntaxNode _expression; internal readonly SyntaxToken _closingBracket; internal IndirectMemberAccessSyntaxNode( SyntaxToken openingBracket, ExpressionSyntaxNode expression, SyntaxToken closingBracket) : base(TokenKind.IndirectMemberAccess) { Slots = 3; this.AdjustWidth(openingBracket); _openingBracket = openingBracket; this.AdjustWidth(expression); _expression = expression; this.AdjustWidth(closingBracket); _closingBracket = closingBracket; } internal IndirectMemberAccessSyntaxNode( SyntaxToken openingBracket, ExpressionSyntaxNode expression, SyntaxToken closingBracket, TokenDiagnostic[] diagnostics) : base(TokenKind.IndirectMemberAccess, 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.IndirectMemberAccessSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new IndirectMemberAccessSyntaxNode(_openingBracket, _expression, _closingBracket, diagnostics); } public override GreenNode? GetSlot(int i) { switch (i) { case 0: return _openingBracket; case 1: return _expression; case 2: return _closingBracket; default: return null; } } } internal class CommandExpressionSyntaxNode : ExpressionSyntaxNode { internal readonly IdentifierNameSyntaxNode _commandName; internal readonly SyntaxList _arguments; internal CommandExpressionSyntaxNode( IdentifierNameSyntaxNode commandName, SyntaxList arguments) : base(TokenKind.Command) { Slots = 2; this.AdjustWidth(commandName); _commandName = commandName; this.AdjustWidth(arguments); _arguments = arguments; } internal CommandExpressionSyntaxNode( IdentifierNameSyntaxNode commandName, SyntaxList arguments, TokenDiagnostic[] diagnostics) : base(TokenKind.Command, 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) { switch (i) { case 0: return _commandName; case 1: return _arguments; default: return null; } } } internal class BaseClassInvokationSyntaxNode : ExpressionSyntaxNode { internal readonly ExpressionSyntaxNode _methodName; internal readonly SyntaxToken _atSign; internal readonly ExpressionSyntaxNode _baseClassNameAndArguments; internal BaseClassInvokationSyntaxNode( ExpressionSyntaxNode methodName, SyntaxToken atSign, ExpressionSyntaxNode baseClassNameAndArguments) : base(TokenKind.ClassInvokation) { Slots = 3; this.AdjustWidth(methodName); _methodName = methodName; this.AdjustWidth(atSign); _atSign = atSign; this.AdjustWidth(baseClassNameAndArguments); _baseClassNameAndArguments = baseClassNameAndArguments; } internal BaseClassInvokationSyntaxNode( ExpressionSyntaxNode methodName, SyntaxToken atSign, ExpressionSyntaxNode baseClassNameAndArguments, TokenDiagnostic[] diagnostics) : base(TokenKind.ClassInvokation, 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.BaseClassInvokationSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new BaseClassInvokationSyntaxNode(_methodName, _atSign, _baseClassNameAndArguments, diagnostics); } public override GreenNode? GetSlot(int i) { switch (i) { case 0: return _methodName; case 1: return _atSign; case 2: return _baseClassNameAndArguments; default: return 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) { switch (i) { case 0: return _assignmentSign; case 1: return _value; default: return null; } } } internal class AttributeSyntaxNode : SyntaxNode { internal readonly IdentifierNameSyntaxNode _name; internal readonly AttributeAssignmentSyntaxNode? _assignment; internal AttributeSyntaxNode( IdentifierNameSyntaxNode name, AttributeAssignmentSyntaxNode? assignment) : base(TokenKind.Attribute) { Slots = 2; this.AdjustWidth(name); _name = name; this.AdjustWidth(assignment); _assignment = assignment; } internal AttributeSyntaxNode( IdentifierNameSyntaxNode 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) { switch (i) { case 0: return _name; case 1: return _assignment; default: return 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) { switch (i) { case 0: return _openingBracket; case 1: return _nodes; case 2: return _closingBracket; default: return null; } } } internal class MethodDefinitionSyntaxNode : MethodDeclarationSyntaxNode { internal readonly SyntaxToken _functionKeyword; internal readonly FunctionOutputDescriptionSyntaxNode? _outputDescription; internal readonly CompoundNameSyntaxNode _name; internal readonly FunctionInputDescriptionSyntaxNode? _inputDescription; 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) { 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 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); _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.MethodDefinitionSyntaxNode(parent, this, position); } public override GreenNode SetDiagnostics(TokenDiagnostic[] diagnostics) { return new MethodDefinitionSyntaxNode(_functionKeyword, _outputDescription, _name, _inputDescription, _commas, _body, _endKeyword, diagnostics); } public override GreenNode? GetSlot(int i) { switch (i) { 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; } } } internal class AbstractMethodDeclarationSyntaxNode : MethodDeclarationSyntaxNode { internal readonly FunctionOutputDescriptionSyntaxNode? _outputDescription; internal readonly CompoundNameSyntaxNode _name; internal readonly FunctionInputDescriptionSyntaxNode? _inputDescription; internal AbstractMethodDeclarationSyntaxNode( FunctionOutputDescriptionSyntaxNode? outputDescription, CompoundNameSyntaxNode 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, CompoundNameSyntaxNode 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) { switch (i) { case 0: return _outputDescription; case 1: return _name; case 2: return _inputDescription; default: return 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) { switch (i) { case 0: return _methodsKeyword; case 1: return _attributes; case 2: return _methods; case 3: return _endKeyword; default: return 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) { switch (i) { case 0: return _propertiesKeyword; case 1: return _attributes; case 2: return _properties; case 3: return _endKeyword; default: return 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) { switch (i) { case 0: return _lessSign; case 1: return _baseClasses; default: return null; } } } internal class ClassDeclarationSyntaxNode : StatementSyntaxNode { internal readonly SyntaxToken _classdefKeyword; internal readonly AttributeListSyntaxNode? _attributes; internal readonly IdentifierNameSyntaxNode _className; internal readonly BaseClassListSyntaxNode? _baseClassList; internal readonly SyntaxList _nodes; internal readonly SyntaxToken _endKeyword; internal ClassDeclarationSyntaxNode( SyntaxToken classdefKeyword, AttributeListSyntaxNode? attributes, IdentifierNameSyntaxNode className, BaseClassListSyntaxNode? baseClassList, SyntaxList nodes, SyntaxToken endKeyword) : base(TokenKind.ClassDeclaration) { 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, IdentifierNameSyntaxNode 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) { switch (i) { 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; } } } 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) { switch (i) { case 0: return _openingBracket; case 1: return _values; case 2: return _closingBracket; default: return null; } } } internal class EnumerationItemSyntaxNode : SyntaxNode { internal readonly IdentifierNameSyntaxNode _name; internal readonly EnumerationItemValueSyntaxNode? _values; internal readonly SyntaxList _commas; internal EnumerationItemSyntaxNode( IdentifierNameSyntaxNode 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( IdentifierNameSyntaxNode 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) { switch (i) { case 0: return _name; case 1: return _values; case 2: return _commas; default: return 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) { switch (i) { case 0: return _enumerationKeyword; case 1: return _attributes; case 2: return _items; case 3: return _endKeyword; default: return 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) { switch (i) { case 0: return _eventsKeyword; case 1: return _attributes; case 2: return _events; case 3: return _endKeyword; default: return 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) { switch (i) { case 0: return _endKeyword; default: return null; } } } }