parol 4.5.0

// ---------------------------------------------------------
// This file was generated by parol.
// Do not edit this file manually.
// Changes will be overwritten on the next build.
// ---------------------------------------------------------

// Disable clippy warnings that can result in the way how parol generates code.
#![allow(clippy::enum_variant_names)]
#![allow(clippy::large_enum_variant)]
#![allow(clippy::upper_case_acronyms)]

use parol_runtime::log::trace;
#[allow(unused_imports)]
use parol_runtime::parol_macros::{pop_and_reverse_item, pop_item};
use parol_runtime::parser::{ParseTreeType, UserActionsTrait};
use parol_runtime::{ParserError, Result, Token};

/// Semantic actions trait generated for the user grammar
/// All functions have default implementations.
pub trait ParolGrammarTrait<'t> {
    /// Semantic action for non-terminal 'Parol'
    fn parol(&mut self, _arg: &Parol<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'Prolog'
    fn prolog(&mut self, _arg: &Prolog<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'StartDeclaration'
    fn start_declaration(&mut self, _arg: &StartDeclaration<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'Declaration'
    fn declaration(&mut self, _arg: &Declaration<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'ScannerDirectives'
    fn scanner_directives(&mut self, _arg: &ScannerDirectives<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'ScannerStateDirectives'
    fn scanner_state_directives(&mut self, _arg: &ScannerStateDirectives<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'GrammarDefinition'
    fn grammar_definition(&mut self, _arg: &GrammarDefinition<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'DoubleColon'
    fn double_colon(&mut self, _arg: &DoubleColon<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'Production'
    fn production(&mut self, _arg: &Production<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'Alternations'
    fn alternations(&mut self, _arg: &Alternations<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'Alternation'
    fn alternation(&mut self, _arg: &Alternation<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'Factor'
    fn factor(&mut self, _arg: &Factor<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'Symbol'
    fn symbol(&mut self, _arg: &Symbol<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'TokenLiteral'
    fn token_literal(&mut self, _arg: &TokenLiteral<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'TokenExpression'
    fn token_expression(&mut self, _arg: &TokenExpression<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'SimpleToken'
    fn simple_token(&mut self, _arg: &SimpleToken<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'TokenWithStates'
    fn token_with_states(&mut self, _arg: &TokenWithStates<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'String'
    fn string(&mut self, _arg: &String<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'RawString'
    fn raw_string(&mut self, _arg: &RawString<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'Regex'
    fn regex(&mut self, _arg: &Regex<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'Group'
    fn group(&mut self, _arg: &Group<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'Optional'
    fn optional(&mut self, _arg: &Optional<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'Repeat'
    fn repeat(&mut self, _arg: &Repeat<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'NonTerminal'
    fn non_terminal(&mut self, _arg: &NonTerminal<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'Identifier'
    fn identifier(&mut self, _arg: &Identifier<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'ScannerState'
    fn scanner_state(&mut self, _arg: &ScannerState<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'IdentifierList'
    fn identifier_list(&mut self, _arg: &IdentifierList<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'ASTControl'
    fn a_s_t_control(&mut self, _arg: &ASTControl<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'MemberName'
    fn member_name(&mut self, _arg: &MemberName<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'CutOperator'
    fn cut_operator(&mut self, _arg: &CutOperator) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'UserTypeDeclaration'
    fn user_type_declaration(&mut self, _arg: &UserTypeDeclaration) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'UserTypeName'
    fn user_type_name(&mut self, _arg: &UserTypeName<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'LookAhead'
    fn look_ahead(&mut self, _arg: &LookAhead<'t>) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'PositiveLookahead'
    fn positive_lookahead(&mut self, _arg: &PositiveLookahead) -> Result<()> {
        Ok(())
    }

    /// Semantic action for non-terminal 'NegativeLookahead'
    fn negative_lookahead(&mut self, _arg: &NegativeLookahead) -> Result<()> {
        Ok(())
    }

    /// This method provides skipped language comments.
    /// If you need comments please provide your own implementation of this method.
    fn on_comment(&mut self, _token: Token<'t>) {}
}

// -------------------------------------------------------------------------------------------------
//
// Output Types of productions deduced from the structure of the transformed grammar
//

///
/// Type derived for production 7
///
/// `Declaration: '%title'^ /* Clipped */ String;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DeclarationPercentTitleString<'t> {
    pub string: String<'t>,
}

///
/// Type derived for production 8
///
/// `Declaration: '%comment'^ /* Clipped */ String;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DeclarationPercentCommentString<'t> {
    pub string: String<'t>,
}

///
/// Type derived for production 9
///
/// `Declaration: '%user_type'^ /* Clipped */ Identifier '='^ /* Clipped */ UserTypeName;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DeclarationPercentUserUnderscoreTypeIdentifierEquUserTypeName<'t> {
    pub identifier: Identifier<'t>,
    pub user_type_name: crate::parser::parol_grammar::UserDefinedTypeName,
}

///
/// Type derived for production 10
///
/// `Declaration: "%nt_type"^ /* Clipped */ Identifier@nt_name '='^ /* Clipped */ UserTypeName@nt_type;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DeclarationPercentNtUnderscoreTypeNtNameEquNtType<'t> {
    pub nt_name: Identifier<'t>,
    pub nt_type: crate::parser::parol_grammar::UserDefinedTypeName,
}

///
/// Type derived for production 11
///
/// `Declaration: "%t_type"^ /* Clipped */ UserTypeName@t_type;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DeclarationPercentTUnderscoreTypeTType {
    pub t_type: crate::parser::parol_grammar::UserDefinedTypeName,
}

///
/// Type derived for production 12
///
/// `Declaration: '%grammar_type'^ /* Clipped */ RawString;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DeclarationPercentGrammarUnderscoreTypeRawString<'t> {
    pub raw_string: RawString<'t>,
}

///
/// Type derived for production 13
///
/// `Declaration: ScannerDirectives;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DeclarationScannerDirectives<'t> {
    pub scanner_directives: ScannerDirectives<'t>,
}

///
/// Type derived for production 14
///
/// `ScannerDirectives: '%line_comment'^ /* Clipped */ TokenLiteral;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ScannerDirectivesPercentLineUnderscoreCommentTokenLiteral<'t> {
    pub token_literal: TokenLiteral<'t>,
}

///
/// Type derived for production 15
///
/// `ScannerDirectives: '%block_comment'^ /* Clipped */ TokenLiteral TokenLiteral;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ScannerDirectivesPercentBlockUnderscoreCommentTokenLiteralTokenLiteral<'t> {
    pub token_literal: TokenLiteral<'t>,
    pub token_literal0: TokenLiteral<'t>,
}

///
/// Type derived for production 16
///
/// `ScannerDirectives: '%auto_newline_off'^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ScannerDirectivesPercentAutoUnderscoreNewlineUnderscoreOff {}

///
/// Type derived for production 17
///
/// `ScannerDirectives: '%auto_ws_off'^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ScannerDirectivesPercentAutoUnderscoreWsUnderscoreOff {}

///
/// Type derived for production 18
///
/// `ScannerDirectives: '%skip'^ /* Clipped */ IdentifierList;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ScannerDirectivesPercentSkipIdentifierList<'t> {
    pub identifier_list: IdentifierList<'t>,
}

///
/// Type derived for production 19
///
/// `ScannerDirectives: '%on'^ /* Clipped */ IdentifierList ScannerStateDirectives;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ScannerDirectivesPercentOnIdentifierListScannerStateDirectives<'t> {
    pub identifier_list: IdentifierList<'t>,
    pub scanner_state_directives: crate::parser::parol_grammar::ScannerStateSwitch,
}

///
/// Type derived for production 20
///
/// `ScannerDirectives: '%allow_unmatched'^ /* Clipped */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ScannerDirectivesPercentAllowUnderscoreUnmatched {}

///
/// Type derived for production 21
///
/// `ScannerStateDirectives: '%enter'^ /* Clipped */ Identifier;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ScannerStateDirectivesPercentEnterIdentifier<'t> {
    pub identifier: Identifier<'t>,
}

///
/// Type derived for production 22
///
/// `ScannerStateDirectives: '%push'^ /* Clipped */ Identifier;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ScannerStateDirectivesPercentPushIdentifier<'t> {
    pub identifier: Identifier<'t>,
}

///
/// Type derived for production 23
///
/// `ScannerStateDirectives: '%pop';`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ScannerStateDirectivesPercentPop<'t> {
    pub percent_pop: Token<'t>, /* %pop */
}

///
/// Type derived for production 35
///
/// `Factor: Group;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct FactorGroup<'t> {
    pub group: Group<'t>,
}

///
/// Type derived for production 36
///
/// `Factor: Repeat;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct FactorRepeat<'t> {
    pub repeat: Repeat<'t>,
}

///
/// Type derived for production 37
///
/// `Factor: Optional;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct FactorOptional<'t> {
    pub optional: Optional<'t>,
}

///
/// Type derived for production 38
///
/// `Factor: Symbol;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct FactorSymbol<'t> {
    pub symbol: Symbol<'t>,
}

///
/// Type derived for production 39
///
/// `Symbol: NonTerminal;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SymbolNonTerminal<'t> {
    pub non_terminal: NonTerminal<'t>,
}

///
/// Type derived for production 40
///
/// `Symbol: SimpleToken;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SymbolSimpleToken<'t> {
    pub simple_token: SimpleToken<'t>,
}

///
/// Type derived for production 41
///
/// `Symbol: TokenWithStates;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SymbolTokenWithStates<'t> {
    pub token_with_states: TokenWithStates<'t>,
}

///
/// Type derived for production 42
///
/// `TokenLiteral: String;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TokenLiteralString<'t> {
    pub string: String<'t>,
}

///
/// Type derived for production 43
///
/// `TokenLiteral: RawString;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TokenLiteralRawString<'t> {
    pub raw_string: RawString<'t>,
}

///
/// Type derived for production 44
///
/// `TokenLiteral: Regex;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TokenLiteralRegex<'t> {
    pub regex: Regex<'t>,
}

///
/// Type derived for production 70
///
/// `ASTControl: CutOperator;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ASTControlCutOperator {
    pub cut_operator: CutOperator,
}

///
/// Type derived for production 71
///
/// `ASTControl: MemberName ASTControlOpt /* Option */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ASTControlMemberNameASTControlOpt<'t> {
    pub member_name: MemberName<'t>,
    pub a_s_t_control_opt: Option<ASTControlOpt>,
}

///
/// Type derived for production 72
///
/// `ASTControl: UserTypeDeclaration;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ASTControlUserTypeDeclaration {
    pub user_type_declaration: UserTypeDeclaration,
}

///
/// Type derived for production 82
///
/// `LookAheadGroup: PositiveLookahead;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LookAheadGroupPositiveLookahead {
    pub positive_lookahead: PositiveLookahead,
}

///
/// Type derived for production 83
///
/// `LookAheadGroup: NegativeLookahead;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LookAheadGroupNegativeLookahead {
    pub negative_lookahead: NegativeLookahead,
}

// -------------------------------------------------------------------------------------------------
//
// Types of non-terminals deduced from the structure of the transformed grammar
//

///
/// Type derived for non-terminal ASTControl
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum ASTControl<'t> {
    CutOperator(ASTControlCutOperator),
    MemberNameASTControlOpt(ASTControlMemberNameASTControlOpt<'t>),
    UserTypeDeclaration(ASTControlUserTypeDeclaration),
}

///
/// Type derived for non-terminal ASTControlOpt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ASTControlOpt {
    pub user_type_declaration: UserTypeDeclaration,
}

///
/// Type derived for non-terminal Alternation
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Alternation<'t> {
    pub alternation_list: Vec<AlternationList<'t>>,
}

///
/// Type derived for non-terminal AlternationList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AlternationList<'t> {
    pub factor: Factor<'t>,
}

///
/// Type derived for non-terminal Alternations
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Alternations<'t> {
    pub alternation: Alternation<'t>,
    pub alternations_list: Vec<AlternationsList<'t>>,
}

///
/// Type derived for non-terminal AlternationsList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AlternationsList<'t> {
    pub alternation: Alternation<'t>,
}

///
/// Type derived for non-terminal CutOperator
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CutOperator {}

///
/// Type derived for non-terminal Declaration
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum Declaration<'t> {
    PercentTitleString(DeclarationPercentTitleString<'t>),
    PercentCommentString(DeclarationPercentCommentString<'t>),
    PercentUserUnderscoreTypeIdentifierEquUserTypeName(
        DeclarationPercentUserUnderscoreTypeIdentifierEquUserTypeName<'t>,
    ),
    PercentNtUnderscoreTypeNtNameEquNtType(DeclarationPercentNtUnderscoreTypeNtNameEquNtType<'t>),
    PercentTUnderscoreTypeTType(DeclarationPercentTUnderscoreTypeTType),
    PercentGrammarUnderscoreTypeRawString(DeclarationPercentGrammarUnderscoreTypeRawString<'t>),
    ScannerDirectives(DeclarationScannerDirectives<'t>),
}

///
/// Type derived for non-terminal DoubleColon
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DoubleColon<'t> {
    pub double_colon: Token<'t>, /* :: */
}

///
/// Type derived for non-terminal Factor
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum Factor<'t> {
    Group(FactorGroup<'t>),
    Repeat(FactorRepeat<'t>),
    Optional(FactorOptional<'t>),
    Symbol(FactorSymbol<'t>),
}

///
/// Type derived for non-terminal GrammarDefinition
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct GrammarDefinition<'t> {
    pub production: Production<'t>,
    pub grammar_definition_list: Vec<GrammarDefinitionList<'t>>,
}

///
/// Type derived for non-terminal GrammarDefinitionList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct GrammarDefinitionList<'t> {
    pub production: Production<'t>,
}

///
/// Type derived for non-terminal Group
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Group<'t> {
    pub l_paren: Token<'t>, /* ( */
    pub alternations: Alternations<'t>,
    pub r_paren: Token<'t>, /* ) */
}

///
/// Type derived for non-terminal Identifier
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Identifier<'t> {
    pub identifier: Token<'t>, /* [a-zA-Z_][a-zA-Z0-9_]* */
}

///
/// Type derived for non-terminal IdentifierList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IdentifierList<'t> {
    pub identifier: Identifier<'t>,
    pub identifier_list_list: Vec<IdentifierListList<'t>>,
}

///
/// Type derived for non-terminal IdentifierListList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IdentifierListList<'t> {
    pub identifier: Identifier<'t>,
}

///
/// Type derived for non-terminal LookAhead
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LookAhead<'t> {
    pub look_ahead_group: LookAheadGroup,
    pub token_literal: TokenLiteral<'t>,
}

///
/// Type derived for non-terminal LookAheadGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum LookAheadGroup {
    PositiveLookahead(LookAheadGroupPositiveLookahead),
    NegativeLookahead(LookAheadGroupNegativeLookahead),
}

///
/// Type derived for non-terminal MemberName
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct MemberName<'t> {
    pub identifier: Identifier<'t>,
}

///
/// Type derived for non-terminal NegativeLookahead
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct NegativeLookahead {}

///
/// Type derived for non-terminal NonTerminal
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct NonTerminal<'t> {
    pub identifier: Identifier<'t>,
    pub non_terminal_opt: Option<NonTerminalOpt<'t>>,
}

///
/// Type derived for non-terminal NonTerminalOpt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct NonTerminalOpt<'t> {
    pub a_s_t_control: ASTControl<'t>,
}

///
/// Type derived for non-terminal Optional
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Optional<'t> {
    pub l_bracket: Token<'t>, /* [ */
    pub alternations: Alternations<'t>,
    pub r_bracket: Token<'t>, /* ] */
}

///
/// Type derived for non-terminal Parol
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Parol<'t> {
    pub prolog: Prolog<'t>,
    pub grammar_definition: GrammarDefinition<'t>,
}

///
/// Type derived for non-terminal PositiveLookahead
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct PositiveLookahead {}

///
/// Type derived for non-terminal Production
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Production<'t> {
    pub identifier: Identifier<'t>,
    pub alternations: Alternations<'t>,
}

///
/// Type derived for non-terminal Prolog
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Prolog<'t> {
    pub start_declaration: StartDeclaration<'t>,
    pub prolog_list: Vec<PrologList<'t>>,
    pub prolog_list0: Vec<PrologList0>,
}

///
/// Type derived for non-terminal PrologList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct PrologList<'t> {
    pub declaration: Declaration<'t>,
}

///
/// Type derived for non-terminal PrologList0
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct PrologList0 {
    pub scanner_state: crate::parser::parol_grammar::ScannerConfig,
}

///
/// Type derived for non-terminal RawString
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RawString<'t> {
    pub raw_string: Token<'t>, /* '(\\.|[^'])*' */
}

///
/// Type derived for non-terminal Regex
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Regex<'t> {
    pub regex: Token<'t>, /* /(\\.|[^\/])*\/ */
}

///
/// Type derived for non-terminal Repeat
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Repeat<'t> {
    pub l_brace: Token<'t>, /* { */
    pub alternations: Alternations<'t>,
    pub r_brace: Token<'t>, /* } */
}

///
/// Type derived for non-terminal ScannerDirectives
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum ScannerDirectives<'t> {
    PercentLineUnderscoreCommentTokenLiteral(
        ScannerDirectivesPercentLineUnderscoreCommentTokenLiteral<'t>,
    ),
    PercentBlockUnderscoreCommentTokenLiteralTokenLiteral(
        ScannerDirectivesPercentBlockUnderscoreCommentTokenLiteralTokenLiteral<'t>,
    ),
    PercentAutoUnderscoreNewlineUnderscoreOff(
        ScannerDirectivesPercentAutoUnderscoreNewlineUnderscoreOff,
    ),
    PercentAutoUnderscoreWsUnderscoreOff(ScannerDirectivesPercentAutoUnderscoreWsUnderscoreOff),
    PercentSkipIdentifierList(ScannerDirectivesPercentSkipIdentifierList<'t>),
    PercentOnIdentifierListScannerStateDirectives(
        ScannerDirectivesPercentOnIdentifierListScannerStateDirectives<'t>,
    ),
    PercentAllowUnderscoreUnmatched(ScannerDirectivesPercentAllowUnderscoreUnmatched),
}

///
/// Type derived for non-terminal ScannerState
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ScannerState<'t> {
    pub state_name: Identifier<'t>,
    pub scanner_state_list: Vec<ScannerStateList<'t>>,
}

///
/// Type derived for non-terminal ScannerStateDirectives
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum ScannerStateDirectives<'t> {
    PercentEnterIdentifier(ScannerStateDirectivesPercentEnterIdentifier<'t>),
    PercentPushIdentifier(ScannerStateDirectivesPercentPushIdentifier<'t>),
    PercentPop(ScannerStateDirectivesPercentPop<'t>),
}

///
/// Type derived for non-terminal ScannerStateList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ScannerStateList<'t> {
    pub scanner_directives: ScannerDirectives<'t>,
}

///
/// Type derived for non-terminal SimpleToken
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SimpleToken<'t> {
    pub token_expression: TokenExpression<'t>,
    pub simple_token_opt: Option<SimpleTokenOpt<'t>>,
}

///
/// Type derived for non-terminal SimpleTokenOpt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SimpleTokenOpt<'t> {
    pub a_s_t_control: ASTControl<'t>,
}

///
/// Type derived for non-terminal StartDeclaration
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct StartDeclaration<'t> {
    pub identifier: Identifier<'t>,
}

///
/// Type derived for non-terminal String
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct String<'t> {
    pub string: Token<'t>, /* "(\\.|[^"])*" */
}

///
/// Type derived for non-terminal Symbol
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum Symbol<'t> {
    NonTerminal(SymbolNonTerminal<'t>),
    SimpleToken(SymbolSimpleToken<'t>),
    TokenWithStates(SymbolTokenWithStates<'t>),
}

///
/// Type derived for non-terminal TokenExpression
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TokenExpression<'t> {
    pub token_literal: TokenLiteral<'t>,
    pub token_expression_opt: Option<TokenExpressionOpt<'t>>,
}

///
/// Type derived for non-terminal TokenExpressionOpt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TokenExpressionOpt<'t> {
    pub look_ahead: LookAhead<'t>,
}

///
/// Type derived for non-terminal TokenLiteral
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum TokenLiteral<'t> {
    String(TokenLiteralString<'t>),
    RawString(TokenLiteralRawString<'t>),
    Regex(TokenLiteralRegex<'t>),
}

///
/// Type derived for non-terminal TokenWithStates
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TokenWithStates<'t> {
    pub identifier_list: IdentifierList<'t>,
    pub token_expression: TokenExpression<'t>,
    pub token_with_states_opt: Option<TokenWithStatesOpt<'t>>,
}

///
/// Type derived for non-terminal TokenWithStatesOpt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TokenWithStatesOpt<'t> {
    pub a_s_t_control: ASTControl<'t>,
}

///
/// Type derived for non-terminal UserTypeDeclaration
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct UserTypeDeclaration {
    pub user_type_name: crate::parser::parol_grammar::UserDefinedTypeName,
}

///
/// Type derived for non-terminal UserTypeName
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct UserTypeName<'t> {
    pub identifier: Identifier<'t>,
    pub user_type_name_list: Vec<UserTypeNameList<'t>>,
}

///
/// Type derived for non-terminal UserTypeNameList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct UserTypeNameList<'t> {
    pub identifier: Identifier<'t>,
}

// -------------------------------------------------------------------------------------------------

///
/// Deduced ASTType of expanded grammar
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum ASTType<'t> {
    ASTControl(ASTControl<'t>),
    ASTControlOpt(Option<ASTControlOpt>),
    Alternation(Alternation<'t>),
    AlternationList(Vec<AlternationList<'t>>),
    Alternations(Alternations<'t>),
    AlternationsList(Vec<AlternationsList<'t>>),
    CutOperator(CutOperator),
    Declaration(Declaration<'t>),
    DoubleColon(DoubleColon<'t>),
    Factor(Factor<'t>),
    GrammarDefinition(GrammarDefinition<'t>),
    GrammarDefinitionList(Vec<GrammarDefinitionList<'t>>),
    Group(Group<'t>),
    Identifier(Identifier<'t>),
    IdentifierList(IdentifierList<'t>),
    IdentifierListList(Vec<IdentifierListList<'t>>),
    LookAhead(LookAhead<'t>),
    LookAheadGroup(LookAheadGroup),
    MemberName(MemberName<'t>),
    NegativeLookahead(NegativeLookahead),
    NonTerminal(NonTerminal<'t>),
    NonTerminalOpt(Option<NonTerminalOpt<'t>>),
    Optional(Optional<'t>),
    Parol(Parol<'t>),
    PositiveLookahead(PositiveLookahead),
    Production(Production<'t>),
    Prolog(Prolog<'t>),
    PrologList(Vec<PrologList<'t>>),
    PrologList0(Vec<PrologList0>),
    RawString(RawString<'t>),
    Regex(Regex<'t>),
    Repeat(Repeat<'t>),
    ScannerDirectives(ScannerDirectives<'t>),
    ScannerState(ScannerState<'t>),
    ScannerStateDirectives(ScannerStateDirectives<'t>),
    ScannerStateList(Vec<ScannerStateList<'t>>),
    SimpleToken(SimpleToken<'t>),
    SimpleTokenOpt(Option<SimpleTokenOpt<'t>>),
    StartDeclaration(StartDeclaration<'t>),
    String(String<'t>),
    Symbol(Symbol<'t>),
    TokenExpression(TokenExpression<'t>),
    TokenExpressionOpt(Option<TokenExpressionOpt<'t>>),
    TokenLiteral(TokenLiteral<'t>),
    TokenWithStates(TokenWithStates<'t>),
    TokenWithStatesOpt(Option<TokenWithStatesOpt<'t>>),
    UserTypeDeclaration(UserTypeDeclaration),
    UserTypeName(UserTypeName<'t>),
    UserTypeNameList(Vec<UserTypeNameList<'t>>),
}

// -------------------------------------------------------------------------------------------------

/// Auto-implemented adapter grammar
///
/// The lifetime parameter `'t` refers to the lifetime of the scanned text.
/// The lifetime parameter `'u` refers to the lifetime of user grammar object.
///
#[allow(dead_code)]
pub struct ParolGrammarAuto<'t, 'u>
where
    't: 'u,
{
    // Mutable reference of the actual user grammar to be able to call the semantic actions on it
    user_grammar: &'u mut dyn ParolGrammarTrait<'t>,
    // Stack to construct the AST on it
    item_stack: Vec<ASTType<'t>>,
}

///
/// The `ParolGrammarAuto` impl is automatically generated for the
/// given grammar.
///
impl<'t, 'u> ParolGrammarAuto<'t, 'u> {
    pub fn new(user_grammar: &'u mut dyn ParolGrammarTrait<'t>) -> Self {
        Self {
            user_grammar,
            item_stack: Vec::new(),
        }
    }

    #[allow(dead_code)]
    fn push(&mut self, item: ASTType<'t>, context: &str) {
        trace!("push    {context}: {item:?}");
        self.item_stack.push(item)
    }

    #[allow(dead_code)]
    fn pop(&mut self, context: &str) -> Option<ASTType<'t>> {
        let item = self.item_stack.pop();
        if let Some(ref item) = item {
            trace!("pop     {context}: {item:?}");
        }
        item
    }

    #[allow(dead_code)]
    // Use this function for debugging purposes:
    // trace!("{}", self.trace_item_stack(context));
    fn trace_item_stack(&self, context: &str) -> std::string::String {
        format!(
            "Item stack at {}:\n{}",
            context,
            self.item_stack
                .iter()
                .rev()
                .map(|s| format!("  {s:?}"))
                .collect::<Vec<std::string::String>>()
                .join("\n")
        )
    }

    /// Semantic action for production 0:
    ///
    /// `Parol: Prolog GrammarDefinition;`
    ///
    #[parol_runtime::function_name::named]
    fn parol(
        &mut self,
        _prolog: &ParseTreeType<'t>,
        _grammar_definition: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let grammar_definition = pop_item!(self, grammar_definition, GrammarDefinition, context);
        let prolog = pop_item!(self, prolog, Prolog, context);
        let parol_built = Parol {
            prolog,
            grammar_definition,
        };
        // Calling user action here
        self.user_grammar.parol(&parol_built)?;
        self.push(ASTType::Parol(parol_built), context);
        Ok(())
    }

    /// Semantic action for production 1:
    ///
    /// `Prolog: StartDeclaration PrologList /* Vec */ PrologList0 /* Vec */;`
    ///
    #[parol_runtime::function_name::named]
    fn prolog(
        &mut self,
        _start_declaration: &ParseTreeType<'t>,
        _prolog_list: &ParseTreeType<'t>,
        _prolog_list0: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let prolog_list0 = pop_and_reverse_item!(self, prolog_list0, PrologList0, context);
        let prolog_list = pop_and_reverse_item!(self, prolog_list, PrologList, context);
        let start_declaration = pop_item!(self, start_declaration, StartDeclaration, context);
        let prolog_built = Prolog {
            start_declaration,
            prolog_list,
            prolog_list0,
        };
        // Calling user action here
        self.user_grammar.prolog(&prolog_built)?;
        self.push(ASTType::Prolog(prolog_built), context);
        Ok(())
    }

    /// Semantic action for production 2:
    ///
    /// `PrologList0 /* Vec<T>::Push */: ScannerState PrologList0;`
    ///
    #[parol_runtime::function_name::named]
    fn prolog_list0_0(
        &mut self,
        _scanner_state: &ParseTreeType<'t>,
        _prolog_list0: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut prolog_list0 = pop_item!(self, prolog_list0, PrologList0, context);
        let scanner_state = pop_item!(self, scanner_state, ScannerState, context);
        let prolog_list0_0_built = PrologList0 {
            scanner_state: (&scanner_state)
                .try_into()
                .map_err(parol_runtime::ParolError::UserError)?,
        };
        // Add an element to the vector
        prolog_list0.push(prolog_list0_0_built);
        self.push(ASTType::PrologList0(prolog_list0), context);
        Ok(())
    }

    /// Semantic action for production 3:
    ///
    /// `PrologList0 /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn prolog_list0_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let prolog_list0_1_built = Vec::new();
        self.push(ASTType::PrologList0(prolog_list0_1_built), context);
        Ok(())
    }

    /// Semantic action for production 4:
    ///
    /// `PrologList /* Vec<T>::Push */: Declaration PrologList;`
    ///
    #[parol_runtime::function_name::named]
    fn prolog_list_0(
        &mut self,
        _declaration: &ParseTreeType<'t>,
        _prolog_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut prolog_list = pop_item!(self, prolog_list, PrologList, context);
        let declaration = pop_item!(self, declaration, Declaration, context);
        let prolog_list_0_built = PrologList { declaration };
        // Add an element to the vector
        prolog_list.push(prolog_list_0_built);
        self.push(ASTType::PrologList(prolog_list), context);
        Ok(())
    }

    /// Semantic action for production 5:
    ///
    /// `PrologList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn prolog_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let prolog_list_1_built = Vec::new();
        self.push(ASTType::PrologList(prolog_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 6:
    ///
    /// `StartDeclaration: '%start'^ /* Clipped */ Identifier;`
    ///
    #[parol_runtime::function_name::named]
    fn start_declaration(
        &mut self,
        _percent_start: &ParseTreeType<'t>,
        _identifier: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let identifier = pop_item!(self, identifier, Identifier, context);
        let start_declaration_built = StartDeclaration { identifier };
        // Calling user action here
        self.user_grammar
            .start_declaration(&start_declaration_built)?;
        self.push(ASTType::StartDeclaration(start_declaration_built), context);
        Ok(())
    }

    /// Semantic action for production 7:
    ///
    /// `Declaration: '%title'^ /* Clipped */ String;`
    ///
    #[parol_runtime::function_name::named]
    fn declaration_0(
        &mut self,
        _percent_title: &ParseTreeType<'t>,
        _string: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let string = pop_item!(self, string, String, context);
        let declaration_0_built = DeclarationPercentTitleString { string };
        let declaration_0_built = Declaration::PercentTitleString(declaration_0_built);
        // Calling user action here
        self.user_grammar.declaration(&declaration_0_built)?;
        self.push(ASTType::Declaration(declaration_0_built), context);
        Ok(())
    }

    /// Semantic action for production 8:
    ///
    /// `Declaration: '%comment'^ /* Clipped */ String;`
    ///
    #[parol_runtime::function_name::named]
    fn declaration_1(
        &mut self,
        _percent_comment: &ParseTreeType<'t>,
        _string: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let string = pop_item!(self, string, String, context);
        let declaration_1_built = DeclarationPercentCommentString { string };
        let declaration_1_built = Declaration::PercentCommentString(declaration_1_built);
        // Calling user action here
        self.user_grammar.declaration(&declaration_1_built)?;
        self.push(ASTType::Declaration(declaration_1_built), context);
        Ok(())
    }

    /// Semantic action for production 9:
    ///
    /// `Declaration: '%user_type'^ /* Clipped */ Identifier '='^ /* Clipped */ UserTypeName;`
    ///
    #[parol_runtime::function_name::named]
    fn declaration_2(
        &mut self,
        _percent_user_underscore_type: &ParseTreeType<'t>,
        _identifier: &ParseTreeType<'t>,
        _equ: &ParseTreeType<'t>,
        _user_type_name: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let user_type_name = pop_item!(self, user_type_name, UserTypeName, context);
        let identifier = pop_item!(self, identifier, Identifier, context);
        let declaration_2_built = DeclarationPercentUserUnderscoreTypeIdentifierEquUserTypeName {
            identifier,
            user_type_name: (&user_type_name)
                .try_into()
                .map_err(parol_runtime::ParolError::UserError)?,
        };
        let declaration_2_built =
            Declaration::PercentUserUnderscoreTypeIdentifierEquUserTypeName(declaration_2_built);
        // Calling user action here
        self.user_grammar.declaration(&declaration_2_built)?;
        self.push(ASTType::Declaration(declaration_2_built), context);
        Ok(())
    }

    /// Semantic action for production 10:
    ///
    /// `Declaration: "%nt_type"^ /* Clipped */ Identifier@nt_name '='^ /* Clipped */ UserTypeName@nt_type;`
    ///
    #[parol_runtime::function_name::named]
    fn declaration_3(
        &mut self,
        _percent_nt_underscore_type: &ParseTreeType<'t>,
        _nt_name: &ParseTreeType<'t>,
        _equ: &ParseTreeType<'t>,
        _nt_type: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let nt_type = pop_item!(self, nt_type, UserTypeName, context);
        let nt_name = pop_item!(self, nt_name, Identifier, context);
        let declaration_3_built = DeclarationPercentNtUnderscoreTypeNtNameEquNtType {
            nt_name,
            nt_type: (&nt_type)
                .try_into()
                .map_err(parol_runtime::ParolError::UserError)?,
        };
        let declaration_3_built =
            Declaration::PercentNtUnderscoreTypeNtNameEquNtType(declaration_3_built);
        // Calling user action here
        self.user_grammar.declaration(&declaration_3_built)?;
        self.push(ASTType::Declaration(declaration_3_built), context);
        Ok(())
    }

    /// Semantic action for production 11:
    ///
    /// `Declaration: "%t_type"^ /* Clipped */ UserTypeName@t_type;`
    ///
    #[parol_runtime::function_name::named]
    fn declaration_4(
        &mut self,
        _percent_t_underscore_type: &ParseTreeType<'t>,
        _t_type: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let t_type = pop_item!(self, t_type, UserTypeName, context);
        let declaration_4_built = DeclarationPercentTUnderscoreTypeTType {
            t_type: (&t_type)
                .try_into()
                .map_err(parol_runtime::ParolError::UserError)?,
        };
        let declaration_4_built = Declaration::PercentTUnderscoreTypeTType(declaration_4_built);
        // Calling user action here
        self.user_grammar.declaration(&declaration_4_built)?;
        self.push(ASTType::Declaration(declaration_4_built), context);
        Ok(())
    }

    /// Semantic action for production 12:
    ///
    /// `Declaration: '%grammar_type'^ /* Clipped */ RawString;`
    ///
    #[parol_runtime::function_name::named]
    fn declaration_5(
        &mut self,
        _percent_grammar_underscore_type: &ParseTreeType<'t>,
        _raw_string: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let raw_string = pop_item!(self, raw_string, RawString, context);
        let declaration_5_built = DeclarationPercentGrammarUnderscoreTypeRawString { raw_string };
        let declaration_5_built =
            Declaration::PercentGrammarUnderscoreTypeRawString(declaration_5_built);
        // Calling user action here
        self.user_grammar.declaration(&declaration_5_built)?;
        self.push(ASTType::Declaration(declaration_5_built), context);
        Ok(())
    }

    /// Semantic action for production 13:
    ///
    /// `Declaration: ScannerDirectives;`
    ///
    #[parol_runtime::function_name::named]
    fn declaration_6(&mut self, _scanner_directives: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let scanner_directives = pop_item!(self, scanner_directives, ScannerDirectives, context);
        let declaration_6_built = DeclarationScannerDirectives { scanner_directives };
        let declaration_6_built = Declaration::ScannerDirectives(declaration_6_built);
        // Calling user action here
        self.user_grammar.declaration(&declaration_6_built)?;
        self.push(ASTType::Declaration(declaration_6_built), context);
        Ok(())
    }

    /// Semantic action for production 14:
    ///
    /// `ScannerDirectives: '%line_comment'^ /* Clipped */ TokenLiteral;`
    ///
    #[parol_runtime::function_name::named]
    fn scanner_directives_0(
        &mut self,
        _percent_line_underscore_comment: &ParseTreeType<'t>,
        _token_literal: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let token_literal = pop_item!(self, token_literal, TokenLiteral, context);
        let scanner_directives_0_built =
            ScannerDirectivesPercentLineUnderscoreCommentTokenLiteral { token_literal };
        let scanner_directives_0_built =
            ScannerDirectives::PercentLineUnderscoreCommentTokenLiteral(scanner_directives_0_built);
        // Calling user action here
        self.user_grammar
            .scanner_directives(&scanner_directives_0_built)?;
        self.push(
            ASTType::ScannerDirectives(scanner_directives_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 15:
    ///
    /// `ScannerDirectives: '%block_comment'^ /* Clipped */ TokenLiteral TokenLiteral;`
    ///
    #[parol_runtime::function_name::named]
    fn scanner_directives_1(
        &mut self,
        _percent_block_underscore_comment: &ParseTreeType<'t>,
        _token_literal: &ParseTreeType<'t>,
        _token_literal0: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let token_literal0 = pop_item!(self, token_literal0, TokenLiteral, context);
        let token_literal = pop_item!(self, token_literal, TokenLiteral, context);
        let scanner_directives_1_built =
            ScannerDirectivesPercentBlockUnderscoreCommentTokenLiteralTokenLiteral {
                token_literal,
                token_literal0,
            };
        let scanner_directives_1_built =
            ScannerDirectives::PercentBlockUnderscoreCommentTokenLiteralTokenLiteral(
                scanner_directives_1_built,
            );
        // Calling user action here
        self.user_grammar
            .scanner_directives(&scanner_directives_1_built)?;
        self.push(
            ASTType::ScannerDirectives(scanner_directives_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 16:
    ///
    /// `ScannerDirectives: '%auto_newline_off'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn scanner_directives_2(
        &mut self,
        _percent_auto_underscore_newline_underscore_off: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let scanner_directives_2_built =
            ScannerDirectivesPercentAutoUnderscoreNewlineUnderscoreOff {};
        let scanner_directives_2_built =
            ScannerDirectives::PercentAutoUnderscoreNewlineUnderscoreOff(
                scanner_directives_2_built,
            );
        // Calling user action here
        self.user_grammar
            .scanner_directives(&scanner_directives_2_built)?;
        self.push(
            ASTType::ScannerDirectives(scanner_directives_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 17:
    ///
    /// `ScannerDirectives: '%auto_ws_off'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn scanner_directives_3(
        &mut self,
        _percent_auto_underscore_ws_underscore_off: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let scanner_directives_3_built = ScannerDirectivesPercentAutoUnderscoreWsUnderscoreOff {};
        let scanner_directives_3_built =
            ScannerDirectives::PercentAutoUnderscoreWsUnderscoreOff(scanner_directives_3_built);
        // Calling user action here
        self.user_grammar
            .scanner_directives(&scanner_directives_3_built)?;
        self.push(
            ASTType::ScannerDirectives(scanner_directives_3_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 18:
    ///
    /// `ScannerDirectives: '%skip'^ /* Clipped */ IdentifierList;`
    ///
    #[parol_runtime::function_name::named]
    fn scanner_directives_4(
        &mut self,
        _percent_skip: &ParseTreeType<'t>,
        _identifier_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let identifier_list = pop_item!(self, identifier_list, IdentifierList, context);
        let scanner_directives_4_built =
            ScannerDirectivesPercentSkipIdentifierList { identifier_list };
        let scanner_directives_4_built =
            ScannerDirectives::PercentSkipIdentifierList(scanner_directives_4_built);
        // Calling user action here
        self.user_grammar
            .scanner_directives(&scanner_directives_4_built)?;
        self.push(
            ASTType::ScannerDirectives(scanner_directives_4_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 19:
    ///
    /// `ScannerDirectives: '%on'^ /* Clipped */ IdentifierList ScannerStateDirectives;`
    ///
    #[parol_runtime::function_name::named]
    fn scanner_directives_5(
        &mut self,
        _percent_on: &ParseTreeType<'t>,
        _identifier_list: &ParseTreeType<'t>,
        _scanner_state_directives: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let scanner_state_directives = pop_item!(
            self,
            scanner_state_directives,
            ScannerStateDirectives,
            context
        );
        let identifier_list = pop_item!(self, identifier_list, IdentifierList, context);
        let scanner_directives_5_built =
            ScannerDirectivesPercentOnIdentifierListScannerStateDirectives {
                identifier_list,
                scanner_state_directives: (&scanner_state_directives)
                    .try_into()
                    .map_err(parol_runtime::ParolError::UserError)?,
            };
        let scanner_directives_5_built =
            ScannerDirectives::PercentOnIdentifierListScannerStateDirectives(
                scanner_directives_5_built,
            );
        // Calling user action here
        self.user_grammar
            .scanner_directives(&scanner_directives_5_built)?;
        self.push(
            ASTType::ScannerDirectives(scanner_directives_5_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 20:
    ///
    /// `ScannerDirectives: '%allow_unmatched'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn scanner_directives_6(
        &mut self,
        _percent_allow_underscore_unmatched: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let scanner_directives_6_built = ScannerDirectivesPercentAllowUnderscoreUnmatched {};
        let scanner_directives_6_built =
            ScannerDirectives::PercentAllowUnderscoreUnmatched(scanner_directives_6_built);
        // Calling user action here
        self.user_grammar
            .scanner_directives(&scanner_directives_6_built)?;
        self.push(
            ASTType::ScannerDirectives(scanner_directives_6_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 21:
    ///
    /// `ScannerStateDirectives: '%enter'^ /* Clipped */ Identifier;`
    ///
    #[parol_runtime::function_name::named]
    fn scanner_state_directives_0(
        &mut self,
        _percent_enter: &ParseTreeType<'t>,
        _identifier: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let identifier = pop_item!(self, identifier, Identifier, context);
        let scanner_state_directives_0_built =
            ScannerStateDirectivesPercentEnterIdentifier { identifier };
        let scanner_state_directives_0_built =
            ScannerStateDirectives::PercentEnterIdentifier(scanner_state_directives_0_built);
        // Calling user action here
        self.user_grammar
            .scanner_state_directives(&scanner_state_directives_0_built)?;
        self.push(
            ASTType::ScannerStateDirectives(scanner_state_directives_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 22:
    ///
    /// `ScannerStateDirectives: '%push'^ /* Clipped */ Identifier;`
    ///
    #[parol_runtime::function_name::named]
    fn scanner_state_directives_1(
        &mut self,
        _percent_push: &ParseTreeType<'t>,
        _identifier: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let identifier = pop_item!(self, identifier, Identifier, context);
        let scanner_state_directives_1_built =
            ScannerStateDirectivesPercentPushIdentifier { identifier };
        let scanner_state_directives_1_built =
            ScannerStateDirectives::PercentPushIdentifier(scanner_state_directives_1_built);
        // Calling user action here
        self.user_grammar
            .scanner_state_directives(&scanner_state_directives_1_built)?;
        self.push(
            ASTType::ScannerStateDirectives(scanner_state_directives_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 23:
    ///
    /// `ScannerStateDirectives: '%pop';`
    ///
    #[parol_runtime::function_name::named]
    fn scanner_state_directives_2(&mut self, percent_pop: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let percent_pop = percent_pop.token()?.clone();
        let scanner_state_directives_2_built = ScannerStateDirectivesPercentPop { percent_pop };
        let scanner_state_directives_2_built =
            ScannerStateDirectives::PercentPop(scanner_state_directives_2_built);
        // Calling user action here
        self.user_grammar
            .scanner_state_directives(&scanner_state_directives_2_built)?;
        self.push(
            ASTType::ScannerStateDirectives(scanner_state_directives_2_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 24:
    ///
    /// `GrammarDefinition: '%%'^ /* Clipped */ Production GrammarDefinitionList /* Vec */;`
    ///
    #[parol_runtime::function_name::named]
    fn grammar_definition(
        &mut self,
        _percent_percent: &ParseTreeType<'t>,
        _production: &ParseTreeType<'t>,
        _grammar_definition_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let grammar_definition_list = pop_and_reverse_item!(
            self,
            grammar_definition_list,
            GrammarDefinitionList,
            context
        );
        let production = pop_item!(self, production, Production, context);
        let grammar_definition_built = GrammarDefinition {
            production,
            grammar_definition_list,
        };
        // Calling user action here
        self.user_grammar
            .grammar_definition(&grammar_definition_built)?;
        self.push(
            ASTType::GrammarDefinition(grammar_definition_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 25:
    ///
    /// `GrammarDefinitionList /* Vec<T>::Push */: Production GrammarDefinitionList;`
    ///
    #[parol_runtime::function_name::named]
    fn grammar_definition_list_0(
        &mut self,
        _production: &ParseTreeType<'t>,
        _grammar_definition_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut grammar_definition_list = pop_item!(
            self,
            grammar_definition_list,
            GrammarDefinitionList,
            context
        );
        let production = pop_item!(self, production, Production, context);
        let grammar_definition_list_0_built = GrammarDefinitionList { production };
        // Add an element to the vector
        grammar_definition_list.push(grammar_definition_list_0_built);
        self.push(
            ASTType::GrammarDefinitionList(grammar_definition_list),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 26:
    ///
    /// `GrammarDefinitionList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn grammar_definition_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let grammar_definition_list_1_built = Vec::new();
        self.push(
            ASTType::GrammarDefinitionList(grammar_definition_list_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 27:
    ///
    /// `DoubleColon: '::';`
    ///
    #[parol_runtime::function_name::named]
    fn double_colon(&mut self, double_colon: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let double_colon = double_colon.token()?.clone();
        let double_colon_built = DoubleColon { double_colon };
        // Calling user action here
        self.user_grammar.double_colon(&double_colon_built)?;
        self.push(ASTType::DoubleColon(double_colon_built), context);
        Ok(())
    }

    /// Semantic action for production 28:
    ///
    /// `Production: Identifier ':'^ /* Clipped */ Alternations ';'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn production(
        &mut self,
        _identifier: &ParseTreeType<'t>,
        _colon: &ParseTreeType<'t>,
        _alternations: &ParseTreeType<'t>,
        _semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let alternations = pop_item!(self, alternations, Alternations, context);
        let identifier = pop_item!(self, identifier, Identifier, context);
        let production_built = Production {
            identifier,
            alternations,
        };
        // Calling user action here
        self.user_grammar.production(&production_built)?;
        self.push(ASTType::Production(production_built), context);
        Ok(())
    }

    /// Semantic action for production 29:
    ///
    /// `Alternations: Alternation AlternationsList /* Vec */;`
    ///
    #[parol_runtime::function_name::named]
    fn alternations(
        &mut self,
        _alternation: &ParseTreeType<'t>,
        _alternations_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let alternations_list =
            pop_and_reverse_item!(self, alternations_list, AlternationsList, context);
        let alternation = pop_item!(self, alternation, Alternation, context);
        let alternations_built = Alternations {
            alternation,
            alternations_list,
        };
        // Calling user action here
        self.user_grammar.alternations(&alternations_built)?;
        self.push(ASTType::Alternations(alternations_built), context);
        Ok(())
    }

    /// Semantic action for production 30:
    ///
    /// `AlternationsList /* Vec<T>::Push */: '|'^ /* Clipped */ Alternation AlternationsList;`
    ///
    #[parol_runtime::function_name::named]
    fn alternations_list_0(
        &mut self,
        _or: &ParseTreeType<'t>,
        _alternation: &ParseTreeType<'t>,
        _alternations_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut alternations_list = pop_item!(self, alternations_list, AlternationsList, context);
        let alternation = pop_item!(self, alternation, Alternation, context);
        let alternations_list_0_built = AlternationsList { alternation };
        // Add an element to the vector
        alternations_list.push(alternations_list_0_built);
        self.push(ASTType::AlternationsList(alternations_list), context);
        Ok(())
    }

    /// Semantic action for production 31:
    ///
    /// `AlternationsList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn alternations_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let alternations_list_1_built = Vec::new();
        self.push(
            ASTType::AlternationsList(alternations_list_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 32:
    ///
    /// `Alternation: AlternationList /* Vec */;`
    ///
    #[parol_runtime::function_name::named]
    fn alternation(&mut self, _alternation_list: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let alternation_list =
            pop_and_reverse_item!(self, alternation_list, AlternationList, context);
        let alternation_built = Alternation { alternation_list };
        // Calling user action here
        self.user_grammar.alternation(&alternation_built)?;
        self.push(ASTType::Alternation(alternation_built), context);
        Ok(())
    }

    /// Semantic action for production 33:
    ///
    /// `AlternationList /* Vec<T>::Push */: Factor AlternationList;`
    ///
    #[parol_runtime::function_name::named]
    fn alternation_list_0(
        &mut self,
        _factor: &ParseTreeType<'t>,
        _alternation_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut alternation_list = pop_item!(self, alternation_list, AlternationList, context);
        let factor = pop_item!(self, factor, Factor, context);
        let alternation_list_0_built = AlternationList { factor };
        // Add an element to the vector
        alternation_list.push(alternation_list_0_built);
        self.push(ASTType::AlternationList(alternation_list), context);
        Ok(())
    }

    /// Semantic action for production 34:
    ///
    /// `AlternationList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn alternation_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let alternation_list_1_built = Vec::new();
        self.push(ASTType::AlternationList(alternation_list_1_built), context);
        Ok(())
    }

    /// Semantic action for production 35:
    ///
    /// `Factor: Group;`
    ///
    #[parol_runtime::function_name::named]
    fn factor_0(&mut self, _group: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let group = pop_item!(self, group, Group, context);
        let factor_0_built = FactorGroup { group };
        let factor_0_built = Factor::Group(factor_0_built);
        // Calling user action here
        self.user_grammar.factor(&factor_0_built)?;
        self.push(ASTType::Factor(factor_0_built), context);
        Ok(())
    }

    /// Semantic action for production 36:
    ///
    /// `Factor: Repeat;`
    ///
    #[parol_runtime::function_name::named]
    fn factor_1(&mut self, _repeat: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let repeat = pop_item!(self, repeat, Repeat, context);
        let factor_1_built = FactorRepeat { repeat };
        let factor_1_built = Factor::Repeat(factor_1_built);
        // Calling user action here
        self.user_grammar.factor(&factor_1_built)?;
        self.push(ASTType::Factor(factor_1_built), context);
        Ok(())
    }

    /// Semantic action for production 37:
    ///
    /// `Factor: Optional;`
    ///
    #[parol_runtime::function_name::named]
    fn factor_2(&mut self, _optional: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let optional = pop_item!(self, optional, Optional, context);
        let factor_2_built = FactorOptional { optional };
        let factor_2_built = Factor::Optional(factor_2_built);
        // Calling user action here
        self.user_grammar.factor(&factor_2_built)?;
        self.push(ASTType::Factor(factor_2_built), context);
        Ok(())
    }

    /// Semantic action for production 38:
    ///
    /// `Factor: Symbol;`
    ///
    #[parol_runtime::function_name::named]
    fn factor_3(&mut self, _symbol: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let symbol = pop_item!(self, symbol, Symbol, context);
        let factor_3_built = FactorSymbol { symbol };
        let factor_3_built = Factor::Symbol(factor_3_built);
        // Calling user action here
        self.user_grammar.factor(&factor_3_built)?;
        self.push(ASTType::Factor(factor_3_built), context);
        Ok(())
    }

    /// Semantic action for production 39:
    ///
    /// `Symbol: NonTerminal;`
    ///
    #[parol_runtime::function_name::named]
    fn symbol_0(&mut self, _non_terminal: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let non_terminal = pop_item!(self, non_terminal, NonTerminal, context);
        let symbol_0_built = SymbolNonTerminal { non_terminal };
        let symbol_0_built = Symbol::NonTerminal(symbol_0_built);
        // Calling user action here
        self.user_grammar.symbol(&symbol_0_built)?;
        self.push(ASTType::Symbol(symbol_0_built), context);
        Ok(())
    }

    /// Semantic action for production 40:
    ///
    /// `Symbol: SimpleToken;`
    ///
    #[parol_runtime::function_name::named]
    fn symbol_1(&mut self, _simple_token: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let simple_token = pop_item!(self, simple_token, SimpleToken, context);
        let symbol_1_built = SymbolSimpleToken { simple_token };
        let symbol_1_built = Symbol::SimpleToken(symbol_1_built);
        // Calling user action here
        self.user_grammar.symbol(&symbol_1_built)?;
        self.push(ASTType::Symbol(symbol_1_built), context);
        Ok(())
    }

    /// Semantic action for production 41:
    ///
    /// `Symbol: TokenWithStates;`
    ///
    #[parol_runtime::function_name::named]
    fn symbol_2(&mut self, _token_with_states: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let token_with_states = pop_item!(self, token_with_states, TokenWithStates, context);
        let symbol_2_built = SymbolTokenWithStates { token_with_states };
        let symbol_2_built = Symbol::TokenWithStates(symbol_2_built);
        // Calling user action here
        self.user_grammar.symbol(&symbol_2_built)?;
        self.push(ASTType::Symbol(symbol_2_built), context);
        Ok(())
    }

    /// Semantic action for production 42:
    ///
    /// `TokenLiteral: String;`
    ///
    #[parol_runtime::function_name::named]
    fn token_literal_0(&mut self, _string: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let string = pop_item!(self, string, String, context);
        let token_literal_0_built = TokenLiteralString { string };
        let token_literal_0_built = TokenLiteral::String(token_literal_0_built);
        // Calling user action here
        self.user_grammar.token_literal(&token_literal_0_built)?;
        self.push(ASTType::TokenLiteral(token_literal_0_built), context);
        Ok(())
    }

    /// Semantic action for production 43:
    ///
    /// `TokenLiteral: RawString;`
    ///
    #[parol_runtime::function_name::named]
    fn token_literal_1(&mut self, _raw_string: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let raw_string = pop_item!(self, raw_string, RawString, context);
        let token_literal_1_built = TokenLiteralRawString { raw_string };
        let token_literal_1_built = TokenLiteral::RawString(token_literal_1_built);
        // Calling user action here
        self.user_grammar.token_literal(&token_literal_1_built)?;
        self.push(ASTType::TokenLiteral(token_literal_1_built), context);
        Ok(())
    }

    /// Semantic action for production 44:
    ///
    /// `TokenLiteral: Regex;`
    ///
    #[parol_runtime::function_name::named]
    fn token_literal_2(&mut self, _regex: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let regex = pop_item!(self, regex, Regex, context);
        let token_literal_2_built = TokenLiteralRegex { regex };
        let token_literal_2_built = TokenLiteral::Regex(token_literal_2_built);
        // Calling user action here
        self.user_grammar.token_literal(&token_literal_2_built)?;
        self.push(ASTType::TokenLiteral(token_literal_2_built), context);
        Ok(())
    }

    /// Semantic action for production 45:
    ///
    /// `TokenExpression: TokenLiteral TokenExpressionOpt /* Option */;`
    ///
    #[parol_runtime::function_name::named]
    fn token_expression(
        &mut self,
        _token_literal: &ParseTreeType<'t>,
        _token_expression_opt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let token_expression_opt =
            pop_item!(self, token_expression_opt, TokenExpressionOpt, context);
        let token_literal = pop_item!(self, token_literal, TokenLiteral, context);
        let token_expression_built = TokenExpression {
            token_literal,
            token_expression_opt,
        };
        // Calling user action here
        self.user_grammar
            .token_expression(&token_expression_built)?;
        self.push(ASTType::TokenExpression(token_expression_built), context);
        Ok(())
    }

    /// Semantic action for production 46:
    ///
    /// `TokenExpressionOpt /* Option<T>::Some */: LookAhead;`
    ///
    #[parol_runtime::function_name::named]
    fn token_expression_opt_0(&mut self, _look_ahead: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let look_ahead = pop_item!(self, look_ahead, LookAhead, context);
        let token_expression_opt_0_built = TokenExpressionOpt { look_ahead };
        self.push(
            ASTType::TokenExpressionOpt(Some(token_expression_opt_0_built)),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 47:
    ///
    /// `TokenExpressionOpt /* Option<T>::None */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn token_expression_opt_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.push(ASTType::TokenExpressionOpt(None), context);
        Ok(())
    }

    /// Semantic action for production 48:
    ///
    /// `SimpleToken: TokenExpression SimpleTokenOpt /* Option */;`
    ///
    #[parol_runtime::function_name::named]
    fn simple_token(
        &mut self,
        _token_expression: &ParseTreeType<'t>,
        _simple_token_opt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let simple_token_opt = pop_item!(self, simple_token_opt, SimpleTokenOpt, context);
        let token_expression = pop_item!(self, token_expression, TokenExpression, context);
        let simple_token_built = SimpleToken {
            token_expression,
            simple_token_opt,
        };
        // Calling user action here
        self.user_grammar.simple_token(&simple_token_built)?;
        self.push(ASTType::SimpleToken(simple_token_built), context);
        Ok(())
    }

    /// Semantic action for production 49:
    ///
    /// `SimpleTokenOpt /* Option<T>::Some */: ASTControl;`
    ///
    #[parol_runtime::function_name::named]
    fn simple_token_opt_0(&mut self, _a_s_t_control: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let a_s_t_control = pop_item!(self, a_s_t_control, ASTControl, context);
        let simple_token_opt_0_built = SimpleTokenOpt { a_s_t_control };
        self.push(
            ASTType::SimpleTokenOpt(Some(simple_token_opt_0_built)),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 50:
    ///
    /// `SimpleTokenOpt /* Option<T>::None */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn simple_token_opt_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.push(ASTType::SimpleTokenOpt(None), context);
        Ok(())
    }

    /// Semantic action for production 51:
    ///
    /// `TokenWithStates: '<'^ /* Clipped */ IdentifierList '>'^ /* Clipped */ TokenExpression TokenWithStatesOpt /* Option */;`
    ///
    #[parol_runtime::function_name::named]
    fn token_with_states(
        &mut self,
        _l_t: &ParseTreeType<'t>,
        _identifier_list: &ParseTreeType<'t>,
        _g_t: &ParseTreeType<'t>,
        _token_expression: &ParseTreeType<'t>,
        _token_with_states_opt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let token_with_states_opt =
            pop_item!(self, token_with_states_opt, TokenWithStatesOpt, context);
        let token_expression = pop_item!(self, token_expression, TokenExpression, context);
        let identifier_list = pop_item!(self, identifier_list, IdentifierList, context);
        let token_with_states_built = TokenWithStates {
            identifier_list,
            token_expression,
            token_with_states_opt,
        };
        // Calling user action here
        self.user_grammar
            .token_with_states(&token_with_states_built)?;
        self.push(ASTType::TokenWithStates(token_with_states_built), context);
        Ok(())
    }

    /// Semantic action for production 52:
    ///
    /// `TokenWithStatesOpt /* Option<T>::Some */: ASTControl;`
    ///
    #[parol_runtime::function_name::named]
    fn token_with_states_opt_0(&mut self, _a_s_t_control: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let a_s_t_control = pop_item!(self, a_s_t_control, ASTControl, context);
        let token_with_states_opt_0_built = TokenWithStatesOpt { a_s_t_control };
        self.push(
            ASTType::TokenWithStatesOpt(Some(token_with_states_opt_0_built)),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 53:
    ///
    /// `TokenWithStatesOpt /* Option<T>::None */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn token_with_states_opt_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.push(ASTType::TokenWithStatesOpt(None), context);
        Ok(())
    }

    /// Semantic action for production 54:
    ///
    /// `String: /"(\\.|[^"])*"/;`
    ///
    #[parol_runtime::function_name::named]
    fn string(&mut self, string: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let string = string.token()?.clone();
        let string_built = String { string };
        // Calling user action here
        self.user_grammar.string(&string_built)?;
        self.push(ASTType::String(string_built), context);
        Ok(())
    }

    /// Semantic action for production 55:
    ///
    /// `RawString: /'(\\.|[^'])*'/;`
    ///
    #[parol_runtime::function_name::named]
    fn raw_string(&mut self, raw_string: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let raw_string = raw_string.token()?.clone();
        let raw_string_built = RawString { raw_string };
        // Calling user action here
        self.user_grammar.raw_string(&raw_string_built)?;
        self.push(ASTType::RawString(raw_string_built), context);
        Ok(())
    }

    /// Semantic action for production 56:
    ///
    /// `Regex: "/(\\.|[^\/])*/";`
    ///
    #[parol_runtime::function_name::named]
    fn regex(&mut self, regex: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let regex = regex.token()?.clone();
        let regex_built = Regex { regex };
        // Calling user action here
        self.user_grammar.regex(&regex_built)?;
        self.push(ASTType::Regex(regex_built), context);
        Ok(())
    }

    /// Semantic action for production 57:
    ///
    /// `Group: '(' Alternations ')';`
    ///
    #[parol_runtime::function_name::named]
    fn group(
        &mut self,
        l_paren: &ParseTreeType<'t>,
        _alternations: &ParseTreeType<'t>,
        r_paren: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let l_paren = l_paren.token()?.clone();
        let r_paren = r_paren.token()?.clone();
        let alternations = pop_item!(self, alternations, Alternations, context);
        let group_built = Group {
            l_paren,
            alternations,
            r_paren,
        };
        // Calling user action here
        self.user_grammar.group(&group_built)?;
        self.push(ASTType::Group(group_built), context);
        Ok(())
    }

    /// Semantic action for production 58:
    ///
    /// `Optional: '[' Alternations ']';`
    ///
    #[parol_runtime::function_name::named]
    fn optional(
        &mut self,
        l_bracket: &ParseTreeType<'t>,
        _alternations: &ParseTreeType<'t>,
        r_bracket: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let l_bracket = l_bracket.token()?.clone();
        let r_bracket = r_bracket.token()?.clone();
        let alternations = pop_item!(self, alternations, Alternations, context);
        let optional_built = Optional {
            l_bracket,
            alternations,
            r_bracket,
        };
        // Calling user action here
        self.user_grammar.optional(&optional_built)?;
        self.push(ASTType::Optional(optional_built), context);
        Ok(())
    }

    /// Semantic action for production 59:
    ///
    /// `Repeat: '{' Alternations '}';`
    ///
    #[parol_runtime::function_name::named]
    fn repeat(
        &mut self,
        l_brace: &ParseTreeType<'t>,
        _alternations: &ParseTreeType<'t>,
        r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let l_brace = l_brace.token()?.clone();
        let r_brace = r_brace.token()?.clone();
        let alternations = pop_item!(self, alternations, Alternations, context);
        let repeat_built = Repeat {
            l_brace,
            alternations,
            r_brace,
        };
        // Calling user action here
        self.user_grammar.repeat(&repeat_built)?;
        self.push(ASTType::Repeat(repeat_built), context);
        Ok(())
    }

    /// Semantic action for production 60:
    ///
    /// `NonTerminal: Identifier NonTerminalOpt /* Option */;`
    ///
    #[parol_runtime::function_name::named]
    fn non_terminal(
        &mut self,
        _identifier: &ParseTreeType<'t>,
        _non_terminal_opt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let non_terminal_opt = pop_item!(self, non_terminal_opt, NonTerminalOpt, context);
        let identifier = pop_item!(self, identifier, Identifier, context);
        let non_terminal_built = NonTerminal {
            identifier,
            non_terminal_opt,
        };
        // Calling user action here
        self.user_grammar.non_terminal(&non_terminal_built)?;
        self.push(ASTType::NonTerminal(non_terminal_built), context);
        Ok(())
    }

    /// Semantic action for production 61:
    ///
    /// `NonTerminalOpt /* Option<T>::Some */: ASTControl;`
    ///
    #[parol_runtime::function_name::named]
    fn non_terminal_opt_0(&mut self, _a_s_t_control: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let a_s_t_control = pop_item!(self, a_s_t_control, ASTControl, context);
        let non_terminal_opt_0_built = NonTerminalOpt { a_s_t_control };
        self.push(
            ASTType::NonTerminalOpt(Some(non_terminal_opt_0_built)),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 62:
    ///
    /// `NonTerminalOpt /* Option<T>::None */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn non_terminal_opt_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.push(ASTType::NonTerminalOpt(None), context);
        Ok(())
    }

    /// Semantic action for production 63:
    ///
    /// `Identifier: /[a-zA-Z_][a-zA-Z0-9_]*/;`
    ///
    #[parol_runtime::function_name::named]
    fn identifier(&mut self, identifier: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let identifier = identifier.token()?.clone();
        let identifier_built = Identifier { identifier };
        // Calling user action here
        self.user_grammar.identifier(&identifier_built)?;
        self.push(ASTType::Identifier(identifier_built), context);
        Ok(())
    }

    /// Semantic action for production 64:
    ///
    /// `ScannerState: '%scanner'^ /* Clipped */ Identifier@state_name '{'^ /* Clipped */ ScannerStateList /* Vec */ '}'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn scanner_state(
        &mut self,
        _percent_scanner: &ParseTreeType<'t>,
        _state_name: &ParseTreeType<'t>,
        _l_brace: &ParseTreeType<'t>,
        _scanner_state_list: &ParseTreeType<'t>,
        _r_brace: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let scanner_state_list =
            pop_and_reverse_item!(self, scanner_state_list, ScannerStateList, context);
        let state_name = pop_item!(self, state_name, Identifier, context);
        let scanner_state_built = ScannerState {
            state_name,
            scanner_state_list,
        };
        // Calling user action here
        self.user_grammar.scanner_state(&scanner_state_built)?;
        self.push(ASTType::ScannerState(scanner_state_built), context);
        Ok(())
    }

    /// Semantic action for production 65:
    ///
    /// `ScannerStateList /* Vec<T>::Push */: ScannerDirectives ScannerStateList;`
    ///
    #[parol_runtime::function_name::named]
    fn scanner_state_list_0(
        &mut self,
        _scanner_directives: &ParseTreeType<'t>,
        _scanner_state_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut scanner_state_list = pop_item!(self, scanner_state_list, ScannerStateList, context);
        let scanner_directives = pop_item!(self, scanner_directives, ScannerDirectives, context);
        let scanner_state_list_0_built = ScannerStateList { scanner_directives };
        // Add an element to the vector
        scanner_state_list.push(scanner_state_list_0_built);
        self.push(ASTType::ScannerStateList(scanner_state_list), context);
        Ok(())
    }

    /// Semantic action for production 66:
    ///
    /// `ScannerStateList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn scanner_state_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let scanner_state_list_1_built = Vec::new();
        self.push(
            ASTType::ScannerStateList(scanner_state_list_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 67:
    ///
    /// `IdentifierList: Identifier IdentifierListList /* Vec */;`
    ///
    #[parol_runtime::function_name::named]
    fn identifier_list(
        &mut self,
        _identifier: &ParseTreeType<'t>,
        _identifier_list_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let identifier_list_list =
            pop_and_reverse_item!(self, identifier_list_list, IdentifierListList, context);
        let identifier = pop_item!(self, identifier, Identifier, context);
        let identifier_list_built = IdentifierList {
            identifier,
            identifier_list_list,
        };
        // Calling user action here
        self.user_grammar.identifier_list(&identifier_list_built)?;
        self.push(ASTType::IdentifierList(identifier_list_built), context);
        Ok(())
    }

    /// Semantic action for production 68:
    ///
    /// `IdentifierListList /* Vec<T>::Push */: ','^ /* Clipped */ Identifier IdentifierListList;`
    ///
    #[parol_runtime::function_name::named]
    fn identifier_list_list_0(
        &mut self,
        _comma: &ParseTreeType<'t>,
        _identifier: &ParseTreeType<'t>,
        _identifier_list_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut identifier_list_list =
            pop_item!(self, identifier_list_list, IdentifierListList, context);
        let identifier = pop_item!(self, identifier, Identifier, context);
        let identifier_list_list_0_built = IdentifierListList { identifier };
        // Add an element to the vector
        identifier_list_list.push(identifier_list_list_0_built);
        self.push(ASTType::IdentifierListList(identifier_list_list), context);
        Ok(())
    }

    /// Semantic action for production 69:
    ///
    /// `IdentifierListList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn identifier_list_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let identifier_list_list_1_built = Vec::new();
        self.push(
            ASTType::IdentifierListList(identifier_list_list_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 70:
    ///
    /// `ASTControl: CutOperator;`
    ///
    #[parol_runtime::function_name::named]
    fn a_s_t_control_0(&mut self, _cut_operator: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let cut_operator = pop_item!(self, cut_operator, CutOperator, context);
        let a_s_t_control_0_built = ASTControlCutOperator { cut_operator };
        let a_s_t_control_0_built = ASTControl::CutOperator(a_s_t_control_0_built);
        // Calling user action here
        self.user_grammar.a_s_t_control(&a_s_t_control_0_built)?;
        self.push(ASTType::ASTControl(a_s_t_control_0_built), context);
        Ok(())
    }

    /// Semantic action for production 71:
    ///
    /// `ASTControl: MemberName ASTControlOpt /* Option */;`
    ///
    #[parol_runtime::function_name::named]
    fn a_s_t_control_1(
        &mut self,
        _member_name: &ParseTreeType<'t>,
        _a_s_t_control_opt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let a_s_t_control_opt = pop_item!(self, a_s_t_control_opt, ASTControlOpt, context);
        let member_name = pop_item!(self, member_name, MemberName, context);
        let a_s_t_control_1_built = ASTControlMemberNameASTControlOpt {
            member_name,
            a_s_t_control_opt,
        };
        let a_s_t_control_1_built = ASTControl::MemberNameASTControlOpt(a_s_t_control_1_built);
        // Calling user action here
        self.user_grammar.a_s_t_control(&a_s_t_control_1_built)?;
        self.push(ASTType::ASTControl(a_s_t_control_1_built), context);
        Ok(())
    }

    /// Semantic action for production 72:
    ///
    /// `ASTControl: UserTypeDeclaration;`
    ///
    #[parol_runtime::function_name::named]
    fn a_s_t_control_2(&mut self, _user_type_declaration: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let user_type_declaration =
            pop_item!(self, user_type_declaration, UserTypeDeclaration, context);
        let a_s_t_control_2_built = ASTControlUserTypeDeclaration {
            user_type_declaration,
        };
        let a_s_t_control_2_built = ASTControl::UserTypeDeclaration(a_s_t_control_2_built);
        // Calling user action here
        self.user_grammar.a_s_t_control(&a_s_t_control_2_built)?;
        self.push(ASTType::ASTControl(a_s_t_control_2_built), context);
        Ok(())
    }

    /// Semantic action for production 73:
    ///
    /// `ASTControlOpt /* Option<T>::Some */: UserTypeDeclaration;`
    ///
    #[parol_runtime::function_name::named]
    fn a_s_t_control_opt_0(&mut self, _user_type_declaration: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let user_type_declaration =
            pop_item!(self, user_type_declaration, UserTypeDeclaration, context);
        let a_s_t_control_opt_0_built = ASTControlOpt {
            user_type_declaration,
        };
        self.push(
            ASTType::ASTControlOpt(Some(a_s_t_control_opt_0_built)),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 74:
    ///
    /// `ASTControlOpt /* Option<T>::None */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn a_s_t_control_opt_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.push(ASTType::ASTControlOpt(None), context);
        Ok(())
    }

    /// Semantic action for production 75:
    ///
    /// `MemberName: '@'^ /* Clipped */ Identifier;`
    ///
    #[parol_runtime::function_name::named]
    fn member_name(
        &mut self,
        _at: &ParseTreeType<'t>,
        _identifier: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let identifier = pop_item!(self, identifier, Identifier, context);
        let member_name_built = MemberName { identifier };
        // Calling user action here
        self.user_grammar.member_name(&member_name_built)?;
        self.push(ASTType::MemberName(member_name_built), context);
        Ok(())
    }

    /// Semantic action for production 76:
    ///
    /// `CutOperator: '^'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn cut_operator(&mut self, _cut_operator: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let cut_operator_built = CutOperator {};
        // Calling user action here
        self.user_grammar.cut_operator(&cut_operator_built)?;
        self.push(ASTType::CutOperator(cut_operator_built), context);
        Ok(())
    }

    /// Semantic action for production 77:
    ///
    /// `UserTypeDeclaration: ':'^ /* Clipped */ UserTypeName;`
    ///
    #[parol_runtime::function_name::named]
    fn user_type_declaration(
        &mut self,
        _colon: &ParseTreeType<'t>,
        _user_type_name: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let user_type_name = pop_item!(self, user_type_name, UserTypeName, context);
        let user_type_declaration_built = UserTypeDeclaration {
            user_type_name: (&user_type_name)
                .try_into()
                .map_err(parol_runtime::ParolError::UserError)?,
        };
        // Calling user action here
        self.user_grammar
            .user_type_declaration(&user_type_declaration_built)?;
        self.push(
            ASTType::UserTypeDeclaration(user_type_declaration_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 78:
    ///
    /// `UserTypeName: Identifier UserTypeNameList /* Vec */;`
    ///
    #[parol_runtime::function_name::named]
    fn user_type_name(
        &mut self,
        _identifier: &ParseTreeType<'t>,
        _user_type_name_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let user_type_name_list =
            pop_and_reverse_item!(self, user_type_name_list, UserTypeNameList, context);
        let identifier = pop_item!(self, identifier, Identifier, context);
        let user_type_name_built = UserTypeName {
            identifier,
            user_type_name_list,
        };
        // Calling user action here
        self.user_grammar.user_type_name(&user_type_name_built)?;
        self.push(ASTType::UserTypeName(user_type_name_built), context);
        Ok(())
    }

    /// Semantic action for production 79:
    ///
    /// `UserTypeNameList /* Vec<T>::Push */: DoubleColon^ /* Clipped */ Identifier UserTypeNameList;`
    ///
    #[parol_runtime::function_name::named]
    fn user_type_name_list_0(
        &mut self,
        _double_colon: &ParseTreeType<'t>,
        _identifier: &ParseTreeType<'t>,
        _user_type_name_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut user_type_name_list =
            pop_item!(self, user_type_name_list, UserTypeNameList, context);
        let identifier = pop_item!(self, identifier, Identifier, context);
        self.pop(context);
        let user_type_name_list_0_built = UserTypeNameList { identifier };
        // Add an element to the vector
        user_type_name_list.push(user_type_name_list_0_built);
        self.push(ASTType::UserTypeNameList(user_type_name_list), context);
        Ok(())
    }

    /// Semantic action for production 80:
    ///
    /// `UserTypeNameList /* Vec<T>::New */: ;`
    ///
    #[parol_runtime::function_name::named]
    fn user_type_name_list_1(&mut self) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let user_type_name_list_1_built = Vec::new();
        self.push(
            ASTType::UserTypeNameList(user_type_name_list_1_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 81:
    ///
    /// `LookAhead: LookAheadGroup TokenLiteral;`
    ///
    #[parol_runtime::function_name::named]
    fn look_ahead(
        &mut self,
        _look_ahead_group: &ParseTreeType<'t>,
        _token_literal: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let token_literal = pop_item!(self, token_literal, TokenLiteral, context);
        let look_ahead_group = pop_item!(self, look_ahead_group, LookAheadGroup, context);
        let look_ahead_built = LookAhead {
            look_ahead_group,
            token_literal,
        };
        // Calling user action here
        self.user_grammar.look_ahead(&look_ahead_built)?;
        self.push(ASTType::LookAhead(look_ahead_built), context);
        Ok(())
    }

    /// Semantic action for production 82:
    ///
    /// `LookAheadGroup: PositiveLookahead;`
    ///
    #[parol_runtime::function_name::named]
    fn look_ahead_group_0(&mut self, _positive_lookahead: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let positive_lookahead = pop_item!(self, positive_lookahead, PositiveLookahead, context);
        let look_ahead_group_0_built = LookAheadGroupPositiveLookahead { positive_lookahead };
        let look_ahead_group_0_built = LookAheadGroup::PositiveLookahead(look_ahead_group_0_built);
        self.push(ASTType::LookAheadGroup(look_ahead_group_0_built), context);
        Ok(())
    }

    /// Semantic action for production 83:
    ///
    /// `LookAheadGroup: NegativeLookahead;`
    ///
    #[parol_runtime::function_name::named]
    fn look_ahead_group_1(&mut self, _negative_lookahead: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let negative_lookahead = pop_item!(self, negative_lookahead, NegativeLookahead, context);
        let look_ahead_group_1_built = LookAheadGroupNegativeLookahead { negative_lookahead };
        let look_ahead_group_1_built = LookAheadGroup::NegativeLookahead(look_ahead_group_1_built);
        self.push(ASTType::LookAheadGroup(look_ahead_group_1_built), context);
        Ok(())
    }

    /// Semantic action for production 84:
    ///
    /// `PositiveLookahead: '?='^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn positive_lookahead(&mut self, _positive_lookahead: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let positive_lookahead_built = PositiveLookahead {};
        // Calling user action here
        self.user_grammar
            .positive_lookahead(&positive_lookahead_built)?;
        self.push(
            ASTType::PositiveLookahead(positive_lookahead_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 85:
    ///
    /// `NegativeLookahead: '?!'^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn negative_lookahead(&mut self, _negative_lookahead: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let negative_lookahead_built = NegativeLookahead {};
        // Calling user action here
        self.user_grammar
            .negative_lookahead(&negative_lookahead_built)?;
        self.push(
            ASTType::NegativeLookahead(negative_lookahead_built),
            context,
        );
        Ok(())
    }
}

impl<'t> UserActionsTrait<'t> for ParolGrammarAuto<'t, '_> {
    ///
    /// This function is implemented automatically for the user's item ParolGrammar.
    ///
    fn call_semantic_action_for_production_number(
        &mut self,
        prod_num: usize,
        children: &[ParseTreeType<'t>],
    ) -> Result<()> {
        match prod_num {
            0 => self.parol(&children[0], &children[1]),
            1 => self.prolog(&children[0], &children[1], &children[2]),
            2 => self.prolog_list0_0(&children[0], &children[1]),
            3 => self.prolog_list0_1(),
            4 => self.prolog_list_0(&children[0], &children[1]),
            5 => self.prolog_list_1(),
            6 => self.start_declaration(&children[0], &children[1]),
            7 => self.declaration_0(&children[0], &children[1]),
            8 => self.declaration_1(&children[0], &children[1]),
            9 => self.declaration_2(&children[0], &children[1], &children[2], &children[3]),
            10 => self.declaration_3(&children[0], &children[1], &children[2], &children[3]),
            11 => self.declaration_4(&children[0], &children[1]),
            12 => self.declaration_5(&children[0], &children[1]),
            13 => self.declaration_6(&children[0]),
            14 => self.scanner_directives_0(&children[0], &children[1]),
            15 => self.scanner_directives_1(&children[0], &children[1], &children[2]),
            16 => self.scanner_directives_2(&children[0]),
            17 => self.scanner_directives_3(&children[0]),
            18 => self.scanner_directives_4(&children[0], &children[1]),
            19 => self.scanner_directives_5(&children[0], &children[1], &children[2]),
            20 => self.scanner_directives_6(&children[0]),
            21 => self.scanner_state_directives_0(&children[0], &children[1]),
            22 => self.scanner_state_directives_1(&children[0], &children[1]),
            23 => self.scanner_state_directives_2(&children[0]),
            24 => self.grammar_definition(&children[0], &children[1], &children[2]),
            25 => self.grammar_definition_list_0(&children[0], &children[1]),
            26 => self.grammar_definition_list_1(),
            27 => self.double_colon(&children[0]),
            28 => self.production(&children[0], &children[1], &children[2], &children[3]),
            29 => self.alternations(&children[0], &children[1]),
            30 => self.alternations_list_0(&children[0], &children[1], &children[2]),
            31 => self.alternations_list_1(),
            32 => self.alternation(&children[0]),
            33 => self.alternation_list_0(&children[0], &children[1]),
            34 => self.alternation_list_1(),
            35 => self.factor_0(&children[0]),
            36 => self.factor_1(&children[0]),
            37 => self.factor_2(&children[0]),
            38 => self.factor_3(&children[0]),
            39 => self.symbol_0(&children[0]),
            40 => self.symbol_1(&children[0]),
            41 => self.symbol_2(&children[0]),
            42 => self.token_literal_0(&children[0]),
            43 => self.token_literal_1(&children[0]),
            44 => self.token_literal_2(&children[0]),
            45 => self.token_expression(&children[0], &children[1]),
            46 => self.token_expression_opt_0(&children[0]),
            47 => self.token_expression_opt_1(),
            48 => self.simple_token(&children[0], &children[1]),
            49 => self.simple_token_opt_0(&children[0]),
            50 => self.simple_token_opt_1(),
            51 => self.token_with_states(
                &children[0],
                &children[1],
                &children[2],
                &children[3],
                &children[4],
            ),
            52 => self.token_with_states_opt_0(&children[0]),
            53 => self.token_with_states_opt_1(),
            54 => self.string(&children[0]),
            55 => self.raw_string(&children[0]),
            56 => self.regex(&children[0]),
            57 => self.group(&children[0], &children[1], &children[2]),
            58 => self.optional(&children[0], &children[1], &children[2]),
            59 => self.repeat(&children[0], &children[1], &children[2]),
            60 => self.non_terminal(&children[0], &children[1]),
            61 => self.non_terminal_opt_0(&children[0]),
            62 => self.non_terminal_opt_1(),
            63 => self.identifier(&children[0]),
            64 => self.scanner_state(
                &children[0],
                &children[1],
                &children[2],
                &children[3],
                &children[4],
            ),
            65 => self.scanner_state_list_0(&children[0], &children[1]),
            66 => self.scanner_state_list_1(),
            67 => self.identifier_list(&children[0], &children[1]),
            68 => self.identifier_list_list_0(&children[0], &children[1], &children[2]),
            69 => self.identifier_list_list_1(),
            70 => self.a_s_t_control_0(&children[0]),
            71 => self.a_s_t_control_1(&children[0], &children[1]),
            72 => self.a_s_t_control_2(&children[0]),
            73 => self.a_s_t_control_opt_0(&children[0]),
            74 => self.a_s_t_control_opt_1(),
            75 => self.member_name(&children[0], &children[1]),
            76 => self.cut_operator(&children[0]),
            77 => self.user_type_declaration(&children[0], &children[1]),
            78 => self.user_type_name(&children[0], &children[1]),
            79 => self.user_type_name_list_0(&children[0], &children[1], &children[2]),
            80 => self.user_type_name_list_1(),
            81 => self.look_ahead(&children[0], &children[1]),
            82 => self.look_ahead_group_0(&children[0]),
            83 => self.look_ahead_group_1(&children[0]),
            84 => self.positive_lookahead(&children[0]),
            85 => self.negative_lookahead(&children[0]),
            _ => Err(ParserError::InternalError(format!(
                "Unhandled production number: {prod_num}"
            ))
            .into()),
        }
    }

    fn on_comment(&mut self, token: Token<'t>) {
        self.user_grammar.on_comment(token)
    }
}