eure_parol/

grammar_trait.rs

// ---------------------------------------------------------
// 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 parol_runtime::{Span, ToSpan};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

///
/// Type derived for production 7
///
/// `TopLevelBinding: ValueBinding;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TopLevelBindingValueBinding<'t> {
    pub value_binding: ValueBinding<'t>,
}

impl ToSpan for TopLevelBindingValueBinding<'_> {
    fn span(&self) -> Span {
        self.value_binding.span()
    }
}

///
/// Type derived for production 8
///
/// `TopLevelBinding: TextBinding;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TopLevelBindingTextBinding<'t> {
    pub text_binding: TextBinding<'t>,
}

impl ToSpan for TopLevelBindingTextBinding<'_> {
    fn span(&self) -> Span {
        self.text_binding.span()
    }
}

///
/// Type derived for production 9
///
/// `RootBinding: RootValueBinding;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RootBindingRootValueBinding<'t> {
    pub root_value_binding: RootValueBinding<'t>,
}

impl ToSpan for RootBindingRootValueBinding<'_> {
    fn span(&self) -> Span {
        self.root_value_binding.span()
    }
}

///
/// Type derived for production 10
///
/// `RootBinding: RootTextBinding;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RootBindingRootTextBinding<'t> {
    pub root_text_binding: RootTextBinding<'t>,
}

impl ToSpan for RootBindingRootTextBinding<'_> {
    fn span(&self) -> Span {
        self.root_text_binding.span()
    }
}

///
/// Type derived for production 20
///
/// `BindingRhs: ValueBinding;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BindingRhsValueBinding<'t> {
    pub value_binding: ValueBinding<'t>,
}

impl ToSpan for BindingRhsValueBinding<'_> {
    fn span(&self) -> Span {
        self.value_binding.span()
    }
}

///
/// Type derived for production 21
///
/// `BindingRhs: SectionBinding;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BindingRhsSectionBinding<'t> {
    pub section_binding: SectionBinding<'t>,
}

impl ToSpan for BindingRhsSectionBinding<'_> {
    fn span(&self) -> Span {
        self.section_binding.span()
    }
}

///
/// Type derived for production 22
///
/// `BindingRhs: TextBinding;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BindingRhsTextBinding<'t> {
    pub text_binding: TextBinding<'t>,
}

impl ToSpan for BindingRhsTextBinding<'_> {
    fn span(&self) -> Span {
        self.text_binding.span()
    }
}

///
/// Type derived for production 33
///
/// `SectionBody: SectionBodyOpt /* Option */;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SectionBodySectionBodyOpt<'t> {
    pub section_body_opt: Option<SectionBodyOpt<'t>>,
}

impl ToSpan for SectionBodySectionBodyOpt<'_> {
    fn span(&self) -> Span {
        self.section_body_opt
            .as_ref()
            .map_or(Span::default(), |o| o.span())
    }
}

///
/// Type derived for production 34
///
/// `SectionBody: BlockBody;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SectionBodyBlockBody<'t> {
    pub block_body: BlockBody<'t>,
}

impl ToSpan for SectionBodyBlockBody<'_> {
    fn span(&self) -> Span {
        self.block_body.span()
    }
}

///
/// Type derived for production 40
///
/// `SectionHead: RootBinding;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SectionHeadRootBinding<'t> {
    pub root_binding: RootBinding<'t>,
}

impl ToSpan for SectionHeadRootBinding<'_> {
    fn span(&self) -> Span {
        self.root_binding.span()
    }
}

///
/// Type derived for production 41
///
/// `SectionHead: NewlineHead;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SectionHeadNewlineHead<'t> {
    pub newline_head: NewlineHead<'t>,
}

impl ToSpan for SectionHeadNewlineHead<'_> {
    fn span(&self) -> Span {
        self.newline_head.span()
    }
}

///
/// Type derived for production 45
///
/// `FlatRootBinding: ValueBinding;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct FlatRootBindingValueBinding<'t> {
    pub value_binding: ValueBinding<'t>,
}

impl ToSpan for FlatRootBindingValueBinding<'_> {
    fn span(&self) -> Span {
        self.value_binding.span()
    }
}

///
/// Type derived for production 46
///
/// `FlatRootBinding: TextBinding;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct FlatRootBindingTextBinding<'t> {
    pub text_binding: TextBinding<'t>,
}

impl ToSpan for FlatRootBindingTextBinding<'_> {
    fn span(&self) -> Span {
        self.text_binding.span()
    }
}

///
/// Type derived for production 51
///
/// `FirstKey: Key;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct FirstKeyKey<'t> {
    pub key: Key<'t>,
}

impl ToSpan for FirstKeyKey<'_> {
    fn span(&self) -> Span {
        self.key.span()
    }
}

///
/// Type derived for production 52
///
/// `FirstKey: ArrayMarker;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct FirstKeyArrayMarker<'t> {
    pub array_marker: ArrayMarker<'t>,
}

impl ToSpan for FirstKeyArrayMarker<'_> {
    fn span(&self) -> Span {
        self.array_marker.span()
    }
}

///
/// Type derived for production 53
///
/// `KeyTail: DotKey;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyTailDotKey<'t> {
    pub dot_key: DotKey<'t>,
}

impl ToSpan for KeyTailDotKey<'_> {
    fn span(&self) -> Span {
        self.dot_key.span()
    }
}

///
/// Type derived for production 54
///
/// `KeyTail: ArrayMarker;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyTailArrayMarker<'t> {
    pub array_marker: ArrayMarker<'t>,
}

impl ToSpan for KeyTailArrayMarker<'_> {
    fn span(&self) -> Span {
        self.array_marker.span()
    }
}

///
/// Type derived for production 58
///
/// `ArrayMarkerOptGroup: Integer;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ArrayMarkerOptGroupInteger<'t> {
    pub integer: Integer<'t>,
}

impl ToSpan for ArrayMarkerOptGroupInteger<'_> {
    fn span(&self) -> Span {
        self.integer.span()
    }
}

///
/// Type derived for production 59
///
/// `ArrayMarkerOptGroup: Caret;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ArrayMarkerOptGroupCaret<'t> {
    pub caret: Caret<'t>,
}

impl ToSpan for ArrayMarkerOptGroupCaret<'_> {
    fn span(&self) -> Span {
        self.caret.span()
    }
}

///
/// Type derived for production 61
///
/// `Key: KeyIdent;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyKeyIdent<'t> {
    pub key_ident: KeyIdent<'t>,
}

impl ToSpan for KeyKeyIdent<'_> {
    fn span(&self) -> Span {
        self.key_ident.span()
    }
}

///
/// Type derived for production 62
///
/// `Key: ExtensionNameSpace;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyExtensionNameSpace<'t> {
    pub extension_name_space: ExtensionNameSpace<'t>,
}

impl ToSpan for KeyExtensionNameSpace<'_> {
    fn span(&self) -> Span {
        self.extension_name_space.span()
    }
}

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

impl ToSpan for KeyString<'_> {
    fn span(&self) -> Span {
        self.string.span()
    }
}

///
/// Type derived for production 64
///
/// `Key: Integer;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyInteger<'t> {
    pub integer: Integer<'t>,
}

impl ToSpan for KeyInteger<'_> {
    fn span(&self) -> Span {
        self.integer.span()
    }
}

///
/// Type derived for production 65
///
/// `Key: Float;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyFloat<'t> {
    pub float: Float<'t>,
}

impl ToSpan for KeyFloat<'_> {
    fn span(&self) -> Span {
        self.float.span()
    }
}

///
/// Type derived for production 66
///
/// `Key: KeyTuple;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyKeyTuple<'t> {
    pub key_tuple: KeyTuple<'t>,
}

impl ToSpan for KeyKeyTuple<'_> {
    fn span(&self) -> Span {
        self.key_tuple.span()
    }
}

///
/// Type derived for production 67
///
/// `Key: TupleIndex;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyTupleIndex<'t> {
    pub tuple_index: TupleIndex<'t>,
}

impl ToSpan for KeyTupleIndex<'_> {
    fn span(&self) -> Span {
        self.tuple_index.span()
    }
}

///
/// Type derived for production 68
///
/// `Key: Hole;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyHole<'t> {
    pub hole: Hole<'t>,
}

impl ToSpan for KeyHole<'_> {
    fn span(&self) -> Span {
        self.hole.span()
    }
}

///
/// Type derived for production 80
///
/// `KeyValue: Integer;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyValueInteger<'t> {
    pub integer: Integer<'t>,
}

impl ToSpan for KeyValueInteger<'_> {
    fn span(&self) -> Span {
        self.integer.span()
    }
}

///
/// Type derived for production 81
///
/// `KeyValue: Boolean;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyValueBoolean<'t> {
    pub boolean: Boolean<'t>,
}

impl ToSpan for KeyValueBoolean<'_> {
    fn span(&self) -> Span {
        self.boolean.span()
    }
}

///
/// Type derived for production 82
///
/// `KeyValue: Str;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyValueStr<'t> {
    pub str: Str<'t>,
}

impl ToSpan for KeyValueStr<'_> {
    fn span(&self) -> Span {
        self.str.span()
    }
}

///
/// Type derived for production 83
///
/// `KeyValue: KeyTuple;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyValueKeyTuple<'t> {
    pub key_tuple: Box<KeyTuple<'t>>,
}

impl ToSpan for KeyValueKeyTuple<'_> {
    fn span(&self) -> Span {
        self.key_tuple.span()
    }
}

///
/// Type derived for production 84
///
/// `KeyValue: Hole;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyValueHole<'t> {
    pub hole: Hole<'t>,
}

impl ToSpan for KeyValueHole<'_> {
    fn span(&self) -> Span {
        self.hole.span()
    }
}

///
/// Type derived for production 85
///
/// `KeyIdent: Ident;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyIdentIdent<'t> {
    pub ident: Ident<'t>,
}

impl ToSpan for KeyIdentIdent<'_> {
    fn span(&self) -> Span {
        self.ident.span()
    }
}

///
/// Type derived for production 86
///
/// `KeyIdent: True;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyIdentTrue<'t> {
    pub r#true: True<'t>,
}

impl ToSpan for KeyIdentTrue<'_> {
    fn span(&self) -> Span {
        self.r#true.span()
    }
}

///
/// Type derived for production 87
///
/// `KeyIdent: False;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyIdentFalse<'t> {
    pub r#false: False<'t>,
}

impl ToSpan for KeyIdentFalse<'_> {
    fn span(&self) -> Span {
        self.r#false.span()
    }
}

///
/// Type derived for production 88
///
/// `KeyIdent: Null;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyIdentNull<'t> {
    pub null: Null<'t>,
}

impl ToSpan for KeyIdentNull<'_> {
    fn span(&self) -> Span {
        self.null.span()
    }
}

///
/// Type derived for production 89
///
/// `Value: Object;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ValueObject<'t> {
    pub object: Box<Object<'t>>,
}

impl ToSpan for ValueObject<'_> {
    fn span(&self) -> Span {
        self.object.span()
    }
}

///
/// Type derived for production 90
///
/// `Value: Array;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ValueArray<'t> {
    pub array: Box<Array<'t>>,
}

impl ToSpan for ValueArray<'_> {
    fn span(&self) -> Span {
        self.array.span()
    }
}

///
/// Type derived for production 91
///
/// `Value: Tuple;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ValueTuple<'t> {
    pub tuple: Box<Tuple<'t>>,
}

impl ToSpan for ValueTuple<'_> {
    fn span(&self) -> Span {
        self.tuple.span()
    }
}

///
/// Type derived for production 92
///
/// `Value: Number;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ValueNumber<'t> {
    pub number: Number<'t>,
}

impl ToSpan for ValueNumber<'_> {
    fn span(&self) -> Span {
        self.number.span()
    }
}

///
/// Type derived for production 93
///
/// `Value: Boolean;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ValueBoolean<'t> {
    pub boolean: Boolean<'t>,
}

impl ToSpan for ValueBoolean<'_> {
    fn span(&self) -> Span {
        self.boolean.span()
    }
}

///
/// Type derived for production 94
///
/// `Value: Null;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ValueNull<'t> {
    pub null: Null<'t>,
}

impl ToSpan for ValueNull<'_> {
    fn span(&self) -> Span {
        self.null.span()
    }
}

///
/// Type derived for production 95
///
/// `Value: Strings;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ValueStrings<'t> {
    pub strings: Strings<'t>,
}

impl ToSpan for ValueStrings<'_> {
    fn span(&self) -> Span {
        self.strings.span()
    }
}

///
/// Type derived for production 96
///
/// `Value: Hole;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ValueHole<'t> {
    pub hole: Hole<'t>,
}

impl ToSpan for ValueHole<'_> {
    fn span(&self) -> Span {
        self.hole.span()
    }
}

///
/// Type derived for production 97
///
/// `Value: CodeBlock;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ValueCodeBlock<'t> {
    pub code_block: CodeBlock<'t>,
}

impl ToSpan for ValueCodeBlock<'_> {
    fn span(&self) -> Span {
        self.code_block.span()
    }
}

///
/// Type derived for production 98
///
/// `Value: InlineCode;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ValueInlineCode<'t> {
    pub inline_code: InlineCode<'t>,
}

impl ToSpan for ValueInlineCode<'_> {
    fn span(&self) -> Span {
        self.inline_code.span()
    }
}

///
/// Type derived for production 127
///
/// `Number: Float;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct NumberFloat<'t> {
    pub float: Float<'t>,
}

impl ToSpan for NumberFloat<'_> {
    fn span(&self) -> Span {
        self.float.span()
    }
}

///
/// Type derived for production 128
///
/// `Number: Integer;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct NumberInteger<'t> {
    pub integer: Integer<'t>,
}

impl ToSpan for NumberInteger<'_> {
    fn span(&self) -> Span {
        self.integer.span()
    }
}

///
/// Type derived for production 129
///
/// `Number: Inf;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct NumberInf<'t> {
    pub inf: Inf<'t>,
}

impl ToSpan for NumberInf<'_> {
    fn span(&self) -> Span {
        self.inf.span()
    }
}

///
/// Type derived for production 130
///
/// `Number: NaN;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct NumberNaN<'t> {
    pub na_n: NaN<'t>,
}

impl ToSpan for NumberNaN<'_> {
    fn span(&self) -> Span {
        self.na_n.span()
    }
}

///
/// Type derived for production 135
///
/// `Boolean: True;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BooleanTrue<'t> {
    pub r#true: True<'t>,
}

impl ToSpan for BooleanTrue<'_> {
    fn span(&self) -> Span {
        self.r#true.span()
    }
}

///
/// Type derived for production 136
///
/// `Boolean: False;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BooleanFalse<'t> {
    pub r#false: False<'t>,
}

impl ToSpan for BooleanFalse<'_> {
    fn span(&self) -> Span {
        self.r#false.span()
    }
}

///
/// Type derived for production 141
///
/// `String: Str;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct StringStr<'t> {
    pub str: Str<'t>,
}

impl ToSpan for StringStr<'_> {
    fn span(&self) -> Span {
        self.str.span()
    }
}

///
/// Type derived for production 142
///
/// `String: LitStr;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct StringLitStr<'t> {
    pub lit_str: LitStr<'t>,
}

impl ToSpan for StringLitStr<'_> {
    fn span(&self) -> Span {
        self.lit_str.span()
    }
}

///
/// Type derived for production 143
///
/// `String: LitStr1;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct StringLitStr1<'t> {
    pub lit_str1: LitStr1<'t>,
}

impl ToSpan for StringLitStr1<'_> {
    fn span(&self) -> Span {
        self.lit_str1.span()
    }
}

///
/// Type derived for production 144
///
/// `String: LitStr2;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct StringLitStr2<'t> {
    pub lit_str2: LitStr2<'t>,
}

impl ToSpan for StringLitStr2<'_> {
    fn span(&self) -> Span {
        self.lit_str2.span()
    }
}

///
/// Type derived for production 145
///
/// `String: LitStr3;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct StringLitStr3<'t> {
    pub lit_str3: LitStr3<'t>,
}

impl ToSpan for StringLitStr3<'_> {
    fn span(&self) -> Span {
        self.lit_str3.span()
    }
}

///
/// Type derived for production 152
///
/// `InlineCode: DelimCode;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct InlineCodeDelimCode<'t> {
    pub delim_code: DelimCode<'t>,
}

impl ToSpan for InlineCodeDelimCode<'_> {
    fn span(&self) -> Span {
        self.delim_code.span()
    }
}

///
/// Type derived for production 153
///
/// `InlineCode: InlineCode1;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct InlineCodeInlineCode1<'t> {
    pub inline_code1: InlineCode1<'t>,
}

impl ToSpan for InlineCodeInlineCode1<'_> {
    fn span(&self) -> Span {
        self.inline_code1.span()
    }
}

///
/// Type derived for production 157
///
/// `LitStr1ListGroup: NoSQuote;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LitStr1ListGroupNoSQuote<'t> {
    pub no_s_quote: NoSQuote<'t>,
}

impl ToSpan for LitStr1ListGroupNoSQuote<'_> {
    fn span(&self) -> Span {
        self.no_s_quote.span()
    }
}

///
/// Type derived for production 158
///
/// `LitStr1ListGroup: SQuote;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LitStr1ListGroupSQuote<'t> {
    pub s_quote: SQuote<'t>,
}

impl ToSpan for LitStr1ListGroupSQuote<'_> {
    fn span(&self) -> Span {
        self.s_quote.span()
    }
}

///
/// Type derived for production 162
///
/// `LitStr2ListGroup: NoSQuote;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LitStr2ListGroupNoSQuote<'t> {
    pub no_s_quote: NoSQuote<'t>,
}

impl ToSpan for LitStr2ListGroupNoSQuote<'_> {
    fn span(&self) -> Span {
        self.no_s_quote.span()
    }
}

///
/// Type derived for production 163
///
/// `LitStr2ListGroup: SQuote;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LitStr2ListGroupSQuote<'t> {
    pub s_quote: SQuote<'t>,
}

impl ToSpan for LitStr2ListGroupSQuote<'_> {
    fn span(&self) -> Span {
        self.s_quote.span()
    }
}

///
/// Type derived for production 167
///
/// `LitStr3ListGroup: NoSQuote;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LitStr3ListGroupNoSQuote<'t> {
    pub no_s_quote: NoSQuote<'t>,
}

impl ToSpan for LitStr3ListGroupNoSQuote<'_> {
    fn span(&self) -> Span {
        self.no_s_quote.span()
    }
}

///
/// Type derived for production 168
///
/// `LitStr3ListGroup: SQuote;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LitStr3ListGroupSQuote<'t> {
    pub s_quote: SQuote<'t>,
}

impl ToSpan for LitStr3ListGroupSQuote<'_> {
    fn span(&self) -> Span {
        self.s_quote.span()
    }
}

///
/// Type derived for production 170
///
/// `DelimCode: DelimCode3;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DelimCodeDelimCode3<'t> {
    pub delim_code3: DelimCode3<'t>,
}

impl ToSpan for DelimCodeDelimCode3<'_> {
    fn span(&self) -> Span {
        self.delim_code3.span()
    }
}

///
/// Type derived for production 171
///
/// `DelimCode: DelimCode2;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DelimCodeDelimCode2<'t> {
    pub delim_code2: DelimCode2<'t>,
}

impl ToSpan for DelimCodeDelimCode2<'_> {
    fn span(&self) -> Span {
        self.delim_code2.span()
    }
}

///
/// Type derived for production 172
///
/// `DelimCode: DelimCode1;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DelimCodeDelimCode1<'t> {
    pub delim_code1: DelimCode1<'t>,
}

impl ToSpan for DelimCodeDelimCode1<'_> {
    fn span(&self) -> Span {
        self.delim_code1.span()
    }
}

///
/// Type derived for production 175
///
/// `DelimCode1ListGroup: NoBacktick;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DelimCode1ListGroupNoBacktick<'t> {
    pub no_backtick: NoBacktick<'t>,
}

impl ToSpan for DelimCode1ListGroupNoBacktick<'_> {
    fn span(&self) -> Span {
        self.no_backtick.span()
    }
}

///
/// Type derived for production 176
///
/// `DelimCode1ListGroup: BacktickDelim;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DelimCode1ListGroupBacktickDelim<'t> {
    pub backtick_delim: BacktickDelim<'t>,
}

impl ToSpan for DelimCode1ListGroupBacktickDelim<'_> {
    fn span(&self) -> Span {
        self.backtick_delim.span()
    }
}

///
/// Type derived for production 180
///
/// `DelimCode2ListGroup: NoBacktick;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DelimCode2ListGroupNoBacktick<'t> {
    pub no_backtick: NoBacktick<'t>,
}

impl ToSpan for DelimCode2ListGroupNoBacktick<'_> {
    fn span(&self) -> Span {
        self.no_backtick.span()
    }
}

///
/// Type derived for production 181
///
/// `DelimCode2ListGroup: BacktickDelim;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DelimCode2ListGroupBacktickDelim<'t> {
    pub backtick_delim: BacktickDelim<'t>,
}

impl ToSpan for DelimCode2ListGroupBacktickDelim<'_> {
    fn span(&self) -> Span {
        self.backtick_delim.span()
    }
}

///
/// Type derived for production 185
///
/// `DelimCode3ListGroup: NoBacktick;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DelimCode3ListGroupNoBacktick<'t> {
    pub no_backtick: NoBacktick<'t>,
}

impl ToSpan for DelimCode3ListGroupNoBacktick<'_> {
    fn span(&self) -> Span {
        self.no_backtick.span()
    }
}

///
/// Type derived for production 186
///
/// `DelimCode3ListGroup: BacktickDelim;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DelimCode3ListGroupBacktickDelim<'t> {
    pub backtick_delim: BacktickDelim<'t>,
}

impl ToSpan for DelimCode3ListGroupBacktickDelim<'_> {
    fn span(&self) -> Span {
        self.backtick_delim.span()
    }
}

///
/// Type derived for production 188
///
/// `CodeBlock: CodeBlock3;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CodeBlockCodeBlock3<'t> {
    pub code_block3: CodeBlock3<'t>,
}

impl ToSpan for CodeBlockCodeBlock3<'_> {
    fn span(&self) -> Span {
        self.code_block3.span()
    }
}

///
/// Type derived for production 189
///
/// `CodeBlock: CodeBlock4;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CodeBlockCodeBlock4<'t> {
    pub code_block4: CodeBlock4<'t>,
}

impl ToSpan for CodeBlockCodeBlock4<'_> {
    fn span(&self) -> Span {
        self.code_block4.span()
    }
}

///
/// Type derived for production 190
///
/// `CodeBlock: CodeBlock5;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CodeBlockCodeBlock5<'t> {
    pub code_block5: CodeBlock5<'t>,
}

impl ToSpan for CodeBlockCodeBlock5<'_> {
    fn span(&self) -> Span {
        self.code_block5.span()
    }
}

///
/// Type derived for production 191
///
/// `CodeBlock: CodeBlock6;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CodeBlockCodeBlock6<'t> {
    pub code_block6: CodeBlock6<'t>,
}

impl ToSpan for CodeBlockCodeBlock6<'_> {
    fn span(&self) -> Span {
        self.code_block6.span()
    }
}

///
/// Type derived for production 194
///
/// `CodeBlock3ListGroup: NoBacktick;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CodeBlock3ListGroupNoBacktick<'t> {
    pub no_backtick: NoBacktick<'t>,
}

impl ToSpan for CodeBlock3ListGroupNoBacktick<'_> {
    fn span(&self) -> Span {
        self.no_backtick.span()
    }
}

///
/// Type derived for production 195
///
/// `CodeBlock3ListGroup: Backtick2;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CodeBlock3ListGroupBacktick2<'t> {
    pub backtick2: Backtick2<'t>,
}

impl ToSpan for CodeBlock3ListGroupBacktick2<'_> {
    fn span(&self) -> Span {
        self.backtick2.span()
    }
}

///
/// Type derived for production 199
///
/// `CodeBlock4ListGroup: NoBacktick;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CodeBlock4ListGroupNoBacktick<'t> {
    pub no_backtick: NoBacktick<'t>,
}

impl ToSpan for CodeBlock4ListGroupNoBacktick<'_> {
    fn span(&self) -> Span {
        self.no_backtick.span()
    }
}

///
/// Type derived for production 200
///
/// `CodeBlock4ListGroup: Backtick3;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CodeBlock4ListGroupBacktick3<'t> {
    pub backtick3: Backtick3<'t>,
}

impl ToSpan for CodeBlock4ListGroupBacktick3<'_> {
    fn span(&self) -> Span {
        self.backtick3.span()
    }
}

///
/// Type derived for production 204
///
/// `CodeBlock5ListGroup: NoBacktick;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CodeBlock5ListGroupNoBacktick<'t> {
    pub no_backtick: NoBacktick<'t>,
}

impl ToSpan for CodeBlock5ListGroupNoBacktick<'_> {
    fn span(&self) -> Span {
        self.no_backtick.span()
    }
}

///
/// Type derived for production 205
///
/// `CodeBlock5ListGroup: Backtick4;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CodeBlock5ListGroupBacktick4<'t> {
    pub backtick4: Backtick4<'t>,
}

impl ToSpan for CodeBlock5ListGroupBacktick4<'_> {
    fn span(&self) -> Span {
        self.backtick4.span()
    }
}

///
/// Type derived for production 209
///
/// `CodeBlock6ListGroup: NoBacktick;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CodeBlock6ListGroupNoBacktick<'t> {
    pub no_backtick: NoBacktick<'t>,
}

impl ToSpan for CodeBlock6ListGroupNoBacktick<'_> {
    fn span(&self) -> Span {
        self.no_backtick.span()
    }
}

///
/// Type derived for production 210
///
/// `CodeBlock6ListGroup: Backtick5;`
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CodeBlock6ListGroupBacktick5<'t> {
    pub backtick5: Backtick5<'t>,
}

impl ToSpan for CodeBlock6ListGroupBacktick5<'_> {
    fn span(&self) -> Span {
        self.backtick5.span()
    }
}

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

///
/// Type derived for non-terminal Array
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Array<'t> {
    pub array_begin: ArrayBegin<'t>,
    pub array_opt: Option<ArrayOpt<'t>>,
    pub array_end: ArrayEnd<'t>,
}

impl ToSpan for Array<'_> {
    fn span(&self) -> Span {
        self.array_begin.span()
            + self
                .array_opt
                .as_ref()
                .map_or(Span::default(), |o| o.span())
            + self.array_end.span()
    }
}

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

impl ToSpan for ArrayBegin<'_> {
    fn span(&self) -> Span {
        self.array_begin.span()
    }
}

///
/// Type derived for non-terminal ArrayElements
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ArrayElements<'t> {
    pub value: Value<'t>,
    pub array_elements_opt: Option<Box<ArrayElementsOpt<'t>>>,
}

impl ToSpan for ArrayElements<'_> {
    fn span(&self) -> Span {
        self.value.span()
            + self
                .array_elements_opt
                .as_ref()
                .map_or(Span::default(), |o| o.span())
    }
}

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

impl ToSpan for ArrayElementsOpt<'_> {
    fn span(&self) -> Span {
        self.array_elements_tail.span()
    }
}

///
/// Type derived for non-terminal ArrayElementsTail
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ArrayElementsTail<'t> {
    pub comma: Comma<'t>,
    pub array_elements_tail_opt: Option<ArrayElementsTailOpt<'t>>,
}

impl ToSpan for ArrayElementsTail<'_> {
    fn span(&self) -> Span {
        self.comma.span()
            + self
                .array_elements_tail_opt
                .as_ref()
                .map_or(Span::default(), |o| o.span())
    }
}

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

impl ToSpan for ArrayElementsTailOpt<'_> {
    fn span(&self) -> Span {
        self.array_elements.span()
    }
}

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

impl ToSpan for ArrayEnd<'_> {
    fn span(&self) -> Span {
        self.array_end.span()
    }
}

///
/// Type derived for non-terminal ArrayMarker
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ArrayMarker<'t> {
    pub array_begin: ArrayBegin<'t>,
    pub array_marker_opt: Option<ArrayMarkerOpt<'t>>,
    pub array_end: ArrayEnd<'t>,
}

impl ToSpan for ArrayMarker<'_> {
    fn span(&self) -> Span {
        self.array_begin.span()
            + self
                .array_marker_opt
                .as_ref()
                .map_or(Span::default(), |o| o.span())
            + self.array_end.span()
    }
}

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

impl ToSpan for ArrayMarkerOpt<'_> {
    fn span(&self) -> Span {
        self.array_marker_opt_group.span()
    }
}

///
/// Type derived for non-terminal ArrayMarkerOptGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum ArrayMarkerOptGroup<'t> {
    Integer(ArrayMarkerOptGroupInteger<'t>),
    Caret(ArrayMarkerOptGroupCaret<'t>),
}

impl ToSpan for ArrayMarkerOptGroup<'_> {
    fn span(&self) -> Span {
        match self {
            ArrayMarkerOptGroup::Integer(v) => v.span(),
            ArrayMarkerOptGroup::Caret(v) => v.span(),
        }
    }
}

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

impl ToSpan for ArrayOpt<'_> {
    fn span(&self) -> Span {
        self.array_elements.span()
    }
}

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

impl ToSpan for At<'_> {
    fn span(&self) -> Span {
        self.at.span()
    }
}

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

impl ToSpan for Backtick2<'_> {
    fn span(&self) -> Span {
        self.backtick2.span()
    }
}

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

impl ToSpan for Backtick3<'_> {
    fn span(&self) -> Span {
        self.backtick3.span()
    }
}

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

impl ToSpan for Backtick4<'_> {
    fn span(&self) -> Span {
        self.backtick4.span()
    }
}

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

impl ToSpan for Backtick5<'_> {
    fn span(&self) -> Span {
        self.backtick5.span()
    }
}

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

impl ToSpan for BacktickDelim<'_> {
    fn span(&self) -> Span {
        self.backtick_delim.span()
    }
}

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

impl ToSpan for Begin<'_> {
    fn span(&self) -> Span {
        self.begin.span()
    }
}

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

impl ToSpan for Bind<'_> {
    fn span(&self) -> Span {
        self.bind.span()
    }
}

///
/// Type derived for non-terminal Binding
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Binding<'t> {
    pub keys: Keys<'t>,
    pub binding_rhs: BindingRhs<'t>,
}

impl ToSpan for Binding<'_> {
    fn span(&self) -> Span {
        self.keys.span() + self.binding_rhs.span()
    }
}

///
/// Type derived for non-terminal BindingRhs
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum BindingRhs<'t> {
    ValueBinding(BindingRhsValueBinding<'t>),
    SectionBinding(BindingRhsSectionBinding<'t>),
    TextBinding(BindingRhsTextBinding<'t>),
}

impl ToSpan for BindingRhs<'_> {
    fn span(&self) -> Span {
        match self {
            BindingRhs::ValueBinding(v) => v.span(),
            BindingRhs::SectionBinding(v) => v.span(),
            BindingRhs::TextBinding(v) => v.span(),
        }
    }
}

///
/// Type derived for non-terminal BlockBody
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct BlockBody<'t> {
    pub begin: Begin<'t>,
    pub eure: Eure<'t>,
    pub end: End<'t>,
}

impl ToSpan for BlockBody<'_> {
    fn span(&self) -> Span {
        self.begin.span() + self.eure.span() + self.end.span()
    }
}

///
/// Type derived for non-terminal Boolean
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum Boolean<'t> {
    True(BooleanTrue<'t>),
    False(BooleanFalse<'t>),
}

impl ToSpan for Boolean<'_> {
    fn span(&self) -> Span {
        match self {
            Boolean::True(v) => v.span(),
            Boolean::False(v) => v.span(),
        }
    }
}

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

impl ToSpan for Caret<'_> {
    fn span(&self) -> Span {
        self.caret.span()
    }
}

///
/// Type derived for non-terminal CodeBlock
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum CodeBlock<'t> {
    CodeBlock3(CodeBlockCodeBlock3<'t>),
    CodeBlock4(CodeBlockCodeBlock4<'t>),
    CodeBlock5(CodeBlockCodeBlock5<'t>),
    CodeBlock6(CodeBlockCodeBlock6<'t>),
}

impl ToSpan for CodeBlock<'_> {
    fn span(&self) -> Span {
        match self {
            CodeBlock::CodeBlock3(v) => v.span(),
            CodeBlock::CodeBlock4(v) => v.span(),
            CodeBlock::CodeBlock5(v) => v.span(),
            CodeBlock::CodeBlock6(v) => v.span(),
        }
    }
}

///
/// Type derived for non-terminal CodeBlock3
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CodeBlock3<'t> {
    pub code_block_start3: CodeBlockStart3<'t>,
    pub code_block3_list: Vec<CodeBlock3List<'t>>,
    pub code_block_end3: CodeBlockEnd3<'t>,
}

impl ToSpan for CodeBlock3<'_> {
    fn span(&self) -> Span {
        self.code_block_start3.span()
            + self
                .code_block3_list
                .first()
                .map_or(Span::default(), |f| f.span())
            + self
                .code_block3_list
                .last()
                .map_or(Span::default(), |l| l.span())
            + self.code_block_end3.span()
    }
}

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

impl ToSpan for CodeBlock3List<'_> {
    fn span(&self) -> Span {
        self.code_block3_list_group.span()
    }
}

///
/// Type derived for non-terminal CodeBlock3ListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum CodeBlock3ListGroup<'t> {
    NoBacktick(CodeBlock3ListGroupNoBacktick<'t>),
    Backtick2(CodeBlock3ListGroupBacktick2<'t>),
}

impl ToSpan for CodeBlock3ListGroup<'_> {
    fn span(&self) -> Span {
        match self {
            CodeBlock3ListGroup::NoBacktick(v) => v.span(),
            CodeBlock3ListGroup::Backtick2(v) => v.span(),
        }
    }
}

///
/// Type derived for non-terminal CodeBlock4
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CodeBlock4<'t> {
    pub code_block_start4: CodeBlockStart4<'t>,
    pub code_block4_list: Vec<CodeBlock4List<'t>>,
    pub code_block_end4: CodeBlockEnd4<'t>,
}

impl ToSpan for CodeBlock4<'_> {
    fn span(&self) -> Span {
        self.code_block_start4.span()
            + self
                .code_block4_list
                .first()
                .map_or(Span::default(), |f| f.span())
            + self
                .code_block4_list
                .last()
                .map_or(Span::default(), |l| l.span())
            + self.code_block_end4.span()
    }
}

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

impl ToSpan for CodeBlock4List<'_> {
    fn span(&self) -> Span {
        self.code_block4_list_group.span()
    }
}

///
/// Type derived for non-terminal CodeBlock4ListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum CodeBlock4ListGroup<'t> {
    NoBacktick(CodeBlock4ListGroupNoBacktick<'t>),
    Backtick3(CodeBlock4ListGroupBacktick3<'t>),
}

impl ToSpan for CodeBlock4ListGroup<'_> {
    fn span(&self) -> Span {
        match self {
            CodeBlock4ListGroup::NoBacktick(v) => v.span(),
            CodeBlock4ListGroup::Backtick3(v) => v.span(),
        }
    }
}

///
/// Type derived for non-terminal CodeBlock5
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CodeBlock5<'t> {
    pub code_block_start5: CodeBlockStart5<'t>,
    pub code_block5_list: Vec<CodeBlock5List<'t>>,
    pub code_block_end5: CodeBlockEnd5<'t>,
}

impl ToSpan for CodeBlock5<'_> {
    fn span(&self) -> Span {
        self.code_block_start5.span()
            + self
                .code_block5_list
                .first()
                .map_or(Span::default(), |f| f.span())
            + self
                .code_block5_list
                .last()
                .map_or(Span::default(), |l| l.span())
            + self.code_block_end5.span()
    }
}

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

impl ToSpan for CodeBlock5List<'_> {
    fn span(&self) -> Span {
        self.code_block5_list_group.span()
    }
}

///
/// Type derived for non-terminal CodeBlock5ListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum CodeBlock5ListGroup<'t> {
    NoBacktick(CodeBlock5ListGroupNoBacktick<'t>),
    Backtick4(CodeBlock5ListGroupBacktick4<'t>),
}

impl ToSpan for CodeBlock5ListGroup<'_> {
    fn span(&self) -> Span {
        match self {
            CodeBlock5ListGroup::NoBacktick(v) => v.span(),
            CodeBlock5ListGroup::Backtick4(v) => v.span(),
        }
    }
}

///
/// Type derived for non-terminal CodeBlock6
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CodeBlock6<'t> {
    pub code_block_start6: CodeBlockStart6<'t>,
    pub code_block6_list: Vec<CodeBlock6List<'t>>,
    pub code_block_end6: CodeBlockEnd6<'t>,
}

impl ToSpan for CodeBlock6<'_> {
    fn span(&self) -> Span {
        self.code_block_start6.span()
            + self
                .code_block6_list
                .first()
                .map_or(Span::default(), |f| f.span())
            + self
                .code_block6_list
                .last()
                .map_or(Span::default(), |l| l.span())
            + self.code_block_end6.span()
    }
}

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

impl ToSpan for CodeBlock6List<'_> {
    fn span(&self) -> Span {
        self.code_block6_list_group.span()
    }
}

///
/// Type derived for non-terminal CodeBlock6ListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum CodeBlock6ListGroup<'t> {
    NoBacktick(CodeBlock6ListGroupNoBacktick<'t>),
    Backtick5(CodeBlock6ListGroupBacktick5<'t>),
}

impl ToSpan for CodeBlock6ListGroup<'_> {
    fn span(&self) -> Span {
        match self {
            CodeBlock6ListGroup::NoBacktick(v) => v.span(),
            CodeBlock6ListGroup::Backtick5(v) => v.span(),
        }
    }
}

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

impl ToSpan for CodeBlockEnd3<'_> {
    fn span(&self) -> Span {
        self.code_block_end3.span()
    }
}

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

impl ToSpan for CodeBlockEnd4<'_> {
    fn span(&self) -> Span {
        self.code_block_end4.span()
    }
}

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

impl ToSpan for CodeBlockEnd5<'_> {
    fn span(&self) -> Span {
        self.code_block_end5.span()
    }
}

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

impl ToSpan for CodeBlockEnd6<'_> {
    fn span(&self) -> Span {
        self.code_block_end6.span()
    }
}

///
/// Type derived for non-terminal CodeBlockStart3
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CodeBlockStart3<'t> {
    pub code_block_start3: Token<'t>, /* `{3}[a-zA-Z0-9-_]*[\s--\r\n]*(\r\n|\r|\n) */
}

impl ToSpan for CodeBlockStart3<'_> {
    fn span(&self) -> Span {
        self.code_block_start3.span()
    }
}

///
/// Type derived for non-terminal CodeBlockStart4
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CodeBlockStart4<'t> {
    pub code_block_start4: Token<'t>, /* `{4}[a-zA-Z0-9-_]*[\s--\r\n]*(\r\n|\r|\n) */
}

impl ToSpan for CodeBlockStart4<'_> {
    fn span(&self) -> Span {
        self.code_block_start4.span()
    }
}

///
/// Type derived for non-terminal CodeBlockStart5
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CodeBlockStart5<'t> {
    pub code_block_start5: Token<'t>, /* `{5}[a-zA-Z0-9-_]*[\s--\r\n]*(\r\n|\r|\n) */
}

impl ToSpan for CodeBlockStart5<'_> {
    fn span(&self) -> Span {
        self.code_block_start5.span()
    }
}

///
/// Type derived for non-terminal CodeBlockStart6
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct CodeBlockStart6<'t> {
    pub code_block_start6: Token<'t>, /* `{6}[a-zA-Z0-9-_]*[\s--\r\n]*(\r\n|\r|\n) */
}

impl ToSpan for CodeBlockStart6<'_> {
    fn span(&self) -> Span {
        self.code_block_start6.span()
    }
}

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

impl ToSpan for Comma<'_> {
    fn span(&self) -> Span {
        self.comma.span()
    }
}

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

impl ToSpan for Continue<'_> {
    fn span(&self) -> Span {
        self.r#continue.span()
    }
}

///
/// Type derived for non-terminal DelimCode
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum DelimCode<'t> {
    DelimCode3(DelimCodeDelimCode3<'t>),
    DelimCode2(DelimCodeDelimCode2<'t>),
    DelimCode1(DelimCodeDelimCode1<'t>),
}

impl ToSpan for DelimCode<'_> {
    fn span(&self) -> Span {
        match self {
            DelimCode::DelimCode3(v) => v.span(),
            DelimCode::DelimCode2(v) => v.span(),
            DelimCode::DelimCode1(v) => v.span(),
        }
    }
}

///
/// Type derived for non-terminal DelimCode1
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DelimCode1<'t> {
    pub delim_code_start1: DelimCodeStart1<'t>,
    pub delim_code1_list: Vec<DelimCode1List<'t>>,
    pub delim_code_end1: DelimCodeEnd1<'t>,
}

impl ToSpan for DelimCode1<'_> {
    fn span(&self) -> Span {
        self.delim_code_start1.span()
            + self
                .delim_code1_list
                .first()
                .map_or(Span::default(), |f| f.span())
            + self
                .delim_code1_list
                .last()
                .map_or(Span::default(), |l| l.span())
            + self.delim_code_end1.span()
    }
}

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

impl ToSpan for DelimCode1List<'_> {
    fn span(&self) -> Span {
        self.delim_code1_list_group.span()
    }
}

///
/// Type derived for non-terminal DelimCode1ListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum DelimCode1ListGroup<'t> {
    NoBacktick(DelimCode1ListGroupNoBacktick<'t>),
    BacktickDelim(DelimCode1ListGroupBacktickDelim<'t>),
}

impl ToSpan for DelimCode1ListGroup<'_> {
    fn span(&self) -> Span {
        match self {
            DelimCode1ListGroup::NoBacktick(v) => v.span(),
            DelimCode1ListGroup::BacktickDelim(v) => v.span(),
        }
    }
}

///
/// Type derived for non-terminal DelimCode2
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DelimCode2<'t> {
    pub delim_code_start2: DelimCodeStart2<'t>,
    pub delim_code2_list: Vec<DelimCode2List<'t>>,
    pub delim_code_end2: DelimCodeEnd2<'t>,
}

impl ToSpan for DelimCode2<'_> {
    fn span(&self) -> Span {
        self.delim_code_start2.span()
            + self
                .delim_code2_list
                .first()
                .map_or(Span::default(), |f| f.span())
            + self
                .delim_code2_list
                .last()
                .map_or(Span::default(), |l| l.span())
            + self.delim_code_end2.span()
    }
}

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

impl ToSpan for DelimCode2List<'_> {
    fn span(&self) -> Span {
        self.delim_code2_list_group.span()
    }
}

///
/// Type derived for non-terminal DelimCode2ListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum DelimCode2ListGroup<'t> {
    NoBacktick(DelimCode2ListGroupNoBacktick<'t>),
    BacktickDelim(DelimCode2ListGroupBacktickDelim<'t>),
}

impl ToSpan for DelimCode2ListGroup<'_> {
    fn span(&self) -> Span {
        match self {
            DelimCode2ListGroup::NoBacktick(v) => v.span(),
            DelimCode2ListGroup::BacktickDelim(v) => v.span(),
        }
    }
}

///
/// Type derived for non-terminal DelimCode3
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DelimCode3<'t> {
    pub delim_code_start3: DelimCodeStart3<'t>,
    pub delim_code3_list: Vec<DelimCode3List<'t>>,
    pub delim_code_end3: DelimCodeEnd3<'t>,
}

impl ToSpan for DelimCode3<'_> {
    fn span(&self) -> Span {
        self.delim_code_start3.span()
            + self
                .delim_code3_list
                .first()
                .map_or(Span::default(), |f| f.span())
            + self
                .delim_code3_list
                .last()
                .map_or(Span::default(), |l| l.span())
            + self.delim_code_end3.span()
    }
}

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

impl ToSpan for DelimCode3List<'_> {
    fn span(&self) -> Span {
        self.delim_code3_list_group.span()
    }
}

///
/// Type derived for non-terminal DelimCode3ListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum DelimCode3ListGroup<'t> {
    NoBacktick(DelimCode3ListGroupNoBacktick<'t>),
    BacktickDelim(DelimCode3ListGroupBacktickDelim<'t>),
}

impl ToSpan for DelimCode3ListGroup<'_> {
    fn span(&self) -> Span {
        match self {
            DelimCode3ListGroup::NoBacktick(v) => v.span(),
            DelimCode3ListGroup::BacktickDelim(v) => v.span(),
        }
    }
}

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

impl ToSpan for DelimCodeEnd1<'_> {
    fn span(&self) -> Span {
        self.delim_code_end1.span()
    }
}

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

impl ToSpan for DelimCodeEnd2<'_> {
    fn span(&self) -> Span {
        self.delim_code_end2.span()
    }
}

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

impl ToSpan for DelimCodeEnd3<'_> {
    fn span(&self) -> Span {
        self.delim_code_end3.span()
    }
}

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

impl ToSpan for DelimCodeStart1<'_> {
    fn span(&self) -> Span {
        self.delim_code_start1.span()
    }
}

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

impl ToSpan for DelimCodeStart2<'_> {
    fn span(&self) -> Span {
        self.delim_code_start2.span()
    }
}

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

impl ToSpan for DelimCodeStart3<'_> {
    fn span(&self) -> Span {
        self.delim_code_start3.span()
    }
}

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

impl ToSpan for Dot<'_> {
    fn span(&self) -> Span {
        self.dot.span()
    }
}

///
/// Type derived for non-terminal DotKey
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct DotKey<'t> {
    pub dot: Dot<'t>,
    pub key: Key<'t>,
}

impl ToSpan for DotKey<'_> {
    fn span(&self) -> Span {
        self.dot.span() + self.key.span()
    }
}

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

impl ToSpan for End<'_> {
    fn span(&self) -> Span {
        self.end.span()
    }
}

///
/// Type derived for non-terminal Eure
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Eure<'t> {
    pub eure_opt: Option<EureOpt<'t>>,
    pub eure_list: Vec<EureList<'t>>,
    pub eure_list0: Vec<EureList0<'t>>,
}

impl ToSpan for Eure<'_> {
    fn span(&self) -> Span {
        self.eure_opt.as_ref().map_or(Span::default(), |o| o.span())
            + self.eure_list.first().map_or(Span::default(), |f| f.span())
            + self.eure_list.last().map_or(Span::default(), |l| l.span())
            + self
                .eure_list0
                .first()
                .map_or(Span::default(), |f| f.span())
            + self.eure_list0.last().map_or(Span::default(), |l| l.span())
    }
}

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

impl ToSpan for EureList<'_> {
    fn span(&self) -> Span {
        self.binding.span()
    }
}

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

impl ToSpan for EureList0<'_> {
    fn span(&self) -> Span {
        self.section.span()
    }
}

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

impl ToSpan for EureOpt<'_> {
    fn span(&self) -> Span {
        self.top_level_binding.span()
    }
}

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

impl ToSpan for Ext<'_> {
    fn span(&self) -> Span {
        self.ext.span()
    }
}

///
/// Type derived for non-terminal ExtensionNameSpace
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ExtensionNameSpace<'t> {
    pub ext: Ext<'t>,
    pub key_ident: KeyIdent<'t>,
}

impl ToSpan for ExtensionNameSpace<'_> {
    fn span(&self) -> Span {
        self.ext.span() + self.key_ident.span()
    }
}

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

impl ToSpan for False<'_> {
    fn span(&self) -> Span {
        self.r#false.span()
    }
}

///
/// Type derived for non-terminal FirstKey
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum FirstKey<'t> {
    Key(FirstKeyKey<'t>),
    ArrayMarker(FirstKeyArrayMarker<'t>),
}

impl ToSpan for FirstKey<'_> {
    fn span(&self) -> Span {
        match self {
            FirstKey::Key(v) => v.span(),
            FirstKey::ArrayMarker(v) => v.span(),
        }
    }
}

///
/// Type derived for non-terminal FlatBody
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct FlatBody<'t> {
    pub section_head: SectionHead<'t>,
    pub flat_body_list: Vec<FlatBodyList<'t>>,
}

impl ToSpan for FlatBody<'_> {
    fn span(&self) -> Span {
        self.section_head.span()
            + self
                .flat_body_list
                .first()
                .map_or(Span::default(), |f| f.span())
            + self
                .flat_body_list
                .last()
                .map_or(Span::default(), |l| l.span())
    }
}

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

impl ToSpan for FlatBodyList<'_> {
    fn span(&self) -> Span {
        self.binding.span()
    }
}

///
/// Type derived for non-terminal FlatRootBinding
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum FlatRootBinding<'t> {
    ValueBinding(FlatRootBindingValueBinding<'t>),
    TextBinding(FlatRootBindingTextBinding<'t>),
}

impl ToSpan for FlatRootBinding<'_> {
    fn span(&self) -> Span {
        match self {
            FlatRootBinding::ValueBinding(v) => v.span(),
            FlatRootBinding::TextBinding(v) => v.span(),
        }
    }
}

///
/// Type derived for non-terminal Float
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Float<'t> {
    pub float: Token<'t>, /* [-+]?\d[\d_]*\.\d+([eE][-+]?\d+)?(f32|f64)?|[-+]?\d[\d_]*[eE][-+]?\d+(f32|f64)? */
}

impl ToSpan for Float<'_> {
    fn span(&self) -> Span {
        self.float.span()
    }
}

///
/// Type derived for non-terminal GrammarNewline
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct GrammarNewline<'t> {
    pub grammar_newline: Token<'t>, /* \r\n|\r|\n */
}

impl ToSpan for GrammarNewline<'_> {
    fn span(&self) -> Span {
        self.grammar_newline.span()
    }
}

///
/// Type derived for non-terminal Hole
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Hole<'t> {
    pub hole: Token<'t>, /* ![\p{XID_Start}_]?[\p{XID_Continue}-]* */
}

impl ToSpan for Hole<'_> {
    fn span(&self) -> Span {
        self.hole.span()
    }
}

///
/// Type derived for non-terminal Ident
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Ident<'t> {
    pub ident: Token<'t>, /* [\p{XID_Start}_][\p{XID_Continue}-]* */
}

impl ToSpan for Ident<'_> {
    fn span(&self) -> Span {
        self.ident.span()
    }
}

///
/// Type derived for non-terminal Inf
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Inf<'t> {
    pub inf: Token<'t>, /* [-+]?[Ii]nf */
}

impl ToSpan for Inf<'_> {
    fn span(&self) -> Span {
        self.inf.span()
    }
}

///
/// Type derived for non-terminal InlineCode
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum InlineCode<'t> {
    DelimCode(InlineCodeDelimCode<'t>),
    InlineCode1(InlineCodeInlineCode1<'t>),
}

impl ToSpan for InlineCode<'_> {
    fn span(&self) -> Span {
        match self {
            InlineCode::DelimCode(v) => v.span(),
            InlineCode::InlineCode1(v) => v.span(),
        }
    }
}

///
/// Type derived for non-terminal InlineCode1
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct InlineCode1<'t> {
    pub inline_code1: Token<'t>, /* [a-zA-Z0-9-_]*`[^`\r\n]*` */
}

impl ToSpan for InlineCode1<'_> {
    fn span(&self) -> Span {
        self.inline_code1.span()
    }
}

///
/// Type derived for non-terminal Integer
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Integer<'t> {
    pub integer: Token<'t>, /* [-+]?\d[\d_]* */
}

impl ToSpan for Integer<'_> {
    fn span(&self) -> Span {
        self.integer.span()
    }
}

///
/// Type derived for non-terminal Key
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum Key<'t> {
    KeyIdent(KeyKeyIdent<'t>),
    ExtensionNameSpace(KeyExtensionNameSpace<'t>),
    String(KeyString<'t>),
    Integer(KeyInteger<'t>),
    Float(KeyFloat<'t>),
    KeyTuple(KeyKeyTuple<'t>),
    TupleIndex(KeyTupleIndex<'t>),
    Hole(KeyHole<'t>),
}

impl ToSpan for Key<'_> {
    fn span(&self) -> Span {
        match self {
            Key::KeyIdent(v) => v.span(),
            Key::ExtensionNameSpace(v) => v.span(),
            Key::String(v) => v.span(),
            Key::Integer(v) => v.span(),
            Key::Float(v) => v.span(),
            Key::KeyTuple(v) => v.span(),
            Key::TupleIndex(v) => v.span(),
            Key::Hole(v) => v.span(),
        }
    }
}

///
/// Type derived for non-terminal KeyIdent
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum KeyIdent<'t> {
    Ident(KeyIdentIdent<'t>),
    True(KeyIdentTrue<'t>),
    False(KeyIdentFalse<'t>),
    Null(KeyIdentNull<'t>),
}

impl ToSpan for KeyIdent<'_> {
    fn span(&self) -> Span {
        match self {
            KeyIdent::Ident(v) => v.span(),
            KeyIdent::True(v) => v.span(),
            KeyIdent::False(v) => v.span(),
            KeyIdent::Null(v) => v.span(),
        }
    }
}

///
/// Type derived for non-terminal KeyTail
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum KeyTail<'t> {
    DotKey(KeyTailDotKey<'t>),
    ArrayMarker(KeyTailArrayMarker<'t>),
}

impl ToSpan for KeyTail<'_> {
    fn span(&self) -> Span {
        match self {
            KeyTail::DotKey(v) => v.span(),
            KeyTail::ArrayMarker(v) => v.span(),
        }
    }
}

///
/// Type derived for non-terminal KeyTuple
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyTuple<'t> {
    pub l_paren: LParen<'t>,
    pub key_tuple_opt: Option<KeyTupleOpt<'t>>,
    pub r_paren: RParen<'t>,
}

impl ToSpan for KeyTuple<'_> {
    fn span(&self) -> Span {
        self.l_paren.span()
            + self
                .key_tuple_opt
                .as_ref()
                .map_or(Span::default(), |o| o.span())
            + self.r_paren.span()
    }
}

///
/// Type derived for non-terminal KeyTupleElements
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyTupleElements<'t> {
    pub key_value: KeyValue<'t>,
    pub key_tuple_elements_opt: Option<Box<KeyTupleElementsOpt<'t>>>,
}

impl ToSpan for KeyTupleElements<'_> {
    fn span(&self) -> Span {
        self.key_value.span()
            + self
                .key_tuple_elements_opt
                .as_ref()
                .map_or(Span::default(), |o| o.span())
    }
}

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

impl ToSpan for KeyTupleElementsOpt<'_> {
    fn span(&self) -> Span {
        self.key_tuple_elements_tail.span()
    }
}

///
/// Type derived for non-terminal KeyTupleElementsTail
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct KeyTupleElementsTail<'t> {
    pub comma: Comma<'t>,
    pub key_tuple_elements_tail_opt: Option<KeyTupleElementsTailOpt<'t>>,
}

impl ToSpan for KeyTupleElementsTail<'_> {
    fn span(&self) -> Span {
        self.comma.span()
            + self
                .key_tuple_elements_tail_opt
                .as_ref()
                .map_or(Span::default(), |o| o.span())
    }
}

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

impl ToSpan for KeyTupleElementsTailOpt<'_> {
    fn span(&self) -> Span {
        self.key_tuple_elements.span()
    }
}

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

impl ToSpan for KeyTupleOpt<'_> {
    fn span(&self) -> Span {
        self.key_tuple_elements.span()
    }
}

///
/// Type derived for non-terminal KeyValue
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum KeyValue<'t> {
    Integer(KeyValueInteger<'t>),
    Boolean(KeyValueBoolean<'t>),
    Str(KeyValueStr<'t>),
    KeyTuple(KeyValueKeyTuple<'t>),
    Hole(KeyValueHole<'t>),
}

impl ToSpan for KeyValue<'_> {
    fn span(&self) -> Span {
        match self {
            KeyValue::Integer(v) => v.span(),
            KeyValue::Boolean(v) => v.span(),
            KeyValue::Str(v) => v.span(),
            KeyValue::KeyTuple(v) => v.span(),
            KeyValue::Hole(v) => v.span(),
        }
    }
}

///
/// Type derived for non-terminal Keys
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Keys<'t> {
    pub first_key: FirstKey<'t>,
    pub keys_list: Vec<KeysList<'t>>,
}

impl ToSpan for Keys<'_> {
    fn span(&self) -> Span {
        self.first_key.span()
            + self.keys_list.first().map_or(Span::default(), |f| f.span())
            + self.keys_list.last().map_or(Span::default(), |l| l.span())
    }
}

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

impl ToSpan for KeysList<'_> {
    fn span(&self) -> Span {
        self.key_tail.span()
    }
}

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

impl ToSpan for LParen<'_> {
    fn span(&self) -> Span {
        self.l_paren.span()
    }
}

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

impl ToSpan for LitStr<'_> {
    fn span(&self) -> Span {
        self.lit_str.span()
    }
}

///
/// Type derived for non-terminal LitStr1
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LitStr1<'t> {
    pub lit_str1_start: LitStr1Start<'t>,
    pub lit_str1_list: Vec<LitStr1List<'t>>,
    pub lit_str1_end: LitStr1End<'t>,
}

impl ToSpan for LitStr1<'_> {
    fn span(&self) -> Span {
        self.lit_str1_start.span()
            + self
                .lit_str1_list
                .first()
                .map_or(Span::default(), |f| f.span())
            + self
                .lit_str1_list
                .last()
                .map_or(Span::default(), |l| l.span())
            + self.lit_str1_end.span()
    }
}

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

impl ToSpan for LitStr1End<'_> {
    fn span(&self) -> Span {
        self.lit_str1_end.span()
    }
}

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

impl ToSpan for LitStr1List<'_> {
    fn span(&self) -> Span {
        self.lit_str1_list_group.span()
    }
}

///
/// Type derived for non-terminal LitStr1ListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum LitStr1ListGroup<'t> {
    NoSQuote(LitStr1ListGroupNoSQuote<'t>),
    SQuote(LitStr1ListGroupSQuote<'t>),
}

impl ToSpan for LitStr1ListGroup<'_> {
    fn span(&self) -> Span {
        match self {
            LitStr1ListGroup::NoSQuote(v) => v.span(),
            LitStr1ListGroup::SQuote(v) => v.span(),
        }
    }
}

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

impl ToSpan for LitStr1Start<'_> {
    fn span(&self) -> Span {
        self.lit_str1_start.span()
    }
}

///
/// Type derived for non-terminal LitStr2
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LitStr2<'t> {
    pub lit_str2_start: LitStr2Start<'t>,
    pub lit_str2_list: Vec<LitStr2List<'t>>,
    pub lit_str2_end: LitStr2End<'t>,
}

impl ToSpan for LitStr2<'_> {
    fn span(&self) -> Span {
        self.lit_str2_start.span()
            + self
                .lit_str2_list
                .first()
                .map_or(Span::default(), |f| f.span())
            + self
                .lit_str2_list
                .last()
                .map_or(Span::default(), |l| l.span())
            + self.lit_str2_end.span()
    }
}

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

impl ToSpan for LitStr2End<'_> {
    fn span(&self) -> Span {
        self.lit_str2_end.span()
    }
}

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

impl ToSpan for LitStr2List<'_> {
    fn span(&self) -> Span {
        self.lit_str2_list_group.span()
    }
}

///
/// Type derived for non-terminal LitStr2ListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum LitStr2ListGroup<'t> {
    NoSQuote(LitStr2ListGroupNoSQuote<'t>),
    SQuote(LitStr2ListGroupSQuote<'t>),
}

impl ToSpan for LitStr2ListGroup<'_> {
    fn span(&self) -> Span {
        match self {
            LitStr2ListGroup::NoSQuote(v) => v.span(),
            LitStr2ListGroup::SQuote(v) => v.span(),
        }
    }
}

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

impl ToSpan for LitStr2Start<'_> {
    fn span(&self) -> Span {
        self.lit_str2_start.span()
    }
}

///
/// Type derived for non-terminal LitStr3
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct LitStr3<'t> {
    pub lit_str3_start: LitStr3Start<'t>,
    pub lit_str3_list: Vec<LitStr3List<'t>>,
    pub lit_str3_end: LitStr3End<'t>,
}

impl ToSpan for LitStr3<'_> {
    fn span(&self) -> Span {
        self.lit_str3_start.span()
            + self
                .lit_str3_list
                .first()
                .map_or(Span::default(), |f| f.span())
            + self
                .lit_str3_list
                .last()
                .map_or(Span::default(), |l| l.span())
            + self.lit_str3_end.span()
    }
}

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

impl ToSpan for LitStr3End<'_> {
    fn span(&self) -> Span {
        self.lit_str3_end.span()
    }
}

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

impl ToSpan for LitStr3List<'_> {
    fn span(&self) -> Span {
        self.lit_str3_list_group.span()
    }
}

///
/// Type derived for non-terminal LitStr3ListGroup
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum LitStr3ListGroup<'t> {
    NoSQuote(LitStr3ListGroupNoSQuote<'t>),
    SQuote(LitStr3ListGroupSQuote<'t>),
}

impl ToSpan for LitStr3ListGroup<'_> {
    fn span(&self) -> Span {
        match self {
            LitStr3ListGroup::NoSQuote(v) => v.span(),
            LitStr3ListGroup::SQuote(v) => v.span(),
        }
    }
}

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

impl ToSpan for LitStr3Start<'_> {
    fn span(&self) -> Span {
        self.lit_str3_start.span()
    }
}

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

impl ToSpan for MapBind<'_> {
    fn span(&self) -> Span {
        self.map_bind.span()
    }
}

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

impl ToSpan for NaN<'_> {
    fn span(&self) -> Span {
        self.na_n.span()
    }
}

///
/// Type derived for non-terminal NewlineBind
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct NewlineBind<'t> {
    pub newline_bind: Token<'t>, /* (\r\n|\r|\n)*= */
}

impl ToSpan for NewlineBind<'_> {
    fn span(&self) -> Span {
        self.newline_bind.span()
    }
}

///
/// Type derived for non-terminal NewlineHead
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct NewlineHead<'t> {
    pub grammar_newline: GrammarNewline<'t>,
    pub newline_head_opt: Option<NewlineHeadOpt<'t>>,
}

impl ToSpan for NewlineHead<'_> {
    fn span(&self) -> Span {
        self.grammar_newline.span()
            + self
                .newline_head_opt
                .as_ref()
                .map_or(Span::default(), |o| o.span())
    }
}

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

impl ToSpan for NewlineHeadOpt<'_> {
    fn span(&self) -> Span {
        self.flat_root_binding.span()
    }
}

///
/// Type derived for non-terminal NewlineTextStart
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct NewlineTextStart<'t> {
    pub newline_text_start: Token<'t>, /* (\r\n|\r|\n)*: */
}

impl ToSpan for NewlineTextStart<'_> {
    fn span(&self) -> Span {
        self.newline_text_start.span()
    }
}

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

impl ToSpan for NoBacktick<'_> {
    fn span(&self) -> Span {
        self.no_backtick.span()
    }
}

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

impl ToSpan for NoSQuote<'_> {
    fn span(&self) -> Span {
        self.no_s_quote.span()
    }
}

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

impl ToSpan for Null<'_> {
    fn span(&self) -> Span {
        self.null.span()
    }
}

///
/// Type derived for non-terminal Number
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum Number<'t> {
    Float(NumberFloat<'t>),
    Integer(NumberInteger<'t>),
    Inf(NumberInf<'t>),
    NaN(NumberNaN<'t>),
}

impl ToSpan for Number<'_> {
    fn span(&self) -> Span {
        match self {
            Number::Float(v) => v.span(),
            Number::Integer(v) => v.span(),
            Number::Inf(v) => v.span(),
            Number::NaN(v) => v.span(),
        }
    }
}

///
/// Type derived for non-terminal Object
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Object<'t> {
    pub begin: Begin<'t>,
    pub object_opt: Option<ObjectOpt<'t>>,
    pub object_list: Vec<ObjectList<'t>>,
    pub end: End<'t>,
}

impl ToSpan for Object<'_> {
    fn span(&self) -> Span {
        self.begin.span()
            + self
                .object_opt
                .as_ref()
                .map_or(Span::default(), |o| o.span())
            + self
                .object_list
                .first()
                .map_or(Span::default(), |f| f.span())
            + self
                .object_list
                .last()
                .map_or(Span::default(), |l| l.span())
            + self.end.span()
    }
}

///
/// Type derived for non-terminal ObjectList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ObjectList<'t> {
    pub keys: Keys<'t>,
    pub map_bind: MapBind<'t>,
    pub value: Value<'t>,
    pub object_opt0: Option<ObjectOpt0<'t>>,
}

impl ToSpan for ObjectList<'_> {
    fn span(&self) -> Span {
        self.keys.span()
            + self.map_bind.span()
            + self.value.span()
            + self
                .object_opt0
                .as_ref()
                .map_or(Span::default(), |o| o.span())
    }
}

///
/// Type derived for non-terminal ObjectOpt
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ObjectOpt<'t> {
    pub value_binding: ValueBinding<'t>,
    pub object_opt1: Option<ObjectOpt1<'t>>,
}

impl ToSpan for ObjectOpt<'_> {
    fn span(&self) -> Span {
        self.value_binding.span()
            + self
                .object_opt1
                .as_ref()
                .map_or(Span::default(), |o| o.span())
    }
}

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

impl ToSpan for ObjectOpt0<'_> {
    fn span(&self) -> Span {
        self.comma.span()
    }
}

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

impl ToSpan for ObjectOpt1<'_> {
    fn span(&self) -> Span {
        self.comma.span()
    }
}

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

impl ToSpan for RParen<'_> {
    fn span(&self) -> Span {
        self.r_paren.span()
    }
}

///
/// Type derived for non-terminal RootBinding
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum RootBinding<'t> {
    RootValueBinding(RootBindingRootValueBinding<'t>),
    RootTextBinding(RootBindingRootTextBinding<'t>),
}

impl ToSpan for RootBinding<'_> {
    fn span(&self) -> Span {
        match self {
            RootBinding::RootValueBinding(v) => v.span(),
            RootBinding::RootTextBinding(v) => v.span(),
        }
    }
}

///
/// Type derived for non-terminal RootTextBinding
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RootTextBinding<'t> {
    pub newline_text_start: NewlineTextStart<'t>,
    pub root_text_binding_opt: Option<RootTextBindingOpt>,
    pub root_text_binding_opt0: Option<RootTextBindingOpt0<'t>>,
    pub root_text_binding_opt1: Option<RootTextBindingOpt1<'t>>,
}

impl ToSpan for RootTextBinding<'_> {
    fn span(&self) -> Span {
        self.newline_text_start.span()
            + self
                .root_text_binding_opt
                .as_ref()
                .map_or(Span::default(), |o| o.span())
            + self
                .root_text_binding_opt0
                .as_ref()
                .map_or(Span::default(), |o| o.span())
            + self
                .root_text_binding_opt1
                .as_ref()
                .map_or(Span::default(), |o| o.span())
    }
}

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

impl ToSpan for RootTextBindingOpt {
    fn span(&self) -> Span {
        Span::default()
    }
}

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

impl ToSpan for RootTextBindingOpt0<'_> {
    fn span(&self) -> Span {
        self.text.span()
    }
}

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

impl ToSpan for RootTextBindingOpt1<'_> {
    fn span(&self) -> Span {
        self.grammar_newline.span()
    }
}

///
/// Type derived for non-terminal RootValueBinding
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RootValueBinding<'t> {
    pub newline_bind: NewlineBind<'t>,
    pub value: Value<'t>,
}

impl ToSpan for RootValueBinding<'_> {
    fn span(&self) -> Span {
        self.newline_bind.span() + self.value.span()
    }
}

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

impl ToSpan for SQuote<'_> {
    fn span(&self) -> Span {
        self.s_quote.span()
    }
}

///
/// Type derived for non-terminal Section
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Section<'t> {
    pub at: At<'t>,
    pub keys: Keys<'t>,
    pub section_body: SectionBody<'t>,
}

impl ToSpan for Section<'_> {
    fn span(&self) -> Span {
        self.at.span() + self.keys.span() + self.section_body.span()
    }
}

///
/// Type derived for non-terminal SectionBinding
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct SectionBinding<'t> {
    pub begin: Begin<'t>,
    pub eure: Eure<'t>,
    pub end: End<'t>,
}

impl ToSpan for SectionBinding<'_> {
    fn span(&self) -> Span {
        self.begin.span() + self.eure.span() + self.end.span()
    }
}

///
/// Type derived for non-terminal SectionBody
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum SectionBody<'t> {
    SectionBodyOpt(SectionBodySectionBodyOpt<'t>),
    BlockBody(SectionBodyBlockBody<'t>),
}

impl ToSpan for SectionBody<'_> {
    fn span(&self) -> Span {
        match self {
            SectionBody::SectionBodyOpt(v) => v.span(),
            SectionBody::BlockBody(v) => v.span(),
        }
    }
}

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

impl ToSpan for SectionBodyOpt<'_> {
    fn span(&self) -> Span {
        self.flat_body.span()
    }
}

///
/// Type derived for non-terminal SectionHead
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum SectionHead<'t> {
    RootBinding(SectionHeadRootBinding<'t>),
    NewlineHead(SectionHeadNewlineHead<'t>),
}

impl ToSpan for SectionHead<'_> {
    fn span(&self) -> Span {
        match self {
            SectionHead::RootBinding(v) => v.span(),
            SectionHead::NewlineHead(v) => v.span(),
        }
    }
}

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

impl ToSpan for Str<'_> {
    fn span(&self) -> Span {
        self.str.span()
    }
}

///
/// Type derived for non-terminal String
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum String<'t> {
    Str(StringStr<'t>),
    LitStr(StringLitStr<'t>),
    LitStr1(StringLitStr1<'t>),
    LitStr2(StringLitStr2<'t>),
    LitStr3(StringLitStr3<'t>),
}

impl ToSpan for String<'_> {
    fn span(&self) -> Span {
        match self {
            String::Str(v) => v.span(),
            String::LitStr(v) => v.span(),
            String::LitStr1(v) => v.span(),
            String::LitStr2(v) => v.span(),
            String::LitStr3(v) => v.span(),
        }
    }
}

///
/// Type derived for non-terminal Strings
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Strings<'t> {
    pub string: String<'t>,
    pub strings_list: Vec<StringsList<'t>>,
}

impl ToSpan for Strings<'_> {
    fn span(&self) -> Span {
        self.string.span()
            + self
                .strings_list
                .first()
                .map_or(Span::default(), |f| f.span())
            + self
                .strings_list
                .last()
                .map_or(Span::default(), |l| l.span())
    }
}

///
/// Type derived for non-terminal StringsList
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct StringsList<'t> {
    pub r#continue: Continue<'t>,
    pub string: String<'t>,
}

impl ToSpan for StringsList<'_> {
    fn span(&self) -> Span {
        self.r#continue.span() + self.string.span()
    }
}

///
/// Type derived for non-terminal Text
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Text<'t> {
    pub text: Token<'t>, /* [^\r\n]* */
}

impl ToSpan for Text<'_> {
    fn span(&self) -> Span {
        self.text.span()
    }
}

///
/// Type derived for non-terminal TextBinding
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TextBinding<'t> {
    pub text_start: TextStart<'t>,
    pub text_binding_opt: Option<TextBindingOpt>,
    pub text_binding_opt0: Option<TextBindingOpt0<'t>>,
    pub text_binding_opt1: Option<TextBindingOpt1<'t>>,
}

impl ToSpan for TextBinding<'_> {
    fn span(&self) -> Span {
        self.text_start.span()
            + self
                .text_binding_opt
                .as_ref()
                .map_or(Span::default(), |o| o.span())
            + self
                .text_binding_opt0
                .as_ref()
                .map_or(Span::default(), |o| o.span())
            + self
                .text_binding_opt1
                .as_ref()
                .map_or(Span::default(), |o| o.span())
    }
}

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

impl ToSpan for TextBindingOpt {
    fn span(&self) -> Span {
        Span::default()
    }
}

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

impl ToSpan for TextBindingOpt0<'_> {
    fn span(&self) -> Span {
        self.text.span()
    }
}

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

impl ToSpan for TextBindingOpt1<'_> {
    fn span(&self) -> Span {
        self.grammar_newline.span()
    }
}

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

impl ToSpan for TextStart<'_> {
    fn span(&self) -> Span {
        self.text_start.span()
    }
}

///
/// Type derived for non-terminal TopLevelBinding
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum TopLevelBinding<'t> {
    ValueBinding(TopLevelBindingValueBinding<'t>),
    TextBinding(TopLevelBindingTextBinding<'t>),
}

impl ToSpan for TopLevelBinding<'_> {
    fn span(&self) -> Span {
        match self {
            TopLevelBinding::ValueBinding(v) => v.span(),
            TopLevelBinding::TextBinding(v) => v.span(),
        }
    }
}

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

impl ToSpan for True<'_> {
    fn span(&self) -> Span {
        self.r#true.span()
    }
}

///
/// Type derived for non-terminal Tuple
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Tuple<'t> {
    pub l_paren: LParen<'t>,
    pub tuple_opt: Option<TupleOpt<'t>>,
    pub r_paren: RParen<'t>,
}

impl ToSpan for Tuple<'_> {
    fn span(&self) -> Span {
        self.l_paren.span()
            + self
                .tuple_opt
                .as_ref()
                .map_or(Span::default(), |o| o.span())
            + self.r_paren.span()
    }
}

///
/// Type derived for non-terminal TupleElements
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TupleElements<'t> {
    pub value: Value<'t>,
    pub tuple_elements_opt: Option<Box<TupleElementsOpt<'t>>>,
}

impl ToSpan for TupleElements<'_> {
    fn span(&self) -> Span {
        self.value.span()
            + self
                .tuple_elements_opt
                .as_ref()
                .map_or(Span::default(), |o| o.span())
    }
}

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

impl ToSpan for TupleElementsOpt<'_> {
    fn span(&self) -> Span {
        self.tuple_elements_tail.span()
    }
}

///
/// Type derived for non-terminal TupleElementsTail
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TupleElementsTail<'t> {
    pub comma: Comma<'t>,
    pub tuple_elements_tail_opt: Option<TupleElementsTailOpt<'t>>,
}

impl ToSpan for TupleElementsTail<'_> {
    fn span(&self) -> Span {
        self.comma.span()
            + self
                .tuple_elements_tail_opt
                .as_ref()
                .map_or(Span::default(), |o| o.span())
    }
}

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

impl ToSpan for TupleElementsTailOpt<'_> {
    fn span(&self) -> Span {
        self.tuple_elements.span()
    }
}

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

impl ToSpan for TupleIndex<'_> {
    fn span(&self) -> Span {
        self.hash.span() + self.integer.span()
    }
}

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

impl ToSpan for TupleOpt<'_> {
    fn span(&self) -> Span {
        self.tuple_elements.span()
    }
}

///
/// Type derived for non-terminal Value
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum Value<'t> {
    Object(ValueObject<'t>),
    Array(ValueArray<'t>),
    Tuple(ValueTuple<'t>),
    Number(ValueNumber<'t>),
    Boolean(ValueBoolean<'t>),
    Null(ValueNull<'t>),
    Strings(ValueStrings<'t>),
    Hole(ValueHole<'t>),
    CodeBlock(ValueCodeBlock<'t>),
    InlineCode(ValueInlineCode<'t>),
}

impl ToSpan for Value<'_> {
    fn span(&self) -> Span {
        match self {
            Value::Object(v) => v.span(),
            Value::Array(v) => v.span(),
            Value::Tuple(v) => v.span(),
            Value::Number(v) => v.span(),
            Value::Boolean(v) => v.span(),
            Value::Null(v) => v.span(),
            Value::Strings(v) => v.span(),
            Value::Hole(v) => v.span(),
            Value::CodeBlock(v) => v.span(),
            Value::InlineCode(v) => v.span(),
        }
    }
}

///
/// Type derived for non-terminal ValueBinding
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ValueBinding<'t> {
    pub bind: Bind<'t>,
    pub value: Value<'t>,
}

impl ToSpan for ValueBinding<'_> {
    fn span(&self) -> Span {
        self.bind.span() + self.value.span()
    }
}

///
/// Type derived for non-terminal Ws
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct Ws<'t> {
    pub ws: Token<'t>, /* [\s--\r\n]+ */
}

impl ToSpan for Ws<'_> {
    fn span(&self) -> Span {
        self.ws.span()
    }
}

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

///
/// Deduced ASTType of expanded grammar
///
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum ASTType<'t> {
    Array(Array<'t>),
    ArrayBegin(ArrayBegin<'t>),
    ArrayElements(ArrayElements<'t>),
    ArrayElementsOpt(Option<ArrayElementsOpt<'t>>),
    ArrayElementsTail(ArrayElementsTail<'t>),
    ArrayElementsTailOpt(Option<ArrayElementsTailOpt<'t>>),
    ArrayEnd(ArrayEnd<'t>),
    ArrayMarker(ArrayMarker<'t>),
    ArrayMarkerOpt(Option<ArrayMarkerOpt<'t>>),
    ArrayMarkerOptGroup(ArrayMarkerOptGroup<'t>),
    ArrayOpt(Option<ArrayOpt<'t>>),
    At(At<'t>),
    Backtick2(Backtick2<'t>),
    Backtick3(Backtick3<'t>),
    Backtick4(Backtick4<'t>),
    Backtick5(Backtick5<'t>),
    BacktickDelim(BacktickDelim<'t>),
    Begin(Begin<'t>),
    Bind(Bind<'t>),
    Binding(Binding<'t>),
    BindingRhs(BindingRhs<'t>),
    BlockBody(BlockBody<'t>),
    Boolean(Boolean<'t>),
    Caret(Caret<'t>),
    CodeBlock(CodeBlock<'t>),
    CodeBlock3(CodeBlock3<'t>),
    CodeBlock3List(Vec<CodeBlock3List<'t>>),
    CodeBlock3ListGroup(CodeBlock3ListGroup<'t>),
    CodeBlock4(CodeBlock4<'t>),
    CodeBlock4List(Vec<CodeBlock4List<'t>>),
    CodeBlock4ListGroup(CodeBlock4ListGroup<'t>),
    CodeBlock5(CodeBlock5<'t>),
    CodeBlock5List(Vec<CodeBlock5List<'t>>),
    CodeBlock5ListGroup(CodeBlock5ListGroup<'t>),
    CodeBlock6(CodeBlock6<'t>),
    CodeBlock6List(Vec<CodeBlock6List<'t>>),
    CodeBlock6ListGroup(CodeBlock6ListGroup<'t>),
    CodeBlockEnd3(CodeBlockEnd3<'t>),
    CodeBlockEnd4(CodeBlockEnd4<'t>),
    CodeBlockEnd5(CodeBlockEnd5<'t>),
    CodeBlockEnd6(CodeBlockEnd6<'t>),
    CodeBlockStart3(CodeBlockStart3<'t>),
    CodeBlockStart4(CodeBlockStart4<'t>),
    CodeBlockStart5(CodeBlockStart5<'t>),
    CodeBlockStart6(CodeBlockStart6<'t>),
    Comma(Comma<'t>),
    Continue(Continue<'t>),
    DelimCode(DelimCode<'t>),
    DelimCode1(DelimCode1<'t>),
    DelimCode1List(Vec<DelimCode1List<'t>>),
    DelimCode1ListGroup(DelimCode1ListGroup<'t>),
    DelimCode2(DelimCode2<'t>),
    DelimCode2List(Vec<DelimCode2List<'t>>),
    DelimCode2ListGroup(DelimCode2ListGroup<'t>),
    DelimCode3(DelimCode3<'t>),
    DelimCode3List(Vec<DelimCode3List<'t>>),
    DelimCode3ListGroup(DelimCode3ListGroup<'t>),
    DelimCodeEnd1(DelimCodeEnd1<'t>),
    DelimCodeEnd2(DelimCodeEnd2<'t>),
    DelimCodeEnd3(DelimCodeEnd3<'t>),
    DelimCodeStart1(DelimCodeStart1<'t>),
    DelimCodeStart2(DelimCodeStart2<'t>),
    DelimCodeStart3(DelimCodeStart3<'t>),
    Dot(Dot<'t>),
    DotKey(DotKey<'t>),
    End(End<'t>),
    Eure(Eure<'t>),
    EureList(Vec<EureList<'t>>),
    EureList0(Vec<EureList0<'t>>),
    EureOpt(Option<EureOpt<'t>>),
    Ext(Ext<'t>),
    ExtensionNameSpace(ExtensionNameSpace<'t>),
    False(False<'t>),
    FirstKey(FirstKey<'t>),
    FlatBody(FlatBody<'t>),
    FlatBodyList(Vec<FlatBodyList<'t>>),
    FlatRootBinding(FlatRootBinding<'t>),
    Float(Float<'t>),
    GrammarNewline(GrammarNewline<'t>),
    Hole(Hole<'t>),
    Ident(Ident<'t>),
    Inf(Inf<'t>),
    InlineCode(InlineCode<'t>),
    InlineCode1(InlineCode1<'t>),
    Integer(Integer<'t>),
    Key(Key<'t>),
    KeyIdent(KeyIdent<'t>),
    KeyTail(KeyTail<'t>),
    KeyTuple(KeyTuple<'t>),
    KeyTupleElements(KeyTupleElements<'t>),
    KeyTupleElementsOpt(Option<KeyTupleElementsOpt<'t>>),
    KeyTupleElementsTail(KeyTupleElementsTail<'t>),
    KeyTupleElementsTailOpt(Option<KeyTupleElementsTailOpt<'t>>),
    KeyTupleOpt(Option<KeyTupleOpt<'t>>),
    KeyValue(KeyValue<'t>),
    Keys(Keys<'t>),
    KeysList(Vec<KeysList<'t>>),
    LParen(LParen<'t>),
    LitStr(LitStr<'t>),
    LitStr1(LitStr1<'t>),
    LitStr1End(LitStr1End<'t>),
    LitStr1List(Vec<LitStr1List<'t>>),
    LitStr1ListGroup(LitStr1ListGroup<'t>),
    LitStr1Start(LitStr1Start<'t>),
    LitStr2(LitStr2<'t>),
    LitStr2End(LitStr2End<'t>),
    LitStr2List(Vec<LitStr2List<'t>>),
    LitStr2ListGroup(LitStr2ListGroup<'t>),
    LitStr2Start(LitStr2Start<'t>),
    LitStr3(LitStr3<'t>),
    LitStr3End(LitStr3End<'t>),
    LitStr3List(Vec<LitStr3List<'t>>),
    LitStr3ListGroup(LitStr3ListGroup<'t>),
    LitStr3Start(LitStr3Start<'t>),
    MapBind(MapBind<'t>),
    NaN(NaN<'t>),
    NewlineBind(NewlineBind<'t>),
    NewlineHead(NewlineHead<'t>),
    NewlineHeadOpt(Option<NewlineHeadOpt<'t>>),
    NewlineTextStart(NewlineTextStart<'t>),
    NoBacktick(NoBacktick<'t>),
    NoSQuote(NoSQuote<'t>),
    Null(Null<'t>),
    Number(Number<'t>),
    Object(Object<'t>),
    ObjectList(Vec<ObjectList<'t>>),
    ObjectOpt(Option<ObjectOpt<'t>>),
    ObjectOpt0(Option<ObjectOpt0<'t>>),
    ObjectOpt1(Option<ObjectOpt1<'t>>),
    RParen(RParen<'t>),
    RootBinding(RootBinding<'t>),
    RootTextBinding(RootTextBinding<'t>),
    RootTextBindingOpt(Option<RootTextBindingOpt>),
    RootTextBindingOpt0(Option<RootTextBindingOpt0<'t>>),
    RootTextBindingOpt1(Option<RootTextBindingOpt1<'t>>),
    RootValueBinding(RootValueBinding<'t>),
    SQuote(SQuote<'t>),
    Section(Section<'t>),
    SectionBinding(SectionBinding<'t>),
    SectionBody(SectionBody<'t>),
    SectionBodyOpt(Option<SectionBodyOpt<'t>>),
    SectionHead(SectionHead<'t>),
    Str(Str<'t>),
    String(String<'t>),
    Strings(Strings<'t>),
    StringsList(Vec<StringsList<'t>>),
    Text(Text<'t>),
    TextBinding(TextBinding<'t>),
    TextBindingOpt(Option<TextBindingOpt>),
    TextBindingOpt0(Option<TextBindingOpt0<'t>>),
    TextBindingOpt1(Option<TextBindingOpt1<'t>>),
    TextStart(TextStart<'t>),
    TopLevelBinding(TopLevelBinding<'t>),
    True(True<'t>),
    Tuple(Tuple<'t>),
    TupleElements(TupleElements<'t>),
    TupleElementsOpt(Option<TupleElementsOpt<'t>>),
    TupleElementsTail(TupleElementsTail<'t>),
    TupleElementsTailOpt(Option<TupleElementsTailOpt<'t>>),
    TupleIndex(TupleIndex<'t>),
    TupleOpt(Option<TupleOpt<'t>>),
    Value(Value<'t>),
    ValueBinding(ValueBinding<'t>),
    Ws(Ws<'t>),
}
impl ToSpan for ASTType<'_> {
    fn span(&self) -> Span {
        match self {
            ASTType::Array(v) => v.span(),
            ASTType::ArrayBegin(v) => v.span(),
            ASTType::ArrayElements(v) => v.span(),
            ASTType::ArrayElementsOpt(o) => o.as_ref().map_or(Span::default(), |o| o.span()),
            ASTType::ArrayElementsTail(v) => v.span(),
            ASTType::ArrayElementsTailOpt(o) => o.as_ref().map_or(Span::default(), |o| o.span()),
            ASTType::ArrayEnd(v) => v.span(),
            ASTType::ArrayMarker(v) => v.span(),
            ASTType::ArrayMarkerOpt(o) => o.as_ref().map_or(Span::default(), |o| o.span()),
            ASTType::ArrayMarkerOptGroup(v) => v.span(),
            ASTType::ArrayOpt(o) => o.as_ref().map_or(Span::default(), |o| o.span()),
            ASTType::At(v) => v.span(),
            ASTType::Backtick2(v) => v.span(),
            ASTType::Backtick3(v) => v.span(),
            ASTType::Backtick4(v) => v.span(),
            ASTType::Backtick5(v) => v.span(),
            ASTType::BacktickDelim(v) => v.span(),
            ASTType::Begin(v) => v.span(),
            ASTType::Bind(v) => v.span(),
            ASTType::Binding(v) => v.span(),
            ASTType::BindingRhs(v) => v.span(),
            ASTType::BlockBody(v) => v.span(),
            ASTType::Boolean(v) => v.span(),
            ASTType::Caret(v) => v.span(),
            ASTType::CodeBlock(v) => v.span(),
            ASTType::CodeBlock3(v) => v.span(),
            ASTType::CodeBlock3List(v) => {
                v.first().map_or(Span::default(), |f| f.span())
                    + v.last().map_or(Span::default(), |l| l.span())
            }
            ASTType::CodeBlock3ListGroup(v) => v.span(),
            ASTType::CodeBlock4(v) => v.span(),
            ASTType::CodeBlock4List(v) => {
                v.first().map_or(Span::default(), |f| f.span())
                    + v.last().map_or(Span::default(), |l| l.span())
            }
            ASTType::CodeBlock4ListGroup(v) => v.span(),
            ASTType::CodeBlock5(v) => v.span(),
            ASTType::CodeBlock5List(v) => {
                v.first().map_or(Span::default(), |f| f.span())
                    + v.last().map_or(Span::default(), |l| l.span())
            }
            ASTType::CodeBlock5ListGroup(v) => v.span(),
            ASTType::CodeBlock6(v) => v.span(),
            ASTType::CodeBlock6List(v) => {
                v.first().map_or(Span::default(), |f| f.span())
                    + v.last().map_or(Span::default(), |l| l.span())
            }
            ASTType::CodeBlock6ListGroup(v) => v.span(),
            ASTType::CodeBlockEnd3(v) => v.span(),
            ASTType::CodeBlockEnd4(v) => v.span(),
            ASTType::CodeBlockEnd5(v) => v.span(),
            ASTType::CodeBlockEnd6(v) => v.span(),
            ASTType::CodeBlockStart3(v) => v.span(),
            ASTType::CodeBlockStart4(v) => v.span(),
            ASTType::CodeBlockStart5(v) => v.span(),
            ASTType::CodeBlockStart6(v) => v.span(),
            ASTType::Comma(v) => v.span(),
            ASTType::Continue(v) => v.span(),
            ASTType::DelimCode(v) => v.span(),
            ASTType::DelimCode1(v) => v.span(),
            ASTType::DelimCode1List(v) => {
                v.first().map_or(Span::default(), |f| f.span())
                    + v.last().map_or(Span::default(), |l| l.span())
            }
            ASTType::DelimCode1ListGroup(v) => v.span(),
            ASTType::DelimCode2(v) => v.span(),
            ASTType::DelimCode2List(v) => {
                v.first().map_or(Span::default(), |f| f.span())
                    + v.last().map_or(Span::default(), |l| l.span())
            }
            ASTType::DelimCode2ListGroup(v) => v.span(),
            ASTType::DelimCode3(v) => v.span(),
            ASTType::DelimCode3List(v) => {
                v.first().map_or(Span::default(), |f| f.span())
                    + v.last().map_or(Span::default(), |l| l.span())
            }
            ASTType::DelimCode3ListGroup(v) => v.span(),
            ASTType::DelimCodeEnd1(v) => v.span(),
            ASTType::DelimCodeEnd2(v) => v.span(),
            ASTType::DelimCodeEnd3(v) => v.span(),
            ASTType::DelimCodeStart1(v) => v.span(),
            ASTType::DelimCodeStart2(v) => v.span(),
            ASTType::DelimCodeStart3(v) => v.span(),
            ASTType::Dot(v) => v.span(),
            ASTType::DotKey(v) => v.span(),
            ASTType::End(v) => v.span(),
            ASTType::Eure(v) => v.span(),
            ASTType::EureList(v) => {
                v.first().map_or(Span::default(), |f| f.span())
                    + v.last().map_or(Span::default(), |l| l.span())
            }
            ASTType::EureList0(v) => {
                v.first().map_or(Span::default(), |f| f.span())
                    + v.last().map_or(Span::default(), |l| l.span())
            }
            ASTType::EureOpt(o) => o.as_ref().map_or(Span::default(), |o| o.span()),
            ASTType::Ext(v) => v.span(),
            ASTType::ExtensionNameSpace(v) => v.span(),
            ASTType::False(v) => v.span(),
            ASTType::FirstKey(v) => v.span(),
            ASTType::FlatBody(v) => v.span(),
            ASTType::FlatBodyList(v) => {
                v.first().map_or(Span::default(), |f| f.span())
                    + v.last().map_or(Span::default(), |l| l.span())
            }
            ASTType::FlatRootBinding(v) => v.span(),
            ASTType::Float(v) => v.span(),
            ASTType::GrammarNewline(v) => v.span(),
            ASTType::Hole(v) => v.span(),
            ASTType::Ident(v) => v.span(),
            ASTType::Inf(v) => v.span(),
            ASTType::InlineCode(v) => v.span(),
            ASTType::InlineCode1(v) => v.span(),
            ASTType::Integer(v) => v.span(),
            ASTType::Key(v) => v.span(),
            ASTType::KeyIdent(v) => v.span(),
            ASTType::KeyTail(v) => v.span(),
            ASTType::KeyTuple(v) => v.span(),
            ASTType::KeyTupleElements(v) => v.span(),
            ASTType::KeyTupleElementsOpt(o) => o.as_ref().map_or(Span::default(), |o| o.span()),
            ASTType::KeyTupleElementsTail(v) => v.span(),
            ASTType::KeyTupleElementsTailOpt(o) => o.as_ref().map_or(Span::default(), |o| o.span()),
            ASTType::KeyTupleOpt(o) => o.as_ref().map_or(Span::default(), |o| o.span()),
            ASTType::KeyValue(v) => v.span(),
            ASTType::Keys(v) => v.span(),
            ASTType::KeysList(v) => {
                v.first().map_or(Span::default(), |f| f.span())
                    + v.last().map_or(Span::default(), |l| l.span())
            }
            ASTType::LParen(v) => v.span(),
            ASTType::LitStr(v) => v.span(),
            ASTType::LitStr1(v) => v.span(),
            ASTType::LitStr1End(v) => v.span(),
            ASTType::LitStr1List(v) => {
                v.first().map_or(Span::default(), |f| f.span())
                    + v.last().map_or(Span::default(), |l| l.span())
            }
            ASTType::LitStr1ListGroup(v) => v.span(),
            ASTType::LitStr1Start(v) => v.span(),
            ASTType::LitStr2(v) => v.span(),
            ASTType::LitStr2End(v) => v.span(),
            ASTType::LitStr2List(v) => {
                v.first().map_or(Span::default(), |f| f.span())
                    + v.last().map_or(Span::default(), |l| l.span())
            }
            ASTType::LitStr2ListGroup(v) => v.span(),
            ASTType::LitStr2Start(v) => v.span(),
            ASTType::LitStr3(v) => v.span(),
            ASTType::LitStr3End(v) => v.span(),
            ASTType::LitStr3List(v) => {
                v.first().map_or(Span::default(), |f| f.span())
                    + v.last().map_or(Span::default(), |l| l.span())
            }
            ASTType::LitStr3ListGroup(v) => v.span(),
            ASTType::LitStr3Start(v) => v.span(),
            ASTType::MapBind(v) => v.span(),
            ASTType::NaN(v) => v.span(),
            ASTType::NewlineBind(v) => v.span(),
            ASTType::NewlineHead(v) => v.span(),
            ASTType::NewlineHeadOpt(o) => o.as_ref().map_or(Span::default(), |o| o.span()),
            ASTType::NewlineTextStart(v) => v.span(),
            ASTType::NoBacktick(v) => v.span(),
            ASTType::NoSQuote(v) => v.span(),
            ASTType::Null(v) => v.span(),
            ASTType::Number(v) => v.span(),
            ASTType::Object(v) => v.span(),
            ASTType::ObjectList(v) => {
                v.first().map_or(Span::default(), |f| f.span())
                    + v.last().map_or(Span::default(), |l| l.span())
            }
            ASTType::ObjectOpt(o) => o.as_ref().map_or(Span::default(), |o| o.span()),
            ASTType::ObjectOpt0(o) => o.as_ref().map_or(Span::default(), |o| o.span()),
            ASTType::ObjectOpt1(o) => o.as_ref().map_or(Span::default(), |o| o.span()),
            ASTType::RParen(v) => v.span(),
            ASTType::RootBinding(v) => v.span(),
            ASTType::RootTextBinding(v) => v.span(),
            ASTType::RootTextBindingOpt(o) => o.as_ref().map_or(Span::default(), |o| o.span()),
            ASTType::RootTextBindingOpt0(o) => o.as_ref().map_or(Span::default(), |o| o.span()),
            ASTType::RootTextBindingOpt1(o) => o.as_ref().map_or(Span::default(), |o| o.span()),
            ASTType::RootValueBinding(v) => v.span(),
            ASTType::SQuote(v) => v.span(),
            ASTType::Section(v) => v.span(),
            ASTType::SectionBinding(v) => v.span(),
            ASTType::SectionBody(v) => v.span(),
            ASTType::SectionBodyOpt(o) => o.as_ref().map_or(Span::default(), |o| o.span()),
            ASTType::SectionHead(v) => v.span(),
            ASTType::Str(v) => v.span(),
            ASTType::String(v) => v.span(),
            ASTType::Strings(v) => v.span(),
            ASTType::StringsList(v) => {
                v.first().map_or(Span::default(), |f| f.span())
                    + v.last().map_or(Span::default(), |l| l.span())
            }
            ASTType::Text(v) => v.span(),
            ASTType::TextBinding(v) => v.span(),
            ASTType::TextBindingOpt(o) => o.as_ref().map_or(Span::default(), |o| o.span()),
            ASTType::TextBindingOpt0(o) => o.as_ref().map_or(Span::default(), |o| o.span()),
            ASTType::TextBindingOpt1(o) => o.as_ref().map_or(Span::default(), |o| o.span()),
            ASTType::TextStart(v) => v.span(),
            ASTType::TopLevelBinding(v) => v.span(),
            ASTType::True(v) => v.span(),
            ASTType::Tuple(v) => v.span(),
            ASTType::TupleElements(v) => v.span(),
            ASTType::TupleElementsOpt(o) => o.as_ref().map_or(Span::default(), |o| o.span()),
            ASTType::TupleElementsTail(v) => v.span(),
            ASTType::TupleElementsTailOpt(o) => o.as_ref().map_or(Span::default(), |o| o.span()),
            ASTType::TupleIndex(v) => v.span(),
            ASTType::TupleOpt(o) => o.as_ref().map_or(Span::default(), |o| o.span()),
            ASTType::Value(v) => v.span(),
            ASTType::ValueBinding(v) => v.span(),
            ASTType::Ws(v) => v.span(),
        }
    }
}

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

/// 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 GrammarAuto<'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 GrammarTrait<'t>,
    // Stack to construct the AST on it
    item_stack: Vec<ASTType<'t>>,
}

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

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

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

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

    /// Semantic action for production 0:
    ///
    /// `Eure: EureOpt /* Option */ EureList /* Vec */ EureList0 /* Vec */;`
    ///
    #[parol_runtime::function_name::named]
    fn eure(
        &mut self,
        _eure_opt: &ParseTreeType<'t>,
        _eure_list: &ParseTreeType<'t>,
        _eure_list0: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let eure_list0 = pop_and_reverse_item!(self, eure_list0, EureList0, context);
        let eure_list = pop_and_reverse_item!(self, eure_list, EureList, context);
        let eure_opt = pop_item!(self, eure_opt, EureOpt, context);
        let eure_built = Eure {
            eure_opt,
            eure_list,
            eure_list0,
        };
        // Calling user action here
        self.user_grammar.eure(&eure_built)?;
        self.push(ASTType::Eure(eure_built), context);
        Ok(())
    }

    /// Semantic action for production 1:
    ///
    /// `EureList0 /* Vec<T>::Push */: Section EureList0;`
    ///
    #[parol_runtime::function_name::named]
    fn eure_list0_0(
        &mut self,
        _section: &ParseTreeType<'t>,
        _eure_list0: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut eure_list0 = pop_item!(self, eure_list0, EureList0, context);
        let section = pop_item!(self, section, Section, context);
        let eure_list0_0_built = EureList0 { section };
        // Add an element to the vector
        eure_list0.push(eure_list0_0_built);
        self.push(ASTType::EureList0(eure_list0), context);
        Ok(())
    }

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

    /// Semantic action for production 3:
    ///
    /// `EureList /* Vec<T>::Push */: Binding EureList;`
    ///
    #[parol_runtime::function_name::named]
    fn eure_list_0(
        &mut self,
        _binding: &ParseTreeType<'t>,
        _eure_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut eure_list = pop_item!(self, eure_list, EureList, context);
        let binding = pop_item!(self, binding, Binding, context);
        let eure_list_0_built = EureList { binding };
        // Add an element to the vector
        eure_list.push(eure_list_0_built);
        self.push(ASTType::EureList(eure_list), context);
        Ok(())
    }

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

    /// Semantic action for production 5:
    ///
    /// `EureOpt /* Option<T>::Some */: TopLevelBinding;`
    ///
    #[parol_runtime::function_name::named]
    fn eure_opt_0(&mut self, _top_level_binding: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let top_level_binding = pop_item!(self, top_level_binding, TopLevelBinding, context);
        let eure_opt_0_built = EureOpt { top_level_binding };
        self.push(ASTType::EureOpt(Some(eure_opt_0_built)), context);
        Ok(())
    }

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

    /// Semantic action for production 7:
    ///
    /// `TopLevelBinding: ValueBinding;`
    ///
    #[parol_runtime::function_name::named]
    fn top_level_binding_0(&mut self, _value_binding: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let value_binding = pop_item!(self, value_binding, ValueBinding, context);
        let top_level_binding_0_built = TopLevelBindingValueBinding { value_binding };
        let top_level_binding_0_built = TopLevelBinding::ValueBinding(top_level_binding_0_built);
        // Calling user action here
        self.user_grammar
            .top_level_binding(&top_level_binding_0_built)?;
        self.push(ASTType::TopLevelBinding(top_level_binding_0_built), context);
        Ok(())
    }

    /// Semantic action for production 8:
    ///
    /// `TopLevelBinding: TextBinding;`
    ///
    #[parol_runtime::function_name::named]
    fn top_level_binding_1(&mut self, _text_binding: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let text_binding = pop_item!(self, text_binding, TextBinding, context);
        let top_level_binding_1_built = TopLevelBindingTextBinding { text_binding };
        let top_level_binding_1_built = TopLevelBinding::TextBinding(top_level_binding_1_built);
        // Calling user action here
        self.user_grammar
            .top_level_binding(&top_level_binding_1_built)?;
        self.push(ASTType::TopLevelBinding(top_level_binding_1_built), context);
        Ok(())
    }

    /// Semantic action for production 9:
    ///
    /// `RootBinding: RootValueBinding;`
    ///
    #[parol_runtime::function_name::named]
    fn root_binding_0(&mut self, _root_value_binding: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let root_value_binding = pop_item!(self, root_value_binding, RootValueBinding, context);
        let root_binding_0_built = RootBindingRootValueBinding { root_value_binding };
        let root_binding_0_built = RootBinding::RootValueBinding(root_binding_0_built);
        // Calling user action here
        self.user_grammar.root_binding(&root_binding_0_built)?;
        self.push(ASTType::RootBinding(root_binding_0_built), context);
        Ok(())
    }

    /// Semantic action for production 10:
    ///
    /// `RootBinding: RootTextBinding;`
    ///
    #[parol_runtime::function_name::named]
    fn root_binding_1(&mut self, _root_text_binding: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let root_text_binding = pop_item!(self, root_text_binding, RootTextBinding, context);
        let root_binding_1_built = RootBindingRootTextBinding { root_text_binding };
        let root_binding_1_built = RootBinding::RootTextBinding(root_binding_1_built);
        // Calling user action here
        self.user_grammar.root_binding(&root_binding_1_built)?;
        self.push(ASTType::RootBinding(root_binding_1_built), context);
        Ok(())
    }

    /// Semantic action for production 11:
    ///
    /// `RootValueBinding: NewlineBind Value;`
    ///
    #[parol_runtime::function_name::named]
    fn root_value_binding(
        &mut self,
        _newline_bind: &ParseTreeType<'t>,
        _value: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let value = pop_item!(self, value, Value, context);
        let newline_bind = pop_item!(self, newline_bind, NewlineBind, context);
        let root_value_binding_built = RootValueBinding {
            newline_bind,
            value,
        };
        // Calling user action here
        self.user_grammar
            .root_value_binding(&root_value_binding_built)?;
        self.push(ASTType::RootValueBinding(root_value_binding_built), context);
        Ok(())
    }

    /// Semantic action for production 12:
    ///
    /// `RootTextBinding: NewlineTextStart RootTextBindingOpt /* Option */ RootTextBindingOpt0 /* Option */ RootTextBindingOpt1 /* Option */;`
    ///
    #[parol_runtime::function_name::named]
    fn root_text_binding(
        &mut self,
        _newline_text_start: &ParseTreeType<'t>,
        _root_text_binding_opt: &ParseTreeType<'t>,
        _root_text_binding_opt0: &ParseTreeType<'t>,
        _root_text_binding_opt1: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let root_text_binding_opt1 =
            pop_item!(self, root_text_binding_opt1, RootTextBindingOpt1, context);
        let root_text_binding_opt0 =
            pop_item!(self, root_text_binding_opt0, RootTextBindingOpt0, context);
        let root_text_binding_opt =
            pop_item!(self, root_text_binding_opt, RootTextBindingOpt, context);
        let newline_text_start = pop_item!(self, newline_text_start, NewlineTextStart, context);
        let root_text_binding_built = RootTextBinding {
            newline_text_start,
            root_text_binding_opt,
            root_text_binding_opt0,
            root_text_binding_opt1,
        };
        // Calling user action here
        self.user_grammar
            .root_text_binding(&root_text_binding_built)?;
        self.push(ASTType::RootTextBinding(root_text_binding_built), context);
        Ok(())
    }

    /// Semantic action for production 13:
    ///
    /// `RootTextBindingOpt1 /* Option<T>::Some */: GrammarNewline;`
    ///
    #[parol_runtime::function_name::named]
    fn root_text_binding_opt1_0(&mut self, _grammar_newline: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let grammar_newline = pop_item!(self, grammar_newline, GrammarNewline, context);
        let root_text_binding_opt1_0_built = RootTextBindingOpt1 { grammar_newline };
        self.push(
            ASTType::RootTextBindingOpt1(Some(root_text_binding_opt1_0_built)),
            context,
        );
        Ok(())
    }

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

    /// Semantic action for production 15:
    ///
    /// `RootTextBindingOpt0 /* Option<T>::Some */: Text;`
    ///
    #[parol_runtime::function_name::named]
    fn root_text_binding_opt0_0(&mut self, _text: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let text = pop_item!(self, text, Text, context);
        let root_text_binding_opt0_0_built = RootTextBindingOpt0 { text };
        self.push(
            ASTType::RootTextBindingOpt0(Some(root_text_binding_opt0_0_built)),
            context,
        );
        Ok(())
    }

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

    /// Semantic action for production 17:
    ///
    /// `RootTextBindingOpt /* Option<T>::Some */: Ws^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn root_text_binding_opt_0(&mut self, _ws: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let root_text_binding_opt_0_built = RootTextBindingOpt {};
        self.push(
            ASTType::RootTextBindingOpt(Some(root_text_binding_opt_0_built)),
            context,
        );
        Ok(())
    }

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

    /// Semantic action for production 19:
    ///
    /// `Binding: Keys BindingRhs;`
    ///
    #[parol_runtime::function_name::named]
    fn binding(
        &mut self,
        _keys: &ParseTreeType<'t>,
        _binding_rhs: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let binding_rhs = pop_item!(self, binding_rhs, BindingRhs, context);
        let keys = pop_item!(self, keys, Keys, context);
        let binding_built = Binding { keys, binding_rhs };
        // Calling user action here
        self.user_grammar.binding(&binding_built)?;
        self.push(ASTType::Binding(binding_built), context);
        Ok(())
    }

    /// Semantic action for production 20:
    ///
    /// `BindingRhs: ValueBinding;`
    ///
    #[parol_runtime::function_name::named]
    fn binding_rhs_0(&mut self, _value_binding: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let value_binding = pop_item!(self, value_binding, ValueBinding, context);
        let binding_rhs_0_built = BindingRhsValueBinding { value_binding };
        let binding_rhs_0_built = BindingRhs::ValueBinding(binding_rhs_0_built);
        // Calling user action here
        self.user_grammar.binding_rhs(&binding_rhs_0_built)?;
        self.push(ASTType::BindingRhs(binding_rhs_0_built), context);
        Ok(())
    }

    /// Semantic action for production 21:
    ///
    /// `BindingRhs: SectionBinding;`
    ///
    #[parol_runtime::function_name::named]
    fn binding_rhs_1(&mut self, _section_binding: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let section_binding = pop_item!(self, section_binding, SectionBinding, context);
        let binding_rhs_1_built = BindingRhsSectionBinding { section_binding };
        let binding_rhs_1_built = BindingRhs::SectionBinding(binding_rhs_1_built);
        // Calling user action here
        self.user_grammar.binding_rhs(&binding_rhs_1_built)?;
        self.push(ASTType::BindingRhs(binding_rhs_1_built), context);
        Ok(())
    }

    /// Semantic action for production 22:
    ///
    /// `BindingRhs: TextBinding;`
    ///
    #[parol_runtime::function_name::named]
    fn binding_rhs_2(&mut self, _text_binding: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let text_binding = pop_item!(self, text_binding, TextBinding, context);
        let binding_rhs_2_built = BindingRhsTextBinding { text_binding };
        let binding_rhs_2_built = BindingRhs::TextBinding(binding_rhs_2_built);
        // Calling user action here
        self.user_grammar.binding_rhs(&binding_rhs_2_built)?;
        self.push(ASTType::BindingRhs(binding_rhs_2_built), context);
        Ok(())
    }

    /// Semantic action for production 23:
    ///
    /// `ValueBinding: Bind Value;`
    ///
    #[parol_runtime::function_name::named]
    fn value_binding(
        &mut self,
        _bind: &ParseTreeType<'t>,
        _value: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let value = pop_item!(self, value, Value, context);
        let bind = pop_item!(self, bind, Bind, context);
        let value_binding_built = ValueBinding { bind, value };
        // Calling user action here
        self.user_grammar.value_binding(&value_binding_built)?;
        self.push(ASTType::ValueBinding(value_binding_built), context);
        Ok(())
    }

    /// Semantic action for production 24:
    ///
    /// `SectionBinding: Begin Eure End;`
    ///
    #[parol_runtime::function_name::named]
    fn section_binding(
        &mut self,
        _begin: &ParseTreeType<'t>,
        _eure: &ParseTreeType<'t>,
        _end: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let end = pop_item!(self, end, End, context);
        let eure = pop_item!(self, eure, Eure, context);
        let begin = pop_item!(self, begin, Begin, context);
        let section_binding_built = SectionBinding { begin, eure, end };
        // Calling user action here
        self.user_grammar.section_binding(&section_binding_built)?;
        self.push(ASTType::SectionBinding(section_binding_built), context);
        Ok(())
    }

    /// Semantic action for production 25:
    ///
    /// `TextBinding: TextStart TextBindingOpt /* Option */ TextBindingOpt0 /* Option */ TextBindingOpt1 /* Option */;`
    ///
    #[parol_runtime::function_name::named]
    fn text_binding(
        &mut self,
        _text_start: &ParseTreeType<'t>,
        _text_binding_opt: &ParseTreeType<'t>,
        _text_binding_opt0: &ParseTreeType<'t>,
        _text_binding_opt1: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let text_binding_opt1 = pop_item!(self, text_binding_opt1, TextBindingOpt1, context);
        let text_binding_opt0 = pop_item!(self, text_binding_opt0, TextBindingOpt0, context);
        let text_binding_opt = pop_item!(self, text_binding_opt, TextBindingOpt, context);
        let text_start = pop_item!(self, text_start, TextStart, context);
        let text_binding_built = TextBinding {
            text_start,
            text_binding_opt,
            text_binding_opt0,
            text_binding_opt1,
        };
        // Calling user action here
        self.user_grammar.text_binding(&text_binding_built)?;
        self.push(ASTType::TextBinding(text_binding_built), context);
        Ok(())
    }

    /// Semantic action for production 26:
    ///
    /// `TextBindingOpt1 /* Option<T>::Some */: GrammarNewline;`
    ///
    #[parol_runtime::function_name::named]
    fn text_binding_opt1_0(&mut self, _grammar_newline: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let grammar_newline = pop_item!(self, grammar_newline, GrammarNewline, context);
        let text_binding_opt1_0_built = TextBindingOpt1 { grammar_newline };
        self.push(
            ASTType::TextBindingOpt1(Some(text_binding_opt1_0_built)),
            context,
        );
        Ok(())
    }

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

    /// Semantic action for production 28:
    ///
    /// `TextBindingOpt0 /* Option<T>::Some */: Text;`
    ///
    #[parol_runtime::function_name::named]
    fn text_binding_opt0_0(&mut self, _text: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let text = pop_item!(self, text, Text, context);
        let text_binding_opt0_0_built = TextBindingOpt0 { text };
        self.push(
            ASTType::TextBindingOpt0(Some(text_binding_opt0_0_built)),
            context,
        );
        Ok(())
    }

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

    /// Semantic action for production 30:
    ///
    /// `TextBindingOpt /* Option<T>::Some */: Ws^ /* Clipped */;`
    ///
    #[parol_runtime::function_name::named]
    fn text_binding_opt_0(&mut self, _ws: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        self.pop(context);
        let text_binding_opt_0_built = TextBindingOpt {};
        self.push(
            ASTType::TextBindingOpt(Some(text_binding_opt_0_built)),
            context,
        );
        Ok(())
    }

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

    /// Semantic action for production 32:
    ///
    /// `Section: At Keys SectionBody;`
    ///
    #[parol_runtime::function_name::named]
    fn section(
        &mut self,
        _at: &ParseTreeType<'t>,
        _keys: &ParseTreeType<'t>,
        _section_body: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let section_body = pop_item!(self, section_body, SectionBody, context);
        let keys = pop_item!(self, keys, Keys, context);
        let at = pop_item!(self, at, At, context);
        let section_built = Section {
            at,
            keys,
            section_body,
        };
        // Calling user action here
        self.user_grammar.section(&section_built)?;
        self.push(ASTType::Section(section_built), context);
        Ok(())
    }

    /// Semantic action for production 33:
    ///
    /// `SectionBody: SectionBodyOpt /* Option */;`
    ///
    #[parol_runtime::function_name::named]
    fn section_body_0(&mut self, _section_body_opt: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let section_body_opt = pop_item!(self, section_body_opt, SectionBodyOpt, context);
        let section_body_0_built = SectionBodySectionBodyOpt { section_body_opt };
        let section_body_0_built = SectionBody::SectionBodyOpt(section_body_0_built);
        // Calling user action here
        self.user_grammar.section_body(&section_body_0_built)?;
        self.push(ASTType::SectionBody(section_body_0_built), context);
        Ok(())
    }

    /// Semantic action for production 34:
    ///
    /// `SectionBody: BlockBody;`
    ///
    #[parol_runtime::function_name::named]
    fn section_body_1(&mut self, _block_body: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let block_body = pop_item!(self, block_body, BlockBody, context);
        let section_body_1_built = SectionBodyBlockBody { block_body };
        let section_body_1_built = SectionBody::BlockBody(section_body_1_built);
        // Calling user action here
        self.user_grammar.section_body(&section_body_1_built)?;
        self.push(ASTType::SectionBody(section_body_1_built), context);
        Ok(())
    }

    /// Semantic action for production 35:
    ///
    /// `SectionBodyOpt /* Option<T>::Some */: FlatBody;`
    ///
    #[parol_runtime::function_name::named]
    fn section_body_opt_0(&mut self, _flat_body: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let flat_body = pop_item!(self, flat_body, FlatBody, context);
        let section_body_opt_0_built = SectionBodyOpt { flat_body };
        self.push(
            ASTType::SectionBodyOpt(Some(section_body_opt_0_built)),
            context,
        );
        Ok(())
    }

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

    /// Semantic action for production 37:
    ///
    /// `FlatBody: SectionHead FlatBodyList /* Vec */;`
    ///
    #[parol_runtime::function_name::named]
    fn flat_body(
        &mut self,
        _section_head: &ParseTreeType<'t>,
        _flat_body_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let flat_body_list = pop_and_reverse_item!(self, flat_body_list, FlatBodyList, context);
        let section_head = pop_item!(self, section_head, SectionHead, context);
        let flat_body_built = FlatBody {
            section_head,
            flat_body_list,
        };
        // Calling user action here
        self.user_grammar.flat_body(&flat_body_built)?;
        self.push(ASTType::FlatBody(flat_body_built), context);
        Ok(())
    }

    /// Semantic action for production 38:
    ///
    /// `FlatBodyList /* Vec<T>::Push */: Binding FlatBodyList;`
    ///
    #[parol_runtime::function_name::named]
    fn flat_body_list_0(
        &mut self,
        _binding: &ParseTreeType<'t>,
        _flat_body_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut flat_body_list = pop_item!(self, flat_body_list, FlatBodyList, context);
        let binding = pop_item!(self, binding, Binding, context);
        let flat_body_list_0_built = FlatBodyList { binding };
        // Add an element to the vector
        flat_body_list.push(flat_body_list_0_built);
        self.push(ASTType::FlatBodyList(flat_body_list), context);
        Ok(())
    }

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

    /// Semantic action for production 40:
    ///
    /// `SectionHead: RootBinding;`
    ///
    #[parol_runtime::function_name::named]
    fn section_head_0(&mut self, _root_binding: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let root_binding = pop_item!(self, root_binding, RootBinding, context);
        let section_head_0_built = SectionHeadRootBinding { root_binding };
        let section_head_0_built = SectionHead::RootBinding(section_head_0_built);
        // Calling user action here
        self.user_grammar.section_head(&section_head_0_built)?;
        self.push(ASTType::SectionHead(section_head_0_built), context);
        Ok(())
    }

    /// Semantic action for production 41:
    ///
    /// `SectionHead: NewlineHead;`
    ///
    #[parol_runtime::function_name::named]
    fn section_head_1(&mut self, _newline_head: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let newline_head = pop_item!(self, newline_head, NewlineHead, context);
        let section_head_1_built = SectionHeadNewlineHead { newline_head };
        let section_head_1_built = SectionHead::NewlineHead(section_head_1_built);
        // Calling user action here
        self.user_grammar.section_head(&section_head_1_built)?;
        self.push(ASTType::SectionHead(section_head_1_built), context);
        Ok(())
    }

    /// Semantic action for production 42:
    ///
    /// `NewlineHead: GrammarNewline NewlineHeadOpt /* Option */;`
    ///
    #[parol_runtime::function_name::named]
    fn newline_head(
        &mut self,
        _grammar_newline: &ParseTreeType<'t>,
        _newline_head_opt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let newline_head_opt = pop_item!(self, newline_head_opt, NewlineHeadOpt, context);
        let grammar_newline = pop_item!(self, grammar_newline, GrammarNewline, context);
        let newline_head_built = NewlineHead {
            grammar_newline,
            newline_head_opt,
        };
        // Calling user action here
        self.user_grammar.newline_head(&newline_head_built)?;
        self.push(ASTType::NewlineHead(newline_head_built), context);
        Ok(())
    }

    /// Semantic action for production 43:
    ///
    /// `NewlineHeadOpt /* Option<T>::Some */: FlatRootBinding;`
    ///
    #[parol_runtime::function_name::named]
    fn newline_head_opt_0(&mut self, _flat_root_binding: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let flat_root_binding = pop_item!(self, flat_root_binding, FlatRootBinding, context);
        let newline_head_opt_0_built = NewlineHeadOpt { flat_root_binding };
        self.push(
            ASTType::NewlineHeadOpt(Some(newline_head_opt_0_built)),
            context,
        );
        Ok(())
    }

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

    /// Semantic action for production 45:
    ///
    /// `FlatRootBinding: ValueBinding;`
    ///
    #[parol_runtime::function_name::named]
    fn flat_root_binding_0(&mut self, _value_binding: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let value_binding = pop_item!(self, value_binding, ValueBinding, context);
        let flat_root_binding_0_built = FlatRootBindingValueBinding { value_binding };
        let flat_root_binding_0_built = FlatRootBinding::ValueBinding(flat_root_binding_0_built);
        // Calling user action here
        self.user_grammar
            .flat_root_binding(&flat_root_binding_0_built)?;
        self.push(ASTType::FlatRootBinding(flat_root_binding_0_built), context);
        Ok(())
    }

    /// Semantic action for production 46:
    ///
    /// `FlatRootBinding: TextBinding;`
    ///
    #[parol_runtime::function_name::named]
    fn flat_root_binding_1(&mut self, _text_binding: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let text_binding = pop_item!(self, text_binding, TextBinding, context);
        let flat_root_binding_1_built = FlatRootBindingTextBinding { text_binding };
        let flat_root_binding_1_built = FlatRootBinding::TextBinding(flat_root_binding_1_built);
        // Calling user action here
        self.user_grammar
            .flat_root_binding(&flat_root_binding_1_built)?;
        self.push(ASTType::FlatRootBinding(flat_root_binding_1_built), context);
        Ok(())
    }

    /// Semantic action for production 47:
    ///
    /// `BlockBody: Begin Eure End;`
    ///
    #[parol_runtime::function_name::named]
    fn block_body(
        &mut self,
        _begin: &ParseTreeType<'t>,
        _eure: &ParseTreeType<'t>,
        _end: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let end = pop_item!(self, end, End, context);
        let eure = pop_item!(self, eure, Eure, context);
        let begin = pop_item!(self, begin, Begin, context);
        let block_body_built = BlockBody { begin, eure, end };
        // Calling user action here
        self.user_grammar.block_body(&block_body_built)?;
        self.push(ASTType::BlockBody(block_body_built), context);
        Ok(())
    }

    /// Semantic action for production 48:
    ///
    /// `Keys: FirstKey KeysList /* Vec */;`
    ///
    #[parol_runtime::function_name::named]
    fn keys(
        &mut self,
        _first_key: &ParseTreeType<'t>,
        _keys_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let keys_list = pop_and_reverse_item!(self, keys_list, KeysList, context);
        let first_key = pop_item!(self, first_key, FirstKey, context);
        let keys_built = Keys {
            first_key,
            keys_list,
        };
        // Calling user action here
        self.user_grammar.keys(&keys_built)?;
        self.push(ASTType::Keys(keys_built), context);
        Ok(())
    }

    /// Semantic action for production 49:
    ///
    /// `KeysList /* Vec<T>::Push */: KeyTail KeysList;`
    ///
    #[parol_runtime::function_name::named]
    fn keys_list_0(
        &mut self,
        _key_tail: &ParseTreeType<'t>,
        _keys_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut keys_list = pop_item!(self, keys_list, KeysList, context);
        let key_tail = pop_item!(self, key_tail, KeyTail, context);
        let keys_list_0_built = KeysList { key_tail };
        // Add an element to the vector
        keys_list.push(keys_list_0_built);
        self.push(ASTType::KeysList(keys_list), context);
        Ok(())
    }

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

    /// Semantic action for production 51:
    ///
    /// `FirstKey: Key;`
    ///
    #[parol_runtime::function_name::named]
    fn first_key_0(&mut self, _key: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let key = pop_item!(self, key, Key, context);
        let first_key_0_built = FirstKeyKey { key };
        let first_key_0_built = FirstKey::Key(first_key_0_built);
        // Calling user action here
        self.user_grammar.first_key(&first_key_0_built)?;
        self.push(ASTType::FirstKey(first_key_0_built), context);
        Ok(())
    }

    /// Semantic action for production 52:
    ///
    /// `FirstKey: ArrayMarker;`
    ///
    #[parol_runtime::function_name::named]
    fn first_key_1(&mut self, _array_marker: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let array_marker = pop_item!(self, array_marker, ArrayMarker, context);
        let first_key_1_built = FirstKeyArrayMarker { array_marker };
        let first_key_1_built = FirstKey::ArrayMarker(first_key_1_built);
        // Calling user action here
        self.user_grammar.first_key(&first_key_1_built)?;
        self.push(ASTType::FirstKey(first_key_1_built), context);
        Ok(())
    }

    /// Semantic action for production 53:
    ///
    /// `KeyTail: DotKey;`
    ///
    #[parol_runtime::function_name::named]
    fn key_tail_0(&mut self, _dot_key: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let dot_key = pop_item!(self, dot_key, DotKey, context);
        let key_tail_0_built = KeyTailDotKey { dot_key };
        let key_tail_0_built = KeyTail::DotKey(key_tail_0_built);
        // Calling user action here
        self.user_grammar.key_tail(&key_tail_0_built)?;
        self.push(ASTType::KeyTail(key_tail_0_built), context);
        Ok(())
    }

    /// Semantic action for production 54:
    ///
    /// `KeyTail: ArrayMarker;`
    ///
    #[parol_runtime::function_name::named]
    fn key_tail_1(&mut self, _array_marker: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let array_marker = pop_item!(self, array_marker, ArrayMarker, context);
        let key_tail_1_built = KeyTailArrayMarker { array_marker };
        let key_tail_1_built = KeyTail::ArrayMarker(key_tail_1_built);
        // Calling user action here
        self.user_grammar.key_tail(&key_tail_1_built)?;
        self.push(ASTType::KeyTail(key_tail_1_built), context);
        Ok(())
    }

    /// Semantic action for production 55:
    ///
    /// `DotKey: Dot Key;`
    ///
    #[parol_runtime::function_name::named]
    fn dot_key(&mut self, _dot: &ParseTreeType<'t>, _key: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let key = pop_item!(self, key, Key, context);
        let dot = pop_item!(self, dot, Dot, context);
        let dot_key_built = DotKey { dot, key };
        // Calling user action here
        self.user_grammar.dot_key(&dot_key_built)?;
        self.push(ASTType::DotKey(dot_key_built), context);
        Ok(())
    }

    /// Semantic action for production 56:
    ///
    /// `ArrayMarker: ArrayBegin ArrayMarkerOpt /* Option */ ArrayEnd;`
    ///
    #[parol_runtime::function_name::named]
    fn array_marker(
        &mut self,
        _array_begin: &ParseTreeType<'t>,
        _array_marker_opt: &ParseTreeType<'t>,
        _array_end: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let array_end = pop_item!(self, array_end, ArrayEnd, context);
        let array_marker_opt = pop_item!(self, array_marker_opt, ArrayMarkerOpt, context);
        let array_begin = pop_item!(self, array_begin, ArrayBegin, context);
        let array_marker_built = ArrayMarker {
            array_begin,
            array_marker_opt,
            array_end,
        };
        // Calling user action here
        self.user_grammar.array_marker(&array_marker_built)?;
        self.push(ASTType::ArrayMarker(array_marker_built), context);
        Ok(())
    }

    /// Semantic action for production 57:
    ///
    /// `ArrayMarkerOpt /* Option<T>::Some */: ArrayMarkerOptGroup;`
    ///
    #[parol_runtime::function_name::named]
    fn array_marker_opt_0(&mut self, _array_marker_opt_group: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let array_marker_opt_group =
            pop_item!(self, array_marker_opt_group, ArrayMarkerOptGroup, context);
        let array_marker_opt_0_built = ArrayMarkerOpt {
            array_marker_opt_group,
        };
        self.push(
            ASTType::ArrayMarkerOpt(Some(array_marker_opt_0_built)),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 58:
    ///
    /// `ArrayMarkerOptGroup: Integer;`
    ///
    #[parol_runtime::function_name::named]
    fn array_marker_opt_group_0(&mut self, _integer: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let integer = pop_item!(self, integer, Integer, context);
        let array_marker_opt_group_0_built = ArrayMarkerOptGroupInteger { integer };
        let array_marker_opt_group_0_built =
            ArrayMarkerOptGroup::Integer(array_marker_opt_group_0_built);
        self.push(
            ASTType::ArrayMarkerOptGroup(array_marker_opt_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 59:
    ///
    /// `ArrayMarkerOptGroup: Caret;`
    ///
    #[parol_runtime::function_name::named]
    fn array_marker_opt_group_1(&mut self, _caret: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let caret = pop_item!(self, caret, Caret, context);
        let array_marker_opt_group_1_built = ArrayMarkerOptGroupCaret { caret };
        let array_marker_opt_group_1_built =
            ArrayMarkerOptGroup::Caret(array_marker_opt_group_1_built);
        self.push(
            ASTType::ArrayMarkerOptGroup(array_marker_opt_group_1_built),
            context,
        );
        Ok(())
    }

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

    /// Semantic action for production 61:
    ///
    /// `Key: KeyIdent;`
    ///
    #[parol_runtime::function_name::named]
    fn key_0(&mut self, _key_ident: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let key_ident = pop_item!(self, key_ident, KeyIdent, context);
        let key_0_built = KeyKeyIdent { key_ident };
        let key_0_built = Key::KeyIdent(key_0_built);
        // Calling user action here
        self.user_grammar.key(&key_0_built)?;
        self.push(ASTType::Key(key_0_built), context);
        Ok(())
    }

    /// Semantic action for production 62:
    ///
    /// `Key: ExtensionNameSpace;`
    ///
    #[parol_runtime::function_name::named]
    fn key_1(&mut self, _extension_name_space: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let extension_name_space =
            pop_item!(self, extension_name_space, ExtensionNameSpace, context);
        let key_1_built = KeyExtensionNameSpace {
            extension_name_space,
        };
        let key_1_built = Key::ExtensionNameSpace(key_1_built);
        // Calling user action here
        self.user_grammar.key(&key_1_built)?;
        self.push(ASTType::Key(key_1_built), context);
        Ok(())
    }

    /// Semantic action for production 63:
    ///
    /// `Key: String;`
    ///
    #[parol_runtime::function_name::named]
    fn key_2(&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 key_2_built = KeyString { string };
        let key_2_built = Key::String(key_2_built);
        // Calling user action here
        self.user_grammar.key(&key_2_built)?;
        self.push(ASTType::Key(key_2_built), context);
        Ok(())
    }

    /// Semantic action for production 64:
    ///
    /// `Key: Integer;`
    ///
    #[parol_runtime::function_name::named]
    fn key_3(&mut self, _integer: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let integer = pop_item!(self, integer, Integer, context);
        let key_3_built = KeyInteger { integer };
        let key_3_built = Key::Integer(key_3_built);
        // Calling user action here
        self.user_grammar.key(&key_3_built)?;
        self.push(ASTType::Key(key_3_built), context);
        Ok(())
    }

    /// Semantic action for production 65:
    ///
    /// `Key: Float;`
    ///
    #[parol_runtime::function_name::named]
    fn key_4(&mut self, _float: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let float = pop_item!(self, float, Float, context);
        let key_4_built = KeyFloat { float };
        let key_4_built = Key::Float(key_4_built);
        // Calling user action here
        self.user_grammar.key(&key_4_built)?;
        self.push(ASTType::Key(key_4_built), context);
        Ok(())
    }

    /// Semantic action for production 66:
    ///
    /// `Key: KeyTuple;`
    ///
    #[parol_runtime::function_name::named]
    fn key_5(&mut self, _key_tuple: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let key_tuple = pop_item!(self, key_tuple, KeyTuple, context);
        let key_5_built = KeyKeyTuple { key_tuple };
        let key_5_built = Key::KeyTuple(key_5_built);
        // Calling user action here
        self.user_grammar.key(&key_5_built)?;
        self.push(ASTType::Key(key_5_built), context);
        Ok(())
    }

    /// Semantic action for production 67:
    ///
    /// `Key: TupleIndex;`
    ///
    #[parol_runtime::function_name::named]
    fn key_6(&mut self, _tuple_index: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let tuple_index = pop_item!(self, tuple_index, TupleIndex, context);
        let key_6_built = KeyTupleIndex { tuple_index };
        let key_6_built = Key::TupleIndex(key_6_built);
        // Calling user action here
        self.user_grammar.key(&key_6_built)?;
        self.push(ASTType::Key(key_6_built), context);
        Ok(())
    }

    /// Semantic action for production 68:
    ///
    /// `Key: Hole;`
    ///
    #[parol_runtime::function_name::named]
    fn key_7(&mut self, _hole: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let hole = pop_item!(self, hole, Hole, context);
        let key_7_built = KeyHole { hole };
        let key_7_built = Key::Hole(key_7_built);
        // Calling user action here
        self.user_grammar.key(&key_7_built)?;
        self.push(ASTType::Key(key_7_built), context);
        Ok(())
    }

    /// Semantic action for production 69:
    ///
    /// `TupleIndex: '#' Integer;`
    ///
    #[parol_runtime::function_name::named]
    fn tuple_index(
        &mut self,
        hash: &ParseTreeType<'t>,
        _integer: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let hash = hash.token()?.clone();
        let integer = pop_item!(self, integer, Integer, context);
        let tuple_index_built = TupleIndex { hash, integer };
        // Calling user action here
        self.user_grammar.tuple_index(&tuple_index_built)?;
        self.push(ASTType::TupleIndex(tuple_index_built), context);
        Ok(())
    }

    /// Semantic action for production 70:
    ///
    /// `ExtensionNameSpace: Ext KeyIdent;`
    ///
    #[parol_runtime::function_name::named]
    fn extension_name_space(
        &mut self,
        _ext: &ParseTreeType<'t>,
        _key_ident: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let key_ident = pop_item!(self, key_ident, KeyIdent, context);
        let ext = pop_item!(self, ext, Ext, context);
        let extension_name_space_built = ExtensionNameSpace { ext, key_ident };
        // Calling user action here
        self.user_grammar
            .extension_name_space(&extension_name_space_built)?;
        self.push(
            ASTType::ExtensionNameSpace(extension_name_space_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 71:
    ///
    /// `KeyTuple: LParen KeyTupleOpt /* Option */ RParen;`
    ///
    #[parol_runtime::function_name::named]
    fn key_tuple(
        &mut self,
        _l_paren: &ParseTreeType<'t>,
        _key_tuple_opt: &ParseTreeType<'t>,
        _r_paren: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let r_paren = pop_item!(self, r_paren, RParen, context);
        let key_tuple_opt = pop_item!(self, key_tuple_opt, KeyTupleOpt, context);
        let l_paren = pop_item!(self, l_paren, LParen, context);
        let key_tuple_built = KeyTuple {
            l_paren,
            key_tuple_opt,
            r_paren,
        };
        // Calling user action here
        self.user_grammar.key_tuple(&key_tuple_built)?;
        self.push(ASTType::KeyTuple(key_tuple_built), context);
        Ok(())
    }

    /// Semantic action for production 72:
    ///
    /// `KeyTupleOpt /* Option<T>::Some */: KeyTupleElements;`
    ///
    #[parol_runtime::function_name::named]
    fn key_tuple_opt_0(&mut self, _key_tuple_elements: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let key_tuple_elements = pop_item!(self, key_tuple_elements, KeyTupleElements, context);
        let key_tuple_opt_0_built = KeyTupleOpt { key_tuple_elements };
        self.push(ASTType::KeyTupleOpt(Some(key_tuple_opt_0_built)), context);
        Ok(())
    }

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

    /// Semantic action for production 74:
    ///
    /// `KeyTupleElements: KeyValue KeyTupleElementsOpt /* Option */;`
    ///
    #[parol_runtime::function_name::named]
    fn key_tuple_elements(
        &mut self,
        _key_value: &ParseTreeType<'t>,
        _key_tuple_elements_opt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let key_tuple_elements_opt =
            pop_item!(self, key_tuple_elements_opt, KeyTupleElementsOpt, context);
        let key_value = pop_item!(self, key_value, KeyValue, context);
        let key_tuple_elements_built = KeyTupleElements {
            key_value,
            key_tuple_elements_opt: key_tuple_elements_opt.map(Box::new),
        };
        // Calling user action here
        self.user_grammar
            .key_tuple_elements(&key_tuple_elements_built)?;
        self.push(ASTType::KeyTupleElements(key_tuple_elements_built), context);
        Ok(())
    }

    /// Semantic action for production 75:
    ///
    /// `KeyTupleElementsOpt /* Option<T>::Some */: KeyTupleElementsTail;`
    ///
    #[parol_runtime::function_name::named]
    fn key_tuple_elements_opt_0(
        &mut self,
        _key_tuple_elements_tail: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let key_tuple_elements_tail =
            pop_item!(self, key_tuple_elements_tail, KeyTupleElementsTail, context);
        let key_tuple_elements_opt_0_built = KeyTupleElementsOpt {
            key_tuple_elements_tail,
        };
        self.push(
            ASTType::KeyTupleElementsOpt(Some(key_tuple_elements_opt_0_built)),
            context,
        );
        Ok(())
    }

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

    /// Semantic action for production 77:
    ///
    /// `KeyTupleElementsTail: Comma KeyTupleElementsTailOpt /* Option */;`
    ///
    #[parol_runtime::function_name::named]
    fn key_tuple_elements_tail(
        &mut self,
        _comma: &ParseTreeType<'t>,
        _key_tuple_elements_tail_opt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let key_tuple_elements_tail_opt = pop_item!(
            self,
            key_tuple_elements_tail_opt,
            KeyTupleElementsTailOpt,
            context
        );
        let comma = pop_item!(self, comma, Comma, context);
        let key_tuple_elements_tail_built = KeyTupleElementsTail {
            comma,
            key_tuple_elements_tail_opt,
        };
        // Calling user action here
        self.user_grammar
            .key_tuple_elements_tail(&key_tuple_elements_tail_built)?;
        self.push(
            ASTType::KeyTupleElementsTail(key_tuple_elements_tail_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 78:
    ///
    /// `KeyTupleElementsTailOpt /* Option<T>::Some */: KeyTupleElements;`
    ///
    #[parol_runtime::function_name::named]
    fn key_tuple_elements_tail_opt_0(
        &mut self,
        _key_tuple_elements: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let key_tuple_elements = pop_item!(self, key_tuple_elements, KeyTupleElements, context);
        let key_tuple_elements_tail_opt_0_built = KeyTupleElementsTailOpt { key_tuple_elements };
        self.push(
            ASTType::KeyTupleElementsTailOpt(Some(key_tuple_elements_tail_opt_0_built)),
            context,
        );
        Ok(())
    }

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

    /// Semantic action for production 80:
    ///
    /// `KeyValue: Integer;`
    ///
    #[parol_runtime::function_name::named]
    fn key_value_0(&mut self, _integer: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let integer = pop_item!(self, integer, Integer, context);
        let key_value_0_built = KeyValueInteger { integer };
        let key_value_0_built = KeyValue::Integer(key_value_0_built);
        // Calling user action here
        self.user_grammar.key_value(&key_value_0_built)?;
        self.push(ASTType::KeyValue(key_value_0_built), context);
        Ok(())
    }

    /// Semantic action for production 81:
    ///
    /// `KeyValue: Boolean;`
    ///
    #[parol_runtime::function_name::named]
    fn key_value_1(&mut self, _boolean: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let boolean = pop_item!(self, boolean, Boolean, context);
        let key_value_1_built = KeyValueBoolean { boolean };
        let key_value_1_built = KeyValue::Boolean(key_value_1_built);
        // Calling user action here
        self.user_grammar.key_value(&key_value_1_built)?;
        self.push(ASTType::KeyValue(key_value_1_built), context);
        Ok(())
    }

    /// Semantic action for production 82:
    ///
    /// `KeyValue: Str;`
    ///
    #[parol_runtime::function_name::named]
    fn key_value_2(&mut self, _str: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let str = pop_item!(self, str, Str, context);
        let key_value_2_built = KeyValueStr { str };
        let key_value_2_built = KeyValue::Str(key_value_2_built);
        // Calling user action here
        self.user_grammar.key_value(&key_value_2_built)?;
        self.push(ASTType::KeyValue(key_value_2_built), context);
        Ok(())
    }

    /// Semantic action for production 83:
    ///
    /// `KeyValue: KeyTuple;`
    ///
    #[parol_runtime::function_name::named]
    fn key_value_3(&mut self, _key_tuple: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let key_tuple = pop_item!(self, key_tuple, KeyTuple, context);
        let key_value_3_built = KeyValueKeyTuple {
            key_tuple: Box::new(key_tuple),
        };
        let key_value_3_built = KeyValue::KeyTuple(key_value_3_built);
        // Calling user action here
        self.user_grammar.key_value(&key_value_3_built)?;
        self.push(ASTType::KeyValue(key_value_3_built), context);
        Ok(())
    }

    /// Semantic action for production 84:
    ///
    /// `KeyValue: Hole;`
    ///
    #[parol_runtime::function_name::named]
    fn key_value_4(&mut self, _hole: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let hole = pop_item!(self, hole, Hole, context);
        let key_value_4_built = KeyValueHole { hole };
        let key_value_4_built = KeyValue::Hole(key_value_4_built);
        // Calling user action here
        self.user_grammar.key_value(&key_value_4_built)?;
        self.push(ASTType::KeyValue(key_value_4_built), context);
        Ok(())
    }

    /// Semantic action for production 85:
    ///
    /// `KeyIdent: Ident;`
    ///
    #[parol_runtime::function_name::named]
    fn key_ident_0(&mut self, _ident: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let ident = pop_item!(self, ident, Ident, context);
        let key_ident_0_built = KeyIdentIdent { ident };
        let key_ident_0_built = KeyIdent::Ident(key_ident_0_built);
        // Calling user action here
        self.user_grammar.key_ident(&key_ident_0_built)?;
        self.push(ASTType::KeyIdent(key_ident_0_built), context);
        Ok(())
    }

    /// Semantic action for production 86:
    ///
    /// `KeyIdent: True;`
    ///
    #[parol_runtime::function_name::named]
    fn key_ident_1(&mut self, _true: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let r#true = pop_item!(self, r#true, True, context);
        let key_ident_1_built = KeyIdentTrue { r#true };
        let key_ident_1_built = KeyIdent::True(key_ident_1_built);
        // Calling user action here
        self.user_grammar.key_ident(&key_ident_1_built)?;
        self.push(ASTType::KeyIdent(key_ident_1_built), context);
        Ok(())
    }

    /// Semantic action for production 87:
    ///
    /// `KeyIdent: False;`
    ///
    #[parol_runtime::function_name::named]
    fn key_ident_2(&mut self, _false: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let r#false = pop_item!(self, r#false, False, context);
        let key_ident_2_built = KeyIdentFalse { r#false };
        let key_ident_2_built = KeyIdent::False(key_ident_2_built);
        // Calling user action here
        self.user_grammar.key_ident(&key_ident_2_built)?;
        self.push(ASTType::KeyIdent(key_ident_2_built), context);
        Ok(())
    }

    /// Semantic action for production 88:
    ///
    /// `KeyIdent: Null;`
    ///
    #[parol_runtime::function_name::named]
    fn key_ident_3(&mut self, _null: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let null = pop_item!(self, null, Null, context);
        let key_ident_3_built = KeyIdentNull { null };
        let key_ident_3_built = KeyIdent::Null(key_ident_3_built);
        // Calling user action here
        self.user_grammar.key_ident(&key_ident_3_built)?;
        self.push(ASTType::KeyIdent(key_ident_3_built), context);
        Ok(())
    }

    /// Semantic action for production 89:
    ///
    /// `Value: Object;`
    ///
    #[parol_runtime::function_name::named]
    fn value_0(&mut self, _object: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let object = pop_item!(self, object, Object, context);
        let value_0_built = ValueObject {
            object: Box::new(object),
        };
        let value_0_built = Value::Object(value_0_built);
        // Calling user action here
        self.user_grammar.value(&value_0_built)?;
        self.push(ASTType::Value(value_0_built), context);
        Ok(())
    }

    /// Semantic action for production 90:
    ///
    /// `Value: Array;`
    ///
    #[parol_runtime::function_name::named]
    fn value_1(&mut self, _array: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let array = pop_item!(self, array, Array, context);
        let value_1_built = ValueArray {
            array: Box::new(array),
        };
        let value_1_built = Value::Array(value_1_built);
        // Calling user action here
        self.user_grammar.value(&value_1_built)?;
        self.push(ASTType::Value(value_1_built), context);
        Ok(())
    }

    /// Semantic action for production 91:
    ///
    /// `Value: Tuple;`
    ///
    #[parol_runtime::function_name::named]
    fn value_2(&mut self, _tuple: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let tuple = pop_item!(self, tuple, Tuple, context);
        let value_2_built = ValueTuple {
            tuple: Box::new(tuple),
        };
        let value_2_built = Value::Tuple(value_2_built);
        // Calling user action here
        self.user_grammar.value(&value_2_built)?;
        self.push(ASTType::Value(value_2_built), context);
        Ok(())
    }

    /// Semantic action for production 92:
    ///
    /// `Value: Number;`
    ///
    #[parol_runtime::function_name::named]
    fn value_3(&mut self, _number: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let number = pop_item!(self, number, Number, context);
        let value_3_built = ValueNumber { number };
        let value_3_built = Value::Number(value_3_built);
        // Calling user action here
        self.user_grammar.value(&value_3_built)?;
        self.push(ASTType::Value(value_3_built), context);
        Ok(())
    }

    /// Semantic action for production 93:
    ///
    /// `Value: Boolean;`
    ///
    #[parol_runtime::function_name::named]
    fn value_4(&mut self, _boolean: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let boolean = pop_item!(self, boolean, Boolean, context);
        let value_4_built = ValueBoolean { boolean };
        let value_4_built = Value::Boolean(value_4_built);
        // Calling user action here
        self.user_grammar.value(&value_4_built)?;
        self.push(ASTType::Value(value_4_built), context);
        Ok(())
    }

    /// Semantic action for production 94:
    ///
    /// `Value: Null;`
    ///
    #[parol_runtime::function_name::named]
    fn value_5(&mut self, _null: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let null = pop_item!(self, null, Null, context);
        let value_5_built = ValueNull { null };
        let value_5_built = Value::Null(value_5_built);
        // Calling user action here
        self.user_grammar.value(&value_5_built)?;
        self.push(ASTType::Value(value_5_built), context);
        Ok(())
    }

    /// Semantic action for production 95:
    ///
    /// `Value: Strings;`
    ///
    #[parol_runtime::function_name::named]
    fn value_6(&mut self, _strings: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let strings = pop_item!(self, strings, Strings, context);
        let value_6_built = ValueStrings { strings };
        let value_6_built = Value::Strings(value_6_built);
        // Calling user action here
        self.user_grammar.value(&value_6_built)?;
        self.push(ASTType::Value(value_6_built), context);
        Ok(())
    }

    /// Semantic action for production 96:
    ///
    /// `Value: Hole;`
    ///
    #[parol_runtime::function_name::named]
    fn value_7(&mut self, _hole: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let hole = pop_item!(self, hole, Hole, context);
        let value_7_built = ValueHole { hole };
        let value_7_built = Value::Hole(value_7_built);
        // Calling user action here
        self.user_grammar.value(&value_7_built)?;
        self.push(ASTType::Value(value_7_built), context);
        Ok(())
    }

    /// Semantic action for production 97:
    ///
    /// `Value: CodeBlock;`
    ///
    #[parol_runtime::function_name::named]
    fn value_8(&mut self, _code_block: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let code_block = pop_item!(self, code_block, CodeBlock, context);
        let value_8_built = ValueCodeBlock { code_block };
        let value_8_built = Value::CodeBlock(value_8_built);
        // Calling user action here
        self.user_grammar.value(&value_8_built)?;
        self.push(ASTType::Value(value_8_built), context);
        Ok(())
    }

    /// Semantic action for production 98:
    ///
    /// `Value: InlineCode;`
    ///
    #[parol_runtime::function_name::named]
    fn value_9(&mut self, _inline_code: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let inline_code = pop_item!(self, inline_code, InlineCode, context);
        let value_9_built = ValueInlineCode { inline_code };
        let value_9_built = Value::InlineCode(value_9_built);
        // Calling user action here
        self.user_grammar.value(&value_9_built)?;
        self.push(ASTType::Value(value_9_built), context);
        Ok(())
    }

    /// Semantic action for production 99:
    ///
    /// `Object: Begin ObjectOpt /* Option */ ObjectList /* Vec */ End;`
    ///
    #[parol_runtime::function_name::named]
    fn object(
        &mut self,
        _begin: &ParseTreeType<'t>,
        _object_opt: &ParseTreeType<'t>,
        _object_list: &ParseTreeType<'t>,
        _end: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let end = pop_item!(self, end, End, context);
        let object_list = pop_and_reverse_item!(self, object_list, ObjectList, context);
        let object_opt = pop_item!(self, object_opt, ObjectOpt, context);
        let begin = pop_item!(self, begin, Begin, context);
        let object_built = Object {
            begin,
            object_opt,
            object_list,
            end,
        };
        // Calling user action here
        self.user_grammar.object(&object_built)?;
        self.push(ASTType::Object(object_built), context);
        Ok(())
    }

    /// Semantic action for production 100:
    ///
    /// `ObjectList /* Vec<T>::Push */: Keys MapBind Value ObjectOpt0 /* Option */ ObjectList;`
    ///
    #[parol_runtime::function_name::named]
    fn object_list_0(
        &mut self,
        _keys: &ParseTreeType<'t>,
        _map_bind: &ParseTreeType<'t>,
        _value: &ParseTreeType<'t>,
        _object_opt0: &ParseTreeType<'t>,
        _object_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut object_list = pop_item!(self, object_list, ObjectList, context);
        let object_opt0 = pop_item!(self, object_opt0, ObjectOpt0, context);
        let value = pop_item!(self, value, Value, context);
        let map_bind = pop_item!(self, map_bind, MapBind, context);
        let keys = pop_item!(self, keys, Keys, context);
        let object_list_0_built = ObjectList {
            object_opt0,
            value,
            map_bind,
            keys,
        };
        // Add an element to the vector
        object_list.push(object_list_0_built);
        self.push(ASTType::ObjectList(object_list), context);
        Ok(())
    }

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

    /// Semantic action for production 102:
    ///
    /// `ObjectOpt0 /* Option<T>::Some */: Comma;`
    ///
    #[parol_runtime::function_name::named]
    fn object_opt0_0(&mut self, _comma: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let comma = pop_item!(self, comma, Comma, context);
        let object_opt0_0_built = ObjectOpt0 { comma };
        self.push(ASTType::ObjectOpt0(Some(object_opt0_0_built)), context);
        Ok(())
    }

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

    /// Semantic action for production 104:
    ///
    /// `ObjectOpt /* Option<T>::Some */: ValueBinding ObjectOpt1 /* Option */;`
    ///
    #[parol_runtime::function_name::named]
    fn object_opt_0(
        &mut self,
        _value_binding: &ParseTreeType<'t>,
        _object_opt1: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let object_opt1 = pop_item!(self, object_opt1, ObjectOpt1, context);
        let value_binding = pop_item!(self, value_binding, ValueBinding, context);
        let object_opt_0_built = ObjectOpt {
            value_binding,
            object_opt1,
        };
        self.push(ASTType::ObjectOpt(Some(object_opt_0_built)), context);
        Ok(())
    }

    /// Semantic action for production 105:
    ///
    /// `ObjectOpt1 /* Option<T>::Some */: Comma;`
    ///
    #[parol_runtime::function_name::named]
    fn object_opt1_0(&mut self, _comma: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let comma = pop_item!(self, comma, Comma, context);
        let object_opt1_0_built = ObjectOpt1 { comma };
        self.push(ASTType::ObjectOpt1(Some(object_opt1_0_built)), context);
        Ok(())
    }

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

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

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

    /// Semantic action for production 109:
    ///
    /// `Array: ArrayBegin ArrayOpt /* Option */ ArrayEnd;`
    ///
    #[parol_runtime::function_name::named]
    fn array(
        &mut self,
        _array_begin: &ParseTreeType<'t>,
        _array_opt: &ParseTreeType<'t>,
        _array_end: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let array_end = pop_item!(self, array_end, ArrayEnd, context);
        let array_opt = pop_item!(self, array_opt, ArrayOpt, context);
        let array_begin = pop_item!(self, array_begin, ArrayBegin, context);
        let array_built = Array {
            array_begin,
            array_opt,
            array_end,
        };
        // Calling user action here
        self.user_grammar.array(&array_built)?;
        self.push(ASTType::Array(array_built), context);
        Ok(())
    }

    /// Semantic action for production 110:
    ///
    /// `ArrayOpt /* Option<T>::Some */: ArrayElements;`
    ///
    #[parol_runtime::function_name::named]
    fn array_opt_0(&mut self, _array_elements: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let array_elements = pop_item!(self, array_elements, ArrayElements, context);
        let array_opt_0_built = ArrayOpt { array_elements };
        self.push(ASTType::ArrayOpt(Some(array_opt_0_built)), context);
        Ok(())
    }

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

    /// Semantic action for production 112:
    ///
    /// `ArrayElements: Value ArrayElementsOpt /* Option */;`
    ///
    #[parol_runtime::function_name::named]
    fn array_elements(
        &mut self,
        _value: &ParseTreeType<'t>,
        _array_elements_opt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let array_elements_opt = pop_item!(self, array_elements_opt, ArrayElementsOpt, context);
        let value = pop_item!(self, value, Value, context);
        let array_elements_built = ArrayElements {
            value,
            array_elements_opt: array_elements_opt.map(Box::new),
        };
        // Calling user action here
        self.user_grammar.array_elements(&array_elements_built)?;
        self.push(ASTType::ArrayElements(array_elements_built), context);
        Ok(())
    }

    /// Semantic action for production 113:
    ///
    /// `ArrayElementsOpt /* Option<T>::Some */: ArrayElementsTail;`
    ///
    #[parol_runtime::function_name::named]
    fn array_elements_opt_0(&mut self, _array_elements_tail: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let array_elements_tail = pop_item!(self, array_elements_tail, ArrayElementsTail, context);
        let array_elements_opt_0_built = ArrayElementsOpt {
            array_elements_tail,
        };
        self.push(
            ASTType::ArrayElementsOpt(Some(array_elements_opt_0_built)),
            context,
        );
        Ok(())
    }

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

    /// Semantic action for production 115:
    ///
    /// `ArrayElementsTail: Comma ArrayElementsTailOpt /* Option */;`
    ///
    #[parol_runtime::function_name::named]
    fn array_elements_tail(
        &mut self,
        _comma: &ParseTreeType<'t>,
        _array_elements_tail_opt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let array_elements_tail_opt =
            pop_item!(self, array_elements_tail_opt, ArrayElementsTailOpt, context);
        let comma = pop_item!(self, comma, Comma, context);
        let array_elements_tail_built = ArrayElementsTail {
            comma,
            array_elements_tail_opt,
        };
        // Calling user action here
        self.user_grammar
            .array_elements_tail(&array_elements_tail_built)?;
        self.push(
            ASTType::ArrayElementsTail(array_elements_tail_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 116:
    ///
    /// `ArrayElementsTailOpt /* Option<T>::Some */: ArrayElements;`
    ///
    #[parol_runtime::function_name::named]
    fn array_elements_tail_opt_0(&mut self, _array_elements: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let array_elements = pop_item!(self, array_elements, ArrayElements, context);
        let array_elements_tail_opt_0_built = ArrayElementsTailOpt { array_elements };
        self.push(
            ASTType::ArrayElementsTailOpt(Some(array_elements_tail_opt_0_built)),
            context,
        );
        Ok(())
    }

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

    /// Semantic action for production 118:
    ///
    /// `Tuple: LParen TupleOpt /* Option */ RParen;`
    ///
    #[parol_runtime::function_name::named]
    fn tuple(
        &mut self,
        _l_paren: &ParseTreeType<'t>,
        _tuple_opt: &ParseTreeType<'t>,
        _r_paren: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let r_paren = pop_item!(self, r_paren, RParen, context);
        let tuple_opt = pop_item!(self, tuple_opt, TupleOpt, context);
        let l_paren = pop_item!(self, l_paren, LParen, context);
        let tuple_built = Tuple {
            l_paren,
            tuple_opt,
            r_paren,
        };
        // Calling user action here
        self.user_grammar.tuple(&tuple_built)?;
        self.push(ASTType::Tuple(tuple_built), context);
        Ok(())
    }

    /// Semantic action for production 119:
    ///
    /// `TupleOpt /* Option<T>::Some */: TupleElements;`
    ///
    #[parol_runtime::function_name::named]
    fn tuple_opt_0(&mut self, _tuple_elements: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let tuple_elements = pop_item!(self, tuple_elements, TupleElements, context);
        let tuple_opt_0_built = TupleOpt { tuple_elements };
        self.push(ASTType::TupleOpt(Some(tuple_opt_0_built)), context);
        Ok(())
    }

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

    /// Semantic action for production 121:
    ///
    /// `TupleElements: Value TupleElementsOpt /* Option */;`
    ///
    #[parol_runtime::function_name::named]
    fn tuple_elements(
        &mut self,
        _value: &ParseTreeType<'t>,
        _tuple_elements_opt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let tuple_elements_opt = pop_item!(self, tuple_elements_opt, TupleElementsOpt, context);
        let value = pop_item!(self, value, Value, context);
        let tuple_elements_built = TupleElements {
            value,
            tuple_elements_opt: tuple_elements_opt.map(Box::new),
        };
        // Calling user action here
        self.user_grammar.tuple_elements(&tuple_elements_built)?;
        self.push(ASTType::TupleElements(tuple_elements_built), context);
        Ok(())
    }

    /// Semantic action for production 122:
    ///
    /// `TupleElementsOpt /* Option<T>::Some */: TupleElementsTail;`
    ///
    #[parol_runtime::function_name::named]
    fn tuple_elements_opt_0(&mut self, _tuple_elements_tail: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let tuple_elements_tail = pop_item!(self, tuple_elements_tail, TupleElementsTail, context);
        let tuple_elements_opt_0_built = TupleElementsOpt {
            tuple_elements_tail,
        };
        self.push(
            ASTType::TupleElementsOpt(Some(tuple_elements_opt_0_built)),
            context,
        );
        Ok(())
    }

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

    /// Semantic action for production 124:
    ///
    /// `TupleElementsTail: Comma TupleElementsTailOpt /* Option */;`
    ///
    #[parol_runtime::function_name::named]
    fn tuple_elements_tail(
        &mut self,
        _comma: &ParseTreeType<'t>,
        _tuple_elements_tail_opt: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let tuple_elements_tail_opt =
            pop_item!(self, tuple_elements_tail_opt, TupleElementsTailOpt, context);
        let comma = pop_item!(self, comma, Comma, context);
        let tuple_elements_tail_built = TupleElementsTail {
            comma,
            tuple_elements_tail_opt,
        };
        // Calling user action here
        self.user_grammar
            .tuple_elements_tail(&tuple_elements_tail_built)?;
        self.push(
            ASTType::TupleElementsTail(tuple_elements_tail_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 125:
    ///
    /// `TupleElementsTailOpt /* Option<T>::Some */: TupleElements;`
    ///
    #[parol_runtime::function_name::named]
    fn tuple_elements_tail_opt_0(&mut self, _tuple_elements: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let tuple_elements = pop_item!(self, tuple_elements, TupleElements, context);
        let tuple_elements_tail_opt_0_built = TupleElementsTailOpt { tuple_elements };
        self.push(
            ASTType::TupleElementsTailOpt(Some(tuple_elements_tail_opt_0_built)),
            context,
        );
        Ok(())
    }

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

    /// Semantic action for production 127:
    ///
    /// `Number: Float;`
    ///
    #[parol_runtime::function_name::named]
    fn number_0(&mut self, _float: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let float = pop_item!(self, float, Float, context);
        let number_0_built = NumberFloat { float };
        let number_0_built = Number::Float(number_0_built);
        // Calling user action here
        self.user_grammar.number(&number_0_built)?;
        self.push(ASTType::Number(number_0_built), context);
        Ok(())
    }

    /// Semantic action for production 128:
    ///
    /// `Number: Integer;`
    ///
    #[parol_runtime::function_name::named]
    fn number_1(&mut self, _integer: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let integer = pop_item!(self, integer, Integer, context);
        let number_1_built = NumberInteger { integer };
        let number_1_built = Number::Integer(number_1_built);
        // Calling user action here
        self.user_grammar.number(&number_1_built)?;
        self.push(ASTType::Number(number_1_built), context);
        Ok(())
    }

    /// Semantic action for production 129:
    ///
    /// `Number: Inf;`
    ///
    #[parol_runtime::function_name::named]
    fn number_2(&mut self, _inf: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let inf = pop_item!(self, inf, Inf, context);
        let number_2_built = NumberInf { inf };
        let number_2_built = Number::Inf(number_2_built);
        // Calling user action here
        self.user_grammar.number(&number_2_built)?;
        self.push(ASTType::Number(number_2_built), context);
        Ok(())
    }

    /// Semantic action for production 130:
    ///
    /// `Number: NaN;`
    ///
    #[parol_runtime::function_name::named]
    fn number_3(&mut self, _na_n: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let na_n = pop_item!(self, na_n, NaN, context);
        let number_3_built = NumberNaN { na_n };
        let number_3_built = Number::NaN(number_3_built);
        // Calling user action here
        self.user_grammar.number(&number_3_built)?;
        self.push(ASTType::Number(number_3_built), context);
        Ok(())
    }

    /// Semantic action for production 131:
    ///
    /// `Integer: <INITIAL, Header>/[-+]?\d[\d_]*/;`
    ///
    #[parol_runtime::function_name::named]
    fn integer(&mut self, integer: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let integer = integer.token()?.clone();
        let integer_built = Integer { integer };
        // Calling user action here
        self.user_grammar.integer(&integer_built)?;
        self.push(ASTType::Integer(integer_built), context);
        Ok(())
    }

    /// Semantic action for production 132:
    ///
    /// `Float: <INITIAL, Header>/[-+]?\d[\d_]*\.\d+([eE][-+]?\d+)?(f32|f64)?|[-+]?\d[\d_]*[eE][-+]?\d+(f32|f64)?/;`
    ///
    #[parol_runtime::function_name::named]
    fn float(&mut self, float: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let float = float.token()?.clone();
        let float_built = Float { float };
        // Calling user action here
        self.user_grammar.float(&float_built)?;
        self.push(ASTType::Float(float_built), context);
        Ok(())
    }

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

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

    /// Semantic action for production 135:
    ///
    /// `Boolean: True;`
    ///
    #[parol_runtime::function_name::named]
    fn boolean_0(&mut self, _true: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let r#true = pop_item!(self, r#true, True, context);
        let boolean_0_built = BooleanTrue { r#true };
        let boolean_0_built = Boolean::True(boolean_0_built);
        // Calling user action here
        self.user_grammar.boolean(&boolean_0_built)?;
        self.push(ASTType::Boolean(boolean_0_built), context);
        Ok(())
    }

    /// Semantic action for production 136:
    ///
    /// `Boolean: False;`
    ///
    #[parol_runtime::function_name::named]
    fn boolean_1(&mut self, _false: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let r#false = pop_item!(self, r#false, False, context);
        let boolean_1_built = BooleanFalse { r#false };
        let boolean_1_built = Boolean::False(boolean_1_built);
        // Calling user action here
        self.user_grammar.boolean(&boolean_1_built)?;
        self.push(ASTType::Boolean(boolean_1_built), context);
        Ok(())
    }

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

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

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

    /// Semantic action for production 140:
    ///
    /// `Hole: <INITIAL, Header>/![\p{XID_Start}_]?[\p{XID_Continue}-]*/;`
    ///
    #[parol_runtime::function_name::named]
    fn hole(&mut self, hole: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let hole = hole.token()?.clone();
        let hole_built = Hole { hole };
        // Calling user action here
        self.user_grammar.hole(&hole_built)?;
        self.push(ASTType::Hole(hole_built), context);
        Ok(())
    }

    /// Semantic action for production 141:
    ///
    /// `String: Str;`
    ///
    #[parol_runtime::function_name::named]
    fn string_0(&mut self, _str: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let str = pop_item!(self, str, Str, context);
        let string_0_built = StringStr { str };
        let string_0_built = String::Str(string_0_built);
        // Calling user action here
        self.user_grammar.string(&string_0_built)?;
        self.push(ASTType::String(string_0_built), context);
        Ok(())
    }

    /// Semantic action for production 142:
    ///
    /// `String: LitStr;`
    ///
    #[parol_runtime::function_name::named]
    fn string_1(&mut self, _lit_str: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let lit_str = pop_item!(self, lit_str, LitStr, context);
        let string_1_built = StringLitStr { lit_str };
        let string_1_built = String::LitStr(string_1_built);
        // Calling user action here
        self.user_grammar.string(&string_1_built)?;
        self.push(ASTType::String(string_1_built), context);
        Ok(())
    }

    /// Semantic action for production 143:
    ///
    /// `String: LitStr1;`
    ///
    #[parol_runtime::function_name::named]
    fn string_2(&mut self, _lit_str1: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let lit_str1 = pop_item!(self, lit_str1, LitStr1, context);
        let string_2_built = StringLitStr1 { lit_str1 };
        let string_2_built = String::LitStr1(string_2_built);
        // Calling user action here
        self.user_grammar.string(&string_2_built)?;
        self.push(ASTType::String(string_2_built), context);
        Ok(())
    }

    /// Semantic action for production 144:
    ///
    /// `String: LitStr2;`
    ///
    #[parol_runtime::function_name::named]
    fn string_3(&mut self, _lit_str2: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let lit_str2 = pop_item!(self, lit_str2, LitStr2, context);
        let string_3_built = StringLitStr2 { lit_str2 };
        let string_3_built = String::LitStr2(string_3_built);
        // Calling user action here
        self.user_grammar.string(&string_3_built)?;
        self.push(ASTType::String(string_3_built), context);
        Ok(())
    }

    /// Semantic action for production 145:
    ///
    /// `String: LitStr3;`
    ///
    #[parol_runtime::function_name::named]
    fn string_4(&mut self, _lit_str3: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let lit_str3 = pop_item!(self, lit_str3, LitStr3, context);
        let string_4_built = StringLitStr3 { lit_str3 };
        let string_4_built = String::LitStr3(string_4_built);
        // Calling user action here
        self.user_grammar.string(&string_4_built)?;
        self.push(ASTType::String(string_4_built), context);
        Ok(())
    }

    /// Semantic action for production 146:
    ///
    /// `Strings: String StringsList /* Vec */;`
    ///
    #[parol_runtime::function_name::named]
    fn strings(
        &mut self,
        _string: &ParseTreeType<'t>,
        _strings_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let strings_list = pop_and_reverse_item!(self, strings_list, StringsList, context);
        let string = pop_item!(self, string, String, context);
        let strings_built = Strings {
            string,
            strings_list,
        };
        // Calling user action here
        self.user_grammar.strings(&strings_built)?;
        self.push(ASTType::Strings(strings_built), context);
        Ok(())
    }

    /// Semantic action for production 147:
    ///
    /// `StringsList /* Vec<T>::Push */: Continue String StringsList;`
    ///
    #[parol_runtime::function_name::named]
    fn strings_list_0(
        &mut self,
        _continue: &ParseTreeType<'t>,
        _string: &ParseTreeType<'t>,
        _strings_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut strings_list = pop_item!(self, strings_list, StringsList, context);
        let string = pop_item!(self, string, String, context);
        let r#continue = pop_item!(self, r#continue, Continue, context);
        let strings_list_0_built = StringsList { string, r#continue };
        // Add an element to the vector
        strings_list.push(strings_list_0_built);
        self.push(ASTType::StringsList(strings_list), context);
        Ok(())
    }

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

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

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

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

    /// Semantic action for production 152:
    ///
    /// `InlineCode: DelimCode;`
    ///
    #[parol_runtime::function_name::named]
    fn inline_code_0(&mut self, _delim_code: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let delim_code = pop_item!(self, delim_code, DelimCode, context);
        let inline_code_0_built = InlineCodeDelimCode { delim_code };
        let inline_code_0_built = InlineCode::DelimCode(inline_code_0_built);
        // Calling user action here
        self.user_grammar.inline_code(&inline_code_0_built)?;
        self.push(ASTType::InlineCode(inline_code_0_built), context);
        Ok(())
    }

    /// Semantic action for production 153:
    ///
    /// `InlineCode: InlineCode1;`
    ///
    #[parol_runtime::function_name::named]
    fn inline_code_1(&mut self, _inline_code1: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let inline_code1 = pop_item!(self, inline_code1, InlineCode1, context);
        let inline_code_1_built = InlineCodeInlineCode1 { inline_code1 };
        let inline_code_1_built = InlineCode::InlineCode1(inline_code_1_built);
        // Calling user action here
        self.user_grammar.inline_code(&inline_code_1_built)?;
        self.push(ASTType::InlineCode(inline_code_1_built), context);
        Ok(())
    }

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

    /// Semantic action for production 155:
    ///
    /// `LitStr1: LitStr1Start LitStr1List /* Vec */ LitStr1End;`
    ///
    #[parol_runtime::function_name::named]
    fn lit_str1(
        &mut self,
        _lit_str1_start: &ParseTreeType<'t>,
        _lit_str1_list: &ParseTreeType<'t>,
        _lit_str1_end: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let lit_str1_end = pop_item!(self, lit_str1_end, LitStr1End, context);
        let lit_str1_list = pop_and_reverse_item!(self, lit_str1_list, LitStr1List, context);
        let lit_str1_start = pop_item!(self, lit_str1_start, LitStr1Start, context);
        let lit_str1_built = LitStr1 {
            lit_str1_start,
            lit_str1_list,
            lit_str1_end,
        };
        // Calling user action here
        self.user_grammar.lit_str1(&lit_str1_built)?;
        self.push(ASTType::LitStr1(lit_str1_built), context);
        Ok(())
    }

    /// Semantic action for production 156:
    ///
    /// `LitStr1List /* Vec<T>::Push */: LitStr1ListGroup LitStr1List;`
    ///
    #[parol_runtime::function_name::named]
    fn lit_str1_list_0(
        &mut self,
        _lit_str1_list_group: &ParseTreeType<'t>,
        _lit_str1_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut lit_str1_list = pop_item!(self, lit_str1_list, LitStr1List, context);
        let lit_str1_list_group = pop_item!(self, lit_str1_list_group, LitStr1ListGroup, context);
        let lit_str1_list_0_built = LitStr1List {
            lit_str1_list_group,
        };
        // Add an element to the vector
        lit_str1_list.push(lit_str1_list_0_built);
        self.push(ASTType::LitStr1List(lit_str1_list), context);
        Ok(())
    }

    /// Semantic action for production 157:
    ///
    /// `LitStr1ListGroup: NoSQuote;`
    ///
    #[parol_runtime::function_name::named]
    fn lit_str1_list_group_0(&mut self, _no_s_quote: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let no_s_quote = pop_item!(self, no_s_quote, NoSQuote, context);
        let lit_str1_list_group_0_built = LitStr1ListGroupNoSQuote { no_s_quote };
        let lit_str1_list_group_0_built = LitStr1ListGroup::NoSQuote(lit_str1_list_group_0_built);
        self.push(
            ASTType::LitStr1ListGroup(lit_str1_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 158:
    ///
    /// `LitStr1ListGroup: SQuote;`
    ///
    #[parol_runtime::function_name::named]
    fn lit_str1_list_group_1(&mut self, _s_quote: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let s_quote = pop_item!(self, s_quote, SQuote, context);
        let lit_str1_list_group_1_built = LitStr1ListGroupSQuote { s_quote };
        let lit_str1_list_group_1_built = LitStr1ListGroup::SQuote(lit_str1_list_group_1_built);
        self.push(
            ASTType::LitStr1ListGroup(lit_str1_list_group_1_built),
            context,
        );
        Ok(())
    }

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

    /// Semantic action for production 160:
    ///
    /// `LitStr2: LitStr2Start LitStr2List /* Vec */ LitStr2End;`
    ///
    #[parol_runtime::function_name::named]
    fn lit_str2(
        &mut self,
        _lit_str2_start: &ParseTreeType<'t>,
        _lit_str2_list: &ParseTreeType<'t>,
        _lit_str2_end: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let lit_str2_end = pop_item!(self, lit_str2_end, LitStr2End, context);
        let lit_str2_list = pop_and_reverse_item!(self, lit_str2_list, LitStr2List, context);
        let lit_str2_start = pop_item!(self, lit_str2_start, LitStr2Start, context);
        let lit_str2_built = LitStr2 {
            lit_str2_start,
            lit_str2_list,
            lit_str2_end,
        };
        // Calling user action here
        self.user_grammar.lit_str2(&lit_str2_built)?;
        self.push(ASTType::LitStr2(lit_str2_built), context);
        Ok(())
    }

    /// Semantic action for production 161:
    ///
    /// `LitStr2List /* Vec<T>::Push */: LitStr2ListGroup LitStr2List;`
    ///
    #[parol_runtime::function_name::named]
    fn lit_str2_list_0(
        &mut self,
        _lit_str2_list_group: &ParseTreeType<'t>,
        _lit_str2_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut lit_str2_list = pop_item!(self, lit_str2_list, LitStr2List, context);
        let lit_str2_list_group = pop_item!(self, lit_str2_list_group, LitStr2ListGroup, context);
        let lit_str2_list_0_built = LitStr2List {
            lit_str2_list_group,
        };
        // Add an element to the vector
        lit_str2_list.push(lit_str2_list_0_built);
        self.push(ASTType::LitStr2List(lit_str2_list), context);
        Ok(())
    }

    /// Semantic action for production 162:
    ///
    /// `LitStr2ListGroup: NoSQuote;`
    ///
    #[parol_runtime::function_name::named]
    fn lit_str2_list_group_0(&mut self, _no_s_quote: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let no_s_quote = pop_item!(self, no_s_quote, NoSQuote, context);
        let lit_str2_list_group_0_built = LitStr2ListGroupNoSQuote { no_s_quote };
        let lit_str2_list_group_0_built = LitStr2ListGroup::NoSQuote(lit_str2_list_group_0_built);
        self.push(
            ASTType::LitStr2ListGroup(lit_str2_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 163:
    ///
    /// `LitStr2ListGroup: SQuote;`
    ///
    #[parol_runtime::function_name::named]
    fn lit_str2_list_group_1(&mut self, _s_quote: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let s_quote = pop_item!(self, s_quote, SQuote, context);
        let lit_str2_list_group_1_built = LitStr2ListGroupSQuote { s_quote };
        let lit_str2_list_group_1_built = LitStr2ListGroup::SQuote(lit_str2_list_group_1_built);
        self.push(
            ASTType::LitStr2ListGroup(lit_str2_list_group_1_built),
            context,
        );
        Ok(())
    }

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

    /// Semantic action for production 165:
    ///
    /// `LitStr3: LitStr3Start LitStr3List /* Vec */ LitStr3End;`
    ///
    #[parol_runtime::function_name::named]
    fn lit_str3(
        &mut self,
        _lit_str3_start: &ParseTreeType<'t>,
        _lit_str3_list: &ParseTreeType<'t>,
        _lit_str3_end: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let lit_str3_end = pop_item!(self, lit_str3_end, LitStr3End, context);
        let lit_str3_list = pop_and_reverse_item!(self, lit_str3_list, LitStr3List, context);
        let lit_str3_start = pop_item!(self, lit_str3_start, LitStr3Start, context);
        let lit_str3_built = LitStr3 {
            lit_str3_start,
            lit_str3_list,
            lit_str3_end,
        };
        // Calling user action here
        self.user_grammar.lit_str3(&lit_str3_built)?;
        self.push(ASTType::LitStr3(lit_str3_built), context);
        Ok(())
    }

    /// Semantic action for production 166:
    ///
    /// `LitStr3List /* Vec<T>::Push */: LitStr3ListGroup LitStr3List;`
    ///
    #[parol_runtime::function_name::named]
    fn lit_str3_list_0(
        &mut self,
        _lit_str3_list_group: &ParseTreeType<'t>,
        _lit_str3_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut lit_str3_list = pop_item!(self, lit_str3_list, LitStr3List, context);
        let lit_str3_list_group = pop_item!(self, lit_str3_list_group, LitStr3ListGroup, context);
        let lit_str3_list_0_built = LitStr3List {
            lit_str3_list_group,
        };
        // Add an element to the vector
        lit_str3_list.push(lit_str3_list_0_built);
        self.push(ASTType::LitStr3List(lit_str3_list), context);
        Ok(())
    }

    /// Semantic action for production 167:
    ///
    /// `LitStr3ListGroup: NoSQuote;`
    ///
    #[parol_runtime::function_name::named]
    fn lit_str3_list_group_0(&mut self, _no_s_quote: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let no_s_quote = pop_item!(self, no_s_quote, NoSQuote, context);
        let lit_str3_list_group_0_built = LitStr3ListGroupNoSQuote { no_s_quote };
        let lit_str3_list_group_0_built = LitStr3ListGroup::NoSQuote(lit_str3_list_group_0_built);
        self.push(
            ASTType::LitStr3ListGroup(lit_str3_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 168:
    ///
    /// `LitStr3ListGroup: SQuote;`
    ///
    #[parol_runtime::function_name::named]
    fn lit_str3_list_group_1(&mut self, _s_quote: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let s_quote = pop_item!(self, s_quote, SQuote, context);
        let lit_str3_list_group_1_built = LitStr3ListGroupSQuote { s_quote };
        let lit_str3_list_group_1_built = LitStr3ListGroup::SQuote(lit_str3_list_group_1_built);
        self.push(
            ASTType::LitStr3ListGroup(lit_str3_list_group_1_built),
            context,
        );
        Ok(())
    }

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

    /// Semantic action for production 170:
    ///
    /// `DelimCode: DelimCode3;`
    ///
    #[parol_runtime::function_name::named]
    fn delim_code_0(&mut self, _delim_code3: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let delim_code3 = pop_item!(self, delim_code3, DelimCode3, context);
        let delim_code_0_built = DelimCodeDelimCode3 { delim_code3 };
        let delim_code_0_built = DelimCode::DelimCode3(delim_code_0_built);
        // Calling user action here
        self.user_grammar.delim_code(&delim_code_0_built)?;
        self.push(ASTType::DelimCode(delim_code_0_built), context);
        Ok(())
    }

    /// Semantic action for production 171:
    ///
    /// `DelimCode: DelimCode2;`
    ///
    #[parol_runtime::function_name::named]
    fn delim_code_1(&mut self, _delim_code2: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let delim_code2 = pop_item!(self, delim_code2, DelimCode2, context);
        let delim_code_1_built = DelimCodeDelimCode2 { delim_code2 };
        let delim_code_1_built = DelimCode::DelimCode2(delim_code_1_built);
        // Calling user action here
        self.user_grammar.delim_code(&delim_code_1_built)?;
        self.push(ASTType::DelimCode(delim_code_1_built), context);
        Ok(())
    }

    /// Semantic action for production 172:
    ///
    /// `DelimCode: DelimCode1;`
    ///
    #[parol_runtime::function_name::named]
    fn delim_code_2(&mut self, _delim_code1: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let delim_code1 = pop_item!(self, delim_code1, DelimCode1, context);
        let delim_code_2_built = DelimCodeDelimCode1 { delim_code1 };
        let delim_code_2_built = DelimCode::DelimCode1(delim_code_2_built);
        // Calling user action here
        self.user_grammar.delim_code(&delim_code_2_built)?;
        self.push(ASTType::DelimCode(delim_code_2_built), context);
        Ok(())
    }

    /// Semantic action for production 173:
    ///
    /// `DelimCode1: DelimCodeStart1 DelimCode1List /* Vec */ DelimCodeEnd1;`
    ///
    #[parol_runtime::function_name::named]
    fn delim_code1(
        &mut self,
        _delim_code_start1: &ParseTreeType<'t>,
        _delim_code1_list: &ParseTreeType<'t>,
        _delim_code_end1: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let delim_code_end1 = pop_item!(self, delim_code_end1, DelimCodeEnd1, context);
        let delim_code1_list =
            pop_and_reverse_item!(self, delim_code1_list, DelimCode1List, context);
        let delim_code_start1 = pop_item!(self, delim_code_start1, DelimCodeStart1, context);
        let delim_code1_built = DelimCode1 {
            delim_code_start1,
            delim_code1_list,
            delim_code_end1,
        };
        // Calling user action here
        self.user_grammar.delim_code1(&delim_code1_built)?;
        self.push(ASTType::DelimCode1(delim_code1_built), context);
        Ok(())
    }

    /// Semantic action for production 174:
    ///
    /// `DelimCode1List /* Vec<T>::Push */: DelimCode1ListGroup DelimCode1List;`
    ///
    #[parol_runtime::function_name::named]
    fn delim_code1_list_0(
        &mut self,
        _delim_code1_list_group: &ParseTreeType<'t>,
        _delim_code1_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut delim_code1_list = pop_item!(self, delim_code1_list, DelimCode1List, context);
        let delim_code1_list_group =
            pop_item!(self, delim_code1_list_group, DelimCode1ListGroup, context);
        let delim_code1_list_0_built = DelimCode1List {
            delim_code1_list_group,
        };
        // Add an element to the vector
        delim_code1_list.push(delim_code1_list_0_built);
        self.push(ASTType::DelimCode1List(delim_code1_list), context);
        Ok(())
    }

    /// Semantic action for production 175:
    ///
    /// `DelimCode1ListGroup: NoBacktick;`
    ///
    #[parol_runtime::function_name::named]
    fn delim_code1_list_group_0(&mut self, _no_backtick: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let no_backtick = pop_item!(self, no_backtick, NoBacktick, context);
        let delim_code1_list_group_0_built = DelimCode1ListGroupNoBacktick { no_backtick };
        let delim_code1_list_group_0_built =
            DelimCode1ListGroup::NoBacktick(delim_code1_list_group_0_built);
        self.push(
            ASTType::DelimCode1ListGroup(delim_code1_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 176:
    ///
    /// `DelimCode1ListGroup: BacktickDelim;`
    ///
    #[parol_runtime::function_name::named]
    fn delim_code1_list_group_1(&mut self, _backtick_delim: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let backtick_delim = pop_item!(self, backtick_delim, BacktickDelim, context);
        let delim_code1_list_group_1_built = DelimCode1ListGroupBacktickDelim { backtick_delim };
        let delim_code1_list_group_1_built =
            DelimCode1ListGroup::BacktickDelim(delim_code1_list_group_1_built);
        self.push(
            ASTType::DelimCode1ListGroup(delim_code1_list_group_1_built),
            context,
        );
        Ok(())
    }

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

    /// Semantic action for production 178:
    ///
    /// `DelimCode2: DelimCodeStart2 DelimCode2List /* Vec */ DelimCodeEnd2;`
    ///
    #[parol_runtime::function_name::named]
    fn delim_code2(
        &mut self,
        _delim_code_start2: &ParseTreeType<'t>,
        _delim_code2_list: &ParseTreeType<'t>,
        _delim_code_end2: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let delim_code_end2 = pop_item!(self, delim_code_end2, DelimCodeEnd2, context);
        let delim_code2_list =
            pop_and_reverse_item!(self, delim_code2_list, DelimCode2List, context);
        let delim_code_start2 = pop_item!(self, delim_code_start2, DelimCodeStart2, context);
        let delim_code2_built = DelimCode2 {
            delim_code_start2,
            delim_code2_list,
            delim_code_end2,
        };
        // Calling user action here
        self.user_grammar.delim_code2(&delim_code2_built)?;
        self.push(ASTType::DelimCode2(delim_code2_built), context);
        Ok(())
    }

    /// Semantic action for production 179:
    ///
    /// `DelimCode2List /* Vec<T>::Push */: DelimCode2ListGroup DelimCode2List;`
    ///
    #[parol_runtime::function_name::named]
    fn delim_code2_list_0(
        &mut self,
        _delim_code2_list_group: &ParseTreeType<'t>,
        _delim_code2_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut delim_code2_list = pop_item!(self, delim_code2_list, DelimCode2List, context);
        let delim_code2_list_group =
            pop_item!(self, delim_code2_list_group, DelimCode2ListGroup, context);
        let delim_code2_list_0_built = DelimCode2List {
            delim_code2_list_group,
        };
        // Add an element to the vector
        delim_code2_list.push(delim_code2_list_0_built);
        self.push(ASTType::DelimCode2List(delim_code2_list), context);
        Ok(())
    }

    /// Semantic action for production 180:
    ///
    /// `DelimCode2ListGroup: NoBacktick;`
    ///
    #[parol_runtime::function_name::named]
    fn delim_code2_list_group_0(&mut self, _no_backtick: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let no_backtick = pop_item!(self, no_backtick, NoBacktick, context);
        let delim_code2_list_group_0_built = DelimCode2ListGroupNoBacktick { no_backtick };
        let delim_code2_list_group_0_built =
            DelimCode2ListGroup::NoBacktick(delim_code2_list_group_0_built);
        self.push(
            ASTType::DelimCode2ListGroup(delim_code2_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 181:
    ///
    /// `DelimCode2ListGroup: BacktickDelim;`
    ///
    #[parol_runtime::function_name::named]
    fn delim_code2_list_group_1(&mut self, _backtick_delim: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let backtick_delim = pop_item!(self, backtick_delim, BacktickDelim, context);
        let delim_code2_list_group_1_built = DelimCode2ListGroupBacktickDelim { backtick_delim };
        let delim_code2_list_group_1_built =
            DelimCode2ListGroup::BacktickDelim(delim_code2_list_group_1_built);
        self.push(
            ASTType::DelimCode2ListGroup(delim_code2_list_group_1_built),
            context,
        );
        Ok(())
    }

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

    /// Semantic action for production 183:
    ///
    /// `DelimCode3: DelimCodeStart3 DelimCode3List /* Vec */ DelimCodeEnd3;`
    ///
    #[parol_runtime::function_name::named]
    fn delim_code3(
        &mut self,
        _delim_code_start3: &ParseTreeType<'t>,
        _delim_code3_list: &ParseTreeType<'t>,
        _delim_code_end3: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let delim_code_end3 = pop_item!(self, delim_code_end3, DelimCodeEnd3, context);
        let delim_code3_list =
            pop_and_reverse_item!(self, delim_code3_list, DelimCode3List, context);
        let delim_code_start3 = pop_item!(self, delim_code_start3, DelimCodeStart3, context);
        let delim_code3_built = DelimCode3 {
            delim_code_start3,
            delim_code3_list,
            delim_code_end3,
        };
        // Calling user action here
        self.user_grammar.delim_code3(&delim_code3_built)?;
        self.push(ASTType::DelimCode3(delim_code3_built), context);
        Ok(())
    }

    /// Semantic action for production 184:
    ///
    /// `DelimCode3List /* Vec<T>::Push */: DelimCode3ListGroup DelimCode3List;`
    ///
    #[parol_runtime::function_name::named]
    fn delim_code3_list_0(
        &mut self,
        _delim_code3_list_group: &ParseTreeType<'t>,
        _delim_code3_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut delim_code3_list = pop_item!(self, delim_code3_list, DelimCode3List, context);
        let delim_code3_list_group =
            pop_item!(self, delim_code3_list_group, DelimCode3ListGroup, context);
        let delim_code3_list_0_built = DelimCode3List {
            delim_code3_list_group,
        };
        // Add an element to the vector
        delim_code3_list.push(delim_code3_list_0_built);
        self.push(ASTType::DelimCode3List(delim_code3_list), context);
        Ok(())
    }

    /// Semantic action for production 185:
    ///
    /// `DelimCode3ListGroup: NoBacktick;`
    ///
    #[parol_runtime::function_name::named]
    fn delim_code3_list_group_0(&mut self, _no_backtick: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let no_backtick = pop_item!(self, no_backtick, NoBacktick, context);
        let delim_code3_list_group_0_built = DelimCode3ListGroupNoBacktick { no_backtick };
        let delim_code3_list_group_0_built =
            DelimCode3ListGroup::NoBacktick(delim_code3_list_group_0_built);
        self.push(
            ASTType::DelimCode3ListGroup(delim_code3_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 186:
    ///
    /// `DelimCode3ListGroup: BacktickDelim;`
    ///
    #[parol_runtime::function_name::named]
    fn delim_code3_list_group_1(&mut self, _backtick_delim: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let backtick_delim = pop_item!(self, backtick_delim, BacktickDelim, context);
        let delim_code3_list_group_1_built = DelimCode3ListGroupBacktickDelim { backtick_delim };
        let delim_code3_list_group_1_built =
            DelimCode3ListGroup::BacktickDelim(delim_code3_list_group_1_built);
        self.push(
            ASTType::DelimCode3ListGroup(delim_code3_list_group_1_built),
            context,
        );
        Ok(())
    }

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

    /// Semantic action for production 188:
    ///
    /// `CodeBlock: CodeBlock3;`
    ///
    #[parol_runtime::function_name::named]
    fn code_block_0(&mut self, _code_block3: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let code_block3 = pop_item!(self, code_block3, CodeBlock3, context);
        let code_block_0_built = CodeBlockCodeBlock3 { code_block3 };
        let code_block_0_built = CodeBlock::CodeBlock3(code_block_0_built);
        // Calling user action here
        self.user_grammar.code_block(&code_block_0_built)?;
        self.push(ASTType::CodeBlock(code_block_0_built), context);
        Ok(())
    }

    /// Semantic action for production 189:
    ///
    /// `CodeBlock: CodeBlock4;`
    ///
    #[parol_runtime::function_name::named]
    fn code_block_1(&mut self, _code_block4: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let code_block4 = pop_item!(self, code_block4, CodeBlock4, context);
        let code_block_1_built = CodeBlockCodeBlock4 { code_block4 };
        let code_block_1_built = CodeBlock::CodeBlock4(code_block_1_built);
        // Calling user action here
        self.user_grammar.code_block(&code_block_1_built)?;
        self.push(ASTType::CodeBlock(code_block_1_built), context);
        Ok(())
    }

    /// Semantic action for production 190:
    ///
    /// `CodeBlock: CodeBlock5;`
    ///
    #[parol_runtime::function_name::named]
    fn code_block_2(&mut self, _code_block5: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let code_block5 = pop_item!(self, code_block5, CodeBlock5, context);
        let code_block_2_built = CodeBlockCodeBlock5 { code_block5 };
        let code_block_2_built = CodeBlock::CodeBlock5(code_block_2_built);
        // Calling user action here
        self.user_grammar.code_block(&code_block_2_built)?;
        self.push(ASTType::CodeBlock(code_block_2_built), context);
        Ok(())
    }

    /// Semantic action for production 191:
    ///
    /// `CodeBlock: CodeBlock6;`
    ///
    #[parol_runtime::function_name::named]
    fn code_block_3(&mut self, _code_block6: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let code_block6 = pop_item!(self, code_block6, CodeBlock6, context);
        let code_block_3_built = CodeBlockCodeBlock6 { code_block6 };
        let code_block_3_built = CodeBlock::CodeBlock6(code_block_3_built);
        // Calling user action here
        self.user_grammar.code_block(&code_block_3_built)?;
        self.push(ASTType::CodeBlock(code_block_3_built), context);
        Ok(())
    }

    /// Semantic action for production 192:
    ///
    /// `CodeBlock3: CodeBlockStart3 CodeBlock3List /* Vec */ CodeBlockEnd3;`
    ///
    #[parol_runtime::function_name::named]
    fn code_block3(
        &mut self,
        _code_block_start3: &ParseTreeType<'t>,
        _code_block3_list: &ParseTreeType<'t>,
        _code_block_end3: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let code_block_end3 = pop_item!(self, code_block_end3, CodeBlockEnd3, context);
        let code_block3_list =
            pop_and_reverse_item!(self, code_block3_list, CodeBlock3List, context);
        let code_block_start3 = pop_item!(self, code_block_start3, CodeBlockStart3, context);
        let code_block3_built = CodeBlock3 {
            code_block_start3,
            code_block3_list,
            code_block_end3,
        };
        // Calling user action here
        self.user_grammar.code_block3(&code_block3_built)?;
        self.push(ASTType::CodeBlock3(code_block3_built), context);
        Ok(())
    }

    /// Semantic action for production 193:
    ///
    /// `CodeBlock3List /* Vec<T>::Push */: CodeBlock3ListGroup CodeBlock3List;`
    ///
    #[parol_runtime::function_name::named]
    fn code_block3_list_0(
        &mut self,
        _code_block3_list_group: &ParseTreeType<'t>,
        _code_block3_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut code_block3_list = pop_item!(self, code_block3_list, CodeBlock3List, context);
        let code_block3_list_group =
            pop_item!(self, code_block3_list_group, CodeBlock3ListGroup, context);
        let code_block3_list_0_built = CodeBlock3List {
            code_block3_list_group,
        };
        // Add an element to the vector
        code_block3_list.push(code_block3_list_0_built);
        self.push(ASTType::CodeBlock3List(code_block3_list), context);
        Ok(())
    }

    /// Semantic action for production 194:
    ///
    /// `CodeBlock3ListGroup: NoBacktick;`
    ///
    #[parol_runtime::function_name::named]
    fn code_block3_list_group_0(&mut self, _no_backtick: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let no_backtick = pop_item!(self, no_backtick, NoBacktick, context);
        let code_block3_list_group_0_built = CodeBlock3ListGroupNoBacktick { no_backtick };
        let code_block3_list_group_0_built =
            CodeBlock3ListGroup::NoBacktick(code_block3_list_group_0_built);
        self.push(
            ASTType::CodeBlock3ListGroup(code_block3_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 195:
    ///
    /// `CodeBlock3ListGroup: Backtick2;`
    ///
    #[parol_runtime::function_name::named]
    fn code_block3_list_group_1(&mut self, _backtick2: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let backtick2 = pop_item!(self, backtick2, Backtick2, context);
        let code_block3_list_group_1_built = CodeBlock3ListGroupBacktick2 { backtick2 };
        let code_block3_list_group_1_built =
            CodeBlock3ListGroup::Backtick2(code_block3_list_group_1_built);
        self.push(
            ASTType::CodeBlock3ListGroup(code_block3_list_group_1_built),
            context,
        );
        Ok(())
    }

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

    /// Semantic action for production 197:
    ///
    /// `CodeBlock4: CodeBlockStart4 CodeBlock4List /* Vec */ CodeBlockEnd4;`
    ///
    #[parol_runtime::function_name::named]
    fn code_block4(
        &mut self,
        _code_block_start4: &ParseTreeType<'t>,
        _code_block4_list: &ParseTreeType<'t>,
        _code_block_end4: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let code_block_end4 = pop_item!(self, code_block_end4, CodeBlockEnd4, context);
        let code_block4_list =
            pop_and_reverse_item!(self, code_block4_list, CodeBlock4List, context);
        let code_block_start4 = pop_item!(self, code_block_start4, CodeBlockStart4, context);
        let code_block4_built = CodeBlock4 {
            code_block_start4,
            code_block4_list,
            code_block_end4,
        };
        // Calling user action here
        self.user_grammar.code_block4(&code_block4_built)?;
        self.push(ASTType::CodeBlock4(code_block4_built), context);
        Ok(())
    }

    /// Semantic action for production 198:
    ///
    /// `CodeBlock4List /* Vec<T>::Push */: CodeBlock4ListGroup CodeBlock4List;`
    ///
    #[parol_runtime::function_name::named]
    fn code_block4_list_0(
        &mut self,
        _code_block4_list_group: &ParseTreeType<'t>,
        _code_block4_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut code_block4_list = pop_item!(self, code_block4_list, CodeBlock4List, context);
        let code_block4_list_group =
            pop_item!(self, code_block4_list_group, CodeBlock4ListGroup, context);
        let code_block4_list_0_built = CodeBlock4List {
            code_block4_list_group,
        };
        // Add an element to the vector
        code_block4_list.push(code_block4_list_0_built);
        self.push(ASTType::CodeBlock4List(code_block4_list), context);
        Ok(())
    }

    /// Semantic action for production 199:
    ///
    /// `CodeBlock4ListGroup: NoBacktick;`
    ///
    #[parol_runtime::function_name::named]
    fn code_block4_list_group_0(&mut self, _no_backtick: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let no_backtick = pop_item!(self, no_backtick, NoBacktick, context);
        let code_block4_list_group_0_built = CodeBlock4ListGroupNoBacktick { no_backtick };
        let code_block4_list_group_0_built =
            CodeBlock4ListGroup::NoBacktick(code_block4_list_group_0_built);
        self.push(
            ASTType::CodeBlock4ListGroup(code_block4_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 200:
    ///
    /// `CodeBlock4ListGroup: Backtick3;`
    ///
    #[parol_runtime::function_name::named]
    fn code_block4_list_group_1(&mut self, _backtick3: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let backtick3 = pop_item!(self, backtick3, Backtick3, context);
        let code_block4_list_group_1_built = CodeBlock4ListGroupBacktick3 { backtick3 };
        let code_block4_list_group_1_built =
            CodeBlock4ListGroup::Backtick3(code_block4_list_group_1_built);
        self.push(
            ASTType::CodeBlock4ListGroup(code_block4_list_group_1_built),
            context,
        );
        Ok(())
    }

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

    /// Semantic action for production 202:
    ///
    /// `CodeBlock5: CodeBlockStart5 CodeBlock5List /* Vec */ CodeBlockEnd5;`
    ///
    #[parol_runtime::function_name::named]
    fn code_block5(
        &mut self,
        _code_block_start5: &ParseTreeType<'t>,
        _code_block5_list: &ParseTreeType<'t>,
        _code_block_end5: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let code_block_end5 = pop_item!(self, code_block_end5, CodeBlockEnd5, context);
        let code_block5_list =
            pop_and_reverse_item!(self, code_block5_list, CodeBlock5List, context);
        let code_block_start5 = pop_item!(self, code_block_start5, CodeBlockStart5, context);
        let code_block5_built = CodeBlock5 {
            code_block_start5,
            code_block5_list,
            code_block_end5,
        };
        // Calling user action here
        self.user_grammar.code_block5(&code_block5_built)?;
        self.push(ASTType::CodeBlock5(code_block5_built), context);
        Ok(())
    }

    /// Semantic action for production 203:
    ///
    /// `CodeBlock5List /* Vec<T>::Push */: CodeBlock5ListGroup CodeBlock5List;`
    ///
    #[parol_runtime::function_name::named]
    fn code_block5_list_0(
        &mut self,
        _code_block5_list_group: &ParseTreeType<'t>,
        _code_block5_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut code_block5_list = pop_item!(self, code_block5_list, CodeBlock5List, context);
        let code_block5_list_group =
            pop_item!(self, code_block5_list_group, CodeBlock5ListGroup, context);
        let code_block5_list_0_built = CodeBlock5List {
            code_block5_list_group,
        };
        // Add an element to the vector
        code_block5_list.push(code_block5_list_0_built);
        self.push(ASTType::CodeBlock5List(code_block5_list), context);
        Ok(())
    }

    /// Semantic action for production 204:
    ///
    /// `CodeBlock5ListGroup: NoBacktick;`
    ///
    #[parol_runtime::function_name::named]
    fn code_block5_list_group_0(&mut self, _no_backtick: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let no_backtick = pop_item!(self, no_backtick, NoBacktick, context);
        let code_block5_list_group_0_built = CodeBlock5ListGroupNoBacktick { no_backtick };
        let code_block5_list_group_0_built =
            CodeBlock5ListGroup::NoBacktick(code_block5_list_group_0_built);
        self.push(
            ASTType::CodeBlock5ListGroup(code_block5_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 205:
    ///
    /// `CodeBlock5ListGroup: Backtick4;`
    ///
    #[parol_runtime::function_name::named]
    fn code_block5_list_group_1(&mut self, _backtick4: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let backtick4 = pop_item!(self, backtick4, Backtick4, context);
        let code_block5_list_group_1_built = CodeBlock5ListGroupBacktick4 { backtick4 };
        let code_block5_list_group_1_built =
            CodeBlock5ListGroup::Backtick4(code_block5_list_group_1_built);
        self.push(
            ASTType::CodeBlock5ListGroup(code_block5_list_group_1_built),
            context,
        );
        Ok(())
    }

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

    /// Semantic action for production 207:
    ///
    /// `CodeBlock6: CodeBlockStart6 CodeBlock6List /* Vec */ CodeBlockEnd6;`
    ///
    #[parol_runtime::function_name::named]
    fn code_block6(
        &mut self,
        _code_block_start6: &ParseTreeType<'t>,
        _code_block6_list: &ParseTreeType<'t>,
        _code_block_end6: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let code_block_end6 = pop_item!(self, code_block_end6, CodeBlockEnd6, context);
        let code_block6_list =
            pop_and_reverse_item!(self, code_block6_list, CodeBlock6List, context);
        let code_block_start6 = pop_item!(self, code_block_start6, CodeBlockStart6, context);
        let code_block6_built = CodeBlock6 {
            code_block_start6,
            code_block6_list,
            code_block_end6,
        };
        // Calling user action here
        self.user_grammar.code_block6(&code_block6_built)?;
        self.push(ASTType::CodeBlock6(code_block6_built), context);
        Ok(())
    }

    /// Semantic action for production 208:
    ///
    /// `CodeBlock6List /* Vec<T>::Push */: CodeBlock6ListGroup CodeBlock6List;`
    ///
    #[parol_runtime::function_name::named]
    fn code_block6_list_0(
        &mut self,
        _code_block6_list_group: &ParseTreeType<'t>,
        _code_block6_list: &ParseTreeType<'t>,
    ) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let mut code_block6_list = pop_item!(self, code_block6_list, CodeBlock6List, context);
        let code_block6_list_group =
            pop_item!(self, code_block6_list_group, CodeBlock6ListGroup, context);
        let code_block6_list_0_built = CodeBlock6List {
            code_block6_list_group,
        };
        // Add an element to the vector
        code_block6_list.push(code_block6_list_0_built);
        self.push(ASTType::CodeBlock6List(code_block6_list), context);
        Ok(())
    }

    /// Semantic action for production 209:
    ///
    /// `CodeBlock6ListGroup: NoBacktick;`
    ///
    #[parol_runtime::function_name::named]
    fn code_block6_list_group_0(&mut self, _no_backtick: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let no_backtick = pop_item!(self, no_backtick, NoBacktick, context);
        let code_block6_list_group_0_built = CodeBlock6ListGroupNoBacktick { no_backtick };
        let code_block6_list_group_0_built =
            CodeBlock6ListGroup::NoBacktick(code_block6_list_group_0_built);
        self.push(
            ASTType::CodeBlock6ListGroup(code_block6_list_group_0_built),
            context,
        );
        Ok(())
    }

    /// Semantic action for production 210:
    ///
    /// `CodeBlock6ListGroup: Backtick5;`
    ///
    #[parol_runtime::function_name::named]
    fn code_block6_list_group_1(&mut self, _backtick5: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let backtick5 = pop_item!(self, backtick5, Backtick5, context);
        let code_block6_list_group_1_built = CodeBlock6ListGroupBacktick5 { backtick5 };
        let code_block6_list_group_1_built =
            CodeBlock6ListGroup::Backtick5(code_block6_list_group_1_built);
        self.push(
            ASTType::CodeBlock6ListGroup(code_block6_list_group_1_built),
            context,
        );
        Ok(())
    }

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

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

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

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

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

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

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

    /// Semantic action for production 218:
    ///
    /// `CodeBlockStart3: /`{3}[a-zA-Z0-9-_]*[\s--\r\n]*(\r\n|\r|\n)/;`
    ///
    #[parol_runtime::function_name::named]
    fn code_block_start3(&mut self, code_block_start3: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let code_block_start3 = code_block_start3.token()?.clone();
        let code_block_start3_built = CodeBlockStart3 { code_block_start3 };
        // Calling user action here
        self.user_grammar
            .code_block_start3(&code_block_start3_built)?;
        self.push(ASTType::CodeBlockStart3(code_block_start3_built), context);
        Ok(())
    }

    /// Semantic action for production 219:
    ///
    /// `CodeBlockStart4: /`{4}[a-zA-Z0-9-_]*[\s--\r\n]*(\r\n|\r|\n)/;`
    ///
    #[parol_runtime::function_name::named]
    fn code_block_start4(&mut self, code_block_start4: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let code_block_start4 = code_block_start4.token()?.clone();
        let code_block_start4_built = CodeBlockStart4 { code_block_start4 };
        // Calling user action here
        self.user_grammar
            .code_block_start4(&code_block_start4_built)?;
        self.push(ASTType::CodeBlockStart4(code_block_start4_built), context);
        Ok(())
    }

    /// Semantic action for production 220:
    ///
    /// `CodeBlockStart5: /`{5}[a-zA-Z0-9-_]*[\s--\r\n]*(\r\n|\r|\n)/;`
    ///
    #[parol_runtime::function_name::named]
    fn code_block_start5(&mut self, code_block_start5: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let code_block_start5 = code_block_start5.token()?.clone();
        let code_block_start5_built = CodeBlockStart5 { code_block_start5 };
        // Calling user action here
        self.user_grammar
            .code_block_start5(&code_block_start5_built)?;
        self.push(ASTType::CodeBlockStart5(code_block_start5_built), context);
        Ok(())
    }

    /// Semantic action for production 221:
    ///
    /// `CodeBlockStart6: /`{6}[a-zA-Z0-9-_]*[\s--\r\n]*(\r\n|\r|\n)/;`
    ///
    #[parol_runtime::function_name::named]
    fn code_block_start6(&mut self, code_block_start6: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let code_block_start6 = code_block_start6.token()?.clone();
        let code_block_start6_built = CodeBlockStart6 { code_block_start6 };
        // Calling user action here
        self.user_grammar
            .code_block_start6(&code_block_start6_built)?;
        self.push(ASTType::CodeBlockStart6(code_block_start6_built), context);
        Ok(())
    }

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

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

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

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

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

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

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

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

    /// Semantic action for production 230:
    ///
    /// `NoBacktick: <InCodeBlock3, InCodeBlock4, InCodeBlock5, InCodeBlock6, InDelimCode1, InDelimCode2, InDelimCode3>/[^`]+/;`
    ///
    #[parol_runtime::function_name::named]
    fn no_backtick(&mut self, no_backtick: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let no_backtick = no_backtick.token()?.clone();
        let no_backtick_built = NoBacktick { no_backtick };
        // Calling user action here
        self.user_grammar.no_backtick(&no_backtick_built)?;
        self.push(ASTType::NoBacktick(no_backtick_built), context);
        Ok(())
    }

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

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

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

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

    /// Semantic action for production 235:
    ///
    /// `NoSQuote: <InLitStr1, InLitStr2, InLitStr3>/[^']+/;`
    ///
    #[parol_runtime::function_name::named]
    fn no_s_quote(&mut self, no_s_quote: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let no_s_quote = no_s_quote.token()?.clone();
        let no_s_quote_built = NoSQuote { no_s_quote };
        // Calling user action here
        self.user_grammar.no_s_quote(&no_s_quote_built)?;
        self.push(ASTType::NoSQuote(no_s_quote_built), context);
        Ok(())
    }

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

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

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

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

    /// Semantic action for production 240:
    ///
    /// `GrammarNewline: <Header, Text>/\r\n|\r|\n/;`
    ///
    #[parol_runtime::function_name::named]
    fn grammar_newline(&mut self, grammar_newline: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let grammar_newline = grammar_newline.token()?.clone();
        let grammar_newline_built = GrammarNewline { grammar_newline };
        // Calling user action here
        self.user_grammar.grammar_newline(&grammar_newline_built)?;
        self.push(ASTType::GrammarNewline(grammar_newline_built), context);
        Ok(())
    }

    /// Semantic action for production 241:
    ///
    /// `Ws: <Text>/[\s--\r\n]+/;`
    ///
    #[parol_runtime::function_name::named]
    fn ws(&mut self, ws: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let ws = ws.token()?.clone();
        let ws_built = Ws { ws };
        // Calling user action here
        self.user_grammar.ws(&ws_built)?;
        self.push(ASTType::Ws(ws_built), context);
        Ok(())
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /// Semantic action for production 258:
    ///
    /// `Ident: <INITIAL, Header>/[\p{XID_Start}_][\p{XID_Continue}-]*/;`
    ///
    #[parol_runtime::function_name::named]
    fn ident(&mut self, ident: &ParseTreeType<'t>) -> Result<()> {
        let context = function_name!();
        trace!("{}", self.trace_item_stack(context));
        let ident = ident.token()?.clone();
        let ident_built = Ident { ident };
        // Calling user action here
        self.user_grammar.ident(&ident_built)?;
        self.push(ASTType::Ident(ident_built), context);
        Ok(())
    }
}

impl<'t> UserActionsTrait<'t> for GrammarAuto<'t, '_> {
    ///
    /// This function is implemented automatically for the user's item Grammar.
    ///
    fn call_semantic_action_for_production_number(
        &mut self,
        prod_num: usize,
        children: &[ParseTreeType<'t>],
    ) -> Result<()> {
        match prod_num {
            0 => self.eure(&children[0], &children[1], &children[2]),
            1 => self.eure_list0_0(&children[0], &children[1]),
            2 => self.eure_list0_1(),
            3 => self.eure_list_0(&children[0], &children[1]),
            4 => self.eure_list_1(),
            5 => self.eure_opt_0(&children[0]),
            6 => self.eure_opt_1(),
            7 => self.top_level_binding_0(&children[0]),
            8 => self.top_level_binding_1(&children[0]),
            9 => self.root_binding_0(&children[0]),
            10 => self.root_binding_1(&children[0]),
            11 => self.root_value_binding(&children[0], &children[1]),
            12 => self.root_text_binding(&children[0], &children[1], &children[2], &children[3]),
            13 => self.root_text_binding_opt1_0(&children[0]),
            14 => self.root_text_binding_opt1_1(),
            15 => self.root_text_binding_opt0_0(&children[0]),
            16 => self.root_text_binding_opt0_1(),
            17 => self.root_text_binding_opt_0(&children[0]),
            18 => self.root_text_binding_opt_1(),
            19 => self.binding(&children[0], &children[1]),
            20 => self.binding_rhs_0(&children[0]),
            21 => self.binding_rhs_1(&children[0]),
            22 => self.binding_rhs_2(&children[0]),
            23 => self.value_binding(&children[0], &children[1]),
            24 => self.section_binding(&children[0], &children[1], &children[2]),
            25 => self.text_binding(&children[0], &children[1], &children[2], &children[3]),
            26 => self.text_binding_opt1_0(&children[0]),
            27 => self.text_binding_opt1_1(),
            28 => self.text_binding_opt0_0(&children[0]),
            29 => self.text_binding_opt0_1(),
            30 => self.text_binding_opt_0(&children[0]),
            31 => self.text_binding_opt_1(),
            32 => self.section(&children[0], &children[1], &children[2]),
            33 => self.section_body_0(&children[0]),
            34 => self.section_body_1(&children[0]),
            35 => self.section_body_opt_0(&children[0]),
            36 => self.section_body_opt_1(),
            37 => self.flat_body(&children[0], &children[1]),
            38 => self.flat_body_list_0(&children[0], &children[1]),
            39 => self.flat_body_list_1(),
            40 => self.section_head_0(&children[0]),
            41 => self.section_head_1(&children[0]),
            42 => self.newline_head(&children[0], &children[1]),
            43 => self.newline_head_opt_0(&children[0]),
            44 => self.newline_head_opt_1(),
            45 => self.flat_root_binding_0(&children[0]),
            46 => self.flat_root_binding_1(&children[0]),
            47 => self.block_body(&children[0], &children[1], &children[2]),
            48 => self.keys(&children[0], &children[1]),
            49 => self.keys_list_0(&children[0], &children[1]),
            50 => self.keys_list_1(),
            51 => self.first_key_0(&children[0]),
            52 => self.first_key_1(&children[0]),
            53 => self.key_tail_0(&children[0]),
            54 => self.key_tail_1(&children[0]),
            55 => self.dot_key(&children[0], &children[1]),
            56 => self.array_marker(&children[0], &children[1], &children[2]),
            57 => self.array_marker_opt_0(&children[0]),
            58 => self.array_marker_opt_group_0(&children[0]),
            59 => self.array_marker_opt_group_1(&children[0]),
            60 => self.array_marker_opt_1(),
            61 => self.key_0(&children[0]),
            62 => self.key_1(&children[0]),
            63 => self.key_2(&children[0]),
            64 => self.key_3(&children[0]),
            65 => self.key_4(&children[0]),
            66 => self.key_5(&children[0]),
            67 => self.key_6(&children[0]),
            68 => self.key_7(&children[0]),
            69 => self.tuple_index(&children[0], &children[1]),
            70 => self.extension_name_space(&children[0], &children[1]),
            71 => self.key_tuple(&children[0], &children[1], &children[2]),
            72 => self.key_tuple_opt_0(&children[0]),
            73 => self.key_tuple_opt_1(),
            74 => self.key_tuple_elements(&children[0], &children[1]),
            75 => self.key_tuple_elements_opt_0(&children[0]),
            76 => self.key_tuple_elements_opt_1(),
            77 => self.key_tuple_elements_tail(&children[0], &children[1]),
            78 => self.key_tuple_elements_tail_opt_0(&children[0]),
            79 => self.key_tuple_elements_tail_opt_1(),
            80 => self.key_value_0(&children[0]),
            81 => self.key_value_1(&children[0]),
            82 => self.key_value_2(&children[0]),
            83 => self.key_value_3(&children[0]),
            84 => self.key_value_4(&children[0]),
            85 => self.key_ident_0(&children[0]),
            86 => self.key_ident_1(&children[0]),
            87 => self.key_ident_2(&children[0]),
            88 => self.key_ident_3(&children[0]),
            89 => self.value_0(&children[0]),
            90 => self.value_1(&children[0]),
            91 => self.value_2(&children[0]),
            92 => self.value_3(&children[0]),
            93 => self.value_4(&children[0]),
            94 => self.value_5(&children[0]),
            95 => self.value_6(&children[0]),
            96 => self.value_7(&children[0]),
            97 => self.value_8(&children[0]),
            98 => self.value_9(&children[0]),
            99 => self.object(&children[0], &children[1], &children[2], &children[3]),
            100 => self.object_list_0(
                &children[0],
                &children[1],
                &children[2],
                &children[3],
                &children[4],
            ),
            101 => self.object_list_1(),
            102 => self.object_opt0_0(&children[0]),
            103 => self.object_opt0_1(),
            104 => self.object_opt_0(&children[0], &children[1]),
            105 => self.object_opt1_0(&children[0]),
            106 => self.object_opt1_1(),
            107 => self.object_opt_1(),
            108 => self.map_bind(&children[0]),
            109 => self.array(&children[0], &children[1], &children[2]),
            110 => self.array_opt_0(&children[0]),
            111 => self.array_opt_1(),
            112 => self.array_elements(&children[0], &children[1]),
            113 => self.array_elements_opt_0(&children[0]),
            114 => self.array_elements_opt_1(),
            115 => self.array_elements_tail(&children[0], &children[1]),
            116 => self.array_elements_tail_opt_0(&children[0]),
            117 => self.array_elements_tail_opt_1(),
            118 => self.tuple(&children[0], &children[1], &children[2]),
            119 => self.tuple_opt_0(&children[0]),
            120 => self.tuple_opt_1(),
            121 => self.tuple_elements(&children[0], &children[1]),
            122 => self.tuple_elements_opt_0(&children[0]),
            123 => self.tuple_elements_opt_1(),
            124 => self.tuple_elements_tail(&children[0], &children[1]),
            125 => self.tuple_elements_tail_opt_0(&children[0]),
            126 => self.tuple_elements_tail_opt_1(),
            127 => self.number_0(&children[0]),
            128 => self.number_1(&children[0]),
            129 => self.number_2(&children[0]),
            130 => self.number_3(&children[0]),
            131 => self.integer(&children[0]),
            132 => self.float(&children[0]),
            133 => self.inf(&children[0]),
            134 => self.na_n(&children[0]),
            135 => self.boolean_0(&children[0]),
            136 => self.boolean_1(&children[0]),
            137 => self.r#true(&children[0]),
            138 => self.r#false(&children[0]),
            139 => self.null(&children[0]),
            140 => self.hole(&children[0]),
            141 => self.string_0(&children[0]),
            142 => self.string_1(&children[0]),
            143 => self.string_2(&children[0]),
            144 => self.string_3(&children[0]),
            145 => self.string_4(&children[0]),
            146 => self.strings(&children[0], &children[1]),
            147 => self.strings_list_0(&children[0], &children[1], &children[2]),
            148 => self.strings_list_1(),
            149 => self.str(&children[0]),
            150 => self.lit_str(&children[0]),
            151 => self.text(&children[0]),
            152 => self.inline_code_0(&children[0]),
            153 => self.inline_code_1(&children[0]),
            154 => self.inline_code1(&children[0]),
            155 => self.lit_str1(&children[0], &children[1], &children[2]),
            156 => self.lit_str1_list_0(&children[0], &children[1]),
            157 => self.lit_str1_list_group_0(&children[0]),
            158 => self.lit_str1_list_group_1(&children[0]),
            159 => self.lit_str1_list_1(),
            160 => self.lit_str2(&children[0], &children[1], &children[2]),
            161 => self.lit_str2_list_0(&children[0], &children[1]),
            162 => self.lit_str2_list_group_0(&children[0]),
            163 => self.lit_str2_list_group_1(&children[0]),
            164 => self.lit_str2_list_1(),
            165 => self.lit_str3(&children[0], &children[1], &children[2]),
            166 => self.lit_str3_list_0(&children[0], &children[1]),
            167 => self.lit_str3_list_group_0(&children[0]),
            168 => self.lit_str3_list_group_1(&children[0]),
            169 => self.lit_str3_list_1(),
            170 => self.delim_code_0(&children[0]),
            171 => self.delim_code_1(&children[0]),
            172 => self.delim_code_2(&children[0]),
            173 => self.delim_code1(&children[0], &children[1], &children[2]),
            174 => self.delim_code1_list_0(&children[0], &children[1]),
            175 => self.delim_code1_list_group_0(&children[0]),
            176 => self.delim_code1_list_group_1(&children[0]),
            177 => self.delim_code1_list_1(),
            178 => self.delim_code2(&children[0], &children[1], &children[2]),
            179 => self.delim_code2_list_0(&children[0], &children[1]),
            180 => self.delim_code2_list_group_0(&children[0]),
            181 => self.delim_code2_list_group_1(&children[0]),
            182 => self.delim_code2_list_1(),
            183 => self.delim_code3(&children[0], &children[1], &children[2]),
            184 => self.delim_code3_list_0(&children[0], &children[1]),
            185 => self.delim_code3_list_group_0(&children[0]),
            186 => self.delim_code3_list_group_1(&children[0]),
            187 => self.delim_code3_list_1(),
            188 => self.code_block_0(&children[0]),
            189 => self.code_block_1(&children[0]),
            190 => self.code_block_2(&children[0]),
            191 => self.code_block_3(&children[0]),
            192 => self.code_block3(&children[0], &children[1], &children[2]),
            193 => self.code_block3_list_0(&children[0], &children[1]),
            194 => self.code_block3_list_group_0(&children[0]),
            195 => self.code_block3_list_group_1(&children[0]),
            196 => self.code_block3_list_1(),
            197 => self.code_block4(&children[0], &children[1], &children[2]),
            198 => self.code_block4_list_0(&children[0], &children[1]),
            199 => self.code_block4_list_group_0(&children[0]),
            200 => self.code_block4_list_group_1(&children[0]),
            201 => self.code_block4_list_1(),
            202 => self.code_block5(&children[0], &children[1], &children[2]),
            203 => self.code_block5_list_0(&children[0], &children[1]),
            204 => self.code_block5_list_group_0(&children[0]),
            205 => self.code_block5_list_group_1(&children[0]),
            206 => self.code_block5_list_1(),
            207 => self.code_block6(&children[0], &children[1], &children[2]),
            208 => self.code_block6_list_0(&children[0], &children[1]),
            209 => self.code_block6_list_group_0(&children[0]),
            210 => self.code_block6_list_group_1(&children[0]),
            211 => self.code_block6_list_1(),
            212 => self.lit_str3_start(&children[0]),
            213 => self.lit_str2_start(&children[0]),
            214 => self.lit_str1_start(&children[0]),
            215 => self.delim_code_start3(&children[0]),
            216 => self.delim_code_start2(&children[0]),
            217 => self.delim_code_start1(&children[0]),
            218 => self.code_block_start3(&children[0]),
            219 => self.code_block_start4(&children[0]),
            220 => self.code_block_start5(&children[0]),
            221 => self.code_block_start6(&children[0]),
            222 => self.code_block_end3(&children[0]),
            223 => self.backtick2(&children[0]),
            224 => self.code_block_end4(&children[0]),
            225 => self.backtick3(&children[0]),
            226 => self.code_block_end5(&children[0]),
            227 => self.backtick4(&children[0]),
            228 => self.code_block_end6(&children[0]),
            229 => self.backtick5(&children[0]),
            230 => self.no_backtick(&children[0]),
            231 => self.lit_str3_end(&children[0]),
            232 => self.lit_str2_end(&children[0]),
            233 => self.lit_str1_end(&children[0]),
            234 => self.s_quote(&children[0]),
            235 => self.no_s_quote(&children[0]),
            236 => self.delim_code_end3(&children[0]),
            237 => self.delim_code_end2(&children[0]),
            238 => self.delim_code_end1(&children[0]),
            239 => self.backtick_delim(&children[0]),
            240 => self.grammar_newline(&children[0]),
            241 => self.ws(&children[0]),
            242 => self.at(&children[0]),
            243 => self.ext(&children[0]),
            244 => self.dot(&children[0]),
            245 => self.begin(&children[0]),
            246 => self.end(&children[0]),
            247 => self.array_begin(&children[0]),
            248 => self.array_end(&children[0]),
            249 => self.caret(&children[0]),
            250 => self.l_paren(&children[0]),
            251 => self.r_paren(&children[0]),
            252 => self.newline_bind(&children[0]),
            253 => self.bind(&children[0]),
            254 => self.comma(&children[0]),
            255 => self.r#continue(&children[0]),
            256 => self.newline_text_start(&children[0]),
            257 => self.text_start(&children[0]),
            258 => self.ident(&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)
    }
}