Method escapeIdent

cel/src/parser/gen/celparser.rs:5428–5496

(&mut self)

    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
{
    pub fn escapeIdent(&mut self) -> Result<Rc<EscapeIdentContextAll<'input>>, ANTLRError> {
        let mut recog = self;
        let _parentctx = recog.ctx.take();
        let mut _localctx = EscapeIdentContextExt::new(_parentctx.clone(), recog.base.get_state());
        recog
            .base
            .enter_rule(_localctx.clone(), 28, RULE_escapeIdent);
        let mut _localctx: Rc<EscapeIdentContextAll> = _localctx;
        let result: Result<(), ANTLRError> = (|| {
            recog.base.set_state(235);
            recog.err_handler.sync(&mut recog.base)?;
            match recog.base.input.la(1) {
                CEL_IDENTIFIER => {
                    let tmp = SimpleIdentifierContextExt::new(&**_localctx);
                    recog.base.enter_outer_alt(Some(tmp.clone()), 1)?;
                    _localctx = tmp;
                    {
                        recog.base.set_state(233);
                        let tmp = recog
                            .base
                            .match_token(CEL_IDENTIFIER, &mut recog.err_handler)?;
                        if let EscapeIdentContextAll::SimpleIdentifierContext(ctx) =
                            cast_mut::<_, EscapeIdentContextAll>(&mut _localctx)
                        {
                            ctx.id = Some(tmp.clone());
                        } else {
                            unreachable!("cant cast");
                        }
                    }
                }

                CEL_ESC_IDENTIFIER => {
                    let tmp = EscapedIdentifierContextExt::new(&**_localctx);
                    recog.base.enter_outer_alt(Some(tmp.clone()), 2)?;
                    _localctx = tmp;
                    {
                        recog.base.set_state(234);
                        let tmp = recog
                            .base
                            .match_token(CEL_ESC_IDENTIFIER, &mut recog.err_handler)?;
                        if let EscapeIdentContextAll::EscapedIdentifierContext(ctx) =
                            cast_mut::<_, EscapeIdentContextAll>(&mut _localctx)
                        {
                            ctx.id = Some(tmp.clone());
                        } else {
                            unreachable!("cant cast");
                        }
                    }
                }

                _ => Err(ANTLRError::NoAltError(NoViableAltError::new(
                    &mut recog.base,
                )))?,
            }
            Ok(())
        })();
        match result {
            Ok(_) => {}