@nomicfoundation/slang
Version:
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.
1,378 lines (1,377 loc) • 191 kB
TypeScript
// This file is generated automatically by infrastructure scripts. Please don't edit by hand.
export namespace NomicFoundationSlangCst {
export { TerminalKindExtensions };
export { NonterminalNode };
export { TerminalNode };
export { Cursor };
export { CursorIterator };
export { AncestorsIterator };
export { Query };
export { QueryMatchIterator };
export { NonterminalKind };
export { TerminalKind };
export { EdgeLabel };
export { Node };
export { NodeType };
}
/**
* Represents different kinds of nonterminal nodes in the syntax tree.
* These are nodes that can have child nodes and represent higher-level language constructs.
*/
export declare enum NonterminalKind {
/**
* Represents a node with kind `AbicoderPragma`, having the following structure:
*
* ```ebnf
* AbicoderPragma = (* abicoder_keyword: *) ABICODER_KEYWORD
* (* version: *) IDENTIFIER;
* ```
*/
AbicoderPragma = "AbicoderPragma",
/**
* Represents a node with kind `AdditiveExpression`, having the following structure:
*
* ```ebnf
* (* Left-associative binary operator *)
* AdditiveExpression = (* left_operand: *) Expression
* (* operator: *) PLUS
* (* right_operand: *) Expression;
*
* (* Left-associative binary operator *)
* AdditiveExpression = (* left_operand: *) Expression
* (* operator: *) MINUS
* (* right_operand: *) Expression;
* ```
*/
AdditiveExpression = "AdditiveExpression",
/**
* Represents a node with kind `AddressType`, having the following structure:
*
* ```ebnf
* AddressType = (* address_keyword: *) ADDRESS_KEYWORD
* (* payable_keyword: *) PAYABLE_KEYWORD?; (* Introduced in 0.5.0 *)
* ```
*/
AddressType = "AddressType",
/**
* Represents a node with kind `AndExpression`, having the following structure:
*
* ```ebnf
* (* Left-associative binary operator *)
* AndExpression = (* left_operand: *) Expression
* (* operator: *) AMPERSAND_AMPERSAND
* (* right_operand: *) Expression;
* ```
*/
AndExpression = "AndExpression",
/**
* Represents a node with kind `ArgumentsDeclaration`, having the following structure:
*
* ```ebnf
* ArgumentsDeclaration = (* variant: *) PositionalArgumentsDeclaration
* | (* variant: *) NamedArgumentsDeclaration;
* ```
*/
ArgumentsDeclaration = "ArgumentsDeclaration",
/**
* Represents a node with kind `ArrayExpression`, having the following structure:
*
* ```ebnf
* ArrayExpression = (* open_bracket: *) OPEN_BRACKET
* (* items: *) ArrayValues
* (* close_bracket: *) CLOSE_BRACKET;
* ```
*/
ArrayExpression = "ArrayExpression",
/**
* Represents a node with kind `ArrayTypeName`, having the following structure:
*
* ```ebnf
* (* Postfix unary operator *)
* ArrayTypeName = (* operand: *) TypeName
* (* open_bracket: *) OPEN_BRACKET
* (* index: *) Expression?
* (* close_bracket: *) CLOSE_BRACKET;
* ```
*/
ArrayTypeName = "ArrayTypeName",
/**
* Represents a node with kind `ArrayValues`, having the following structure:
*
* ```ebnf
* ArrayValues = (* item: *) Expression ((* separator: *) COMMA (* item: *) Expression)*;
* ```
*/
ArrayValues = "ArrayValues",
/**
* Represents a node with kind `AssemblyFlags`, having the following structure:
*
* ```ebnf
* (* Introduced in 0.8.13 *)
* AssemblyFlags = (* item: *) StringLiteral ((* separator: *) COMMA (* item: *) StringLiteral)*;
* ```
*/
AssemblyFlags = "AssemblyFlags",
/**
* Represents a node with kind `AssemblyFlagsDeclaration`, having the following structure:
*
* ```ebnf
* (* Introduced in 0.8.13 *)
* AssemblyFlagsDeclaration = (* open_paren: *) OPEN_PAREN
* (* flags: *) AssemblyFlags
* (* close_paren: *) CLOSE_PAREN;
* ```
*/
AssemblyFlagsDeclaration = "AssemblyFlagsDeclaration",
/**
* Represents a node with kind `AssemblyStatement`, having the following structure:
*
* ```ebnf
* AssemblyStatement = (* assembly_keyword: *) ASSEMBLY_KEYWORD
* (* label: *) StringLiteral?
* (* flags: *) AssemblyFlagsDeclaration? (* Introduced in 0.8.13 *)
* (* body: *) YulBlock;
* ```
*/
AssemblyStatement = "AssemblyStatement",
/**
* Represents a node with kind `AssignmentExpression`, having the following structure:
*
* ```ebnf
* (* Left-associative binary operator *)
* AssignmentExpression = (* left_operand: *) Expression
* (* operator: *) EQUAL
* (* right_operand: *) Expression;
*
* (* Left-associative binary operator *)
* AssignmentExpression = (* left_operand: *) Expression
* (* operator: *) BAR_EQUAL
* (* right_operand: *) Expression;
*
* (* Left-associative binary operator *)
* AssignmentExpression = (* left_operand: *) Expression
* (* operator: *) PLUS_EQUAL
* (* right_operand: *) Expression;
*
* (* Left-associative binary operator *)
* AssignmentExpression = (* left_operand: *) Expression
* (* operator: *) MINUS_EQUAL
* (* right_operand: *) Expression;
*
* (* Left-associative binary operator *)
* AssignmentExpression = (* left_operand: *) Expression
* (* operator: *) CARET_EQUAL
* (* right_operand: *) Expression;
*
* (* Left-associative binary operator *)
* AssignmentExpression = (* left_operand: *) Expression
* (* operator: *) SLASH_EQUAL
* (* right_operand: *) Expression;
*
* (* Left-associative binary operator *)
* AssignmentExpression = (* left_operand: *) Expression
* (* operator: *) PERCENT_EQUAL
* (* right_operand: *) Expression;
*
* (* Left-associative binary operator *)
* AssignmentExpression = (* left_operand: *) Expression
* (* operator: *) ASTERISK_EQUAL
* (* right_operand: *) Expression;
*
* (* Left-associative binary operator *)
* AssignmentExpression = (* left_operand: *) Expression
* (* operator: *) AMPERSAND_EQUAL
* (* right_operand: *) Expression;
*
* (* Left-associative binary operator *)
* AssignmentExpression = (* left_operand: *) Expression
* (* operator: *) LESS_THAN_LESS_THAN_EQUAL
* (* right_operand: *) Expression;
*
* (* Left-associative binary operator *)
* AssignmentExpression = (* left_operand: *) Expression
* (* operator: *) GREATER_THAN_GREATER_THAN_EQUAL
* (* right_operand: *) Expression;
*
* (* Left-associative binary operator *)
* AssignmentExpression = (* left_operand: *) Expression
* (* operator: *) GREATER_THAN_GREATER_THAN_GREATER_THAN_EQUAL
* (* right_operand: *) Expression;
* ```
*/
AssignmentExpression = "AssignmentExpression",
/**
* Represents a node with kind `BitwiseAndExpression`, having the following structure:
*
* ```ebnf
* (* Left-associative binary operator *)
* BitwiseAndExpression = (* left_operand: *) Expression
* (* operator: *) AMPERSAND
* (* right_operand: *) Expression;
* ```
*/
BitwiseAndExpression = "BitwiseAndExpression",
/**
* Represents a node with kind `BitwiseOrExpression`, having the following structure:
*
* ```ebnf
* (* Left-associative binary operator *)
* BitwiseOrExpression = (* left_operand: *) Expression
* (* operator: *) BAR
* (* right_operand: *) Expression;
* ```
*/
BitwiseOrExpression = "BitwiseOrExpression",
/**
* Represents a node with kind `BitwiseXorExpression`, having the following structure:
*
* ```ebnf
* (* Left-associative binary operator *)
* BitwiseXorExpression = (* left_operand: *) Expression
* (* operator: *) CARET
* (* right_operand: *) Expression;
* ```
*/
BitwiseXorExpression = "BitwiseXorExpression",
/**
* Represents a node with kind `Block`, having the following structure:
*
* ```ebnf
* Block = (* open_brace: *) OPEN_BRACE
* (* statements: *) Statements
* (* close_brace: *) CLOSE_BRACE;
* ```
*/
Block = "Block",
/**
* Represents a node with kind `BreakStatement`, having the following structure:
*
* ```ebnf
* BreakStatement = (* break_keyword: *) BREAK_KEYWORD
* (* semicolon: *) SEMICOLON;
* ```
*/
BreakStatement = "BreakStatement",
/**
* Represents a node with kind `CallOptions`, having the following structure:
*
* ```ebnf
* (* Introduced in 0.6.2 *)
* CallOptions = (* item: *) NamedArgument ((* separator: *) COMMA (* item: *) NamedArgument)*;
* ```
*/
CallOptions = "CallOptions",
/**
* Represents a node with kind `CallOptionsExpression`, having the following structure:
*
* ```ebnf
* (* Postfix unary operator *)
* (* Introduced in 0.6.2 *)
* CallOptionsExpression = (* operand: *) Expression
* (* open_brace: *) OPEN_BRACE
* (* options: *) CallOptions
* (* close_brace: *) CLOSE_BRACE;
* ```
*/
CallOptionsExpression = "CallOptionsExpression",
/**
* Represents a node with kind `CatchClause`, having the following structure:
*
* ```ebnf
* (* Introduced in 0.6.0 *)
* CatchClause = (* catch_keyword: *) CATCH_KEYWORD
* (* error: *) CatchClauseError?
* (* body: *) Block;
* ```
*/
CatchClause = "CatchClause",
/**
* Represents a node with kind `CatchClauseError`, having the following structure:
*
* ```ebnf
* (* Introduced in 0.6.0 *)
* CatchClauseError = (* name: *) IDENTIFIER?
* (* parameters: *) ParametersDeclaration;
* ```
*/
CatchClauseError = "CatchClauseError",
/**
* Represents a node with kind `CatchClauses`, having the following structure:
*
* ```ebnf
* (* Introduced in 0.6.0 *)
* CatchClauses = (* item: *) CatchClause+;
* ```
*/
CatchClauses = "CatchClauses",
/**
* Represents a node with kind `ConditionalExpression`, having the following structure:
*
* ```ebnf
* (* Postfix unary operator *)
* ConditionalExpression = (* operand: *) Expression
* (* question_mark: *) QUESTION_MARK
* (* true_expression: *) Expression
* (* colon: *) COLON
* (* false_expression: *) Expression;
* ```
*/
ConditionalExpression = "ConditionalExpression",
/**
* Represents a node with kind `ConstantDefinition`, having the following structure:
*
* ```ebnf
* (* Introduced in 0.7.4 *)
* ConstantDefinition = (* type_name: *) TypeName
* (* constant_keyword: *) CONSTANT_KEYWORD
* (* name: *) IDENTIFIER
* (* equal: *) EQUAL
* (* value: *) Expression
* (* semicolon: *) SEMICOLON;
* ```
*/
ConstantDefinition = "ConstantDefinition",
/**
* Represents a node with kind `ConstructorAttribute`, having the following structure:
*
* ```ebnf
* (* Introduced in 0.4.22 *)
* ConstructorAttribute = (* variant: *) ModifierInvocation
* | (* variant: *) INTERNAL_KEYWORD
* | (* variant: *) OVERRIDE_KEYWORD (* Introduced in 0.6.0 and deprecated in 0.6.7. *)
* | (* variant: *) PAYABLE_KEYWORD
* | (* variant: *) PUBLIC_KEYWORD
* | (* variant: *) VIRTUAL_KEYWORD; (* Introduced in 0.6.0 and deprecated in 0.6.7. *)
* ```
*/
ConstructorAttribute = "ConstructorAttribute",
/**
* Represents a node with kind `ConstructorAttributes`, having the following structure:
*
* ```ebnf
* (* Introduced in 0.4.22 *)
* ConstructorAttributes = (* item: *) ConstructorAttribute*;
* ```
*/
ConstructorAttributes = "ConstructorAttributes",
/**
* Represents a node with kind `ConstructorDefinition`, having the following structure:
*
* ```ebnf
* (* Introduced in 0.4.22 *)
* ConstructorDefinition = (* constructor_keyword: *) CONSTRUCTOR_KEYWORD
* (* parameters: *) ParametersDeclaration
* (* attributes: *) ConstructorAttributes
* (* body: *) Block;
* ```
*/
ConstructorDefinition = "ConstructorDefinition",
/**
* Represents a node with kind `ContinueStatement`, having the following structure:
*
* ```ebnf
* ContinueStatement = (* continue_keyword: *) CONTINUE_KEYWORD
* (* semicolon: *) SEMICOLON;
* ```
*/
ContinueStatement = "ContinueStatement",
/**
* Represents a node with kind `ContractDefinition`, having the following structure:
*
* ```ebnf
* ContractDefinition = (* abstract_keyword: *) ABSTRACT_KEYWORD? (* Introduced in 0.6.0 *)
* (* contract_keyword: *) CONTRACT_KEYWORD
* (* name: *) IDENTIFIER
* (* specifiers: *) ContractSpecifiers
* (* open_brace: *) OPEN_BRACE
* (* members: *) ContractMembers
* (* close_brace: *) CLOSE_BRACE;
* ```
*/
ContractDefinition = "ContractDefinition",
/**
* Represents a node with kind `ContractMember`, having the following structure:
*
* ```ebnf
* ContractMember = (* variant: *) UsingDirective
* | (* variant: *) FunctionDefinition
* | (* variant: *) ConstructorDefinition (* Introduced in 0.4.22 *)
* | (* variant: *) ReceiveFunctionDefinition (* Introduced in 0.6.0 *)
* | (* variant: *) FallbackFunctionDefinition (* Introduced in 0.6.0 *)
* | (* variant: *) UnnamedFunctionDefinition (* Deprecated in 0.6.0 *)
* | (* variant: *) ModifierDefinition
* | (* variant: *) StructDefinition
* | (* variant: *) EnumDefinition
* | (* variant: *) EventDefinition
* | (* variant: *) ErrorDefinition (* Introduced in 0.8.4 *)
* | (* variant: *) UserDefinedValueTypeDefinition (* Introduced in 0.8.8 *)
* | (* variant: *) StateVariableDefinition;
* ```
*/
ContractMember = "ContractMember",
/**
* Represents a node with kind `ContractMembers`, having the following structure:
*
* ```ebnf
* ContractMembers = (* item: *) ContractMember*;
* ```
*/
ContractMembers = "ContractMembers",
/**
* Represents a node with kind `ContractSpecifier`, having the following structure:
*
* ```ebnf
* ContractSpecifier = (* variant: *) InheritanceSpecifier
* | (* variant: *) StorageLayoutSpecifier; (* Introduced in 0.8.29 *)
* ```
*/
ContractSpecifier = "ContractSpecifier",
/**
* Represents a node with kind `ContractSpecifiers`, having the following structure:
*
* ```ebnf
* ContractSpecifiers = (* item: *) ContractSpecifier*;
* ```
*/
ContractSpecifiers = "ContractSpecifiers",
/**
* Represents a node with kind `DecimalNumberExpression`, having the following structure:
*
* ```ebnf
* DecimalNumberExpression = (* literal: *) DECIMAL_LITERAL
* (* unit: *) NumberUnit?;
* ```
*/
DecimalNumberExpression = "DecimalNumberExpression",
/**
* Represents a node with kind `DoWhileStatement`, having the following structure:
*
* ```ebnf
* DoWhileStatement = (* do_keyword: *) DO_KEYWORD
* (* body: *) Statement
* (* while_keyword: *) WHILE_KEYWORD
* (* open_paren: *) OPEN_PAREN
* (* condition: *) Expression
* (* close_paren: *) CLOSE_PAREN
* (* semicolon: *) SEMICOLON;
* ```
*/
DoWhileStatement = "DoWhileStatement",
/**
* Represents a node with kind `ElementaryType`, having the following structure:
*
* ```ebnf
* ElementaryType = (* variant: *) BOOL_KEYWORD
* | (* variant: *) BYTE_KEYWORD (* Deprecated in 0.8.0 *)
* | (* variant: *) STRING_KEYWORD
* | (* variant: *) AddressType
* | (* variant: *) BYTES_KEYWORD
* | (* variant: *) INT_KEYWORD
* | (* variant: *) UINT_KEYWORD
* | (* variant: *) FIXED_KEYWORD
* | (* variant: *) UFIXED_KEYWORD;
* ```
*/
ElementaryType = "ElementaryType",
/**
* Represents a node with kind `ElseBranch`, having the following structure:
*
* ```ebnf
* ElseBranch = (* else_keyword: *) ELSE_KEYWORD
* (* body: *) Statement;
* ```
*/
ElseBranch = "ElseBranch",
/**
* Represents a node with kind `EmitStatement`, having the following structure:
*
* ```ebnf
* (* Introduced in 0.4.21 *)
* EmitStatement = (* emit_keyword: *) EMIT_KEYWORD
* (* event: *) IdentifierPath
* (* arguments: *) ArgumentsDeclaration
* (* semicolon: *) SEMICOLON;
* ```
*/
EmitStatement = "EmitStatement",
/**
* Represents a node with kind `EnumDefinition`, having the following structure:
*
* ```ebnf
* EnumDefinition = (* enum_keyword: *) ENUM_KEYWORD
* (* name: *) IDENTIFIER
* (* open_brace: *) OPEN_BRACE
* (* members: *) EnumMembers
* (* close_brace: *) CLOSE_BRACE;
* ```
*/
EnumDefinition = "EnumDefinition",
/**
* Represents a node with kind `EnumMembers`, having the following structure:
*
* ```ebnf
* EnumMembers = ((* item: *) IDENTIFIER ((* separator: *) COMMA (* item: *) IDENTIFIER)*)?;
* ```
*/
EnumMembers = "EnumMembers",
/**
* Represents a node with kind `EqualityExpression`, having the following structure:
*
* ```ebnf
* (* Left-associative binary operator *)
* EqualityExpression = (* left_operand: *) Expression
* (* operator: *) EQUAL_EQUAL
* (* right_operand: *) Expression;
*
* (* Left-associative binary operator *)
* EqualityExpression = (* left_operand: *) Expression
* (* operator: *) BANG_EQUAL
* (* right_operand: *) Expression;
* ```
*/
EqualityExpression = "EqualityExpression",
/**
* Represents a node with kind `ErrorDefinition`, having the following structure:
*
* ```ebnf
* (* Introduced in 0.8.4 *)
* ErrorDefinition = (* error_keyword: *) ERROR_KEYWORD
* (* name: *) IDENTIFIER
* (* members: *) ErrorParametersDeclaration
* (* semicolon: *) SEMICOLON;
* ```
*/
ErrorDefinition = "ErrorDefinition",
/**
* Represents a node with kind `ErrorParameter`, having the following structure:
*
* ```ebnf
* (* Introduced in 0.8.4 *)
* ErrorParameter = (* type_name: *) TypeName
* (* name: *) IDENTIFIER?;
* ```
*/
ErrorParameter = "ErrorParameter",
/**
* Represents a node with kind `ErrorParameters`, having the following structure:
*
* ```ebnf
* (* Introduced in 0.8.4 *)
* ErrorParameters = ((* item: *) ErrorParameter ((* separator: *) COMMA (* item: *) ErrorParameter)*)?;
* ```
*/
ErrorParameters = "ErrorParameters",
/**
* Represents a node with kind `ErrorParametersDeclaration`, having the following structure:
*
* ```ebnf
* (* Introduced in 0.8.4 *)
* ErrorParametersDeclaration = (* open_paren: *) OPEN_PAREN
* (* parameters: *) ErrorParameters
* (* close_paren: *) CLOSE_PAREN;
* ```
*/
ErrorParametersDeclaration = "ErrorParametersDeclaration",
/**
* Represents a node with kind `EventDefinition`, having the following structure:
*
* ```ebnf
* EventDefinition = (* event_keyword: *) EVENT_KEYWORD
* (* name: *) IDENTIFIER
* (* parameters: *) EventParametersDeclaration
* (* anonymous_keyword: *) ANONYMOUS_KEYWORD?
* (* semicolon: *) SEMICOLON;
* ```
*/
EventDefinition = "EventDefinition",
/**
* Represents a node with kind `EventParameter`, having the following structure:
*
* ```ebnf
* EventParameter = (* type_name: *) TypeName
* (* indexed_keyword: *) INDEXED_KEYWORD?
* (* name: *) IDENTIFIER?;
* ```
*/
EventParameter = "EventParameter",
/**
* Represents a node with kind `EventParameters`, having the following structure:
*
* ```ebnf
* EventParameters = ((* item: *) EventParameter ((* separator: *) COMMA (* item: *) EventParameter)*)?;
* ```
*/
EventParameters = "EventParameters",
/**
* Represents a node with kind `EventParametersDeclaration`, having the following structure:
*
* ```ebnf
* EventParametersDeclaration = (* open_paren: *) OPEN_PAREN
* (* parameters: *) EventParameters
* (* close_paren: *) CLOSE_PAREN;
* ```
*/
EventParametersDeclaration = "EventParametersDeclaration",
/**
* Represents a node with kind `ExperimentalFeature`, having the following structure:
*
* ```ebnf
* ExperimentalFeature = (* variant: *) IDENTIFIER
* | (* variant: *) StringLiteral;
* ```
*/
ExperimentalFeature = "ExperimentalFeature",
/**
* Represents a node with kind `ExperimentalPragma`, having the following structure:
*
* ```ebnf
* ExperimentalPragma = (* experimental_keyword: *) EXPERIMENTAL_KEYWORD
* (* feature: *) ExperimentalFeature;
* ```
*/
ExperimentalPragma = "ExperimentalPragma",
/**
* Represents a node with kind `ExponentiationExpression`, having the following structure:
*
* ```ebnf
* (* Left-associative binary operator *)
* (* Deprecated in 0.8.0 *)
* ExponentiationExpression = (* left_operand: *) Expression
* (* operator: *) ASTERISK_ASTERISK
* (* right_operand: *) Expression;
*
* (* Right-associative binary operator *)
* (* Introduced in 0.8.0 *)
* ExponentiationExpression = (* left_operand: *) Expression
* (* operator: *) ASTERISK_ASTERISK
* (* right_operand: *) Expression;
* ```
*/
ExponentiationExpression = "ExponentiationExpression",
/**
* Represents a node with kind `Expression`, having the following structure:
*
* ```ebnf
* Expression = (* variant: *) AssignmentExpression
* | (* variant: *) ConditionalExpression
* | (* variant: *) OrExpression
* | (* variant: *) AndExpression
* | (* variant: *) EqualityExpression
* | (* variant: *) InequalityExpression
* | (* variant: *) BitwiseOrExpression
* | (* variant: *) BitwiseXorExpression
* | (* variant: *) BitwiseAndExpression
* | (* variant: *) ShiftExpression
* | (* variant: *) AdditiveExpression
* | (* variant: *) MultiplicativeExpression
* | (* variant: *) ExponentiationExpression
* | (* variant: *) PostfixExpression
* | (* variant: *) PrefixExpression
* | (* variant: *) FunctionCallExpression
* | (* variant: *) CallOptionsExpression
* | (* variant: *) MemberAccessExpression
* | (* variant: *) IndexAccessExpression
* | (* variant: *) NewExpression
* | (* variant: *) TupleExpression
* | (* variant: *) TypeExpression (* Introduced in 0.5.3 *)
* | (* variant: *) ArrayExpression
* | (* variant: *) HexNumberExpression
* | (* variant: *) DecimalNumberExpression
* | (* variant: *) StringExpression
* | (* variant: *) ElementaryType
* | (* variant: *) PAYABLE_KEYWORD (* Introduced in 0.6.0 *)
* | (* variant: *) THIS_KEYWORD
* | (* variant: *) SUPER_KEYWORD
* | (* variant: *) TRUE_KEYWORD
* | (* variant: *) FALSE_KEYWORD
* | (* variant: *) IDENTIFIER;
* ```
*/
Expression = "Expression",
/**
* Represents a node with kind `ExpressionStatement`, having the following structure:
*
* ```ebnf
* ExpressionStatement = (* expression: *) Expression
* (* semicolon: *) SEMICOLON;
* ```
*/
ExpressionStatement = "ExpressionStatement",
/**
* Represents a node with kind `FallbackFunctionAttribute`, having the following structure:
*
* ```ebnf
* (* Introduced in 0.6.0 *)
* FallbackFunctionAttribute = (* variant: *) ModifierInvocation
* | (* variant: *) OverrideSpecifier
* | (* variant: *) EXTERNAL_KEYWORD
* | (* variant: *) PAYABLE_KEYWORD
* | (* variant: *) PURE_KEYWORD
* | (* variant: *) VIEW_KEYWORD
* | (* variant: *) VIRTUAL_KEYWORD;
* ```
*/
FallbackFunctionAttribute = "FallbackFunctionAttribute",
/**
* Represents a node with kind `FallbackFunctionAttributes`, having the following structure:
*
* ```ebnf
* (* Introduced in 0.6.0 *)
* FallbackFunctionAttributes = (* item: *) FallbackFunctionAttribute*;
* ```
*/
FallbackFunctionAttributes = "FallbackFunctionAttributes",
/**
* Represents a node with kind `FallbackFunctionDefinition`, having the following structure:
*
* ```ebnf
* (* Introduced in 0.6.0 *)
* FallbackFunctionDefinition = (* fallback_keyword: *) FALLBACK_KEYWORD
* (* parameters: *) ParametersDeclaration
* (* attributes: *) FallbackFunctionAttributes
* (* returns: *) ReturnsDeclaration?
* (* body: *) FunctionBody;
* ```
*/
FallbackFunctionDefinition = "FallbackFunctionDefinition",
/**
* Represents a node with kind `ForStatement`, having the following structure:
*
* ```ebnf
* ForStatement = (* for_keyword: *) FOR_KEYWORD
* (* open_paren: *) OPEN_PAREN
* (* initialization: *) ForStatementInitialization
* (* condition: *) ForStatementCondition
* (* iterator: *) Expression?
* (* close_paren: *) CLOSE_PAREN
* (* body: *) Statement;
* ```
*/
ForStatement = "ForStatement",
/**
* Represents a node with kind `ForStatementCondition`, having the following structure:
*
* ```ebnf
* ForStatementCondition = (* variant: *) ExpressionStatement
* | (* variant: *) SEMICOLON;
* ```
*/
ForStatementCondition = "ForStatementCondition",
/**
* Represents a node with kind `ForStatementInitialization`, having the following structure:
*
* ```ebnf
* ForStatementInitialization = (* variant: *) TupleDeconstructionStatement
* | (* variant: *) VariableDeclarationStatement
* | (* variant: *) ExpressionStatement
* | (* variant: *) SEMICOLON;
* ```
*/
ForStatementInitialization = "ForStatementInitialization",
/**
* Represents a node with kind `FunctionAttribute`, having the following structure:
*
* ```ebnf
* FunctionAttribute = (* variant: *) ModifierInvocation
* | (* variant: *) OverrideSpecifier (* Introduced in 0.6.0 *)
* | (* variant: *) CONSTANT_KEYWORD (* Deprecated in 0.5.0 *)
* | (* variant: *) EXTERNAL_KEYWORD
* | (* variant: *) INTERNAL_KEYWORD
* | (* variant: *) PAYABLE_KEYWORD
* | (* variant: *) PRIVATE_KEYWORD
* | (* variant: *) PUBLIC_KEYWORD
* | (* variant: *) PURE_KEYWORD (* Introduced in 0.4.16 *)
* | (* variant: *) VIEW_KEYWORD (* Introduced in 0.4.16 *)
* | (* variant: *) VIRTUAL_KEYWORD; (* Introduced in 0.6.0 *)
* ```
*/
FunctionAttribute = "FunctionAttribute",
/**
* Represents a node with kind `FunctionAttributes`, having the following structure:
*
* ```ebnf
* FunctionAttributes = (* item: *) FunctionAttribute*;
* ```
*/
FunctionAttributes = "FunctionAttributes",
/**
* Represents a node with kind `FunctionBody`, having the following structure:
*
* ```ebnf
* FunctionBody = (* variant: *) Block
* | (* variant: *) SEMICOLON;
* ```
*/
FunctionBody = "FunctionBody",
/**
* Represents a node with kind `FunctionCallExpression`, having the following structure:
*
* ```ebnf
* (* Postfix unary operator *)
* FunctionCallExpression = (* operand: *) Expression
* (* arguments: *) ArgumentsDeclaration;
* ```
*/
FunctionCallExpression = "FunctionCallExpression",
/**
* Represents a node with kind `FunctionDefinition`, having the following structure:
*
* ```ebnf
* FunctionDefinition = (* function_keyword: *) FUNCTION_KEYWORD
* (* name: *) FunctionName
* (* parameters: *) ParametersDeclaration
* (* attributes: *) FunctionAttributes
* (* returns: *) ReturnsDeclaration?
* (* body: *) FunctionBody;
* ```
*/
FunctionDefinition = "FunctionDefinition",
/**
* Represents a node with kind `FunctionName`, having the following structure:
*
* ```ebnf
* FunctionName = (* variant: *) IDENTIFIER
* | (* variant: *) FALLBACK_KEYWORD
* | (* variant: *) RECEIVE_KEYWORD;
* ```
*/
FunctionName = "FunctionName",
/**
* Represents a node with kind `FunctionType`, having the following structure:
*
* ```ebnf
* FunctionType = (* function_keyword: *) FUNCTION_KEYWORD
* (* parameters: *) ParametersDeclaration
* (* attributes: *) FunctionTypeAttributes
* (* returns: *) ReturnsDeclaration?;
* ```
*/
FunctionType = "FunctionType",
/**
* Represents a node with kind `FunctionTypeAttribute`, having the following structure:
*
* ```ebnf
* FunctionTypeAttribute = (* variant: *) INTERNAL_KEYWORD
* | (* variant: *) EXTERNAL_KEYWORD
* | (* variant: *) PRIVATE_KEYWORD
* | (* variant: *) PUBLIC_KEYWORD
* | (* variant: *) CONSTANT_KEYWORD (* Deprecated in 0.5.0 *)
* | (* variant: *) PURE_KEYWORD (* Introduced in 0.4.16 *)
* | (* variant: *) VIEW_KEYWORD (* Introduced in 0.4.16 *)
* | (* variant: *) PAYABLE_KEYWORD;
* ```
*/
FunctionTypeAttribute = "FunctionTypeAttribute",
/**
* Represents a node with kind `FunctionTypeAttributes`, having the following structure:
*
* ```ebnf
* FunctionTypeAttributes = (* item: *) FunctionTypeAttribute*;
* ```
*/
FunctionTypeAttributes = "FunctionTypeAttributes",
/**
* Represents a node with kind `HexNumberExpression`, having the following structure:
*
* ```ebnf
* HexNumberExpression = (* literal: *) HEX_LITERAL
* (* unit: *) NumberUnit?; (* Deprecated in 0.5.0 *)
* ```
*/
HexNumberExpression = "HexNumberExpression",
/**
* Represents a node with kind `HexStringLiteral`, having the following structure:
*
* ```ebnf
* HexStringLiteral = (* variant: *) SINGLE_QUOTED_HEX_STRING_LITERAL
* | (* variant: *) DOUBLE_QUOTED_HEX_STRING_LITERAL;
* ```
*/
HexStringLiteral = "HexStringLiteral",
/**
* Represents a node with kind `HexStringLiterals`, having the following structure:
*
* ```ebnf
* (* Introduced in 0.5.14 *)
* HexStringLiterals = (* item: *) HexStringLiteral+;
* ```
*/
HexStringLiterals = "HexStringLiterals",
/**
* Represents a node with kind `IdentifierPath`, having the following structure:
*
* ```ebnf
* IdentifierPath = (* item: *) IDENTIFIER ((* separator: *) PERIOD (* item: *) IDENTIFIER)*;
* ```
*/
IdentifierPath = "IdentifierPath",
/**
* Represents a node with kind `IfStatement`, having the following structure:
*
* ```ebnf
* IfStatement = (* if_keyword: *) IF_KEYWORD
* (* open_paren: *) OPEN_PAREN
* (* condition: *) Expression
* (* close_paren: *) CLOSE_PAREN
* (* body: *) Statement
* (* else_branch: *) ElseBranch?;
* ```
*/
IfStatement = "IfStatement",
/**
* Represents a node with kind `ImportAlias`, having the following structure:
*
* ```ebnf
* ImportAlias = (* as_keyword: *) AS_KEYWORD
* (* identifier: *) IDENTIFIER;
* ```
*/
ImportAlias = "ImportAlias",
/**
* Represents a node with kind `ImportClause`, having the following structure:
*
* ```ebnf
* ImportClause = (* variant: *) PathImport
* | (* variant: *) NamedImport
* | (* variant: *) ImportDeconstruction;
* ```
*/
ImportClause = "ImportClause",
/**
* Represents a node with kind `ImportDeconstruction`, having the following structure:
*
* ```ebnf
* ImportDeconstruction = (* open_brace: *) OPEN_BRACE
* (* symbols: *) ImportDeconstructionSymbols
* (* close_brace: *) CLOSE_BRACE
* (* from_keyword: *) FROM_KEYWORD
* (* path: *) StringLiteral;
* ```
*/
ImportDeconstruction = "ImportDeconstruction",
/**
* Represents a node with kind `ImportDeconstructionSymbol`, having the following structure:
*
* ```ebnf
* ImportDeconstructionSymbol = (* name: *) IDENTIFIER
* (* alias: *) ImportAlias?;
* ```
*/
ImportDeconstructionSymbol = "ImportDeconstructionSymbol",
/**
* Represents a node with kind `ImportDeconstructionSymbols`, having the following structure:
*
* ```ebnf
* ImportDeconstructionSymbols = (* item: *) ImportDeconstructionSymbol ((* separator: *) COMMA (* item: *) ImportDeconstructionSymbol)*;
* ```
*/
ImportDeconstructionSymbols = "ImportDeconstructionSymbols",
/**
* Represents a node with kind `ImportDirective`, having the following structure:
*
* ```ebnf
* ImportDirective = (* import_keyword: *) IMPORT_KEYWORD
* (* clause: *) ImportClause
* (* semicolon: *) SEMICOLON;
* ```
*/
ImportDirective = "ImportDirective",
/**
* Represents a node with kind `IndexAccessEnd`, having the following structure:
*
* ```ebnf
* IndexAccessEnd = (* colon: *) COLON
* (* end: *) Expression?;
* ```
*/
IndexAccessEnd = "IndexAccessEnd",
/**
* Represents a node with kind `IndexAccessExpression`, having the following structure:
*
* ```ebnf
* (* Postfix unary operator *)
* IndexAccessExpression = (* operand: *) Expression
* (* open_bracket: *) OPEN_BRACKET
* (* start: *) Expression?
* (* end: *) IndexAccessEnd?
* (* close_bracket: *) CLOSE_BRACKET;
* ```
*/
IndexAccessExpression = "IndexAccessExpression",
/**
* Represents a node with kind `InequalityExpression`, having the following structure:
*
* ```ebnf
* (* Left-associative binary operator *)
* InequalityExpression = (* left_operand: *) Expression
* (* operator: *) LESS_THAN
* (* right_operand: *) Expression;
*
* (* Left-associative binary operator *)
* InequalityExpression = (* left_operand: *) Expression
* (* operator: *) GREATER_THAN
* (* right_operand: *) Expression;
*
* (* Left-associative binary operator *)
* InequalityExpression = (* left_operand: *) Expression
* (* operator: *) LESS_THAN_EQUAL
* (* right_operand: *) Expression;
*
* (* Left-associative binary operator *)
* InequalityExpression = (* left_operand: *) Expression
* (* operator: *) GREATER_THAN_EQUAL
* (* right_operand: *) Expression;
* ```
*/
InequalityExpression = "InequalityExpression",
/**
* Represents a node with kind `InheritanceSpecifier`, having the following structure:
*
* ```ebnf
* InheritanceSpecifier = (* is_keyword: *) IS_KEYWORD
* (* types: *) InheritanceTypes;
* ```
*/
InheritanceSpecifier = "InheritanceSpecifier",
/**
* Represents a node with kind `InheritanceType`, having the following structure:
*
* ```ebnf
* InheritanceType = (* type_name: *) IdentifierPath
* (* arguments: *) ArgumentsDeclaration?;
* ```
*/
InheritanceType = "InheritanceType",
/**
* Represents a node with kind `InheritanceTypes`, having the following structure:
*
* ```ebnf
* InheritanceTypes = (* item: *) InheritanceType ((* separator: *) COMMA (* item: *) InheritanceType)*;
* ```
*/
InheritanceTypes = "InheritanceTypes",
/**
* Represents a node with kind `InterfaceDefinition`, having the following structure:
*
* ```ebnf
* InterfaceDefinition = (* interface_keyword: *) INTERFACE_KEYWORD
* (* name: *) IDENTIFIER
* (* inheritance: *) InheritanceSpecifier?
* (* open_brace: *) OPEN_BRACE
* (* members: *) InterfaceMembers
* (* close_brace: *) CLOSE_BRACE;
* ```
*/
InterfaceDefinition = "InterfaceDefinition",
/**
* Represents a node with kind `InterfaceMembers`, having the following structure:
*
* ```ebnf
* InterfaceMembers = (* item: *) ContractMember*;
* ```
*/
InterfaceMembers = "InterfaceMembers",
/**
* Represents a node with kind `LibraryDefinition`, having the following structure:
*
* ```ebnf
* LibraryDefinition = (* library_keyword: *) LIBRARY_KEYWORD
* (* name: *) IDENTIFIER
* (* open_brace: *) OPEN_BRACE
* (* members: *) LibraryMembers
* (* close_brace: *) CLOSE_BRACE;
* ```
*/
LibraryDefinition = "LibraryDefinition",
/**
* Represents a node with kind `LibraryMembers`, having the following structure:
*
* ```ebnf
* LibraryMembers = (* item: *) ContractMember*;
* ```
*/
LibraryMembers = "LibraryMembers",
/**
* Represents a node with kind `MappingKey`, having the following structure:
*
* ```ebnf
* MappingKey = (* key_type: *) MappingKeyType
* (* name: *) IDENTIFIER?; (* Introduced in 0.8.18 *)
* ```
*/
MappingKey = "MappingKey",
/**
* Represents a node with kind `MappingKeyType`, having the following structure:
*
* ```ebnf
* MappingKeyType = (* variant: *) ElementaryType
* | (* variant: *) IdentifierPath;
* ```
*/
MappingKeyType = "MappingKeyType",
/**
* Represents a node with kind `MappingType`, having the following structure:
*
* ```ebnf
* MappingType = (* mapping_keyword: *) MAPPING_KEYWORD
* (* open_paren: *) OPEN_PAREN
* (* key_type: *) MappingKey
* (* equal_greater_than: *) EQUAL_GREATER_THAN
* (* value_type: *) MappingValue
* (* close_paren: *) CLOSE_PAREN;
* ```
*/
MappingType = "MappingType",
/**
* Represents a node with kind `MappingValue`, having the following structure:
*
* ```ebnf
* MappingValue = (* type_name: *) TypeName
* (* name: *) IDENTIFIER?; (* Introduced in 0.8.18 *)
* ```
*/
MappingValue = "MappingValue",
/**
* Represents a node with kind `MemberAccessExpression`, having the following structure:
*
* ```ebnf
* (* Postfix unary operator *)
* MemberAccessExpression = (* operand: *) Expression
* (* period: *) PERIOD
* (* member: *) IDENTIFIER;
* ```
*/
MemberAccessExpression = "MemberAccessExpression",
/**
* Represents a node with kind `ModifierAttribute`, having the following structure:
*
* ```ebnf
* ModifierAttribute = (* variant: *) OverrideSpecifier (* Introduced in 0.6.0 *)
* | (* variant: *) VIRTUAL_KEYWORD; (* Introduced in 0.6.0 *)
* ```
*/
ModifierAttribute = "ModifierAttribute",
/**
* Represents a node with kind `ModifierAttributes`, having the following structure:
*
* ```ebnf
* ModifierAttributes = (* item: *) ModifierAttribute*;
* ```
*/
ModifierAttributes = "ModifierAttributes",
/**
* Represents a node with kind `ModifierDefinition`, having the following structure:
*
* ```ebnf
* ModifierDefinition = (* modifier_keyword: *) MODIFIER_KEYWORD
* (* name: *) IDENTIFIER
* (* parameters: *) ParametersDeclaration?
* (* attributes: *) ModifierAttributes
* (* body: *) FunctionBody;
* ```
*/
ModifierDefinition = "ModifierDefinition",
/**
* Represents a node with kind `ModifierInvocation`, having the following structure:
*
* ```ebnf
* ModifierInvocation = (* name: *) IdentifierPath
* (* arguments: *) ArgumentsDeclaration?;
* ```
*/
ModifierInvocation = "ModifierInvocation",
/**
* Represents a node with kind `MultiplicativeExpression`, having the following structure:
*
* ```ebnf
* (* Left-associative binary operator *)
* MultiplicativeExpression = (* left_operand: *) Expression
* (* operator: *) ASTERISK
* (* right_operand: *) Expression;
*
* (* Left-associative binary operator *)
* MultiplicativeExpression = (* left_operand: *) Expression
* (* operator: *) SLASH
* (* right_operand: *) Expression;
*
* (* Left-associative binary operator *)
* MultiplicativeExpression = (* left_operand: *) Expression
* (* operator: *) PERCENT
* (* right_operand: *) Expression;
* ```
*/
MultiplicativeExpression = "MultiplicativeExpression",
/**
* Represents a node with kind `NamedArgument`, having the following structure:
*
* ```ebnf
* NamedArgument = (* name: *) IDENTIFIER
* (* colon: *) COLON
* (* value: *) Expression;
* ```
*/
NamedArgument = "NamedArgument",
/**
* Represents a node with kind `NamedArgumentGroup`, having the following structure:
*
* ```ebnf
* NamedArgumentGroup = (* open_brace: *) OPEN_BRACE
* (* arguments: *) NamedArguments
* (* close_brace: *) CLOSE_BRACE;
* ```
*/
NamedArgumentGroup = "NamedArgumentGroup",
/**
* Represents a node with kind `NamedArguments`, having the following structure:
*
* ```ebnf
* NamedArguments = ((* item: *) NamedArgument ((* separator: *) COMMA (* item: *) NamedArgument)*)?;
* ```
*/
NamedArguments = "NamedArguments",
/**
* Represents a node with kind `NamedArgumentsDeclaration`, having the following structure:
*
* ```ebnf
* NamedArgumentsDeclaration = (* open_paren: *) OPEN_PAREN
* (* arguments: *) NamedArgumentGroup?
* (* close_paren: *) CLOSE_PAREN;
* ```
*/
NamedArgumentsDeclaration = "NamedArgumentsDeclaration",
/**
* Represents a node with kind `NamedImport`, having the following structure:
*
* ```ebnf
* NamedImport = (* asterisk: *) ASTERISK
* (* alias: *) ImportAlias
* (* from_keyword: *) FROM_KEYWORD
* (* path: *) StringLiteral;
* ```
*/
NamedImport = "NamedImport",
/**
* Represents a node with kind `NewExpression`, having the following structure:
*
* ```ebnf
* NewExpression = (* new_keyword: *) NEW_KEYWORD
* (* type_name: *) TypeName;
* ```
*/
NewExpression = "NewExpression",
/**
* Represents a node with kind `NumberUnit`, having the following structure:
*
* ```ebnf
* NumberUnit = (* variant: *) WEI_KEYWORD
* | (* variant: *) GWEI_KEYWORD (* Introduced in 0.6.11 *)
* | (* variant: *) SZABO_KEYWORD (* Deprecated in 0.7.0 *)
* | (* variant: *) FINNEY_KEYWORD (* Deprecated in 0.7.0 *)
* | (* variant: *) ETHER_KEYWORD
* | (* variant: *) SECONDS_KEYWORD
* | (* variant: *) MINUTES_KEYWORD
* | (* variant: *) HOURS_KEYWORD
* | (* variant: *) DAYS_KEYWORD
* | (* variant: *) WEEKS_KEYWORD
* | (* variant: *) YEARS_KEYWORD; (* Deprecated in 0.5.0 *)
* ```
*/
NumberUnit = "NumberUnit",
/**
* Represents a node with kind `OrExpression`, having the following structure:
*
* ```ebnf
* (* Left-associative binary operator *)
* OrExpression = (* left_operand: *) Expression
* (* operator: *) BAR_BAR
* (* right_operand: *) Expression;
* ```
*/
OrExpression = "OrExpression",
/**
* Represents a node with kind `OverridePaths`, having the following structure:
*
* ```ebnf
* (* Introduced in 0.6.0 *)
* OverridePaths = (* item: *) IdentifierPath ((* separator: *) COMMA (* item: *) IdentifierPath)*;
* ```
*/
OverridePaths = "OverridePaths",
/**
* Represents a node with kind `OverridePathsDeclaration`, having the following structure:
*
* ```ebnf
* (* Introduced in 0.6.0 *)
* OverridePathsDeclaration = (* open_paren: *) OPEN_PAREN
* (* paths: *) OverridePaths
* (* close_paren: *) CLOSE_PAREN;
* ```
*/
OverridePathsDeclaration = "OverridePathsDeclaration",
/**
* Represents a node with kind `OverrideSpecifier`, having the following structure:
*
* ```ebnf
* (* Introduced in 0.6.0 *)
* OverrideSpecifier = (* override_keyword: *) OVERRIDE_KEYWORD
* (* overridden: *) OverridePathsDeclaration?;
* ```
*/
OverrideSpecifier = "OverrideSpecifier",
/**
* Represents a node with kind `Parameter`, having the following structure:
*
* ```ebnf
* Parameter = (* type_name: *) TypeName
* (* storage_location: *) StorageLocation?
* (* name: *) IDENTIFIER?;
* ```
*/
Parameter = "Parameter",
/**
* Represents a node with kind `Parameters`, having the following structure:
*
* ```ebnf
* Parameters = ((* item: *) Parameter ((* separator: *) COMMA (* item: *) Parameter)*)?;
* ```
*/
Parameters = "Parameters",
/**
* Represents a node with kind `ParametersDeclaration`, having the following structure:
*
* ```ebnf
* ParametersDeclaration = (* open_paren: *) OPEN_PAREN
* (* parameters: *) Parameters
* (* close_paren: *) CLOSE_PAREN;
* ```
*/
ParametersDeclaration = "ParametersDeclaration",
/**
* Represents a node with kind `PathImport`, having the following structure:
*
* ```ebnf
* PathImport = (* path: *) StringLiteral
* (* alias: *) ImportAlias?;
* ```
*/
PathImport = "PathImport",
/**
* Represents a node with kind `PositionalArguments`, having the following structure:
*
* ```ebnf
* PositionalArguments = ((* item: *) Expression ((* separator: *) COMMA (* item: *) Expression)*)?;
* ```
*/
PositionalArguments = "PositionalArguments",
/**
* Represents a node with kind `PositionalArgumentsDeclaration`, having the following structure:
*
* ```ebnf
* PositionalArgumentsDeclaration = (* open_paren: *) OPEN_PAREN
* (* arguments: *) PositionalArguments
* (* close_paren: *) CLOSE_PAREN;
* ```
*/
PositionalArgumentsDeclaration = "PositionalArgumentsDeclaration",
/**
* Represents a node with kind `PostfixExpression`, having the following str