@nomicfoundation/slang/target/cst/rewriter.generated.mjs

A modular set of compiler APIs empowering the next generation of Solidity code analysis and developer tooling. Written in Rust and distributed in multiple languages.

// This file is generated automatically by infrastructure scripts. Please don't edit by hand.
import { NonterminalKind, NonterminalNode, NodeType, TerminalKind, Edge } from "./index.mjs";
/** Abstract class to rewrite a CST. */
export class BaseRewriter {
    /** Replaces the `node` with a new node. If the result is `undefined`, the node is removed from the tree.
        This function typically the entry point of the rewrite operation. */
    rewriteNode(node) {
        switch (node.type) {
            case NodeType.TerminalNode:
                return this.rewriteTerminalNode(node);
            case NodeType.NonterminalNode:
                return this.rewriteNonterminalNode(node);
        }
    }
    /** Rewrites a non-terminal node. Typically called from `rewriteNode`. */
    rewriteNonterminalNode(node) {
        switch (node.kind) {
            case NonterminalKind.AbicoderPragma:
                return this.rewriteAbicoderPragma(node);
            case NonterminalKind.AbicoderVersion:
                return this.rewriteAbicoderVersion(node);
            case NonterminalKind.AdditiveExpression:
                return this.rewriteAdditiveExpression(node);
            case NonterminalKind.AddressType:
                return this.rewriteAddressType(node);
            case NonterminalKind.AndExpression:
                return this.rewriteAndExpression(node);
            case NonterminalKind.ArgumentsDeclaration:
                return this.rewriteArgumentsDeclaration(node);
            case NonterminalKind.ArrayExpression:
                return this.rewriteArrayExpression(node);
            case NonterminalKind.ArrayTypeName:
                return this.rewriteArrayTypeName(node);
            case NonterminalKind.ArrayValues:
                return this.rewriteArrayValues(node);
            case NonterminalKind.AssemblyFlags:
                return this.rewriteAssemblyFlags(node);
            case NonterminalKind.AssemblyFlagsDeclaration:
                return this.rewriteAssemblyFlagsDeclaration(node);
            case NonterminalKind.AssemblyStatement:
                return this.rewriteAssemblyStatement(node);
            case NonterminalKind.AssignmentExpression:
                return this.rewriteAssignmentExpression(node);
            case NonterminalKind.BitwiseAndExpression:
                return this.rewriteBitwiseAndExpression(node);
            case NonterminalKind.BitwiseOrExpression:
                return this.rewriteBitwiseOrExpression(node);
            case NonterminalKind.BitwiseXorExpression:
                return this.rewriteBitwiseXorExpression(node);
            case NonterminalKind.Block:
                return this.rewriteBlock(node);
            case NonterminalKind.BreakStatement:
                return this.rewriteBreakStatement(node);
            case NonterminalKind.CallOptions:
                return this.rewriteCallOptions(node);
            case NonterminalKind.CallOptionsExpression:
                return this.rewriteCallOptionsExpression(node);
            case NonterminalKind.CatchClause:
                return this.rewriteCatchClause(node);
            case NonterminalKind.CatchClauseError:
                return this.rewriteCatchClauseError(node);
            case NonterminalKind.CatchClauses:
                return this.rewriteCatchClauses(node);
            case NonterminalKind.ConditionalExpression:
                return this.rewriteConditionalExpression(node);
            case NonterminalKind.ConstantDefinition:
                return this.rewriteConstantDefinition(node);
            case NonterminalKind.ConstructorAttribute:
                return this.rewriteConstructorAttribute(node);
            case NonterminalKind.ConstructorAttributes:
                return this.rewriteConstructorAttributes(node);
            case NonterminalKind.ConstructorDefinition:
                return this.rewriteConstructorDefinition(node);
            case NonterminalKind.ContinueStatement:
                return this.rewriteContinueStatement(node);
            case NonterminalKind.ContractDefinition:
                return this.rewriteContractDefinition(node);
            case NonterminalKind.ContractMember:
                return this.rewriteContractMember(node);
            case NonterminalKind.ContractMembers:
                return this.rewriteContractMembers(node);
            case NonterminalKind.ContractSpecifier:
                return this.rewriteContractSpecifier(node);
            case NonterminalKind.ContractSpecifiers:
                return this.rewriteContractSpecifiers(node);
            case NonterminalKind.DecimalNumberExpression:
                return this.rewriteDecimalNumberExpression(node);
            case NonterminalKind.DoWhileStatement:
                return this.rewriteDoWhileStatement(node);
            case NonterminalKind.ElementaryType:
                return this.rewriteElementaryType(node);
            case NonterminalKind.ElseBranch:
                return this.rewriteElseBranch(node);
            case NonterminalKind.EmitStatement:
                return this.rewriteEmitStatement(node);
            case NonterminalKind.EnumDefinition:
                return this.rewriteEnumDefinition(node);
            case NonterminalKind.EnumMembers:
                return this.rewriteEnumMembers(node);
            case NonterminalKind.EqualityExpression:
                return this.rewriteEqualityExpression(node);
            case NonterminalKind.ErrorDefinition:
                return this.rewriteErrorDefinition(node);
            case NonterminalKind.ErrorParameter:
                return this.rewriteErrorParameter(node);
            case NonterminalKind.ErrorParameters:
                return this.rewriteErrorParameters(node);
            case NonterminalKind.ErrorParametersDeclaration:
                return this.rewriteErrorParametersDeclaration(node);
            case NonterminalKind.EventDefinition:
                return this.rewriteEventDefinition(node);
            case NonterminalKind.EventParameter:
                return this.rewriteEventParameter(node);
            case NonterminalKind.EventParameters:
                return this.rewriteEventParameters(node);
            case NonterminalKind.EventParametersDeclaration:
                return this.rewriteEventParametersDeclaration(node);
            case NonterminalKind.ExperimentalFeature:
                return this.rewriteExperimentalFeature(node);
            case NonterminalKind.ExperimentalPragma:
                return this.rewriteExperimentalPragma(node);
            case NonterminalKind.ExponentiationExpression:
                return this.rewriteExponentiationExpression(node);
            case NonterminalKind.Expression:
                return this.rewriteExpression(node);
            case NonterminalKind.ExpressionStatement:
                return this.rewriteExpressionStatement(node);
            case NonterminalKind.FallbackFunctionAttribute:
                return this.rewriteFallbackFunctionAttribute(node);
            case NonterminalKind.FallbackFunctionAttributes:
                return this.rewriteFallbackFunctionAttributes(node);
            case NonterminalKind.FallbackFunctionDefinition:
                return this.rewriteFallbackFunctionDefinition(node);
            case NonterminalKind.ForStatement:
                return this.rewriteForStatement(node);
            case NonterminalKind.ForStatementCondition:
                return this.rewriteForStatementCondition(node);
            case NonterminalKind.ForStatementInitialization:
                return this.rewriteForStatementInitialization(node);
            case NonterminalKind.FunctionAttribute:
                return this.rewriteFunctionAttribute(node);
            case NonterminalKind.FunctionAttributes:
                return this.rewriteFunctionAttributes(node);
            case NonterminalKind.FunctionBody:
                return this.rewriteFunctionBody(node);
            case NonterminalKind.FunctionCallExpression:
                return this.rewriteFunctionCallExpression(node);
            case NonterminalKind.FunctionDefinition:
                return this.rewriteFunctionDefinition(node);
            case NonterminalKind.FunctionName:
                return this.rewriteFunctionName(node);
            case NonterminalKind.FunctionType:
                return this.rewriteFunctionType(node);
            case NonterminalKind.FunctionTypeAttribute:
                return this.rewriteFunctionTypeAttribute(node);
            case NonterminalKind.FunctionTypeAttributes:
                return this.rewriteFunctionTypeAttributes(node);
            case NonterminalKind.HexNumberExpression:
                return this.rewriteHexNumberExpression(node);
            case NonterminalKind.HexStringLiteral:
                return this.rewriteHexStringLiteral(node);
            case NonterminalKind.HexStringLiterals:
                return this.rewriteHexStringLiterals(node);
            case NonterminalKind.IdentifierPath:
                return this.rewriteIdentifierPath(node);
            case NonterminalKind.IfStatement:
                return this.rewriteIfStatement(node);
            case NonterminalKind.ImportAlias:
                return this.rewriteImportAlias(node);
            case NonterminalKind.ImportClause:
                return this.rewriteImportClause(node);
            case NonterminalKind.ImportDeconstruction:
                return this.rewriteImportDeconstruction(node);
            case NonterminalKind.ImportDeconstructionSymbol:
                return this.rewriteImportDeconstructionSymbol(node);
            case NonterminalKind.ImportDeconstructionSymbols:
                return this.rewriteImportDeconstructionSymbols(node);
            case NonterminalKind.ImportDirective:
                return this.rewriteImportDirective(node);
            case NonterminalKind.IndexAccessEnd:
                return this.rewriteIndexAccessEnd(node);
            case NonterminalKind.IndexAccessExpression:
                return this.rewriteIndexAccessExpression(node);
            case NonterminalKind.InequalityExpression:
                return this.rewriteInequalityExpression(node);
            case NonterminalKind.InheritanceSpecifier:
                return this.rewriteInheritanceSpecifier(node);
            case NonterminalKind.InheritanceType:
                return this.rewriteInheritanceType(node);
            case NonterminalKind.InheritanceTypes:
                return this.rewriteInheritanceTypes(node);
            case NonterminalKind.InterfaceDefinition:
                return this.rewriteInterfaceDefinition(node);
            case NonterminalKind.InterfaceMembers:
                return this.rewriteInterfaceMembers(node);
            case NonterminalKind.LibraryDefinition:
                return this.rewriteLibraryDefinition(node);
            case NonterminalKind.LibraryMembers:
                return this.rewriteLibraryMembers(node);
            case NonterminalKind.MappingKey:
                return this.rewriteMappingKey(node);
            case NonterminalKind.MappingKeyType:
                return this.rewriteMappingKeyType(node);
            case NonterminalKind.MappingType:
                return this.rewriteMappingType(node);
            case NonterminalKind.MappingValue:
                return this.rewriteMappingValue(node);
            case NonterminalKind.MemberAccessExpression:
                return this.rewriteMemberAccessExpression(node);
            case NonterminalKind.ModifierAttribute:
                return this.rewriteModifierAttribute(node);
            case NonterminalKind.ModifierAttributes:
                return this.rewriteModifierAttributes(node);
            case NonterminalKind.ModifierDefinition:
                return this.rewriteModifierDefinition(node);
            case NonterminalKind.ModifierInvocation:
                return this.rewriteModifierInvocation(node);
            case NonterminalKind.MultiplicativeExpression:
                return this.rewriteMultiplicativeExpression(node);
            case NonterminalKind.NamedArgument:
                return this.rewriteNamedArgument(node);
            case NonterminalKind.NamedArgumentGroup:
                return this.rewriteNamedArgumentGroup(node);
            case NonterminalKind.NamedArguments:
                return this.rewriteNamedArguments(node);
            case NonterminalKind.NamedArgumentsDeclaration:
                return this.rewriteNamedArgumentsDeclaration(node);
            case NonterminalKind.NamedImport:
                return this.rewriteNamedImport(node);
            case NonterminalKind.NewExpression:
                return this.rewriteNewExpression(node);
            case NonterminalKind.NumberUnit:
                return this.rewriteNumberUnit(node);
            case NonterminalKind.OrExpression:
                return this.rewriteOrExpression(node);
            case NonterminalKind.OverridePaths:
                return this.rewriteOverridePaths(node);
            case NonterminalKind.OverridePathsDeclaration:
                return this.rewriteOverridePathsDeclaration(node);
            case NonterminalKind.OverrideSpecifier:
                return this.rewriteOverrideSpecifier(node);
            case NonterminalKind.Parameter:
                return this.rewriteParameter(node);
            case NonterminalKind.Parameters:
                return this.rewriteParameters(node);
            case NonterminalKind.ParametersDeclaration:
                return this.rewriteParametersDeclaration(node);
            case NonterminalKind.PathImport:
                return this.rewritePathImport(node);
            case NonterminalKind.PositionalArguments:
                return this.rewritePositionalArguments(node);
            case NonterminalKind.PositionalArgumentsDeclaration:
                return this.rewritePositionalArgumentsDeclaration(node);
            case NonterminalKind.PostfixExpression:
                return this.rewritePostfixExpression(node);
            case NonterminalKind.Pragma:
                return this.rewritePragma(node);
            case NonterminalKind.PragmaDirective:
                return this.rewritePragmaDirective(node);
            case NonterminalKind.PrefixExpression:
                return this.rewritePrefixExpression(node);
            case NonterminalKind.ReceiveFunctionAttribute:
                return this.rewriteReceiveFunctionAttribute(node);
            case NonterminalKind.ReceiveFunctionAttributes:
                return this.rewriteReceiveFunctionAttributes(node);
            case NonterminalKind.ReceiveFunctionDefinition:
                return this.rewriteReceiveFunctionDefinition(node);
            case NonterminalKind.ReturnStatement:
                return this.rewriteReturnStatement(node);
            case NonterminalKind.ReturnsDeclaration:
                return this.rewriteReturnsDeclaration(node);
            case NonterminalKind.RevertStatement:
                return this.rewriteRevertStatement(node);
            case NonterminalKind.ShiftExpression:
                return this.rewriteShiftExpression(node);
            case NonterminalKind.SimpleVersionLiteral:
                return this.rewriteSimpleVersionLiteral(node);
            case NonterminalKind.SourceUnit:
                return this.rewriteSourceUnit(node);
            case NonterminalKind.SourceUnitMember:
                return this.rewriteSourceUnitMember(node);
            case NonterminalKind.SourceUnitMembers:
                return this.rewriteSourceUnitMembers(node);
            case NonterminalKind.StateVariableAttribute:
                return this.rewriteStateVariableAttribute(node);
            case NonterminalKind.StateVariableAttributes:
                return this.rewriteStateVariableAttributes(node);
            case NonterminalKind.StateVariableDefinition:
                return this.rewriteStateVariableDefinition(node);
            case NonterminalKind.StateVariableDefinitionValue:
                return this.rewriteStateVariableDefinitionValue(node);
            case NonterminalKind.Statement:
                return this.rewriteStatement(node);
            case NonterminalKind.Statements:
                return this.rewriteStatements(node);
            case NonterminalKind.StorageLayoutSpecifier:
                return this.rewriteStorageLayoutSpecifier(node);
            case NonterminalKind.StorageLocation:
                return this.rewriteStorageLocation(node);
            case NonterminalKind.StringExpression:
                return this.rewriteStringExpression(node);
            case NonterminalKind.StringLiteral:
                return this.rewriteStringLiteral(node);
            case NonterminalKind.StringLiterals:
                return this.rewriteStringLiterals(node);
            case NonterminalKind.StructDefinition:
                return this.rewriteStructDefinition(node);
            case NonterminalKind.StructMember:
                return this.rewriteStructMember(node);
            case NonterminalKind.StructMembers:
                return this.rewriteStructMembers(node);
            case NonterminalKind.ThrowStatement:
                return this.rewriteThrowStatement(node);
            case NonterminalKind.TryStatement:
                return this.rewriteTryStatement(node);
            case NonterminalKind.TupleDeconstructionElement:
                return this.rewriteTupleDeconstructionElement(node);
            case NonterminalKind.TupleDeconstructionElements:
                return this.rewriteTupleDeconstructionElements(node);
            case NonterminalKind.TupleDeconstructionStatement:
                return this.rewriteTupleDeconstructionStatement(node);
            case NonterminalKind.TupleExpression:
                return this.rewriteTupleExpression(node);
            case NonterminalKind.TupleMember:
                return this.rewriteTupleMember(node);
            case NonterminalKind.TupleValue:
                return this.rewriteTupleValue(node);
            case NonterminalKind.TupleValues:
                return this.rewriteTupleValues(node);
            case NonterminalKind.TypeExpression:
                return this.rewriteTypeExpression(node);
            case NonterminalKind.TypeName:
                return this.rewriteTypeName(node);
            case NonterminalKind.TypedTupleMember:
                return this.rewriteTypedTupleMember(node);
            case NonterminalKind.UncheckedBlock:
                return this.rewriteUncheckedBlock(node);
            case NonterminalKind.UnicodeStringLiteral:
                return this.rewriteUnicodeStringLiteral(node);
            case NonterminalKind.UnicodeStringLiterals:
                return this.rewriteUnicodeStringLiterals(node);
            case NonterminalKind.UnnamedFunctionAttribute:
                return this.rewriteUnnamedFunctionAttribute(node);
            case NonterminalKind.UnnamedFunctionAttributes:
                return this.rewriteUnnamedFunctionAttributes(node);
            case NonterminalKind.UnnamedFunctionDefinition:
                return this.rewriteUnnamedFunctionDefinition(node);
            case NonterminalKind.UntypedTupleMember:
                return this.rewriteUntypedTupleMember(node);
            case NonterminalKind.UserDefinedValueTypeDefinition:
                return this.rewriteUserDefinedValueTypeDefinition(node);
            case NonterminalKind.UsingAlias:
                return this.rewriteUsingAlias(node);
            case NonterminalKind.UsingClause:
                return this.rewriteUsingClause(node);
            case NonterminalKind.UsingDeconstruction:
                return this.rewriteUsingDeconstruction(node);
            case NonterminalKind.UsingDeconstructionSymbol:
                return this.rewriteUsingDeconstructionSymbol(node);
            case NonterminalKind.UsingDeconstructionSymbols:
                return this.rewriteUsingDeconstructionSymbols(node);
            case NonterminalKind.UsingDirective:
                return this.rewriteUsingDirective(node);
            case NonterminalKind.UsingOperator:
                return this.rewriteUsingOperator(node);
            case NonterminalKind.UsingTarget:
                return this.rewriteUsingTarget(node);
            case NonterminalKind.VariableDeclarationStatement:
                return this.rewriteVariableDeclarationStatement(node);
            case NonterminalKind.VariableDeclarationType:
                return this.rewriteVariableDeclarationType(node);
            case NonterminalKind.VariableDeclarationValue:
                return this.rewriteVariableDeclarationValue(node);
            case NonterminalKind.VersionExpression:
                return this.rewriteVersionExpression(node);
            case NonterminalKind.VersionExpressionSet:
                return this.rewriteVersionExpressionSet(node);
            case NonterminalKind.VersionExpressionSets:
                return this.rewriteVersionExpressionSets(node);
            case NonterminalKind.VersionLiteral:
                return this.rewriteVersionLiteral(node);
            case NonterminalKind.VersionOperator:
                return this.rewriteVersionOperator(node);
            case NonterminalKind.VersionPragma:
                return this.rewriteVersionPragma(node);
            case NonterminalKind.VersionRange:
                return this.rewriteVersionRange(node);
            case NonterminalKind.VersionTerm:
                return this.rewriteVersionTerm(node);
            case NonterminalKind.WhileStatement:
                return this.rewriteWhileStatement(node);
            case NonterminalKind.YulArguments:
                return this.rewriteYulArguments(node);
            case NonterminalKind.YulAssignmentOperator:
                return this.rewriteYulAssignmentOperator(node);
            case NonterminalKind.YulBlock:
                return this.rewriteYulBlock(node);
            case NonterminalKind.YulBreakStatement:
                return this.rewriteYulBreakStatement(node);
            case NonterminalKind.YulColonAndEqual:
                return this.rewriteYulColonAndEqual(node);
            case NonterminalKind.YulContinueStatement:
                return this.rewriteYulContinueStatement(node);
            case NonterminalKind.YulDefaultCase:
                return this.rewriteYulDefaultCase(node);
            case NonterminalKind.YulEqualAndColon:
                return this.rewriteYulEqualAndColon(node);
            case NonterminalKind.YulExpression:
                return this.rewriteYulExpression(node);
            case NonterminalKind.YulForStatement:
                return this.rewriteYulForStatement(node);
            case NonterminalKind.YulFunctionCallExpression:
                return this.rewriteYulFunctionCallExpression(node);
            case NonterminalKind.YulFunctionDefinition:
                return this.rewriteYulFunctionDefinition(node);
            case NonterminalKind.YulIfStatement:
                return this.rewriteYulIfStatement(node);
            case NonterminalKind.YulLabel:
                return this.rewriteYulLabel(node);
            case NonterminalKind.YulLeaveStatement:
                return this.rewriteYulLeaveStatement(node);
            case NonterminalKind.YulLiteral:
                return this.rewriteYulLiteral(node);
            case NonterminalKind.YulParameters:
                return this.rewriteYulParameters(node);
            case NonterminalKind.YulParametersDeclaration:
                return this.rewriteYulParametersDeclaration(node);
            case NonterminalKind.YulPath:
                return this.rewriteYulPath(node);
            case NonterminalKind.YulPaths:
                return this.rewriteYulPaths(node);
            case NonterminalKind.YulReturnsDeclaration:
                return this.rewriteYulReturnsDeclaration(node);
            case NonterminalKind.YulStackAssignmentOperator:
                return this.rewriteYulStackAssignmentOperator(node);
            case NonterminalKind.YulStackAssignmentStatement:
                return this.rewriteYulStackAssignmentStatement(node);
            case NonterminalKind.YulStatement:
                return this.rewriteYulStatement(node);
            case NonterminalKind.YulStatements:
                return this.rewriteYulStatements(node);
            case NonterminalKind.YulSwitchCase:
                return this.rewriteYulSwitchCase(node);
            case NonterminalKind.YulSwitchCases:
                return this.rewriteYulSwitchCases(node);
            case NonterminalKind.YulSwitchStatement:
                return this.rewriteYulSwitchStatement(node);
            case NonterminalKind.YulValueCase:
                return this.rewriteYulValueCase(node);
            case NonterminalKind.YulVariableAssignmentStatement:
                return this.rewriteYulVariableAssignmentStatement(node);
            case NonterminalKind.YulVariableDeclarationStatement:
                return this.rewriteYulVariableDeclarationStatement(node);
            case NonterminalKind.YulVariableDeclarationValue:
                return this.rewriteYulVariableDeclarationValue(node);
            case NonterminalKind.YulVariableNames:
                return this.rewriteYulVariableNames(node);
        }
    }
    /** Rewrites a terminal node. Typically called from `rewriteNode`. */
    rewriteTerminalNode(node) {
        switch (node.kind) {
            case TerminalKind.ABIEncoderV2Keyword:
                return this.rewriteABIEncoderV2Keyword(node);
            case TerminalKind.AbicoderKeyword:
                return this.rewriteAbicoderKeyword(node);
            case TerminalKind.AbicoderV1Keyword:
                return this.rewriteAbicoderV1Keyword(node);
            case TerminalKind.AbicoderV2Keyword:
                return this.rewriteAbicoderV2Keyword(node);
            case TerminalKind.AbstractKeyword:
                return this.rewriteAbstractKeyword(node);
            case TerminalKind.AddressKeyword:
                return this.rewriteAddressKeyword(node);
            case TerminalKind.AfterKeyword:
                return this.rewriteAfterKeyword(node);
            case TerminalKind.AliasKeyword:
                return this.rewriteAliasKeyword(node);
            case TerminalKind.Ampersand:
                return this.rewriteAmpersand(node);
            case TerminalKind.AmpersandAmpersand:
                return this.rewriteAmpersandAmpersand(node);
            case TerminalKind.AmpersandEqual:
                return this.rewriteAmpersandEqual(node);
            case TerminalKind.AnonymousKeyword:
                return this.rewriteAnonymousKeyword(node);
            case TerminalKind.ApplyKeyword:
                return this.rewriteApplyKeyword(node);
            case TerminalKind.AsKeyword:
                return this.rewriteAsKeyword(node);
            case TerminalKind.AssemblyKeyword:
                return this.rewriteAssemblyKeyword(node);
            case TerminalKind.Asterisk:
                return this.rewriteAsterisk(node);
            case TerminalKind.AsteriskAsterisk:
                return this.rewriteAsteriskAsterisk(node);
            case TerminalKind.AsteriskEqual:
                return this.rewriteAsteriskEqual(node);
            case TerminalKind.AtKeyword:
                return this.rewriteAtKeyword(node);
            case TerminalKind.AutoKeyword:
                return this.rewriteAutoKeyword(node);
            case TerminalKind.Bang:
                return this.rewriteBang(node);
            case TerminalKind.BangEqual:
                return this.rewriteBangEqual(node);
            case TerminalKind.Bar:
                return this.rewriteBar(node);
            case TerminalKind.BarBar:
                return this.rewriteBarBar(node);
            case TerminalKind.BarEqual:
                return this.rewriteBarEqual(node);
            case TerminalKind.BoolKeyword:
                return this.rewriteBoolKeyword(node);
            case TerminalKind.BreakKeyword:
                return this.rewriteBreakKeyword(node);
            case TerminalKind.ByteKeyword:
                return this.rewriteByteKeyword(node);
            case TerminalKind.BytesKeyword:
                return this.rewriteBytesKeyword(node);
            case TerminalKind.CallDataKeyword:
                return this.rewriteCallDataKeyword(node);
            case TerminalKind.Caret:
                return this.rewriteCaret(node);
            case TerminalKind.CaretEqual:
                return this.rewriteCaretEqual(node);
            case TerminalKind.CaseKeyword:
                return this.rewriteCaseKeyword(node);
            case TerminalKind.CatchKeyword:
                return this.rewriteCatchKeyword(node);
            case TerminalKind.CloseBrace:
                return this.rewriteCloseBrace(node);
            case TerminalKind.CloseBracket:
                return this.rewriteCloseBracket(node);
            case TerminalKind.CloseParen:
                return this.rewriteCloseParen(node);
            case TerminalKind.Colon:
                return this.rewriteColon(node);
            case TerminalKind.ColonEqual:
                return this.rewriteColonEqual(node);
            case TerminalKind.Comma:
                return this.rewriteComma(node);
            case TerminalKind.ConstantKeyword:
                return this.rewriteConstantKeyword(node);
            case TerminalKind.ConstructorKeyword:
                return this.rewriteConstructorKeyword(node);
            case TerminalKind.ContinueKeyword:
                return this.rewriteContinueKeyword(node);
            case TerminalKind.ContractKeyword:
                return this.rewriteContractKeyword(node);
            case TerminalKind.CopyOfKeyword:
                return this.rewriteCopyOfKeyword(node);
            case TerminalKind.DaysKeyword:
                return this.rewriteDaysKeyword(node);
            case TerminalKind.DecimalLiteral:
                return this.rewriteDecimalLiteral(node);
            case TerminalKind.DefaultKeyword:
                return this.rewriteDefaultKeyword(node);
            case TerminalKind.DefineKeyword:
                return this.rewriteDefineKeyword(node);
            case TerminalKind.DeleteKeyword:
                return this.rewriteDeleteKeyword(node);
            case TerminalKind.DoKeyword:
                return this.rewriteDoKeyword(node);
            case TerminalKind.DoubleQuotedHexStringLiteral:
                return this.rewriteDoubleQuotedHexStringLiteral(node);
            case TerminalKind.DoubleQuotedStringLiteral:
                return this.rewriteDoubleQuotedStringLiteral(node);
            case TerminalKind.DoubleQuotedUnicodeStringLiteral:
                return this.rewriteDoubleQuotedUnicodeStringLiteral(node);
            case TerminalKind.DoubleQuotedVersionLiteral:
                return this.rewriteDoubleQuotedVersionLiteral(node);
            case TerminalKind.ElseKeyword:
                return this.rewriteElseKeyword(node);
            case TerminalKind.EmitKeyword:
                return this.rewriteEmitKeyword(node);
            case TerminalKind.EndOfLine:
                return this.rewriteEndOfLine(node);
            case TerminalKind.EnumKeyword:
                return this.rewriteEnumKeyword(node);
            case TerminalKind.Equal:
                return this.rewriteEqual(node);
            case TerminalKind.EqualColon:
                return this.rewriteEqualColon(node);
            case TerminalKind.EqualEqual:
                return this.rewriteEqualEqual(node);
            case TerminalKind.EqualGreaterThan:
                return this.rewriteEqualGreaterThan(node);
            case TerminalKind.ErrorKeyword:
                return this.rewriteErrorKeyword(node);
            case TerminalKind.EtherKeyword:
                return this.rewriteEtherKeyword(node);
            case TerminalKind.EventKeyword:
                return this.rewriteEventKeyword(node);
            case TerminalKind.ExperimentalKeyword:
                return this.rewriteExperimentalKeyword(node);
            case TerminalKind.ExternalKeyword:
                return this.rewriteExternalKeyword(node);
            case TerminalKind.FallbackKeyword:
                return this.rewriteFallbackKeyword(node);
            case TerminalKind.FalseKeyword:
                return this.rewriteFalseKeyword(node);
            case TerminalKind.FinalKeyword:
                return this.rewriteFinalKeyword(node);
            case TerminalKind.FinneyKeyword:
                return this.rewriteFinneyKeyword(node);
            case TerminalKind.FixedKeyword:
                return this.rewriteFixedKeyword(node);
            case TerminalKind.ForKeyword:
                return this.rewriteForKeyword(node);
            case TerminalKind.FromKeyword:
                return this.rewriteFromKeyword(node);
            case TerminalKind.FunctionKeyword:
                return this.rewriteFunctionKeyword(node);
            case TerminalKind.GlobalKeyword:
                return this.rewriteGlobalKeyword(node);
            case TerminalKind.GreaterThan:
                return this.rewriteGreaterThan(node);
            case TerminalKind.GreaterThanEqual:
                return this.rewriteGreaterThanEqual(node);
            case TerminalKind.GreaterThanGreaterThan:
                return this.rewriteGreaterThanGreaterThan(node);
            case TerminalKind.GreaterThanGreaterThanEqual:
                return this.rewriteGreaterThanGreaterThanEqual(node);
            case TerminalKind.GreaterThanGreaterThanGreaterThan:
                return this.rewriteGreaterThanGreaterThanGreaterThan(node);
            case TerminalKind.GreaterThanGreaterThanGreaterThanEqual:
                return this.rewriteGreaterThanGreaterThanGreaterThanEqual(node);
            case TerminalKind.GweiKeyword:
                return this.rewriteGweiKeyword(node);
            case TerminalKind.HexKeyword:
                return this.rewriteHexKeyword(node);
            case TerminalKind.HexLiteral:
                return this.rewriteHexLiteral(node);
            case TerminalKind.HoursKeyword:
                return this.rewriteHoursKeyword(node);
            case TerminalKind.Identifier:
                return this.rewriteIdentifier(node);
            case TerminalKind.IfKeyword:
                return this.rewriteIfKeyword(node);
            case TerminalKind.ImmutableKeyword:
                return this.rewriteImmutableKeyword(node);
            case TerminalKind.ImplementsKeyword:
                return this.rewriteImplementsKeyword(node);
            case TerminalKind.ImportKeyword:
                return this.rewriteImportKeyword(node);
            case TerminalKind.InKeyword:
                return this.rewriteInKeyword(node);
            case TerminalKind.IndexedKeyword:
                return this.rewriteIndexedKeyword(node);
            case TerminalKind.InlineKeyword:
                return this.rewriteInlineKeyword(node);
            case TerminalKind.IntKeyword:
                return this.rewriteIntKeyword(node);
            case TerminalKind.InterfaceKeyword:
                return this.rewriteInterfaceKeyword(node);
            case TerminalKind.InternalKeyword:
                return this.rewriteInternalKeyword(node);
            case TerminalKind.IsKeyword:
                return this.rewriteIsKeyword(node);
            case TerminalKind.LayoutKeyword:
                return this.rewriteLayoutKeyword(node);
            case TerminalKind.LessThan:
                return this.rewriteLessThan(node);
            case TerminalKind.LessThanEqual:
                return this.rewriteLessThanEqual(node);
            case TerminalKind.LessThanLessThan:
                return this.rewriteLessThanLessThan(node);
            case TerminalKind.LessThanLessThanEqual:
                return this.rewriteLessThanLessThanEqual(node);
            case TerminalKind.LetKeyword:
                return this.rewriteLetKeyword(node);
            case TerminalKind.LibraryKeyword:
                return this.rewriteLibraryKeyword(node);
            case TerminalKind.MacroKeyword:
                return this.rewriteMacroKeyword(node);
            case TerminalKind.MappingKeyword:
                return this.rewriteMappingKeyword(node);
            case TerminalKind.MatchKeyword:
                return this.rewriteMatchKeyword(node);
            case TerminalKind.MemoryKeyword:
                return this.rewriteMemoryKeyword(node);
            case TerminalKind.Minus:
                return this.rewriteMinus(node);
            case TerminalKind.MinusEqual:
                return this.rewriteMinusEqual(node);
            case TerminalKind.MinusGreaterThan:
                return this.rewriteMinusGreaterThan(node);
            case TerminalKind.MinusMinus:
                return this.rewriteMinusMinus(node);
            case TerminalKind.MinutesKeyword:
                return this.rewriteMinutesKeyword(node);
            case TerminalKind.ModifierKeyword:
                return this.rewriteModifierKeyword(node);
            case TerminalKind.MultiLineComment:
                return this.rewriteMultiLineComment(node);
            case TerminalKind.MultiLineNatSpecComment:
                return this.rewriteMultiLineNatSpecComment(node);
            case TerminalKind.MutableKeyword:
                return this.rewriteMutableKeyword(node);
            case TerminalKind.NewKeyword:
                return this.rewriteNewKeyword(node);
            case TerminalKind.NullKeyword:
                return this.rewriteNullKeyword(node);
            case TerminalKind.OfKeyword:
                return this.rewriteOfKeyword(node);
            case TerminalKind.OpenBrace:
                return this.rewriteOpenBrace(node);
            case TerminalKind.OpenBracket:
                return this.rewriteOpenBracket(node);
            case TerminalKind.OpenParen:
                return this.rewriteOpenParen(node);
            case TerminalKind.OverrideKeyword:
                return this.rewriteOverrideKeyword(node);
            case TerminalKind.PartialKeyword:
                return this.rewritePartialKeyword(node);
            case TerminalKind.PayableKeyword:
                return this.rewritePayableKeyword(node);
            case TerminalKind.Percent:
                return this.rewritePercent(node);
            case TerminalKind.PercentEqual:
                return this.rewritePercentEqual(node);
            case TerminalKind.Period:
                return this.rewritePeriod(node);
            case TerminalKind.Plus:
                return this.rewritePlus(node);
            case TerminalKind.PlusEqual:
                return this.rewritePlusEqual(node);
            case TerminalKind.PlusPlus:
                return this.rewritePlusPlus(node);
            case TerminalKind.PragmaKeyword:
                return this.rewritePragmaKeyword(node);
            case TerminalKind.PrivateKeyword:
                return this.rewritePrivateKeyword(node);
            case TerminalKind.PromiseKeyword:
                return this.rewritePromiseKeyword(node);
            case TerminalKind.PublicKeyword:
                return this.rewritePublicKeyword(node);
            case TerminalKind.PureKeyword:
                return this.rewritePureKeyword(node);
            case TerminalKind.QuestionMark:
                return this.rewriteQuestionMark(node);
            case TerminalKind.ReceiveKeyword:
                return this.rewriteReceiveKeyword(node);
            case TerminalKind.ReferenceKeyword:
                return this.rewriteReferenceKeyword(node);
            case TerminalKind.RelocatableKeyword:
                return this.rewriteRelocatableKeyword(node);
            case TerminalKind.ReturnKeyword:
                return this.rewriteReturnKeyword(node);
            case TerminalKind.ReturnsKeyword:
                return this.rewriteReturnsKeyword(node);
            case TerminalKind.RevertKeyword:
                return this.rewriteRevertKeyword(node);
            case TerminalKind.SMTCheckerKeyword:
                return this.rewriteSMTCheckerKeyword(node);
            case TerminalKind.SealedKeyword:
                return this.rewriteSealedKeyword(node);
            case TerminalKind.SecondsKeyword:
                return this.rewriteSecondsKeyword(node);
            case TerminalKind.Semicolon:
                return this.rewriteSemicolon(node);
            case TerminalKind.SingleLineComment:
                return this.rewriteSingleLineComment(node);
            case TerminalKind.SingleLineNatSpecComment:
                return this.rewriteSingleLineNatSpecComment(node);
            case TerminalKind.SingleQuotedHexStringLiteral:
                return this.rewriteSingleQuotedHexStringLiteral(node);
            case TerminalKind.SingleQuotedStringLiteral:
                return this.rewriteSingleQuotedStringLiteral(node);
            case TerminalKind.SingleQuotedUnicodeStringLiteral:
                return this.rewriteSingleQuotedUnicodeStringLiteral(node);
            case TerminalKind.SingleQuotedVersionLiteral:
                return this.rewriteSingleQuotedVersionLiteral(node);
            case TerminalKind.SizeOfKeyword:
                return this.rewriteSizeOfKeyword(node);
            case TerminalKind.Slash:
                return this.rewriteSlash(node);
            case TerminalKind.SlashEqual:
                return this.rewriteSlashEqual(node);
            case TerminalKind.SolidityKeyword:
                return this.rewriteSolidityKeyword(node);
            case TerminalKind.StaticKeyword:
                return this.rewriteStaticKeyword(node);
            case TerminalKind.StorageKeyword:
                return this.rewriteStorageKeyword(node);
            case TerminalKind.StringKeyword:
                return this.rewriteStringKeyword(node);
            case TerminalKind.StructKeyword:
                return this.rewriteStructKeyword(node);
            case TerminalKind.SuperKeyword:
                return this.rewriteSuperKeyword(node);
            case TerminalKind.SupportsKeyword:
                return this.rewriteSupportsKeyword(node);
            case TerminalKind.SwitchKeyword:
                return this.rewriteSwitchKeyword(node);
            case TerminalKind.SzaboKeyword:
                return this.rewriteSzaboKeyword(node);
            case TerminalKind.ThisKeyword:
                return this.rewriteThisKeyword(node);
            case TerminalKind.ThrowKeyword:
                return this.rewriteThrowKeyword(node);
            case TerminalKind.Tilde:
                return this.rewriteTilde(node);
            case TerminalKind.TransientKeyword:
                return this.rewriteTransientKeyword(node);
            case TerminalKind.TrueKeyword:
                return this.rewriteTrueKeyword(node);
            case TerminalKind.TryKeyword:
                return this.rewriteTryKeyword(node);
            case TerminalKind.TypeDefKeyword:
                return this.rewriteTypeDefKeyword(node);
            case TerminalKind.TypeKeyword:
                return this.rewriteTypeKeyword(node);
            case TerminalKind.TypeOfKeyword:
                return this.rewriteTypeOfKeyword(node);
            case TerminalKind.UfixedKeyword:
                return this.rewriteUfixedKeyword(node);
            case TerminalKind.UintKeyword:
                return this.rewriteUintKeyword(node);
            case TerminalKind.UncheckedKeyword:
                return this.rewriteUncheckedKeyword(node);
            case TerminalKind.UsingKeyword:
                return this.rewriteUsingKeyword(node);
            case TerminalKind.VarKeyword:
                return this.rewriteVarKeyword(node);
            case TerminalKind.VersionSpecifier:
                return this.rewriteVersionSpecifier(node);
            case TerminalKind.ViewKeyword:
                return this.rewriteViewKeyword(node);
            case TerminalKind.VirtualKeyword:
                return this.rewriteVirtualKeyword(node);
            case TerminalKind.WeeksKeyword:
                return this.rewriteWeeksKeyword(node);
            case TerminalKind.WeiKeyword:
                return this.rewriteWeiKeyword(node);
            case TerminalKind.WhileKeyword:
                return this.rewriteWhileKeyword(node);
            case TerminalKind.Whitespace:
                return this.rewriteWhitespace(node);
            case TerminalKind.YearsKeyword:
                return this.rewriteYearsKeyword(node);
            case TerminalKind.YulAbstractKeyword:
                return this.rewriteYulAbstractKeyword(node);
            case TerminalKind.YulAfterKeyword:
                return this.rewriteYulAfterKeyword(node);
            case TerminalKind.YulAliasKeyword:
                return this.rewriteYulAliasKeyword(node);
            case TerminalKind.YulAnonymousKeyword:
                return this.rewriteYulAnonymousKeyword(node);
            case TerminalKind.YulApplyKeyword:
                return this.rewriteYulApplyKeyword(node);
            case TerminalKind.YulAsKeyword:
                return this.rewriteYulAsKeyword(node);
            case TerminalKind.YulAssemblyKeyword:
                return this.rewriteYulAssemblyKeyword(node);
            case TerminalKind.YulAutoKeyword:
                return this.rewriteYulAutoKeyword(node);
            case TerminalKind.YulBoolKeyword:
                return this.rewriteYulBoolKeyword(node);
            case TerminalKind.YulBreakKeyword:
                return this.rewriteYulBreakKeyword(node);
            case TerminalKind.YulBytesKeyword:
                return this.rewriteYulBytesKeyword(node);
            case TerminalKind.YulCallDataKeyword:
                return this.rewriteYulCallDataKeyword(node);
            case TerminalKind.YulCaseKeyword:
                return this.rewriteYulCaseKeyword(node);
            case TerminalKind.YulCatchKeyword:
                return this.rewriteYulCatchKeyword(node);
            case TerminalKind.YulConstantKeyword:
                return this.rewriteYulConstantKeyword(node);
            case TerminalKind.YulConstructorKeyword:
                return this.rewriteYulConstructorKeyword(node);
            case TerminalKind.YulContinueKeyword:
                return this.rewriteYulContinueKeyword(node);
            case TerminalKind.YulContractKeyword:
                return this.rewriteYulContractKeyword(node);
            case TerminalKind.YulCopyOfKeyword:
                return this.rewriteYulCopyOfKeyword(node);
            case TerminalKind.YulDaysKeyword:
                return this.rewriteYulDaysKeyword(node);
            case TerminalKind.YulDecimalLiteral:
                return this.rewriteYulDecimalLiteral(node);
            case TerminalKind.YulDefaultKeyword:
                return this.rewriteYulDefaultKeyword(node);
            case TerminalKind.YulDefineKeyword:
                return this.rewriteYulDefineKeyword(node);
            case TerminalKind.YulDeleteKeyword:
                return this.rewriteYulDeleteKeyword(node);
            case TerminalKind.YulDoKeyword:
                return this.rewriteYulDoKeyword(node);
            case TerminalKind.YulElseKeyword:
                return this.rewriteYulElseKeyword(node);
            case TerminalKind.YulEmitKeyword:
                return this.rewriteYulEmitKeyword(node);
            case TerminalKind.YulEnumKeyword:
                return this.rewriteYulEnumKeyword(node);
            case TerminalKind.YulEtherKeyword:
                return this.rewriteYulEtherKeyword(node);
            case TerminalKind.YulEventKeyword:
                return this.rewriteYulEventKeyword(node);
            case TerminalKind.YulExternalKeyword:
                return this.rewriteYulExternalKeyword(node);
            case TerminalKind.YulFallbackKeyword:
                return this.rewriteYulFallbackKeyword(node);
            case TerminalKind.YulFalseKeyword:
                return this.rewriteYulFalseKeyword(node);
            case TerminalKind.YulFinalKeyword:
                return this.rewriteYulFinalKeyword(node);
            case TerminalKind.YulFinneyKeyword:
                return this.rewriteYulFinneyKeyword(node);
            case TerminalKind.YulFixedKeyword:
                return this.rewriteYulFixedKeyword(node);
            case TerminalKind.YulForKeyword:
                return this.rewriteYulForKeyword(node);
            case TerminalKind.YulFunctionKeyword:
                return this.rewriteYulFunctionKeyword(node);
            case TerminalKind.YulGweiKeyword:
                return this.rewriteYulGweiKeyword(node);
            case TerminalKind.YulHexKeyword:
                return this.rewriteYulHexKeyword(node);
            case TerminalKind.YulHexLiteral:
                return this.rewriteYulHexLiteral(node);
            case TerminalKind.YulHoursKeyword:
                return this.rewriteYulHoursKeyword(node);
            case TerminalKind.YulIdentifier:
                return this.rewriteYulIdentifier(node);
            case TerminalKind.YulIfKeyword:
                return this.rewriteYulIfKeyword(node);
            case TerminalKind.YulImmutableKeyword:
                return this.rewriteYulImmutableKeyword(node);
            case TerminalKind.YulImplementsKeyword:
                return this.rewriteYulImplementsKeyword(node);
            case TerminalKind.YulImportKeyword:
                return this.rewriteYulImportKeyword(node);
            case TerminalKind.YulInKeyword:
                return this.