expressir 0.2.5-x64-mingw32 → 0.2.7-x64-mingw32

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/DecisionInfo.h

@@ -1,227 +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.
- */
-
-#pragma once
-
-#include "atn/ContextSensitivityInfo.h"
-#include "atn/AmbiguityInfo.h"
-#include "atn/PredicateEvalInfo.h"
-#include "atn/ErrorInfo.h"
-
-namespace antlr4 {
-namespace atn {
-
-  class LookaheadEventInfo;
-
-  /// <summary>
-  /// This class contains profiling gathered for a particular decision.
-  ///
-  /// <para>
-  /// Parsing performance in ANTLR 4 is heavily influenced by both static factors
-  /// (e.g. the form of the rules in the grammar) and dynamic factors (e.g. the
-  /// choice of input and the state of the DFA cache at the time profiling
-  /// operations are started). For best results, gather and use aggregate
-  /// statistics from a large sample of inputs representing the inputs expected in
-  /// production before using the results to make changes in the grammar.</para>
-  ///
-  /// @since 4.3
-  /// </summary>
-  class ANTLR4CPP_PUBLIC DecisionInfo {
-  public:
-    /// <summary>
-    /// The decision number, which is an index into <seealso cref="ATN#decisionToState"/>.
-    /// </summary>
-    const size_t decision;
-
-    /// <summary>
-    /// The total number of times <seealso cref="ParserATNSimulator#adaptivePredict"/> was
-    /// invoked for this decision.
-    /// </summary>
-    long long invocations = 0;
-
-    /// <summary>
-    /// The total time spent in <seealso cref="ParserATNSimulator#adaptivePredict"/> for
-    /// this decision, in nanoseconds.
-    ///
-    /// <para>
-    /// The value of this field contains the sum of differential results obtained
-    /// by <seealso cref="System#nanoTime()"/>, and is not adjusted to compensate for JIT
-    /// and/or garbage collection overhead. For best accuracy, use a modern JVM
-    /// implementation that provides precise results from
-    /// <seealso cref="System#nanoTime()"/>, and perform profiling in a separate process
-    /// which is warmed up by parsing the input prior to profiling. If desired,
-    /// call <seealso cref="ATNSimulator#clearDFA"/> to reset the DFA cache to its initial
-    /// state before starting the profiling measurement pass.</para>
-    /// </summary>
-    long long timeInPrediction = 0;
-
-    /// <summary>
-    /// The sum of the lookahead required for SLL prediction for this decision.
-    /// Note that SLL prediction is used before LL prediction for performance
-    /// reasons even when <seealso cref="PredictionMode#LL"/> or
-    /// <seealso cref="PredictionMode#LL_EXACT_AMBIG_DETECTION"/> is used.
-    /// </summary>
-    long long SLL_TotalLook = 0;
-
-    /// <summary>
-    /// Gets the minimum lookahead required for any single SLL prediction to
-    /// complete for this decision, by reaching a unique prediction, reaching an
-    /// SLL conflict state, or encountering a syntax error.
-    /// </summary>
-    long long SLL_MinLook = 0;
-
-    /// <summary>
-    /// Gets the maximum lookahead required for any single SLL prediction to
-    /// complete for this decision, by reaching a unique prediction, reaching an
-    /// SLL conflict state, or encountering a syntax error.
-    /// </summary>
-    long long SLL_MaxLook = 0;
-
-    /// Gets the <seealso cref="LookaheadEventInfo"/> associated with the event where the
-    /// <seealso cref="#SLL_MaxLook"/> value was set.
-    Ref<LookaheadEventInfo> SLL_MaxLookEvent;
-
-    /// <summary>
-    /// The sum of the lookahead required for LL prediction for this decision.
-    /// Note that LL prediction is only used when SLL prediction reaches a
-    /// conflict state.
-    /// </summary>
-    long long LL_TotalLook = 0;
-
-    /// <summary>
-    /// Gets the minimum lookahead required for any single LL prediction to
-    /// complete for this decision. An LL prediction completes when the algorithm
-    /// reaches a unique prediction, a conflict state (for
-    /// <seealso cref="PredictionMode#LL"/>, an ambiguity state (for
-    /// <seealso cref="PredictionMode#LL_EXACT_AMBIG_DETECTION"/>, or a syntax error.
-    /// </summary>
-    long long LL_MinLook = 0;
-
-    /// <summary>
-    /// Gets the maximum lookahead required for any single LL prediction to
-    /// complete for this decision. An LL prediction completes when the algorithm
-    /// reaches a unique prediction, a conflict state (for
-    /// <seealso cref="PredictionMode#LL"/>, an ambiguity state (for
-    /// <seealso cref="PredictionMode#LL_EXACT_AMBIG_DETECTION"/>, or a syntax error.
-    /// </summary>
-    long long LL_MaxLook = 0;
-
-    /// <summary>
-    /// Gets the <seealso cref="LookaheadEventInfo"/> associated with the event where the
-    /// <seealso cref="#LL_MaxLook"/> value was set.
-    /// </summary>
-    Ref<LookaheadEventInfo> LL_MaxLookEvent;
-
-    /// <summary>
-    /// A collection of <seealso cref="ContextSensitivityInfo"/> instances describing the
-    /// context sensitivities encountered during LL prediction for this decision.
-    /// </summary>
-    /// <seealso cref= ContextSensitivityInfo </seealso>
-    std::vector<ContextSensitivityInfo> contextSensitivities;
-
-    /// <summary>
-    /// A collection of <seealso cref="ErrorInfo"/> instances describing the parse errors
-    /// identified during calls to <seealso cref="ParserATNSimulator#adaptivePredict"/> for
-    /// this decision.
-    /// </summary>
-    /// <seealso cref= ErrorInfo </seealso>
-    std::vector<ErrorInfo> errors;
-
-    /// <summary>
-    /// A collection of <seealso cref="AmbiguityInfo"/> instances describing the
-    /// ambiguities encountered during LL prediction for this decision.
-    /// </summary>
-    /// <seealso cref= AmbiguityInfo </seealso>
-    std::vector<AmbiguityInfo> ambiguities;
-
-    /// <summary>
-    /// A collection of <seealso cref="PredicateEvalInfo"/> instances describing the
-    /// results of evaluating individual predicates during prediction for this
-    /// decision.
-    /// </summary>
-    /// <seealso cref= PredicateEvalInfo </seealso>
-    std::vector<PredicateEvalInfo> predicateEvals;
-
-    /// <summary>
-    /// The total number of ATN transitions required during SLL prediction for
-    /// this decision. An ATN transition is determined by the number of times the
-    /// DFA does not contain an edge that is required for prediction, resulting
-    /// in on-the-fly computation of that edge.
-    ///
-    /// <para>
-    /// If DFA caching of SLL transitions is employed by the implementation, ATN
-    /// computation may cache the computed edge for efficient lookup during
-    /// future parsing of this decision. Otherwise, the SLL parsing algorithm
-    /// will use ATN transitions exclusively.</para>
-    /// </summary>
-    /// <seealso cref= #SLL_ATNTransitions </seealso>
-    /// <seealso cref= ParserATNSimulator#computeTargetState </seealso>
-    /// <seealso cref= LexerATNSimulator#computeTargetState </seealso>
-    long long SLL_ATNTransitions = 0;
-
-    /// <summary>
-    /// The total number of DFA transitions required during SLL prediction for
-    /// this decision.
-    ///
-    /// <para>If the ATN simulator implementation does not use DFA caching for SLL
-    /// transitions, this value will be 0.</para>
-    /// </summary>
-    /// <seealso cref= ParserATNSimulator#getExistingTargetState </seealso>
-    /// <seealso cref= LexerATNSimulator#getExistingTargetState </seealso>
-    long long SLL_DFATransitions = 0;
-
-    /// <summary>
-    /// Gets the total number of times SLL prediction completed in a conflict
-    /// state, resulting in fallback to LL prediction.
-    ///
-    /// <para>Note that this value is not related to whether or not
-    /// <seealso cref="PredictionMode#SLL"/> may be used successfully with a particular
-    /// grammar. If the ambiguity resolution algorithm applied to the SLL
-    /// conflicts for this decision produce the same result as LL prediction for
-    /// this decision, <seealso cref="PredictionMode#SLL"/> would produce the same overall
-    /// parsing result as <seealso cref="PredictionMode#LL"/>.</para>
-    /// </summary>
-    long long LL_Fallback = 0;
-
-    /// <summary>
-    /// The total number of ATN transitions required during LL prediction for
-    /// this decision. An ATN transition is determined by the number of times the
-    /// DFA does not contain an edge that is required for prediction, resulting
-    /// in on-the-fly computation of that edge.
-    ///
-    /// <para>
-    /// If DFA caching of LL transitions is employed by the implementation, ATN
-    /// computation may cache the computed edge for efficient lookup during
-    /// future parsing of this decision. Otherwise, the LL parsing algorithm will
-    /// use ATN transitions exclusively.</para>
-    /// </summary>
-    /// <seealso cref= #LL_DFATransitions </seealso>
-    /// <seealso cref= ParserATNSimulator#computeTargetState </seealso>
-    /// <seealso cref= LexerATNSimulator#computeTargetState </seealso>
-    long long LL_ATNTransitions = 0;
-
-    /// <summary>
-    /// The total number of DFA transitions required during LL prediction for
-    /// this decision.
-    ///
-    /// <para>If the ATN simulator implementation does not use DFA caching for LL
-    /// transitions, this value will be 0.</para>
-    /// </summary>
-    /// <seealso cref= ParserATNSimulator#getExistingTargetState </seealso>
-    /// <seealso cref= LexerATNSimulator#getExistingTargetState </seealso>
-    long long LL_DFATransitions = 0;
-
-    /// <summary>
-    /// Constructs a new instance of the <seealso cref="DecisionInfo"/> class to contain
-    /// statistics for a particular decision.
-    /// </summary>
-    /// <param name="decision"> The decision number </param>
-    DecisionInfo(size_t decision);
-
-    std::string toString() const;
-  };
-
-} // namespace atn
-} // namespace antlr4

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/DecisionState.cpp

@@ -1,17 +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 "atn/DecisionState.h"
-
-using namespace antlr4::atn;
-
-void DecisionState::InitializeInstanceFields() {
-  decision = -1;
-  nonGreedy = false;
-}
-
-std::string DecisionState::toString() const {
-  return "DECISION " + ATNState::toString();
-}

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/DecisionState.h

@@ -1,30 +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.
- */
-
-#pragma once
-
-#include "atn/ATNState.h"
-
-namespace antlr4 {
-namespace atn {
-
-  class ANTLR4CPP_PUBLIC DecisionState : public ATNState {
-  public:
-    int decision;
-    bool nonGreedy;
-
-  private:
-    void InitializeInstanceFields();
-
-  public:
-    DecisionState() {
-      InitializeInstanceFields();
-    }
-
-    virtual std::string toString() const override;
-  };
-
-} // namespace atn
-} // namespace antlr4

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/EmptyPredictionContext.cpp

@@ -1,35 +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 "atn/EmptyPredictionContext.h"
-
-using namespace antlr4::atn;
-
-EmptyPredictionContext::EmptyPredictionContext() : SingletonPredictionContext(nullptr, EMPTY_RETURN_STATE) {
-}
-
-bool EmptyPredictionContext::isEmpty() const {
-  return true;
-}
-
-size_t EmptyPredictionContext::size() const {
-  return 1;
-}
-
-Ref<PredictionContext> EmptyPredictionContext::getParent(size_t /*index*/) const {
-  return nullptr;
-}
-
-size_t EmptyPredictionContext::getReturnState(size_t /*index*/) const {
-  return returnState;
-}
-
-bool EmptyPredictionContext::operator == (const PredictionContext &o) const {
-  return this == &o;
-}
-
-std::string EmptyPredictionContext::toString() const {
-  return "$";
-}

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/EmptyPredictionContext.h

@@ -1,27 +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.
- */
-
-#pragma once
-
-#include "atn/SingletonPredictionContext.h"
-
-namespace antlr4 {
-namespace atn {
-
-  class ANTLR4CPP_PUBLIC EmptyPredictionContext : public SingletonPredictionContext {
-  public:
-    EmptyPredictionContext();
-
-    virtual bool isEmpty() const override;
-    virtual size_t size() const override;
-    virtual Ref<PredictionContext> getParent(size_t index) const override;
-    virtual size_t getReturnState(size_t index) const override;
-    virtual std::string toString() const override;
-
-    virtual bool operator == (const PredictionContext &o) const override;
-  };
-
-} // namespace atn
-} // namespace antlr4

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/EpsilonTransition.cpp

@@ -1,35 +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 "atn/EpsilonTransition.h"
-
-using namespace antlr4::atn;
-
-EpsilonTransition::EpsilonTransition(ATNState *target) : EpsilonTransition(target, INVALID_INDEX) {
-}
-
-EpsilonTransition::EpsilonTransition(ATNState *target, size_t outermostPrecedenceReturn)
-  : Transition(target), _outermostPrecedenceReturn(outermostPrecedenceReturn) {
-}
-
-size_t EpsilonTransition::outermostPrecedenceReturn() {
-  return _outermostPrecedenceReturn;
-}
-
-Transition::SerializationType EpsilonTransition::getSerializationType() const {
-  return EPSILON;
-}
-
-bool EpsilonTransition::isEpsilon() const {
-  return true;
-}
-
-bool EpsilonTransition::matches(size_t /*symbol*/, size_t /*minVocabSymbol*/, size_t /*maxVocabSymbol*/) const {
-  return false;
-}
-
-std::string EpsilonTransition::toString() const {
-  return "EPSILON " + Transition::toString() + " {}";
-}

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/EpsilonTransition.h

@@ -1,39 +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.
- */
-
-#pragma once
-
-#include "atn/Transition.h"
-
-namespace antlr4 {
-namespace atn {
-
-  class ANTLR4CPP_PUBLIC EpsilonTransition final : public Transition {
-  public:
-    EpsilonTransition(ATNState *target);
-    EpsilonTransition(ATNState *target, size_t outermostPrecedenceReturn);
-
-    /**
-     * @return the rule index of a precedence rule for which this transition is
-     * returning from, where the precedence value is 0; otherwise, INVALID_INDEX.
-     *
-     * @see ATNConfig#isPrecedenceFilterSuppressed()
-     * @see ParserATNSimulator#applyPrecedenceFilter(ATNConfigSet)
-     * @since 4.4.1
-     */
-    size_t outermostPrecedenceReturn();
-    virtual SerializationType getSerializationType() const override;
-
-    virtual bool isEpsilon() const override;
-    virtual bool matches(size_t symbol, size_t minVocabSymbol, size_t maxVocabSymbol) const override;
-
-    virtual std::string toString() const override;
-
-  private:
-    const size_t _outermostPrecedenceReturn; // A rule index.
-  };
-
-} // namespace atn
-} // namespace antlr4

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/ErrorInfo.cpp

@@ -1,15 +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 "atn/ATNConfigSet.h"
-
-#include "atn/ErrorInfo.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-
-ErrorInfo::ErrorInfo(size_t decision, ATNConfigSet *configs, TokenStream *input, size_t startIndex, size_t stopIndex, bool fullCtx)
-  : DecisionEventInfo(decision, configs, input, startIndex, stopIndex, fullCtx) {
-}

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/ErrorInfo.h

@@ -1,43 +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.
- */
-
-#pragma once
-
-#include "atn/DecisionEventInfo.h"
-
-namespace antlr4 {
-namespace atn {
-
-  /// <summary>
-  /// This class represents profiling event information for a syntax error
-  /// identified during prediction. Syntax errors occur when the prediction
-  /// algorithm is unable to identify an alternative which would lead to a
-  /// successful parse.
-  /// </summary>
-  /// <seealso cref= Parser#notifyErrorListeners(Token, String, RecognitionException) </seealso>
-  /// <seealso cref= ANTLRErrorListener#syntaxError
-  ///
-  /// @since 4.3 </seealso>
-  class ANTLR4CPP_PUBLIC ErrorInfo : public DecisionEventInfo {
-  public:
-    /// <summary>
-    /// Constructs a new instance of the <seealso cref="ErrorInfo"/> class with the
-    /// specified detailed syntax error information.
-    /// </summary>
-    /// <param name="decision"> The decision number </param>
-    /// <param name="configs"> The final configuration set reached during prediction
-    /// prior to reaching the <seealso cref="ATNSimulator#ERROR"/> state </param>
-    /// <param name="input"> The input token stream </param>
-    /// <param name="startIndex"> The start index for the current prediction </param>
-    /// <param name="stopIndex"> The index at which the syntax error was identified </param>
-    /// <param name="fullCtx"> {@code true} if the syntax error was identified during LL
-    /// prediction; otherwise, {@code false} if the syntax error was identified
-    /// during SLL prediction </param>
-    ErrorInfo(size_t decision, ATNConfigSet *configs, TokenStream *input, size_t startIndex, size_t stopIndex,
-              bool fullCtx);
-  };
-
-} // namespace atn
-} // namespace antlr4

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/LL1Analyzer.cpp

@@ -1,158 +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 "atn/RuleStopState.h"
-#include "atn/Transition.h"
-#include "atn/RuleTransition.h"
-#include "atn/SingletonPredictionContext.h"
-#include "atn/AbstractPredicateTransition.h"
-#include "atn/WildcardTransition.h"
-#include "atn/NotSetTransition.h"
-#include "misc/IntervalSet.h"
-#include "atn/ATNConfig.h"
-#include "atn/EmptyPredictionContext.h"
-
-#include "support/CPPUtils.h"
-
-#include "atn/LL1Analyzer.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-using namespace antlrcpp;
-
-LL1Analyzer::LL1Analyzer(const ATN &atn) : _atn(atn) {
-}
-
-LL1Analyzer::~LL1Analyzer() {
-}
-
-std::vector<misc::IntervalSet> LL1Analyzer::getDecisionLookahead(ATNState *s) const {
-  std::vector<misc::IntervalSet> look;
-
-  if (s == nullptr) {
-    return look;
-  }
-
-  look.resize(s->transitions.size()); // Fills all interval sets with defaults.
-  for (size_t alt = 0; alt < s->transitions.size(); alt++) {
-    bool seeThruPreds = false; // fail to get lookahead upon pred
-
-    ATNConfig::Set lookBusy;
-    antlrcpp::BitSet callRuleStack;
-    _LOOK(s->transitions[alt]->target, nullptr, PredictionContext::EMPTY,
-          look[alt], lookBusy, callRuleStack, seeThruPreds, false);
-
-    // Wipe out lookahead for this alternative if we found nothing
-    // or we had a predicate when we !seeThruPreds
-    if (look[alt].size() == 0 || look[alt].contains(HIT_PRED)) {
-      look[alt].clear();
-    }
-  }
-  return look;
-}
-
-misc::IntervalSet LL1Analyzer::LOOK(ATNState *s, RuleContext *ctx) const {
-  return LOOK(s, nullptr, ctx);
-}
-
-misc::IntervalSet LL1Analyzer::LOOK(ATNState *s, ATNState *stopState, RuleContext *ctx) const {
-  misc::IntervalSet r;
-  bool seeThruPreds = true; // ignore preds; get all lookahead
-  Ref<PredictionContext> lookContext = ctx != nullptr ? PredictionContext::fromRuleContext(_atn, ctx) : nullptr;
-
-  ATNConfig::Set lookBusy;
-  antlrcpp::BitSet callRuleStack;
-  _LOOK(s, stopState, lookContext, r, lookBusy, callRuleStack, seeThruPreds, true);
-
-  return r;
-}
-
-void LL1Analyzer::_LOOK(ATNState *s, ATNState *stopState, Ref<PredictionContext> const& ctx, misc::IntervalSet &look,
-  ATNConfig::Set &lookBusy, antlrcpp::BitSet &calledRuleStack, bool seeThruPreds, bool addEOF) const {
-
-  Ref<ATNConfig> c = std::make_shared<ATNConfig>(s, 0, ctx);
-
-  if (lookBusy.count(c) > 0) // Keep in mind comparison is based on members of the class, not the actual instance.
-    return;
-
-  lookBusy.insert(c);
-
-  // ml: s can never be null, hence no need to check if stopState is != null.
-  if (s == stopState) {
-    if (ctx == nullptr) {
-      look.add(Token::EPSILON);
-      return;
-    } else if (ctx->isEmpty() && addEOF) {
-      look.add(Token::EOF);
-      return;
-    }
-  }
-
-  if (s->getStateType() == ATNState::RULE_STOP) {
-    if (ctx == nullptr) {
-      look.add(Token::EPSILON);
-      return;
-    } else if (ctx->isEmpty() && addEOF) {
-      look.add(Token::EOF);
-      return;
-    }
-
-    if (ctx != PredictionContext::EMPTY) {
-      // run thru all possible stack tops in ctx
-      for (size_t i = 0; i < ctx->size(); i++) {
-        ATNState *returnState = _atn.states[ctx->getReturnState(i)];
-
-        bool removed = calledRuleStack.test(returnState->ruleIndex);
-        auto onExit = finally([removed, &calledRuleStack, returnState] {
-          if (removed) {
-            calledRuleStack.set(returnState->ruleIndex);
-          }
-        });
-
-        calledRuleStack[returnState->ruleIndex] = false;
-        _LOOK(returnState, stopState, ctx->getParent(i), look, lookBusy, calledRuleStack, seeThruPreds, addEOF);
-      }
-      return;
-    }
-  }
-
-  size_t n = s->transitions.size();
-  for (size_t i = 0; i < n; i++) {
-    Transition *t = s->transitions[i];
-
-    if (t->getSerializationType() == Transition::RULE) {
-      if (calledRuleStack[(static_cast<RuleTransition*>(t))->target->ruleIndex]) {
-        continue;
-      }
-
-      Ref<PredictionContext> newContext = SingletonPredictionContext::create(ctx, (static_cast<RuleTransition*>(t))->followState->stateNumber);
-      auto onExit = finally([t, &calledRuleStack] {
-        calledRuleStack[(static_cast<RuleTransition*>(t))->target->ruleIndex] = false;
-      });
-
-      calledRuleStack.set((static_cast<RuleTransition*>(t))->target->ruleIndex);
-      _LOOK(t->target, stopState, newContext, look, lookBusy, calledRuleStack, seeThruPreds, addEOF);
-
-    } else if (is<AbstractPredicateTransition *>(t)) {
-      if (seeThruPreds) {
-        _LOOK(t->target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF);
-      } else {
-        look.add(HIT_PRED);
-      }
-    } else if (t->isEpsilon()) {
-      _LOOK(t->target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF);
-    } else if (t->getSerializationType() == Transition::WILDCARD) {
-      look.addAll(misc::IntervalSet::of(Token::MIN_USER_TOKEN_TYPE, static_cast<ssize_t>(_atn.maxTokenType)));
-    } else {
-      misc::IntervalSet set = t->label();
-      if (!set.isEmpty()) {
-        if (is<NotSetTransition*>(t)) {
-          set = set.complement(misc::IntervalSet::of(Token::MIN_USER_TOKEN_TYPE, static_cast<ssize_t>(_atn.maxTokenType)));
-        }
-        look.addAll(set);
-      }
-    }
-  }
-}