expressir 1.2.3 → 1.2.6

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

@@ -5,80 +5,27 @@
 
 #pragma once
 
-#include "atn/LexerAction.h"
 #include "atn/ATNDeserializationOptions.h"
+#include "atn/SerializedATNView.h"
+#include "atn/LexerAction.h"
+#include "atn/Transition.h"
 
 namespace antlr4 {
 namespace atn {
 
-  class ANTLR4CPP_PUBLIC ATNDeserializer {
+  class ANTLR4CPP_PUBLIC ATNDeserializer final {
   public:
-    static const size_t SERIALIZED_VERSION;
-
-    /// This is the current serialized UUID.
-    // ml: defined as function to avoid the “static initialization order fiasco”.
-    static Guid SERIALIZED_UUID();
+    static constexpr size_t SERIALIZED_VERSION = 4;
 
     ATNDeserializer();
-    ATNDeserializer(const ATNDeserializationOptions& dso);
-    virtual ~ATNDeserializer();
-
-    static Guid toUUID(const unsigned short *data, size_t offset);
-
-    virtual ATN deserialize(const std::vector<uint16_t> &input);
-    virtual void verifyATN(const ATN &atn);
-
-    static void checkCondition(bool condition);
-    static void checkCondition(bool condition, const std::string &message);
 
-    static Transition *edgeFactory(const ATN &atn, size_t type, size_t src, size_t trg, size_t arg1, size_t arg2,
-                                   size_t arg3, const std::vector<misc::IntervalSet> &sets);
+    explicit ATNDeserializer(ATNDeserializationOptions deserializationOptions);
 
-    static ATNState *stateFactory(size_t type, size_t ruleIndex);
-
-  protected:
-    /// Determines if a particular serialized representation of an ATN supports
-    /// a particular feature, identified by the <seealso cref="UUID"/> used for serializing
-    /// the ATN at the time the feature was first introduced.
-    ///
-    /// <param name="feature"> The <seealso cref="UUID"/> marking the first time the feature was
-    /// supported in the serialized ATN. </param>
-    /// <param name="actualUuid"> The <seealso cref="UUID"/> of the actual serialized ATN which is
-    /// currently being deserialized. </param>
-    /// <returns> {@code true} if the {@code actualUuid} value represents a
-    /// serialized ATN at or after the feature identified by {@code feature} was
-    /// introduced; otherwise, {@code false}. </returns>
-    virtual bool isFeatureSupported(const Guid &feature, const Guid &actualUuid);
-    void markPrecedenceDecisions(const ATN &atn);
-    Ref<LexerAction> lexerActionFactory(LexerActionType type, int data1, int data2);
+    std::unique_ptr<ATN> deserialize(SerializedATNView input) const;
+    void verifyATN(const ATN &atn) const;
 
   private:
-    /// This is the earliest supported serialized UUID.
-    static Guid BASE_SERIALIZED_UUID();
-
-    /// This UUID indicates an extension of <seealso cref="BASE_SERIALIZED_UUID"/> for the
-    /// addition of precedence predicates.
-    static Guid ADDED_PRECEDENCE_TRANSITIONS();
-
-    /**
-     * This UUID indicates an extension of ADDED_PRECEDENCE_TRANSITIONS
-     * for the addition of lexer actions encoded as a sequence of
-     * LexerAction instances.
-     */
-    static Guid ADDED_LEXER_ACTIONS();
-
-    /**
-     * This UUID indicates the serialized ATN contains two sets of
-     * IntervalSets, where the second set's values are encoded as
-     * 32-bit integers to support the full Unicode SMP range up to U+10FFFF.
-     */
-    static Guid ADDED_UNICODE_SMP();
-
-    /// This list contains all of the currently supported UUIDs, ordered by when
-    /// the feature first appeared in this branch.
-    static std::vector<Guid>& SUPPORTED_UUIDS();
-
-    ATNDeserializationOptions deserializationOptions;
+    const ATNDeserializationOptions _deserializationOptions;
   };
 
 } // namespace atn

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

@@ -3,61 +3,31 @@
  * can be found in the LICENSE.txt file in the project root.
  */
 
-#include "atn/ATNType.h"
+#include "atn/ATNSimulator.h"
+
 #include "atn/ATNConfigSet.h"
-#include "dfa/DFAState.h"
 #include "atn/ATNDeserializer.h"
-#include "atn/EmptyPredictionContext.h"
-
-#include "atn/ATNSimulator.h"
+#include "atn/ATNType.h"
+#include "dfa/DFAState.h"
 
 using namespace antlr4;
 using namespace antlr4::dfa;
 using namespace antlr4::atn;
 
-const Ref<DFAState> ATNSimulator::ERROR = std::make_shared<DFAState>(INT32_MAX);
-antlrcpp::SingleWriteMultipleReadLock ATNSimulator::_stateLock;
-antlrcpp::SingleWriteMultipleReadLock ATNSimulator::_edgeLock;
+const Ref<DFAState> ATNSimulator::ERROR = std::make_shared<DFAState>(std::numeric_limits<int>::max());
 
 ATNSimulator::ATNSimulator(const ATN &atn, PredictionContextCache &sharedContextCache)
-: atn(atn), _sharedContextCache(sharedContextCache) {
-}
-
-ATNSimulator::~ATNSimulator() {
-}
+    : atn(atn), _sharedContextCache(sharedContextCache) {}
 
 void ATNSimulator::clearDFA() {
   throw UnsupportedOperationException("This ATN simulator does not support clearing the DFA.");
 }
 
-PredictionContextCache& ATNSimulator::getSharedContextCache() {
+PredictionContextCache& ATNSimulator::getSharedContextCache() const {
   return _sharedContextCache;
 }
 
-Ref<PredictionContext> ATNSimulator::getCachedContext(Ref<PredictionContext> const& context) {
+Ref<const PredictionContext> ATNSimulator::getCachedContext(const Ref<const PredictionContext> &context) {
   // This function must only be called with an active state lock, as we are going to change a shared structure.
-  std::map<Ref<PredictionContext>, Ref<PredictionContext>> visited;
-  return PredictionContext::getCachedContext(context, _sharedContextCache, visited);
-}
-
-ATN ATNSimulator::deserialize(const std::vector<uint16_t> &data) {
-  ATNDeserializer deserializer;
-  return deserializer.deserialize(data);
-}
-
-void ATNSimulator::checkCondition(bool condition) {
-  ATNDeserializer::checkCondition(condition);
-}
-
-void ATNSimulator::checkCondition(bool condition, const std::string &message) {
-  ATNDeserializer::checkCondition(condition, message);
-}
-
-Transition *ATNSimulator::edgeFactory(const ATN &atn, int type, int src, int trg, int arg1, int arg2, int arg3,
-                                      const std::vector<misc::IntervalSet> &sets) {
-  return ATNDeserializer::edgeFactory(atn, type, src, trg, arg1, arg2, arg3, sets);
-}
-
-ATNState *ATNSimulator::stateFactory(int type, int ruleIndex) {
-  return ATNDeserializer::stateFactory(type, ruleIndex);
+  return PredictionContext::getCachedContext(context, getSharedContextCache());
 }

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

@@ -6,9 +6,10 @@
 #pragma once
 
 #include "atn/ATN.h"
+#include "atn/PredictionContext.h"
+#include "atn/PredictionContextCache.h"
 #include "misc/IntervalSet.h"
 #include "support/CPPUtils.h"
-#include "atn/PredictionContext.h"
 
 namespace antlr4 {
 namespace atn {
@@ -20,7 +21,8 @@ namespace atn {
     const ATN &atn;
 
     ATNSimulator(const ATN &atn, PredictionContextCache &sharedContextCache);
-    virtual ~ATNSimulator();
+
+    virtual ~ATNSimulator() = default;
 
     virtual void reset() = 0;
 
@@ -36,29 +38,11 @@ namespace atn {
      * @since 4.3
      */
     virtual void clearDFA();
-    virtual PredictionContextCache& getSharedContextCache();
-    virtual Ref<PredictionContext> getCachedContext(Ref<PredictionContext> const& context);
-
-    /// @deprecated Use <seealso cref="ATNDeserializer#deserialize"/> instead.
-    static ATN deserialize(const std::vector<uint16_t> &data);
 
-    /// @deprecated Use <seealso cref="ATNDeserializer#checkCondition(boolean)"/> instead.
-    static void checkCondition(bool condition);
-
-    /// @deprecated Use <seealso cref="ATNDeserializer#checkCondition(boolean, String)"/> instead.
-    static void checkCondition(bool condition, const std::string &message);
-
-    /// @deprecated Use <seealso cref="ATNDeserializer#edgeFactory"/> instead.
-    static Transition *edgeFactory(const ATN &atn, int type, int src, int trg, int arg1, int arg2, int arg3,
-                                   const std::vector<misc::IntervalSet> &sets);
-
-    /// @deprecated Use <seealso cref="ATNDeserializer#stateFactory"/> instead.
-    static ATNState *stateFactory(int type, int ruleIndex);
+    PredictionContextCache& getSharedContextCache() const;
+    Ref<const PredictionContext> getCachedContext(const Ref<const PredictionContext> &context);
 
   protected:
-    static antlrcpp::SingleWriteMultipleReadLock _stateLock; // Lock for DFA states.
-    static antlrcpp::SingleWriteMultipleReadLock _edgeLock; // Lock for the sparse edge map in DFA states.
-
     /// <summary>
     /// The context cache maps all PredictionContext objects that are equals()
     ///  to a single cached copy. This cache is shared across all contexts

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

@@ -13,30 +13,15 @@
 using namespace antlr4::atn;
 using namespace antlrcpp;
 
-ATNState::ATNState() {
-}
-
-ATNState::~ATNState() {
-  for (auto transition : transitions) {
-    delete transition;
-  }
-}
-
-const std::vector<std::string> ATNState::serializationNames = {
-  "INVALID", "BASIC", "RULE_START", "BLOCK_START",
-  "PLUS_BLOCK_START", "STAR_BLOCK_START", "TOKEN_START", "RULE_STOP",
-  "BLOCK_END", "STAR_LOOP_BACK", "STAR_LOOP_ENTRY", "PLUS_LOOP_BACK", "LOOP_END"
-};
-
-size_t ATNState::hashCode() {
+size_t ATNState::hashCode() const {
   return stateNumber;
 }
 
-bool ATNState::operator == (const ATNState &other) {
+bool ATNState::equals(const ATNState &other) const {
   return stateNumber == other.stateNumber;
 }
 
-bool ATNState::isNonGreedyExitState() {
+bool ATNState::isNonGreedyExitState() const {
   return false;
 }
 
@@ -44,14 +29,13 @@ std::string ATNState::toString() const {
   return std::to_string(stateNumber);
 }
 
-void ATNState::addTransition(Transition *e) {
-  addTransition(transitions.size(), e);
+void ATNState::addTransition(ConstTransitionPtr e) {
+  addTransition(transitions.size(), std::move(e));
 }
 
-void ATNState::addTransition(size_t index, Transition *e) {
-  for (Transition *transition : transitions)
+void ATNState::addTransition(size_t index, ConstTransitionPtr e) {
+  for (const auto &transition : transitions)
     if (transition->target->stateNumber == e->target->stateNumber) {
-      delete e;
       return;
     }
 
@@ -62,11 +46,11 @@ void ATNState::addTransition(size_t index, Transition *e) {
     epsilonOnlyTransitions = false;
   }
 
-  transitions.insert(transitions.begin() + index, e);
+  transitions.insert(transitions.begin() + index, std::move(e));
 }
 
-Transition *ATNState::removeTransition(size_t index) {
-  Transition *result = transitions[index];
+ConstTransitionPtr ATNState::removeTransition(size_t index) {
+  ConstTransitionPtr result = std::move(transitions[index]);
   transitions.erase(transitions.begin() + index);
   return result;
 }

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

@@ -6,6 +6,8 @@
 #pragma once
 
 #include "misc/IntervalSet.h"
+#include "atn/Transition.h"
+#include "atn/ATNStateType.h"
 
 namespace antlr4 {
 namespace atn {
@@ -70,55 +72,53 @@ namespace atn {
   ///
   /// <embed src="images/OptionalNonGreedy.svg" type="image/svg+xml"/>
   /// </summary>
+
+// GCC generates a warning here 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
+// Only forward-declare if it hasn't already been declared.
+#ifndef ANTLR4CPP_ATN_DECLARED
   class ANTLR4CPP_PUBLIC ATN;
+#endif
 
   class ANTLR4CPP_PUBLIC ATNState {
   public:
-    ATNState();
+    static constexpr size_t INITIAL_NUM_TRANSITIONS = 4;
+    static constexpr size_t INVALID_STATE_NUMBER = std::numeric_limits<size_t>::max();
+
+    size_t stateNumber = INVALID_STATE_NUMBER;
+    size_t ruleIndex = 0; // at runtime, we don't have Rule objects
+    bool epsilonOnlyTransitions = false;
+
+    /// Track the transitions emanating from this ATN state.
+    std::vector<ConstTransitionPtr> transitions;
+
+    ATNState() = delete;
+
     ATNState(ATNState const&) = delete;
 
-    virtual ~ATNState();
+    ATNState(ATNState&&) = delete;
+
+    virtual ~ATNState() = default;
 
     ATNState& operator=(ATNState const&) = delete;
 
-    static const size_t INITIAL_NUM_TRANSITIONS = 4;
-    static const size_t INVALID_STATE_NUMBER = static_cast<size_t>(-1); // std::numeric_limits<size_t>::max();
-
-    enum {
-      ATN_INVALID_TYPE = 0,
-      BASIC = 1,
-      RULE_START = 2,
-      BLOCK_START = 3,
-      PLUS_BLOCK_START = 4,
-      STAR_BLOCK_START = 5,
-      TOKEN_START = 6,
-      RULE_STOP = 7,
-      BLOCK_END = 8,
-      STAR_LOOP_BACK = 9,
-      STAR_LOOP_ENTRY = 10,
-      PLUS_LOOP_BACK = 11,
-      LOOP_END = 12
-    };
-
-    static const std::vector<std::string> serializationNames;
+    ATNState& operator=(ATNState&&) = delete;
 
-    size_t stateNumber = INVALID_STATE_NUMBER;
-    size_t ruleIndex = 0; // at runtime, we don't have Rule objects
-    bool epsilonOnlyTransitions = false;
+    void addTransition(ConstTransitionPtr e);
+    void addTransition(size_t index, ConstTransitionPtr e);
+    ConstTransitionPtr removeTransition(size_t index);
 
-  public:
-    virtual size_t hashCode();
-    bool operator == (const ATNState &other);
-
-    /// Track the transitions emanating from this ATN state.
-    std::vector<Transition*> transitions;
+    virtual size_t hashCode() const;
+    virtual bool equals(const ATNState &other) const;
 
-    virtual bool isNonGreedyExitState();
+    virtual bool isNonGreedyExitState() const;
     virtual std::string toString() const;
-    virtual void addTransition(Transition *e);
-    virtual void addTransition(size_t index, Transition *e);
-    virtual Transition* removeTransition(size_t index);
-    virtual size_t getStateType() = 0;
+
+    ATNStateType getStateType() const { return _stateType; }
+
+  protected:
+    explicit ATNState(ATNStateType stateType) : _stateType(stateType) {}
 
   private:
     /// Used to cache lookahead during parsing, not used during construction.
@@ -126,8 +126,14 @@ namespace atn {
     misc::IntervalSet _nextTokenWithinRule;
     std::atomic<bool> _nextTokenUpdated { false };
 
+    const ATNStateType _stateType;
+
     friend class ATN;
   };
 
+  inline bool operator==(const ATNState &lhs, const ATNState &rhs) { return lhs.equals(rhs); }
+
+  inline bool operator!=(const ATNState &lhs, const ATNState &rhs) { return !operator==(lhs, rhs); }
+
 } // namespace atn
 } // namespace antlr4

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

@@ -0,0 +1,33 @@
+#include "atn/ATNStateType.h"
+
+std::string antlr4::atn::atnStateTypeName(ATNStateType atnStateType) {
+  switch (atnStateType) {
+    case ATNStateType::INVALID:
+      return "INVALID";
+    case ATNStateType::BASIC:
+      return "BASIC";
+    case ATNStateType::RULE_START:
+      return "RULE_START";
+    case ATNStateType::BLOCK_START:
+      return "BLOCK_START";
+    case ATNStateType::PLUS_BLOCK_START:
+      return "PLUS_BLOCK_START";
+    case ATNStateType::STAR_BLOCK_START:
+      return "STAR_BLOCK_START";
+    case ATNStateType::TOKEN_START:
+      return "TOKEN_START";
+    case ATNStateType::RULE_STOP:
+      return "RULE_STOP";
+    case ATNStateType::BLOCK_END:
+      return "BLOCK_END";
+    case ATNStateType::STAR_LOOP_BACK:
+      return "STAR_LOOP_BACK";
+    case ATNStateType::STAR_LOOP_ENTRY:
+      return "STAR_LOOP_ENTRY";
+    case ATNStateType::PLUS_LOOP_BACK:
+      return "PLUS_LOOP_BACK";
+    case ATNStateType::LOOP_END:
+      return "LOOP_END";
+  }
+  return "UNKNOWN";
+}

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

@@ -0,0 +1,36 @@
+/* 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 <cstddef>
+#include <string>
+
+#include "antlr4-common.h"
+
+namespace antlr4 {
+namespace atn {
+
+  // Constants for ATNState serialization.
+  enum class ATNStateType : size_t {
+    INVALID = 0,
+    BASIC = 1,
+    RULE_START = 2,
+    BLOCK_START = 3,
+    PLUS_BLOCK_START = 4,
+    STAR_BLOCK_START = 5,
+    TOKEN_START = 6,
+    RULE_STOP = 7,
+    BLOCK_END = 8,
+    STAR_LOOP_BACK = 9,
+    STAR_LOOP_ENTRY = 10,
+    PLUS_LOOP_BACK = 11,
+    LOOP_END = 12,
+  };
+
+  ANTLR4CPP_PUBLIC std::string atnStateTypeName(ATNStateType atnStateType);
+
+} // namespace atn
+} // namespace antlr4

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

@@ -8,15 +8,11 @@
 using namespace antlr4::atn;
 
 ActionTransition::ActionTransition(ATNState *target, size_t ruleIndex)
-  : Transition(target), ruleIndex(ruleIndex), actionIndex(INVALID_INDEX), isCtxDependent(false) {
+  : Transition(TransitionType::ACTION, target), ruleIndex(ruleIndex), actionIndex(INVALID_INDEX), isCtxDependent(false) {
 }
 
 ActionTransition::ActionTransition(ATNState *target, size_t ruleIndex, size_t actionIndex, bool isCtxDependent)
-  : Transition(target), ruleIndex(ruleIndex), actionIndex(actionIndex), isCtxDependent(isCtxDependent) {
-}
-
-Transition::SerializationType ActionTransition::getSerializationType() const {
-  return ACTION;
+  : Transition(TransitionType::ACTION, target), ruleIndex(ruleIndex), actionIndex(actionIndex), isCtxDependent(isCtxDependent) {
 }
 
 bool ActionTransition::isEpsilon() const {

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

@@ -12,6 +12,10 @@ namespace atn {
 
   class ANTLR4CPP_PUBLIC ActionTransition final : public Transition {
   public:
+    static bool is(const Transition &transition) { return transition.getTransitionType() == TransitionType::ACTION; }
+
+    static bool is(const Transition *transition) { return transition != nullptr && is(*transition); }
+
     const size_t ruleIndex;
     const size_t actionIndex;
     const bool isCtxDependent; // e.g., $i ref in action
@@ -20,8 +24,6 @@ namespace atn {
 
     ActionTransition(ATNState *target, size_t ruleIndex, size_t actionIndex, bool isCtxDependent);
 
-    virtual SerializationType getSerializationType() const override;
-
     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/ArrayPredictionContext.cpp

@@ -3,25 +3,39 @@
  * can be found in the LICENSE.txt file in the project root.
  */
 
-#include "support/Arrays.h"
-#include "atn/SingletonPredictionContext.h"
-
 #include "atn/ArrayPredictionContext.h"
 
+#include <cstring>
+
+#include "atn/SingletonPredictionContext.h"
+#include "misc/MurmurHash.h"
+#include "support/Casts.h"
+
 using namespace antlr4::atn;
+using namespace antlr4::misc;
+using namespace antlrcpp;
 
-ArrayPredictionContext::ArrayPredictionContext(Ref<SingletonPredictionContext> const& a)
-  : ArrayPredictionContext({ a->parent }, { a->returnState }) {
-}
+namespace {
+
+  bool cachedHashCodeEqual(size_t lhs, size_t rhs) {
+    return lhs == rhs || lhs == 0 || rhs == 0;
+  }
+
+  bool predictionContextEqual(const Ref<const PredictionContext> &lhs, const Ref<const PredictionContext> &rhs) {
+    return *lhs == *rhs;
+  }
 
-ArrayPredictionContext::ArrayPredictionContext(std::vector<Ref<PredictionContext>> const& parents_,
-                                               std::vector<size_t> const& returnStates)
-  : PredictionContext(calculateHashCode(parents_, returnStates)), parents(parents_), returnStates(returnStates) {
-    assert(parents.size() > 0);
-    assert(returnStates.size() > 0);
 }
 
-ArrayPredictionContext::~ArrayPredictionContext() {
+ArrayPredictionContext::ArrayPredictionContext(const SingletonPredictionContext &predictionContext)
+    : ArrayPredictionContext({ predictionContext.parent }, { predictionContext.returnState }) {}
+
+ArrayPredictionContext::ArrayPredictionContext(std::vector<Ref<const PredictionContext>> parents,
+                                               std::vector<size_t> returnStates)
+    : PredictionContext(PredictionContextType::ARRAY), parents(std::move(parents)), returnStates(std::move(returnStates)) {
+  assert(this->parents.size() > 0);
+  assert(this->returnStates.size() > 0);
+  assert(this->parents.size() == this->returnStates.size());
 }
 
 bool ArrayPredictionContext::isEmpty() const {
@@ -33,7 +47,7 @@ size_t ArrayPredictionContext::size() const {
   return returnStates.size();
 }
 
-Ref<PredictionContext> ArrayPredictionContext::getParent(size_t index) const {
+const Ref<const PredictionContext>& ArrayPredictionContext::getParent(size_t index) const {
   return parents[index];
 }
 
@@ -41,18 +55,31 @@ size_t ArrayPredictionContext::getReturnState(size_t index) const {
   return returnStates[index];
 }
 
-bool ArrayPredictionContext::operator == (PredictionContext const& o) const {
-  if (this == &o) {
-    return true;
+size_t ArrayPredictionContext::hashCodeImpl() const {
+  size_t hash = MurmurHash::initialize();
+  hash = MurmurHash::update(hash, static_cast<size_t>(getContextType()));
+  for (const auto &parent : parents) {
+    hash = MurmurHash::update(hash, parent);
   }
-
-  const ArrayPredictionContext *other = dynamic_cast<const ArrayPredictionContext*>(&o);
-  if (other == nullptr || hashCode() != other->hashCode()) {
-    return false; // can't be same if hash is different
+  for (const auto &returnState : returnStates) {
+    hash = MurmurHash::update(hash, returnState);
   }
+  return MurmurHash::finish(hash, 1 + parents.size() + returnStates.size());
+}
 
-  return antlrcpp::Arrays::equals(returnStates, other->returnStates) &&
-    antlrcpp::Arrays::equals(parents, other->parents);
+bool ArrayPredictionContext::equals(const PredictionContext &other) const {
+  if (this == std::addressof(other)) {
+    return true;
+  }
+  if (getContextType() != other.getContextType()) {
+    return false;
+  }
+  const auto &array = downCast<const ArrayPredictionContext&>(other);
+  return returnStates.size() == array.returnStates.size() &&
+         parents.size() == array.parents.size() &&
+         cachedHashCodeEqual(cachedHashCode(), array.cachedHashCode()) &&
+         std::memcmp(returnStates.data(), array.returnStates.data(), returnStates.size() * sizeof(decltype(returnStates)::value_type)) == 0 &&
+         std::equal(parents.begin(), parents.end(), array.parents.begin(), predictionContextEqual);
 }
 
 std::string ArrayPredictionContext::toString() const {

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

@@ -13,29 +13,37 @@ namespace atn {
 
   class SingletonPredictionContext;
 
-  class ANTLR4CPP_PUBLIC ArrayPredictionContext : public PredictionContext {
+  class ANTLR4CPP_PUBLIC ArrayPredictionContext final : public PredictionContext {
   public:
+    static bool is(const PredictionContext &predictionContext) { return predictionContext.getContextType() == PredictionContextType::ARRAY; }
+
+    static bool is(const PredictionContext *predictionContext) { return predictionContext != nullptr && is(*predictionContext); }
+
     /// Parent can be empty only if full ctx mode and we make an array
     /// from EMPTY and non-empty. We merge EMPTY by using null parent and
     /// returnState == EMPTY_RETURN_STATE.
     // Also here: we use a strong reference to our parents to avoid having them freed prematurely.
     //            See also SinglePredictionContext.
-    const std::vector<Ref<PredictionContext>> parents;
+    std::vector<Ref<const PredictionContext>> parents;
 
     /// Sorted for merge, no duplicates; if present, EMPTY_RETURN_STATE is always last.
-    const std::vector<size_t> returnStates;
+    std::vector<size_t> returnStates;
+
+    explicit ArrayPredictionContext(const SingletonPredictionContext &predictionContext);
+
+    ArrayPredictionContext(std::vector<Ref<const PredictionContext>> parents, std::vector<size_t> returnStates);
 
-    ArrayPredictionContext(Ref<SingletonPredictionContext> const& a);
-    ArrayPredictionContext(std::vector<Ref<PredictionContext>> const& parents_, std::vector<size_t> const& returnStates);
-    virtual ~ArrayPredictionContext();
+    ArrayPredictionContext(ArrayPredictionContext&&) = default;
 
-    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;
-    bool operator == (const PredictionContext &o) const override;
+    bool isEmpty() const override;
+    size_t size() const override;
+    const Ref<const PredictionContext>& getParent(size_t index) const override;
+    size_t getReturnState(size_t index) const override;
+    bool equals(const PredictionContext &other) const override;
+    std::string toString() const override;
 
-    virtual std::string toString() const override;
+  protected:
+    size_t hashCodeImpl() const override;
   };
 
 } // namespace atn

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

@@ -11,11 +11,7 @@
 using namespace antlr4::misc;
 using namespace antlr4::atn;
 
-AtomTransition::AtomTransition(ATNState *target, size_t label) : Transition(target), _label(label) {
-}
-
-Transition::SerializationType AtomTransition::getSerializationType() const {
-  return ATOM;
+AtomTransition::AtomTransition(ATNState *target, size_t label) : Transition(TransitionType::ATOM, target), _label(label) {
 }
 
 IntervalSet AtomTransition::label() const {