expressir 1.2.4 → 1.2.7

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

@@ -7,6 +7,7 @@
 #include "atn/LexerIndexedCustomAction.h"
 #include "support/CPPUtils.h"
 #include "support/Arrays.h"
+#include "support/Casts.h"
 
 #include "atn/LexerActionExecutor.h"
 
@@ -15,48 +16,54 @@ using namespace antlr4::atn;
 using namespace antlr4::misc;
 using namespace antlrcpp;
 
-LexerActionExecutor::LexerActionExecutor(const std::vector<Ref<LexerAction>> &lexerActions)
-  : _lexerActions(lexerActions), _hashCode(generateHashCode()) {
-}
+namespace {
+
+  bool cachedHashCodeEqual(size_t lhs, size_t rhs) {
+    return lhs == rhs || lhs == 0 || rhs == 0;
+  }
+
+  bool lexerActionEqual(const Ref<const LexerAction> &lhs, const Ref<const LexerAction> &rhs) {
+    return *lhs == *rhs;
+  }
 
-LexerActionExecutor::~LexerActionExecutor() {
 }
 
-Ref<LexerActionExecutor> LexerActionExecutor::append(Ref<LexerActionExecutor> const& lexerActionExecutor,
-                                                     Ref<LexerAction> const& lexerAction) {
+LexerActionExecutor::LexerActionExecutor(std::vector<Ref<const LexerAction>> lexerActions)
+    : _lexerActions(std::move(lexerActions)), _hashCode(0) {}
+
+Ref<const LexerActionExecutor> LexerActionExecutor::append(const Ref<const LexerActionExecutor> &lexerActionExecutor,
+                                                           Ref<const LexerAction> lexerAction) {
   if (lexerActionExecutor == nullptr) {
-    return std::make_shared<LexerActionExecutor>(std::vector<Ref<LexerAction>> { lexerAction });
+    return std::make_shared<LexerActionExecutor>(std::vector<Ref<const LexerAction>>{ std::move(lexerAction) });
   }
-
-  std::vector<Ref<LexerAction>> lexerActions = lexerActionExecutor->_lexerActions; // Make a copy.
-  lexerActions.push_back(lexerAction);
-  return std::make_shared<LexerActionExecutor>(lexerActions);
+  std::vector<Ref<const LexerAction>> lexerActions;
+  lexerActions.reserve(lexerActionExecutor->_lexerActions.size() + 1);
+  lexerActions.insert(lexerActions.begin(), lexerActionExecutor->_lexerActions.begin(), lexerActionExecutor->_lexerActions.end());
+  lexerActions.push_back(std::move(lexerAction));
+  return std::make_shared<LexerActionExecutor>(std::move(lexerActions));
 }
 
-Ref<LexerActionExecutor> LexerActionExecutor::fixOffsetBeforeMatch(int offset) {
-  std::vector<Ref<LexerAction>> updatedLexerActions;
+Ref<const LexerActionExecutor> LexerActionExecutor::fixOffsetBeforeMatch(int offset) const {
+  std::vector<Ref<const LexerAction>> updatedLexerActions;
   for (size_t i = 0; i < _lexerActions.size(); i++) {
-    if (_lexerActions[i]->isPositionDependent() && !is<LexerIndexedCustomAction>(_lexerActions[i])) {
+    if (_lexerActions[i]->isPositionDependent() && !LexerIndexedCustomAction::is(*_lexerActions[i])) {
       if (updatedLexerActions.empty()) {
         updatedLexerActions = _lexerActions; // Make a copy.
       }
-
       updatedLexerActions[i] = std::make_shared<LexerIndexedCustomAction>(offset, _lexerActions[i]);
     }
   }
-
   if (updatedLexerActions.empty()) {
     return shared_from_this();
   }
-
-  return std::make_shared<LexerActionExecutor>(updatedLexerActions);
+  return std::make_shared<LexerActionExecutor>(std::move(updatedLexerActions));
 }
 
-std::vector<Ref<LexerAction>> LexerActionExecutor::getLexerActions() const {
+const std::vector<Ref<const LexerAction>>& LexerActionExecutor::getLexerActions() const {
   return _lexerActions;
 }
 
-void LexerActionExecutor::execute(Lexer *lexer, CharStream *input, size_t startIndex) {
+void LexerActionExecutor::execute(Lexer *lexer, CharStream *input, size_t startIndex) const {
   bool requiresSeek = false;
   size_t stopIndex = input->index();
 
@@ -65,43 +72,40 @@ void LexerActionExecutor::execute(Lexer *lexer, CharStream *input, size_t startI
       input->seek(stopIndex);
     }
   });
-  for (auto lexerAction : _lexerActions) {
-    if (is<LexerIndexedCustomAction>(lexerAction)) {
-      int offset = (std::static_pointer_cast<LexerIndexedCustomAction>(lexerAction))->getOffset();
+  for (const auto &lexerAction : _lexerActions) {
+    if (LexerIndexedCustomAction::is(*lexerAction)) {
+      int offset = downCast<const LexerIndexedCustomAction&>(*lexerAction).getOffset();
       input->seek(startIndex + offset);
-      lexerAction = std::static_pointer_cast<LexerIndexedCustomAction>(lexerAction)->getAction();
       requiresSeek = (startIndex + offset) != stopIndex;
     } else if (lexerAction->isPositionDependent()) {
       input->seek(stopIndex);
       requiresSeek = false;
     }
-
     lexerAction->execute(lexer);
   }
 }
 
 size_t LexerActionExecutor::hashCode() const {
-  return _hashCode;
-}
-
-bool LexerActionExecutor::operator == (const LexerActionExecutor &obj) const {
-  if (&obj == this) {
-    return true;
+  auto hash = _hashCode.load(std::memory_order_relaxed);
+  if (hash == 0) {
+    hash = MurmurHash::initialize();
+    for (const auto &lexerAction : _lexerActions) {
+      hash = MurmurHash::update(hash, lexerAction);
+    }
+    hash = MurmurHash::finish(hash, _lexerActions.size());
+    if (hash == 0) {
+      hash = std::numeric_limits<size_t>::max();
+    }
+    _hashCode.store(hash, std::memory_order_relaxed);
   }
-
-  return _hashCode == obj._hashCode && Arrays::equals(_lexerActions, obj._lexerActions);
-}
-
-bool LexerActionExecutor::operator != (const LexerActionExecutor &obj) const {
-  return !operator==(obj);
+  return hash;
 }
 
-size_t LexerActionExecutor::generateHashCode() const {
-  size_t hash = MurmurHash::initialize();
-  for (auto lexerAction : _lexerActions) {
-    hash = MurmurHash::update(hash, lexerAction);
+bool LexerActionExecutor::equals(const LexerActionExecutor &other) const {
+  if (this == std::addressof(other)) {
+    return true;
   }
-  hash = MurmurHash::finish(hash, _lexerActions.size());
-
-  return hash;
+  return cachedHashCodeEqual(_hashCode.load(std::memory_order_relaxed), other._hashCode.load(std::memory_order_relaxed)) &&
+         _lexerActions.size() == other._lexerActions.size() &&
+         std::equal(_lexerActions.begin(), _lexerActions.end(), other._lexerActions.begin(), lexerActionEqual);
 }

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

@@ -17,13 +17,12 @@ namespace atn {
   /// <para>The executor tracks position information for position-dependent lexer actions
   /// efficiently, ensuring that actions appearing only at the end of the rule do
   /// not cause bloating of the <seealso cref="DFA"/> created for the lexer.</para>
-  class ANTLR4CPP_PUBLIC LexerActionExecutor : public std::enable_shared_from_this<LexerActionExecutor> {
+  class ANTLR4CPP_PUBLIC LexerActionExecutor final : public std::enable_shared_from_this<LexerActionExecutor> {
   public:
     /// <summary>
     /// Constructs an executor for a sequence of <seealso cref="LexerAction"/> actions. </summary>
     /// <param name="lexerActions"> The lexer actions to execute. </param>
-    LexerActionExecutor(const std::vector<Ref<LexerAction>> &lexerActions);
-    virtual ~LexerActionExecutor();
+    explicit LexerActionExecutor(std::vector<Ref<const LexerAction>> lexerActions);
 
     /// <summary>
     /// Creates a <seealso cref="LexerActionExecutor"/> which executes the actions for
@@ -39,8 +38,8 @@ namespace atn {
     /// </param>
     /// <returns> A <seealso cref="LexerActionExecutor"/> for executing the combine actions
     /// of {@code lexerActionExecutor} and {@code lexerAction}. </returns>
-    static Ref<LexerActionExecutor> append(Ref<LexerActionExecutor> const& lexerActionExecutor,
-                                           Ref<LexerAction> const& lexerAction);
+    static Ref<const LexerActionExecutor> append(const Ref<const LexerActionExecutor> &lexerActionExecutor,
+                                                 Ref<const LexerAction> lexerAction);
 
     /// <summary>
     /// Creates a <seealso cref="LexerActionExecutor"/> which encodes the current offset
@@ -70,12 +69,12 @@ namespace atn {
     /// </param>
     /// <returns> A <seealso cref="LexerActionExecutor"/> which stores input stream offsets
     /// for all position-dependent lexer actions. </returns>
-    virtual Ref<LexerActionExecutor> fixOffsetBeforeMatch(int offset);
+    Ref<const LexerActionExecutor> fixOffsetBeforeMatch(int offset) const;
 
     /// <summary>
     /// Gets the lexer actions to be executed by this executor. </summary>
     /// <returns> The lexer actions to be executed by this executor. </returns>
-    virtual std::vector<Ref<LexerAction>> getLexerActions() const;
+    const std::vector<Ref<const LexerAction>>& getLexerActions() const;
 
     /// <summary>
     /// Execute the actions encapsulated by this executor within the context of a
@@ -95,21 +94,35 @@ namespace atn {
     /// <param name="startIndex"> The token start index. This value may be passed to
     /// <seealso cref="IntStream#seek"/> to set the {@code input} position to the beginning
     /// of the token. </param>
-    virtual void execute(Lexer *lexer, CharStream *input, size_t startIndex);
+    void execute(Lexer *lexer, CharStream *input, size_t startIndex) const;
 
-    virtual size_t hashCode() const;
-    virtual bool operator == (const LexerActionExecutor &obj) const;
-    virtual bool operator != (const LexerActionExecutor &obj) const;
+    size_t hashCode() const;
+
+    bool equals(const LexerActionExecutor &other) const;
 
   private:
-    const std::vector<Ref<LexerAction>> _lexerActions;
+    const std::vector<Ref<const LexerAction>> _lexerActions;
+    mutable std::atomic<size_t> _hashCode;
+  };
+
+  inline bool operator==(const LexerActionExecutor &lhs, const LexerActionExecutor &rhs) {
+    return lhs.equals(rhs);
+  }
+
+  inline bool operator!=(const LexerActionExecutor &lhs, const LexerActionExecutor &rhs) {
+    return !operator==(lhs, rhs);
+  }
+
+}  // namespace atn
+}  // namespace antlr4
 
-    /// Caches the result of <seealso cref="#hashCode"/> since the hash code is an element
-    /// of the performance-critical <seealso cref="LexerATNConfig#hashCode"/> operation.
-    const size_t _hashCode;
+namespace std {
 
-    size_t generateHashCode() const;
+  template <>
+  struct hash<::antlr4::atn::LexerActionExecutor> {
+    size_t operator()(const ::antlr4::atn::LexerActionExecutor &lexerActionExecutor) const {
+      return lexerActionExecutor.hashCode();
+    }
   };
 
-} // namespace atn
-} // namespace antlr4
+}  // namespace std

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

@@ -20,7 +20,7 @@ namespace atn {
     /// <summary>
     /// The type of a <seealso cref="LexerChannelAction"/> action.
     /// </summary>
-    CHANNEL,
+    CHANNEL = 0,
     /// <summary>
     /// The type of a <seealso cref="LexerCustomAction"/> action.
     /// </summary>
@@ -49,6 +49,8 @@ namespace atn {
     /// The type of a <seealso cref="LexerTypeAction"/> action.
     /// </summary>
     TYPE,
+
+    INDEXED_CUSTOM,
   };
 
 } // namespace atn

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

@@ -5,51 +5,39 @@
 
 #include "misc/MurmurHash.h"
 #include "Lexer.h"
+#include "support/Casts.h"
 
 #include "atn/LexerChannelAction.h"
 
 using namespace antlr4::atn;
 using namespace antlr4::misc;
+using namespace antlrcpp;
 
-LexerChannelAction::LexerChannelAction(int channel) : _channel(channel) {
-}
-
-int LexerChannelAction::getChannel() const {
-  return _channel;
-}
-
-LexerActionType LexerChannelAction::getActionType() const {
-  return LexerActionType::CHANNEL;
-}
+LexerChannelAction::LexerChannelAction(int channel)
+    : LexerAction(LexerActionType::CHANNEL, false), _channel(channel) {}
 
-bool LexerChannelAction::isPositionDependent() const {
-  return false;
+void LexerChannelAction::execute(Lexer *lexer) const {
+  lexer->setChannel(getChannel());
 }
 
-void LexerChannelAction::execute(Lexer *lexer) {
-  lexer->setChannel(_channel);
-}
-
-size_t LexerChannelAction::hashCode() const {
+size_t LexerChannelAction::hashCodeImpl() const {
   size_t hash = MurmurHash::initialize();
   hash = MurmurHash::update(hash, static_cast<size_t>(getActionType()));
-  hash = MurmurHash::update(hash, _channel);
+  hash = MurmurHash::update(hash, getChannel());
   return MurmurHash::finish(hash, 2);
 }
 
-bool LexerChannelAction::operator == (const LexerAction &obj) const {
-  if (&obj == this) {
+bool LexerChannelAction::equals(const LexerAction &other) const {
+  if (this == std::addressof(other)) {
     return true;
   }
-
-  const LexerChannelAction *action = dynamic_cast<const LexerChannelAction *>(&obj);
-  if (action == nullptr) {
+  if (getActionType() != other.getActionType()) {
     return false;
   }
-
-  return _channel == action->_channel;
+  const auto &lexerAction = downCast<const LexerChannelAction&>(other);
+  return getChannel() == lexerAction.getChannel();
 }
 
 std::string LexerChannelAction::toString() const {
-  return "channel(" + std::to_string(_channel) + ")";
+  return "channel(" + std::to_string(getChannel()) + ")";
 }

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

@@ -22,26 +22,20 @@ namespace atn {
   /// </summary>
   class ANTLR4CPP_PUBLIC LexerChannelAction final : public LexerAction {
   public:
+    static bool is(const LexerAction &lexerAction) { return lexerAction.getActionType() == LexerActionType::CHANNEL; }
+
+    static bool is(const LexerAction *lexerAction) { return lexerAction != nullptr && is(*lexerAction); }
+
     /// <summary>
     /// Constructs a new {@code channel} action with the specified channel value. </summary>
     /// <param name="channel"> The channel value to pass to <seealso cref="Lexer#setChannel"/>. </param>
-    LexerChannelAction(int channel);
+    explicit LexerChannelAction(int channel);
 
     /// <summary>
     /// Gets the channel to use for the <seealso cref="Token"/> created by the lexer.
     /// </summary>
     /// <returns> The channel to use for the <seealso cref="Token"/> created by the lexer. </returns>
-    int getChannel() const;
-
-    /// <summary>
-    /// {@inheritDoc} </summary>
-    /// <returns> This method returns <seealso cref="LexerActionType#CHANNEL"/>. </returns>
-    virtual LexerActionType getActionType() const override;
-
-    /// <summary>
-    /// {@inheritDoc} </summary>
-    /// <returns> This method returns {@code false}. </returns>
-    virtual bool isPositionDependent() const override;
+    int getChannel() const { return _channel; }
 
     /// <summary>
     /// {@inheritDoc}
@@ -49,11 +43,13 @@ namespace atn {
     /// <para>This action is implemented by calling <seealso cref="Lexer#setChannel"/> with the
     /// value provided by <seealso cref="#getChannel"/>.</para>
     /// </summary>
-    virtual void execute(Lexer *lexer) override;
+    void execute(Lexer *lexer) const override;
+
+    bool equals(const LexerAction &other) const override;
+    std::string toString() const override;
 
-    virtual size_t hashCode() const override;
-    virtual bool operator == (const LexerAction &obj) const override;
-    virtual std::string toString() const override;
+  protected:
+    size_t hashCodeImpl() const override;
 
   private:
     const int _channel;

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

@@ -4,59 +4,42 @@
  */
 
 #include "misc/MurmurHash.h"
-#include "support/CPPUtils.h"
 #include "Lexer.h"
+#include "support/Casts.h"
 
 #include "atn/LexerCustomAction.h"
 
 using namespace antlr4;
 using namespace antlr4::atn;
 using namespace antlr4::misc;
+using namespace antlrcpp;
 
-LexerCustomAction::LexerCustomAction(size_t ruleIndex, size_t actionIndex) : _ruleIndex(ruleIndex), _actionIndex(actionIndex) {
-}
-
-size_t LexerCustomAction::getRuleIndex() const {
-  return _ruleIndex;
-}
+LexerCustomAction::LexerCustomAction(size_t ruleIndex, size_t actionIndex)
+    : LexerAction(LexerActionType::CUSTOM, true), _ruleIndex(ruleIndex), _actionIndex(actionIndex) {}
 
-size_t LexerCustomAction::getActionIndex() const {
-  return _actionIndex;
+void LexerCustomAction::execute(Lexer *lexer) const {
+  lexer->action(nullptr, getRuleIndex(), getActionIndex());
 }
 
-LexerActionType LexerCustomAction::getActionType() const {
-  return LexerActionType::CUSTOM;
-}
-
-bool LexerCustomAction::isPositionDependent() const {
-  return true;
-}
-
-void LexerCustomAction::execute(Lexer *lexer) {
-  lexer->action(nullptr, _ruleIndex, _actionIndex);
-}
-
-size_t LexerCustomAction::hashCode() const {
+size_t LexerCustomAction::hashCodeImpl() const {
   size_t hash = MurmurHash::initialize();
   hash = MurmurHash::update(hash, static_cast<size_t>(getActionType()));
-  hash = MurmurHash::update(hash, _ruleIndex);
-  hash = MurmurHash::update(hash, _actionIndex);
+  hash = MurmurHash::update(hash, getRuleIndex());
+  hash = MurmurHash::update(hash, getActionIndex());
   return MurmurHash::finish(hash, 3);
 }
 
-bool LexerCustomAction::operator == (const LexerAction &obj) const {
-  if (&obj == this) {
+bool LexerCustomAction::equals(const LexerAction &other) const {
+  if (this == std::addressof(other)) {
     return true;
   }
-
-  const LexerCustomAction *action = dynamic_cast<const LexerCustomAction *>(&obj);
-  if (action == nullptr) {
+  if (getActionType() != other.getActionType()) {
     return false;
   }
-
-  return _ruleIndex == action->_ruleIndex && _actionIndex == action->_actionIndex;
+  const auto &lexerAction = downCast<const LexerCustomAction&>(other);
+  return getRuleIndex() == lexerAction.getRuleIndex() && getActionIndex() == lexerAction.getActionIndex();
 }
 
 std::string LexerCustomAction::toString() const {
-  return antlrcpp::toString(this);
+  return "custom(" + std::to_string(getRuleIndex()) + ", " + std::to_string(getActionIndex()) + ")";
 }

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

@@ -26,6 +26,10 @@ namespace atn {
   /// </summary>
   class ANTLR4CPP_PUBLIC LexerCustomAction final : public LexerAction {
   public:
+    static bool is(const LexerAction &lexerAction) { return lexerAction.getActionType() == LexerActionType::CUSTOM; }
+
+    static bool is(const LexerAction *lexerAction) { return lexerAction != nullptr && is(*lexerAction); }
+
     /// <summary>
     /// Constructs a custom lexer action with the specified rule and action
     /// indexes.
@@ -40,31 +44,13 @@ namespace atn {
     /// Gets the rule index to use for calls to <seealso cref="Recognizer#action"/>.
     /// </summary>
     /// <returns> The rule index for the custom action. </returns>
-    size_t getRuleIndex() const;
+    size_t getRuleIndex() const { return _ruleIndex; }
 
     /// <summary>
     /// Gets the action index to use for calls to <seealso cref="Recognizer#action"/>.
     /// </summary>
     /// <returns> The action index for the custom action. </returns>
-    size_t getActionIndex() const;
-
-    /// <summary>
-    /// {@inheritDoc}
-    /// </summary>
-    /// <returns> This method returns <seealso cref="LexerActionType#CUSTOM"/>. </returns>
-    virtual LexerActionType getActionType() const override;
-
-    /// <summary>
-    /// Gets whether the lexer action is position-dependent. Position-dependent
-    /// actions may have different semantics depending on the <seealso cref="CharStream"/>
-    /// index at the time the action is executed.
-    ///
-    /// <para>Custom actions are position-dependent since they may represent a
-    /// user-defined embedded action which makes calls to methods like
-    /// <seealso cref="Lexer#getText"/>.</para>
-    /// </summary>
-    /// <returns> This method returns {@code true}. </returns>
-    virtual bool isPositionDependent() const override;
+    size_t getActionIndex() const { return _actionIndex; }
 
     /// <summary>
     /// {@inheritDoc}
@@ -72,11 +58,13 @@ namespace atn {
     /// <para>Custom actions are implemented by calling <seealso cref="Lexer#action"/> with the
     /// appropriate rule and action indexes.</para>
     /// </summary>
-    virtual void execute(Lexer *lexer) override;
+    void execute(Lexer *lexer) const override;
+
+    bool equals(const LexerAction &other) const override;
+    std::string toString() const override;
 
-    virtual size_t hashCode() const override;
-    virtual bool operator == (const LexerAction &obj) const override;
-    virtual std::string toString() const override;
+  protected:
+    size_t hashCodeImpl() const override;
 
   private:
     const size_t _ruleIndex;

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

@@ -6,58 +6,52 @@
 #include "misc/MurmurHash.h"
 #include "Lexer.h"
 #include "support/CPPUtils.h"
+#include "support/Casts.h"
 
 #include "atn/LexerIndexedCustomAction.h"
 
 using namespace antlr4;
 using namespace antlr4::atn;
 using namespace antlr4::misc;
+using namespace antlrcpp;
 
-LexerIndexedCustomAction::LexerIndexedCustomAction(int offset, Ref<LexerAction> const& action)
-  : _offset(offset), _action(action) {
-}
-
-int LexerIndexedCustomAction::getOffset() const {
-  return _offset;
-}
+namespace {
 
-Ref<LexerAction> LexerIndexedCustomAction::getAction() const {
-  return _action;
-}
+  bool cachedHashCodeEqual(size_t lhs, size_t rhs) {
+    return lhs == rhs || lhs == 0 || rhs == 0;
+  }
 
-LexerActionType LexerIndexedCustomAction::getActionType() const {
-  return _action->getActionType();
 }
 
-bool LexerIndexedCustomAction::isPositionDependent() const {
-  return true;
-}
+LexerIndexedCustomAction::LexerIndexedCustomAction(int offset, Ref<const LexerAction> action)
+    : LexerAction(LexerActionType::INDEXED_CUSTOM, true), _action(std::move(action)), _offset(offset) {}
 
-void LexerIndexedCustomAction::execute(Lexer *lexer) {
+void LexerIndexedCustomAction::execute(Lexer *lexer) const {
   // assume the input stream position was properly set by the calling code
-  _action->execute(lexer);
+  getAction()->execute(lexer);
 }
 
-size_t LexerIndexedCustomAction::hashCode() const {
+size_t LexerIndexedCustomAction::hashCodeImpl() const {
   size_t hash = MurmurHash::initialize();
-  hash = MurmurHash::update(hash, _offset);
-  hash = MurmurHash::update(hash, _action);
-  return MurmurHash::finish(hash, 2);
+  hash = MurmurHash::update(hash, static_cast<size_t>(getActionType()));
+  hash = MurmurHash::update(hash, getOffset());
+  hash = MurmurHash::update(hash, getAction());
+  return MurmurHash::finish(hash, 3);
 }
 
-bool LexerIndexedCustomAction::operator == (const LexerAction &obj) const {
-  if (&obj == this) {
+bool LexerIndexedCustomAction::equals(const LexerAction &other) const {
+  if (this == std::addressof(other)) {
     return true;
   }
-
-  const LexerIndexedCustomAction *action = dynamic_cast<const LexerIndexedCustomAction *>(&obj);
-  if (action == nullptr) {
+  if (getActionType() != other.getActionType()) {
     return false;
   }
-
-  return _offset == action->_offset && *_action == *action->_action;
+  const auto &lexerAction = downCast<const LexerIndexedCustomAction&>(other);
+  return getOffset() == lexerAction.getOffset() &&
+         cachedHashCodeEqual(cachedHashCode(), lexerAction.cachedHashCode()) &&
+         *getAction() == *lexerAction.getAction();
 }
 
 std::string LexerIndexedCustomAction::toString() const {
-  return antlrcpp::toString(this);
+  return "indexedCustom(" + std::to_string(getOffset()) + ", " + getAction()->toString() + ")";
 }

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

@@ -26,6 +26,10 @@ namespace atn {
   /// </summary>
   class ANTLR4CPP_PUBLIC LexerIndexedCustomAction final : public LexerAction {
   public:
+    static bool is(const LexerAction &lexerAction) { return lexerAction.getActionType() == LexerActionType::INDEXED_CUSTOM; }
+
+    static bool is(const LexerAction *lexerAction) { return lexerAction != nullptr && is(*lexerAction); }
+
     /// <summary>
     /// Constructs a new indexed custom action by associating a character offset
     /// with a <seealso cref="LexerAction"/>.
@@ -38,7 +42,7 @@ namespace atn {
     /// executed. </param>
     /// <param name="action"> The lexer action to execute at a particular offset in the
     /// input <seealso cref="CharStream"/>. </param>
-    LexerIndexedCustomAction(int offset, Ref<LexerAction> const& action);
+    LexerIndexedCustomAction(int offset, Ref<const LexerAction> action);
 
     /// <summary>
     /// Gets the location in the input <seealso cref="CharStream"/> at which the lexer
@@ -47,34 +51,24 @@ namespace atn {
     /// </summary>
     /// <returns> The location in the input <seealso cref="CharStream"/> at which the lexer
     /// action should be executed. </returns>
-    int getOffset() const;
+    int getOffset() const { return _offset; }
 
     /// <summary>
     /// Gets the lexer action to execute.
     /// </summary>
     /// <returns> A <seealso cref="LexerAction"/> object which executes the lexer action. </returns>
-    Ref<LexerAction> getAction() const;
-
-    /// <summary>
-    /// {@inheritDoc}
-    /// </summary>
-    /// <returns> This method returns the result of calling <seealso cref="#getActionType"/>
-    /// on the <seealso cref="LexerAction"/> returned by <seealso cref="#getAction"/>. </returns>
-    virtual LexerActionType getActionType() const override;
+    const Ref<const LexerAction>& getAction() const { return _action; }
 
-    /// <summary>
-    /// {@inheritDoc} </summary>
-    /// <returns> This method returns {@code true}. </returns>
-    virtual bool isPositionDependent() const override;
+    void execute(Lexer *lexer) const override;
+    bool equals(const LexerAction &other) const override;
+    std::string toString() const override;
 
-    virtual void execute(Lexer *lexer) override;
-    virtual size_t hashCode() const override;
-    virtual bool operator == (const LexerAction &obj) const override;
-    virtual std::string toString() const override;
+  protected:
+    size_t hashCodeImpl() const override;
 
   private:
+    const Ref<const LexerAction> _action;
     const int _offset;
-    const Ref<LexerAction> _action;
   };
 
 } // namespace atn