parol-ls 4.4.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};
use std::marker::PhantomData;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /// Semantic action for non-terminal 'LookAhead'
    fn look_ahead(&mut self, _arg: &LookAhead) -> 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<'_>) {}
}

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

///
/// Type derived for production 7
///
/// `Declaration: "%title" String;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DeclarationPercentTitleString {
    pub percent_title: crate::parol_ls_grammar::OwnedToken, /* %title */
    pub string: String,
}

///
/// Type derived for production 8
///
/// `Declaration: "%comment" String;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DeclarationPercentCommentString {
    pub percent_comment: crate::parol_ls_grammar::OwnedToken, /* %comment */
    pub string: String,
}

///
/// Type derived for production 9
///
/// `Declaration: "%user_type" Identifier "=" UserTypeName;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DeclarationPercentUserUnderscoreTypeIdentifierEquUserTypeName {
    pub percent_user_underscore_type: crate::parol_ls_grammar::OwnedToken, /* %user_type */
    pub identifier: Identifier,
    pub equ: crate::parol_ls_grammar::OwnedToken, /* = */
    pub user_type_name: UserTypeName,
}

///
/// Type derived for production 10
///
/// `Declaration: "%nt_type" Identifier@nt_name "=" UserTypeName@nt_type;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DeclarationPercentNtUnderscoreTypeNtNameEquNtType {
    pub percent_nt_underscore_type: crate::parol_ls_grammar::OwnedToken, /* %nt_type */
    pub nt_name: Identifier,
    pub equ: crate::parol_ls_grammar::OwnedToken, /* = */
    pub nt_type: UserTypeName,
}

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

///
/// Type derived for production 12
///
/// `Declaration: '%grammar_type' LiteralString;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DeclarationPercentGrammarUnderscoreTypeLiteralString {
    pub percent_grammar_underscore_type: crate::parol_ls_grammar::OwnedToken, /* %grammar_type */
    pub literal_string: LiteralString,
}

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

///
/// Type derived for production 14
///
/// `ScannerDirectives: "%line_comment" TokenLiteral;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ScannerDirectivesPercentLineUnderscoreCommentTokenLiteral {
    pub percent_line_underscore_comment: crate::parol_ls_grammar::OwnedToken, /* %line_comment */
    pub token_literal: TokenLiteral,
}

///
/// Type derived for production 15
///
/// `ScannerDirectives: "%block_comment" TokenLiteral TokenLiteral;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ScannerDirectivesPercentBlockUnderscoreCommentTokenLiteralTokenLiteral {
    pub percent_block_underscore_comment: crate::parol_ls_grammar::OwnedToken, /* %block_comment */
    pub token_literal: TokenLiteral,
    pub token_literal0: TokenLiteral,
}

///
/// Type derived for production 16
///
/// `ScannerDirectives: "%auto_newline_off";`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ScannerDirectivesPercentAutoUnderscoreNewlineUnderscoreOff {
    pub percent_auto_underscore_newline_underscore_off: crate::parol_ls_grammar::OwnedToken, /* %auto_newline_off */
}

///
/// Type derived for production 17
///
/// `ScannerDirectives: "%auto_ws_off";`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ScannerDirectivesPercentAutoUnderscoreWsUnderscoreOff {
    pub percent_auto_underscore_ws_underscore_off: crate::parol_ls_grammar::OwnedToken, /* %auto_ws_off */
}

///
/// Type derived for production 18
///
/// `ScannerDirectives: '%skip' IdentifierList;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ScannerDirectivesPercentSkipIdentifierList {
    pub percent_skip: crate::parol_ls_grammar::OwnedToken, /* %skip */
    pub identifier_list: IdentifierList,
}

///
/// Type derived for production 19
///
/// `ScannerDirectives: '%on' IdentifierList ScannerStateDirectives;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ScannerDirectivesPercentOnIdentifierListScannerStateDirectives {
    pub percent_on: crate::parol_ls_grammar::OwnedToken, /* %on */
    pub identifier_list: IdentifierList,
    pub scanner_state_directives: ScannerStateDirectives,
}

///
/// Type derived for production 20
///
/// `ScannerDirectives: "%allow_unmatched";`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ScannerDirectivesPercentAllowUnderscoreUnmatched {
    pub percent_allow_underscore_unmatched: crate::parol_ls_grammar::OwnedToken, /* %allow_unmatched */
}

///
/// Type derived for production 21
///
/// `ScannerStateDirectives: '%enter' Identifier;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ScannerStateDirectivesPercentEnterIdentifier {
    pub percent_enter: crate::parol_ls_grammar::OwnedToken, /* %enter */
    pub identifier: Identifier,
}

///
/// Type derived for production 22
///
/// `ScannerStateDirectives: '%push' Identifier;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ScannerStateDirectivesPercentPushIdentifier {
    pub percent_push: crate::parol_ls_grammar::OwnedToken, /* %push */
    pub identifier: Identifier,
}

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

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

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

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

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

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

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

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

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

///
/// Type derived for production 44
///
/// `TokenLiteral: LiteralString;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TokenLiteralLiteralString {
    pub literal_string: LiteralString,
}

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

///
/// 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 {
    pub member_name: MemberName,
    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 83
///
/// `LookAheadGroup: PositiveLookahead;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LookAheadGroupPositiveLookahead {
    pub positive_lookahead: PositiveLookahead,
}

///
/// Type derived for production 84
///
/// `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 {
    CutOperator(ASTControlCutOperator),
    MemberNameASTControlOpt(ASTControlMemberNameASTControlOpt),
    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 {
    pub alternation_list: Vec<AlternationList>,
}

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

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

///
/// Type derived for non-terminal AlternationsList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AlternationsList {
    pub or: crate::parol_ls_grammar::OwnedToken, /* | */
    pub alternation: Alternation,
}

///
/// Type derived for non-terminal CutOperator
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CutOperator {
    pub cut_operator: crate::parol_ls_grammar::OwnedToken, /* ^ */
}

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

///
/// Type derived for non-terminal DoubleColon
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DoubleColon {
    pub double_colon: crate::parol_ls_grammar::OwnedToken, /* :: */
}

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

///
/// Type derived for non-terminal GrammarDefinition
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct GrammarDefinition {
    pub percent_percent: crate::parol_ls_grammar::OwnedToken, /* %% */
    pub production: Production,
    pub grammar_definition_list: Vec<GrammarDefinitionList>,
}

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

///
/// Type derived for non-terminal Group
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Group {
    pub l_paren: crate::parol_ls_grammar::OwnedToken, /* ( */
    pub alternations: Alternations,
    pub r_paren: crate::parol_ls_grammar::OwnedToken, /* ) */
}

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

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

///
/// Type derived for non-terminal IdentifierListList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct IdentifierListList {
    pub comma: crate::parol_ls_grammar::OwnedToken, /* , */
    pub identifier: Identifier,
}

///
/// Type derived for non-terminal LiteralString
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LiteralString {
    pub literal_string: crate::parol_ls_grammar::OwnedToken, /* '(\\.|[^'])*' */
}

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

///
/// 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 {
    pub identifier: Identifier,
}

///
/// Type derived for non-terminal NegativeLookahead
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct NegativeLookahead {
    pub negative_lookahead: crate::parol_ls_grammar::OwnedToken, /* ?! */
}

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

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

///
/// Type derived for non-terminal Optional
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Optional {
    pub l_bracket: crate::parol_ls_grammar::OwnedToken, /* [ */
    pub alternations: Alternations,
    pub r_bracket: crate::parol_ls_grammar::OwnedToken, /* ] */
}

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

///
/// Type derived for non-terminal PositiveLookahead
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct PositiveLookahead {
    pub positive_lookahead: crate::parol_ls_grammar::OwnedToken, /* ?= */
}

///
/// Type derived for non-terminal Production
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Production {
    pub production_l_h_s: ProductionLHS,
    pub alternations: Alternations,
    pub semicolon: crate::parol_ls_grammar::OwnedToken, /* ; */
}

///
/// Type derived for non-terminal ProductionLHS
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ProductionLHS {
    pub identifier: Identifier,
    pub colon: crate::parol_ls_grammar::OwnedToken, /* : */
}

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

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

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

///
/// Type derived for non-terminal Regex
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Regex {
    pub regex: crate::parol_ls_grammar::OwnedToken, /* /(\\.|[^\/])*\/ */
}

///
/// Type derived for non-terminal Repeat
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Repeat {
    pub l_brace: crate::parol_ls_grammar::OwnedToken, /* { */
    pub alternations: Alternations,
    pub r_brace: crate::parol_ls_grammar::OwnedToken, /* } */
}

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

///
/// Type derived for non-terminal ScannerState
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ScannerState {
    pub percent_scanner: crate::parol_ls_grammar::OwnedToken, /* %scanner */
    pub identifier: Identifier,
    pub l_brace: crate::parol_ls_grammar::OwnedToken, /* { */
    pub scanner_state_list: Vec<ScannerStateList>,
    pub r_brace: crate::parol_ls_grammar::OwnedToken, /* } */
}

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

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

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

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

///
/// Type derived for non-terminal StartDeclaration
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct StartDeclaration {
    pub percent_start: crate::parol_ls_grammar::OwnedToken, /* %start */
    pub identifier: Identifier,
}

///
/// Type derived for non-terminal String
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct String {
    pub string: crate::parol_ls_grammar::OwnedToken, /* "(\\.|[^"])*" */
}

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

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

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

///
/// Type derived for non-terminal TokenLiteral
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum TokenLiteral {
    String(TokenLiteralString),
    LiteralString(TokenLiteralLiteralString),
    Regex(TokenLiteralRegex),
}

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

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

///
/// Type derived for non-terminal UserTypeDeclaration
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct UserTypeDeclaration {
    pub colon: crate::parol_ls_grammar::OwnedToken, /* : */
    pub user_type_name: UserTypeName,
}

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

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

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

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

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

/// 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 ParolLsGrammarAuto<'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 ParolLsGrammarTrait,
    // Stack to construct the AST on it
    item_stack: Vec<ASTType>,
    // Just to hold the lifetime generated by parol
    phantom: PhantomData<&'t str>,
}

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

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

    #[allow(dead_code)]
    fn pop(&mut self, context: &str) -> Option<ASTType> {
        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:
    ///
    /// `ParolLs: Prolog GrammarDefinition;`
    ///
    #[parol_runtime::function_name::named]
    fn parol_ls(
        &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_ls_built = ParolLs {
            prolog,
            grammar_definition,
        };
        // Calling user action here
        self.user_grammar.parol_ls(&parol_ls_built)?;
        self.push(ASTType::ParolLs(parol_ls_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 };
        // 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" 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 percent_start = percent_start
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let identifier = pop_item!(self, identifier, Identifier, context);
        let start_declaration_built = StartDeclaration {
            percent_start,
            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" 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 percent_title = percent_title
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let string = pop_item!(self, string, String, context);
        let declaration_0_built = DeclarationPercentTitleString {
            percent_title,
            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" 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 percent_comment = percent_comment
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let string = pop_item!(self, string, String, context);
        let declaration_1_built = DeclarationPercentCommentString {
            percent_comment,
            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" Identifier "=" 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 percent_user_underscore_type = percent_user_underscore_type
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let equ = equ
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        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 {
            percent_user_underscore_type,
            identifier,
            equ,
            user_type_name,
        };
        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" Identifier@nt_name "=" 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 percent_nt_underscore_type = percent_nt_underscore_type
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let equ = equ
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        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 {
            percent_nt_underscore_type,
            nt_name,
            equ,
            nt_type,
        };
        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" 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 percent_t_underscore_type = percent_t_underscore_type
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let t_type = pop_item!(self, t_type, UserTypeName, context);
        let declaration_4_built = DeclarationPercentTUnderscoreTypeTType {
            percent_t_underscore_type,
            t_type,
        };
        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' LiteralString;`
    ///
    #[parol_runtime::function_name::named]
    fn declaration_5(
        &mut self,
        percent_grammar_underscore_type: &ParseTreeType<'t>,
        _literal_string: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let percent_grammar_underscore_type = percent_grammar_underscore_type
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let literal_string = pop_item!(self, literal_string, LiteralString, context);
        let declaration_5_built = DeclarationPercentGrammarUnderscoreTypeLiteralString {
            percent_grammar_underscore_type,
            literal_string,
        };
        let declaration_5_built =
            Declaration::PercentGrammarUnderscoreTypeLiteralString(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" 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 percent_line_underscore_comment = percent_line_underscore_comment
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let token_literal = pop_item!(self, token_literal, TokenLiteral, context);
        let scanner_directives_0_built =
            ScannerDirectivesPercentLineUnderscoreCommentTokenLiteral {
                percent_line_underscore_comment,
                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" 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 percent_block_underscore_comment = percent_block_underscore_comment
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        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 {
                percent_block_underscore_comment,
                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";`
    ///
    #[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 percent_auto_underscore_newline_underscore_off =
            percent_auto_underscore_newline_underscore_off
                .token()?
                .try_into()
                .map_err(parol_runtime::ParolError::UserError)?;
        let scanner_directives_2_built =
            ScannerDirectivesPercentAutoUnderscoreNewlineUnderscoreOff {
                percent_auto_underscore_newline_underscore_off,
            };
        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";`
    ///
    #[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 percent_auto_underscore_ws_underscore_off = percent_auto_underscore_ws_underscore_off
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let scanner_directives_3_built = ScannerDirectivesPercentAutoUnderscoreWsUnderscoreOff {
            percent_auto_underscore_ws_underscore_off,
        };
        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' 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 percent_skip = percent_skip
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let identifier_list = pop_item!(self, identifier_list, IdentifierList, context);
        let scanner_directives_4_built = ScannerDirectivesPercentSkipIdentifierList {
            percent_skip,
            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' 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 percent_on = percent_on
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        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 {
                percent_on,
                identifier_list,
                scanner_state_directives,
            };
        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";`
    ///
    #[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 percent_allow_underscore_unmatched = percent_allow_underscore_unmatched
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let scanner_directives_6_built = ScannerDirectivesPercentAllowUnderscoreUnmatched {
            percent_allow_underscore_unmatched,
        };
        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' 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 percent_enter = percent_enter
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let identifier = pop_item!(self, identifier, Identifier, context);
        let scanner_state_directives_0_built = ScannerStateDirectivesPercentEnterIdentifier {
            percent_enter,
            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' 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 percent_push = percent_push
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let identifier = pop_item!(self, identifier, Identifier, context);
        let scanner_state_directives_1_built = ScannerStateDirectivesPercentPushIdentifier {
            percent_push,
            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()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        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: "%%" 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 percent_percent = percent_percent
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        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 {
            percent_percent,
            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()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        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:
    ///
    /// `ProductionLHS: Identifier ":";`
    ///
    #[parol_runtime::function_name::named]
    fn production_l_h_s(
        &mut self,
        _identifier: &ParseTreeType<'t>,
        colon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let colon = colon
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let identifier = pop_item!(self, identifier, Identifier, context);
        let production_l_h_s_built = ProductionLHS { identifier, colon };
        // Calling user action here
        self.user_grammar
            .production_l_h_s(&production_l_h_s_built)?;
        self.push(ASTType::ProductionLHS(production_l_h_s_built), context);
        Ok(())
    }

    /// Semantic action for production 29:
    ///
    /// `Production: ProductionLHS Alternations ";";`
    ///
    #[parol_runtime::function_name::named]
    fn production(
        &mut self,
        _production_l_h_s: &ParseTreeType<'t>,
        _alternations: &ParseTreeType<'t>,
        semicolon: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let semicolon = semicolon
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let alternations = pop_item!(self, alternations, Alternations, context);
        let production_l_h_s = pop_item!(self, production_l_h_s, ProductionLHS, context);
        let production_built = Production {
            production_l_h_s,
            alternations,
            semicolon,
        };
        // Calling user action here
        self.user_grammar.production(&production_built)?;
        self.push(ASTType::Production(production_built), context);
        Ok(())
    }

    /// Semantic action for production 30:
    ///
    /// `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 31:
    ///
    /// `AlternationsList /* Vec<T>::Push */: '|' 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 or = or
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        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, or };
        // 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 32:
    ///
    /// `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 33:
    ///
    /// `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 34:
    ///
    /// `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 35:
    ///
    /// `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 36:
    ///
    /// `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 37:
    ///
    /// `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 38:
    ///
    /// `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 39:
    ///
    /// `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 40:
    ///
    /// `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 41:
    ///
    /// `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 42:
    ///
    /// `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 43:
    ///
    /// `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 44:
    ///
    /// `TokenLiteral: LiteralString;`
    ///
    #[parol_runtime::function_name::named]
    fn token_literal_1(&mut self, _literal_string: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let literal_string = pop_item!(self, literal_string, LiteralString, context);
        let token_literal_1_built = TokenLiteralLiteralString { literal_string };
        let token_literal_1_built = TokenLiteral::LiteralString(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 45:
    ///
    /// `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 46:
    ///
    /// `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 47:
    ///
    /// `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 48:
    ///
    /// `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 49:
    ///
    /// `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 50:
    ///
    /// `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 51:
    ///
    /// `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 52:
    ///
    /// `TokenWithStates: "<" IdentifierList ">" 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 l_t = l_t
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let g_t = g_t
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        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 {
            l_t,
            identifier_list,
            g_t,
            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 53:
    ///
    /// `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 54:
    ///
    /// `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 55:
    ///
    /// `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()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let r_paren = r_paren
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        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 56:
    ///
    /// `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()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let r_bracket = r_bracket
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        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 57:
    ///
    /// `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()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let r_brace = r_brace
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        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 58:
    ///
    /// `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 59:
    ///
    /// `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 60:
    ///
    /// `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 61:
    ///
    /// `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()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        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 62:
    ///
    /// `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()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        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 63:
    ///
    /// `LiteralString: /'(\\.|[^'])*'/;`
    ///
    #[parol_runtime::function_name::named]
    fn literal_string(&mut self, literal_string: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let literal_string = literal_string
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let literal_string_built = LiteralString { literal_string };
        // Calling user action here
        self.user_grammar.literal_string(&literal_string_built)?;
        self.push(ASTType::LiteralString(literal_string_built), context);
        Ok(())
    }

    /// Semantic action for production 64:
    ///
    /// `ScannerState: "%scanner" Identifier '{' ScannerStateList /* Vec */ '}';`
    ///
    #[parol_runtime::function_name::named]
    fn scanner_state(
        &mut self,
        percent_scanner: &ParseTreeType<'t>,
        _identifier: &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 percent_scanner = percent_scanner
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let l_brace = l_brace
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let r_brace = r_brace
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let scanner_state_list =
            pop_and_reverse_item!(self, scanner_state_list, ScannerStateList, context);
        let identifier = pop_item!(self, identifier, Identifier, context);
        let scanner_state_built = ScannerState {
            percent_scanner,
            identifier,
            l_brace,
            scanner_state_list,
            r_brace,
        };
        // 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 */: "," 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 comma = comma
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        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, comma };
        // 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: '^';`
    ///
    #[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 = cut_operator
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let cut_operator_built = CutOperator { cut_operator };
        // 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: ":" 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 colon = colon
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let user_type_name = pop_item!(self, user_type_name, UserTypeName, context);
        let user_type_declaration_built = UserTypeDeclaration {
            colon,
            user_type_name,
        };
        // 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 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);
        let double_colon = pop_item!(self, double_colon, DoubleColon, context);
        let user_type_name_list_0_built = UserTypeNameList {
            identifier,
            double_colon,
        };
        // 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:
    ///
    /// `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()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        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 82:
    ///
    /// `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 83:
    ///
    /// `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 84:
    ///
    /// `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 85:
    ///
    /// `PositiveLookahead: '?=';`
    ///
    #[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 = positive_lookahead
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let positive_lookahead_built = PositiveLookahead { positive_lookahead };
        // 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 86:
    ///
    /// `NegativeLookahead: '?!';`
    ///
    #[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 = negative_lookahead
            .token()?
            .try_into()
            .map_err(parol_runtime::ParolError::UserError)?;
        let negative_lookahead_built = NegativeLookahead { negative_lookahead };
        // 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 ParolLsGrammarAuto<'t, '_> {
    ///
    /// This function is implemented automatically for the user's item ParolLsGrammar.
    ///
    fn call_semantic_action_for_production_number(
        &mut self,
        prod_num: usize,
        children: &[ParseTreeType<'t>],
    ) -> Result<()> {
        match prod_num {
            0 => self.parol_ls(&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_l_h_s(&children[0], &children[1]),
            29 => self.production(&children[0], &children[1], &children[2]),
            30 => self.alternations(&children[0], &children[1]),
            31 => self.alternations_list_0(&children[0], &children[1], &children[2]),
            32 => self.alternations_list_1(),
            33 => self.alternation(&children[0]),
            34 => self.alternation_list_0(&children[0], &children[1]),
            35 => self.alternation_list_1(),
            36 => self.factor_0(&children[0]),
            37 => self.factor_1(&children[0]),
            38 => self.factor_2(&children[0]),
            39 => self.factor_3(&children[0]),
            40 => self.symbol_0(&children[0]),
            41 => self.symbol_1(&children[0]),
            42 => self.symbol_2(&children[0]),
            43 => self.token_literal_0(&children[0]),
            44 => self.token_literal_1(&children[0]),
            45 => self.token_literal_2(&children[0]),
            46 => self.token_expression(&children[0], &children[1]),
            47 => self.token_expression_opt_0(&children[0]),
            48 => self.token_expression_opt_1(),
            49 => self.simple_token(&children[0], &children[1]),
            50 => self.simple_token_opt_0(&children[0]),
            51 => self.simple_token_opt_1(),
            52 => self.token_with_states(
                &children[0],
                &children[1],
                &children[2],
                &children[3],
                &children[4],
            ),
            53 => self.token_with_states_opt_0(&children[0]),
            54 => self.token_with_states_opt_1(),
            55 => self.group(&children[0], &children[1], &children[2]),
            56 => self.optional(&children[0], &children[1], &children[2]),
            57 => self.repeat(&children[0], &children[1], &children[2]),
            58 => self.non_terminal(&children[0], &children[1]),
            59 => self.non_terminal_opt_0(&children[0]),
            60 => self.non_terminal_opt_1(),
            61 => self.identifier(&children[0]),
            62 => self.string(&children[0]),
            63 => self.literal_string(&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.regex(&children[0]),
            82 => self.look_ahead(&children[0], &children[1]),
            83 => self.look_ahead_group_0(&children[0]),
            84 => self.look_ahead_group_1(&children[0]),
            85 => self.positive_lookahead(&children[0]),
            86 => 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)
    }
}