expressir 1.2.3 → 1.2.6

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

@@ -13,13 +13,16 @@ namespace atn {
   /// TODO: make all transitions sets? no, should remove set edges.
   class ANTLR4CPP_PUBLIC AtomTransition final : public Transition {
   public:
+    static bool is(const Transition &transition) { return transition.getTransitionType() == TransitionType::ATOM; }
+
+    static bool is(const Transition *transition) { return transition != nullptr && is(*transition); }
+
     /// The token type or character value; or, signifies special label.
+    /// TODO: rename this to label
     const size_t _label;
 
     AtomTransition(ATNState *target, size_t label);
 
-    virtual SerializationType getSerializationType() const override;
-
     virtual misc::IntervalSet label() const override;
     virtual bool matches(size_t symbol, size_t minVocabSymbol, size_t maxVocabSymbol) const override;
 

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

@@ -12,10 +12,12 @@ namespace antlr4 {
 namespace atn {
 
   class ANTLR4CPP_PUBLIC BasicBlockStartState final : public BlockStartState {
-
   public:
-    virtual size_t getStateType() override;
+    static bool is(const ATNState &atnState) { return atnState.getStateType() == ATNStateType::BLOCK_START; }
+
+    static bool is(const ATNState *atnState) { return atnState != nullptr && is(*atnState); }
 
+    BasicBlockStartState() : BlockStartState(ATNStateType::BLOCK_START) {}
   };
 
 } // namespace atn

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

@@ -11,10 +11,12 @@ namespace antlr4 {
 namespace atn {
 
   class ANTLR4CPP_PUBLIC BasicState final : public ATNState {
-
   public:
-    virtual size_t getStateType() override;
+    static bool is(const ATNState &atnState) { return atnState.getStateType() == ATNStateType::BASIC; }
+
+    static bool is(const ATNState *atnState) { return atnState != nullptr && is(*atnState); }
 
+    BasicState() : ATNState(ATNStateType::BASIC) {}
   };
 
 } // namespace atn

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

@@ -13,11 +13,13 @@ namespace atn {
   /// Terminal node of a simple {@code (a|b|c)} block.
   class ANTLR4CPP_PUBLIC BlockEndState final : public ATNState {
   public:
-    BlockStartState *startState = nullptr;
+    static bool is(const ATNState &atnState) { return atnState.getStateType() == ATNStateType::BLOCK_END; }
+
+    static bool is(const ATNState *atnState) { return atnState != nullptr && is(*atnState); }
 
-    BlockEndState();
+    BlockStartState *startState = nullptr;
 
-    virtual size_t getStateType() override;
+    BlockEndState() : ATNState(ATNStateType::BLOCK_END) {}
   };
 
 } // namespace atn

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

@@ -13,8 +13,17 @@ namespace atn {
   ///  The start of a regular {@code (...)} block.
   class ANTLR4CPP_PUBLIC BlockStartState : public DecisionState {
   public:
-    ~BlockStartState();
+    static bool is(const ATNState &atnState) {
+      const auto stateType = atnState.getStateType();
+      return stateType >= ATNStateType::BLOCK_START && stateType <= ATNStateType::STAR_BLOCK_START;
+    }
+
+    static bool is(const ATNState *atnState) { return atnState != nullptr && is(*atnState); }
+
     BlockEndState *endState = nullptr;
+
+  protected:
+    using DecisionState::DecisionState;
   };
 
 } // namespace atn

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

@@ -218,7 +218,7 @@ namespace atn {
     /// statistics for a particular decision.
     /// </summary>
     /// <param name="decision"> The decision number </param>
-    DecisionInfo(size_t decision);
+    explicit DecisionInfo(size_t decision);
 
     std::string toString() const;
   };

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

@@ -7,11 +7,6 @@
 
 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

@@ -12,18 +12,22 @@ namespace atn {
 
   class ANTLR4CPP_PUBLIC DecisionState : public ATNState {
   public:
-    int decision;
-    bool nonGreedy;
+    static bool is(const ATNState &atnState) {
+      const auto stateType = atnState.getStateType();
+      return (stateType >= ATNStateType::BLOCK_START && stateType <= ATNStateType::TOKEN_START) ||
+              stateType == ATNStateType::PLUS_LOOP_BACK ||
+              stateType == ATNStateType::STAR_LOOP_ENTRY;
+    }
 
-  private:
-    void InitializeInstanceFields();
+    static bool is(const ATNState *atnState) { return atnState != nullptr && is(*atnState); }
 
-  public:
-    DecisionState() {
-      InitializeInstanceFields();
-    }
+    int decision = -1;
+    bool nonGreedy = false;
 
     virtual std::string toString() const override;
+
+  protected:
+    using ATNState::ATNState;
   };
 
 } // namespace atn

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

@@ -11,17 +11,13 @@ EpsilonTransition::EpsilonTransition(ATNState *target) : EpsilonTransition(targe
 }
 
 EpsilonTransition::EpsilonTransition(ATNState *target, size_t outermostPrecedenceReturn)
-  : Transition(target), _outermostPrecedenceReturn(outermostPrecedenceReturn) {
+  : Transition(TransitionType::EPSILON, target), _outermostPrecedenceReturn(outermostPrecedenceReturn) {
 }
 
-size_t EpsilonTransition::outermostPrecedenceReturn() {
+size_t EpsilonTransition::outermostPrecedenceReturn() const {
   return _outermostPrecedenceReturn;
 }
 
-Transition::SerializationType EpsilonTransition::getSerializationType() const {
-  return EPSILON;
-}
-
 bool EpsilonTransition::isEpsilon() const {
   return true;
 }

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

@@ -12,7 +12,11 @@ namespace atn {
 
   class ANTLR4CPP_PUBLIC EpsilonTransition final : public Transition {
   public:
-    EpsilonTransition(ATNState *target);
+    static bool is(const Transition &transition) { return transition.getTransitionType() == TransitionType::EPSILON; }
+
+    static bool is(const Transition *transition) { return transition != nullptr && is(*transition); }
+
+    explicit EpsilonTransition(ATNState *target);
     EpsilonTransition(ATNState *target, size_t outermostPrecedenceReturn);
 
     /**
@@ -23,8 +27,7 @@ namespace atn {
      * @see ParserATNSimulator#applyPrecedenceFilter(ATNConfigSet)
      * @since 4.4.1
      */
-    size_t outermostPrecedenceReturn();
-    virtual SerializationType getSerializationType() const override;
+    size_t outermostPrecedenceReturn() const;
 
     virtual bool isEpsilon() const override;
     virtual bool matches(size_t symbol, size_t minVocabSymbol, size_t maxVocabSymbol) const override;

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

@@ -7,12 +7,10 @@
 #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"
 
@@ -22,10 +20,140 @@ using namespace antlr4;
 using namespace antlr4::atn;
 using namespace antlrcpp;
 
-LL1Analyzer::LL1Analyzer(const ATN &atn) : _atn(atn) {
-}
+namespace {
+
+  struct ATNConfigHasher final {
+    size_t operator()(const ATNConfig& atn_config) const {
+      return atn_config.hashCode();
+    }
+  };
+
+  struct ATNConfigComparer final {
+    bool operator()(const ATNConfig& lhs, const ATNConfig& rhs) const {
+      return lhs == rhs;
+    }
+  };
+
+  class LL1AnalyzerImpl final {
+  public:
+    LL1AnalyzerImpl(const ATN& atn, misc::IntervalSet& look, bool seeThruPreds, bool addEOF) : _atn(atn), _look(look), _seeThruPreds(seeThruPreds), _addEOF(addEOF) {}
+
+    /// <summary>
+    /// Compute set of tokens that can follow {@code s} in the ATN in the
+    /// specified {@code ctx}.
+    /// <p/>
+    /// If {@code ctx} is {@code null} and {@code stopState} or the end of the
+    /// rule containing {@code s} is reached, <seealso cref="Token#EPSILON"/> is added to
+    /// the result set. If {@code ctx} is not {@code null} and {@code addEOF} is
+    /// {@code true} and {@code stopState} or the end of the outermost rule is
+    /// reached, <seealso cref="Token#EOF"/> is added to the result set.
+    /// </summary>
+    /// <param name="s"> the ATN state. </param>
+    /// <param name="stopState"> the ATN state to stop at. This can be a
+    /// <seealso cref="BlockEndState"/> to detect epsilon paths through a closure. </param>
+    /// <param name="ctx"> The outer context, or {@code null} if the outer context should
+    /// not be used. </param>
+    /// <param name="look"> The result lookahead set. </param>
+    /// <param name="lookBusy"> A set used for preventing epsilon closures in the ATN
+    /// from causing a stack overflow. Outside code should pass
+    /// {@code new HashSet<ATNConfig>} for this argument. </param>
+    /// <param name="calledRuleStack"> A set used for preventing left recursion in the
+    /// ATN from causing a stack overflow. Outside code should pass
+    /// {@code new BitSet()} for this argument. </param>
+    /// <param name="seeThruPreds"> {@code true} to true semantic predicates as
+    /// implicitly {@code true} and "see through them", otherwise {@code false}
+    /// to treat semantic predicates as opaque and add <seealso cref="#HIT_PRED"/> to the
+    /// result if one is encountered. </param>
+    /// <param name="addEOF"> Add <seealso cref="Token#EOF"/> to the result if the end of the
+    /// outermost context is reached. This parameter has no effect if {@code ctx}
+    /// is {@code null}. </param>
+    void LOOK(ATNState *s, ATNState *stopState, Ref<const PredictionContext> const& ctx) {
+      if (!_lookBusy.insert(ATNConfig(s, 0, ctx)).second) {
+        return;
+      }
+
+      // 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() == ATNStateType::RULE_STOP) {
+        if (ctx == nullptr) {
+          _look.add(Token::EPSILON);
+          return;
+        } else if (ctx->isEmpty() && _addEOF) {
+          _look.add(Token::EOF);
+          return;
+        }
+
+        if (ctx != PredictionContext::EMPTY) {
+          bool removed = _calledRuleStack.test(s->ruleIndex);
+          _calledRuleStack[s->ruleIndex] = false;
+          // run thru all possible stack tops in ctx
+          for (size_t i = 0; i < ctx->size(); i++) {
+            ATNState *returnState = _atn.states[ctx->getReturnState(i)];
+            LOOK(returnState, stopState, ctx->getParent(i));
+          }
+          if (removed) {
+            _calledRuleStack.set(s->ruleIndex);
+          }
+          return;
+        }
+      }
+
+      size_t n = s->transitions.size();
+      for (size_t i = 0; i < n; i++) {
+        const Transition *t = s->transitions[i].get();
+        const auto tType = t->getTransitionType();
+
+        if (tType == TransitionType::RULE) {
+          if (_calledRuleStack[(static_cast<const RuleTransition*>(t))->target->ruleIndex]) {
+            continue;
+          }
+
+          Ref<const PredictionContext> newContext = SingletonPredictionContext::create(ctx, (static_cast<const RuleTransition*>(t))->followState->stateNumber);
+
+          _calledRuleStack.set((static_cast<const RuleTransition*>(t))->target->ruleIndex);
+          LOOK(t->target, stopState, newContext);
+          _calledRuleStack[(static_cast<const RuleTransition*>(t))->target->ruleIndex] = false;
+
+        } else if (tType == TransitionType::PREDICATE || tType == TransitionType::PRECEDENCE) {
+          if (_seeThruPreds) {
+            LOOK(t->target, stopState, ctx);
+          } else {
+            _look.add(LL1Analyzer::HIT_PRED);
+          }
+        } else if (t->isEpsilon()) {
+          LOOK(t->target, stopState, ctx);
+        } else if (tType == TransitionType::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 (tType == TransitionType::NOT_SET) {
+              set = set.complement(misc::IntervalSet::of(Token::MIN_USER_TOKEN_TYPE, static_cast<ssize_t>(_atn.maxTokenType)));
+            }
+            _look.addAll(set);
+          }
+        }
+      }
+    }
+
+  private:
+    const ATN& _atn;
+    misc::IntervalSet& _look;
+    antlrcpp::BitSet _calledRuleStack;
+    std::unordered_set<ATNConfig, ATNConfigHasher, ATNConfigComparer> _lookBusy;
+    bool _seeThruPreds;
+    bool _addEOF;
+  };
 
-LL1Analyzer::~LL1Analyzer() {
 }
 
 std::vector<misc::IntervalSet> LL1Analyzer::getDecisionLookahead(ATNState *s) const {
@@ -37,16 +165,11 @@ std::vector<misc::IntervalSet> LL1Analyzer::getDecisionLookahead(ATNState *s) co
 
   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);
-
+    LL1AnalyzerImpl impl(_atn, look[alt], false, false);
+    impl.LOOK(s->transitions[alt]->target, nullptr, PredictionContext::EMPTY);
     // 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)) {
+    if (look[alt].size() == 0 || look[alt].contains(LL1Analyzer::HIT_PRED)) {
       look[alt].clear();
     }
   }
@@ -58,101 +181,9 @@ misc::IntervalSet LL1Analyzer::LOOK(ATNState *s, RuleContext *ctx) const {
 }
 
 misc::IntervalSet LL1Analyzer::LOOK(ATNState *s, ATNState *stopState, RuleContext *ctx) const {
+  Ref<const PredictionContext> lookContext = ctx != nullptr ? PredictionContext::fromRuleContext(_atn, ctx) : nullptr;
   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);
-
+  LL1AnalyzerImpl impl(_atn, r, true, true);
+  impl.LOOK(s, stopState, lookContext);
   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);
-      }
-    }
-  }
-}

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

@@ -6,23 +6,20 @@
 #pragma once
 
 #include "Token.h"
-#include "support/BitSet.h"
-#include "atn/PredictionContext.h"
 #include "atn/ATNConfig.h"
+#include "atn/PredictionContext.h"
+#include "support/BitSet.h"
 
 namespace antlr4 {
 namespace atn {
 
-  class ANTLR4CPP_PUBLIC LL1Analyzer {
+  class ANTLR4CPP_PUBLIC LL1Analyzer final {
   public:
     /// Special value added to the lookahead sets to indicate that we hit
     ///  a predicate during analysis if {@code seeThruPreds==false}.
-    static const size_t HIT_PRED = Token::INVALID_TYPE;
+    static constexpr size_t HIT_PRED = Token::INVALID_TYPE;
 
-    const atn::ATN &_atn;
-
-    LL1Analyzer(const atn::ATN &atn);
-    virtual ~LL1Analyzer();
+    explicit LL1Analyzer(const atn::ATN &atn) : _atn(atn) {}
 
     /// <summary>
     /// Calculates the SLL(1) expected lookahead set for each outgoing transition
@@ -33,7 +30,7 @@ namespace atn {
     /// </summary>
     /// <param name="s"> the ATN state </param>
     /// <returns> the expected symbols for each outgoing transition of {@code s}. </returns>
-    virtual std::vector<misc::IntervalSet> getDecisionLookahead(ATNState *s) const;
+    std::vector<misc::IntervalSet> getDecisionLookahead(ATNState *s) const;
 
     /// <summary>
     /// Compute set of tokens that can follow {@code s} in the ATN in the
@@ -50,7 +47,7 @@ namespace atn {
     /// </param>
     /// <returns> The set of tokens that can follow {@code s} in the ATN in the
     /// specified {@code ctx}. </returns>
-    virtual misc::IntervalSet LOOK(ATNState *s, RuleContext *ctx) const;
+    misc::IntervalSet LOOK(ATNState *s, RuleContext *ctx) const;
 
     /// <summary>
     /// Compute set of tokens that can follow {@code s} in the ATN in the
@@ -69,40 +66,10 @@ namespace atn {
     /// </param>
     /// <returns> The set of tokens that can follow {@code s} in the ATN in the
     /// specified {@code ctx}. </returns>
-    virtual misc::IntervalSet LOOK(ATNState *s, ATNState *stopState, RuleContext *ctx) const;
+    misc::IntervalSet LOOK(ATNState *s, ATNState *stopState, RuleContext *ctx) const;
 
-    /// <summary>
-    /// Compute set of tokens that can follow {@code s} in the ATN in the
-    /// specified {@code ctx}.
-    /// <p/>
-    /// If {@code ctx} is {@code null} and {@code stopState} or the end of the
-    /// rule containing {@code s} is reached, <seealso cref="Token#EPSILON"/> is added to
-    /// the result set. If {@code ctx} is not {@code null} and {@code addEOF} is
-    /// {@code true} and {@code stopState} or the end of the outermost rule is
-    /// reached, <seealso cref="Token#EOF"/> is added to the result set.
-    /// </summary>
-    /// <param name="s"> the ATN state. </param>
-    /// <param name="stopState"> the ATN state to stop at. This can be a
-    /// <seealso cref="BlockEndState"/> to detect epsilon paths through a closure. </param>
-    /// <param name="ctx"> The outer context, or {@code null} if the outer context should
-    /// not be used. </param>
-    /// <param name="look"> The result lookahead set. </param>
-    /// <param name="lookBusy"> A set used for preventing epsilon closures in the ATN
-    /// from causing a stack overflow. Outside code should pass
-    /// {@code new HashSet<ATNConfig>} for this argument. </param>
-    /// <param name="calledRuleStack"> A set used for preventing left recursion in the
-    /// ATN from causing a stack overflow. Outside code should pass
-    /// {@code new BitSet()} for this argument. </param>
-    /// <param name="seeThruPreds"> {@code true} to true semantic predicates as
-    /// implicitly {@code true} and "see through them", otherwise {@code false}
-    /// to treat semantic predicates as opaque and add <seealso cref="#HIT_PRED"/> to the
-    /// result if one is encountered. </param>
-    /// <param name="addEOF"> Add <seealso cref="Token#EOF"/> to the result if the end of the
-    /// outermost context is reached. This parameter has no effect if {@code ctx}
-    /// is {@code null}. </param>
-  protected:
-    virtual void _LOOK(ATNState *s, ATNState *stopState, Ref<PredictionContext> const& ctx, misc::IntervalSet &look,
-      ATNConfig::Set &lookBusy, antlrcpp::BitSet &calledRuleStack, bool seeThruPreds, bool addEOF) const;
+  private:
+    const atn::ATN &_atn;
   };
 
 } // namespace atn

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

@@ -10,44 +10,27 @@
 #include "atn/LexerActionExecutor.h"
 
 #include "support/CPPUtils.h"
+#include "support/Casts.h"
 
 #include "atn/LexerATNConfig.h"
 
 using namespace antlr4::atn;
 using namespace antlrcpp;
 
-LexerATNConfig::LexerATNConfig(ATNState *state, int alt, Ref<PredictionContext> const& context)
-  : ATNConfig(state, alt, context, SemanticContext::NONE), _passedThroughNonGreedyDecision(false) {
-}
+LexerATNConfig::LexerATNConfig(ATNState *state, int alt, Ref<const PredictionContext> context)
+    : ATNConfig(state, alt, std::move(context)) {}
 
-LexerATNConfig::LexerATNConfig(ATNState *state, int alt, Ref<PredictionContext> const& context,
-                               Ref<LexerActionExecutor> const& lexerActionExecutor)
-  : ATNConfig(state, alt, context, SemanticContext::NONE), _lexerActionExecutor(lexerActionExecutor),
-    _passedThroughNonGreedyDecision(false) {
-}
+LexerATNConfig::LexerATNConfig(ATNState *state, int alt, Ref<const PredictionContext> context, Ref<const LexerActionExecutor> lexerActionExecutor)
+    : ATNConfig(state, alt, std::move(context)), _lexerActionExecutor(std::move(lexerActionExecutor)) {}
 
-LexerATNConfig::LexerATNConfig(Ref<LexerATNConfig> const& c, ATNState *state)
-  : ATNConfig(c, state, c->context, c->semanticContext), _lexerActionExecutor(c->_lexerActionExecutor),
-   _passedThroughNonGreedyDecision(checkNonGreedyDecision(c, state)) {
-}
+LexerATNConfig::LexerATNConfig(LexerATNConfig const& other, ATNState *state)
+    : ATNConfig(other, state), _lexerActionExecutor(other._lexerActionExecutor), _passedThroughNonGreedyDecision(checkNonGreedyDecision(other, state)) {}
 
-LexerATNConfig::LexerATNConfig(Ref<LexerATNConfig> const& c, ATNState *state, Ref<LexerActionExecutor> const& lexerActionExecutor)
-  : ATNConfig(c, state, c->context, c->semanticContext), _lexerActionExecutor(lexerActionExecutor),
-    _passedThroughNonGreedyDecision(checkNonGreedyDecision(c, state)) {
-}
+LexerATNConfig::LexerATNConfig(LexerATNConfig const& other, ATNState *state, Ref<const LexerActionExecutor> lexerActionExecutor)
+    : ATNConfig(other, state), _lexerActionExecutor(std::move(lexerActionExecutor)), _passedThroughNonGreedyDecision(checkNonGreedyDecision(other, state)) {}
 
-LexerATNConfig::LexerATNConfig(Ref<LexerATNConfig> const& c, ATNState *state, Ref<PredictionContext> const& context)
-  : ATNConfig(c, state, context, c->semanticContext), _lexerActionExecutor(c->_lexerActionExecutor),
-    _passedThroughNonGreedyDecision(checkNonGreedyDecision(c, state)) {
-}
-
-Ref<LexerActionExecutor> LexerATNConfig::getLexerActionExecutor() const {
-  return _lexerActionExecutor;
-}
-
-bool LexerATNConfig::hasPassedThroughNonGreedyDecision() {
-  return _passedThroughNonGreedyDecision;
-}
+LexerATNConfig::LexerATNConfig(LexerATNConfig const& other, ATNState *state, Ref<const PredictionContext> context)
+    : ATNConfig(other, state, std::move(context)), _lexerActionExecutor(other._lexerActionExecutor), _passedThroughNonGreedyDecision(checkNonGreedyDecision(other, state)) {}
 
 size_t LexerATNConfig::hashCode() const {
   size_t hashCode = misc::MurmurHash::initialize(7);
@@ -61,7 +44,7 @@ size_t LexerATNConfig::hashCode() const {
   return hashCode;
 }
 
-bool LexerATNConfig::operator == (const LexerATNConfig& other) const
+bool LexerATNConfig::operator==(const LexerATNConfig& other) const
 {
   if (this == &other)
     return true;
@@ -75,10 +58,10 @@ bool LexerATNConfig::operator == (const LexerATNConfig& other) const
     return false;
   }
 
-  return ATNConfig::operator == (other);
+  return ATNConfig::operator==(other);
 }
 
-bool LexerATNConfig::checkNonGreedyDecision(Ref<LexerATNConfig> const& source, ATNState *target) {
-  return source->_passedThroughNonGreedyDecision ||
-    (is<DecisionState*>(target) && (static_cast<DecisionState*>(target))->nonGreedy);
+bool LexerATNConfig::checkNonGreedyDecision(LexerATNConfig const& source, ATNState *target) {
+  return source._passedThroughNonGreedyDecision ||
+    (DecisionState::is(target) && downCast<DecisionState*>(target)->nonGreedy);
 }