messages.hpp

Go to the documentation of this file.

#ifndef LIB_RUBY_PARSER_MESSAGES_HPP
#define LIB_RUBY_PARSER_MESSAGES_HPP
 
// This file is autogenerated by codegen/messages.hpp.liquid
 
#include <cstdint>
#include "string.hpp"
 
namespace lib_ruby_parser
{
    class FractionAfterNumeric
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        FractionAfterNumeric();
        FractionAfterNumeric(const FractionAfterNumeric &) = delete;
        FractionAfterNumeric &operator=(FractionAfterNumeric const &) = delete;
 
        FractionAfterNumeric(FractionAfterNumeric &&) = default;
        FractionAfterNumeric &operator=(FractionAfterNumeric &&) = default;
    };
 
    class NoDigitsAfterDot
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        NoDigitsAfterDot();
        NoDigitsAfterDot(const NoDigitsAfterDot &) = delete;
        NoDigitsAfterDot &operator=(NoDigitsAfterDot const &) = delete;
 
        NoDigitsAfterDot(NoDigitsAfterDot &&) = default;
        NoDigitsAfterDot &operator=(NoDigitsAfterDot &&) = default;
    };
 
    class UnknownTypeOfPercentString
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        UnknownTypeOfPercentString();
        UnknownTypeOfPercentString(const UnknownTypeOfPercentString &) = delete;
        UnknownTypeOfPercentString &operator=(UnknownTypeOfPercentString const &) = delete;
 
        UnknownTypeOfPercentString(UnknownTypeOfPercentString &&) = default;
        UnknownTypeOfPercentString &operator=(UnknownTypeOfPercentString &&) = default;
    };
 
    class NumericLiteralWithoutDigits
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        NumericLiteralWithoutDigits();
        NumericLiteralWithoutDigits(const NumericLiteralWithoutDigits &) = delete;
        NumericLiteralWithoutDigits &operator=(NumericLiteralWithoutDigits const &) = delete;
 
        NumericLiteralWithoutDigits(NumericLiteralWithoutDigits &&) = default;
        NumericLiteralWithoutDigits &operator=(NumericLiteralWithoutDigits &&) = default;
    };
 
    class UnterminatedList
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        UnterminatedList();
        UnterminatedList(const UnterminatedList &) = delete;
        UnterminatedList &operator=(UnterminatedList const &) = delete;
 
        UnterminatedList(UnterminatedList &&) = default;
        UnterminatedList &operator=(UnterminatedList &&) = default;
    };
 
    class UnterminatedRegexp
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        UnterminatedRegexp();
        UnterminatedRegexp(const UnterminatedRegexp &) = delete;
        UnterminatedRegexp &operator=(UnterminatedRegexp const &) = delete;
 
        UnterminatedRegexp(UnterminatedRegexp &&) = default;
        UnterminatedRegexp &operator=(UnterminatedRegexp &&) = default;
    };
 
    class UnterminatedString
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        UnterminatedString();
        UnterminatedString(const UnterminatedString &) = delete;
        UnterminatedString &operator=(UnterminatedString const &) = delete;
 
        UnterminatedString(UnterminatedString &&) = default;
        UnterminatedString &operator=(UnterminatedString &&) = default;
    };
 
    class UnterminatedQuotedString
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        UnterminatedQuotedString();
        UnterminatedQuotedString(const UnterminatedQuotedString &) = delete;
        UnterminatedQuotedString &operator=(UnterminatedQuotedString const &) = delete;
 
        UnterminatedQuotedString(UnterminatedQuotedString &&) = default;
        UnterminatedQuotedString &operator=(UnterminatedQuotedString &&) = default;
    };
 
    class InvalidUnicodeEscape
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        InvalidUnicodeEscape();
        InvalidUnicodeEscape(const InvalidUnicodeEscape &) = delete;
        InvalidUnicodeEscape &operator=(InvalidUnicodeEscape const &) = delete;
 
        InvalidUnicodeEscape(InvalidUnicodeEscape &&) = default;
        InvalidUnicodeEscape &operator=(InvalidUnicodeEscape &&) = default;
    };
 
    class TooLargeUnicodeCodepoint
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        TooLargeUnicodeCodepoint();
        TooLargeUnicodeCodepoint(const TooLargeUnicodeCodepoint &) = delete;
        TooLargeUnicodeCodepoint &operator=(TooLargeUnicodeCodepoint const &) = delete;
 
        TooLargeUnicodeCodepoint(TooLargeUnicodeCodepoint &&) = default;
        TooLargeUnicodeCodepoint &operator=(TooLargeUnicodeCodepoint &&) = default;
    };
 
    class InvalidUnicodeCodepoint
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        InvalidUnicodeCodepoint();
        InvalidUnicodeCodepoint(const InvalidUnicodeCodepoint &) = delete;
        InvalidUnicodeCodepoint &operator=(InvalidUnicodeCodepoint const &) = delete;
 
        InvalidUnicodeCodepoint(InvalidUnicodeCodepoint &&) = default;
        InvalidUnicodeCodepoint &operator=(InvalidUnicodeCodepoint &&) = default;
    };
 
    class MultipleCodepointAtSingleChar
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        MultipleCodepointAtSingleChar();
        MultipleCodepointAtSingleChar(const MultipleCodepointAtSingleChar &) = delete;
        MultipleCodepointAtSingleChar &operator=(MultipleCodepointAtSingleChar const &) = delete;
 
        MultipleCodepointAtSingleChar(MultipleCodepointAtSingleChar &&) = default;
        MultipleCodepointAtSingleChar &operator=(MultipleCodepointAtSingleChar &&) = default;
    };
 
    class InvalidEscapeCharacter
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        InvalidEscapeCharacter();
        InvalidEscapeCharacter(const InvalidEscapeCharacter &) = delete;
        InvalidEscapeCharacter &operator=(InvalidEscapeCharacter const &) = delete;
 
        InvalidEscapeCharacter(InvalidEscapeCharacter &&) = default;
        InvalidEscapeCharacter &operator=(InvalidEscapeCharacter &&) = default;
    };
 
    class InvalidHexEscape
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        InvalidHexEscape();
        InvalidHexEscape(const InvalidHexEscape &) = delete;
        InvalidHexEscape &operator=(InvalidHexEscape const &) = delete;
 
        InvalidHexEscape(InvalidHexEscape &&) = default;
        InvalidHexEscape &operator=(InvalidHexEscape &&) = default;
    };
 
    class UnterminatedHeredoc
    {
    public:
        String heredoc_id;
 
        UnterminatedHeredoc() = delete;
        UnterminatedHeredoc(
            String heredoc_id);
        UnterminatedHeredoc(const UnterminatedHeredoc &) = delete;
        UnterminatedHeredoc &operator=(UnterminatedHeredoc const &) = delete;
 
        UnterminatedHeredoc(UnterminatedHeredoc &&) = default;
        UnterminatedHeredoc &operator=(UnterminatedHeredoc &&) = default;
    };
 
    class UnterminatedHeredocId
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        UnterminatedHeredocId();
        UnterminatedHeredocId(const UnterminatedHeredocId &) = delete;
        UnterminatedHeredocId &operator=(UnterminatedHeredocId const &) = delete;
 
        UnterminatedHeredocId(UnterminatedHeredocId &&) = default;
        UnterminatedHeredocId &operator=(UnterminatedHeredocId &&) = default;
    };
 
    class SlashRAtMiddleOfLine
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        SlashRAtMiddleOfLine();
        SlashRAtMiddleOfLine(const SlashRAtMiddleOfLine &) = delete;
        SlashRAtMiddleOfLine &operator=(SlashRAtMiddleOfLine const &) = delete;
 
        SlashRAtMiddleOfLine(SlashRAtMiddleOfLine &&) = default;
        SlashRAtMiddleOfLine &operator=(SlashRAtMiddleOfLine &&) = default;
    };
 
    class DStarInterpretedAsArgPrefix
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        DStarInterpretedAsArgPrefix();
        DStarInterpretedAsArgPrefix(const DStarInterpretedAsArgPrefix &) = delete;
        DStarInterpretedAsArgPrefix &operator=(DStarInterpretedAsArgPrefix const &) = delete;
 
        DStarInterpretedAsArgPrefix(DStarInterpretedAsArgPrefix &&) = default;
        DStarInterpretedAsArgPrefix &operator=(DStarInterpretedAsArgPrefix &&) = default;
    };
 
    class StarInterpretedAsArgPrefix
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        StarInterpretedAsArgPrefix();
        StarInterpretedAsArgPrefix(const StarInterpretedAsArgPrefix &) = delete;
        StarInterpretedAsArgPrefix &operator=(StarInterpretedAsArgPrefix const &) = delete;
 
        StarInterpretedAsArgPrefix(StarInterpretedAsArgPrefix &&) = default;
        StarInterpretedAsArgPrefix &operator=(StarInterpretedAsArgPrefix &&) = default;
    };
 
    class AmpersandInterpretedAsArgPrefix
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        AmpersandInterpretedAsArgPrefix();
        AmpersandInterpretedAsArgPrefix(const AmpersandInterpretedAsArgPrefix &) = delete;
        AmpersandInterpretedAsArgPrefix &operator=(AmpersandInterpretedAsArgPrefix const &) = delete;
 
        AmpersandInterpretedAsArgPrefix(AmpersandInterpretedAsArgPrefix &&) = default;
        AmpersandInterpretedAsArgPrefix &operator=(AmpersandInterpretedAsArgPrefix &&) = default;
    };
 
    class TripleDotAtEol
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        TripleDotAtEol();
        TripleDotAtEol(const TripleDotAtEol &) = delete;
        TripleDotAtEol &operator=(TripleDotAtEol const &) = delete;
 
        TripleDotAtEol(TripleDotAtEol &&) = default;
        TripleDotAtEol &operator=(TripleDotAtEol &&) = default;
    };
 
    class ParenthesesIterpretedAsArglist
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        ParenthesesIterpretedAsArglist();
        ParenthesesIterpretedAsArglist(const ParenthesesIterpretedAsArglist &) = delete;
        ParenthesesIterpretedAsArglist &operator=(ParenthesesIterpretedAsArglist const &) = delete;
 
        ParenthesesIterpretedAsArglist(ParenthesesIterpretedAsArglist &&) = default;
        ParenthesesIterpretedAsArglist &operator=(ParenthesesIterpretedAsArglist &&) = default;
    };
 
    class AmbiguousFirstArgument
    {
    public:
        uint8_t operator_;
 
        AmbiguousFirstArgument() = delete;
        AmbiguousFirstArgument(
            uint8_t operator_);
        AmbiguousFirstArgument(const AmbiguousFirstArgument &) = delete;
        AmbiguousFirstArgument &operator=(AmbiguousFirstArgument const &) = delete;
 
        AmbiguousFirstArgument(AmbiguousFirstArgument &&) = default;
        AmbiguousFirstArgument &operator=(AmbiguousFirstArgument &&) = default;
    };
 
    class AmbiguousOperator
    {
    public:
        String operator_;
 
        String interpreted_as;
 
        AmbiguousOperator() = delete;
        AmbiguousOperator(
            String operator_,
            String interpreted_as);
        AmbiguousOperator(const AmbiguousOperator &) = delete;
        AmbiguousOperator &operator=(AmbiguousOperator const &) = delete;
 
        AmbiguousOperator(AmbiguousOperator &&) = default;
        AmbiguousOperator &operator=(AmbiguousOperator &&) = default;
    };
 
    class InvalidCharacterSyntax
    {
    public:
        String suggestion;
 
        InvalidCharacterSyntax() = delete;
        InvalidCharacterSyntax(
            String suggestion);
        InvalidCharacterSyntax(const InvalidCharacterSyntax &) = delete;
        InvalidCharacterSyntax &operator=(InvalidCharacterSyntax const &) = delete;
 
        InvalidCharacterSyntax(InvalidCharacterSyntax &&) = default;
        InvalidCharacterSyntax &operator=(InvalidCharacterSyntax &&) = default;
    };
 
    class InvalidOctalDigit
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        InvalidOctalDigit();
        InvalidOctalDigit(const InvalidOctalDigit &) = delete;
        InvalidOctalDigit &operator=(InvalidOctalDigit const &) = delete;
 
        InvalidOctalDigit(InvalidOctalDigit &&) = default;
        InvalidOctalDigit &operator=(InvalidOctalDigit &&) = default;
    };
 
    class TrailingCharInNumber
    {
    public:
        uint8_t c;
 
        TrailingCharInNumber() = delete;
        TrailingCharInNumber(
            uint8_t c);
        TrailingCharInNumber(const TrailingCharInNumber &) = delete;
        TrailingCharInNumber &operator=(TrailingCharInNumber const &) = delete;
 
        TrailingCharInNumber(TrailingCharInNumber &&) = default;
        TrailingCharInNumber &operator=(TrailingCharInNumber &&) = default;
    };
 
    class EmbeddedDocumentMeetsEof
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        EmbeddedDocumentMeetsEof();
        EmbeddedDocumentMeetsEof(const EmbeddedDocumentMeetsEof &) = delete;
        EmbeddedDocumentMeetsEof &operator=(EmbeddedDocumentMeetsEof const &) = delete;
 
        EmbeddedDocumentMeetsEof(EmbeddedDocumentMeetsEof &&) = default;
        EmbeddedDocumentMeetsEof &operator=(EmbeddedDocumentMeetsEof &&) = default;
    };
 
    class InvalidChar
    {
    public:
        uint8_t c;
 
        InvalidChar() = delete;
        InvalidChar(
            uint8_t c);
        InvalidChar(const InvalidChar &) = delete;
        InvalidChar &operator=(InvalidChar const &) = delete;
 
        InvalidChar(InvalidChar &&) = default;
        InvalidChar &operator=(InvalidChar &&) = default;
    };
 
    class IncompleteCharacterSyntax
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        IncompleteCharacterSyntax();
        IncompleteCharacterSyntax(const IncompleteCharacterSyntax &) = delete;
        IncompleteCharacterSyntax &operator=(IncompleteCharacterSyntax const &) = delete;
 
        IncompleteCharacterSyntax(IncompleteCharacterSyntax &&) = default;
        IncompleteCharacterSyntax &operator=(IncompleteCharacterSyntax &&) = default;
    };
 
    class GvarWithoutId
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        GvarWithoutId();
        GvarWithoutId(const GvarWithoutId &) = delete;
        GvarWithoutId &operator=(GvarWithoutId const &) = delete;
 
        GvarWithoutId(GvarWithoutId &&) = default;
        GvarWithoutId &operator=(GvarWithoutId &&) = default;
    };
 
    class InvalidGvarName
    {
    public:
        uint8_t c;
 
        InvalidGvarName() = delete;
        InvalidGvarName(
            uint8_t c);
        InvalidGvarName(const InvalidGvarName &) = delete;
        InvalidGvarName &operator=(InvalidGvarName const &) = delete;
 
        InvalidGvarName(InvalidGvarName &&) = default;
        InvalidGvarName &operator=(InvalidGvarName &&) = default;
    };
 
    class IvarWithoutId
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        IvarWithoutId();
        IvarWithoutId(const IvarWithoutId &) = delete;
        IvarWithoutId &operator=(IvarWithoutId const &) = delete;
 
        IvarWithoutId(IvarWithoutId &&) = default;
        IvarWithoutId &operator=(IvarWithoutId &&) = default;
    };
 
    class InvalidIvarName
    {
    public:
        uint8_t c;
 
        InvalidIvarName() = delete;
        InvalidIvarName(
            uint8_t c);
        InvalidIvarName(const InvalidIvarName &) = delete;
        InvalidIvarName &operator=(InvalidIvarName const &) = delete;
 
        InvalidIvarName(InvalidIvarName &&) = default;
        InvalidIvarName &operator=(InvalidIvarName &&) = default;
    };
 
    class CvarWithoutId
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        CvarWithoutId();
        CvarWithoutId(const CvarWithoutId &) = delete;
        CvarWithoutId &operator=(CvarWithoutId const &) = delete;
 
        CvarWithoutId(CvarWithoutId &&) = default;
        CvarWithoutId &operator=(CvarWithoutId &&) = default;
    };
 
    class InvalidCvarName
    {
    public:
        uint8_t c;
 
        InvalidCvarName() = delete;
        InvalidCvarName(
            uint8_t c);
        InvalidCvarName(const InvalidCvarName &) = delete;
        InvalidCvarName &operator=(InvalidCvarName const &) = delete;
 
        InvalidCvarName(InvalidCvarName &&) = default;
        InvalidCvarName &operator=(InvalidCvarName &&) = default;
    };
 
    class UnknownRegexOptions
    {
    public:
        String options;
 
        UnknownRegexOptions() = delete;
        UnknownRegexOptions(
            String options);
        UnknownRegexOptions(const UnknownRegexOptions &) = delete;
        UnknownRegexOptions &operator=(UnknownRegexOptions const &) = delete;
 
        UnknownRegexOptions(UnknownRegexOptions &&) = default;
        UnknownRegexOptions &operator=(UnknownRegexOptions &&) = default;
    };
 
    class UnterminatedUnicodeEscape
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        UnterminatedUnicodeEscape();
        UnterminatedUnicodeEscape(const UnterminatedUnicodeEscape &) = delete;
        UnterminatedUnicodeEscape &operator=(UnterminatedUnicodeEscape const &) = delete;
 
        UnterminatedUnicodeEscape(UnterminatedUnicodeEscape &&) = default;
        UnterminatedUnicodeEscape &operator=(UnterminatedUnicodeEscape &&) = default;
    };
 
    class EncodingError
    {
    public:
        String error;
 
        EncodingError() = delete;
        EncodingError(
            String error);
        EncodingError(const EncodingError &) = delete;
        EncodingError &operator=(EncodingError const &) = delete;
 
        EncodingError(EncodingError &&) = default;
        EncodingError &operator=(EncodingError &&) = default;
    };
 
    class InvalidMultibyteChar
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        InvalidMultibyteChar();
        InvalidMultibyteChar(const InvalidMultibyteChar &) = delete;
        InvalidMultibyteChar &operator=(InvalidMultibyteChar const &) = delete;
 
        InvalidMultibyteChar(InvalidMultibyteChar &&) = default;
        InvalidMultibyteChar &operator=(InvalidMultibyteChar &&) = default;
    };
 
    class AmbiguousTernaryOperator
    {
    public:
        String condition;
 
        AmbiguousTernaryOperator() = delete;
        AmbiguousTernaryOperator(
            String condition);
        AmbiguousTernaryOperator(const AmbiguousTernaryOperator &) = delete;
        AmbiguousTernaryOperator &operator=(AmbiguousTernaryOperator const &) = delete;
 
        AmbiguousTernaryOperator(AmbiguousTernaryOperator &&) = default;
        AmbiguousTernaryOperator &operator=(AmbiguousTernaryOperator &&) = default;
    };
 
    class AmbiguousRegexp
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        AmbiguousRegexp();
        AmbiguousRegexp(const AmbiguousRegexp &) = delete;
        AmbiguousRegexp &operator=(AmbiguousRegexp const &) = delete;
 
        AmbiguousRegexp(AmbiguousRegexp &&) = default;
        AmbiguousRegexp &operator=(AmbiguousRegexp &&) = default;
    };
 
    class ElseWithoutRescue
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        ElseWithoutRescue();
        ElseWithoutRescue(const ElseWithoutRescue &) = delete;
        ElseWithoutRescue &operator=(ElseWithoutRescue const &) = delete;
 
        ElseWithoutRescue(ElseWithoutRescue &&) = default;
        ElseWithoutRescue &operator=(ElseWithoutRescue &&) = default;
    };
 
    class BeginNotAtTopLevel
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        BeginNotAtTopLevel();
        BeginNotAtTopLevel(const BeginNotAtTopLevel &) = delete;
        BeginNotAtTopLevel &operator=(BeginNotAtTopLevel const &) = delete;
 
        BeginNotAtTopLevel(BeginNotAtTopLevel &&) = default;
        BeginNotAtTopLevel &operator=(BeginNotAtTopLevel &&) = default;
    };
 
    class AliasNthRef
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        AliasNthRef();
        AliasNthRef(const AliasNthRef &) = delete;
        AliasNthRef &operator=(AliasNthRef const &) = delete;
 
        AliasNthRef(AliasNthRef &&) = default;
        AliasNthRef &operator=(AliasNthRef &&) = default;
    };
 
    class CsendInsideMasgn
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        CsendInsideMasgn();
        CsendInsideMasgn(const CsendInsideMasgn &) = delete;
        CsendInsideMasgn &operator=(CsendInsideMasgn const &) = delete;
 
        CsendInsideMasgn(CsendInsideMasgn &&) = default;
        CsendInsideMasgn &operator=(CsendInsideMasgn &&) = default;
    };
 
    class ClassOrModuleNameMustBeConstant
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        ClassOrModuleNameMustBeConstant();
        ClassOrModuleNameMustBeConstant(const ClassOrModuleNameMustBeConstant &) = delete;
        ClassOrModuleNameMustBeConstant &operator=(ClassOrModuleNameMustBeConstant const &) = delete;
 
        ClassOrModuleNameMustBeConstant(ClassOrModuleNameMustBeConstant &&) = default;
        ClassOrModuleNameMustBeConstant &operator=(ClassOrModuleNameMustBeConstant &&) = default;
    };
 
    class EndlessSetterDefinition
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        EndlessSetterDefinition();
        EndlessSetterDefinition(const EndlessSetterDefinition &) = delete;
        EndlessSetterDefinition &operator=(EndlessSetterDefinition const &) = delete;
 
        EndlessSetterDefinition(EndlessSetterDefinition &&) = default;
        EndlessSetterDefinition &operator=(EndlessSetterDefinition &&) = default;
    };
 
    class UnexpectedToken
    {
    public:
        String token_name;
 
        UnexpectedToken() = delete;
        UnexpectedToken(
            String token_name);
        UnexpectedToken(const UnexpectedToken &) = delete;
        UnexpectedToken &operator=(UnexpectedToken const &) = delete;
 
        UnexpectedToken(UnexpectedToken &&) = default;
        UnexpectedToken &operator=(UnexpectedToken &&) = default;
    };
 
    class ClassDefinitionInMethodBody
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        ClassDefinitionInMethodBody();
        ClassDefinitionInMethodBody(const ClassDefinitionInMethodBody &) = delete;
        ClassDefinitionInMethodBody &operator=(ClassDefinitionInMethodBody const &) = delete;
 
        ClassDefinitionInMethodBody(ClassDefinitionInMethodBody &&) = default;
        ClassDefinitionInMethodBody &operator=(ClassDefinitionInMethodBody &&) = default;
    };
 
    class ModuleDefinitionInMethodBody
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        ModuleDefinitionInMethodBody();
        ModuleDefinitionInMethodBody(const ModuleDefinitionInMethodBody &) = delete;
        ModuleDefinitionInMethodBody &operator=(ModuleDefinitionInMethodBody const &) = delete;
 
        ModuleDefinitionInMethodBody(ModuleDefinitionInMethodBody &&) = default;
        ModuleDefinitionInMethodBody &operator=(ModuleDefinitionInMethodBody &&) = default;
    };
 
    class InvalidReturnInClassOrModuleBody
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        InvalidReturnInClassOrModuleBody();
        InvalidReturnInClassOrModuleBody(const InvalidReturnInClassOrModuleBody &) = delete;
        InvalidReturnInClassOrModuleBody &operator=(InvalidReturnInClassOrModuleBody const &) = delete;
 
        InvalidReturnInClassOrModuleBody(InvalidReturnInClassOrModuleBody &&) = default;
        InvalidReturnInClassOrModuleBody &operator=(InvalidReturnInClassOrModuleBody &&) = default;
    };
 
    class ConstArgument
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        ConstArgument();
        ConstArgument(const ConstArgument &) = delete;
        ConstArgument &operator=(ConstArgument const &) = delete;
 
        ConstArgument(ConstArgument &&) = default;
        ConstArgument &operator=(ConstArgument &&) = default;
    };
 
    class IvarArgument
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        IvarArgument();
        IvarArgument(const IvarArgument &) = delete;
        IvarArgument &operator=(IvarArgument const &) = delete;
 
        IvarArgument(IvarArgument &&) = default;
        IvarArgument &operator=(IvarArgument &&) = default;
    };
 
    class GvarArgument
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        GvarArgument();
        GvarArgument(const GvarArgument &) = delete;
        GvarArgument &operator=(GvarArgument const &) = delete;
 
        GvarArgument(GvarArgument &&) = default;
        GvarArgument &operator=(GvarArgument &&) = default;
    };
 
    class CvarArgument
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        CvarArgument();
        CvarArgument(const CvarArgument &) = delete;
        CvarArgument &operator=(CvarArgument const &) = delete;
 
        CvarArgument(CvarArgument &&) = default;
        CvarArgument &operator=(CvarArgument &&) = default;
    };
 
    class NoSuchLocalVariable
    {
    public:
        String var_name;
 
        NoSuchLocalVariable() = delete;
        NoSuchLocalVariable(
            String var_name);
        NoSuchLocalVariable(const NoSuchLocalVariable &) = delete;
        NoSuchLocalVariable &operator=(NoSuchLocalVariable const &) = delete;
 
        NoSuchLocalVariable(NoSuchLocalVariable &&) = default;
        NoSuchLocalVariable &operator=(NoSuchLocalVariable &&) = default;
    };
 
    class OrdinaryParamDefined
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        OrdinaryParamDefined();
        OrdinaryParamDefined(const OrdinaryParamDefined &) = delete;
        OrdinaryParamDefined &operator=(OrdinaryParamDefined const &) = delete;
 
        OrdinaryParamDefined(OrdinaryParamDefined &&) = default;
        OrdinaryParamDefined &operator=(OrdinaryParamDefined &&) = default;
    };
 
    class NumparamUsed
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        NumparamUsed();
        NumparamUsed(const NumparamUsed &) = delete;
        NumparamUsed &operator=(NumparamUsed const &) = delete;
 
        NumparamUsed(NumparamUsed &&) = default;
        NumparamUsed &operator=(NumparamUsed &&) = default;
    };
 
    class TokAtEolWithoutExpression
    {
    public:
        String token_name;
 
        TokAtEolWithoutExpression() = delete;
        TokAtEolWithoutExpression(
            String token_name);
        TokAtEolWithoutExpression(const TokAtEolWithoutExpression &) = delete;
        TokAtEolWithoutExpression &operator=(TokAtEolWithoutExpression const &) = delete;
 
        TokAtEolWithoutExpression(TokAtEolWithoutExpression &&) = default;
        TokAtEolWithoutExpression &operator=(TokAtEolWithoutExpression &&) = default;
    };
 
    class InvalidIdToGet
    {
    public:
        String identifier;
 
        InvalidIdToGet() = delete;
        InvalidIdToGet(
            String identifier);
        InvalidIdToGet(const InvalidIdToGet &) = delete;
        InvalidIdToGet &operator=(InvalidIdToGet const &) = delete;
 
        InvalidIdToGet(InvalidIdToGet &&) = default;
        InvalidIdToGet &operator=(InvalidIdToGet &&) = default;
    };
 
    class ForwardArgAfterRestarg
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        ForwardArgAfterRestarg();
        ForwardArgAfterRestarg(const ForwardArgAfterRestarg &) = delete;
        ForwardArgAfterRestarg &operator=(ForwardArgAfterRestarg const &) = delete;
 
        ForwardArgAfterRestarg(ForwardArgAfterRestarg &&) = default;
        ForwardArgAfterRestarg &operator=(ForwardArgAfterRestarg &&) = default;
    };
 
    class NoAnonymousBlockarg
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        NoAnonymousBlockarg();
        NoAnonymousBlockarg(const NoAnonymousBlockarg &) = delete;
        NoAnonymousBlockarg &operator=(NoAnonymousBlockarg const &) = delete;
 
        NoAnonymousBlockarg(NoAnonymousBlockarg &&) = default;
        NoAnonymousBlockarg &operator=(NoAnonymousBlockarg &&) = default;
    };
 
    class EndInMethod
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        EndInMethod();
        EndInMethod(const EndInMethod &) = delete;
        EndInMethod &operator=(EndInMethod const &) = delete;
 
        EndInMethod(EndInMethod &&) = default;
        EndInMethod &operator=(EndInMethod &&) = default;
    };
 
    class ComparisonAfterComparison
    {
    public:
        String comparison;
 
        ComparisonAfterComparison() = delete;
        ComparisonAfterComparison(
            String comparison);
        ComparisonAfterComparison(const ComparisonAfterComparison &) = delete;
        ComparisonAfterComparison &operator=(ComparisonAfterComparison const &) = delete;
 
        ComparisonAfterComparison(ComparisonAfterComparison &&) = default;
        ComparisonAfterComparison &operator=(ComparisonAfterComparison &&) = default;
    };
 
    class DuplicateHashKey
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        DuplicateHashKey();
        DuplicateHashKey(const DuplicateHashKey &) = delete;
        DuplicateHashKey &operator=(DuplicateHashKey const &) = delete;
 
        DuplicateHashKey(DuplicateHashKey &&) = default;
        DuplicateHashKey &operator=(DuplicateHashKey &&) = default;
    };
 
    class CircularArgumentReference
    {
    public:
        String arg_name;
 
        CircularArgumentReference() = delete;
        CircularArgumentReference(
            String arg_name);
        CircularArgumentReference(const CircularArgumentReference &) = delete;
        CircularArgumentReference &operator=(CircularArgumentReference const &) = delete;
 
        CircularArgumentReference(CircularArgumentReference &&) = default;
        CircularArgumentReference &operator=(CircularArgumentReference &&) = default;
    };
 
    class DynamicConstantAssignment
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        DynamicConstantAssignment();
        DynamicConstantAssignment(const DynamicConstantAssignment &) = delete;
        DynamicConstantAssignment &operator=(DynamicConstantAssignment const &) = delete;
 
        DynamicConstantAssignment(DynamicConstantAssignment &&) = default;
        DynamicConstantAssignment &operator=(DynamicConstantAssignment &&) = default;
    };
 
    class CantAssignToSelf
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        CantAssignToSelf();
        CantAssignToSelf(const CantAssignToSelf &) = delete;
        CantAssignToSelf &operator=(CantAssignToSelf const &) = delete;
 
        CantAssignToSelf(CantAssignToSelf &&) = default;
        CantAssignToSelf &operator=(CantAssignToSelf &&) = default;
    };
 
    class CantAssignToNil
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        CantAssignToNil();
        CantAssignToNil(const CantAssignToNil &) = delete;
        CantAssignToNil &operator=(CantAssignToNil const &) = delete;
 
        CantAssignToNil(CantAssignToNil &&) = default;
        CantAssignToNil &operator=(CantAssignToNil &&) = default;
    };
 
    class CantAssignToTrue
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        CantAssignToTrue();
        CantAssignToTrue(const CantAssignToTrue &) = delete;
        CantAssignToTrue &operator=(CantAssignToTrue const &) = delete;
 
        CantAssignToTrue(CantAssignToTrue &&) = default;
        CantAssignToTrue &operator=(CantAssignToTrue &&) = default;
    };
 
    class CantAssignToFalse
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        CantAssignToFalse();
        CantAssignToFalse(const CantAssignToFalse &) = delete;
        CantAssignToFalse &operator=(CantAssignToFalse const &) = delete;
 
        CantAssignToFalse(CantAssignToFalse &&) = default;
        CantAssignToFalse &operator=(CantAssignToFalse &&) = default;
    };
 
    class CantAssignToFile
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        CantAssignToFile();
        CantAssignToFile(const CantAssignToFile &) = delete;
        CantAssignToFile &operator=(CantAssignToFile const &) = delete;
 
        CantAssignToFile(CantAssignToFile &&) = default;
        CantAssignToFile &operator=(CantAssignToFile &&) = default;
    };
 
    class CantAssignToLine
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        CantAssignToLine();
        CantAssignToLine(const CantAssignToLine &) = delete;
        CantAssignToLine &operator=(CantAssignToLine const &) = delete;
 
        CantAssignToLine(CantAssignToLine &&) = default;
        CantAssignToLine &operator=(CantAssignToLine &&) = default;
    };
 
    class CantAssignToEncoding
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        CantAssignToEncoding();
        CantAssignToEncoding(const CantAssignToEncoding &) = delete;
        CantAssignToEncoding &operator=(CantAssignToEncoding const &) = delete;
 
        CantAssignToEncoding(CantAssignToEncoding &&) = default;
        CantAssignToEncoding &operator=(CantAssignToEncoding &&) = default;
    };
 
    class CantAssignToNumparam
    {
    public:
        String numparam;
 
        CantAssignToNumparam() = delete;
        CantAssignToNumparam(
            String numparam);
        CantAssignToNumparam(const CantAssignToNumparam &) = delete;
        CantAssignToNumparam &operator=(CantAssignToNumparam const &) = delete;
 
        CantAssignToNumparam(CantAssignToNumparam &&) = default;
        CantAssignToNumparam &operator=(CantAssignToNumparam &&) = default;
    };
 
    class CantSetVariable
    {
    public:
        String var_name;
 
        CantSetVariable() = delete;
        CantSetVariable(
            String var_name);
        CantSetVariable(const CantSetVariable &) = delete;
        CantSetVariable &operator=(CantSetVariable const &) = delete;
 
        CantSetVariable(CantSetVariable &&) = default;
        CantSetVariable &operator=(CantSetVariable &&) = default;
    };
 
    class BlockGivenToYield
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        BlockGivenToYield();
        BlockGivenToYield(const BlockGivenToYield &) = delete;
        BlockGivenToYield &operator=(BlockGivenToYield const &) = delete;
 
        BlockGivenToYield(BlockGivenToYield &&) = default;
        BlockGivenToYield &operator=(BlockGivenToYield &&) = default;
    };
 
    class BlockAndBlockArgGiven
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        BlockAndBlockArgGiven();
        BlockAndBlockArgGiven(const BlockAndBlockArgGiven &) = delete;
        BlockAndBlockArgGiven &operator=(BlockAndBlockArgGiven const &) = delete;
 
        BlockAndBlockArgGiven(BlockAndBlockArgGiven &&) = default;
        BlockAndBlockArgGiven &operator=(BlockAndBlockArgGiven &&) = default;
    };
 
    class SymbolLiteralWithInterpolation
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        SymbolLiteralWithInterpolation();
        SymbolLiteralWithInterpolation(const SymbolLiteralWithInterpolation &) = delete;
        SymbolLiteralWithInterpolation &operator=(SymbolLiteralWithInterpolation const &) = delete;
 
        SymbolLiteralWithInterpolation(SymbolLiteralWithInterpolation &&) = default;
        SymbolLiteralWithInterpolation &operator=(SymbolLiteralWithInterpolation &&) = default;
    };
 
    class ReservedForNumparam
    {
    public:
        String numparam;
 
        ReservedForNumparam() = delete;
        ReservedForNumparam(
            String numparam);
        ReservedForNumparam(const ReservedForNumparam &) = delete;
        ReservedForNumparam &operator=(ReservedForNumparam const &) = delete;
 
        ReservedForNumparam(ReservedForNumparam &&) = default;
        ReservedForNumparam &operator=(ReservedForNumparam &&) = default;
    };
 
    class KeyMustBeValidAsLocalVariable
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        KeyMustBeValidAsLocalVariable();
        KeyMustBeValidAsLocalVariable(const KeyMustBeValidAsLocalVariable &) = delete;
        KeyMustBeValidAsLocalVariable &operator=(KeyMustBeValidAsLocalVariable const &) = delete;
 
        KeyMustBeValidAsLocalVariable(KeyMustBeValidAsLocalVariable &&) = default;
        KeyMustBeValidAsLocalVariable &operator=(KeyMustBeValidAsLocalVariable &&) = default;
    };
 
    class DuplicateVariableName
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        DuplicateVariableName();
        DuplicateVariableName(const DuplicateVariableName &) = delete;
        DuplicateVariableName &operator=(DuplicateVariableName const &) = delete;
 
        DuplicateVariableName(DuplicateVariableName &&) = default;
        DuplicateVariableName &operator=(DuplicateVariableName &&) = default;
    };
 
    class DuplicateKeyName
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        DuplicateKeyName();
        DuplicateKeyName(const DuplicateKeyName &) = delete;
        DuplicateKeyName &operator=(DuplicateKeyName const &) = delete;
 
        DuplicateKeyName(DuplicateKeyName &&) = default;
        DuplicateKeyName &operator=(DuplicateKeyName &&) = default;
    };
 
    class SingletonLiteral
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        SingletonLiteral();
        SingletonLiteral(const SingletonLiteral &) = delete;
        SingletonLiteral &operator=(SingletonLiteral const &) = delete;
 
        SingletonLiteral(SingletonLiteral &&) = default;
        SingletonLiteral &operator=(SingletonLiteral &&) = default;
    };
 
    class NthRefIsTooBig
    {
    public:
        String nth_ref;
 
        NthRefIsTooBig() = delete;
        NthRefIsTooBig(
            String nth_ref);
        NthRefIsTooBig(const NthRefIsTooBig &) = delete;
        NthRefIsTooBig &operator=(NthRefIsTooBig const &) = delete;
 
        NthRefIsTooBig(NthRefIsTooBig &&) = default;
        NthRefIsTooBig &operator=(NthRefIsTooBig &&) = default;
    };
 
    class DuplicatedArgumentName
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        DuplicatedArgumentName();
        DuplicatedArgumentName(const DuplicatedArgumentName &) = delete;
        DuplicatedArgumentName &operator=(DuplicatedArgumentName const &) = delete;
 
        DuplicatedArgumentName(DuplicatedArgumentName &&) = default;
        DuplicatedArgumentName &operator=(DuplicatedArgumentName &&) = default;
    };
 
    class RegexError
    {
    public:
        String error;
 
        RegexError() = delete;
        RegexError(
            String error);
        RegexError(const RegexError &) = delete;
        RegexError &operator=(RegexError const &) = delete;
 
        RegexError(RegexError &&) = default;
        RegexError &operator=(RegexError &&) = default;
    };
 
    class InvalidSymbol
    {
    public:
        String symbol;
 
        InvalidSymbol() = delete;
        InvalidSymbol(
            String symbol);
        InvalidSymbol(const InvalidSymbol &) = delete;
        InvalidSymbol &operator=(InvalidSymbol const &) = delete;
 
        InvalidSymbol(InvalidSymbol &&) = default;
        InvalidSymbol &operator=(InvalidSymbol &&) = default;
    };
 
    class VoidValueExpression
    {
    public:
        // dummy byte (zero-sized classes are not allowed in C++)
        uint8_t dummy;
        VoidValueExpression();
        VoidValueExpression(const VoidValueExpression &) = delete;
        VoidValueExpression &operator=(VoidValueExpression const &) = delete;
 
        VoidValueExpression(VoidValueExpression &&) = default;
        VoidValueExpression &operator=(VoidValueExpression &&) = default;
    };
 
 
    class DiagnosticMessage {
    public:
        enum class Tag {
            FRACTION_AFTER_NUMERIC,
            NO_DIGITS_AFTER_DOT,
            UNKNOWN_TYPE_OF_PERCENT_STRING,
            NUMERIC_LITERAL_WITHOUT_DIGITS,
            UNTERMINATED_LIST,
            UNTERMINATED_REGEXP,
            UNTERMINATED_STRING,
            UNTERMINATED_QUOTED_STRING,
            INVALID_UNICODE_ESCAPE,
            TOO_LARGE_UNICODE_CODEPOINT,
            INVALID_UNICODE_CODEPOINT,
            MULTIPLE_CODEPOINT_AT_SINGLE_CHAR,
            INVALID_ESCAPE_CHARACTER,
            INVALID_HEX_ESCAPE,
            UNTERMINATED_HEREDOC,
            UNTERMINATED_HEREDOC_ID,
            SLASH_R_AT_MIDDLE_OF_LINE,
            D_STAR_INTERPRETED_AS_ARG_PREFIX,
            STAR_INTERPRETED_AS_ARG_PREFIX,
            AMPERSAND_INTERPRETED_AS_ARG_PREFIX,
            TRIPLE_DOT_AT_EOL,
            PARENTHESES_ITERPRETED_AS_ARGLIST,
            AMBIGUOUS_FIRST_ARGUMENT,
            AMBIGUOUS_OPERATOR,
            INVALID_CHARACTER_SYNTAX,
            INVALID_OCTAL_DIGIT,
            TRAILING_CHAR_IN_NUMBER,
            EMBEDDED_DOCUMENT_MEETS_EOF,
            INVALID_CHAR,
            INCOMPLETE_CHARACTER_SYNTAX,
            GVAR_WITHOUT_ID,
            INVALID_GVAR_NAME,
            IVAR_WITHOUT_ID,
            INVALID_IVAR_NAME,
            CVAR_WITHOUT_ID,
            INVALID_CVAR_NAME,
            UNKNOWN_REGEX_OPTIONS,
            UNTERMINATED_UNICODE_ESCAPE,
            ENCODING_ERROR,
            INVALID_MULTIBYTE_CHAR,
            AMBIGUOUS_TERNARY_OPERATOR,
            AMBIGUOUS_REGEXP,
            ELSE_WITHOUT_RESCUE,
            BEGIN_NOT_AT_TOP_LEVEL,
            ALIAS_NTH_REF,
            CSEND_INSIDE_MASGN,
            CLASS_OR_MODULE_NAME_MUST_BE_CONSTANT,
            ENDLESS_SETTER_DEFINITION,
            UNEXPECTED_TOKEN,
            CLASS_DEFINITION_IN_METHOD_BODY,
            MODULE_DEFINITION_IN_METHOD_BODY,
            INVALID_RETURN_IN_CLASS_OR_MODULE_BODY,
            CONST_ARGUMENT,
            IVAR_ARGUMENT,
            GVAR_ARGUMENT,
            CVAR_ARGUMENT,
            NO_SUCH_LOCAL_VARIABLE,
            ORDINARY_PARAM_DEFINED,
            NUMPARAM_USED,
            TOK_AT_EOL_WITHOUT_EXPRESSION,
            INVALID_ID_TO_GET,
            FORWARD_ARG_AFTER_RESTARG,
            NO_ANONYMOUS_BLOCKARG,
            END_IN_METHOD,
            COMPARISON_AFTER_COMPARISON,
            DUPLICATE_HASH_KEY,
            CIRCULAR_ARGUMENT_REFERENCE,
            DYNAMIC_CONSTANT_ASSIGNMENT,
            CANT_ASSIGN_TO_SELF,
            CANT_ASSIGN_TO_NIL,
            CANT_ASSIGN_TO_TRUE,
            CANT_ASSIGN_TO_FALSE,
            CANT_ASSIGN_TO_FILE,
            CANT_ASSIGN_TO_LINE,
            CANT_ASSIGN_TO_ENCODING,
            CANT_ASSIGN_TO_NUMPARAM,
            CANT_SET_VARIABLE,
            BLOCK_GIVEN_TO_YIELD,
            BLOCK_AND_BLOCK_ARG_GIVEN,
            SYMBOL_LITERAL_WITH_INTERPOLATION,
            RESERVED_FOR_NUMPARAM,
            KEY_MUST_BE_VALID_AS_LOCAL_VARIABLE,
            DUPLICATE_VARIABLE_NAME,
            DUPLICATE_KEY_NAME,
            SINGLETON_LITERAL,
            NTH_REF_IS_TOO_BIG,
            DUPLICATED_ARGUMENT_NAME,
            REGEX_ERROR,
            INVALID_SYMBOL,
            VOID_VALUE_EXPRESSION,
        };
 
        union Value {
            FractionAfterNumeric fraction_after_numeric;
            NoDigitsAfterDot no_digits_after_dot;
            UnknownTypeOfPercentString unknown_type_of_percent_string;
            NumericLiteralWithoutDigits numeric_literal_without_digits;
            UnterminatedList unterminated_list;
            UnterminatedRegexp unterminated_regexp;
            UnterminatedString unterminated_string;
            UnterminatedQuotedString unterminated_quoted_string;
            InvalidUnicodeEscape invalid_unicode_escape;
            TooLargeUnicodeCodepoint too_large_unicode_codepoint;
            InvalidUnicodeCodepoint invalid_unicode_codepoint;
            MultipleCodepointAtSingleChar multiple_codepoint_at_single_char;
            InvalidEscapeCharacter invalid_escape_character;
            InvalidHexEscape invalid_hex_escape;
            UnterminatedHeredoc unterminated_heredoc;
            UnterminatedHeredocId unterminated_heredoc_id;
            SlashRAtMiddleOfLine slash_r_at_middle_of_line;
            DStarInterpretedAsArgPrefix d_star_interpreted_as_arg_prefix;
            StarInterpretedAsArgPrefix star_interpreted_as_arg_prefix;
            AmpersandInterpretedAsArgPrefix ampersand_interpreted_as_arg_prefix;
            TripleDotAtEol triple_dot_at_eol;
            ParenthesesIterpretedAsArglist parentheses_iterpreted_as_arglist;
            AmbiguousFirstArgument ambiguous_first_argument;
            AmbiguousOperator ambiguous_operator;
            InvalidCharacterSyntax invalid_character_syntax;
            InvalidOctalDigit invalid_octal_digit;
            TrailingCharInNumber trailing_char_in_number;
            EmbeddedDocumentMeetsEof embedded_document_meets_eof;
            InvalidChar invalid_char;
            IncompleteCharacterSyntax incomplete_character_syntax;
            GvarWithoutId gvar_without_id;
            InvalidGvarName invalid_gvar_name;
            IvarWithoutId ivar_without_id;
            InvalidIvarName invalid_ivar_name;
            CvarWithoutId cvar_without_id;
            InvalidCvarName invalid_cvar_name;
            UnknownRegexOptions unknown_regex_options;
            UnterminatedUnicodeEscape unterminated_unicode_escape;
            EncodingError encoding_error;
            InvalidMultibyteChar invalid_multibyte_char;
            AmbiguousTernaryOperator ambiguous_ternary_operator;
            AmbiguousRegexp ambiguous_regexp;
            ElseWithoutRescue else_without_rescue;
            BeginNotAtTopLevel begin_not_at_top_level;
            AliasNthRef alias_nth_ref;
            CsendInsideMasgn csend_inside_masgn;
            ClassOrModuleNameMustBeConstant class_or_module_name_must_be_constant;
            EndlessSetterDefinition endless_setter_definition;
            UnexpectedToken unexpected_token;
            ClassDefinitionInMethodBody class_definition_in_method_body;
            ModuleDefinitionInMethodBody module_definition_in_method_body;
            InvalidReturnInClassOrModuleBody invalid_return_in_class_or_module_body;
            ConstArgument const_argument;
            IvarArgument ivar_argument;
            GvarArgument gvar_argument;
            CvarArgument cvar_argument;
            NoSuchLocalVariable no_such_local_variable;
            OrdinaryParamDefined ordinary_param_defined;
            NumparamUsed numparam_used;
            TokAtEolWithoutExpression tok_at_eol_without_expression;
            InvalidIdToGet invalid_id_to_get;
            ForwardArgAfterRestarg forward_arg_after_restarg;
            NoAnonymousBlockarg no_anonymous_blockarg;
            EndInMethod end_in_method;
            ComparisonAfterComparison comparison_after_comparison;
            DuplicateHashKey duplicate_hash_key;
            CircularArgumentReference circular_argument_reference;
            DynamicConstantAssignment dynamic_constant_assignment;
            CantAssignToSelf cant_assign_to_self;
            CantAssignToNil cant_assign_to_nil;
            CantAssignToTrue cant_assign_to_true;
            CantAssignToFalse cant_assign_to_false;
            CantAssignToFile cant_assign_to_file;
            CantAssignToLine cant_assign_to_line;
            CantAssignToEncoding cant_assign_to_encoding;
            CantAssignToNumparam cant_assign_to_numparam;
            CantSetVariable cant_set_variable;
            BlockGivenToYield block_given_to_yield;
            BlockAndBlockArgGiven block_and_block_arg_given;
            SymbolLiteralWithInterpolation symbol_literal_with_interpolation;
            ReservedForNumparam reserved_for_numparam;
            KeyMustBeValidAsLocalVariable key_must_be_valid_as_local_variable;
            DuplicateVariableName duplicate_variable_name;
            DuplicateKeyName duplicate_key_name;
            SingletonLiteral singleton_literal;
            NthRefIsTooBig nth_ref_is_too_big;
            DuplicatedArgumentName duplicated_argument_name;
            RegexError regex_error;
            InvalidSymbol invalid_symbol;
            VoidValueExpression void_value_expression;
 
            Value();
            Value(Value &&);
            ~Value();
 
            Value &operator=(Value &&);
        };
 
        Tag tag;
        Value as;
        DiagnosticMessage(FractionAfterNumeric variant);
        DiagnosticMessage(NoDigitsAfterDot variant);
        DiagnosticMessage(UnknownTypeOfPercentString variant);
        DiagnosticMessage(NumericLiteralWithoutDigits variant);
        DiagnosticMessage(UnterminatedList variant);
        DiagnosticMessage(UnterminatedRegexp variant);
        DiagnosticMessage(UnterminatedString variant);
        DiagnosticMessage(UnterminatedQuotedString variant);
        DiagnosticMessage(InvalidUnicodeEscape variant);
        DiagnosticMessage(TooLargeUnicodeCodepoint variant);
        DiagnosticMessage(InvalidUnicodeCodepoint variant);
        DiagnosticMessage(MultipleCodepointAtSingleChar variant);
        DiagnosticMessage(InvalidEscapeCharacter variant);
        DiagnosticMessage(InvalidHexEscape variant);
        DiagnosticMessage(UnterminatedHeredoc variant);
        DiagnosticMessage(UnterminatedHeredocId variant);
        DiagnosticMessage(SlashRAtMiddleOfLine variant);
        DiagnosticMessage(DStarInterpretedAsArgPrefix variant);
        DiagnosticMessage(StarInterpretedAsArgPrefix variant);
        DiagnosticMessage(AmpersandInterpretedAsArgPrefix variant);
        DiagnosticMessage(TripleDotAtEol variant);
        DiagnosticMessage(ParenthesesIterpretedAsArglist variant);
        DiagnosticMessage(AmbiguousFirstArgument variant);
        DiagnosticMessage(AmbiguousOperator variant);
        DiagnosticMessage(InvalidCharacterSyntax variant);
        DiagnosticMessage(InvalidOctalDigit variant);
        DiagnosticMessage(TrailingCharInNumber variant);
        DiagnosticMessage(EmbeddedDocumentMeetsEof variant);
        DiagnosticMessage(InvalidChar variant);
        DiagnosticMessage(IncompleteCharacterSyntax variant);
        DiagnosticMessage(GvarWithoutId variant);
        DiagnosticMessage(InvalidGvarName variant);
        DiagnosticMessage(IvarWithoutId variant);
        DiagnosticMessage(InvalidIvarName variant);
        DiagnosticMessage(CvarWithoutId variant);
        DiagnosticMessage(InvalidCvarName variant);
        DiagnosticMessage(UnknownRegexOptions variant);
        DiagnosticMessage(UnterminatedUnicodeEscape variant);
        DiagnosticMessage(EncodingError variant);
        DiagnosticMessage(InvalidMultibyteChar variant);
        DiagnosticMessage(AmbiguousTernaryOperator variant);
        DiagnosticMessage(AmbiguousRegexp variant);
        DiagnosticMessage(ElseWithoutRescue variant);
        DiagnosticMessage(BeginNotAtTopLevel variant);
        DiagnosticMessage(AliasNthRef variant);
        DiagnosticMessage(CsendInsideMasgn variant);
        DiagnosticMessage(ClassOrModuleNameMustBeConstant variant);
        DiagnosticMessage(EndlessSetterDefinition variant);
        DiagnosticMessage(UnexpectedToken variant);
        DiagnosticMessage(ClassDefinitionInMethodBody variant);
        DiagnosticMessage(ModuleDefinitionInMethodBody variant);
        DiagnosticMessage(InvalidReturnInClassOrModuleBody variant);
        DiagnosticMessage(ConstArgument variant);
        DiagnosticMessage(IvarArgument variant);
        DiagnosticMessage(GvarArgument variant);
        DiagnosticMessage(CvarArgument variant);
        DiagnosticMessage(NoSuchLocalVariable variant);
        DiagnosticMessage(OrdinaryParamDefined variant);
        DiagnosticMessage(NumparamUsed variant);
        DiagnosticMessage(TokAtEolWithoutExpression variant);
        DiagnosticMessage(InvalidIdToGet variant);
        DiagnosticMessage(ForwardArgAfterRestarg variant);
        DiagnosticMessage(NoAnonymousBlockarg variant);
        DiagnosticMessage(EndInMethod variant);
        DiagnosticMessage(ComparisonAfterComparison variant);
        DiagnosticMessage(DuplicateHashKey variant);
        DiagnosticMessage(CircularArgumentReference variant);
        DiagnosticMessage(DynamicConstantAssignment variant);
        DiagnosticMessage(CantAssignToSelf variant);
        DiagnosticMessage(CantAssignToNil variant);
        DiagnosticMessage(CantAssignToTrue variant);
        DiagnosticMessage(CantAssignToFalse variant);
        DiagnosticMessage(CantAssignToFile variant);
        DiagnosticMessage(CantAssignToLine variant);
        DiagnosticMessage(CantAssignToEncoding variant);
        DiagnosticMessage(CantAssignToNumparam variant);
        DiagnosticMessage(CantSetVariable variant);
        DiagnosticMessage(BlockGivenToYield variant);
        DiagnosticMessage(BlockAndBlockArgGiven variant);
        DiagnosticMessage(SymbolLiteralWithInterpolation variant);
        DiagnosticMessage(ReservedForNumparam variant);
        DiagnosticMessage(KeyMustBeValidAsLocalVariable variant);
        DiagnosticMessage(DuplicateVariableName variant);
        DiagnosticMessage(DuplicateKeyName variant);
        DiagnosticMessage(SingletonLiteral variant);
        DiagnosticMessage(NthRefIsTooBig variant);
        DiagnosticMessage(DuplicatedArgumentName variant);
        DiagnosticMessage(RegexError variant);
        DiagnosticMessage(InvalidSymbol variant);
        DiagnosticMessage(VoidValueExpression variant);
 
        DiagnosticMessage(DiagnosticMessage &&);
        ~DiagnosticMessage();
 
        DiagnosticMessage &operator=(DiagnosticMessage &&);
    };
 
    class DiagnosticMessageList
    {
    public:
        DiagnosticMessage *ptr;
        size_t capacity;
        size_t len;
 
        DiagnosticMessageList() = delete;
        DiagnosticMessageList(DiagnosticMessage *ptr, size_t len, size_t capacity);
        ~DiagnosticMessageList();
 
        DiagnosticMessageList(const DiagnosticMessageList &) = delete;
        DiagnosticMessageList &operator=(DiagnosticMessageList const &) = delete;
 
        DiagnosticMessageList(DiagnosticMessageList &&);
        DiagnosticMessageList &operator=(DiagnosticMessageList &&);
    };
} // namespace lib_ruby_parser
 
#endif // LIB_RUBY_PARSER_MESSAGES_HPP