dbt-antlr4 1.2.1

#![crate_type = "lib"]
// #![warn(missing_docs)] // warn if there is missing docs
// #![warn(missing_debug_implementations)]
// #![warn(trivial_numeric_casts)]

//! # dbt-antlr4 runtime
//!
//! This is a Rust runtime for [ANTLR4] parser generator.
//! It is required to use parsers and lexers generated by [ANTLR4] parser generator
//!
//! This documentation refers to particular api used by generated parsers,lexers and syntax trees.
//!
//! For info on what is [ANTLR4] and how to generate parser please refer to:
//!  - [ANTLR4] main repository
//!  - [README] for Rust target
//!
//! [ANTLR4]: https://github.com/antlr/antlr4
//! [README]: https://github.com/sdf-labs/antlr4/blob/dev/runtime/Rust/README.md
//!
//! Documentation for this crate is still a work in progress, but you can find
//! some docs in the source code, and also refer to the Java runtime
//! documentation for general concepts and architecture of the runtime, as well
//! as for documentation of internal modules that are not yet documented in
//! Rust.
//!
//! [`CharStream`]: crate::char_stream::CharStream
//! [`TokenFactory`]: crate::token_factory::TokenFactory
//! [`Token`]: crate::token::Token
//! [`TokenStream`]: crate::token_stream::TokenStream
//! [`ParserRuleContext`]: crate::parser_rule_context::ParserRuleContext

#[doc(inline)]
pub use error_strategy::{BailErrorStrategy, DefaultErrorStrategy, ErrorStrategy};

pub use input_stream::InputStream;

#[doc(inline)]
pub use lexer::{BaseLexer, Lexer};
#[doc(inline)]
pub use parser::{BaseParser, ListenerId, Parser};
#[doc(inline)]
pub use token_source::TokenSource;
//extern crate uuid;
#[doc(hidden)]
pub use prediction_context::PredictionContextCache;

#[doc(inline)]
pub use prediction_mode::PredictionMode;

#[doc(inline)]
pub use arena::Arena;

mod arena;
#[doc(hidden)]
pub mod atn_config;
#[doc(hidden)]
pub mod atn_simulator;
pub mod int_stream;
mod lexer_action;
mod ll1_analyzer;
#[doc(hidden)]
pub mod recognizer;
pub mod token_factory;
//pub mod tokenstream_rewriter;
#[doc(hidden)]
pub mod atn_deserialization_options;
#[doc(hidden)]
pub mod atn_state;
pub mod char_stream;
#[doc(hidden)]
pub mod interval_set;
pub mod parser_rule_context;
mod prediction_context;
#[doc(hidden)]
pub mod semantic_context;
mod token_source;
pub mod token_stream;
//pub mod trace_listener;
#[doc(hidden)]
pub mod dfa;
#[doc(hidden)]
pub mod transition;
pub mod tree;
//pub mod file_stream;
#[doc(hidden)]
pub mod atn;
#[doc(hidden)]
pub mod atn_config_set;
#[doc(hidden)]
pub mod atn_deserializer;
pub mod common_token_stream;
pub mod error_listener;
pub mod error_strategy;
pub mod errors;
pub mod input_stream;
pub mod lexer;
#[doc(hidden)]
pub mod lexer_action_executor;
pub mod lexer_atn_simulator;
pub mod parser;
pub mod parser_atn_simulator;
mod prediction_mode;
pub mod token;
pub mod trees;
mod utils;
//pub mod tokenstream_rewriter_test;
mod atn_type;
// mod context_factory;
pub mod rule_context;
pub mod vocabulary;

// ======= Re-exports ========
pub use stacker;

pub const VERSION_MAJOR: &str = env!("CARGO_PKG_VERSION_MAJOR");
pub const VERSION_MINOR: &str = env!("CARGO_PKG_VERSION_MINOR");

// ======= Macros =======

pub const fn version_str_eq(a: &str, b: &str) -> bool {
    if a.len() != b.len() {
        return false;
    }
    let (a, b) = (a.as_bytes(), b.as_bytes());
    let mut i = 0;
    while i < a.len() {
        if a[i] != b[i] {
            return false;
        }
        i += 1;
    }
    true
}

#[macro_export]
macro_rules! check_version {
    ($major:literal, $minor:literal) => {
        const _: () = assert!(
            $crate::version_str_eq($major, $crate::VERSION_MAJOR)
                && $crate::version_str_eq($minor, $crate::VERSION_MINOR),
            "Generated parser is not compatible with current runtime version, \
             please regenerate using the matching ANTLR tool version, \
             or update the runtime to match the version used for generation."
        );
    };
}

#[macro_export]
macro_rules! impl_tree {
    // Pattern: EnumName { Variant1, Variant2, ... }
    ($enum_name:ident { $($variant:ident,)+ }) => {
        impl<'input, 'arena> Tree<'arena> for $enum_name<'input, 'arena> {
            fn get_parent(&self) -> Option<&'arena Self> {
                match self {
                    $( $enum_name::$variant(inner) => inner.get_parent(), )+
                    _ => None,
                }
            }

            fn has_parent(&self) -> bool {
                match self {
                    $( $enum_name::$variant(inner) => inner.has_parent(), )+
                    _ => false,
                }
            }

            // fn get_payload(&self) -> Box<dyn std::any::Any> {
            //     match self {
            //         $( $enum_name::$variant(inner) => Tree::get_payload(inner), )+
            //     }
            // }

            fn get_child(&self, i: usize) -> Option<&'arena Self> {
                match self {
                    $( $enum_name::$variant(inner) => inner.get_child(i), )+
                    _ => None,
                }
            }

            fn get_child_count(&self) -> usize {
                match self {
                    $( $enum_name::$variant(inner) => inner.get_child_count(), )+
                    _ => 0,
                }
            }

            fn get_children<'a>(&'a self) -> Box<dyn Iterator<Item = &'arena Self> + 'a> {
                match self {
                    $( $enum_name::$variant(inner) => inner.get_children(), )+
                    _ => Box::new(std::iter::empty()) as Box<dyn Iterator<Item = &'arena Self>>,
                }
            }

            // fn to_string_tree(&self) -> String {
            //     match self {
            //         $( $enum_name::$variant(inner) => Tree::to_string_tree(inner), )+
            //     }
            // }
        }
    };
}

#[macro_export]
macro_rules! impl_parse_tree {
    // Pattern: EnumName { Variant1, Variant2, ... }
    ($enum_name:ident { $($variant:ident,)+ }) => {
        impl<'input, 'arena> ParseTree<'input, 'arena> for $enum_name<'input, 'arena> {
            // fn get_source_interval(&self) -> crate::interval_set::Interval {
            //     match self {
            //         $( $enum_name::$variant(inner) => inner.get_source_interval(), )+
            //         _ => crate::interval_set::Interval::new_empty(),
            //     }
            // }

            // fn get_text(&self) -> String {
            //     match self {
            //         $( $enum_name::$variant(inner) => inner.get_text(), )+
            //         _ => String::new(),
            //     }
            // }
        }
    };
}

#[macro_export]
macro_rules! impl_rule_node_common {
    // Pattern: EnumName { Variant1, Variant2, ... }
    ($enum_name:ident { $($variant:ident,)+ }) => {
        fn get_rule_context(&self) -> &dyn ParserRuleContext<'input, 'arena> {
            match self {
                // Generate a match arm for every variant
                $( $enum_name::$variant(inner) => inner as &dyn ParserRuleContext<'input, 'arena>, )+
                $enum_name::Terminal(inner) => { inner as &dyn ParserRuleContext<'input, 'arena> },
                $enum_name::Error(inner) => { inner as &dyn ParserRuleContext<'input, 'arena> },
            }
        }

        fn as_terminal_node(&self) -> Option<&TerminalNode<'input, 'arena>> {
            match self {
                $enum_name::Terminal(inner) => Some(inner),
                _ => None,
            }
        }

        fn as_terminal_node_mut(&mut self) -> Option<&mut TerminalNode<'input, 'arena>> {
            match self {
                $enum_name::Terminal(inner) => Some(inner),
                _ => None,
            }
        }

        fn as_error_node(&self) -> Option<&ErrorNode<'input, 'arena>> {
            match self {
                $enum_name::Error(inner) => Some(inner),
                _ => None,
            }
        }

        fn as_error_node_mut(&mut self) -> Option<&mut ErrorNode<'input, 'arena>> {
            match self {
                $enum_name::Error(inner) => Some(inner),
                _ => None,
            }
        }

        fn set_exception(&self, e: $crate::errors::ANTLRError, arena: &'arena $crate::Arena) {
            match self {
                $( $enum_name::$variant(inner) => inner.set_exception(e, arena), )+
                _ => {}
            }
        }

        fn set_invoking_state(&mut self, t: i32) {
            match self {
                $( $enum_name::$variant(inner) => inner.set_invoking_state(t), )+
                _ => {}
            }
        }

        fn set_alt_number(&mut self, alt_number: i32) {
            match self {
                $( $enum_name::$variant(inner) => inner.set_alt_number(alt_number), )+
                _ => {}
            }
        }

        fn set_start(&mut self, t: Option<&'arena dyn $crate::token::Token>) {
            match self {
                $( $enum_name::$variant(inner) => inner.set_start(t), )+
                _ => {}
            }
        }

        fn set_stop(&mut self, t: Option<&'arena dyn $crate::token::Token>) {
            match self {
                $( $enum_name::$variant(inner) => inner.set_stop(t), )+
                _ => {}
            }
        }

        fn remove_last_child(&mut self) {
            match self {
                $( $enum_name::$variant(inner) => inner.remove_last_child(), )+
                _ => {}
            }
        }

        fn add_child(&mut self, child: &'arena Self) {
            match self {
                $( $enum_name::$variant(inner) => inner.add_child(child), )+
                _ => {}
            }
        }

        fn set_parent(&mut self, parent: Option<&'arena Self>) {
            match self {
                $( $enum_name::$variant(inner) => inner.set_parent(parent), )+
                _ => {}
            }
        }

        unsafe fn set_self_ref(&mut self, self_ref: *const Self) {
            match self {
                $( $enum_name::$variant(inner) => inner.set_self_ref(self_ref), )+
                _ => {}
            }
        }
    };
}

#[macro_export]
macro_rules! impl_rule_node {
    // No Listener and no Visitor
    ($enum_name:ident { $($variant:ident,)+ }; ) => {
        impl<'input, 'arena> RuleNode<'input, 'arena> for $enum_name<'input, 'arena> {
            type Listener = dyn ParseTreeListener<'input, 'arena, Self>;

            $crate::impl_rule_node_common! { $enum_name { $($variant,)+ } }

            fn enter_rule(&self, _listener: &mut Self::Listener) -> Result<(), ANTLRError> {
                Ok(())
            }

            fn exit_rule(&self, _listener: &mut Self::Listener) -> Result<(), ANTLRError> {
                Ok(())
            }
        }
    };

    // Just Visitor
    ($enum_name:ident { $($labeled_variant:ident,)*; $($variant:ident($visit_method:ident),)* }; visitor = $visitor:ty, ) => {
        impl<'input, 'arena> RuleNode<'input, 'arena> for $enum_name<'input, 'arena> {
            type listener = dyn ParseTreeListener<'input, 'arena, Self>;

            $crate::impl_rule_node_common! { $enum_name { $( $labeled_variant,)* $($variant,)* } }

            fn enter_rule(&self, _listener: &mut Self::Listener) -> Result<(), ANTLRError> {
                Ok(())
            }

            fn exit_rule(&self, _listener: &mut Self::Listener) -> Result<(), ANTLRError> {
                Ok(())
            }

            // fn accept(&self, visitor: &mut Self::Visitor) -> Result<<Self::Visitor as ParseTreeVisitor<'input, 'arena, Self>>::Return, ANTLRError>
            // {
            //     match self {
            //         $( $enum_name::$labeled_variant(inner) => inner.dispatch_visit(visitor), )*
            //         $( $enum_name::$variant(inner) => visitor.$visit_method(inner), )*
            //         $enum_name::Terminal(inner) => { visitor.visit_terminal(inner) },
            //         $enum_name::Error(inner) => { visitor.visit_error_node(inner) },
            //     }
            // }
        }
    };

    // Just Listener
    ($enum_name:ident { $($labeled_variant:ident,)*; $($variant:ident($enter_method:ident, $exit_method:ident, ),)* }; listener = $listener:ty, ) => {
        impl<'input, 'arena> RuleNode<'input, 'arena> for $enum_name<'input, 'arena> {
            type Listener = $listener;

            $crate::impl_rule_node_common! { $enum_name { $( $labeled_variant,)* $($variant,)* } }

            fn enter_rule(&self, listener: &mut Self::Listener) -> Result<(), ANTLRError> {
                match self {
                    $( $enum_name::$labeled_variant(inner) => inner.dispatch_enter(listener), )*
                    $( $enum_name::$variant(inner) => listener.$enter_method(inner), )*
                    $enum_name::Terminal(inner) => { listener.visit_terminal(inner) },
                    $enum_name::Error(inner) => { listener.visit_error_node(inner) },
                }
            }

            fn exit_rule(&self, listener: &mut Self::Listener) -> Result<(), ANTLRError> {
                match self {
                    $( $enum_name::$labeled_variant(inner) => inner.dispatch_exit(listener), )*
                    $( $enum_name::$variant(inner) => listener.$exit_method(inner), )*
                    $enum_name::Terminal(inner) => { listener.visit_terminal(inner) },
                    $enum_name::Error(inner) => { listener.visit_error_node(inner) },
                }
            }
        }
    };

    // Both listener and visitor
    ($enum_name:ident { $($labeled_variant:ident,)*; $($variant:ident($enter_method:ident, $exit_method:ident, $visit_method:ident),)* }; listener = $listener:ty, visitor = $visitor:ident, ) => {
        impl<'input, 'arena> RuleNode<'input, 'arena> for $enum_name<'input, 'arena> {
            type Listener = $listener;

            $crate::impl_rule_node_common! { $enum_name { $($labeled_variant,)* $($variant,)* } }

            fn enter_rule(&self, listener: &mut Self::Listener) -> Result<(), ANTLRError> {
                match self {
                    $( $enum_name::$labeled_variant(inner) => inner.dispatch_enter(listener), )*
                    $( $enum_name::$variant(inner) => listener.$enter_method(inner), )*
                    $enum_name::Terminal(inner) => { listener.visit_terminal(inner) },
                    $enum_name::Error(inner) => { listener.visit_error_node(inner) },
                }
            }

            fn exit_rule(&self, listener: &mut Self::Listener) -> Result<(), ANTLRError> {
                match self {
                    $( $enum_name::$labeled_variant(inner) => inner.dispatch_exit(listener), )*
                    $( $enum_name::$variant(inner) => listener.$exit_method(inner), )*
                    $enum_name::Terminal(inner) => { listener.visit_terminal(inner) },
                    $enum_name::Error(inner) => { listener.visit_error_node(inner) },
                }
            }
        }

        impl<'input, 'arena> Visitable<'input, 'arena> for $enum_name<'input, 'arena>
        where
            'input: 'arena,
        {
            fn accept<V>(&'arena self, visitor: &mut V) -> Result<V::Return, ANTLRError>
            where
                V: $visitor<'input, 'arena> + ?Sized,
            {
                match self {
                    $( $enum_name::$labeled_variant(inner) => inner.accept(visitor), )*
                    $( $enum_name::$variant(inner) => visitor.$visit_method(inner), )+
                    $enum_name::Terminal(inner) => { visitor.visit_terminal(inner) },
                    $enum_name::Error(inner) => { visitor.visit_error_node(inner) },
                }
            }
        }
    };
}

#[macro_export]
macro_rules! impl_listener_dispatch {
    // Pattern: EnumName { Variant1, Variant2, ... }
    ($listener:ident::$node_name:ident::$enum_name:ident { $($variant:ident($enter_method:ident, $exit_method:ident),)+ }) => {
        impl<'input, 'arena> $enum_name<'input, 'arena>
        where
            'input: 'arena,
        {
            fn dispatch_enter(&self, listener: &mut (dyn $listener<'input, 'arena> + 'static)) -> Result<(), ANTLRError>
            {
                match self {
                    $( $enum_name::$variant(inner) => listener.$enter_method(inner), )+
                    $enum_name::Error(_) => Ok(()),
                }
            }

            fn dispatch_exit(&self, listener: &mut (dyn $listener<'input, 'arena> + 'static)) -> Result<(), ANTLRError>
            {
                match self {
                    $( $enum_name::$variant(inner) => listener.$exit_method(inner), )+
                    $enum_name::Error(_) => Ok(()),
                }
            }
        }
    };
}

#[macro_export]
macro_rules! impl_visitable {
    // Pattern: EnumName { Variant1, Variant2, ... }
    ($visitor:ident::$enum_name:ident { $($variant:ident($visit_method:ident),)+ }) => {
        impl<'input, 'arena> Visitable<'input, 'arena> for $enum_name<'input, 'arena> {
            fn accept<V>(&'arena self, visitor: &mut V) -> Result<V::Return, ANTLRError>
            where
                V: $visitor<'input, 'arena> + ?Sized,
            {
                match self {
                    $( $enum_name::$variant(inner) => visitor.$visit_method(inner), )+
                    $enum_name::Error(_) => Ok(Default::default()),
                }
            }
        }
    };
    ($visitor:ident::$ctx_name:ident($visit_method:ident)) => {
        impl<'input, 'arena> Visitable<'input, 'arena> for $ctx_name<'input, 'arena> {
            fn accept<V>(&'arena self, visitor: &mut V) -> Result<V::Return, ANTLRError>
            where
                V: $visitor<'input, 'arena> + ?Sized,
            {
                visitor.$visit_method(self)
            }
        }
    };
}

#[macro_export]
macro_rules! impl_rule_context {
    // Pattern: EnumName { Variant1, Variant2, ... }
    ($enum_name:ident { $($variant:ident,)+ }) => {
        impl<'input, 'arena> RuleContext<'arena> for $enum_name<'input, 'arena> {
            fn get_rule_index(&self) -> usize {
                match self {
                    // Generate a match arm for every variant
                    $( $enum_name::$variant(inner) => RuleContext::get_rule_index(inner), )+
                }
            }

            fn get_alt_number(&self) -> i32 {
                match self {
                    $( $enum_name::$variant(inner) => RuleContext::get_alt_number(inner), )+
                }
            }

            fn get_invoking_state(&self) -> i32 {
                match self {
                    $( $enum_name::$variant(inner) => RuleContext::get_invoking_state(inner), )+
                }
            }

            fn get_parent_ctx(&self) -> Option<&'arena dyn RuleContext<'arena>> {
                match self {
                    $( $enum_name::$variant(inner) => RuleContext::get_parent_ctx(inner), )+
                }
            }

            fn get_node_text(&self, rule_names: &[&str]) -> String {
                match self {
                    $( $enum_name::$variant(inner) => RuleContext::get_node_text(inner, rule_names), )+
                }
            }

        }
    };
}

#[macro_export]
macro_rules! impl_parser_rule_context {
    // Pattern: EnumName { Variant1, Variant2, ... }
    ($enum_name:ident { $($variant:ident,)+ }) => {
        impl<'input, 'arena> ParserRuleContext<'input, 'arena> for $enum_name<'input, 'arena> {
            fn start(&self) -> &'arena dyn $crate::token::Token {
                match self {
                    $( $enum_name::$variant(inner) => ParserRuleContext::start(inner), )+
                }
            }

            fn stop(&self) -> &'arena dyn $crate::token::Token {
                match self {
                    $( $enum_name::$variant(inner) => ParserRuleContext::stop(inner), )+
                }
            }

            fn get_parent_ctx(&self) -> Option<&'arena dyn ParserRuleContext<'input, 'arena>> {
                match self {
                    $( $enum_name::$variant(inner) => ParserRuleContext::get_parent_ctx(inner), )+
                }
            }

            fn get_child_ctx(&self, _i: usize) -> Option<&'arena dyn ParserRuleContext<'input, 'arena>> {
                match self {
                    $( $enum_name::$variant(inner) => ParserRuleContext::get_child_ctx(inner, _i), )+
                }
            }

            fn get_child_count(&self) -> usize {
                match self {
                    $( $enum_name::$variant(inner) => ParserRuleContext::get_child_count(inner), )+
                }
            }

            fn iter_children<'a>(
                &'a self,
            ) -> Box<dyn Iterator<Item = &'arena dyn ParserRuleContext<'input, 'arena>> + 'a>
            where
                'input: 'a,
                'arena: 'a,
            {
                match self {
                    $( $enum_name::$variant(inner) => ParserRuleContext::iter_children(inner), )+
                }
            }

            fn get_token(&self, _ttype: i32, _pos: usize) -> Option<&TerminalNode<'input, 'arena>> {
                match self {
                    $( $enum_name::$variant(inner) => ParserRuleContext::get_token(inner, _ttype, _pos), )+
                }
            }

            fn get_tokens(&self, _ttype: i32) -> Vec<&TerminalNode<'input, 'arena>> {
                match self {
                    $( $enum_name::$variant(inner) => ParserRuleContext::get_tokens(inner, _ttype), )+
                }
            }

            fn get_text(&self) -> String {
                match self {
                    $( $enum_name::$variant(inner) => ParserRuleContext::get_text(inner), )+
                }
            }
       }
    };
}

#[macro_export]
macro_rules! impl_from_contexts {
    ($enum_name:ident { $($variant:ident($inner:ident)),+ $(,)? }) => {
        $(
            impl<'input, 'arena> From<$inner<'input, 'arena>> for $enum_name<'input, 'arena> {
                fn from(ctx: $inner<'input, 'arena>) -> Self {
                    $enum_name::$variant(ctx)
                }
            }
        )+
    };
}

#[macro_export]
macro_rules! impl_defaults {
    ($enum_name:ident) => {
        impl<'input, 'arena> From<TerminalNode<'input, 'arena>> for $enum_name<'input, 'arena> {
            fn from(node: TerminalNode<'input, 'arena>) -> Self {
                $enum_name::Terminal(node)
            }
        }

        impl<'input, 'arena> From<ErrorNode<'input, 'arena>> for $enum_name<'input, 'arena> {
            fn from(node: ErrorNode<'input, 'arena>) -> Self {
                $enum_name::Error(node)
            }
        }

        impl<'input, 'arena> Default for $enum_name<'input, 'arena> {
            fn default() -> Self {
                Self::Error(ErrorNode::default())
            }
        }
    };
}

#[macro_export]
macro_rules! impl_into_base_ext {
    ($enum_name:ident::$base_name:ident { $($variant:ident),+ $(,)? }) => {
        impl<'input, 'arena> $enum_name<'input, 'arena> {
            fn into_base_ext(self) -> $base_name<'input, 'arena> {
                match self {
                    $(
                        $enum_name::$variant(inner) => inner.morph(|ctx| ctx.base),
                    )+
                    $enum_name::Error(inner) => inner,
                }
            }
        }
    };
}

#[macro_export]
macro_rules! impl_tree_trait_delegates {
    ($node_name:ident::$enum_name:ident { $($variant:ident),+ $(,)? }) => {
        impl<'input, 'arena> $enum_name<'input, 'arena> {
            fn get_parent(&self) -> Option<&'arena $node_name<'input, 'arena>> {
                match self {
                    $( $enum_name::$variant(inner) => inner.get_parent(), )+
                }
            }

            fn has_parent(&self) -> bool {
                match self {
                    $( $enum_name::$variant(inner) => inner.has_parent(), )+
                }
            }

            fn get_child(&self, i: usize) -> Option<&'arena $node_name<'input, 'arena>> {
                match self {
                    $( $enum_name::$variant(inner) => inner.get_child(i), )+
                }
            }

            fn get_child_count(&self) -> usize {
                match self {
                    $( $enum_name::$variant(inner) => inner.get_child_count(), )+
                }
            }

            fn get_children<'a>(&'a self) -> Box<dyn Iterator<Item = &'arena $node_name<'input, 'arena>> + 'a> {
                match self {
                    $( $enum_name::$variant(inner) => inner.get_children(), )+
                }
            }

            fn set_start(&mut self, t: Option<&'arena dyn $crate::token::Token>) {
                match self {
                    $( $enum_name::$variant(inner) => inner.set_start(t), )+
                }
            }

            fn set_stop(&mut self, t: Option<&'arena dyn $crate::token::Token>) {
                match self {
                    $( $enum_name::$variant(inner) => inner.set_stop(t), )+
                }
            }

            fn set_parent(&mut self, parent: Option<&'arena $node_name<'input, 'arena>>) {
                match self {
                    $( $enum_name::$variant(inner) => inner.set_parent(parent), )+
                }
            }

            fn set_invoking_state(&mut self, t: i32) {
                match self {
                    $( $enum_name::$variant(inner) => inner.set_invoking_state(t), )+
                }
            }

            fn set_alt_number(&mut self, alt_number: i32) {
                match self {
                    $( $enum_name::$variant(inner) => inner.set_alt_number(alt_number), )+
                }
            }

            fn set_exception(&self, e: $crate::errors::ANTLRError, arena: &'arena $crate::Arena) {
                match self {
                    $( $enum_name::$variant(inner) => inner.set_exception(e, arena), )+
                }
            }

            fn remove_last_child(&mut self) {
                match self {
                    $( $enum_name::$variant(inner) => inner.remove_last_child(), )+
                }
            }

            fn add_child(&mut self, child: &'arena $node_name<'input, 'arena>) {
                match self {
                    $( $enum_name::$variant(inner) => inner.add_child(child), )+
                }
            }

            unsafe fn set_self_ref(&mut self, self_ref: *const $node_name<'input, 'arena>) {
                match self {
                    $( $enum_name::$variant(inner) => inner.set_self_ref(self_ref), )+
                }
            }
        }
    };
}

#[macro_export]
macro_rules! impl_node_inner {
    ($node_name:ident::$variant_name:ident::$enum_name:ident { $($variant:ident),+ $(,)? }) => {
        impl<'input, 'arena> NodeInner<'input, 'arena, $node_name<'input, 'arena>>
            for $enum_name<'input, 'arena>
        {
            fn cast_from<'a>(node: &'a $node_name<'input, 'arena>) -> Option<&'a Self> {
                match node {
                    $node_name::$variant_name(inner) => Some(inner),
                    _ => None,
                }
            }

            fn cast_from_mut<'a>(node: &'a mut $node_name<'input, 'arena>) -> Option<&'a mut Self>
            where
                Self: Sized,
            {
                match node {
                    $node_name::$variant_name(inner) => Some(inner),
                    _ => None,
                }
            }

            fn try_as_node(&'arena self) -> Option<&'arena $node_name<'input, 'arena>> {
                match self {
                    $( $enum_name::$variant(inner) => inner.try_as_node(), )+
                }
            }

            fn iter_child_nodes<'a>(&'a self) -> Box<dyn Iterator<Item = &'arena $node_name<'input, 'arena>> + 'a> {
                match self {
                    $( $enum_name::$variant(inner) => inner.get_children(), )+
                }
            }
        }
    };
}

#[macro_export]
macro_rules! impl_token_source {
    ($lexer:ident) => {
        impl<'input, 'arena, Input, TF> $crate::TokenSource<'input, 'arena, TF>
            for $lexer<'input, 'arena, Input, TF>
        where
            TF: $crate::token_factory::TokenFactory<'input, 'arena> + 'arena,
            Input: $crate::char_stream::CharStream<'input>,
        {
            fn next_token(&mut self) -> &'arena mut TF::Tok {
                self.base.next_token()
            }

            fn get_line(&self) -> u32 {
                self.base.get_line()
            }

            fn get_char_position_in_line(&self) -> i32 {
                self.base.get_char_position_in_line()
            }

            fn get_input_stream(&mut self) -> Option<&mut dyn $crate::int_stream::IntStream> {
                self.base.get_input_stream()
            }

            fn get_source_name(&self) -> String {
                self.base.get_source_name()
            }

            fn get_token_factory(&self) -> &TF {
                self.base.get_token_factory()
            }

            fn get_dfa_string(&self) -> String {
                self.base.get_dfa_string()
            }
        }
    };
}

#[macro_export]
macro_rules! impl_deref {
    (parser => $parser_name:ident) => {
        impl<'input, 'arena, Input, TF> Deref for $parser_name<'input, 'arena, Input, TF>
        where
            'input: 'arena,
            TF: TokenFactory<'input, 'arena> + 'arena,
            Input: TokenStream<'input, 'arena, TF> + 'arena,
        {
            type Target = BaseParserType<'input, 'arena, Input, TF>;
            fn deref(&self) -> &Self::Target {
                &self.base
            }
        }

        impl<'input, 'arena, Input, TF> DerefMut for $parser_name<'input, 'arena, Input, TF>
        where
            'input: 'arena,
            TF: TokenFactory<'input, 'arena> + 'arena,
            Input: TokenStream<'input, 'arena, TF> + 'arena,
        {
            fn deref_mut(&mut self) -> &mut Self::Target {
                &mut self.base
            }
        }
    };
    (lexer => $lexer_name:ident) => {
        impl<'input, 'arena, Input, TF> Deref for $lexer_name<'input, 'arena, Input, TF>
        where
            'input: 'arena,
            TF: TokenFactory<'input, 'arena> + 'arena,
            Input: CharStream<'input> + 'arena,
        {
            type Target = BaseLexerType<'input, 'arena, Input, TF>;
            fn deref(&self) -> &Self::Target {
                &self.base
            }
        }

        impl<'input, 'arena, Input, TF> DerefMut for $lexer_name<'input, 'arena, Input, TF>
        where
            'input: 'arena,
            TF: TokenFactory<'input, 'arena> + 'arena,
            Input: CharStream<'input> + 'arena,
        {
            fn deref_mut(&mut self) -> &mut Self::Target {
                &mut self.base
            }
        }
    };
}