expressir 1.4.3 → 2.1.0

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/ParserATNSimulator.cpp

@@ -1,1413 +0,0 @@
-/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
- * Use of this file is governed by the BSD 3-clause license that
- * can be found in the LICENSE.txt file in the project root.
- */
-
-#include "dfa/DFA.h"
-#include "NoViableAltException.h"
-#include "atn/DecisionState.h"
-#include "ParserRuleContext.h"
-#include "misc/IntervalSet.h"
-#include "Parser.h"
-#include "CommonTokenStream.h"
-#include "atn/NotSetTransition.h"
-#include "atn/AtomTransition.h"
-#include "atn/RuleTransition.h"
-#include "atn/PredicateTransition.h"
-#include "atn/PrecedencePredicateTransition.h"
-#include "atn/SingletonPredictionContext.h"
-#include "atn/ActionTransition.h"
-#include "atn/EpsilonTransition.h"
-#include "atn/RuleStopState.h"
-#include "atn/ATNConfigSet.h"
-#include "atn/ATNConfig.h"
-#include "internal/Synchronization.h"
-
-#include "atn/StarLoopEntryState.h"
-#include "atn/BlockStartState.h"
-#include "atn/BlockEndState.h"
-
-#include "misc/Interval.h"
-#include "ANTLRErrorListener.h"
-
-#include "Vocabulary.h"
-#include "support/Arrays.h"
-#include "support/Casts.h"
-
-#include "atn/ParserATNSimulator.h"
-
-#ifndef DEBUG_ATN
-#define DEBUG_ATN 0
-#endif
-#ifndef TRACE_ATN_SIM
-#define TRACE_ATN_SIM 0
-#endif
-#ifndef DFA_DEBUG
-#define DFA_DEBUG 0
-#endif
-#ifndef RETRY_DEBUG
-#define RETRY_DEBUG 0
-#endif
-
-using namespace antlr4;
-using namespace antlr4::atn;
-using namespace antlr4::internal;
-using namespace antlrcpp;
-
-const bool ParserATNSimulator::TURN_OFF_LR_LOOP_ENTRY_BRANCH_OPT = ParserATNSimulator::getLrLoopSetting();
-
-ParserATNSimulator::ParserATNSimulator(const ATN &atn, std::vector<dfa::DFA> &decisionToDFA,
-                                       PredictionContextCache &sharedContextCache)
-: ParserATNSimulator(nullptr, atn, decisionToDFA, sharedContextCache) {
-}
-
-ParserATNSimulator::ParserATNSimulator(Parser *parser, const ATN &atn, std::vector<dfa::DFA> &decisionToDFA,
-                                       PredictionContextCache &sharedContextCache)
-: ParserATNSimulator(parser, atn, decisionToDFA, sharedContextCache, ParserATNSimulatorOptions()) {}
-
-ParserATNSimulator::ParserATNSimulator(Parser *parser, const ATN &atn, std::vector<dfa::DFA> &decisionToDFA,
-                                       PredictionContextCache &sharedContextCache,
-                                       const ParserATNSimulatorOptions &options)
-: ATNSimulator(atn, sharedContextCache), decisionToDFA(decisionToDFA), parser(parser),
-  mergeCache(options.getPredictionContextMergeCacheOptions()) {
-  InitializeInstanceFields();
-}
-
-void ParserATNSimulator::reset() {
-}
-
-void ParserATNSimulator::clearDFA() {
-  int size = (int)decisionToDFA.size();
-  decisionToDFA.clear();
-  for (int d = 0; d < size; ++d) {
-    decisionToDFA.push_back(dfa::DFA(atn.getDecisionState(d), d));
-  }
-}
-
-size_t ParserATNSimulator::adaptivePredict(TokenStream *input, size_t decision, ParserRuleContext *outerContext) {
-
-#if DEBUG_ATN == 1 || TRACE_ATN_SIM == 1
-    std::cout << "adaptivePredict decision " << decision << " exec LA(1)==" << getLookaheadName(input) << " line "
-      << input->LT(1)->getLine() << ":" << input->LT(1)->getCharPositionInLine() << std::endl;
-#endif
-
-  _input = input;
-  _startIndex = input->index();
-  _outerContext = outerContext;
-  dfa::DFA &dfa = decisionToDFA[decision];
-  _dfa = &dfa;
-
-  ssize_t m = input->mark();
-  size_t index = _startIndex;
-
-  // Now we are certain to have a specific decision's DFA
-  // But, do we still need an initial state?
-  auto onExit = finally([this, input, index, m] {
-    if (mergeCache.getOptions().getClearEveryN() != 0) {
-      if (++_mergeCacheCounter == mergeCache.getOptions().getClearEveryN()) {
-        mergeCache.clear();
-        _mergeCacheCounter = 0;
-      }
-    }
-    _dfa = nullptr;
-    input->seek(index);
-    input->release(m);
-  });
-
-  dfa::DFAState *s0;
-  {
-    SharedLock<SharedMutex> stateLock(atn._stateMutex);
-    if (dfa.isPrecedenceDfa()) {
-      // the start state for a precedence DFA depends on the current
-      // parser precedence, and is provided by a DFA method.
-      SharedLock<SharedMutex> edgeLock(atn._edgeMutex);
-      s0 = dfa.getPrecedenceStartState(parser->getPrecedence());
-    } else {
-      // the start state for a "regular" DFA is just s0
-      s0 = dfa.s0;
-    }
-  }
-
-  if (s0 == nullptr) {
-    auto s0_closure = computeStartState(dfa.atnStartState, &ParserRuleContext::EMPTY, false);
-    std::unique_ptr<dfa::DFAState> newState;
-    std::unique_ptr<dfa::DFAState> oldState;
-    UniqueLock<SharedMutex> stateLock(atn._stateMutex);
-    dfa::DFAState* ds0 = dfa.s0;
-    if (dfa.isPrecedenceDfa()) {
-      /* If this is a precedence DFA, we use applyPrecedenceFilter
-       * to convert the computed start state to a precedence start
-       * state. We then use DFA.setPrecedenceStartState to set the
-       * appropriate start state for the precedence level rather
-       * than simply setting DFA.s0.
-       */
-      ds0->configs = std::move(s0_closure); // not used for prediction but useful to know start configs anyway
-      newState = std::make_unique<dfa::DFAState>(applyPrecedenceFilter(ds0->configs.get()));
-      s0 = addDFAState(dfa, newState.get());
-      UniqueLock<SharedMutex> edgeLock(atn._edgeMutex);
-      dfa.setPrecedenceStartState(parser->getPrecedence(), s0);
-    } else {
-      newState = std::make_unique<dfa::DFAState>(std::move(s0_closure));
-      s0 = addDFAState(dfa, newState.get());
-      if (ds0 != s0) {
-        oldState.reset(ds0);
-        dfa.s0 = s0;
-      }
-    }
-    if (s0 == newState.get()) {
-      newState.release();
-    }
-  }
-
-  // We can start with an existing DFA.
-  size_t alt = execATN(dfa, s0, input, index, outerContext != nullptr ? outerContext : &ParserRuleContext::EMPTY);
-
-  return alt;
-}
-
-size_t ParserATNSimulator::execATN(dfa::DFA &dfa, dfa::DFAState *s0, TokenStream *input, size_t startIndex,
-                                   ParserRuleContext *outerContext) {
-
-#if DEBUG_ATN == 1 || TRACE_ATN_SIM == 1
-    std::cout << "execATN decision " << dfa.decision << ", DFA state " << s0->toString() <<
-      ", LA(1)==" << getLookaheadName(input) <<
-      " line " << input->LT(1)->getLine() << ":" << input->LT(1)->getCharPositionInLine() << std::endl;
-#endif
-
-  dfa::DFAState *previousD = s0;
-
-#if DEBUG_ATN == 1
-    std::cout << "s0 = " << s0->toString() << std::endl;
-#endif
-
-  size_t t = input->LA(1);
-
-  while (true) { // while more work
-    dfa::DFAState *D = getExistingTargetState(previousD, t);
-    if (D == nullptr) {
-      D = computeTargetState(dfa, previousD, t);
-    }
-
-    if (D == ERROR.get()) {
-      // if any configs in previous dipped into outer context, that
-      // means that input up to t actually finished entry rule
-      // at least for SLL decision. Full LL doesn't dip into outer
-      // so don't need special case.
-      // We will get an error no matter what so delay until after
-      // decision; better error message. Also, no reachable target
-      // ATN states in SLL implies LL will also get nowhere.
-      // If conflict in states that dip out, choose min since we
-      // will get error no matter what.
-      NoViableAltException e = noViableAlt(input, outerContext, previousD->configs.get(), startIndex, false);
-      input->seek(startIndex);
-      size_t alt = getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(previousD->configs.get(), outerContext);
-      if (alt != ATN::INVALID_ALT_NUMBER) {
-        return alt;
-      }
-
-      throw e;
-    }
-
-    if (D->requiresFullContext && _mode != PredictionMode::SLL) {
-      // IF PREDS, MIGHT RESOLVE TO SINGLE ALT => SLL (or syntax error)
-      BitSet conflictingAlts;
-      if (D->predicates.size() != 0) {
-#if DEBUG_ATN == 1
-          std::cout << "DFA state has preds in DFA sim LL failover" << std::endl;
-#endif
-
-        size_t conflictIndex = input->index();
-        if (conflictIndex != startIndex) {
-          input->seek(startIndex);
-        }
-
-        conflictingAlts = evalSemanticContext(D->predicates, outerContext, true);
-        if (conflictingAlts.count() == 1) {
-#if DEBUG_ATN == 1
-            std::cout << "Full LL avoided" << std::endl;
-#endif
-
-          return conflictingAlts.nextSetBit(0);
-        }
-
-        if (conflictIndex != startIndex) {
-          // restore the index so reporting the fallback to full
-          // context occurs with the index at the correct spot
-          input->seek(conflictIndex);
-        }
-      }
-
-#if DFA_DEBUG == 1
-        std::cout << "ctx sensitive state " << outerContext << " in " << D << std::endl;
-#endif
-
-      bool fullCtx = true;
-      std::unique_ptr<ATNConfigSet> s0_closure = computeStartState(dfa.atnStartState, outerContext, fullCtx);
-      reportAttemptingFullContext(dfa, conflictingAlts, D->configs.get(), startIndex, input->index());
-      size_t alt = execATNWithFullContext(dfa, D, s0_closure.get(), input, startIndex, outerContext);
-      return alt;
-    }
-
-    if (D->isAcceptState) {
-      if (D->predicates.empty()) {
-        return D->prediction;
-      }
-
-      size_t stopIndex = input->index();
-      input->seek(startIndex);
-      BitSet alts = evalSemanticContext(D->predicates, outerContext, true);
-      switch (alts.count()) {
-        case 0:
-          throw noViableAlt(input, outerContext, D->configs.get(), startIndex, false);
-
-        case 1:
-          return alts.nextSetBit(0);
-
-        default:
-          // report ambiguity after predicate evaluation to make sure the correct
-          // set of ambig alts is reported.
-          reportAmbiguity(dfa, D, startIndex, stopIndex, false, alts, D->configs.get());
-          return alts.nextSetBit(0);
-      }
-    }
-
-    previousD = D;
-
-    if (t != Token::EOF) {
-      input->consume();
-      t = input->LA(1);
-    }
-  }
-}
-
-dfa::DFAState *ParserATNSimulator::getExistingTargetState(dfa::DFAState *previousD, size_t t) {
-  dfa::DFAState* retval;
-  SharedLock<SharedMutex> edgeLock(atn._edgeMutex);
-  auto iterator = previousD->edges.find(t);
-  retval = (iterator == previousD->edges.end()) ? nullptr : iterator->second;
-  return retval;
-}
-
-dfa::DFAState *ParserATNSimulator::computeTargetState(dfa::DFA &dfa, dfa::DFAState *previousD, size_t t) {
-  std::unique_ptr<ATNConfigSet> reach = computeReachSet(previousD->configs.get(), t, false);
-  if (reach == nullptr) {
-    addDFAEdge(dfa, previousD, t, ERROR.get());
-    return ERROR.get();
-  }
-
-  // create new target state; we'll add to DFA after it's complete
-  dfa::DFAState *D = new dfa::DFAState(std::move(reach)); /* mem-check: managed by the DFA or deleted below, "reach" is no longer valid now. */
-  size_t predictedAlt = getUniqueAlt(D->configs.get());
-
-  if (predictedAlt != ATN::INVALID_ALT_NUMBER) {
-    // NO CONFLICT, UNIQUELY PREDICTED ALT
-    D->isAcceptState = true;
-    D->configs->uniqueAlt = predictedAlt;
-    D->prediction = predictedAlt;
-  } else if (PredictionModeClass::hasSLLConflictTerminatingPrediction(_mode, D->configs.get())) {
-    // MORE THAN ONE VIABLE ALTERNATIVE
-    D->configs->conflictingAlts = getConflictingAlts(D->configs.get());
-    D->requiresFullContext = true;
-    // in SLL-only mode, we will stop at this state and return the minimum alt
-    D->isAcceptState = true;
-    D->prediction = D->configs->conflictingAlts.nextSetBit(0);
-  }
-
-  if (D->isAcceptState && D->configs->hasSemanticContext) {
-    predicateDFAState(D, atn.getDecisionState(dfa.decision));
-    if (D->predicates.size() != 0) {
-      D->prediction = ATN::INVALID_ALT_NUMBER;
-    }
-  }
-
-  // all adds to dfa are done after we've created full D state
-  dfa::DFAState *state = addDFAEdge(dfa, previousD, t, D);
-  if (state != D) {
-    delete D; // If the new state exists already we don't need it and use the existing one instead.
-  }
-  return state;
-}
-
-void ParserATNSimulator::predicateDFAState(dfa::DFAState *dfaState, DecisionState *decisionState) {
-  // We need to test all predicates, even in DFA states that
-  // uniquely predict alternative.
-  size_t nalts = decisionState->transitions.size();
-
-  // Update DFA so reach becomes accept state with (predicate,alt)
-  // pairs if preds found for conflicting alts
-  BitSet altsToCollectPredsFrom = getConflictingAltsOrUniqueAlt(dfaState->configs.get());
-  std::vector<Ref<const SemanticContext>> altToPred = getPredsForAmbigAlts(altsToCollectPredsFrom, dfaState->configs.get(), nalts);
-  if (!altToPred.empty()) {
-    dfaState->predicates = getPredicatePredictions(altsToCollectPredsFrom, altToPred);
-    dfaState->prediction = ATN::INVALID_ALT_NUMBER; // make sure we use preds
-  } else {
-    // There are preds in configs but they might go away
-    // when OR'd together like {p}? || NONE == NONE. If neither
-    // alt has preds, resolve to min alt
-    dfaState->prediction = altsToCollectPredsFrom.nextSetBit(0);
-  }
-}
-
-size_t ParserATNSimulator::execATNWithFullContext(dfa::DFA &dfa, dfa::DFAState *D, ATNConfigSet *s0,
-  TokenStream *input, size_t startIndex, ParserRuleContext *outerContext) {
-
-#if TRACE_ATN_SIM == 1
-    std::cout << "execATNWithFullContext " << s0->toString() << std::endl;
-#endif
-
-  bool fullCtx = true;
-  bool foundExactAmbig = false;
-
-  std::unique_ptr<ATNConfigSet> reach;
-  ATNConfigSet *previous = s0;
-  input->seek(startIndex);
-  size_t t = input->LA(1);
-  size_t predictedAlt;
-
-  while (true) {
-    reach = computeReachSet(previous, t, fullCtx);
-    if (reach == nullptr) {
-      // if any configs in previous dipped into outer context, that
-      // means that input up to t actually finished entry rule
-      // at least for LL decision. Full LL doesn't dip into outer
-      // so don't need special case.
-      // We will get an error no matter what so delay until after
-      // decision; better error message. Also, no reachable target
-      // ATN states in SLL implies LL will also get nowhere.
-      // If conflict in states that dip out, choose min since we
-      // will get error no matter what.
-      NoViableAltException e = noViableAlt(input, outerContext, previous, startIndex, previous != s0);
-      input->seek(startIndex);
-      size_t alt = getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(previous, outerContext);
-      if (alt != ATN::INVALID_ALT_NUMBER) {
-        return alt;
-      }
-      throw e;
-    }
-    if (previous != s0) // Don't delete the start set.
-        delete previous;
-    previous = nullptr;
-
-    std::vector<BitSet> altSubSets = PredictionModeClass::getConflictingAltSubsets(reach.get());
-    reach->uniqueAlt = getUniqueAlt(reach.get());
-    // unique prediction?
-    if (reach->uniqueAlt != ATN::INVALID_ALT_NUMBER) {
-      predictedAlt = reach->uniqueAlt;
-      break;
-    }
-    if (_mode != PredictionMode::LL_EXACT_AMBIG_DETECTION) {
-      predictedAlt = PredictionModeClass::resolvesToJustOneViableAlt(altSubSets);
-      if (predictedAlt != ATN::INVALID_ALT_NUMBER) {
-        break;
-      }
-    } else {
-      // In exact ambiguity mode, we never try to terminate early.
-      // Just keeps scarfing until we know what the conflict is
-      if (PredictionModeClass::allSubsetsConflict(altSubSets) && PredictionModeClass::allSubsetsEqual(altSubSets)) {
-        foundExactAmbig = true;
-        predictedAlt = PredictionModeClass::getSingleViableAlt(altSubSets);
-        break;
-      }
-      // else there are multiple non-conflicting subsets or
-      // we're not sure what the ambiguity is yet.
-      // So, keep going.
-    }
-    previous = reach.release();
-
-    if (t != Token::EOF) {
-      input->consume();
-      t = input->LA(1);
-    }
-  }
-
-  // If the configuration set uniquely predicts an alternative,
-  // without conflict, then we know that it's a full LL decision
-  // not SLL.
-  if (reach->uniqueAlt != ATN::INVALID_ALT_NUMBER) {
-    reportContextSensitivity(dfa, predictedAlt, reach.get(), startIndex, input->index());
-    return predictedAlt;
-  }
-
-  // We do not check predicates here because we have checked them
-  // on-the-fly when doing full context prediction.
-
-  /*
-   In non-exact ambiguity detection mode, we might	actually be able to
-   detect an exact ambiguity, but I'm not going to spend the cycles
-   needed to check. We only emit ambiguity warnings in exact ambiguity
-   mode.
-
-   For example, we might know that we have conflicting configurations.
-   But, that does not mean that there is no way forward without a
-   conflict. It's possible to have nonconflicting alt subsets as in:
-
-   LL altSubSets=[{1, 2}, {1, 2}, {1}, {1, 2}]
-
-   from
-
-   [(17,1,[5 $]), (13,1,[5 10 $]), (21,1,[5 10 $]), (11,1,[$]),
-   (13,2,[5 10 $]), (21,2,[5 10 $]), (11,2,[$])]
-
-   In this case, (17,1,[5 $]) indicates there is some next sequence that
-   would resolve this without conflict to alternative 1. Any other viable
-   next sequence, however, is associated with a conflict.  We stop
-   looking for input because no amount of further lookahead will alter
-   the fact that we should predict alternative 1.  We just can't say for
-   sure that there is an ambiguity without looking further.
-   */
-  reportAmbiguity(dfa, D, startIndex, input->index(), foundExactAmbig, reach->getAlts(), reach.get());
-
-  return predictedAlt;
-}
-
-std::unique_ptr<ATNConfigSet> ParserATNSimulator::computeReachSet(ATNConfigSet *closure_, size_t t, bool fullCtx) {
-
-  std::unique_ptr<ATNConfigSet> intermediate(new ATNConfigSet(fullCtx));
-
-  /* Configurations already in a rule stop state indicate reaching the end
-   * of the decision rule (local context) or end of the start rule (full
-   * context). Once reached, these configurations are never updated by a
-   * closure operation, so they are handled separately for the performance
-   * advantage of having a smaller intermediate set when calling closure.
-   *
-   * For full-context reach operations, separate handling is required to
-   * ensure that the alternative matching the longest overall sequence is
-   * chosen when multiple such configurations can match the input.
-   */
-  std::vector<Ref<ATNConfig>> skippedStopStates;
-
-  // First figure out where we can reach on input t
-  for (const auto &c : closure_->configs) {
-    if (RuleStopState::is(c->state)) {
-      assert(c->context->isEmpty());
-
-      if (fullCtx || t == Token::EOF) {
-        skippedStopStates.push_back(c);
-      }
-
-      continue;
-    }
-
-    size_t n = c->state->transitions.size();
-    for (size_t ti = 0; ti < n; ti++) { // for each transition
-      const Transition *trans = c->state->transitions[ti].get();
-      ATNState *target = getReachableTarget(trans, (int)t);
-      if (target != nullptr) {
-        intermediate->add(std::make_shared<ATNConfig>(*c, target), &mergeCache);
-      }
-    }
-  }
-
-  // Now figure out where the reach operation can take us...
-  std::unique_ptr<ATNConfigSet> reach;
-
-  /* This block optimizes the reach operation for intermediate sets which
-   * trivially indicate a termination state for the overall
-   * adaptivePredict operation.
-   *
-   * The conditions assume that intermediate
-   * contains all configurations relevant to the reach set, but this
-   * condition is not true when one or more configurations have been
-   * withheld in skippedStopStates, or when the current symbol is EOF.
-   */
-  if (skippedStopStates.empty() && t != Token::EOF) {
-    if (intermediate->size() == 1) {
-      // Don't pursue the closure if there is just one state.
-      // It can only have one alternative; just add to result
-      // Also don't pursue the closure if there is unique alternative
-      // among the configurations.
-      reach = std::move(intermediate);
-    } else if (getUniqueAlt(intermediate.get()) != ATN::INVALID_ALT_NUMBER) {
-      // Also don't pursue the closure if there is unique alternative
-      // among the configurations.
-      reach = std::move(intermediate);
-    }
-  }
-
-  /* If the reach set could not be trivially determined, perform a closure
-   * operation on the intermediate set to compute its initial value.
-   */
-  if (reach == nullptr) {
-    reach.reset(new ATNConfigSet(fullCtx));
-    ATNConfig::Set closureBusy;
-
-    bool treatEofAsEpsilon = t == Token::EOF;
-    for (const auto &c : intermediate->configs) {
-      closure(c, reach.get(), closureBusy, false, fullCtx, treatEofAsEpsilon);
-    }
-  }
-
-  if (t == IntStream::EOF) {
-    /* After consuming EOF no additional input is possible, so we are
-     * only interested in configurations which reached the end of the
-     * decision rule (local context) or end of the start rule (full
-     * context). Update reach to contain only these configurations. This
-     * handles both explicit EOF transitions in the grammar and implicit
-     * EOF transitions following the end of the decision or start rule.
-     *
-     * When reach==intermediate, no closure operation was performed. In
-     * this case, removeAllConfigsNotInRuleStopState needs to check for
-     * reachable rule stop states as well as configurations already in
-     * a rule stop state.
-     *
-     * This is handled before the configurations in skippedStopStates,
-     * because any configurations potentially added from that list are
-     * already guaranteed to meet this condition whether or not it's
-     * required.
-     */
-    ATNConfigSet *temp = removeAllConfigsNotInRuleStopState(reach.get(), *reach == *intermediate);
-    if (temp != reach.get())
-      reach.reset(temp); // We got a new set, so use that.
-  }
-
-  /* If skippedStopStates is not null, then it contains at least one
-   * configuration. For full-context reach operations, these
-   * configurations reached the end of the start rule, in which case we
-   * only add them back to reach if no configuration during the current
-   * closure operation reached such a state. This ensures adaptivePredict
-   * chooses an alternative matching the longest overall sequence when
-   * multiple alternatives are viable.
-   */
-  if (skippedStopStates.size() > 0 && (!fullCtx || !PredictionModeClass::hasConfigInRuleStopState(reach.get()))) {
-    assert(!skippedStopStates.empty());
-
-    for (const auto &c : skippedStopStates) {
-      reach->add(c, &mergeCache);
-    }
-  }
-
-#if DEBUG_ATN == 1 || TRACE_ATN_SIM == 1
-    std::cout << "computeReachSet " << closure_->toString() << " -> " << reach->toString() << std::endl;
-#endif
-
-    if (reach->isEmpty()) {
-    return nullptr;
-  }
-  return reach;
-}
-
-ATNConfigSet* ParserATNSimulator::removeAllConfigsNotInRuleStopState(ATNConfigSet *configs,
-  bool lookToEndOfRule) {
-  if (PredictionModeClass::allConfigsInRuleStopStates(configs)) {
-    return configs;
-  }
-
-  ATNConfigSet *result = new ATNConfigSet(configs->fullCtx); /* mem-check: released by caller */
-
-  for (const auto &config : configs->configs) {
-    if (config->state != nullptr && config->state->getStateType() == ATNStateType::RULE_STOP) {
-      result->add(config, &mergeCache);
-      continue;
-    }
-
-    if (lookToEndOfRule && config->state->epsilonOnlyTransitions) {
-      misc::IntervalSet nextTokens = atn.nextTokens(config->state);
-      if (nextTokens.contains(Token::EPSILON)) {
-        ATNState *endOfRuleState = atn.ruleToStopState[config->state->ruleIndex];
-        result->add(std::make_shared<ATNConfig>(*config, endOfRuleState), &mergeCache);
-      }
-    }
-  }
-
-  return result;
-}
-
-std::unique_ptr<ATNConfigSet> ParserATNSimulator::computeStartState(ATNState *p, RuleContext *ctx, bool fullCtx) {
-  // always at least the implicit call to start rule
-  Ref<const PredictionContext> initialContext = PredictionContext::fromRuleContext(atn, ctx);
-  std::unique_ptr<ATNConfigSet> configs(new ATNConfigSet(fullCtx));
-
-#if DEBUG_ATN == 1 || TRACE_ATN_SIM == 1
-    std::cout << "computeStartState from ATN state " << p->toString() << " initialContext=" << initialContext->toString() << std::endl;
-#endif
-
-    for (size_t i = 0; i < p->transitions.size(); i++) {
-    ATNState *target = p->transitions[i]->target;
-    Ref<ATNConfig> c = std::make_shared<ATNConfig>(target, (int)i + 1, initialContext);
-    ATNConfig::Set closureBusy;
-    closure(c, configs.get(), closureBusy, true, fullCtx, false);
-  }
-
-  return configs;
-}
-
-std::unique_ptr<ATNConfigSet> ParserATNSimulator::applyPrecedenceFilter(ATNConfigSet *configs) {
-  std::map<size_t, Ref<const PredictionContext>> statesFromAlt1;
-  std::unique_ptr<ATNConfigSet> configSet(new ATNConfigSet(configs->fullCtx));
-  for (const auto &config : configs->configs) {
-    // handle alt 1 first
-    if (config->alt != 1) {
-      continue;
-    }
-
-    Ref<const SemanticContext> updatedContext = config->semanticContext->evalPrecedence(parser, _outerContext);
-    if (updatedContext == nullptr) {
-      // the configuration was eliminated
-      continue;
-    }
-
-    statesFromAlt1[config->state->stateNumber] = config->context;
-    if (updatedContext != config->semanticContext) {
-      configSet->add(std::make_shared<ATNConfig>(*config, updatedContext), &mergeCache);
-    }
-    else {
-      configSet->add(config, &mergeCache);
-    }
-  }
-
-  for (const auto &config : configs->configs) {
-    if (config->alt == 1) {
-      // already handled
-      continue;
-    }
-
-    if (!config->isPrecedenceFilterSuppressed()) {
-      /* In the future, this elimination step could be updated to also
-       * filter the prediction context for alternatives predicting alt>1
-       * (basically a graph subtraction algorithm).
-       */
-      auto iterator = statesFromAlt1.find(config->state->stateNumber);
-      if (iterator != statesFromAlt1.end() && *iterator->second == *config->context) {
-        // eliminated
-        continue;
-      }
-    }
-
-    configSet->add(config, &mergeCache);
-  }
-
-  return configSet;
-}
-
-atn::ATNState* ParserATNSimulator::getReachableTarget(const Transition *trans, size_t ttype) {
-  if (trans->matches(ttype, 0, atn.maxTokenType)) {
-    return trans->target;
-  }
-
-  return nullptr;
-}
-
-// Note that caller must memory manage the returned value from this function
-std::vector<Ref<const SemanticContext>> ParserATNSimulator::getPredsForAmbigAlts(const BitSet &ambigAlts,
-  ATNConfigSet *configs, size_t nalts) {
-  // REACH=[1|1|[]|0:0, 1|2|[]|0:1]
-  /* altToPred starts as an array of all null contexts. The entry at index i
-   * corresponds to alternative i. altToPred[i] may have one of three values:
-   *   1. null: no ATNConfig c is found such that c.alt==i
-   *   2. SemanticContext.NONE: At least one ATNConfig c exists such that
-   *      c.alt==i and c.semanticContext==SemanticContext.NONE. In other words,
-   *      alt i has at least one un-predicated config.
-   *   3. Non-NONE Semantic Context: There exists at least one, and for all
-   *      ATNConfig c such that c.alt==i, c.semanticContext!=SemanticContext.NONE.
-   *
-   * From this, it is clear that NONE||anything==NONE.
-   */
-  std::vector<Ref<const SemanticContext>> altToPred(nalts + 1);
-
-  for (const auto &c : configs->configs) {
-    if (ambigAlts.test(c->alt)) {
-      altToPred[c->alt] = SemanticContext::Or(altToPred[c->alt], c->semanticContext);
-    }
-  }
-
-  size_t nPredAlts = 0;
-  for (size_t i = 1; i <= nalts; i++) {
-    if (altToPred[i] == nullptr) {
-      altToPred[i] = SemanticContext::Empty::Instance;
-    } else if (altToPred[i] != SemanticContext::Empty::Instance) {
-      nPredAlts++;
-    }
-  }
-
-  // nonambig alts are null in altToPred
-  if (nPredAlts == 0) {
-    altToPred.clear();
-  }
-#if DEBUG_ATN == 1
-    std::cout << "getPredsForAmbigAlts result " << Arrays::toString(altToPred) << std::endl;
-#endif
-
-  return altToPred;
-}
-
-std::vector<dfa::DFAState::PredPrediction> ParserATNSimulator::getPredicatePredictions(const antlrcpp::BitSet &ambigAlts,
-                                                                                       const std::vector<Ref<const SemanticContext>> &altToPred) {
-  bool containsPredicate = std::find_if(altToPred.begin(), altToPred.end(), [](const Ref<const SemanticContext> &context) {
-    return context != SemanticContext::Empty::Instance;
-  }) != altToPred.end();
-  std::vector<dfa::DFAState::PredPrediction> pairs;
-  if (containsPredicate) {
-    for (size_t i = 1; i < altToPred.size(); i++) {
-      const auto &pred = altToPred[i];
-      assert(pred != nullptr); // unpredicted is indicated by SemanticContext.NONE
-      if (ambigAlts.test(i)) {
-        pairs.emplace_back(pred, static_cast<int>(i));
-      }
-    }
-  }
-  return pairs;
-}
-
-size_t ParserATNSimulator::getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(ATNConfigSet *configs,
-  ParserRuleContext *outerContext)
-{
-  std::pair<ATNConfigSet *, ATNConfigSet *> sets = splitAccordingToSemanticValidity(configs, outerContext);
-  std::unique_ptr<ATNConfigSet> semValidConfigs(sets.first);
-  std::unique_ptr<ATNConfigSet> semInvalidConfigs(sets.second);
-  size_t alt = getAltThatFinishedDecisionEntryRule(semValidConfigs.get());
-  if (alt != ATN::INVALID_ALT_NUMBER) { // semantically/syntactically viable path exists
-    return alt;
-  }
-  // Is there a syntactically valid path with a failed pred?
-  if (!semInvalidConfigs->configs.empty()) {
-    alt = getAltThatFinishedDecisionEntryRule(semInvalidConfigs.get());
-    if (alt != ATN::INVALID_ALT_NUMBER) { // syntactically viable path exists
-      return alt;
-    }
-  }
-  return ATN::INVALID_ALT_NUMBER;
-}
-
-size_t ParserATNSimulator::getAltThatFinishedDecisionEntryRule(ATNConfigSet *configs) {
-  misc::IntervalSet alts;
-  for (const auto &c : configs->configs) {
-    if (c->getOuterContextDepth() > 0 || (c->state != nullptr && c->state->getStateType() == ATNStateType::RULE_STOP && c->context->hasEmptyPath())) {
-      alts.add(c->alt);
-    }
-  }
-  if (alts.size() == 0) {
-    return ATN::INVALID_ALT_NUMBER;
-  }
-  return alts.getMinElement();
-}
-
-std::pair<ATNConfigSet *, ATNConfigSet *> ParserATNSimulator::splitAccordingToSemanticValidity(ATNConfigSet *configs,
-  ParserRuleContext *outerContext) {
-
-  // mem-check: both pointers must be freed by the caller.
-  ATNConfigSet *succeeded(new ATNConfigSet(configs->fullCtx));
-  ATNConfigSet *failed(new ATNConfigSet(configs->fullCtx));
-  for (const auto &c : configs->configs) {
-    if (c->semanticContext != SemanticContext::Empty::Instance) {
-      bool predicateEvaluationResult = evalSemanticContext(c->semanticContext, outerContext, c->alt, configs->fullCtx);
-      if (predicateEvaluationResult) {
-        succeeded->add(c);
-      } else {
-        failed->add(c);
-      }
-    } else {
-      succeeded->add(c);
-    }
-  }
-  return { succeeded, failed };
-}
-
-BitSet ParserATNSimulator::evalSemanticContext(const std::vector<dfa::DFAState::PredPrediction> &predPredictions,
-                                               ParserRuleContext *outerContext, bool complete) {
-  BitSet predictions;
-  for (const auto &prediction : predPredictions) {
-    if (prediction.pred == SemanticContext::Empty::Instance) {
-      predictions.set(prediction.alt);
-      if (!complete) {
-        break;
-      }
-      continue;
-    }
-
-    bool fullCtx = false; // in dfa
-    bool predicateEvaluationResult = evalSemanticContext(prediction.pred, outerContext, prediction.alt, fullCtx);
-#if DEBUG_ATN == 1 || DFA_DEBUG == 1
-      std::cout << "eval pred " << prediction.toString() << " = " << predicateEvaluationResult << std::endl;
-#endif
-
-    if (predicateEvaluationResult) {
-#if DEBUG_ATN == 1 || DFA_DEBUG == 1
-        std::cout << "PREDICT " << prediction.alt << std::endl;
-#endif
-
-      predictions.set(prediction.alt);
-      if (!complete) {
-        break;
-      }
-    }
-  }
-
-  return predictions;
-}
-
-bool ParserATNSimulator::evalSemanticContext(Ref<const SemanticContext> const& pred, ParserRuleContext *parserCallStack,
-                                             size_t /*alt*/, bool /*fullCtx*/) {
-  return pred->eval(parser, parserCallStack);
-}
-
-void ParserATNSimulator::closure(Ref<ATNConfig> const& config, ATNConfigSet *configs, ATNConfig::Set &closureBusy,
-                                 bool collectPredicates, bool fullCtx, bool treatEofAsEpsilon) {
-  const int initialDepth = 0;
-  closureCheckingStopState(config, configs, closureBusy, collectPredicates, fullCtx, initialDepth, treatEofAsEpsilon);
-
-  assert(!fullCtx || !configs->dipsIntoOuterContext);
-}
-
-void ParserATNSimulator::closureCheckingStopState(Ref<ATNConfig> const& config, ATNConfigSet *configs,
-  ATNConfig::Set &closureBusy, bool collectPredicates, bool fullCtx, int depth, bool treatEofAsEpsilon) {
-
-#if TRACE_ATN_SIM == 1
-    std::cout << "closure(" << config->toString(true) << ")" << std::endl;
-#endif
-
-  if (config->state != nullptr && config->state->getStateType() == ATNStateType::RULE_STOP) {
-    // We hit rule end. If we have context info, use it
-    // run thru all possible stack tops in ctx
-    if (!config->context->isEmpty()) {
-      for (size_t i = 0; i < config->context->size(); i++) {
-        if (config->context->getReturnState(i) == PredictionContext::EMPTY_RETURN_STATE) {
-          if (fullCtx) {
-            configs->add(std::make_shared<ATNConfig>(*config, config->state, PredictionContext::EMPTY), &mergeCache);
-            continue;
-          } else {
-            // we have no context info, just chase follow links (if greedy)
-#if DEBUG_ATN == 1
-              std::cout << "FALLING off rule " << getRuleName(config->state->ruleIndex) << std::endl;
-#endif
-            closure_(config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEofAsEpsilon);
-          }
-          continue;
-        }
-        ATNState *returnState = atn.states[config->context->getReturnState(i)];
-        Ref<const PredictionContext> newContext = config->context->getParent(i); // "pop" return state
-        Ref<ATNConfig> c = std::make_shared<ATNConfig>(returnState, config->alt, newContext, config->semanticContext);
-        // While we have context to pop back from, we may have
-        // gotten that context AFTER having falling off a rule.
-        // Make sure we track that we are now out of context.
-        //
-        // This assignment also propagates the
-        // isPrecedenceFilterSuppressed() value to the new
-        // configuration.
-        c->reachesIntoOuterContext = config->reachesIntoOuterContext;
-        assert(depth > INT_MIN);
-
-        closureCheckingStopState(c, configs, closureBusy, collectPredicates, fullCtx, depth - 1, treatEofAsEpsilon);
-      }
-      return;
-    } else if (fullCtx) {
-      // reached end of start rule
-      configs->add(config, &mergeCache);
-      return;
-    } else {
-      // else if we have no context info, just chase follow links (if greedy)
-    }
-  }
-
-  closure_(config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEofAsEpsilon);
-}
-
-void ParserATNSimulator::closure_(Ref<ATNConfig> const& config, ATNConfigSet *configs, ATNConfig::Set &closureBusy,
-                                  bool collectPredicates, bool fullCtx, int depth, bool treatEofAsEpsilon) {
-  ATNState *p = config->state;
-  // optimization
-  if (!p->epsilonOnlyTransitions) {
-    // make sure to not return here, because EOF transitions can act as
-    // both epsilon transitions and non-epsilon transitions.
-    configs->add(config, &mergeCache);
-  }
-
-  for (size_t i = 0; i < p->transitions.size(); i++) {
-    if (i == 0 && canDropLoopEntryEdgeInLeftRecursiveRule(config.get()))
-      continue;
-
-    const Transition *t = p->transitions[i].get();
-    bool continueCollecting = !(t != nullptr && t->getTransitionType() == TransitionType::ACTION) && collectPredicates;
-    Ref<ATNConfig> c = getEpsilonTarget(config, t, continueCollecting, depth == 0, fullCtx, treatEofAsEpsilon);
-    if (c != nullptr) {
-      int newDepth = depth;
-      if (config->state != nullptr && config->state->getStateType() == ATNStateType::RULE_STOP) {
-        assert(!fullCtx);
-
-        // target fell off end of rule; mark resulting c as having dipped into outer context
-        // We can't get here if incoming config was rule stop and we had context
-        // track how far we dip into outer context.  Might
-        // come in handy and we avoid evaluating context dependent
-        // preds if this is > 0.
-
-        if (closureBusy.count(c) > 0) {
-          // avoid infinite recursion for right-recursive rules
-          continue;
-        }
-        closureBusy.insert(c);
-
-        if (_dfa != nullptr && _dfa->isPrecedenceDfa()) {
-          size_t outermostPrecedenceReturn = downCast<const EpsilonTransition *>(t)->outermostPrecedenceReturn();
-          if (outermostPrecedenceReturn == _dfa->atnStartState->ruleIndex) {
-            c->setPrecedenceFilterSuppressed(true);
-          }
-        }
-
-        c->reachesIntoOuterContext++;
-
-        if (!t->isEpsilon()) {
-          // avoid infinite recursion for EOF* and EOF+
-          if (closureBusy.count(c) == 0) {
-            closureBusy.insert(c);
-          } else {
-            continue;
-          }
-        }
-
-        configs->dipsIntoOuterContext = true; // TODO: can remove? only care when we add to set per middle of this method
-        assert(newDepth > INT_MIN);
-
-        newDepth--;
-#if DFA_DEBUG == 1
-          std::cout << "dips into outer ctx: " << c << std::endl;
-#endif
-
-      } else  if (!t->isEpsilon()) {
-        // avoid infinite recursion for EOF* and EOF+
-        if (closureBusy.count(c) == 0) {
-          closureBusy.insert(c);
-        } else {
-          continue;
-        }
-      }
-
-      if (t != nullptr && t->getTransitionType() == TransitionType::RULE) {
-        // latch when newDepth goes negative - once we step out of the entry context we can't return
-        if (newDepth >= 0) {
-          newDepth++;
-        }
-      }
-
-      closureCheckingStopState(c, configs, closureBusy, continueCollecting, fullCtx, newDepth, treatEofAsEpsilon);
-    }
-  }
-}
-
-bool ParserATNSimulator::canDropLoopEntryEdgeInLeftRecursiveRule(ATNConfig *config) const {
-  if (TURN_OFF_LR_LOOP_ENTRY_BRANCH_OPT)
-    return false;
-
-  ATNState *p = config->state;
-
-  // First check to see if we are in StarLoopEntryState generated during
-  // left-recursion elimination. For efficiency, also check if
-  // the context has an empty stack case. If so, it would mean
-  // global FOLLOW so we can't perform optimization
-  if (p->getStateType() != ATNStateType::STAR_LOOP_ENTRY ||
-      !((StarLoopEntryState *)p)->isPrecedenceDecision || // Are we the special loop entry/exit state?
-      config->context->isEmpty() ||                      // If SLL wildcard
-      config->context->hasEmptyPath())
-  {
-    return false;
-  }
-
-  // Require all return states to return back to the same rule
-  // that p is in.
-  size_t numCtxs = config->context->size();
-  for (size_t i = 0; i < numCtxs; i++) { // for each stack context
-    ATNState *returnState = atn.states[config->context->getReturnState(i)];
-    if (returnState->ruleIndex != p->ruleIndex)
-      return false;
-  }
-
-  BlockStartState *decisionStartState = (BlockStartState *)p->transitions[0]->target;
-  size_t blockEndStateNum = decisionStartState->endState->stateNumber;
-  BlockEndState *blockEndState = (BlockEndState *)atn.states[blockEndStateNum];
-
-  // Verify that the top of each stack context leads to loop entry/exit
-  // state through epsilon edges and w/o leaving rule.
-  for (size_t i = 0; i < numCtxs; i++) {                           // for each stack context
-    size_t returnStateNumber = config->context->getReturnState(i);
-    ATNState *returnState = atn.states[returnStateNumber];
-    // All states must have single outgoing epsilon edge.
-    if (returnState->transitions.size() != 1 || !returnState->transitions[0]->isEpsilon())
-    {
-      return false;
-    }
-
-    // Look for prefix op case like 'not expr', (' type ')' expr
-    ATNState *returnStateTarget = returnState->transitions[0]->target;
-    if (returnState->getStateType() == ATNStateType::BLOCK_END && returnStateTarget == p) {
-      continue;
-    }
-
-    // Look for 'expr op expr' or case where expr's return state is block end
-    // of (...)* internal block; the block end points to loop back
-    // which points to p but we don't need to check that
-    if (returnState == blockEndState) {
-      continue;
-    }
-
-    // Look for ternary expr ? expr : expr. The return state points at block end,
-    // which points at loop entry state
-    if (returnStateTarget == blockEndState) {
-      continue;
-    }
-
-    // Look for complex prefix 'between expr and expr' case where 2nd expr's
-    // return state points at block end state of (...)* internal block
-    if (returnStateTarget->getStateType() == ATNStateType::BLOCK_END &&
-        returnStateTarget->transitions.size() == 1 &&
-        returnStateTarget->transitions[0]->isEpsilon() &&
-        returnStateTarget->transitions[0]->target == p)
-    {
-      continue;
-    }
-
-    // Anything else ain't conforming.
-    return false;
-  }
-
-  return true;
-}
-
-std::string ParserATNSimulator::getRuleName(size_t index) {
-  if (parser != nullptr) {
-    return parser->getRuleNames()[index];
-  }
-  return "<rule " + std::to_string(index) + ">";
-}
-
-Ref<ATNConfig> ParserATNSimulator::getEpsilonTarget(Ref<ATNConfig> const& config, const Transition *t, bool collectPredicates,
-                                                    bool inContext, bool fullCtx, bool treatEofAsEpsilon) {
-  switch (t->getTransitionType()) {
-    case TransitionType::RULE:
-      return ruleTransition(config, static_cast<const RuleTransition*>(t));
-
-    case TransitionType::PRECEDENCE:
-      return precedenceTransition(config, static_cast<const PrecedencePredicateTransition*>(t), collectPredicates, inContext, fullCtx);
-
-    case TransitionType::PREDICATE:
-      return predTransition(config, static_cast<const PredicateTransition*>(t), collectPredicates, inContext, fullCtx);
-
-    case TransitionType::ACTION:
-      return actionTransition(config, static_cast<const ActionTransition*>(t));
-
-    case TransitionType::EPSILON:
-      return std::make_shared<ATNConfig>(*config, t->target);
-
-    case TransitionType::ATOM:
-    case TransitionType::RANGE:
-    case TransitionType::SET:
-      // EOF transitions act like epsilon transitions after the first EOF
-      // transition is traversed
-      if (treatEofAsEpsilon) {
-        if (t->matches(Token::EOF, 0, 1)) {
-          return std::make_shared<ATNConfig>(*config, t->target);
-        }
-      }
-
-      return nullptr;
-
-    default:
-      return nullptr;
-  }
-}
-
-Ref<ATNConfig> ParserATNSimulator::actionTransition(Ref<ATNConfig> const& config, const ActionTransition *t) {
-#if DFA_DEBUG == 1
-    std::cout << "ACTION edge " << t->ruleIndex << ":" << t->actionIndex << std::endl;
-#endif
-
-  return std::make_shared<ATNConfig>(*config, t->target);
-}
-
-Ref<ATNConfig> ParserATNSimulator::precedenceTransition(Ref<ATNConfig> const& config, const PrecedencePredicateTransition *pt,
-    bool collectPredicates, bool inContext, bool fullCtx) {
-#if DFA_DEBUG == 1
-    std::cout << "PRED (collectPredicates=" << collectPredicates << ") " << pt->getPrecedence() << ">=_p" << ", ctx dependent=true" << std::endl;
-    if (parser != nullptr) {
-      std::cout << "context surrounding pred is " << Arrays::listToString(parser->getRuleInvocationStack(), ", ") << std::endl;
-    }
-#endif
-
-  Ref<ATNConfig> c;
-  if (collectPredicates && inContext) {
-    const auto &predicate = pt->getPredicate();
-
-    if (fullCtx) {
-      // In full context mode, we can evaluate predicates on-the-fly
-      // during closure, which dramatically reduces the size of
-      // the config sets. It also obviates the need to test predicates
-      // later during conflict resolution.
-      size_t currentPosition = _input->index();
-      _input->seek(_startIndex);
-      bool predSucceeds = evalSemanticContext(predicate, _outerContext, config->alt, fullCtx);
-      _input->seek(currentPosition);
-      if (predSucceeds) {
-        c = std::make_shared<ATNConfig>(*config, pt->target); // no pred context
-      }
-    } else {
-      Ref<const SemanticContext> newSemCtx = SemanticContext::And(config->semanticContext, predicate);
-      c = std::make_shared<ATNConfig>(*config, pt->target, std::move(newSemCtx));
-    }
-  } else {
-    c = std::make_shared<ATNConfig>(*config, pt->target);
-  }
-
-#if DFA_DEBUG == 1
-    std::cout << "config from pred transition=" << c << std::endl;
-#endif
-
-  return c;
-}
-
-Ref<ATNConfig> ParserATNSimulator::predTransition(Ref<ATNConfig> const& config, const PredicateTransition *pt,
-  bool collectPredicates, bool inContext, bool fullCtx) {
-#if DFA_DEBUG == 1
-    std::cout << "PRED (collectPredicates=" << collectPredicates << ") " << pt->getRuleIndex() << ":" << pt->getPredIndex() << ", ctx dependent=" << pt->isCtxDependent() << std::endl;
-    if (parser != nullptr) {
-      std::cout << "context surrounding pred is " << Arrays::listToString(parser->getRuleInvocationStack(), ", ") << std::endl;
-    }
-#endif
-
-  Ref<ATNConfig> c = nullptr;
-  if (collectPredicates && (!pt->isCtxDependent() || (pt->isCtxDependent() && inContext))) {
-    const auto &predicate = pt->getPredicate();
-    if (fullCtx) {
-      // In full context mode, we can evaluate predicates on-the-fly
-      // during closure, which dramatically reduces the size of
-      // the config sets. It also obviates the need to test predicates
-      // later during conflict resolution.
-      size_t currentPosition = _input->index();
-      _input->seek(_startIndex);
-      bool predSucceeds = evalSemanticContext(predicate, _outerContext, config->alt, fullCtx);
-      _input->seek(currentPosition);
-      if (predSucceeds) {
-        c = std::make_shared<ATNConfig>(*config, pt->target); // no pred context
-      }
-    } else {
-      Ref<const SemanticContext> newSemCtx = SemanticContext::And(config->semanticContext, predicate);
-      c = std::make_shared<ATNConfig>(*config, pt->target, std::move(newSemCtx));
-    }
-  } else {
-    c = std::make_shared<ATNConfig>(*config, pt->target);
-  }
-
-#if DFA_DEBUG == 1
-    std::cout << "config from pred transition=" << c << std::endl;
-#endif
-
-  return c;
-}
-
-Ref<ATNConfig> ParserATNSimulator::ruleTransition(Ref<ATNConfig> const& config, const RuleTransition *t) {
-#if DFA_DEBUG == 1
-    std::cout << "CALL rule " << getRuleName(t->target->ruleIndex) << ", ctx=" << config->context << std::endl;
-#endif
-
-  atn::ATNState *returnState = t->followState;
-  Ref<const PredictionContext> newContext = SingletonPredictionContext::create(config->context, returnState->stateNumber);
-  return std::make_shared<ATNConfig>(*config, t->target, newContext);
-}
-
-BitSet ParserATNSimulator::getConflictingAlts(ATNConfigSet *configs) {
-  std::vector<BitSet> altsets = PredictionModeClass::getConflictingAltSubsets(configs);
-  return PredictionModeClass::getAlts(altsets);
-}
-
-BitSet ParserATNSimulator::getConflictingAltsOrUniqueAlt(ATNConfigSet *configs) {
-  BitSet conflictingAlts;
-  if (configs->uniqueAlt != ATN::INVALID_ALT_NUMBER) {
-    conflictingAlts.set(configs->uniqueAlt);
-  } else {
-    conflictingAlts = configs->conflictingAlts;
-  }
-  return conflictingAlts;
-}
-
-std::string ParserATNSimulator::getTokenName(size_t t) {
-  if (t == Token::EOF) {
-    return "EOF";
-  }
-
-  const dfa::Vocabulary &vocabulary = parser != nullptr ? parser->getVocabulary() : dfa::Vocabulary();
-  std::string displayName = vocabulary.getDisplayName(t);
-  if (displayName == std::to_string(t)) {
-    return displayName;
-  }
-
-  return displayName + "<" + std::to_string(t) + ">";
-}
-
-std::string ParserATNSimulator::getLookaheadName(TokenStream *input) {
-  return getTokenName(input->LA(1));
-}
-
-void ParserATNSimulator::dumpDeadEndConfigs(NoViableAltException &nvae) {
-  std::cerr << "dead end configs: ";
-  for (const auto &c : nvae.getDeadEndConfigs()->configs) {
-    std::string trans = "no edges";
-    if (c->state->transitions.size() > 0) {
-      const Transition *t = c->state->transitions[0].get();
-      if (t != nullptr && t->getTransitionType() == TransitionType::ATOM) {
-        const AtomTransition *at = static_cast<const AtomTransition*>(t);
-        trans = "Atom " + getTokenName(at->_label);
-      } else if (t != nullptr && t->getTransitionType() == TransitionType::SET) {
-        const SetTransition *st = static_cast<const SetTransition*>(t);
-        trans = "Set ";
-        trans += st->set.toString();
-      } else if (t != nullptr && t->getTransitionType() == TransitionType::NOT_SET) {
-        const SetTransition *st = static_cast<const NotSetTransition*>(t);
-        trans = "~Set ";
-        trans += st->set.toString();
-      }
-    }
-    std::cerr << c->toString(true) + ":" + trans;
-  }
-}
-
-NoViableAltException ParserATNSimulator::noViableAlt(TokenStream *input, ParserRuleContext *outerContext,
-  ATNConfigSet *configs, size_t startIndex, bool deleteConfigs) {
-  return NoViableAltException(parser, input, input->get(startIndex), input->LT(1), configs, outerContext, deleteConfigs);
-}
-
-size_t ParserATNSimulator::getUniqueAlt(ATNConfigSet *configs) {
-  size_t alt = ATN::INVALID_ALT_NUMBER;
-  for (const auto &c : configs->configs) {
-    if (alt == ATN::INVALID_ALT_NUMBER) {
-      alt = c->alt; // found first alt
-    } else if (c->alt != alt) {
-      return ATN::INVALID_ALT_NUMBER;
-    }
-  }
-  return alt;
-}
-
-dfa::DFAState *ParserATNSimulator::addDFAEdge(dfa::DFA &dfa, dfa::DFAState *from, ssize_t t, dfa::DFAState *to) {
-#if DFA_DEBUG == 1
-    std::cout << "EDGE " << from << " -> " << to << " upon " << getTokenName(t) << std::endl;
-#endif
-
-  if (to == nullptr) {
-    return nullptr;
-  }
-
-  {
-    UniqueLock<SharedMutex> stateLock(atn._stateMutex);
-    to = addDFAState(dfa, to); // used existing if possible not incoming
-  }
-  if (from == nullptr || t > (int)atn.maxTokenType) {
-    return to;
-  }
-
-  {
-    UniqueLock<SharedMutex> edgeLock(atn._edgeMutex);
-    from->edges[t] = to; // connect
-  }
-
-#if DFA_DEBUG == 1
-    std::string dfaText;
-    if (parser != nullptr) {
-      dfaText = dfa.toString(parser->getVocabulary());
-    } else {
-      dfaText = dfa.toString(dfa::Vocabulary());
-    }
-    std::cout << "DFA=\n" << dfaText << std::endl;
-#endif
-
-  return to;
-}
-
-dfa::DFAState *ParserATNSimulator::addDFAState(dfa::DFA &dfa, dfa::DFAState *D) {
-  if (D == ERROR.get()) {
-    return D;
-  }
-
-  // Optimizing the configs below should not alter the hash code. Thus we can just do an insert
-  // which will only succeed if an equivalent DFAState does not already exist.
-  auto [existing, inserted] = dfa.states.insert(D);
-  if (!inserted) {
-#if TRACE_ATN_SIM == 1
-      std::cout << "addDFAState " << D->toString() << " exists" << std::endl;
-#endif
-    return *existing;
-  }
-
-  // Previously we did a lookup, then set fields, then inserted. It was `dfa.states.size()`, since
-  // we already inserted we need to subtract one.
-  D->stateNumber = static_cast<int>(dfa.states.size() - 1);
-
-#if TRACE_ATN_SIM == 1
-    std::cout << "addDFAState new " << D->toString() << std::endl;
-#endif
-
-  if (!D->configs->isReadonly()) {
-    D->configs->optimizeConfigs(this);
-    D->configs->setReadonly(true);
-  }
-
-#if DFA_DEBUG == 1
-  std::cout << "adding new DFA state: " << D << std::endl;
-#endif
-
-  return D;
-}
-
-void ParserATNSimulator::reportAttemptingFullContext(dfa::DFA &dfa, const antlrcpp::BitSet &conflictingAlts,
-  ATNConfigSet *configs, size_t startIndex, size_t stopIndex) {
-#if DFA_DEBUG == 1 || RETRY_DEBUG == 1
-    misc::Interval interval = misc::Interval((int)startIndex, (int)stopIndex);
-    std::cout << "reportAttemptingFullContext decision=" << dfa.decision << ":" << configs << ", input=" << parser->getTokenStream()->getText(interval) << std::endl;
-#endif
-
-  if (parser != nullptr) {
-    parser->getErrorListenerDispatch().reportAttemptingFullContext(parser, dfa, startIndex, stopIndex, conflictingAlts, configs);
-  }
-}
-
-void ParserATNSimulator::reportContextSensitivity(dfa::DFA &dfa, size_t prediction, ATNConfigSet *configs,
-  size_t startIndex, size_t stopIndex) {
-#if DFA_DEBUG == 1 || RETRY_DEBUG == 1
-    misc::Interval interval = misc::Interval(startIndex, stopIndex);
-    std::cout << "reportContextSensitivity decision=" << dfa.decision << ":" << configs << ", input=" << parser->getTokenStream()->getText(interval) << std::endl;
-#endif
-
-  if (parser != nullptr) {
-    parser->getErrorListenerDispatch().reportContextSensitivity(parser, dfa, startIndex, stopIndex, prediction, configs);
-  }
-}
-
-void ParserATNSimulator::reportAmbiguity(dfa::DFA &dfa, dfa::DFAState * /*D*/, size_t startIndex, size_t stopIndex,
-                                         bool exact, const antlrcpp::BitSet &ambigAlts, ATNConfigSet *configs) {
-#if DFA_DEBUG == 1 || RETRY_DEBUG == 1
-    misc::Interval interval = misc::Interval((int)startIndex, (int)stopIndex);
-    std::cout << "reportAmbiguity " << ambigAlts << ":" << configs << ", input=" << parser->getTokenStream()->getText(interval) << std::endl;
-#endif
-
-  if (parser != nullptr) {
-    parser->getErrorListenerDispatch().reportAmbiguity(parser, dfa, startIndex, stopIndex, exact, ambigAlts, configs);
-  }
-}
-
-void ParserATNSimulator::setPredictionMode(PredictionMode newMode) {
-  _mode = newMode;
-}
-
-atn::PredictionMode ParserATNSimulator::getPredictionMode() {
-  return _mode;
-}
-
-Parser* ParserATNSimulator::getParser() {
-  return parser;
-}
-
-#ifdef _MSC_VER
-#pragma warning (disable:4996) // 'getenv': This function or variable may be unsafe. Consider using _dupenv_s instead.
-#endif
-
-bool ParserATNSimulator::getLrLoopSetting() {
-  char *var = std::getenv("TURN_OFF_LR_LOOP_ENTRY_BRANCH_OPT");
-  if (var == nullptr)
-    return false;
-  std::string value(var);
-  return value == "true" || value == "1";
-}
-
-#ifdef _MSC_VER
-#pragma warning (default:4996)
-#endif
-
-void ParserATNSimulator::InitializeInstanceFields() {
-  _mode = PredictionMode::LL;
-  _startIndex = 0;
-}