lib-ruby-parser 3.0.11

// This file is auto-generated by codegen/rust/messages/native/variants.rs

crate::use_native_or_external!(StringPtr);

/// Emitted for code
/// ```text
/// 1.2.3
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct FractionAfterNumeric {
}

impl FractionAfterNumeric {
}

/// Emitted for code like
/// ```text
/// foo.2
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct NoDigitsAfterDot {
}

impl NoDigitsAfterDot {
}

/// Emitted for code like
/// ```text
/// %k[foo]
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct UnknownTypeOfPercentString {
}

impl UnknownTypeOfPercentString {
}

/// Emitted for code like
/// ```text
/// 0b
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct NumericLiteralWithoutDigits {
}

impl NumericLiteralWithoutDigits {
}

/// Emitted for code like
/// ```text
/// %w[foo bar
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct UnterminatedList {
}

impl UnterminatedList {
}

/// Emitted for code like
/// ```text
/// /foo
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct UnterminatedRegexp {
}

impl UnterminatedRegexp {
}

/// Emitted for code like
/// ```text
/// "foo
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct UnterminatedString {
}

impl UnterminatedString {
}

/// Emitted for code like
/// ```text
/// %s
/// //    ^ EOF, not "
///
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct UnterminatedQuotedString {
}

impl UnterminatedQuotedString {
}

/// Emitted for code like
/// ```text
/// "\ufoo"
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct InvalidUnicodeEscape {
}

impl InvalidUnicodeEscape {
}

/// Emitted for code like
/// ```text
/// "\u{999999}"
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct TooLargeUnicodeCodepoint {
}

impl TooLargeUnicodeCodepoint {
}

/// Emitted for code like
/// ```text
/// "\u{d800}"
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct InvalidUnicodeCodepoint {
}

impl InvalidUnicodeCodepoint {
}

/// Emitted for code like
/// ```text
/// ?\u{41 42}
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct MultipleCodepointAtSingleChar {
}

impl MultipleCodepointAtSingleChar {
}

/// Emitted for code like
/// ```text
/// "\M-
"
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct InvalidEscapeCharacter {
}

impl InvalidEscapeCharacter {
}

/// Emitted for code like
/// ```text
/// "\xZZ"
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct InvalidHexEscape {
}

impl InvalidHexEscape {
}

/// Emitted for code like
/// ```text
/// <<-HERE
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct UnterminatedHeredoc {
        /// Heredoc identifier
    pub heredoc_id: StringPtr,
}

impl UnterminatedHeredoc {
    /// Returns `heredoc_id` field
    pub fn get_heredoc_id(&self) -> &StringPtr {
        &self.heredoc_id
    }
}

/// Emitted for code like
/// ```text
/// <<-"HERE
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct UnterminatedHeredocId {
}

impl UnterminatedHeredocId {
}

/// Emitted for code like
/// ```text
/// eval("foo \r = 42")
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct SlashRAtMiddleOfLine {
}

impl SlashRAtMiddleOfLine {
}

/// Emitted for code like (only in $VERBOSE mode)
/// ```text
/// foo **arg
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct DStarInterpretedAsArgPrefix {
}

impl DStarInterpretedAsArgPrefix {
}

/// Emitted for code like (only in $VERBOSE mode)
/// ```text
/// foo *arg
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct StarInterpretedAsArgPrefix {
}

impl StarInterpretedAsArgPrefix {
}

/// Emitted for code like (only in $VERBOSE mode)
/// ```text
/// foo &arg
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct AmpersandInterpretedAsArgPrefix {
}

impl AmpersandInterpretedAsArgPrefix {
}

/// Emitted for code like
/// ```text
/// range = 1...
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct TripleDotAtEol {
}

impl TripleDotAtEol {
}

/// Emitted for code like (only in $VERBOSE mode)
/// ```text
/// def m (a, b, c); end
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct ParenthesesIterpretedAsArglist {
}

impl ParenthesesIterpretedAsArglist {
}

/// Emitted for code like (only in $VERBOSE mode)
/// ```text
/// m +foo
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct AmbiguousFirstArgument {
        /// Operator that is ambiguous
    pub operator: u8,
}

impl AmbiguousFirstArgument {
    /// Returns `operator` field
    pub fn get_operator(&self) -> &u8 {
        &self.operator
    }
}

/// Emitted for code like (only in $VERBOSE mode)
/// ```text
/// 1 *2
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct AmbiguousOperator {
        /// Operator that is ambiguous
    pub operator: StringPtr,
        /// Interpretation of this operator
    pub interpreted_as: StringPtr,
}

impl AmbiguousOperator {
    /// Returns `operator` field
    pub fn get_operator(&self) -> &StringPtr {
        &self.operator
    }
    /// Returns `interpreted_as` field
    pub fn get_interpreted_as(&self) -> &StringPtr {
        &self.interpreted_as
    }
}

/// Emitted for code like
/// ```text
/// "\M- "
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct InvalidCharacterSyntax {
        /// Valid syntax sugestions
    pub suggestion: StringPtr,
}

impl InvalidCharacterSyntax {
    /// Returns `suggestion` field
    pub fn get_suggestion(&self) -> &StringPtr {
        &self.suggestion
    }
}

/// Emitted for code like
/// ```text
/// 09
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct InvalidOctalDigit {
}

impl InvalidOctalDigit {
}

/// Emitted for code like
/// ```text
/// 0_a
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct TrailingCharInNumber {
        /// Invalid trailing char
    pub c: u8,
}

impl TrailingCharInNumber {
    /// Returns `c` field
    pub fn get_c(&self) -> &u8 {
        &self.c
    }
}

/// Emitted for code like
/// ```text
/// =begin
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct EmbeddedDocumentMeetsEof {
}

impl EmbeddedDocumentMeetsEof {
}

/// Emitted for code like
/// ```text
/// eval("\x01foo")
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct InvalidChar {
        /// char
    pub c: u8,
}

impl InvalidChar {
    /// Returns `c` field
    pub fn get_c(&self) -> &u8 {
        &self.c
    }
}

/// It is unknown how to trigger this error.
/// Code that triggers it in MRI can be dead.
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct IncompleteCharacterSyntax {
}

impl IncompleteCharacterSyntax {
}

/// Emitted for code like
/// ```text
/// $
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct GvarWithoutId {
}

impl GvarWithoutId {
}

/// Emitted for code like
/// ```text
/// $@
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct InvalidGvarName {
        /// char after `$`
    pub c: u8,
}

impl InvalidGvarName {
    /// Returns `c` field
    pub fn get_c(&self) -> &u8 {
        &self.c
    }
}

/// Emitted for code like
/// ```text
/// @
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct IvarWithoutId {
}

impl IvarWithoutId {
}

/// Emitted for code like
/// ```text
/// @1
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct InvalidIvarName {
        /// char after `@`
    pub c: u8,
}

impl InvalidIvarName {
    /// Returns `c` field
    pub fn get_c(&self) -> &u8 {
        &self.c
    }
}

/// Emitted for code like
/// ```text
/// @@
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct CvarWithoutId {
}

impl CvarWithoutId {
}

/// Emitted for code like
/// ```text
/// @@1
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct InvalidCvarName {
        /// char after `@@`
    pub c: u8,
}

impl InvalidCvarName {
    /// Returns `c` field
    pub fn get_c(&self) -> &u8 {
        &self.c
    }
}

/// Emitted for code like
/// ```text
/// /re/foo
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct UnknownRegexOptions {
        /// Concatenated unknown options
    pub options: StringPtr,
}

impl UnknownRegexOptions {
    /// Returns `options` field
    pub fn get_options(&self) -> &StringPtr {
        &self.options
    }
}

/// Emitted for code like
/// ```text
/// "\u{1234"
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct UnterminatedUnicodeEscape {
}

impl UnterminatedUnicodeEscape {
}

/// Emitted for code like
/// ```text
/// # encoding: foo
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct EncodingError {
        /// Error from decoder
    pub error: StringPtr,
}

impl EncodingError {
    /// Returns `error` field
    pub fn get_error(&self) -> &StringPtr {
        &self.error
    }
}

/// Emitter for code like
/// ```text
/// eval("\xFF = 42")
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct InvalidMultibyteChar {
}

impl InvalidMultibyteChar {
}

/// Emitted for code like
/// ```text
/// a ?AA : 2
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct AmbiguousTernaryOperator {
        /// Source of the condition expression
    pub condition: StringPtr,
}

impl AmbiguousTernaryOperator {
    /// Returns `condition` field
    pub fn get_condition(&self) -> &StringPtr {
        &self.condition
    }
}

/// Emitted for code like
/// ```text
/// m /foo/
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct AmbiguousRegexp {
}

impl AmbiguousRegexp {
}

/// Emitted for code like
/// ```text
/// begin; else; end
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct ElseWithoutRescue {
}

impl ElseWithoutRescue {
}

/// Emitted for code like
/// ```text
/// def f; BEGIN{}; end
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct BeginNotAtTopLevel {
}

impl BeginNotAtTopLevel {
}

/// Emitted for code like
/// ```text
/// alias $a $1
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct AliasNthRef {
}

impl AliasNthRef {
}

/// Emitted for code like
/// ```text
/// *a&.x = 0
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct CsendInsideMasgn {
}

impl CsendInsideMasgn {
}

/// Emitted for code like
/// ```text
/// module foo; end
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct ClassOrModuleNameMustBeConstant {
}

impl ClassOrModuleNameMustBeConstant {
}

/// Emitted for code like
/// ```text
/// def foo=() = 42
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct EndlessSetterDefinition {
}

impl EndlessSetterDefinition {
}

/// Emitted for any code that produces invalid sequence of tokens
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct UnexpectedToken {
        /// Name of the token
    pub token_name: StringPtr,
}

impl UnexpectedToken {
    /// Returns `token_name` field
    pub fn get_token_name(&self) -> &StringPtr {
        &self.token_name
    }
}

/// Emitted for code like
/// ```text
/// def a; class Foo; end; end
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct ClassDefinitionInMethodBody {
}

impl ClassDefinitionInMethodBody {
}

/// Emitted for code like
/// ```text
/// def a; module Foo; end; end
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct ModuleDefinitionInMethodBody {
}

impl ModuleDefinitionInMethodBody {
}

/// Emitted for code like
/// ```text
/// class A; return; end
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct InvalidReturnInClassOrModuleBody {
}

impl InvalidReturnInClassOrModuleBody {
}

/// Emitted for code like
/// ```text
/// def foo(Abc); end
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct ConstArgument {
}

impl ConstArgument {
}

/// Emitted for code like
/// ```text
/// def foo(@abc); end
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct IvarArgument {
}

impl IvarArgument {
}

/// Emitted for code like
/// ```text
/// def foo($abc); end
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct GvarArgument {
}

impl GvarArgument {
}

/// Emitted for code like
/// ```text
/// def foo(@@abc); end
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct CvarArgument {
}

impl CvarArgument {
}

/// Emitted for code like
/// ```text
/// case 0; in ^a; true; end
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct NoSuchLocalVariable {
        /// Variable name
    pub var_name: StringPtr,
}

impl NoSuchLocalVariable {
    /// Returns `var_name` field
    pub fn get_var_name(&self) -> &StringPtr {
        &self.var_name
    }
}

/// Emitted for code like
/// ```text
/// m { |a| _1 }
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct OrdinaryParamDefined {
}

impl OrdinaryParamDefined {
}

/// Emitted for code like
/// ```text
/// foo { _1; bar { _2 }; }
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct NumparamUsed {
}

impl NumparamUsed {
}

/// Emitted for code like (only in $VERBOSE mode)
/// ```text
/// if
/// 42
/// end
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct TokAtEolWithoutExpression {
        /// Name of the token
    pub token_name: StringPtr,
}

impl TokAtEolWithoutExpression {
    /// Returns `token_name` field
    pub fn get_token_name(&self) -> &StringPtr {
        &self.token_name
    }
}

/// Emitted for code like
/// ```text
/// def m; END {}; end
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct EndInMethod {
}

impl EndInMethod {
}

/// Emitted for code like (only in $VERBOSE mode)
/// ```text
/// a < b < c
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct ComparisonAfterComparison {
        /// Source of the first comparison
    pub comparison: StringPtr,
}

impl ComparisonAfterComparison {
    /// Returns `comparison` field
    pub fn get_comparison(&self) -> &StringPtr {
        &self.comparison
    }
}

/// Emitted for code like
/// ```text
/// def m(foo = foo) end
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct CircularArgumentReference {
        /// Name of the argument
    pub arg_name: StringPtr,
}

impl CircularArgumentReference {
    /// Returns `arg_name` field
    pub fn get_arg_name(&self) -> &StringPtr {
        &self.arg_name
    }
}

/// Emitted for code like
/// ```text
/// def m; FOO = 1; end
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct DynamicConstantAssignment {
}

impl DynamicConstantAssignment {
}

/// Emitted for code like
/// ```text
/// self = foo
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct CantAssignToSelf {
}

impl CantAssignToSelf {
}

/// Emitted for code like
/// ```text
/// nil = foo
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct CantAssignToNil {
}

impl CantAssignToNil {
}

/// Emitted for code like
/// ```text
/// true = foo
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct CantAssignToTrue {
}

impl CantAssignToTrue {
}

/// Emitted for code like
/// ```text
/// false = foo
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct CantAssignToFalse {
}

impl CantAssignToFalse {
}

/// Emitted for code like
/// ```text
/// __FILE__ = foo
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct CantAssignToFile {
}

impl CantAssignToFile {
}

/// Emitted for code like
/// ```text
/// __LINE__ = foo
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct CantAssignToLine {
}

impl CantAssignToLine {
}

/// Emitted for code like
/// ```text
/// __ENCODING__ = foo
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct CantAssignToEncoding {
}

impl CantAssignToEncoding {
}

/// Emitted for code like
/// ```text
/// proc {_1; _1 = nil}
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct CantAssignToNumparam {
        /// Source of the numbered parameter
    pub numparam: StringPtr,
}

impl CantAssignToNumparam {
    /// Returns `numparam` field
    pub fn get_numparam(&self) -> &StringPtr {
        &self.numparam
    }
}

/// Emitted for code like
/// ```text
/// $1 = foo
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct CantSetVariable {
        /// Source of the read-only variable that is assigned
    pub var_name: StringPtr,
}

impl CantSetVariable {
    /// Returns `var_name` field
    pub fn get_var_name(&self) -> &StringPtr {
        &self.var_name
    }
}

/// Emitted for code like
/// ```text
/// yield(&foo)
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct BlockGivenToYield {
}

impl BlockGivenToYield {
}

/// Emitted for code like
/// ```text
/// fun(&bar) do end
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct BlockAndBlockArgGiven {
}

impl BlockAndBlockArgGiven {
}

/// Emitted for code like
/// ```text
/// case a; in "#{a}": 1; end
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct SymbolLiteralWithInterpolation {
}

impl SymbolLiteralWithInterpolation {
}

/// Emitted for code like
/// ```text
/// _1 = 1
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct ReservedForNumparam {
        /// Numbered parameter that is treated as a local variable
    pub numparam: StringPtr,
}

impl ReservedForNumparam {
    /// Returns `numparam` field
    pub fn get_numparam(&self) -> &StringPtr {
        &self.numparam
    }
}

/// Emitted for code like
/// ```text
/// case a; in a?:; end
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct KeyMustBeValidAsLocalVariable {
}

impl KeyMustBeValidAsLocalVariable {
}

/// Emitted for code like
/// ```text
/// case 0; in a, a; end
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct DuplicateVariableName {
}

impl DuplicateVariableName {
}

/// Emitted for code like
/// ```text
/// case 0; in a: 1, a: 2; end
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct DuplicateKeyName {
}

impl DuplicateKeyName {
}

/// Emitted for code like
/// ```text
/// def (1).foo; end
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct SingletonLiteral {
}

impl SingletonLiteral {
}

/// Emitted for code like (only in $VERBOSE mode)
/// ```text
/// $100
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct NthRefIsTooBig {
        /// Source of the nth_ref that is techincally a regular global variable
    pub nth_ref: StringPtr,
}

impl NthRefIsTooBig {
    /// Returns `nth_ref` field
    pub fn get_nth_ref(&self) -> &StringPtr {
        &self.nth_ref
    }
}

/// Emitted for code like
/// ```text
/// def foo(aa, aa); end
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct DuplicatedArgumentName {
}

impl DuplicatedArgumentName {
}

/// Emitted for code like
/// ```text
/// /[/
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct RegexError {
        /// Error from Onigurama engine
    pub error: StringPtr,
}

impl RegexError {
    /// Returns `error` field
    pub fn get_error(&self) -> &StringPtr {
        &self.error
    }
}

/// Emitted for code like
/// ```text
/// %I"x .\xc3."
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct InvalidSymbol {
        /// Source of the symbol
    pub symbol: StringPtr,
}

impl InvalidSymbol {
    /// Returns `symbol` field
    pub fn get_symbol(&self) -> &StringPtr {
        &self.symbol
    }
}

/// Emitted for code like
/// ```text
/// a = return
/// ```
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct VoidValueExpression {
}

impl VoidValueExpression {
}


impl crate::DiagnosticMessage {
    /// Casts `self` to `Option<&FractionAfterNumeric>`, return `None` if variant doesn't match
    pub fn as_fraction_after_numeric(&self) -> Option<&FractionAfterNumeric> {
        match self {
            Self::FractionAfterNumeric(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&NoDigitsAfterDot>`, return `None` if variant doesn't match
    pub fn as_no_digits_after_dot(&self) -> Option<&NoDigitsAfterDot> {
        match self {
            Self::NoDigitsAfterDot(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&UnknownTypeOfPercentString>`, return `None` if variant doesn't match
    pub fn as_unknown_type_of_percent_string(&self) -> Option<&UnknownTypeOfPercentString> {
        match self {
            Self::UnknownTypeOfPercentString(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&NumericLiteralWithoutDigits>`, return `None` if variant doesn't match
    pub fn as_numeric_literal_without_digits(&self) -> Option<&NumericLiteralWithoutDigits> {
        match self {
            Self::NumericLiteralWithoutDigits(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&UnterminatedList>`, return `None` if variant doesn't match
    pub fn as_unterminated_list(&self) -> Option<&UnterminatedList> {
        match self {
            Self::UnterminatedList(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&UnterminatedRegexp>`, return `None` if variant doesn't match
    pub fn as_unterminated_regexp(&self) -> Option<&UnterminatedRegexp> {
        match self {
            Self::UnterminatedRegexp(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&UnterminatedString>`, return `None` if variant doesn't match
    pub fn as_unterminated_string(&self) -> Option<&UnterminatedString> {
        match self {
            Self::UnterminatedString(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&UnterminatedQuotedString>`, return `None` if variant doesn't match
    pub fn as_unterminated_quoted_string(&self) -> Option<&UnterminatedQuotedString> {
        match self {
            Self::UnterminatedQuotedString(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&InvalidUnicodeEscape>`, return `None` if variant doesn't match
    pub fn as_invalid_unicode_escape(&self) -> Option<&InvalidUnicodeEscape> {
        match self {
            Self::InvalidUnicodeEscape(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&TooLargeUnicodeCodepoint>`, return `None` if variant doesn't match
    pub fn as_too_large_unicode_codepoint(&self) -> Option<&TooLargeUnicodeCodepoint> {
        match self {
            Self::TooLargeUnicodeCodepoint(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&InvalidUnicodeCodepoint>`, return `None` if variant doesn't match
    pub fn as_invalid_unicode_codepoint(&self) -> Option<&InvalidUnicodeCodepoint> {
        match self {
            Self::InvalidUnicodeCodepoint(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&MultipleCodepointAtSingleChar>`, return `None` if variant doesn't match
    pub fn as_multiple_codepoint_at_single_char(&self) -> Option<&MultipleCodepointAtSingleChar> {
        match self {
            Self::MultipleCodepointAtSingleChar(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&InvalidEscapeCharacter>`, return `None` if variant doesn't match
    pub fn as_invalid_escape_character(&self) -> Option<&InvalidEscapeCharacter> {
        match self {
            Self::InvalidEscapeCharacter(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&InvalidHexEscape>`, return `None` if variant doesn't match
    pub fn as_invalid_hex_escape(&self) -> Option<&InvalidHexEscape> {
        match self {
            Self::InvalidHexEscape(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&UnterminatedHeredoc>`, return `None` if variant doesn't match
    pub fn as_unterminated_heredoc(&self) -> Option<&UnterminatedHeredoc> {
        match self {
            Self::UnterminatedHeredoc(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&UnterminatedHeredocId>`, return `None` if variant doesn't match
    pub fn as_unterminated_heredoc_id(&self) -> Option<&UnterminatedHeredocId> {
        match self {
            Self::UnterminatedHeredocId(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&SlashRAtMiddleOfLine>`, return `None` if variant doesn't match
    pub fn as_slash_r_at_middle_of_line(&self) -> Option<&SlashRAtMiddleOfLine> {
        match self {
            Self::SlashRAtMiddleOfLine(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&DStarInterpretedAsArgPrefix>`, return `None` if variant doesn't match
    pub fn as_d_star_interpreted_as_arg_prefix(&self) -> Option<&DStarInterpretedAsArgPrefix> {
        match self {
            Self::DStarInterpretedAsArgPrefix(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&StarInterpretedAsArgPrefix>`, return `None` if variant doesn't match
    pub fn as_star_interpreted_as_arg_prefix(&self) -> Option<&StarInterpretedAsArgPrefix> {
        match self {
            Self::StarInterpretedAsArgPrefix(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&AmpersandInterpretedAsArgPrefix>`, return `None` if variant doesn't match
    pub fn as_ampersand_interpreted_as_arg_prefix(&self) -> Option<&AmpersandInterpretedAsArgPrefix> {
        match self {
            Self::AmpersandInterpretedAsArgPrefix(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&TripleDotAtEol>`, return `None` if variant doesn't match
    pub fn as_triple_dot_at_eol(&self) -> Option<&TripleDotAtEol> {
        match self {
            Self::TripleDotAtEol(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&ParenthesesIterpretedAsArglist>`, return `None` if variant doesn't match
    pub fn as_parentheses_iterpreted_as_arglist(&self) -> Option<&ParenthesesIterpretedAsArglist> {
        match self {
            Self::ParenthesesIterpretedAsArglist(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&AmbiguousFirstArgument>`, return `None` if variant doesn't match
    pub fn as_ambiguous_first_argument(&self) -> Option<&AmbiguousFirstArgument> {
        match self {
            Self::AmbiguousFirstArgument(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&AmbiguousOperator>`, return `None` if variant doesn't match
    pub fn as_ambiguous_operator(&self) -> Option<&AmbiguousOperator> {
        match self {
            Self::AmbiguousOperator(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&InvalidCharacterSyntax>`, return `None` if variant doesn't match
    pub fn as_invalid_character_syntax(&self) -> Option<&InvalidCharacterSyntax> {
        match self {
            Self::InvalidCharacterSyntax(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&InvalidOctalDigit>`, return `None` if variant doesn't match
    pub fn as_invalid_octal_digit(&self) -> Option<&InvalidOctalDigit> {
        match self {
            Self::InvalidOctalDigit(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&TrailingCharInNumber>`, return `None` if variant doesn't match
    pub fn as_trailing_char_in_number(&self) -> Option<&TrailingCharInNumber> {
        match self {
            Self::TrailingCharInNumber(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&EmbeddedDocumentMeetsEof>`, return `None` if variant doesn't match
    pub fn as_embedded_document_meets_eof(&self) -> Option<&EmbeddedDocumentMeetsEof> {
        match self {
            Self::EmbeddedDocumentMeetsEof(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&InvalidChar>`, return `None` if variant doesn't match
    pub fn as_invalid_char(&self) -> Option<&InvalidChar> {
        match self {
            Self::InvalidChar(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&IncompleteCharacterSyntax>`, return `None` if variant doesn't match
    pub fn as_incomplete_character_syntax(&self) -> Option<&IncompleteCharacterSyntax> {
        match self {
            Self::IncompleteCharacterSyntax(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&GvarWithoutId>`, return `None` if variant doesn't match
    pub fn as_gvar_without_id(&self) -> Option<&GvarWithoutId> {
        match self {
            Self::GvarWithoutId(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&InvalidGvarName>`, return `None` if variant doesn't match
    pub fn as_invalid_gvar_name(&self) -> Option<&InvalidGvarName> {
        match self {
            Self::InvalidGvarName(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&IvarWithoutId>`, return `None` if variant doesn't match
    pub fn as_ivar_without_id(&self) -> Option<&IvarWithoutId> {
        match self {
            Self::IvarWithoutId(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&InvalidIvarName>`, return `None` if variant doesn't match
    pub fn as_invalid_ivar_name(&self) -> Option<&InvalidIvarName> {
        match self {
            Self::InvalidIvarName(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&CvarWithoutId>`, return `None` if variant doesn't match
    pub fn as_cvar_without_id(&self) -> Option<&CvarWithoutId> {
        match self {
            Self::CvarWithoutId(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&InvalidCvarName>`, return `None` if variant doesn't match
    pub fn as_invalid_cvar_name(&self) -> Option<&InvalidCvarName> {
        match self {
            Self::InvalidCvarName(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&UnknownRegexOptions>`, return `None` if variant doesn't match
    pub fn as_unknown_regex_options(&self) -> Option<&UnknownRegexOptions> {
        match self {
            Self::UnknownRegexOptions(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&UnterminatedUnicodeEscape>`, return `None` if variant doesn't match
    pub fn as_unterminated_unicode_escape(&self) -> Option<&UnterminatedUnicodeEscape> {
        match self {
            Self::UnterminatedUnicodeEscape(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&EncodingError>`, return `None` if variant doesn't match
    pub fn as_encoding_error(&self) -> Option<&EncodingError> {
        match self {
            Self::EncodingError(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&InvalidMultibyteChar>`, return `None` if variant doesn't match
    pub fn as_invalid_multibyte_char(&self) -> Option<&InvalidMultibyteChar> {
        match self {
            Self::InvalidMultibyteChar(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&AmbiguousTernaryOperator>`, return `None` if variant doesn't match
    pub fn as_ambiguous_ternary_operator(&self) -> Option<&AmbiguousTernaryOperator> {
        match self {
            Self::AmbiguousTernaryOperator(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&AmbiguousRegexp>`, return `None` if variant doesn't match
    pub fn as_ambiguous_regexp(&self) -> Option<&AmbiguousRegexp> {
        match self {
            Self::AmbiguousRegexp(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&ElseWithoutRescue>`, return `None` if variant doesn't match
    pub fn as_else_without_rescue(&self) -> Option<&ElseWithoutRescue> {
        match self {
            Self::ElseWithoutRescue(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&BeginNotAtTopLevel>`, return `None` if variant doesn't match
    pub fn as_begin_not_at_top_level(&self) -> Option<&BeginNotAtTopLevel> {
        match self {
            Self::BeginNotAtTopLevel(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&AliasNthRef>`, return `None` if variant doesn't match
    pub fn as_alias_nth_ref(&self) -> Option<&AliasNthRef> {
        match self {
            Self::AliasNthRef(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&CsendInsideMasgn>`, return `None` if variant doesn't match
    pub fn as_csend_inside_masgn(&self) -> Option<&CsendInsideMasgn> {
        match self {
            Self::CsendInsideMasgn(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&ClassOrModuleNameMustBeConstant>`, return `None` if variant doesn't match
    pub fn as_class_or_module_name_must_be_constant(&self) -> Option<&ClassOrModuleNameMustBeConstant> {
        match self {
            Self::ClassOrModuleNameMustBeConstant(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&EndlessSetterDefinition>`, return `None` if variant doesn't match
    pub fn as_endless_setter_definition(&self) -> Option<&EndlessSetterDefinition> {
        match self {
            Self::EndlessSetterDefinition(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&UnexpectedToken>`, return `None` if variant doesn't match
    pub fn as_unexpected_token(&self) -> Option<&UnexpectedToken> {
        match self {
            Self::UnexpectedToken(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&ClassDefinitionInMethodBody>`, return `None` if variant doesn't match
    pub fn as_class_definition_in_method_body(&self) -> Option<&ClassDefinitionInMethodBody> {
        match self {
            Self::ClassDefinitionInMethodBody(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&ModuleDefinitionInMethodBody>`, return `None` if variant doesn't match
    pub fn as_module_definition_in_method_body(&self) -> Option<&ModuleDefinitionInMethodBody> {
        match self {
            Self::ModuleDefinitionInMethodBody(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&InvalidReturnInClassOrModuleBody>`, return `None` if variant doesn't match
    pub fn as_invalid_return_in_class_or_module_body(&self) -> Option<&InvalidReturnInClassOrModuleBody> {
        match self {
            Self::InvalidReturnInClassOrModuleBody(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&ConstArgument>`, return `None` if variant doesn't match
    pub fn as_const_argument(&self) -> Option<&ConstArgument> {
        match self {
            Self::ConstArgument(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&IvarArgument>`, return `None` if variant doesn't match
    pub fn as_ivar_argument(&self) -> Option<&IvarArgument> {
        match self {
            Self::IvarArgument(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&GvarArgument>`, return `None` if variant doesn't match
    pub fn as_gvar_argument(&self) -> Option<&GvarArgument> {
        match self {
            Self::GvarArgument(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&CvarArgument>`, return `None` if variant doesn't match
    pub fn as_cvar_argument(&self) -> Option<&CvarArgument> {
        match self {
            Self::CvarArgument(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&NoSuchLocalVariable>`, return `None` if variant doesn't match
    pub fn as_no_such_local_variable(&self) -> Option<&NoSuchLocalVariable> {
        match self {
            Self::NoSuchLocalVariable(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&OrdinaryParamDefined>`, return `None` if variant doesn't match
    pub fn as_ordinary_param_defined(&self) -> Option<&OrdinaryParamDefined> {
        match self {
            Self::OrdinaryParamDefined(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&NumparamUsed>`, return `None` if variant doesn't match
    pub fn as_numparam_used(&self) -> Option<&NumparamUsed> {
        match self {
            Self::NumparamUsed(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&TokAtEolWithoutExpression>`, return `None` if variant doesn't match
    pub fn as_tok_at_eol_without_expression(&self) -> Option<&TokAtEolWithoutExpression> {
        match self {
            Self::TokAtEolWithoutExpression(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&EndInMethod>`, return `None` if variant doesn't match
    pub fn as_end_in_method(&self) -> Option<&EndInMethod> {
        match self {
            Self::EndInMethod(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&ComparisonAfterComparison>`, return `None` if variant doesn't match
    pub fn as_comparison_after_comparison(&self) -> Option<&ComparisonAfterComparison> {
        match self {
            Self::ComparisonAfterComparison(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&CircularArgumentReference>`, return `None` if variant doesn't match
    pub fn as_circular_argument_reference(&self) -> Option<&CircularArgumentReference> {
        match self {
            Self::CircularArgumentReference(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&DynamicConstantAssignment>`, return `None` if variant doesn't match
    pub fn as_dynamic_constant_assignment(&self) -> Option<&DynamicConstantAssignment> {
        match self {
            Self::DynamicConstantAssignment(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&CantAssignToSelf>`, return `None` if variant doesn't match
    pub fn as_cant_assign_to_self(&self) -> Option<&CantAssignToSelf> {
        match self {
            Self::CantAssignToSelf(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&CantAssignToNil>`, return `None` if variant doesn't match
    pub fn as_cant_assign_to_nil(&self) -> Option<&CantAssignToNil> {
        match self {
            Self::CantAssignToNil(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&CantAssignToTrue>`, return `None` if variant doesn't match
    pub fn as_cant_assign_to_true(&self) -> Option<&CantAssignToTrue> {
        match self {
            Self::CantAssignToTrue(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&CantAssignToFalse>`, return `None` if variant doesn't match
    pub fn as_cant_assign_to_false(&self) -> Option<&CantAssignToFalse> {
        match self {
            Self::CantAssignToFalse(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&CantAssignToFile>`, return `None` if variant doesn't match
    pub fn as_cant_assign_to_file(&self) -> Option<&CantAssignToFile> {
        match self {
            Self::CantAssignToFile(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&CantAssignToLine>`, return `None` if variant doesn't match
    pub fn as_cant_assign_to_line(&self) -> Option<&CantAssignToLine> {
        match self {
            Self::CantAssignToLine(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&CantAssignToEncoding>`, return `None` if variant doesn't match
    pub fn as_cant_assign_to_encoding(&self) -> Option<&CantAssignToEncoding> {
        match self {
            Self::CantAssignToEncoding(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&CantAssignToNumparam>`, return `None` if variant doesn't match
    pub fn as_cant_assign_to_numparam(&self) -> Option<&CantAssignToNumparam> {
        match self {
            Self::CantAssignToNumparam(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&CantSetVariable>`, return `None` if variant doesn't match
    pub fn as_cant_set_variable(&self) -> Option<&CantSetVariable> {
        match self {
            Self::CantSetVariable(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&BlockGivenToYield>`, return `None` if variant doesn't match
    pub fn as_block_given_to_yield(&self) -> Option<&BlockGivenToYield> {
        match self {
            Self::BlockGivenToYield(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&BlockAndBlockArgGiven>`, return `None` if variant doesn't match
    pub fn as_block_and_block_arg_given(&self) -> Option<&BlockAndBlockArgGiven> {
        match self {
            Self::BlockAndBlockArgGiven(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&SymbolLiteralWithInterpolation>`, return `None` if variant doesn't match
    pub fn as_symbol_literal_with_interpolation(&self) -> Option<&SymbolLiteralWithInterpolation> {
        match self {
            Self::SymbolLiteralWithInterpolation(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&ReservedForNumparam>`, return `None` if variant doesn't match
    pub fn as_reserved_for_numparam(&self) -> Option<&ReservedForNumparam> {
        match self {
            Self::ReservedForNumparam(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&KeyMustBeValidAsLocalVariable>`, return `None` if variant doesn't match
    pub fn as_key_must_be_valid_as_local_variable(&self) -> Option<&KeyMustBeValidAsLocalVariable> {
        match self {
            Self::KeyMustBeValidAsLocalVariable(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&DuplicateVariableName>`, return `None` if variant doesn't match
    pub fn as_duplicate_variable_name(&self) -> Option<&DuplicateVariableName> {
        match self {
            Self::DuplicateVariableName(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&DuplicateKeyName>`, return `None` if variant doesn't match
    pub fn as_duplicate_key_name(&self) -> Option<&DuplicateKeyName> {
        match self {
            Self::DuplicateKeyName(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&SingletonLiteral>`, return `None` if variant doesn't match
    pub fn as_singleton_literal(&self) -> Option<&SingletonLiteral> {
        match self {
            Self::SingletonLiteral(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&NthRefIsTooBig>`, return `None` if variant doesn't match
    pub fn as_nth_ref_is_too_big(&self) -> Option<&NthRefIsTooBig> {
        match self {
            Self::NthRefIsTooBig(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&DuplicatedArgumentName>`, return `None` if variant doesn't match
    pub fn as_duplicated_argument_name(&self) -> Option<&DuplicatedArgumentName> {
        match self {
            Self::DuplicatedArgumentName(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&RegexError>`, return `None` if variant doesn't match
    pub fn as_regex_error(&self) -> Option<&RegexError> {
        match self {
            Self::RegexError(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&InvalidSymbol>`, return `None` if variant doesn't match
    pub fn as_invalid_symbol(&self) -> Option<&InvalidSymbol> {
        match self {
            Self::InvalidSymbol(variant) => Some(variant),
            _ => None
        }
    }
    /// Casts `self` to `Option<&VoidValueExpression>`, return `None` if variant doesn't match
    pub fn as_void_value_expression(&self) -> Option<&VoidValueExpression> {
        match self {
            Self::VoidValueExpression(variant) => Some(variant),
            _ => None
        }
    }
}