expressir 1.4.3 → 2.1.0

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

@@ -1,34 +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:
-    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;
-    }
-
-    static bool is(const ATNState *atnState) { return atnState != nullptr && is(*atnState); }
-
-    int decision = -1;
-    bool nonGreedy = false;
-
-    virtual std::string toString() const override;
-
-  protected:
-    using ATNState::ATNState;
-  };
-
-} // namespace atn
-} // namespace antlr4

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

@@ -1,31 +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(TransitionType::EPSILON, target), _outermostPrecedenceReturn(outermostPrecedenceReturn) {
-}
-
-size_t EpsilonTransition::outermostPrecedenceReturn() const {
-  return _outermostPrecedenceReturn;
-}
-
-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,42 +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:
-    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);
-
-    /**
-     * @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() const;
-
-    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/HashUtils.h

@@ -1,18 +0,0 @@
-/* Copyright (c) 2022 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 <cstddef>
-
-namespace antlr4 {
-namespace atn {
-
-  inline bool cachedHashCodeEqual(size_t lhs, size_t rhs) {
-    return lhs == rhs || lhs == 0 || rhs == 0;
-  }
-
-} // namespace atn
-} // namespace antlr4

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

@@ -1,189 +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/WildcardTransition.h"
-#include "atn/NotSetTransition.h"
-#include "misc/IntervalSet.h"
-#include "atn/ATNConfig.h"
-
-#include "support/CPPUtils.h"
-
-#include "atn/LL1Analyzer.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-using namespace antlrcpp;
-
-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;
-  };
-
-}
-
-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++) {
-    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(LL1Analyzer::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 {
-  Ref<const PredictionContext> lookContext = ctx != nullptr ? PredictionContext::fromRuleContext(_atn, ctx) : nullptr;
-  misc::IntervalSet r;
-  LL1AnalyzerImpl impl(_atn, r, true, true);
-  impl.LOOK(s, stopState, lookContext);
-  return r;
-}

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

@@ -1,76 +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 "Token.h"
-#include "atn/ATNConfig.h"
-#include "atn/PredictionContext.h"
-#include "support/BitSet.h"
-
-namespace antlr4 {
-namespace atn {
-
-  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 constexpr size_t HIT_PRED = Token::INVALID_TYPE;
-
-    explicit LL1Analyzer(const atn::ATN &atn) : _atn(atn) {}
-
-    /// <summary>
-    /// Calculates the SLL(1) expected lookahead set for each outgoing transition
-    /// of an <seealso cref="ATNState"/>. The returned array has one element for each
-    /// outgoing transition in {@code s}. If the closure from transition
-    /// <em>i</em> leads to a semantic predicate before matching a symbol, the
-    /// element at index <em>i</em> of the result will be {@code null}.
-    /// </summary>
-    /// <param name="s"> the ATN state </param>
-    /// <returns> the expected symbols for each outgoing transition of {@code s}. </returns>
-    std::vector<misc::IntervalSet> getDecisionLookahead(ATNState *s) 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 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 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="ctx"> the complete parser context, or {@code null} if the context
-    /// should be ignored
-    /// </param>
-    /// <returns> The set of tokens that can follow {@code s} in the ATN in the
-    /// specified {@code ctx}. </returns>
-    misc::IntervalSet LOOK(ATNState *s, 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 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 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 complete parser context, or {@code null} if the context
-    /// should be ignored
-    /// </param>
-    /// <returns> The set of tokens that can follow {@code s} in the ATN in the
-    /// specified {@code ctx}. </returns>
-    misc::IntervalSet LOOK(ATNState *s, ATNState *stopState, RuleContext *ctx) const;
-
-  private:
-    const atn::ATN &_atn;
-  };
-
-} // namespace atn
-} // namespace antlr4

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

@@ -1,67 +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 "misc/MurmurHash.h"
-#include "atn/DecisionState.h"
-#include "atn/PredictionContext.h"
-#include "SemanticContext.h"
-#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<const PredictionContext> context)
-    : ATNConfig(state, alt, std::move(context)) {}
-
-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(LexerATNConfig const& other, ATNState *state)
-    : ATNConfig(other, state), _lexerActionExecutor(other._lexerActionExecutor), _passedThroughNonGreedyDecision(checkNonGreedyDecision(other, 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(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);
-  hashCode = misc::MurmurHash::update(hashCode, state->stateNumber);
-  hashCode = misc::MurmurHash::update(hashCode, alt);
-  hashCode = misc::MurmurHash::update(hashCode, context);
-  hashCode = misc::MurmurHash::update(hashCode, semanticContext);
-  hashCode = misc::MurmurHash::update(hashCode, _passedThroughNonGreedyDecision ? 1 : 0);
-  hashCode = misc::MurmurHash::update(hashCode, _lexerActionExecutor);
-  hashCode = misc::MurmurHash::finish(hashCode, 6);
-  return hashCode;
-}
-
-bool LexerATNConfig::operator==(const LexerATNConfig& other) const
-{
-  if (this == &other)
-    return true;
-
-  if (_passedThroughNonGreedyDecision != other._passedThroughNonGreedyDecision)
-    return false;
-
-  if (_lexerActionExecutor == nullptr)
-    return other._lexerActionExecutor == nullptr;
-  if (*_lexerActionExecutor != *(other._lexerActionExecutor)) {
-    return false;
-  }
-
-  return ATNConfig::operator==(other);
-}
-
-bool LexerATNConfig::checkNonGreedyDecision(LexerATNConfig const& source, ATNState *target) {
-  return source._passedThroughNonGreedyDecision ||
-    (DecisionState::is(target) && downCast<DecisionState*>(target)->nonGreedy);
-}

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/LexerATNConfig.h

@@ -1,44 +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/ATNConfig.h"
-
-namespace antlr4 {
-namespace atn {
-
-  class ANTLR4CPP_PUBLIC LexerATNConfig final : public ATNConfig {
-  public:
-    LexerATNConfig(ATNState *state, int alt, Ref<const PredictionContext> context);
-    LexerATNConfig(ATNState *state, int alt, Ref<const PredictionContext> context, Ref<const LexerActionExecutor> lexerActionExecutor);
-
-    LexerATNConfig(LexerATNConfig const& other, ATNState *state);
-    LexerATNConfig(LexerATNConfig const& other, ATNState *state, Ref<const LexerActionExecutor> lexerActionExecutor);
-    LexerATNConfig(LexerATNConfig const& other, ATNState *state, Ref<const PredictionContext> context);
-
-    /**
-     * Gets the {@link LexerActionExecutor} capable of executing the embedded
-     * action(s) for the current configuration.
-     */
-    const Ref<const LexerActionExecutor>& getLexerActionExecutor() const { return _lexerActionExecutor; }
-    bool hasPassedThroughNonGreedyDecision() const { return _passedThroughNonGreedyDecision; }
-
-    virtual size_t hashCode() const override;
-
-    bool operator==(const LexerATNConfig& other) const;
-
-  private:
-    /**
-     * This is the backing field for {@link #getLexerActionExecutor}.
-     */
-    const Ref<const LexerActionExecutor> _lexerActionExecutor;
-    const bool _passedThroughNonGreedyDecision = false;
-
-    static bool checkNonGreedyDecision(LexerATNConfig const& source, ATNState *target);
-  };
-
-} // namespace atn
-} // namespace antlr4