expressir 1.2.4 → 1.2.5

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

@@ -6,39 +6,34 @@
 #pragma once
 
 #include <algorithm>
-#include <assert.h>
+#include <any>
 #include <atomic>
-#include <chrono>
+#include <bitset>
+#include <cassert>
+#include <climits>
+#include <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <exception>
 #include <fstream>
 #include <iostream>
 #include <iterator>
 #include <limits>
-#include <limits.h>
-#include <list>
 #include <map>
 #include <memory>
+#include <mutex>
 #include <set>
-#include <stdarg.h>
-#include <stdint.h>
-#include <stdlib.h>
+#include <shared_mutex>
 #include <sstream>
 #include <stack>
 #include <string>
+#include <string_view>
 #include <typeinfo>
 #include <type_traits>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
 #include <vector>
-#include <mutex>
-#include <exception>
-#include <bitset>
-#include <condition_variable>
-#include <functional>
-
-#ifndef USE_UTF8_INSTEAD_OF_CODECVT
-  #include <codecvt>
-#endif
 
 // Defines for the Guid class and other platform dependent stuff.
 #ifdef _WIN32
@@ -52,25 +47,12 @@
     #endif
   #endif
 
-  #define GUID_WINDOWS
-
   #ifdef _WIN64
     typedef __int64 ssize_t;
   #else
     typedef __int32 ssize_t;
   #endif
 
-  #if _MSC_VER >= 1900 && _MSC_VER < 2000
-    // VS 2015 has a known bug when using std::codecvt_utf8<char32_t>
-    // so we have to temporarily use __int32 instead.
-    // https://connect.microsoft.com/VisualStudio/feedback/details/1403302/unresolved-external-when-using-codecvt-utf8
-    typedef std::basic_string<__int32> i32string;
-
-    typedef i32string UTF32String;
-  #else
-    typedef std::u32string UTF32String;
-  #endif
-
   #ifdef ANTLR4CPP_EXPORTS
     #define ANTLR4CPP_PUBLIC __declspec(dllexport)
   #else
@@ -81,26 +63,13 @@
     #endif
   #endif
 
-  #if defined(_MSC_VER) && !defined(__clang__)
-    // clang-cl should escape this to prevent [ignored-attributes].
-    namespace std {
-      class ANTLR4CPP_PUBLIC exception; // Prevents warning C4275 from MSVC.
-    } // namespace std
-  #endif
-
 #elif defined(__APPLE__)
-  typedef std::u32string UTF32String;
-
-  #define GUID_CFUUID
   #if __GNUC__ >= 4
     #define ANTLR4CPP_PUBLIC __attribute__ ((visibility ("default")))
   #else
     #define ANTLR4CPP_PUBLIC
   #endif
 #else
-  typedef std::u32string UTF32String;
-
-  #define GUID_LIBUUID
   #if __GNUC__ >= 6
     #define ANTLR4CPP_PUBLIC __attribute__ ((visibility ("default")))
   #else
@@ -108,27 +77,16 @@
   #endif
 #endif
 
-#include "support/guid.h"
-#include "support/Declarations.h"
+#ifdef __has_builtin
+#define ANTLR4CPP_HAVE_BUILTIN(x) __has_builtin(x)
+#else
+#define ANTLR4CPP_HAVE_BUILTIN(x) 0
+#endif
 
-#if !defined(HAS_NOEXCEPT)
-  #if defined(__clang__)
-    #if __has_feature(cxx_noexcept)
-      #define HAS_NOEXCEPT
-    #endif
-  #else
-    #if defined(__GXX_EXPERIMENTAL_CXX0X__) && __GNUC__ * 10 + __GNUC_MINOR__ >= 46 || \
-      defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023026
-      #define HAS_NOEXCEPT
-    #endif
-  #endif
+#define ANTLR4CPP_INTERNAL_STRINGIFY(x) #x
+#define ANTLR4CPP_STRINGIFY(x) ANTLR4CPP_INTERNAL_STRINGIFY(x)
 
-  #ifdef HAS_NOEXCEPT
-    #define NOEXCEPT noexcept
-  #else
-    #define NOEXCEPT
-  #endif
-#endif
+#include "support/Declarations.h"
 
 // We have to undefine this symbol as ANTLR will use this name for own members and even
 // generated functions. Because EOF is a global macro we cannot use e.g. a namespace scope to disambiguate.

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

@@ -49,6 +49,7 @@
 #include "TokenStreamRewriter.h"
 #include "UnbufferedCharStream.h"
 #include "UnbufferedTokenStream.h"
+#include "Version.h"
 #include "Vocabulary.h"
 #include "Vocabulary.h"
 #include "WritableToken.h"
@@ -57,11 +58,9 @@
 #include "atn/ATNConfigSet.h"
 #include "atn/ATNDeserializationOptions.h"
 #include "atn/ATNDeserializer.h"
-#include "atn/ATNSerializer.h"
 #include "atn/ATNSimulator.h"
 #include "atn/ATNState.h"
 #include "atn/ATNType.h"
-#include "atn/AbstractPredicateTransition.h"
 #include "atn/ActionTransition.h"
 #include "atn/AmbiguityInfo.h"
 #include "atn/ArrayPredictionContext.h"
@@ -74,7 +73,6 @@
 #include "atn/DecisionEventInfo.h"
 #include "atn/DecisionInfo.h"
 #include "atn/DecisionState.h"
-#include "atn/EmptyPredictionContext.h"
 #include "atn/EpsilonTransition.h"
 #include "atn/ErrorInfo.h"
 #include "atn/LL1Analyzer.h"
@@ -98,12 +96,16 @@
 #include "atn/OrderedATNConfigSet.h"
 #include "atn/ParseInfo.h"
 #include "atn/ParserATNSimulator.h"
+#include "atn/ParserATNSimulatorOptions.h"
 #include "atn/PlusBlockStartState.h"
 #include "atn/PlusLoopbackState.h"
 #include "atn/PrecedencePredicateTransition.h"
 #include "atn/PredicateEvalInfo.h"
 #include "atn/PredicateTransition.h"
 #include "atn/PredictionContext.h"
+#include "atn/PredictionContextCache.h"
+#include "atn/PredictionContextMergeCache.h"
+#include "atn/PredictionContextMergeCacheOptions.h"
 #include "atn/PredictionMode.h"
 #include "atn/ProfilingATNSimulator.h"
 #include "atn/RangeTransition.h"
@@ -111,6 +113,7 @@
 #include "atn/RuleStopState.h"
 #include "atn/RuleTransition.h"
 #include "atn/SemanticContext.h"
+#include "atn/SerializedATNView.h"
 #include "atn/SetTransition.h"
 #include "atn/SingletonPredictionContext.h"
 #include "atn/StarBlockStartState.h"
@@ -131,9 +134,8 @@
 #include "support/Any.h"
 #include "support/Arrays.h"
 #include "support/BitSet.h"
+#include "support/Casts.h"
 #include "support/CPPUtils.h"
-#include "support/StringUtils.h"
-#include "support/guid.h"
 #include "tree/AbstractParseTreeVisitor.h"
 #include "tree/ErrorNode.h"
 #include "tree/ErrorNodeImpl.h"

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

@@ -20,24 +20,9 @@ using namespace antlr4;
 using namespace antlr4::atn;
 using namespace antlrcpp;
 
-ATN::ATN() : ATN(ATNType::LEXER, 0) {
-}
+ATN::ATN() : ATN(ATNType::LEXER, 0) {}
 
-ATN::ATN(ATN &&other) {
-  // All source vectors are implicitly cleared by the moves.
-  states = std::move(other.states);
-  decisionToState = std::move(other.decisionToState);
-  ruleToStartState = std::move(other.ruleToStartState);
-  ruleToStopState = std::move(other.ruleToStopState);
-  grammarType = std::move(other.grammarType);
-  maxTokenType = std::move(other.maxTokenType);
-  ruleToTokenType = std::move(other.ruleToTokenType);
-  lexerActions = std::move(other.lexerActions);
-  modeToStartState = std::move(other.modeToStartState);
-}
-
-ATN::ATN(ATNType grammarType_, size_t maxTokenType_) : grammarType(grammarType_), maxTokenType(maxTokenType_) {
-}
+ATN::ATN(ATNType grammarType_, size_t maxTokenType_) : grammarType(grammarType_), maxTokenType(maxTokenType_) {}
 
 ATN::~ATN() {
   for (ATNState *state : states) {
@@ -45,42 +30,6 @@ ATN::~ATN() {
   }
 }
 
-/**
- * Required to be defined (even though not used) as we have an explicit move assignment operator.
- */
-ATN& ATN::operator = (ATN &other) NOEXCEPT {
-  states = other.states;
-  decisionToState = other.decisionToState;
-  ruleToStartState = other.ruleToStartState;
-  ruleToStopState = other.ruleToStopState;
-  grammarType = other.grammarType;
-  maxTokenType = other.maxTokenType;
-  ruleToTokenType = other.ruleToTokenType;
-  lexerActions = other.lexerActions;
-  modeToStartState = other.modeToStartState;
-
-  return *this;
-}
-
-/**
- * Explicit move assignment operator to make this the preferred assignment. With implicit copy/move assignment
- * operators it seems the copy operator is preferred causing trouble when releasing the allocated ATNState instances.
- */
-ATN& ATN::operator = (ATN &&other) NOEXCEPT {
-  // All source vectors are implicitly cleared by the moves.
-  states = std::move(other.states);
-  decisionToState = std::move(other.decisionToState);
-  ruleToStartState = std::move(other.ruleToStartState);
-  ruleToStopState = std::move(other.ruleToStopState);
-  grammarType = std::move(other.grammarType);
-  maxTokenType = std::move(other.maxTokenType);
-  ruleToTokenType = std::move(other.ruleToTokenType);
-  lexerActions = std::move(other.lexerActions);
-  modeToStartState = std::move(other.modeToStartState);
-
-  return *this;
-}
-
 misc::IntervalSet ATN::nextTokens(ATNState *s, RuleContext *ctx) const {
   LL1Analyzer analyzer(*this);
   return analyzer.LOOK(s, ctx);
@@ -89,7 +38,7 @@ misc::IntervalSet ATN::nextTokens(ATNState *s, RuleContext *ctx) const {
 
 misc::IntervalSet const& ATN::nextTokens(ATNState *s) const {
   if (!s->_nextTokenUpdated) {
-    std::unique_lock<std::mutex> lock { _mutex };
+    std::unique_lock<std::mutex> lock(_mutex);
     if (!s->_nextTokenUpdated) {
       s->_nextTokenWithinRule = nextTokens(s, nullptr);
       s->_nextTokenUpdated = true;
@@ -146,7 +95,7 @@ misc::IntervalSet ATN::getExpectedTokens(size_t stateNumber, RuleContext *contex
   expected.remove(Token::EPSILON);
   while (ctx && ctx->invokingState != ATNState::INVALID_STATE_NUMBER && following.contains(Token::EPSILON)) {
     ATNState *invokingState = states.at(ctx->invokingState);
-    RuleTransition *rt = static_cast<RuleTransition*>(invokingState->transitions[0]);
+    const RuleTransition *rt = static_cast<const RuleTransition*>(invokingState->transitions[0].get());
     following = nextTokens(rt->followState);
     expected.addAll(following);
     expected.remove(Token::EPSILON);

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

@@ -7,24 +7,36 @@
 
 #include "RuleContext.h"
 
+// GCC generates a warning when forward-declaring ATN if ATN has already been
+// declared due to the attributes added by ANTLR4CPP_PUBLIC.
+// See: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=39159
+// Add constant that can be checked so forward-declarations can be omitted.
+#define ANTLR4CPP_ATN_DECLARED
+
 namespace antlr4 {
 namespace atn {
 
+  class LexerATNSimulator;
+  class ParserATNSimulator;
+
   class ANTLR4CPP_PUBLIC ATN {
   public:
-#if __cplusplus >= 201703L
     static constexpr size_t INVALID_ALT_NUMBER = 0;
-#else
-    enum : size_t {
-      INVALID_ALT_NUMBER = 0,
-    };
-#endif
 
     /// Used for runtime deserialization of ATNs from strings.
     ATN();
-    ATN(ATN &&other);
+
     ATN(ATNType grammarType, size_t maxTokenType);
-    virtual ~ATN();
+
+    ATN(const ATN&) = delete;
+
+    ATN(ATN&&) = delete;
+
+    ~ATN();
+
+    ATN& operator=(const ATN&) = delete;
+
+    ATN& operator=(ATN&&) = delete;
 
     std::vector<ATNState *> states;
 
@@ -56,37 +68,34 @@ namespace atn {
 
     /// For lexer ATNs, this is an array of {@link LexerAction} objects which may
     /// be referenced by action transitions in the ATN.
-    std::vector<Ref<LexerAction>> lexerActions;
+    std::vector<Ref<const LexerAction>> lexerActions;
 
     std::vector<TokensStartState *> modeToStartState;
 
-    ATN& operator = (ATN &other) NOEXCEPT;
-    ATN& operator = (ATN &&other) NOEXCEPT;
-
     /// <summary>
     /// Compute the set of valid tokens that can occur starting in state {@code s}.
     ///  If {@code ctx} is null, the set of tokens will not include what can follow
     ///  the rule surrounding {@code s}. In other words, the set will be
     ///  restricted to tokens reachable staying within {@code s}'s rule.
     /// </summary>
-    virtual misc::IntervalSet nextTokens(ATNState *s, RuleContext *ctx) const;
+    misc::IntervalSet nextTokens(ATNState *s, RuleContext *ctx) const;
 
     /// <summary>
     /// Compute the set of valid tokens that can occur starting in {@code s} and
     /// staying in same rule. <seealso cref="Token#EPSILON"/> is in set if we reach end of
     /// rule.
     /// </summary>
-    virtual misc::IntervalSet const& nextTokens(ATNState *s) const;
+    misc::IntervalSet const& nextTokens(ATNState *s) const;
 
-    virtual void addState(ATNState *state);
+    void addState(ATNState *state);
 
-    virtual void removeState(ATNState *state);
+    void removeState(ATNState *state);
 
-    virtual int defineDecisionState(DecisionState *s);
+    int defineDecisionState(DecisionState *s);
 
-    virtual DecisionState *getDecisionState(size_t decision) const;
+    DecisionState *getDecisionState(size_t decision) const;
 
-    virtual size_t getNumberOfDecisions() const;
+    size_t getNumberOfDecisions() const;
 
     /// <summary>
     /// Computes the set of input symbols which could follow ATN state number
@@ -106,12 +115,17 @@ namespace atn {
     /// specified state in the specified context. </returns>
     /// <exception cref="IllegalArgumentException"> if the ATN does not contain a state with
     /// number {@code stateNumber} </exception>
-    virtual misc::IntervalSet getExpectedTokens(size_t stateNumber, RuleContext *context) const;
+    misc::IntervalSet getExpectedTokens(size_t stateNumber, RuleContext *context) const;
 
     std::string toString() const;
 
   private:
+    friend class LexerATNSimulator;
+    friend class ParserATNSimulator;
+
     mutable std::mutex _mutex;
+    mutable std::shared_mutex _stateMutex;
+    mutable std::shared_mutex _edgeMutex;
   };
 
 } // namespace atn

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

@@ -11,41 +11,40 @@
 
 using namespace antlr4::atn;
 
-ATNConfig::ATNConfig(ATNState *state_, size_t alt_, Ref<PredictionContext> const& context_)
-  : ATNConfig(state_, alt_, context_, SemanticContext::NONE) {
-}
+namespace {
 
-ATNConfig::ATNConfig(ATNState *state_, size_t alt_, Ref<PredictionContext> const& context_, Ref<SemanticContext> const& semanticContext_)
-  : state(state_), alt(alt_), context(context_), semanticContext(semanticContext_) {
-  reachesIntoOuterContext = 0;
-}
+/**
+ * This field stores the bit mask for implementing the
+ * {@link #isPrecedenceFilterSuppressed} property as a bit within the
+ * existing {@link #reachesIntoOuterContext} field.
+ */
+inline constexpr size_t SUPPRESS_PRECEDENCE_FILTER = 0x40000000;
 
-ATNConfig::ATNConfig(Ref<ATNConfig> const& c) : ATNConfig(c, c->state, c->context, c->semanticContext) {
 }
 
-ATNConfig::ATNConfig(Ref<ATNConfig> const& c, ATNState *state_) : ATNConfig(c, state_, c->context, c->semanticContext) {
-}
+ATNConfig::ATNConfig(ATNState *state, size_t alt, Ref<const PredictionContext> context)
+    : ATNConfig(state, alt, std::move(context), 0, SemanticContext::NONE) {}
 
-ATNConfig::ATNConfig(Ref<ATNConfig> const& c, ATNState *state, Ref<SemanticContext> const& semanticContext)
-  : ATNConfig(c, state, c->context, semanticContext) {
-}
+ATNConfig::ATNConfig(ATNState *state, size_t alt, Ref<const PredictionContext> context, Ref<const SemanticContext> semanticContext)
+    : ATNConfig(state, alt, std::move(context), 0, std::move(semanticContext)) {}
 
-ATNConfig::ATNConfig(Ref<ATNConfig> const& c, Ref<SemanticContext> const& semanticContext)
-  : ATNConfig(c, c->state, c->context, semanticContext) {
-}
+ATNConfig::ATNConfig(ATNConfig const& other, Ref<const SemanticContext> semanticContext)
+    : ATNConfig(other.state, other.alt, other.context, other.reachesIntoOuterContext, std::move(semanticContext)) {}
 
-ATNConfig::ATNConfig(Ref<ATNConfig> const& c, ATNState *state, Ref<PredictionContext> const& context)
-  : ATNConfig(c, state, context, c->semanticContext) {
-}
+ATNConfig::ATNConfig(ATNConfig const& other, ATNState *state)
+    : ATNConfig(state, other.alt, other.context, other.reachesIntoOuterContext, other.semanticContext) {}
 
-ATNConfig::ATNConfig(Ref<ATNConfig> const& c, ATNState *state, Ref<PredictionContext> const& context,
-                     Ref<SemanticContext> const& semanticContext)
-  : state(state), alt(c->alt), context(context), reachesIntoOuterContext(c->reachesIntoOuterContext),
-    semanticContext(semanticContext) {
-}
+ATNConfig::ATNConfig(ATNConfig const& other, ATNState *state, Ref<const SemanticContext> semanticContext)
+    : ATNConfig(state, other.alt, other.context, other.reachesIntoOuterContext, std::move(semanticContext)) {}
 
-ATNConfig::~ATNConfig() {
-}
+ATNConfig::ATNConfig(ATNConfig const& other, ATNState *state, Ref<const PredictionContext> context)
+    : ATNConfig(state, other.alt, std::move(context), other.reachesIntoOuterContext, other.semanticContext) {}
+
+ATNConfig::ATNConfig(ATNConfig const& other, ATNState *state, Ref<const PredictionContext> context, Ref<const SemanticContext> semanticContext)
+    : ATNConfig(state, other.alt, std::move(context), other.reachesIntoOuterContext, std::move(semanticContext)) {}
+
+ATNConfig::ATNConfig(ATNState *state, size_t alt, Ref<const PredictionContext> context, size_t reachesIntoOuterContext, Ref<const SemanticContext> semanticContext)
+    : state(state), alt(alt), context(std::move(context)), reachesIntoOuterContext(reachesIntoOuterContext), semanticContext(std::move(semanticContext)) {}
 
 size_t ATNConfig::hashCode() const {
   size_t hashCode = misc::MurmurHash::initialize(7);
@@ -73,22 +72,18 @@ void ATNConfig::setPrecedenceFilterSuppressed(bool value) {
   }
 }
 
-bool ATNConfig::operator == (const ATNConfig &other) const {
+bool ATNConfig::operator==(const ATNConfig &other) const {
   return state->stateNumber == other.state->stateNumber && alt == other.alt &&
     ((context == other.context) || (*context == *other.context)) &&
     *semanticContext == *other.semanticContext &&
     isPrecedenceFilterSuppressed() == other.isPrecedenceFilterSuppressed();
 }
 
-bool ATNConfig::operator != (const ATNConfig &other) const {
-  return !operator==(other);
-}
-
-std::string ATNConfig::toString() {
+std::string ATNConfig::toString() const {
   return toString(true);
 }
 
-std::string ATNConfig::toString(bool showAlt) {
+std::string ATNConfig::toString(bool showAlt) const {
   std::stringstream ss;
   ss << "(";
 
@@ -100,12 +95,12 @@ std::string ATNConfig::toString(bool showAlt) {
     ss << ",[" << context->toString() << "]";
   }
   if (semanticContext != nullptr && semanticContext != SemanticContext::NONE) {
-    ss << "," << semanticContext.get();
+    ss << ",[" << semanticContext->toString() << "]";
   }
   if (getOuterContextDepth() > 0) {
     ss << ",up=" << getOuterContextDepth();
   }
-  ss << ')';
+  ss << ")";
 
   return ss.str();
 }

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

@@ -5,6 +5,11 @@
 
 #pragma once
 
+#include <cassert>
+
+#include "antlr4-common.h"
+#include "atn/SemanticContext.h"
+
 namespace antlr4 {
 namespace atn {
 
@@ -20,32 +25,39 @@ namespace atn {
   public:
     struct Hasher
     {
+      size_t operator()(Ref<ATNConfig> const& k) const {
+        return k->hashCode();
+      }
+
       size_t operator()(ATNConfig const& k) const {
         return k.hashCode();
       }
     };
 
     struct Comparer {
+      bool operator()(Ref<ATNConfig> const& lhs, Ref<ATNConfig> const& rhs) const {
+        return (lhs == rhs) || (*lhs == *rhs);
+      }
+
       bool operator()(ATNConfig const& lhs, ATNConfig const& rhs) const {
         return (&lhs == &rhs) || (lhs == rhs);
       }
     };
 
-
     using Set = std::unordered_set<Ref<ATNConfig>, Hasher, Comparer>;
 
     /// The ATN state associated with this configuration.
-    ATNState * state;
+    ATNState *state = nullptr;
 
     /// What alt (or lexer rule) is predicted by this configuration.
-    const size_t alt;
+    const size_t alt = 0;
 
     /// The stack of invoking states leading to the rule/states associated
     /// with this config.  We track only those contexts pushed during
     /// execution of the ATN simulator.
     ///
     /// Can be shared between multiple ANTConfig instances.
-    Ref<PredictionContext> context;
+    Ref<const PredictionContext> context;
 
     /**
      * We cannot execute predicates dependent upon local context unless
@@ -70,23 +82,25 @@ namespace atn {
      * {@link ATNConfigSet#add(ATNConfig, DoubleKeyMap)} method are
      * <em>completely</em> unaffected by the change.</p>
      */
-    size_t reachesIntoOuterContext;
+    size_t reachesIntoOuterContext = 0;
 
     /// Can be shared between multiple ATNConfig instances.
-    Ref<SemanticContext> semanticContext;
+    Ref<const SemanticContext> semanticContext;
 
-    ATNConfig(ATNState *state, size_t alt, Ref<PredictionContext> const& context);
-    ATNConfig(ATNState *state, size_t alt, Ref<PredictionContext> const& context, Ref<SemanticContext> const& semanticContext);
+    ATNConfig(ATNState *state, size_t alt, Ref<const PredictionContext> context);
+    ATNConfig(ATNState *state, size_t alt, Ref<const PredictionContext> context, Ref<const SemanticContext> semanticContext);
 
-    ATNConfig(Ref<ATNConfig> const& c); // dup
-    ATNConfig(Ref<ATNConfig> const& c, ATNState *state);
-    ATNConfig(Ref<ATNConfig> const& c, ATNState *state, Ref<SemanticContext> const& semanticContext);
-    ATNConfig(Ref<ATNConfig> const& c, Ref<SemanticContext> const& semanticContext);
-    ATNConfig(Ref<ATNConfig> const& c, ATNState *state, Ref<PredictionContext> const& context);
-    ATNConfig(Ref<ATNConfig> const& c, ATNState *state, Ref<PredictionContext> const& context, Ref<SemanticContext> const& semanticContext);
+    ATNConfig(ATNConfig const& other, Ref<const SemanticContext> semanticContext);
+    ATNConfig(ATNConfig const& other, ATNState *state);
+    ATNConfig(ATNConfig const& other, ATNState *state, Ref<const SemanticContext> semanticContext);
+    ATNConfig(ATNConfig const& other, ATNState *state, Ref<const PredictionContext> context);
+    ATNConfig(ATNConfig const& other, ATNState *state, Ref<const PredictionContext> context, Ref<const SemanticContext> semanticContext);
 
     ATNConfig(ATNConfig const&) = default;
-    virtual ~ATNConfig();
+
+    ATNConfig(ATNConfig&&) = default;
+
+    virtual ~ATNConfig() = default;
 
     virtual size_t hashCode() const;
 
@@ -95,32 +109,21 @@ namespace atn {
      * as it existed prior to the introduction of the
      * {@link #isPrecedenceFilterSuppressed} method.
      */
-    size_t getOuterContextDepth() const ;
+    size_t getOuterContextDepth() const;
     bool isPrecedenceFilterSuppressed() const;
     void setPrecedenceFilterSuppressed(bool value);
 
     /// An ATN configuration is equal to another if both have
     /// the same state, they predict the same alternative, and
     /// syntactic/semantic contexts are the same.
-    bool operator == (const ATNConfig &other) const;
-    bool operator != (const ATNConfig &other) const;
+    bool operator==(const ATNConfig &other) const;
+    bool operator!=(const ATNConfig &other) const;
 
-    virtual std::string toString();
-    std::string toString(bool showAlt);
+    virtual std::string toString() const;
+    std::string toString(bool showAlt) const;
 
   private:
-    /**
-     * This field stores the bit mask for implementing the
-     * {@link #isPrecedenceFilterSuppressed} property as a bit within the
-     * existing {@link #reachesIntoOuterContext} field.
-     */
-#if __cplusplus >= 201703L
-    static constexpr size_t SUPPRESS_PRECEDENCE_FILTER = 0x40000000;
-#else
-    enum : size_t {
-      SUPPRESS_PRECEDENCE_FILTER = 0x40000000,
-    };
-#endif
+    ATNConfig(ATNState *state, size_t alt, Ref<const PredictionContext> context, size_t reachesIntoOuterContext, Ref<const SemanticContext> semanticContext);
   };
 
 } // namespace atn