lib-ruby-parser 3.0.11

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

use crate::DiagnosticMessage;
use crate::blobs::Blob;
use crate::containers::ExternalStringPtr as StringPtr;

/// External FractionAfterNumeric
#[repr(C)]
pub struct FractionAfterNumeric {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_fraction_after_numeric(blob: *const Blob<DiagnosticMessage>) -> *const Blob<FractionAfterNumeric>;
}

impl FractionAfterNumeric {
}

impl std::fmt::Debug for FractionAfterNumeric {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("FractionAfterNumeric")
            .finish()
    }
}

impl PartialEq for FractionAfterNumeric {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&FractionAfterNumeric>`, return `None` if variant doesn't match
    pub fn as_fraction_after_numeric(&self) -> Option<&FractionAfterNumeric> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_fraction_after_numeric(&self.blob) as *const FractionAfterNumeric).as_ref()
        }
    }
}

/// External NoDigitsAfterDot
#[repr(C)]
pub struct NoDigitsAfterDot {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_no_digits_after_dot(blob: *const Blob<DiagnosticMessage>) -> *const Blob<NoDigitsAfterDot>;
}

impl NoDigitsAfterDot {
}

impl std::fmt::Debug for NoDigitsAfterDot {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("NoDigitsAfterDot")
            .finish()
    }
}

impl PartialEq for NoDigitsAfterDot {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&NoDigitsAfterDot>`, return `None` if variant doesn't match
    pub fn as_no_digits_after_dot(&self) -> Option<&NoDigitsAfterDot> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_no_digits_after_dot(&self.blob) as *const NoDigitsAfterDot).as_ref()
        }
    }
}

/// External UnknownTypeOfPercentString
#[repr(C)]
pub struct UnknownTypeOfPercentString {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_unknown_type_of_percent_string(blob: *const Blob<DiagnosticMessage>) -> *const Blob<UnknownTypeOfPercentString>;
}

impl UnknownTypeOfPercentString {
}

impl std::fmt::Debug for UnknownTypeOfPercentString {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("UnknownTypeOfPercentString")
            .finish()
    }
}

impl PartialEq for UnknownTypeOfPercentString {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&UnknownTypeOfPercentString>`, return `None` if variant doesn't match
    pub fn as_unknown_type_of_percent_string(&self) -> Option<&UnknownTypeOfPercentString> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_unknown_type_of_percent_string(&self.blob) as *const UnknownTypeOfPercentString).as_ref()
        }
    }
}

/// External NumericLiteralWithoutDigits
#[repr(C)]
pub struct NumericLiteralWithoutDigits {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_numeric_literal_without_digits(blob: *const Blob<DiagnosticMessage>) -> *const Blob<NumericLiteralWithoutDigits>;
}

impl NumericLiteralWithoutDigits {
}

impl std::fmt::Debug for NumericLiteralWithoutDigits {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("NumericLiteralWithoutDigits")
            .finish()
    }
}

impl PartialEq for NumericLiteralWithoutDigits {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&NumericLiteralWithoutDigits>`, return `None` if variant doesn't match
    pub fn as_numeric_literal_without_digits(&self) -> Option<&NumericLiteralWithoutDigits> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_numeric_literal_without_digits(&self.blob) as *const NumericLiteralWithoutDigits).as_ref()
        }
    }
}

/// External UnterminatedList
#[repr(C)]
pub struct UnterminatedList {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_unterminated_list(blob: *const Blob<DiagnosticMessage>) -> *const Blob<UnterminatedList>;
}

impl UnterminatedList {
}

impl std::fmt::Debug for UnterminatedList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("UnterminatedList")
            .finish()
    }
}

impl PartialEq for UnterminatedList {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&UnterminatedList>`, return `None` if variant doesn't match
    pub fn as_unterminated_list(&self) -> Option<&UnterminatedList> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_unterminated_list(&self.blob) as *const UnterminatedList).as_ref()
        }
    }
}

/// External UnterminatedRegexp
#[repr(C)]
pub struct UnterminatedRegexp {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_unterminated_regexp(blob: *const Blob<DiagnosticMessage>) -> *const Blob<UnterminatedRegexp>;
}

impl UnterminatedRegexp {
}

impl std::fmt::Debug for UnterminatedRegexp {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("UnterminatedRegexp")
            .finish()
    }
}

impl PartialEq for UnterminatedRegexp {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&UnterminatedRegexp>`, return `None` if variant doesn't match
    pub fn as_unterminated_regexp(&self) -> Option<&UnterminatedRegexp> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_unterminated_regexp(&self.blob) as *const UnterminatedRegexp).as_ref()
        }
    }
}

/// External UnterminatedString
#[repr(C)]
pub struct UnterminatedString {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_unterminated_string(blob: *const Blob<DiagnosticMessage>) -> *const Blob<UnterminatedString>;
}

impl UnterminatedString {
}

impl std::fmt::Debug for UnterminatedString {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("UnterminatedString")
            .finish()
    }
}

impl PartialEq for UnterminatedString {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&UnterminatedString>`, return `None` if variant doesn't match
    pub fn as_unterminated_string(&self) -> Option<&UnterminatedString> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_unterminated_string(&self.blob) as *const UnterminatedString).as_ref()
        }
    }
}

/// External UnterminatedQuotedString
#[repr(C)]
pub struct UnterminatedQuotedString {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_unterminated_quoted_string(blob: *const Blob<DiagnosticMessage>) -> *const Blob<UnterminatedQuotedString>;
}

impl UnterminatedQuotedString {
}

impl std::fmt::Debug for UnterminatedQuotedString {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("UnterminatedQuotedString")
            .finish()
    }
}

impl PartialEq for UnterminatedQuotedString {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&UnterminatedQuotedString>`, return `None` if variant doesn't match
    pub fn as_unterminated_quoted_string(&self) -> Option<&UnterminatedQuotedString> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_unterminated_quoted_string(&self.blob) as *const UnterminatedQuotedString).as_ref()
        }
    }
}

/// External InvalidUnicodeEscape
#[repr(C)]
pub struct InvalidUnicodeEscape {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_invalid_unicode_escape(blob: *const Blob<DiagnosticMessage>) -> *const Blob<InvalidUnicodeEscape>;
}

impl InvalidUnicodeEscape {
}

impl std::fmt::Debug for InvalidUnicodeEscape {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("InvalidUnicodeEscape")
            .finish()
    }
}

impl PartialEq for InvalidUnicodeEscape {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&InvalidUnicodeEscape>`, return `None` if variant doesn't match
    pub fn as_invalid_unicode_escape(&self) -> Option<&InvalidUnicodeEscape> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_invalid_unicode_escape(&self.blob) as *const InvalidUnicodeEscape).as_ref()
        }
    }
}

/// External TooLargeUnicodeCodepoint
#[repr(C)]
pub struct TooLargeUnicodeCodepoint {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_too_large_unicode_codepoint(blob: *const Blob<DiagnosticMessage>) -> *const Blob<TooLargeUnicodeCodepoint>;
}

impl TooLargeUnicodeCodepoint {
}

impl std::fmt::Debug for TooLargeUnicodeCodepoint {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("TooLargeUnicodeCodepoint")
            .finish()
    }
}

impl PartialEq for TooLargeUnicodeCodepoint {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&TooLargeUnicodeCodepoint>`, return `None` if variant doesn't match
    pub fn as_too_large_unicode_codepoint(&self) -> Option<&TooLargeUnicodeCodepoint> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_too_large_unicode_codepoint(&self.blob) as *const TooLargeUnicodeCodepoint).as_ref()
        }
    }
}

/// External InvalidUnicodeCodepoint
#[repr(C)]
pub struct InvalidUnicodeCodepoint {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_invalid_unicode_codepoint(blob: *const Blob<DiagnosticMessage>) -> *const Blob<InvalidUnicodeCodepoint>;
}

impl InvalidUnicodeCodepoint {
}

impl std::fmt::Debug for InvalidUnicodeCodepoint {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("InvalidUnicodeCodepoint")
            .finish()
    }
}

impl PartialEq for InvalidUnicodeCodepoint {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&InvalidUnicodeCodepoint>`, return `None` if variant doesn't match
    pub fn as_invalid_unicode_codepoint(&self) -> Option<&InvalidUnicodeCodepoint> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_invalid_unicode_codepoint(&self.blob) as *const InvalidUnicodeCodepoint).as_ref()
        }
    }
}

/// External MultipleCodepointAtSingleChar
#[repr(C)]
pub struct MultipleCodepointAtSingleChar {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_multiple_codepoint_at_single_char(blob: *const Blob<DiagnosticMessage>) -> *const Blob<MultipleCodepointAtSingleChar>;
}

impl MultipleCodepointAtSingleChar {
}

impl std::fmt::Debug for MultipleCodepointAtSingleChar {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("MultipleCodepointAtSingleChar")
            .finish()
    }
}

impl PartialEq for MultipleCodepointAtSingleChar {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&MultipleCodepointAtSingleChar>`, return `None` if variant doesn't match
    pub fn as_multiple_codepoint_at_single_char(&self) -> Option<&MultipleCodepointAtSingleChar> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_multiple_codepoint_at_single_char(&self.blob) as *const MultipleCodepointAtSingleChar).as_ref()
        }
    }
}

/// External InvalidEscapeCharacter
#[repr(C)]
pub struct InvalidEscapeCharacter {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_invalid_escape_character(blob: *const Blob<DiagnosticMessage>) -> *const Blob<InvalidEscapeCharacter>;
}

impl InvalidEscapeCharacter {
}

impl std::fmt::Debug for InvalidEscapeCharacter {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("InvalidEscapeCharacter")
            .finish()
    }
}

impl PartialEq for InvalidEscapeCharacter {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&InvalidEscapeCharacter>`, return `None` if variant doesn't match
    pub fn as_invalid_escape_character(&self) -> Option<&InvalidEscapeCharacter> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_invalid_escape_character(&self.blob) as *const InvalidEscapeCharacter).as_ref()
        }
    }
}

/// External InvalidHexEscape
#[repr(C)]
pub struct InvalidHexEscape {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_invalid_hex_escape(blob: *const Blob<DiagnosticMessage>) -> *const Blob<InvalidHexEscape>;
}

impl InvalidHexEscape {
}

impl std::fmt::Debug for InvalidHexEscape {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("InvalidHexEscape")
            .finish()
    }
}

impl PartialEq for InvalidHexEscape {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&InvalidHexEscape>`, return `None` if variant doesn't match
    pub fn as_invalid_hex_escape(&self) -> Option<&InvalidHexEscape> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_invalid_hex_escape(&self.blob) as *const InvalidHexEscape).as_ref()
        }
    }
}

/// External UnterminatedHeredoc
#[repr(C)]
pub struct UnterminatedHeredoc {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_unterminated_heredoc(blob: *const Blob<DiagnosticMessage>) -> *const Blob<UnterminatedHeredoc>;
    fn lib_ruby_parser__external__diagnotic_messages__unterminated_heredoc__get_heredoc_id(blob: *const Blob<UnterminatedHeredoc>) -> *const Blob<StringPtr>;
}

impl UnterminatedHeredoc {
    /// Returns `heredoc_id` field
    pub fn get_heredoc_id(&self) -> &StringPtr {
        unsafe {
            #[allow(trivial_casts)]
            (lib_ruby_parser__external__diagnotic_messages__unterminated_heredoc__get_heredoc_id(&self.blob) as *const StringPtr).as_ref().unwrap()
        }
    }
}

impl std::fmt::Debug for UnterminatedHeredoc {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("UnterminatedHeredoc")
            .field("heredoc_id", self.get_heredoc_id())
            .finish()
    }
}

impl PartialEq for UnterminatedHeredoc {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        if self.get_heredoc_id() != other.get_heredoc_id() {
            return false
        }
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&UnterminatedHeredoc>`, return `None` if variant doesn't match
    pub fn as_unterminated_heredoc(&self) -> Option<&UnterminatedHeredoc> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_unterminated_heredoc(&self.blob) as *const UnterminatedHeredoc).as_ref()
        }
    }
}

/// External UnterminatedHeredocId
#[repr(C)]
pub struct UnterminatedHeredocId {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_unterminated_heredoc_id(blob: *const Blob<DiagnosticMessage>) -> *const Blob<UnterminatedHeredocId>;
}

impl UnterminatedHeredocId {
}

impl std::fmt::Debug for UnterminatedHeredocId {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("UnterminatedHeredocId")
            .finish()
    }
}

impl PartialEq for UnterminatedHeredocId {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&UnterminatedHeredocId>`, return `None` if variant doesn't match
    pub fn as_unterminated_heredoc_id(&self) -> Option<&UnterminatedHeredocId> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_unterminated_heredoc_id(&self.blob) as *const UnterminatedHeredocId).as_ref()
        }
    }
}

/// External SlashRAtMiddleOfLine
#[repr(C)]
pub struct SlashRAtMiddleOfLine {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_slash_r_at_middle_of_line(blob: *const Blob<DiagnosticMessage>) -> *const Blob<SlashRAtMiddleOfLine>;
}

impl SlashRAtMiddleOfLine {
}

impl std::fmt::Debug for SlashRAtMiddleOfLine {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("SlashRAtMiddleOfLine")
            .finish()
    }
}

impl PartialEq for SlashRAtMiddleOfLine {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&SlashRAtMiddleOfLine>`, return `None` if variant doesn't match
    pub fn as_slash_r_at_middle_of_line(&self) -> Option<&SlashRAtMiddleOfLine> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_slash_r_at_middle_of_line(&self.blob) as *const SlashRAtMiddleOfLine).as_ref()
        }
    }
}

/// External DStarInterpretedAsArgPrefix
#[repr(C)]
pub struct DStarInterpretedAsArgPrefix {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_d_star_interpreted_as_arg_prefix(blob: *const Blob<DiagnosticMessage>) -> *const Blob<DStarInterpretedAsArgPrefix>;
}

impl DStarInterpretedAsArgPrefix {
}

impl std::fmt::Debug for DStarInterpretedAsArgPrefix {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("DStarInterpretedAsArgPrefix")
            .finish()
    }
}

impl PartialEq for DStarInterpretedAsArgPrefix {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&DStarInterpretedAsArgPrefix>`, return `None` if variant doesn't match
    pub fn as_d_star_interpreted_as_arg_prefix(&self) -> Option<&DStarInterpretedAsArgPrefix> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_d_star_interpreted_as_arg_prefix(&self.blob) as *const DStarInterpretedAsArgPrefix).as_ref()
        }
    }
}

/// External StarInterpretedAsArgPrefix
#[repr(C)]
pub struct StarInterpretedAsArgPrefix {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_star_interpreted_as_arg_prefix(blob: *const Blob<DiagnosticMessage>) -> *const Blob<StarInterpretedAsArgPrefix>;
}

impl StarInterpretedAsArgPrefix {
}

impl std::fmt::Debug for StarInterpretedAsArgPrefix {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("StarInterpretedAsArgPrefix")
            .finish()
    }
}

impl PartialEq for StarInterpretedAsArgPrefix {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&StarInterpretedAsArgPrefix>`, return `None` if variant doesn't match
    pub fn as_star_interpreted_as_arg_prefix(&self) -> Option<&StarInterpretedAsArgPrefix> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_star_interpreted_as_arg_prefix(&self.blob) as *const StarInterpretedAsArgPrefix).as_ref()
        }
    }
}

/// External AmpersandInterpretedAsArgPrefix
#[repr(C)]
pub struct AmpersandInterpretedAsArgPrefix {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_ampersand_interpreted_as_arg_prefix(blob: *const Blob<DiagnosticMessage>) -> *const Blob<AmpersandInterpretedAsArgPrefix>;
}

impl AmpersandInterpretedAsArgPrefix {
}

impl std::fmt::Debug for AmpersandInterpretedAsArgPrefix {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("AmpersandInterpretedAsArgPrefix")
            .finish()
    }
}

impl PartialEq for AmpersandInterpretedAsArgPrefix {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&AmpersandInterpretedAsArgPrefix>`, return `None` if variant doesn't match
    pub fn as_ampersand_interpreted_as_arg_prefix(&self) -> Option<&AmpersandInterpretedAsArgPrefix> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_ampersand_interpreted_as_arg_prefix(&self.blob) as *const AmpersandInterpretedAsArgPrefix).as_ref()
        }
    }
}

/// External TripleDotAtEol
#[repr(C)]
pub struct TripleDotAtEol {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_triple_dot_at_eol(blob: *const Blob<DiagnosticMessage>) -> *const Blob<TripleDotAtEol>;
}

impl TripleDotAtEol {
}

impl std::fmt::Debug for TripleDotAtEol {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("TripleDotAtEol")
            .finish()
    }
}

impl PartialEq for TripleDotAtEol {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&TripleDotAtEol>`, return `None` if variant doesn't match
    pub fn as_triple_dot_at_eol(&self) -> Option<&TripleDotAtEol> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_triple_dot_at_eol(&self.blob) as *const TripleDotAtEol).as_ref()
        }
    }
}

/// External ParenthesesIterpretedAsArglist
#[repr(C)]
pub struct ParenthesesIterpretedAsArglist {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_parentheses_iterpreted_as_arglist(blob: *const Blob<DiagnosticMessage>) -> *const Blob<ParenthesesIterpretedAsArglist>;
}

impl ParenthesesIterpretedAsArglist {
}

impl std::fmt::Debug for ParenthesesIterpretedAsArglist {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("ParenthesesIterpretedAsArglist")
            .finish()
    }
}

impl PartialEq for ParenthesesIterpretedAsArglist {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&ParenthesesIterpretedAsArglist>`, return `None` if variant doesn't match
    pub fn as_parentheses_iterpreted_as_arglist(&self) -> Option<&ParenthesesIterpretedAsArglist> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_parentheses_iterpreted_as_arglist(&self.blob) as *const ParenthesesIterpretedAsArglist).as_ref()
        }
    }
}

/// External AmbiguousFirstArgument
#[repr(C)]
pub struct AmbiguousFirstArgument {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_ambiguous_first_argument(blob: *const Blob<DiagnosticMessage>) -> *const Blob<AmbiguousFirstArgument>;
    fn lib_ruby_parser__external__diagnotic_messages__ambiguous_first_argument__get_operator_(blob: *const Blob<AmbiguousFirstArgument>) -> *const Blob<u8>;
}

impl AmbiguousFirstArgument {
    /// Returns `operator` field
    pub fn get_operator(&self) -> &u8 {
        unsafe {
            #[allow(trivial_casts)]
            (lib_ruby_parser__external__diagnotic_messages__ambiguous_first_argument__get_operator_(&self.blob) as *const u8).as_ref().unwrap()
        }
    }
}

impl std::fmt::Debug for AmbiguousFirstArgument {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("AmbiguousFirstArgument")
            .field("operator", self.get_operator())
            .finish()
    }
}

impl PartialEq for AmbiguousFirstArgument {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        if self.get_operator() != other.get_operator() {
            return false
        }
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&AmbiguousFirstArgument>`, return `None` if variant doesn't match
    pub fn as_ambiguous_first_argument(&self) -> Option<&AmbiguousFirstArgument> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_ambiguous_first_argument(&self.blob) as *const AmbiguousFirstArgument).as_ref()
        }
    }
}

/// External AmbiguousOperator
#[repr(C)]
pub struct AmbiguousOperator {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_ambiguous_operator(blob: *const Blob<DiagnosticMessage>) -> *const Blob<AmbiguousOperator>;
    fn lib_ruby_parser__external__diagnotic_messages__ambiguous_operator__get_operator_(blob: *const Blob<AmbiguousOperator>) -> *const Blob<StringPtr>;
    fn lib_ruby_parser__external__diagnotic_messages__ambiguous_operator__get_interpreted_as(blob: *const Blob<AmbiguousOperator>) -> *const Blob<StringPtr>;
}

impl AmbiguousOperator {
    /// Returns `operator` field
    pub fn get_operator(&self) -> &StringPtr {
        unsafe {
            #[allow(trivial_casts)]
            (lib_ruby_parser__external__diagnotic_messages__ambiguous_operator__get_operator_(&self.blob) as *const StringPtr).as_ref().unwrap()
        }
    }
    /// Returns `interpreted_as` field
    pub fn get_interpreted_as(&self) -> &StringPtr {
        unsafe {
            #[allow(trivial_casts)]
            (lib_ruby_parser__external__diagnotic_messages__ambiguous_operator__get_interpreted_as(&self.blob) as *const StringPtr).as_ref().unwrap()
        }
    }
}

impl std::fmt::Debug for AmbiguousOperator {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("AmbiguousOperator")
            .field("operator", self.get_operator())
            .field("interpreted_as", self.get_interpreted_as())
            .finish()
    }
}

impl PartialEq for AmbiguousOperator {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        if self.get_operator() != other.get_operator() {
            return false
        }
        if self.get_interpreted_as() != other.get_interpreted_as() {
            return false
        }
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&AmbiguousOperator>`, return `None` if variant doesn't match
    pub fn as_ambiguous_operator(&self) -> Option<&AmbiguousOperator> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_ambiguous_operator(&self.blob) as *const AmbiguousOperator).as_ref()
        }
    }
}

/// External InvalidCharacterSyntax
#[repr(C)]
pub struct InvalidCharacterSyntax {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_invalid_character_syntax(blob: *const Blob<DiagnosticMessage>) -> *const Blob<InvalidCharacterSyntax>;
    fn lib_ruby_parser__external__diagnotic_messages__invalid_character_syntax__get_suggestion(blob: *const Blob<InvalidCharacterSyntax>) -> *const Blob<StringPtr>;
}

impl InvalidCharacterSyntax {
    /// Returns `suggestion` field
    pub fn get_suggestion(&self) -> &StringPtr {
        unsafe {
            #[allow(trivial_casts)]
            (lib_ruby_parser__external__diagnotic_messages__invalid_character_syntax__get_suggestion(&self.blob) as *const StringPtr).as_ref().unwrap()
        }
    }
}

impl std::fmt::Debug for InvalidCharacterSyntax {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("InvalidCharacterSyntax")
            .field("suggestion", self.get_suggestion())
            .finish()
    }
}

impl PartialEq for InvalidCharacterSyntax {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        if self.get_suggestion() != other.get_suggestion() {
            return false
        }
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&InvalidCharacterSyntax>`, return `None` if variant doesn't match
    pub fn as_invalid_character_syntax(&self) -> Option<&InvalidCharacterSyntax> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_invalid_character_syntax(&self.blob) as *const InvalidCharacterSyntax).as_ref()
        }
    }
}

/// External InvalidOctalDigit
#[repr(C)]
pub struct InvalidOctalDigit {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_invalid_octal_digit(blob: *const Blob<DiagnosticMessage>) -> *const Blob<InvalidOctalDigit>;
}

impl InvalidOctalDigit {
}

impl std::fmt::Debug for InvalidOctalDigit {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("InvalidOctalDigit")
            .finish()
    }
}

impl PartialEq for InvalidOctalDigit {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&InvalidOctalDigit>`, return `None` if variant doesn't match
    pub fn as_invalid_octal_digit(&self) -> Option<&InvalidOctalDigit> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_invalid_octal_digit(&self.blob) as *const InvalidOctalDigit).as_ref()
        }
    }
}

/// External TrailingCharInNumber
#[repr(C)]
pub struct TrailingCharInNumber {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_trailing_char_in_number(blob: *const Blob<DiagnosticMessage>) -> *const Blob<TrailingCharInNumber>;
    fn lib_ruby_parser__external__diagnotic_messages__trailing_char_in_number__get_c(blob: *const Blob<TrailingCharInNumber>) -> *const Blob<u8>;
}

impl TrailingCharInNumber {
    /// Returns `c` field
    pub fn get_c(&self) -> &u8 {
        unsafe {
            #[allow(trivial_casts)]
            (lib_ruby_parser__external__diagnotic_messages__trailing_char_in_number__get_c(&self.blob) as *const u8).as_ref().unwrap()
        }
    }
}

impl std::fmt::Debug for TrailingCharInNumber {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("TrailingCharInNumber")
            .field("c", self.get_c())
            .finish()
    }
}

impl PartialEq for TrailingCharInNumber {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        if self.get_c() != other.get_c() {
            return false
        }
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&TrailingCharInNumber>`, return `None` if variant doesn't match
    pub fn as_trailing_char_in_number(&self) -> Option<&TrailingCharInNumber> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_trailing_char_in_number(&self.blob) as *const TrailingCharInNumber).as_ref()
        }
    }
}

/// External EmbeddedDocumentMeetsEof
#[repr(C)]
pub struct EmbeddedDocumentMeetsEof {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_embedded_document_meets_eof(blob: *const Blob<DiagnosticMessage>) -> *const Blob<EmbeddedDocumentMeetsEof>;
}

impl EmbeddedDocumentMeetsEof {
}

impl std::fmt::Debug for EmbeddedDocumentMeetsEof {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("EmbeddedDocumentMeetsEof")
            .finish()
    }
}

impl PartialEq for EmbeddedDocumentMeetsEof {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&EmbeddedDocumentMeetsEof>`, return `None` if variant doesn't match
    pub fn as_embedded_document_meets_eof(&self) -> Option<&EmbeddedDocumentMeetsEof> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_embedded_document_meets_eof(&self.blob) as *const EmbeddedDocumentMeetsEof).as_ref()
        }
    }
}

/// External InvalidChar
#[repr(C)]
pub struct InvalidChar {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_invalid_char(blob: *const Blob<DiagnosticMessage>) -> *const Blob<InvalidChar>;
    fn lib_ruby_parser__external__diagnotic_messages__invalid_char__get_c(blob: *const Blob<InvalidChar>) -> *const Blob<u8>;
}

impl InvalidChar {
    /// Returns `c` field
    pub fn get_c(&self) -> &u8 {
        unsafe {
            #[allow(trivial_casts)]
            (lib_ruby_parser__external__diagnotic_messages__invalid_char__get_c(&self.blob) as *const u8).as_ref().unwrap()
        }
    }
}

impl std::fmt::Debug for InvalidChar {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("InvalidChar")
            .field("c", self.get_c())
            .finish()
    }
}

impl PartialEq for InvalidChar {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        if self.get_c() != other.get_c() {
            return false
        }
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&InvalidChar>`, return `None` if variant doesn't match
    pub fn as_invalid_char(&self) -> Option<&InvalidChar> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_invalid_char(&self.blob) as *const InvalidChar).as_ref()
        }
    }
}

/// External IncompleteCharacterSyntax
#[repr(C)]
pub struct IncompleteCharacterSyntax {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_incomplete_character_syntax(blob: *const Blob<DiagnosticMessage>) -> *const Blob<IncompleteCharacterSyntax>;
}

impl IncompleteCharacterSyntax {
}

impl std::fmt::Debug for IncompleteCharacterSyntax {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("IncompleteCharacterSyntax")
            .finish()
    }
}

impl PartialEq for IncompleteCharacterSyntax {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&IncompleteCharacterSyntax>`, return `None` if variant doesn't match
    pub fn as_incomplete_character_syntax(&self) -> Option<&IncompleteCharacterSyntax> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_incomplete_character_syntax(&self.blob) as *const IncompleteCharacterSyntax).as_ref()
        }
    }
}

/// External GvarWithoutId
#[repr(C)]
pub struct GvarWithoutId {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_gvar_without_id(blob: *const Blob<DiagnosticMessage>) -> *const Blob<GvarWithoutId>;
}

impl GvarWithoutId {
}

impl std::fmt::Debug for GvarWithoutId {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("GvarWithoutId")
            .finish()
    }
}

impl PartialEq for GvarWithoutId {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&GvarWithoutId>`, return `None` if variant doesn't match
    pub fn as_gvar_without_id(&self) -> Option<&GvarWithoutId> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_gvar_without_id(&self.blob) as *const GvarWithoutId).as_ref()
        }
    }
}

/// External InvalidGvarName
#[repr(C)]
pub struct InvalidGvarName {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_invalid_gvar_name(blob: *const Blob<DiagnosticMessage>) -> *const Blob<InvalidGvarName>;
    fn lib_ruby_parser__external__diagnotic_messages__invalid_gvar_name__get_c(blob: *const Blob<InvalidGvarName>) -> *const Blob<u8>;
}

impl InvalidGvarName {
    /// Returns `c` field
    pub fn get_c(&self) -> &u8 {
        unsafe {
            #[allow(trivial_casts)]
            (lib_ruby_parser__external__diagnotic_messages__invalid_gvar_name__get_c(&self.blob) as *const u8).as_ref().unwrap()
        }
    }
}

impl std::fmt::Debug for InvalidGvarName {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("InvalidGvarName")
            .field("c", self.get_c())
            .finish()
    }
}

impl PartialEq for InvalidGvarName {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        if self.get_c() != other.get_c() {
            return false
        }
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&InvalidGvarName>`, return `None` if variant doesn't match
    pub fn as_invalid_gvar_name(&self) -> Option<&InvalidGvarName> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_invalid_gvar_name(&self.blob) as *const InvalidGvarName).as_ref()
        }
    }
}

/// External IvarWithoutId
#[repr(C)]
pub struct IvarWithoutId {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_ivar_without_id(blob: *const Blob<DiagnosticMessage>) -> *const Blob<IvarWithoutId>;
}

impl IvarWithoutId {
}

impl std::fmt::Debug for IvarWithoutId {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("IvarWithoutId")
            .finish()
    }
}

impl PartialEq for IvarWithoutId {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&IvarWithoutId>`, return `None` if variant doesn't match
    pub fn as_ivar_without_id(&self) -> Option<&IvarWithoutId> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_ivar_without_id(&self.blob) as *const IvarWithoutId).as_ref()
        }
    }
}

/// External InvalidIvarName
#[repr(C)]
pub struct InvalidIvarName {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_invalid_ivar_name(blob: *const Blob<DiagnosticMessage>) -> *const Blob<InvalidIvarName>;
    fn lib_ruby_parser__external__diagnotic_messages__invalid_ivar_name__get_c(blob: *const Blob<InvalidIvarName>) -> *const Blob<u8>;
}

impl InvalidIvarName {
    /// Returns `c` field
    pub fn get_c(&self) -> &u8 {
        unsafe {
            #[allow(trivial_casts)]
            (lib_ruby_parser__external__diagnotic_messages__invalid_ivar_name__get_c(&self.blob) as *const u8).as_ref().unwrap()
        }
    }
}

impl std::fmt::Debug for InvalidIvarName {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("InvalidIvarName")
            .field("c", self.get_c())
            .finish()
    }
}

impl PartialEq for InvalidIvarName {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        if self.get_c() != other.get_c() {
            return false
        }
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&InvalidIvarName>`, return `None` if variant doesn't match
    pub fn as_invalid_ivar_name(&self) -> Option<&InvalidIvarName> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_invalid_ivar_name(&self.blob) as *const InvalidIvarName).as_ref()
        }
    }
}

/// External CvarWithoutId
#[repr(C)]
pub struct CvarWithoutId {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_cvar_without_id(blob: *const Blob<DiagnosticMessage>) -> *const Blob<CvarWithoutId>;
}

impl CvarWithoutId {
}

impl std::fmt::Debug for CvarWithoutId {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("CvarWithoutId")
            .finish()
    }
}

impl PartialEq for CvarWithoutId {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&CvarWithoutId>`, return `None` if variant doesn't match
    pub fn as_cvar_without_id(&self) -> Option<&CvarWithoutId> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_cvar_without_id(&self.blob) as *const CvarWithoutId).as_ref()
        }
    }
}

/// External InvalidCvarName
#[repr(C)]
pub struct InvalidCvarName {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_invalid_cvar_name(blob: *const Blob<DiagnosticMessage>) -> *const Blob<InvalidCvarName>;
    fn lib_ruby_parser__external__diagnotic_messages__invalid_cvar_name__get_c(blob: *const Blob<InvalidCvarName>) -> *const Blob<u8>;
}

impl InvalidCvarName {
    /// Returns `c` field
    pub fn get_c(&self) -> &u8 {
        unsafe {
            #[allow(trivial_casts)]
            (lib_ruby_parser__external__diagnotic_messages__invalid_cvar_name__get_c(&self.blob) as *const u8).as_ref().unwrap()
        }
    }
}

impl std::fmt::Debug for InvalidCvarName {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("InvalidCvarName")
            .field("c", self.get_c())
            .finish()
    }
}

impl PartialEq for InvalidCvarName {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        if self.get_c() != other.get_c() {
            return false
        }
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&InvalidCvarName>`, return `None` if variant doesn't match
    pub fn as_invalid_cvar_name(&self) -> Option<&InvalidCvarName> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_invalid_cvar_name(&self.blob) as *const InvalidCvarName).as_ref()
        }
    }
}

/// External UnknownRegexOptions
#[repr(C)]
pub struct UnknownRegexOptions {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_unknown_regex_options(blob: *const Blob<DiagnosticMessage>) -> *const Blob<UnknownRegexOptions>;
    fn lib_ruby_parser__external__diagnotic_messages__unknown_regex_options__get_options(blob: *const Blob<UnknownRegexOptions>) -> *const Blob<StringPtr>;
}

impl UnknownRegexOptions {
    /// Returns `options` field
    pub fn get_options(&self) -> &StringPtr {
        unsafe {
            #[allow(trivial_casts)]
            (lib_ruby_parser__external__diagnotic_messages__unknown_regex_options__get_options(&self.blob) as *const StringPtr).as_ref().unwrap()
        }
    }
}

impl std::fmt::Debug for UnknownRegexOptions {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("UnknownRegexOptions")
            .field("options", self.get_options())
            .finish()
    }
}

impl PartialEq for UnknownRegexOptions {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        if self.get_options() != other.get_options() {
            return false
        }
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&UnknownRegexOptions>`, return `None` if variant doesn't match
    pub fn as_unknown_regex_options(&self) -> Option<&UnknownRegexOptions> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_unknown_regex_options(&self.blob) as *const UnknownRegexOptions).as_ref()
        }
    }
}

/// External UnterminatedUnicodeEscape
#[repr(C)]
pub struct UnterminatedUnicodeEscape {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_unterminated_unicode_escape(blob: *const Blob<DiagnosticMessage>) -> *const Blob<UnterminatedUnicodeEscape>;
}

impl UnterminatedUnicodeEscape {
}

impl std::fmt::Debug for UnterminatedUnicodeEscape {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("UnterminatedUnicodeEscape")
            .finish()
    }
}

impl PartialEq for UnterminatedUnicodeEscape {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&UnterminatedUnicodeEscape>`, return `None` if variant doesn't match
    pub fn as_unterminated_unicode_escape(&self) -> Option<&UnterminatedUnicodeEscape> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_unterminated_unicode_escape(&self.blob) as *const UnterminatedUnicodeEscape).as_ref()
        }
    }
}

/// External EncodingError
#[repr(C)]
pub struct EncodingError {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_encoding_error(blob: *const Blob<DiagnosticMessage>) -> *const Blob<EncodingError>;
    fn lib_ruby_parser__external__diagnotic_messages__encoding_error__get_error(blob: *const Blob<EncodingError>) -> *const Blob<StringPtr>;
}

impl EncodingError {
    /// Returns `error` field
    pub fn get_error(&self) -> &StringPtr {
        unsafe {
            #[allow(trivial_casts)]
            (lib_ruby_parser__external__diagnotic_messages__encoding_error__get_error(&self.blob) as *const StringPtr).as_ref().unwrap()
        }
    }
}

impl std::fmt::Debug for EncodingError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("EncodingError")
            .field("error", self.get_error())
            .finish()
    }
}

impl PartialEq for EncodingError {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        if self.get_error() != other.get_error() {
            return false
        }
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&EncodingError>`, return `None` if variant doesn't match
    pub fn as_encoding_error(&self) -> Option<&EncodingError> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_encoding_error(&self.blob) as *const EncodingError).as_ref()
        }
    }
}

/// External InvalidMultibyteChar
#[repr(C)]
pub struct InvalidMultibyteChar {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_invalid_multibyte_char(blob: *const Blob<DiagnosticMessage>) -> *const Blob<InvalidMultibyteChar>;
}

impl InvalidMultibyteChar {
}

impl std::fmt::Debug for InvalidMultibyteChar {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("InvalidMultibyteChar")
            .finish()
    }
}

impl PartialEq for InvalidMultibyteChar {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&InvalidMultibyteChar>`, return `None` if variant doesn't match
    pub fn as_invalid_multibyte_char(&self) -> Option<&InvalidMultibyteChar> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_invalid_multibyte_char(&self.blob) as *const InvalidMultibyteChar).as_ref()
        }
    }
}

/// External AmbiguousTernaryOperator
#[repr(C)]
pub struct AmbiguousTernaryOperator {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_ambiguous_ternary_operator(blob: *const Blob<DiagnosticMessage>) -> *const Blob<AmbiguousTernaryOperator>;
    fn lib_ruby_parser__external__diagnotic_messages__ambiguous_ternary_operator__get_condition(blob: *const Blob<AmbiguousTernaryOperator>) -> *const Blob<StringPtr>;
}

impl AmbiguousTernaryOperator {
    /// Returns `condition` field
    pub fn get_condition(&self) -> &StringPtr {
        unsafe {
            #[allow(trivial_casts)]
            (lib_ruby_parser__external__diagnotic_messages__ambiguous_ternary_operator__get_condition(&self.blob) as *const StringPtr).as_ref().unwrap()
        }
    }
}

impl std::fmt::Debug for AmbiguousTernaryOperator {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("AmbiguousTernaryOperator")
            .field("condition", self.get_condition())
            .finish()
    }
}

impl PartialEq for AmbiguousTernaryOperator {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        if self.get_condition() != other.get_condition() {
            return false
        }
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&AmbiguousTernaryOperator>`, return `None` if variant doesn't match
    pub fn as_ambiguous_ternary_operator(&self) -> Option<&AmbiguousTernaryOperator> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_ambiguous_ternary_operator(&self.blob) as *const AmbiguousTernaryOperator).as_ref()
        }
    }
}

/// External AmbiguousRegexp
#[repr(C)]
pub struct AmbiguousRegexp {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_ambiguous_regexp(blob: *const Blob<DiagnosticMessage>) -> *const Blob<AmbiguousRegexp>;
}

impl AmbiguousRegexp {
}

impl std::fmt::Debug for AmbiguousRegexp {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("AmbiguousRegexp")
            .finish()
    }
}

impl PartialEq for AmbiguousRegexp {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&AmbiguousRegexp>`, return `None` if variant doesn't match
    pub fn as_ambiguous_regexp(&self) -> Option<&AmbiguousRegexp> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_ambiguous_regexp(&self.blob) as *const AmbiguousRegexp).as_ref()
        }
    }
}

/// External ElseWithoutRescue
#[repr(C)]
pub struct ElseWithoutRescue {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_else_without_rescue(blob: *const Blob<DiagnosticMessage>) -> *const Blob<ElseWithoutRescue>;
}

impl ElseWithoutRescue {
}

impl std::fmt::Debug for ElseWithoutRescue {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("ElseWithoutRescue")
            .finish()
    }
}

impl PartialEq for ElseWithoutRescue {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&ElseWithoutRescue>`, return `None` if variant doesn't match
    pub fn as_else_without_rescue(&self) -> Option<&ElseWithoutRescue> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_else_without_rescue(&self.blob) as *const ElseWithoutRescue).as_ref()
        }
    }
}

/// External BeginNotAtTopLevel
#[repr(C)]
pub struct BeginNotAtTopLevel {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_begin_not_at_top_level(blob: *const Blob<DiagnosticMessage>) -> *const Blob<BeginNotAtTopLevel>;
}

impl BeginNotAtTopLevel {
}

impl std::fmt::Debug for BeginNotAtTopLevel {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("BeginNotAtTopLevel")
            .finish()
    }
}

impl PartialEq for BeginNotAtTopLevel {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&BeginNotAtTopLevel>`, return `None` if variant doesn't match
    pub fn as_begin_not_at_top_level(&self) -> Option<&BeginNotAtTopLevel> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_begin_not_at_top_level(&self.blob) as *const BeginNotAtTopLevel).as_ref()
        }
    }
}

/// External AliasNthRef
#[repr(C)]
pub struct AliasNthRef {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_alias_nth_ref(blob: *const Blob<DiagnosticMessage>) -> *const Blob<AliasNthRef>;
}

impl AliasNthRef {
}

impl std::fmt::Debug for AliasNthRef {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("AliasNthRef")
            .finish()
    }
}

impl PartialEq for AliasNthRef {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&AliasNthRef>`, return `None` if variant doesn't match
    pub fn as_alias_nth_ref(&self) -> Option<&AliasNthRef> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_alias_nth_ref(&self.blob) as *const AliasNthRef).as_ref()
        }
    }
}

/// External CsendInsideMasgn
#[repr(C)]
pub struct CsendInsideMasgn {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_csend_inside_masgn(blob: *const Blob<DiagnosticMessage>) -> *const Blob<CsendInsideMasgn>;
}

impl CsendInsideMasgn {
}

impl std::fmt::Debug for CsendInsideMasgn {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("CsendInsideMasgn")
            .finish()
    }
}

impl PartialEq for CsendInsideMasgn {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&CsendInsideMasgn>`, return `None` if variant doesn't match
    pub fn as_csend_inside_masgn(&self) -> Option<&CsendInsideMasgn> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_csend_inside_masgn(&self.blob) as *const CsendInsideMasgn).as_ref()
        }
    }
}

/// External ClassOrModuleNameMustBeConstant
#[repr(C)]
pub struct ClassOrModuleNameMustBeConstant {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_class_or_module_name_must_be_constant(blob: *const Blob<DiagnosticMessage>) -> *const Blob<ClassOrModuleNameMustBeConstant>;
}

impl ClassOrModuleNameMustBeConstant {
}

impl std::fmt::Debug for ClassOrModuleNameMustBeConstant {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("ClassOrModuleNameMustBeConstant")
            .finish()
    }
}

impl PartialEq for ClassOrModuleNameMustBeConstant {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// 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> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_class_or_module_name_must_be_constant(&self.blob) as *const ClassOrModuleNameMustBeConstant).as_ref()
        }
    }
}

/// External EndlessSetterDefinition
#[repr(C)]
pub struct EndlessSetterDefinition {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_endless_setter_definition(blob: *const Blob<DiagnosticMessage>) -> *const Blob<EndlessSetterDefinition>;
}

impl EndlessSetterDefinition {
}

impl std::fmt::Debug for EndlessSetterDefinition {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("EndlessSetterDefinition")
            .finish()
    }
}

impl PartialEq for EndlessSetterDefinition {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&EndlessSetterDefinition>`, return `None` if variant doesn't match
    pub fn as_endless_setter_definition(&self) -> Option<&EndlessSetterDefinition> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_endless_setter_definition(&self.blob) as *const EndlessSetterDefinition).as_ref()
        }
    }
}

/// External UnexpectedToken
#[repr(C)]
pub struct UnexpectedToken {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_unexpected_token(blob: *const Blob<DiagnosticMessage>) -> *const Blob<UnexpectedToken>;
    fn lib_ruby_parser__external__diagnotic_messages__unexpected_token__get_token_name(blob: *const Blob<UnexpectedToken>) -> *const Blob<StringPtr>;
}

impl UnexpectedToken {
    /// Returns `token_name` field
    pub fn get_token_name(&self) -> &StringPtr {
        unsafe {
            #[allow(trivial_casts)]
            (lib_ruby_parser__external__diagnotic_messages__unexpected_token__get_token_name(&self.blob) as *const StringPtr).as_ref().unwrap()
        }
    }
}

impl std::fmt::Debug for UnexpectedToken {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("UnexpectedToken")
            .field("token_name", self.get_token_name())
            .finish()
    }
}

impl PartialEq for UnexpectedToken {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        if self.get_token_name() != other.get_token_name() {
            return false
        }
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&UnexpectedToken>`, return `None` if variant doesn't match
    pub fn as_unexpected_token(&self) -> Option<&UnexpectedToken> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_unexpected_token(&self.blob) as *const UnexpectedToken).as_ref()
        }
    }
}

/// External ClassDefinitionInMethodBody
#[repr(C)]
pub struct ClassDefinitionInMethodBody {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_class_definition_in_method_body(blob: *const Blob<DiagnosticMessage>) -> *const Blob<ClassDefinitionInMethodBody>;
}

impl ClassDefinitionInMethodBody {
}

impl std::fmt::Debug for ClassDefinitionInMethodBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("ClassDefinitionInMethodBody")
            .finish()
    }
}

impl PartialEq for ClassDefinitionInMethodBody {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&ClassDefinitionInMethodBody>`, return `None` if variant doesn't match
    pub fn as_class_definition_in_method_body(&self) -> Option<&ClassDefinitionInMethodBody> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_class_definition_in_method_body(&self.blob) as *const ClassDefinitionInMethodBody).as_ref()
        }
    }
}

/// External ModuleDefinitionInMethodBody
#[repr(C)]
pub struct ModuleDefinitionInMethodBody {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_module_definition_in_method_body(blob: *const Blob<DiagnosticMessage>) -> *const Blob<ModuleDefinitionInMethodBody>;
}

impl ModuleDefinitionInMethodBody {
}

impl std::fmt::Debug for ModuleDefinitionInMethodBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("ModuleDefinitionInMethodBody")
            .finish()
    }
}

impl PartialEq for ModuleDefinitionInMethodBody {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&ModuleDefinitionInMethodBody>`, return `None` if variant doesn't match
    pub fn as_module_definition_in_method_body(&self) -> Option<&ModuleDefinitionInMethodBody> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_module_definition_in_method_body(&self.blob) as *const ModuleDefinitionInMethodBody).as_ref()
        }
    }
}

/// External InvalidReturnInClassOrModuleBody
#[repr(C)]
pub struct InvalidReturnInClassOrModuleBody {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_invalid_return_in_class_or_module_body(blob: *const Blob<DiagnosticMessage>) -> *const Blob<InvalidReturnInClassOrModuleBody>;
}

impl InvalidReturnInClassOrModuleBody {
}

impl std::fmt::Debug for InvalidReturnInClassOrModuleBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("InvalidReturnInClassOrModuleBody")
            .finish()
    }
}

impl PartialEq for InvalidReturnInClassOrModuleBody {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// 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> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_invalid_return_in_class_or_module_body(&self.blob) as *const InvalidReturnInClassOrModuleBody).as_ref()
        }
    }
}

/// External ConstArgument
#[repr(C)]
pub struct ConstArgument {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_const_argument(blob: *const Blob<DiagnosticMessage>) -> *const Blob<ConstArgument>;
}

impl ConstArgument {
}

impl std::fmt::Debug for ConstArgument {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("ConstArgument")
            .finish()
    }
}

impl PartialEq for ConstArgument {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&ConstArgument>`, return `None` if variant doesn't match
    pub fn as_const_argument(&self) -> Option<&ConstArgument> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_const_argument(&self.blob) as *const ConstArgument).as_ref()
        }
    }
}

/// External IvarArgument
#[repr(C)]
pub struct IvarArgument {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_ivar_argument(blob: *const Blob<DiagnosticMessage>) -> *const Blob<IvarArgument>;
}

impl IvarArgument {
}

impl std::fmt::Debug for IvarArgument {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("IvarArgument")
            .finish()
    }
}

impl PartialEq for IvarArgument {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&IvarArgument>`, return `None` if variant doesn't match
    pub fn as_ivar_argument(&self) -> Option<&IvarArgument> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_ivar_argument(&self.blob) as *const IvarArgument).as_ref()
        }
    }
}

/// External GvarArgument
#[repr(C)]
pub struct GvarArgument {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_gvar_argument(blob: *const Blob<DiagnosticMessage>) -> *const Blob<GvarArgument>;
}

impl GvarArgument {
}

impl std::fmt::Debug for GvarArgument {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("GvarArgument")
            .finish()
    }
}

impl PartialEq for GvarArgument {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&GvarArgument>`, return `None` if variant doesn't match
    pub fn as_gvar_argument(&self) -> Option<&GvarArgument> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_gvar_argument(&self.blob) as *const GvarArgument).as_ref()
        }
    }
}

/// External CvarArgument
#[repr(C)]
pub struct CvarArgument {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_cvar_argument(blob: *const Blob<DiagnosticMessage>) -> *const Blob<CvarArgument>;
}

impl CvarArgument {
}

impl std::fmt::Debug for CvarArgument {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("CvarArgument")
            .finish()
    }
}

impl PartialEq for CvarArgument {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&CvarArgument>`, return `None` if variant doesn't match
    pub fn as_cvar_argument(&self) -> Option<&CvarArgument> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_cvar_argument(&self.blob) as *const CvarArgument).as_ref()
        }
    }
}

/// External NoSuchLocalVariable
#[repr(C)]
pub struct NoSuchLocalVariable {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_no_such_local_variable(blob: *const Blob<DiagnosticMessage>) -> *const Blob<NoSuchLocalVariable>;
    fn lib_ruby_parser__external__diagnotic_messages__no_such_local_variable__get_var_name(blob: *const Blob<NoSuchLocalVariable>) -> *const Blob<StringPtr>;
}

impl NoSuchLocalVariable {
    /// Returns `var_name` field
    pub fn get_var_name(&self) -> &StringPtr {
        unsafe {
            #[allow(trivial_casts)]
            (lib_ruby_parser__external__diagnotic_messages__no_such_local_variable__get_var_name(&self.blob) as *const StringPtr).as_ref().unwrap()
        }
    }
}

impl std::fmt::Debug for NoSuchLocalVariable {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("NoSuchLocalVariable")
            .field("var_name", self.get_var_name())
            .finish()
    }
}

impl PartialEq for NoSuchLocalVariable {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        if self.get_var_name() != other.get_var_name() {
            return false
        }
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&NoSuchLocalVariable>`, return `None` if variant doesn't match
    pub fn as_no_such_local_variable(&self) -> Option<&NoSuchLocalVariable> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_no_such_local_variable(&self.blob) as *const NoSuchLocalVariable).as_ref()
        }
    }
}

/// External OrdinaryParamDefined
#[repr(C)]
pub struct OrdinaryParamDefined {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_ordinary_param_defined(blob: *const Blob<DiagnosticMessage>) -> *const Blob<OrdinaryParamDefined>;
}

impl OrdinaryParamDefined {
}

impl std::fmt::Debug for OrdinaryParamDefined {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("OrdinaryParamDefined")
            .finish()
    }
}

impl PartialEq for OrdinaryParamDefined {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&OrdinaryParamDefined>`, return `None` if variant doesn't match
    pub fn as_ordinary_param_defined(&self) -> Option<&OrdinaryParamDefined> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_ordinary_param_defined(&self.blob) as *const OrdinaryParamDefined).as_ref()
        }
    }
}

/// External NumparamUsed
#[repr(C)]
pub struct NumparamUsed {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_numparam_used(blob: *const Blob<DiagnosticMessage>) -> *const Blob<NumparamUsed>;
}

impl NumparamUsed {
}

impl std::fmt::Debug for NumparamUsed {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("NumparamUsed")
            .finish()
    }
}

impl PartialEq for NumparamUsed {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&NumparamUsed>`, return `None` if variant doesn't match
    pub fn as_numparam_used(&self) -> Option<&NumparamUsed> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_numparam_used(&self.blob) as *const NumparamUsed).as_ref()
        }
    }
}

/// External TokAtEolWithoutExpression
#[repr(C)]
pub struct TokAtEolWithoutExpression {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_tok_at_eol_without_expression(blob: *const Blob<DiagnosticMessage>) -> *const Blob<TokAtEolWithoutExpression>;
    fn lib_ruby_parser__external__diagnotic_messages__tok_at_eol_without_expression__get_token_name(blob: *const Blob<TokAtEolWithoutExpression>) -> *const Blob<StringPtr>;
}

impl TokAtEolWithoutExpression {
    /// Returns `token_name` field
    pub fn get_token_name(&self) -> &StringPtr {
        unsafe {
            #[allow(trivial_casts)]
            (lib_ruby_parser__external__diagnotic_messages__tok_at_eol_without_expression__get_token_name(&self.blob) as *const StringPtr).as_ref().unwrap()
        }
    }
}

impl std::fmt::Debug for TokAtEolWithoutExpression {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("TokAtEolWithoutExpression")
            .field("token_name", self.get_token_name())
            .finish()
    }
}

impl PartialEq for TokAtEolWithoutExpression {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        if self.get_token_name() != other.get_token_name() {
            return false
        }
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&TokAtEolWithoutExpression>`, return `None` if variant doesn't match
    pub fn as_tok_at_eol_without_expression(&self) -> Option<&TokAtEolWithoutExpression> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_tok_at_eol_without_expression(&self.blob) as *const TokAtEolWithoutExpression).as_ref()
        }
    }
}

/// External EndInMethod
#[repr(C)]
pub struct EndInMethod {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_end_in_method(blob: *const Blob<DiagnosticMessage>) -> *const Blob<EndInMethod>;
}

impl EndInMethod {
}

impl std::fmt::Debug for EndInMethod {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("EndInMethod")
            .finish()
    }
}

impl PartialEq for EndInMethod {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&EndInMethod>`, return `None` if variant doesn't match
    pub fn as_end_in_method(&self) -> Option<&EndInMethod> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_end_in_method(&self.blob) as *const EndInMethod).as_ref()
        }
    }
}

/// External ComparisonAfterComparison
#[repr(C)]
pub struct ComparisonAfterComparison {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_comparison_after_comparison(blob: *const Blob<DiagnosticMessage>) -> *const Blob<ComparisonAfterComparison>;
    fn lib_ruby_parser__external__diagnotic_messages__comparison_after_comparison__get_comparison(blob: *const Blob<ComparisonAfterComparison>) -> *const Blob<StringPtr>;
}

impl ComparisonAfterComparison {
    /// Returns `comparison` field
    pub fn get_comparison(&self) -> &StringPtr {
        unsafe {
            #[allow(trivial_casts)]
            (lib_ruby_parser__external__diagnotic_messages__comparison_after_comparison__get_comparison(&self.blob) as *const StringPtr).as_ref().unwrap()
        }
    }
}

impl std::fmt::Debug for ComparisonAfterComparison {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("ComparisonAfterComparison")
            .field("comparison", self.get_comparison())
            .finish()
    }
}

impl PartialEq for ComparisonAfterComparison {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        if self.get_comparison() != other.get_comparison() {
            return false
        }
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&ComparisonAfterComparison>`, return `None` if variant doesn't match
    pub fn as_comparison_after_comparison(&self) -> Option<&ComparisonAfterComparison> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_comparison_after_comparison(&self.blob) as *const ComparisonAfterComparison).as_ref()
        }
    }
}

/// External CircularArgumentReference
#[repr(C)]
pub struct CircularArgumentReference {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_circular_argument_reference(blob: *const Blob<DiagnosticMessage>) -> *const Blob<CircularArgumentReference>;
    fn lib_ruby_parser__external__diagnotic_messages__circular_argument_reference__get_arg_name(blob: *const Blob<CircularArgumentReference>) -> *const Blob<StringPtr>;
}

impl CircularArgumentReference {
    /// Returns `arg_name` field
    pub fn get_arg_name(&self) -> &StringPtr {
        unsafe {
            #[allow(trivial_casts)]
            (lib_ruby_parser__external__diagnotic_messages__circular_argument_reference__get_arg_name(&self.blob) as *const StringPtr).as_ref().unwrap()
        }
    }
}

impl std::fmt::Debug for CircularArgumentReference {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("CircularArgumentReference")
            .field("arg_name", self.get_arg_name())
            .finish()
    }
}

impl PartialEq for CircularArgumentReference {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        if self.get_arg_name() != other.get_arg_name() {
            return false
        }
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&CircularArgumentReference>`, return `None` if variant doesn't match
    pub fn as_circular_argument_reference(&self) -> Option<&CircularArgumentReference> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_circular_argument_reference(&self.blob) as *const CircularArgumentReference).as_ref()
        }
    }
}

/// External DynamicConstantAssignment
#[repr(C)]
pub struct DynamicConstantAssignment {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_dynamic_constant_assignment(blob: *const Blob<DiagnosticMessage>) -> *const Blob<DynamicConstantAssignment>;
}

impl DynamicConstantAssignment {
}

impl std::fmt::Debug for DynamicConstantAssignment {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("DynamicConstantAssignment")
            .finish()
    }
}

impl PartialEq for DynamicConstantAssignment {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&DynamicConstantAssignment>`, return `None` if variant doesn't match
    pub fn as_dynamic_constant_assignment(&self) -> Option<&DynamicConstantAssignment> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_dynamic_constant_assignment(&self.blob) as *const DynamicConstantAssignment).as_ref()
        }
    }
}

/// External CantAssignToSelf
#[repr(C)]
pub struct CantAssignToSelf {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_cant_assign_to_self(blob: *const Blob<DiagnosticMessage>) -> *const Blob<CantAssignToSelf>;
}

impl CantAssignToSelf {
}

impl std::fmt::Debug for CantAssignToSelf {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("CantAssignToSelf")
            .finish()
    }
}

impl PartialEq for CantAssignToSelf {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&CantAssignToSelf>`, return `None` if variant doesn't match
    pub fn as_cant_assign_to_self(&self) -> Option<&CantAssignToSelf> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_cant_assign_to_self(&self.blob) as *const CantAssignToSelf).as_ref()
        }
    }
}

/// External CantAssignToNil
#[repr(C)]
pub struct CantAssignToNil {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_cant_assign_to_nil(blob: *const Blob<DiagnosticMessage>) -> *const Blob<CantAssignToNil>;
}

impl CantAssignToNil {
}

impl std::fmt::Debug for CantAssignToNil {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("CantAssignToNil")
            .finish()
    }
}

impl PartialEq for CantAssignToNil {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&CantAssignToNil>`, return `None` if variant doesn't match
    pub fn as_cant_assign_to_nil(&self) -> Option<&CantAssignToNil> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_cant_assign_to_nil(&self.blob) as *const CantAssignToNil).as_ref()
        }
    }
}

/// External CantAssignToTrue
#[repr(C)]
pub struct CantAssignToTrue {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_cant_assign_to_true(blob: *const Blob<DiagnosticMessage>) -> *const Blob<CantAssignToTrue>;
}

impl CantAssignToTrue {
}

impl std::fmt::Debug for CantAssignToTrue {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("CantAssignToTrue")
            .finish()
    }
}

impl PartialEq for CantAssignToTrue {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&CantAssignToTrue>`, return `None` if variant doesn't match
    pub fn as_cant_assign_to_true(&self) -> Option<&CantAssignToTrue> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_cant_assign_to_true(&self.blob) as *const CantAssignToTrue).as_ref()
        }
    }
}

/// External CantAssignToFalse
#[repr(C)]
pub struct CantAssignToFalse {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_cant_assign_to_false(blob: *const Blob<DiagnosticMessage>) -> *const Blob<CantAssignToFalse>;
}

impl CantAssignToFalse {
}

impl std::fmt::Debug for CantAssignToFalse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("CantAssignToFalse")
            .finish()
    }
}

impl PartialEq for CantAssignToFalse {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&CantAssignToFalse>`, return `None` if variant doesn't match
    pub fn as_cant_assign_to_false(&self) -> Option<&CantAssignToFalse> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_cant_assign_to_false(&self.blob) as *const CantAssignToFalse).as_ref()
        }
    }
}

/// External CantAssignToFile
#[repr(C)]
pub struct CantAssignToFile {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_cant_assign_to_file(blob: *const Blob<DiagnosticMessage>) -> *const Blob<CantAssignToFile>;
}

impl CantAssignToFile {
}

impl std::fmt::Debug for CantAssignToFile {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("CantAssignToFile")
            .finish()
    }
}

impl PartialEq for CantAssignToFile {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&CantAssignToFile>`, return `None` if variant doesn't match
    pub fn as_cant_assign_to_file(&self) -> Option<&CantAssignToFile> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_cant_assign_to_file(&self.blob) as *const CantAssignToFile).as_ref()
        }
    }
}

/// External CantAssignToLine
#[repr(C)]
pub struct CantAssignToLine {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_cant_assign_to_line(blob: *const Blob<DiagnosticMessage>) -> *const Blob<CantAssignToLine>;
}

impl CantAssignToLine {
}

impl std::fmt::Debug for CantAssignToLine {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("CantAssignToLine")
            .finish()
    }
}

impl PartialEq for CantAssignToLine {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&CantAssignToLine>`, return `None` if variant doesn't match
    pub fn as_cant_assign_to_line(&self) -> Option<&CantAssignToLine> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_cant_assign_to_line(&self.blob) as *const CantAssignToLine).as_ref()
        }
    }
}

/// External CantAssignToEncoding
#[repr(C)]
pub struct CantAssignToEncoding {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_cant_assign_to_encoding(blob: *const Blob<DiagnosticMessage>) -> *const Blob<CantAssignToEncoding>;
}

impl CantAssignToEncoding {
}

impl std::fmt::Debug for CantAssignToEncoding {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("CantAssignToEncoding")
            .finish()
    }
}

impl PartialEq for CantAssignToEncoding {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&CantAssignToEncoding>`, return `None` if variant doesn't match
    pub fn as_cant_assign_to_encoding(&self) -> Option<&CantAssignToEncoding> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_cant_assign_to_encoding(&self.blob) as *const CantAssignToEncoding).as_ref()
        }
    }
}

/// External CantAssignToNumparam
#[repr(C)]
pub struct CantAssignToNumparam {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_cant_assign_to_numparam(blob: *const Blob<DiagnosticMessage>) -> *const Blob<CantAssignToNumparam>;
    fn lib_ruby_parser__external__diagnotic_messages__cant_assign_to_numparam__get_numparam(blob: *const Blob<CantAssignToNumparam>) -> *const Blob<StringPtr>;
}

impl CantAssignToNumparam {
    /// Returns `numparam` field
    pub fn get_numparam(&self) -> &StringPtr {
        unsafe {
            #[allow(trivial_casts)]
            (lib_ruby_parser__external__diagnotic_messages__cant_assign_to_numparam__get_numparam(&self.blob) as *const StringPtr).as_ref().unwrap()
        }
    }
}

impl std::fmt::Debug for CantAssignToNumparam {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("CantAssignToNumparam")
            .field("numparam", self.get_numparam())
            .finish()
    }
}

impl PartialEq for CantAssignToNumparam {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        if self.get_numparam() != other.get_numparam() {
            return false
        }
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&CantAssignToNumparam>`, return `None` if variant doesn't match
    pub fn as_cant_assign_to_numparam(&self) -> Option<&CantAssignToNumparam> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_cant_assign_to_numparam(&self.blob) as *const CantAssignToNumparam).as_ref()
        }
    }
}

/// External CantSetVariable
#[repr(C)]
pub struct CantSetVariable {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_cant_set_variable(blob: *const Blob<DiagnosticMessage>) -> *const Blob<CantSetVariable>;
    fn lib_ruby_parser__external__diagnotic_messages__cant_set_variable__get_var_name(blob: *const Blob<CantSetVariable>) -> *const Blob<StringPtr>;
}

impl CantSetVariable {
    /// Returns `var_name` field
    pub fn get_var_name(&self) -> &StringPtr {
        unsafe {
            #[allow(trivial_casts)]
            (lib_ruby_parser__external__diagnotic_messages__cant_set_variable__get_var_name(&self.blob) as *const StringPtr).as_ref().unwrap()
        }
    }
}

impl std::fmt::Debug for CantSetVariable {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("CantSetVariable")
            .field("var_name", self.get_var_name())
            .finish()
    }
}

impl PartialEq for CantSetVariable {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        if self.get_var_name() != other.get_var_name() {
            return false
        }
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&CantSetVariable>`, return `None` if variant doesn't match
    pub fn as_cant_set_variable(&self) -> Option<&CantSetVariable> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_cant_set_variable(&self.blob) as *const CantSetVariable).as_ref()
        }
    }
}

/// External BlockGivenToYield
#[repr(C)]
pub struct BlockGivenToYield {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_block_given_to_yield(blob: *const Blob<DiagnosticMessage>) -> *const Blob<BlockGivenToYield>;
}

impl BlockGivenToYield {
}

impl std::fmt::Debug for BlockGivenToYield {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("BlockGivenToYield")
            .finish()
    }
}

impl PartialEq for BlockGivenToYield {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&BlockGivenToYield>`, return `None` if variant doesn't match
    pub fn as_block_given_to_yield(&self) -> Option<&BlockGivenToYield> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_block_given_to_yield(&self.blob) as *const BlockGivenToYield).as_ref()
        }
    }
}

/// External BlockAndBlockArgGiven
#[repr(C)]
pub struct BlockAndBlockArgGiven {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_block_and_block_arg_given(blob: *const Blob<DiagnosticMessage>) -> *const Blob<BlockAndBlockArgGiven>;
}

impl BlockAndBlockArgGiven {
}

impl std::fmt::Debug for BlockAndBlockArgGiven {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("BlockAndBlockArgGiven")
            .finish()
    }
}

impl PartialEq for BlockAndBlockArgGiven {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&BlockAndBlockArgGiven>`, return `None` if variant doesn't match
    pub fn as_block_and_block_arg_given(&self) -> Option<&BlockAndBlockArgGiven> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_block_and_block_arg_given(&self.blob) as *const BlockAndBlockArgGiven).as_ref()
        }
    }
}

/// External SymbolLiteralWithInterpolation
#[repr(C)]
pub struct SymbolLiteralWithInterpolation {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_symbol_literal_with_interpolation(blob: *const Blob<DiagnosticMessage>) -> *const Blob<SymbolLiteralWithInterpolation>;
}

impl SymbolLiteralWithInterpolation {
}

impl std::fmt::Debug for SymbolLiteralWithInterpolation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("SymbolLiteralWithInterpolation")
            .finish()
    }
}

impl PartialEq for SymbolLiteralWithInterpolation {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&SymbolLiteralWithInterpolation>`, return `None` if variant doesn't match
    pub fn as_symbol_literal_with_interpolation(&self) -> Option<&SymbolLiteralWithInterpolation> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_symbol_literal_with_interpolation(&self.blob) as *const SymbolLiteralWithInterpolation).as_ref()
        }
    }
}

/// External ReservedForNumparam
#[repr(C)]
pub struct ReservedForNumparam {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_reserved_for_numparam(blob: *const Blob<DiagnosticMessage>) -> *const Blob<ReservedForNumparam>;
    fn lib_ruby_parser__external__diagnotic_messages__reserved_for_numparam__get_numparam(blob: *const Blob<ReservedForNumparam>) -> *const Blob<StringPtr>;
}

impl ReservedForNumparam {
    /// Returns `numparam` field
    pub fn get_numparam(&self) -> &StringPtr {
        unsafe {
            #[allow(trivial_casts)]
            (lib_ruby_parser__external__diagnotic_messages__reserved_for_numparam__get_numparam(&self.blob) as *const StringPtr).as_ref().unwrap()
        }
    }
}

impl std::fmt::Debug for ReservedForNumparam {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("ReservedForNumparam")
            .field("numparam", self.get_numparam())
            .finish()
    }
}

impl PartialEq for ReservedForNumparam {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        if self.get_numparam() != other.get_numparam() {
            return false
        }
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&ReservedForNumparam>`, return `None` if variant doesn't match
    pub fn as_reserved_for_numparam(&self) -> Option<&ReservedForNumparam> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_reserved_for_numparam(&self.blob) as *const ReservedForNumparam).as_ref()
        }
    }
}

/// External KeyMustBeValidAsLocalVariable
#[repr(C)]
pub struct KeyMustBeValidAsLocalVariable {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_key_must_be_valid_as_local_variable(blob: *const Blob<DiagnosticMessage>) -> *const Blob<KeyMustBeValidAsLocalVariable>;
}

impl KeyMustBeValidAsLocalVariable {
}

impl std::fmt::Debug for KeyMustBeValidAsLocalVariable {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("KeyMustBeValidAsLocalVariable")
            .finish()
    }
}

impl PartialEq for KeyMustBeValidAsLocalVariable {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// 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> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_key_must_be_valid_as_local_variable(&self.blob) as *const KeyMustBeValidAsLocalVariable).as_ref()
        }
    }
}

/// External DuplicateVariableName
#[repr(C)]
pub struct DuplicateVariableName {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_duplicate_variable_name(blob: *const Blob<DiagnosticMessage>) -> *const Blob<DuplicateVariableName>;
}

impl DuplicateVariableName {
}

impl std::fmt::Debug for DuplicateVariableName {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("DuplicateVariableName")
            .finish()
    }
}

impl PartialEq for DuplicateVariableName {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&DuplicateVariableName>`, return `None` if variant doesn't match
    pub fn as_duplicate_variable_name(&self) -> Option<&DuplicateVariableName> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_duplicate_variable_name(&self.blob) as *const DuplicateVariableName).as_ref()
        }
    }
}

/// External DuplicateKeyName
#[repr(C)]
pub struct DuplicateKeyName {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_duplicate_key_name(blob: *const Blob<DiagnosticMessage>) -> *const Blob<DuplicateKeyName>;
}

impl DuplicateKeyName {
}

impl std::fmt::Debug for DuplicateKeyName {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("DuplicateKeyName")
            .finish()
    }
}

impl PartialEq for DuplicateKeyName {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&DuplicateKeyName>`, return `None` if variant doesn't match
    pub fn as_duplicate_key_name(&self) -> Option<&DuplicateKeyName> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_duplicate_key_name(&self.blob) as *const DuplicateKeyName).as_ref()
        }
    }
}

/// External SingletonLiteral
#[repr(C)]
pub struct SingletonLiteral {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_singleton_literal(blob: *const Blob<DiagnosticMessage>) -> *const Blob<SingletonLiteral>;
}

impl SingletonLiteral {
}

impl std::fmt::Debug for SingletonLiteral {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("SingletonLiteral")
            .finish()
    }
}

impl PartialEq for SingletonLiteral {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&SingletonLiteral>`, return `None` if variant doesn't match
    pub fn as_singleton_literal(&self) -> Option<&SingletonLiteral> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_singleton_literal(&self.blob) as *const SingletonLiteral).as_ref()
        }
    }
}

/// External NthRefIsTooBig
#[repr(C)]
pub struct NthRefIsTooBig {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_nth_ref_is_too_big(blob: *const Blob<DiagnosticMessage>) -> *const Blob<NthRefIsTooBig>;
    fn lib_ruby_parser__external__diagnotic_messages__nth_ref_is_too_big__get_nth_ref(blob: *const Blob<NthRefIsTooBig>) -> *const Blob<StringPtr>;
}

impl NthRefIsTooBig {
    /// Returns `nth_ref` field
    pub fn get_nth_ref(&self) -> &StringPtr {
        unsafe {
            #[allow(trivial_casts)]
            (lib_ruby_parser__external__diagnotic_messages__nth_ref_is_too_big__get_nth_ref(&self.blob) as *const StringPtr).as_ref().unwrap()
        }
    }
}

impl std::fmt::Debug for NthRefIsTooBig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("NthRefIsTooBig")
            .field("nth_ref", self.get_nth_ref())
            .finish()
    }
}

impl PartialEq for NthRefIsTooBig {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        if self.get_nth_ref() != other.get_nth_ref() {
            return false
        }
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&NthRefIsTooBig>`, return `None` if variant doesn't match
    pub fn as_nth_ref_is_too_big(&self) -> Option<&NthRefIsTooBig> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_nth_ref_is_too_big(&self.blob) as *const NthRefIsTooBig).as_ref()
        }
    }
}

/// External DuplicatedArgumentName
#[repr(C)]
pub struct DuplicatedArgumentName {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_duplicated_argument_name(blob: *const Blob<DiagnosticMessage>) -> *const Blob<DuplicatedArgumentName>;
}

impl DuplicatedArgumentName {
}

impl std::fmt::Debug for DuplicatedArgumentName {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("DuplicatedArgumentName")
            .finish()
    }
}

impl PartialEq for DuplicatedArgumentName {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&DuplicatedArgumentName>`, return `None` if variant doesn't match
    pub fn as_duplicated_argument_name(&self) -> Option<&DuplicatedArgumentName> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_duplicated_argument_name(&self.blob) as *const DuplicatedArgumentName).as_ref()
        }
    }
}

/// External RegexError
#[repr(C)]
pub struct RegexError {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_regex_error(blob: *const Blob<DiagnosticMessage>) -> *const Blob<RegexError>;
    fn lib_ruby_parser__external__diagnotic_messages__regex_error__get_error(blob: *const Blob<RegexError>) -> *const Blob<StringPtr>;
}

impl RegexError {
    /// Returns `error` field
    pub fn get_error(&self) -> &StringPtr {
        unsafe {
            #[allow(trivial_casts)]
            (lib_ruby_parser__external__diagnotic_messages__regex_error__get_error(&self.blob) as *const StringPtr).as_ref().unwrap()
        }
    }
}

impl std::fmt::Debug for RegexError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("RegexError")
            .field("error", self.get_error())
            .finish()
    }
}

impl PartialEq for RegexError {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        if self.get_error() != other.get_error() {
            return false
        }
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&RegexError>`, return `None` if variant doesn't match
    pub fn as_regex_error(&self) -> Option<&RegexError> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_regex_error(&self.blob) as *const RegexError).as_ref()
        }
    }
}

/// External InvalidSymbol
#[repr(C)]
pub struct InvalidSymbol {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_invalid_symbol(blob: *const Blob<DiagnosticMessage>) -> *const Blob<InvalidSymbol>;
    fn lib_ruby_parser__external__diagnotic_messages__invalid_symbol__get_symbol(blob: *const Blob<InvalidSymbol>) -> *const Blob<StringPtr>;
}

impl InvalidSymbol {
    /// Returns `symbol` field
    pub fn get_symbol(&self) -> &StringPtr {
        unsafe {
            #[allow(trivial_casts)]
            (lib_ruby_parser__external__diagnotic_messages__invalid_symbol__get_symbol(&self.blob) as *const StringPtr).as_ref().unwrap()
        }
    }
}

impl std::fmt::Debug for InvalidSymbol {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("InvalidSymbol")
            .field("symbol", self.get_symbol())
            .finish()
    }
}

impl PartialEq for InvalidSymbol {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        if self.get_symbol() != other.get_symbol() {
            return false
        }
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&InvalidSymbol>`, return `None` if variant doesn't match
    pub fn as_invalid_symbol(&self) -> Option<&InvalidSymbol> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_invalid_symbol(&self.blob) as *const InvalidSymbol).as_ref()
        }
    }
}

/// External VoidValueExpression
#[repr(C)]
pub struct VoidValueExpression {
    pub(crate) blob: Blob<Self>,
}

extern "C" {
    fn lib_ruby_parser__external__diagnotic_messages__as_void_value_expression(blob: *const Blob<DiagnosticMessage>) -> *const Blob<VoidValueExpression>;
}

impl VoidValueExpression {
}

impl std::fmt::Debug for VoidValueExpression {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("VoidValueExpression")
            .finish()
    }
}

impl PartialEq for VoidValueExpression {
    #[allow(unused_variables)]
    fn eq(&self, other: &Self) -> bool {
        true
    }
}

impl DiagnosticMessage {
    /// Casts `self` to `Option<&VoidValueExpression>`, return `None` if variant doesn't match
    pub fn as_void_value_expression(&self) -> Option<&VoidValueExpression> {
        unsafe {
            (lib_ruby_parser__external__diagnotic_messages__as_void_value_expression(&self.blob) as *const VoidValueExpression).as_ref()
        }
    }
}