expressir 1.2.4 → 1.2.7

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

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

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

@@ -20,26 +20,20 @@ namespace atn {
   /// </summary>
   class ANTLR4CPP_PUBLIC LexerModeAction final : public LexerAction {
   public:
+    static bool is(const LexerAction &lexerAction) { return lexerAction.getActionType() == LexerActionType::MODE; }
+
+    static bool is(const LexerAction *lexerAction) { return lexerAction != nullptr && is(*lexerAction); }
+
     /// <summary>
     /// Constructs a new {@code mode} action with the specified mode value. </summary>
     /// <param name="mode"> The mode value to pass to <seealso cref="Lexer#mode"/>. </param>
-    LexerModeAction(int mode);
+    explicit LexerModeAction(int mode);
 
     /// <summary>
     /// Get the lexer mode this action should transition the lexer to.
     /// </summary>
     /// <returns> The lexer mode for this {@code mode} command. </returns>
-    int getMode();
-
-    /// <summary>
-    /// {@inheritDoc} </summary>
-    /// <returns> This method returns <seealso cref="LexerActionType#MODE"/>. </returns>
-    virtual LexerActionType getActionType() const override;
-
-    /// <summary>
-    /// {@inheritDoc} </summary>
-    /// <returns> This method returns {@code false}. </returns>
-    virtual bool isPositionDependent() const override;
+    int getMode() const { return _mode; }
 
     /// <summary>
     /// {@inheritDoc}
@@ -47,11 +41,13 @@ namespace atn {
     /// <para>This action is implemented by calling <seealso cref="Lexer#mode"/> with the
     /// value provided by <seealso cref="#getMode"/>.</para>
     /// </summary>
-    virtual void execute(Lexer *lexer) override;
+    void execute(Lexer *lexer) const override;
+
+    bool equals(const LexerAction &obj) 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 _mode;

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

@@ -12,34 +12,23 @@ using namespace antlr4;
 using namespace antlr4::atn;
 using namespace antlr4::misc;
 
-const Ref<LexerMoreAction> LexerMoreAction::getInstance() {
-  static Ref<LexerMoreAction> instance(new LexerMoreAction());
+const Ref<const LexerMoreAction>& LexerMoreAction::getInstance() {
+  static const Ref<const LexerMoreAction> instance(new LexerMoreAction());
   return instance;
 }
 
-LexerMoreAction::LexerMoreAction() {
-}
-
-LexerActionType LexerMoreAction::getActionType() const {
-  return LexerActionType::MORE;
-}
-
-bool LexerMoreAction::isPositionDependent() const {
-  return false;
-}
-
-void LexerMoreAction::execute(Lexer *lexer) {
+void LexerMoreAction::execute(Lexer *lexer) const {
   lexer->more();
 }
 
-size_t LexerMoreAction::hashCode() const {
+size_t LexerMoreAction::hashCodeImpl() const {
   size_t hash = MurmurHash::initialize();
   hash = MurmurHash::update(hash, static_cast<size_t>(getActionType()));
   return MurmurHash::finish(hash, 1);
 }
 
-bool LexerMoreAction::operator == (const LexerAction &obj) const {
-  return &obj == this;
+bool LexerMoreAction::equals(const LexerAction &other) const {
+  return this == std::addressof(other);
 }
 
 std::string LexerMoreAction::toString() const {

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

@@ -22,35 +22,31 @@ namespace atn {
   /// </summary>
   class ANTLR4CPP_PUBLIC LexerMoreAction final : public LexerAction {
   public:
-    /// <summary>
-    /// Provides a singleton instance of this parameterless lexer action.
-    /// </summary>
-    static const Ref<LexerMoreAction> getInstance();
+    static bool is(const LexerAction &lexerAction) { return lexerAction.getActionType() == LexerActionType::MORE; }
 
-    /// <summary>
-    /// {@inheritDoc} </summary>
-    /// <returns> This method returns <seealso cref="LexerActionType#MORE"/>. </returns>
-    virtual LexerActionType getActionType() const override;
+    static bool is(const LexerAction *lexerAction) { return lexerAction != nullptr && is(*lexerAction); }
 
     /// <summary>
-    /// {@inheritDoc} </summary>
-    /// <returns> This method returns {@code false}. </returns>
-    virtual bool isPositionDependent() const override;
+    /// Provides a singleton instance of this parameterless lexer action.
+    /// </summary>
+    static const Ref<const LexerMoreAction>& getInstance();
 
     /// <summary>
     /// {@inheritDoc}
     ///
     /// <para>This action is implemented by calling <seealso cref="Lexer#more"/>.</para>
     /// </summary>
-    virtual void execute(Lexer *lexer) override;
+    void execute(Lexer *lexer) const override;
+
+    bool equals(const LexerAction &obj) 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:
     /// Constructs the singleton instance of the lexer {@code more} command.
-    LexerMoreAction();
+    LexerMoreAction() : LexerAction(LexerActionType::MORE, false) {}
   };
 
 } // namespace atn

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

@@ -12,34 +12,23 @@ using namespace antlr4;
 using namespace antlr4::atn;
 using namespace antlr4::misc;
 
-const Ref<LexerPopModeAction> LexerPopModeAction::getInstance() {
-  static Ref<LexerPopModeAction> instance(new LexerPopModeAction());
+const Ref<const LexerPopModeAction>& LexerPopModeAction::getInstance() {
+  static const Ref<const LexerPopModeAction> instance(new LexerPopModeAction());
   return instance;
 }
 
-LexerPopModeAction::LexerPopModeAction() {
-}
-
-LexerActionType LexerPopModeAction::getActionType() const {
-  return LexerActionType::POP_MODE;
-}
-
-bool LexerPopModeAction::isPositionDependent() const {
-  return false;
-}
-
-void LexerPopModeAction::execute(Lexer *lexer) {
+void LexerPopModeAction::execute(Lexer *lexer) const {
   lexer->popMode();
 }
 
-size_t LexerPopModeAction::hashCode() const {
+size_t LexerPopModeAction::hashCodeImpl() const {
   size_t hash = MurmurHash::initialize();
   hash = MurmurHash::update(hash, static_cast<size_t>(getActionType()));
   return MurmurHash::finish(hash, 1);
 }
 
-bool LexerPopModeAction::operator == (const LexerAction &obj) const {
-  return &obj == this;
+bool LexerPopModeAction::equals(const LexerAction &other) const {
+  return this == std::addressof(other);
 }
 
 std::string LexerPopModeAction::toString() const {

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

@@ -22,35 +22,31 @@ namespace atn {
   /// </summary>
   class ANTLR4CPP_PUBLIC LexerPopModeAction final : public LexerAction {
   public:
-    /// <summary>
-    /// Provides a singleton instance of this parameterless lexer action.
-    /// </summary>
-    static const Ref<LexerPopModeAction> getInstance();
+    static bool is(const LexerAction &lexerAction) { return lexerAction.getActionType() == LexerActionType::POP_MODE; }
 
-    /// <summary>
-    /// {@inheritDoc} </summary>
-    /// <returns> This method returns <seealso cref="LexerActionType#POP_MODE"/>. </returns>
-    virtual LexerActionType getActionType() const override;
+    static bool is(const LexerAction *lexerAction) { return lexerAction != nullptr && is(*lexerAction); }
 
     /// <summary>
-    /// {@inheritDoc} </summary>
-    /// <returns> This method returns {@code false}. </returns>
-    virtual bool isPositionDependent() const override;
+    /// Provides a singleton instance of this parameterless lexer action.
+    /// </summary>
+    static const Ref<const LexerPopModeAction>& getInstance();
 
     /// <summary>
     /// {@inheritDoc}
     ///
     /// <para>This action is implemented by calling <seealso cref="Lexer#popMode"/>.</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:
     /// Constructs the singleton instance of the lexer {@code popMode} command.
-    LexerPopModeAction();
+    LexerPopModeAction() : LexerAction(LexerActionType::POP_MODE, false) {}
   };
 
 } // namespace atn

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

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

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

@@ -20,26 +20,20 @@ namespace atn {
   /// </summary>
   class ANTLR4CPP_PUBLIC LexerPushModeAction final : public LexerAction {
   public:
+    static bool is(const LexerAction &lexerAction) { return lexerAction.getActionType() == LexerActionType::PUSH_MODE; }
+
+    static bool is(const LexerAction *lexerAction) { return lexerAction != nullptr && is(*lexerAction); }
+
     /// <summary>
     /// Constructs a new {@code pushMode} action with the specified mode value. </summary>
     /// <param name="mode"> The mode value to pass to <seealso cref="Lexer#pushMode"/>. </param>
-    LexerPushModeAction(int mode);
+    explicit LexerPushModeAction(int mode);
 
     /// <summary>
     /// Get the lexer mode this action should transition the lexer to.
     /// </summary>
     /// <returns> The lexer mode for this {@code pushMode} command. </returns>
-    int getMode() const;
-
-    /// <summary>
-    /// {@inheritDoc} </summary>
-    /// <returns> This method returns <seealso cref="LexerActionType#PUSH_MODE"/>. </returns>
-    virtual LexerActionType getActionType() const override;
-
-    /// <summary>
-    /// {@inheritDoc} </summary>
-    /// <returns> This method returns {@code false}. </returns>
-    virtual bool isPositionDependent() const override;
+    int getMode() const { return _mode; }
 
     /// <summary>
     /// {@inheritDoc}
@@ -47,11 +41,13 @@ namespace atn {
     /// <para>This action is implemented by calling <seealso cref="Lexer#pushMode"/> with the
     /// value provided by <seealso cref="#getMode"/>.</para>
     /// </summary>
-    virtual void execute(Lexer *lexer) override;
+    void execute(Lexer *lexer) const override;
+
+    bool equals(const LexerAction &obj) 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 _mode;

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

@@ -12,34 +12,23 @@ using namespace antlr4;
 using namespace antlr4::atn;
 using namespace antlr4::misc;
 
-const Ref<LexerSkipAction> LexerSkipAction::getInstance() {
-  static Ref<LexerSkipAction> instance(new LexerSkipAction());
+const Ref<const LexerSkipAction>& LexerSkipAction::getInstance() {
+  static const Ref<const LexerSkipAction> instance(new LexerSkipAction());
   return instance;
 }
 
-LexerSkipAction::LexerSkipAction() {
-}
-
-LexerActionType LexerSkipAction::getActionType() const {
-  return LexerActionType::SKIP;
-}
-
-bool LexerSkipAction::isPositionDependent() const {
-  return false;
-}
-
-void LexerSkipAction::execute(Lexer *lexer) {
+void LexerSkipAction::execute(Lexer *lexer) const {
   lexer->skip();
 }
 
-size_t LexerSkipAction::hashCode() const {
+size_t LexerSkipAction::hashCodeImpl() const {
   size_t hash = MurmurHash::initialize();
   hash = MurmurHash::update(hash, static_cast<size_t>(getActionType()));
   return MurmurHash::finish(hash, 1);
 }
 
-bool LexerSkipAction::operator == (const LexerAction &obj) const {
-  return &obj == this;
+bool LexerSkipAction::equals(const LexerAction &other) const {
+  return this == std::addressof(other);
 }
 
 std::string LexerSkipAction::toString() const {

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

@@ -22,33 +22,29 @@ namespace atn {
   /// </summary>
   class ANTLR4CPP_PUBLIC LexerSkipAction final : public LexerAction {
   public:
-    /// Provides a singleton instance of this parameterless lexer action.
-    static const Ref<LexerSkipAction> getInstance();
+    static bool is(const LexerAction &lexerAction) { return lexerAction.getActionType() == LexerActionType::SKIP; }
 
-    /// <summary>
-    /// {@inheritDoc} </summary>
-    /// <returns> This method returns <seealso cref="LexerActionType#SKIP"/>. </returns>
-    virtual LexerActionType getActionType() const override;
+    static bool is(const LexerAction *lexerAction) { return lexerAction != nullptr && is(*lexerAction); }
 
-    /// <summary>
-    /// {@inheritDoc} </summary>
-    /// <returns> This method returns {@code false}. </returns>
-    virtual bool isPositionDependent() const override;
+    /// Provides a singleton instance of this parameterless lexer action.
+    static const Ref<const LexerSkipAction>& getInstance();
 
     /// <summary>
     /// {@inheritDoc}
     ///
     /// <para>This action is implemented by calling <seealso cref="Lexer#skip"/>.</para>
     /// </summary>
-    virtual void execute(Lexer *lexer) override;
+    void execute(Lexer *lexer) const override;
+
+    bool equals(const LexerAction &obj) 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:
     /// Constructs the singleton instance of the lexer {@code skip} command.
-    LexerSkipAction();
+    LexerSkipAction() : LexerAction(LexerActionType::SKIP, false) {}
   };
 
 } // namespace atn

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

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

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

@@ -13,27 +13,21 @@ namespace atn {
 
   /// Implements the {@code type} lexer action by calling <seealso cref="Lexer#setType"/>
   /// with the assigned type.
-  class ANTLR4CPP_PUBLIC LexerTypeAction : public LexerAction {
+  class ANTLR4CPP_PUBLIC LexerTypeAction final : public LexerAction {
   public:
+    static bool is(const LexerAction &lexerAction) { return lexerAction.getActionType() == LexerActionType::TYPE; }
+
+    static bool is(const LexerAction *lexerAction) { return lexerAction != nullptr && is(*lexerAction); }
+
     /// <summary>
     /// Constructs a new {@code type} action with the specified token type value. </summary>
     /// <param name="type"> The type to assign to the token using <seealso cref="Lexer#setType"/>. </param>
-    LexerTypeAction(int type);
+    explicit LexerTypeAction(int type);
 
     /// <summary>
     /// Gets the type to assign to a token created by the lexer. </summary>
     /// <returns> The type to assign to a token created by the lexer. </returns>
-    virtual int getType() const;
-
-    /// <summary>
-    /// {@inheritDoc} </summary>
-    /// <returns> This method returns <seealso cref="LexerActionType#TYPE"/>. </returns>
-    virtual LexerActionType getActionType() const override;
-
-    /// <summary>
-    /// {@inheritDoc} </summary>
-    /// <returns> This method returns {@code false}. </returns>
-    virtual bool isPositionDependent() const override;
+    int getType() const { return _type; }
 
     /// <summary>
     /// {@inheritDoc}
@@ -41,11 +35,13 @@ namespace atn {
     /// <para>This action is implemented by calling <seealso cref="Lexer#setType"/> with the
     /// value provided by <seealso cref="#getType"/>.</para>
     /// </summary>
-    virtual void execute(Lexer *lexer) override;
+    void execute(Lexer *lexer) const override;
+
+    bool equals(const LexerAction &obj) 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 _type;

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

@@ -13,9 +13,13 @@ namespace atn {
   /// Mark the end of a * or + loop.
   class ANTLR4CPP_PUBLIC LoopEndState final : public ATNState {
   public:
+    static bool is(const ATNState &atnState) { return atnState.getStateType() == ATNStateType::LOOP_END; }
+
+    static bool is(const ATNState *atnState) { return atnState != nullptr && is(*atnState); }
+
     ATNState *loopBackState = nullptr;
 
-    virtual size_t getStateType() override;
+    LoopEndState() : ATNState(ATNStateType::LOOP_END) {}
   };
 
 } // namespace atn

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

@@ -10,12 +10,7 @@
 using namespace antlr4;
 using namespace antlr4::atn;
 
-NotSetTransition::NotSetTransition(ATNState *target, const misc::IntervalSet &set) : SetTransition(target, set) {
-}
-
-Transition::SerializationType NotSetTransition::getSerializationType() const {
-  return NOT_SET;
-}
+NotSetTransition::NotSetTransition(ATNState *target, misc::IntervalSet set) : SetTransition(TransitionType::NOT_SET, target, std::move(set)) {}
 
 bool NotSetTransition::matches(size_t symbol, size_t minVocabSymbol, size_t maxVocabSymbol) const {
   return symbol >= minVocabSymbol && symbol <= maxVocabSymbol