expressir 1.2.4 → 1.2.5

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

@@ -7,6 +7,7 @@
 
 #include "Recognizer.h"
 #include "support/CPPUtils.h"
+#include "atn/SemanticContextType.h"
 
 namespace antlr4 {
 namespace atn {
@@ -19,36 +20,15 @@ namespace atn {
   ///  SemanticContext within the scope of this outer class.
   class ANTLR4CPP_PUBLIC SemanticContext : public std::enable_shared_from_this<SemanticContext> {
   public:
-    struct Hasher
-    {
-      size_t operator()(Ref<SemanticContext> const& k) const {
-        return k->hashCode();
-      }
-    };
-
-    struct Comparer {
-      bool operator()(Ref<SemanticContext> const& lhs, Ref<SemanticContext> const& rhs) const {
-        if (lhs == rhs)
-          return true;
-        return (lhs->hashCode() == rhs->hashCode()) && (*lhs == *rhs);
-      }
-    };
-
-
-    using Set = std::unordered_set<Ref<SemanticContext>, Hasher, Comparer>;
-
     /**
      * The default {@link SemanticContext}, which is semantically equivalent to
      * a predicate of the form {@code {true}?}.
      */
-    static const Ref<SemanticContext> NONE;
+    static const Ref<const SemanticContext> NONE;
 
-    virtual ~SemanticContext();
+    virtual ~SemanticContext() = default;
 
-    virtual size_t hashCode() const = 0;
-    virtual std::string toString() const = 0;
-    virtual bool operator == (const SemanticContext &other) const = 0;
-    virtual bool operator != (const SemanticContext &other) const;
+    SemanticContextType getContextType() const { return _contextType; }
 
     /// <summary>
     /// For context independent predicates, we evaluate them without a local
@@ -63,7 +43,7 @@ namespace atn {
     /// prediction, so we passed in the outer context here in case of context
     /// dependent predicate evaluation.
     /// </summary>
-    virtual bool eval(Recognizer *parser, RuleContext *parserCallStack) = 0;
+    virtual bool eval(Recognizer *parser, RuleContext *parserCallStack) const = 0;
 
     /**
      * Evaluate the precedence predicates for the context and reduce the result.
@@ -83,12 +63,18 @@ namespace atn {
      * semantic context after precedence predicates are evaluated.</li>
      * </ul>
      */
-    virtual Ref<SemanticContext> evalPrecedence(Recognizer *parser, RuleContext *parserCallStack);
+    virtual Ref<const SemanticContext> evalPrecedence(Recognizer *parser, RuleContext *parserCallStack) const;
+
+    virtual size_t hashCode() const = 0;
+
+    virtual bool equals(const SemanticContext &other) const = 0;
 
-    static Ref<SemanticContext> And(Ref<SemanticContext> const& a, Ref<SemanticContext> const& b);
+    virtual std::string toString() const = 0;
+
+    static Ref<const SemanticContext> And(Ref<const SemanticContext> a, Ref<const SemanticContext> b);
 
     /// See also: ParserATNSimulator::getPredsForAmbigAlts.
-    static Ref<SemanticContext> Or(Ref<SemanticContext> const& a, Ref<SemanticContext> const& b);
+    static Ref<const SemanticContext> Or(Ref<const SemanticContext> a, Ref<const SemanticContext> b);
 
     class Predicate;
     class PrecedencePredicate;
@@ -96,44 +82,54 @@ namespace atn {
     class AND;
     class OR;
 
+  protected:
+    explicit SemanticContext(SemanticContextType contextType) : _contextType(contextType) {}
+
   private:
-    static std::vector<Ref<PrecedencePredicate>> filterPrecedencePredicates(const Set &collection);
+    const SemanticContextType _contextType;
   };
 
-  class ANTLR4CPP_PUBLIC SemanticContext::Predicate : public SemanticContext {
+  inline bool operator==(const SemanticContext &lhs, const SemanticContext &rhs) {
+    return lhs.equals(rhs);
+  }
+
+  inline bool operator!=(const SemanticContext &lhs, const SemanticContext &rhs) {
+    return !operator==(lhs, rhs);
+  }
+
+  class ANTLR4CPP_PUBLIC SemanticContext::Predicate final : public SemanticContext {
   public:
+    static bool is(const SemanticContext &semanticContext) { return semanticContext.getContextType() == SemanticContextType::PREDICATE; }
+
+    static bool is(const SemanticContext *semanticContext) { return semanticContext != nullptr && is(*semanticContext); }
+
     const size_t ruleIndex;
     const size_t predIndex;
     const bool isCtxDependent; // e.g., $i ref in pred
 
-  protected:
-    Predicate();
-
-  public:
     Predicate(size_t ruleIndex, size_t predIndex, bool isCtxDependent);
 
-    virtual bool eval(Recognizer *parser, RuleContext *parserCallStack) override;
-    virtual size_t hashCode() const override;
-    virtual bool operator == (const SemanticContext &other) const override;
-    virtual std::string toString() const override;
+    bool eval(Recognizer *parser, RuleContext *parserCallStack) const override;
+    size_t hashCode() const override;
+    bool equals(const SemanticContext &other) const override;
+    std::string toString() const override;
   };
 
-  class ANTLR4CPP_PUBLIC SemanticContext::PrecedencePredicate : public SemanticContext {
+  class ANTLR4CPP_PUBLIC SemanticContext::PrecedencePredicate final : public SemanticContext {
   public:
+    static bool is(const SemanticContext &semanticContext) { return semanticContext.getContextType() == SemanticContextType::PRECEDENCE; }
+
+    static bool is(const SemanticContext *semanticContext) { return semanticContext != nullptr && is(*semanticContext); }
+
     const int precedence;
 
-  protected:
-    PrecedencePredicate();
+    explicit PrecedencePredicate(int precedence);
 
-  public:
-    PrecedencePredicate(int precedence);
-
-    virtual bool eval(Recognizer *parser, RuleContext *parserCallStack) override;
-    virtual Ref<SemanticContext> evalPrecedence(Recognizer *parser, RuleContext *parserCallStack) override;
-    virtual int compareTo(PrecedencePredicate *o);
-    virtual size_t hashCode() const override;
-    virtual bool operator == (const SemanticContext &other) const override;
-    virtual std::string toString() const override;
+    bool eval(Recognizer *parser, RuleContext *parserCallStack) const override;
+    Ref<const SemanticContext> evalPrecedence(Recognizer *parser, RuleContext *parserCallStack) const override;
+    size_t hashCode() const override;
+    bool equals(const SemanticContext &other) const override;
+    std::string toString() const override;
   };
 
   /**
@@ -144,7 +140,12 @@ namespace atn {
    */
   class ANTLR4CPP_PUBLIC SemanticContext::Operator : public SemanticContext {
   public:
-    virtual ~Operator() override;
+    static bool is(const SemanticContext &semanticContext) {
+      const auto contextType = semanticContext.getContextType();
+      return contextType == SemanticContextType::AND || contextType == SemanticContextType::OR;
+    }
+
+    static bool is(const SemanticContext *semanticContext) { return semanticContext != nullptr && is(*semanticContext); }
 
     /**
      * Gets the operands for the semantic context operator.
@@ -155,68 +156,78 @@ namespace atn {
      * @since 4.3
      */
 
-    virtual std::vector<Ref<SemanticContext>> getOperands() const = 0;
+    virtual const std::vector<Ref<const SemanticContext>>& getOperands() const = 0;
+
+  protected:
+    using SemanticContext::SemanticContext;
   };
 
   /**
    * A semantic context which is true whenever none of the contained contexts
    * is false.
    */
-  class ANTLR4CPP_PUBLIC SemanticContext::AND : public SemanticContext::Operator {
+  class ANTLR4CPP_PUBLIC SemanticContext::AND final : public SemanticContext::Operator {
   public:
-    std::vector<Ref<SemanticContext>> opnds;
+    static bool is(const SemanticContext &semanticContext) { return semanticContext.getContextType() == SemanticContextType::AND; }
+
+    static bool is(const SemanticContext *semanticContext) { return semanticContext != nullptr && is(*semanticContext); }
 
-    AND(Ref<SemanticContext> const& a, Ref<SemanticContext> const& b) ;
+    AND(Ref<const SemanticContext> a, Ref<const SemanticContext> b) ;
 
-    virtual std::vector<Ref<SemanticContext>> getOperands() const override;
-    virtual bool operator == (const SemanticContext &other) const override;
-    virtual size_t hashCode() const override;
+    const std::vector<Ref<const SemanticContext>>& getOperands() const override;
 
     /**
      * The evaluation of predicates by this context is short-circuiting, but
      * unordered.</p>
      */
-    virtual bool eval(Recognizer *parser, RuleContext *parserCallStack) override;
-    virtual Ref<SemanticContext> evalPrecedence(Recognizer *parser, RuleContext *parserCallStack) override;
-    virtual std::string toString() const override;
+    bool eval(Recognizer *parser, RuleContext *parserCallStack) const override;
+    Ref<const SemanticContext> evalPrecedence(Recognizer *parser, RuleContext *parserCallStack) const override;
+    size_t hashCode() const override;
+    bool equals(const SemanticContext &other) const override;
+    std::string toString() const override;
+
+  private:
+    std::vector<Ref<const SemanticContext>> _opnds;
   };
 
   /**
    * A semantic context which is true whenever at least one of the contained
    * contexts is true.
    */
-  class ANTLR4CPP_PUBLIC SemanticContext::OR : public SemanticContext::Operator {
+  class ANTLR4CPP_PUBLIC SemanticContext::OR final : public SemanticContext::Operator {
   public:
-    std::vector<Ref<SemanticContext>> opnds;
+    static bool is(const SemanticContext &semanticContext) { return semanticContext.getContextType() == SemanticContextType::OR; }
+
+    static bool is(const SemanticContext *semanticContext) { return semanticContext != nullptr && is(*semanticContext); }
 
-    OR(Ref<SemanticContext> const& a, Ref<SemanticContext> const& b);
+    OR(Ref<const SemanticContext> a, Ref<const SemanticContext> b);
 
-    virtual std::vector<Ref<SemanticContext>> getOperands() const override;
-    virtual bool operator == (const SemanticContext &other) const override;
-    virtual size_t hashCode() const override;
+    const std::vector<Ref<const SemanticContext>>& getOperands() const override;
 
     /**
      * The evaluation of predicates by this context is short-circuiting, but
      * unordered.
      */
-    virtual bool eval(Recognizer *parser, RuleContext *parserCallStack) override;
-    virtual Ref<SemanticContext> evalPrecedence(Recognizer *parser, RuleContext *parserCallStack) override;
-    virtual std::string toString() const override;
-  };
+    bool eval(Recognizer *parser, RuleContext *parserCallStack) const override;
+    Ref<const SemanticContext> evalPrecedence(Recognizer *parser, RuleContext *parserCallStack) const override;
+    size_t hashCode() const override;
+    bool equals(const SemanticContext &other) const override;
+    std::string toString() const override;
 
-} // namespace atn
-} // namespace antlr4
+  private:
+    std::vector<Ref<const SemanticContext>> _opnds;
+  };
 
-// Hash function for SemanticContext, used in the MurmurHash::update function
+}  // namespace atn
+}  // namespace antlr4
 
 namespace std {
-  using antlr4::atn::SemanticContext;
 
-  template <> struct hash<SemanticContext>
-  {
-    size_t operator () (SemanticContext &x) const
-    {
-      return x.hashCode();
+  template <>
+  struct hash<::antlr4::atn::SemanticContext> {
+    size_t operator()(const ::antlr4::atn::SemanticContext &semanticContext) const {
+      return semanticContext.hashCode();
     }
   };
-}
+
+}  // namespace std

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

@@ -0,0 +1,23 @@
+/* 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 "antlr4-common.h"
+
+namespace antlr4 {
+namespace atn {
+
+  enum class SemanticContextType : size_t {
+    PREDICATE = 1,
+    PRECEDENCE = 2,
+    AND = 3,
+    OR = 4,
+  };
+
+} // namespace atn
+} // namespace antlr4

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

@@ -0,0 +1,101 @@
+/* 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 <cstdint>
+#include <cstring>
+#include <iterator>
+#include <vector>
+
+#include "antlr4-common.h"
+#include "misc/MurmurHash.h"
+
+namespace antlr4 {
+namespace atn {
+
+  class ANTLR4CPP_PUBLIC SerializedATNView final {
+  public:
+    using value_type = int32_t;
+    using size_type = size_t;
+    using difference_type = ptrdiff_t;
+    using reference = int32_t&;
+    using const_reference = const int32_t&;
+    using pointer = int32_t*;
+    using const_pointer = const int32_t*;
+    using iterator = const_pointer;
+    using const_iterator = const_pointer;
+    using reverse_iterator = std::reverse_iterator<iterator>;
+    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+    SerializedATNView() = default;
+
+    SerializedATNView(const_pointer data, size_type size) : _data(data), _size(size) {}
+
+    SerializedATNView(const std::vector<int32_t> &serializedATN) : _data(serializedATN.data()), _size(serializedATN.size()) {}
+
+    SerializedATNView(const SerializedATNView&) = default;
+
+    SerializedATNView& operator=(const SerializedATNView&) = default;
+
+    const_iterator begin() const { return data(); }
+
+    const_iterator cbegin() const { return data(); }
+
+    const_iterator end() const { return data() + size(); }
+
+    const_iterator cend() const { return data() + size(); }
+
+    const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
+
+    const_reverse_iterator crbegin() const { return const_reverse_iterator(cend()); }
+
+    const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
+
+    const_reverse_iterator crend() const { return const_reverse_iterator(cbegin()); }
+
+    bool empty() const { return size() == 0; }
+
+    const_pointer data() const { return _data; }
+
+    size_type size() const { return _size; }
+
+    size_type size_bytes() const { return size() * sizeof(value_type); }
+
+    const_reference operator[](size_type index) const { return _data[index]; }
+
+  private:
+    const_pointer _data = nullptr;
+    size_type _size = 0;
+  };
+
+  inline bool operator==(const SerializedATNView &lhs, const SerializedATNView &rhs) {
+    return (lhs.data() == rhs.data() && lhs.size() == rhs.size()) ||
+           (lhs.size() == rhs.size() && std::memcmp(lhs.data(), rhs.data(), lhs.size_bytes()) == 0);
+  }
+
+  inline bool operator!=(const SerializedATNView &lhs, const SerializedATNView &rhs) {
+    return !operator==(lhs, rhs);
+  }
+
+  inline bool operator<(const SerializedATNView &lhs, const SerializedATNView &rhs) {
+    int diff = std::memcmp(lhs.data(), rhs.data(), std::min(lhs.size_bytes(), rhs.size_bytes()));
+    return diff < 0 || (diff == 0 && lhs.size() < rhs.size());
+  }
+
+}  // namespace atn
+}  // namespace antlr4
+
+namespace std {
+
+  template <>
+  struct hash<::antlr4::atn::SerializedATNView> {
+    size_t operator()(const ::antlr4::atn::SerializedATNView &serializedATNView) const {
+      return ::antlr4::misc::MurmurHash::hashCode(serializedATNView.data(), serializedATNView.size());
+    }
+  };
+
+}  // namespace std

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

@@ -11,12 +11,8 @@
 using namespace antlr4;
 using namespace antlr4::atn;
 
-SetTransition::SetTransition(ATNState *target, const misc::IntervalSet &aSet)
-  : Transition(target), set(aSet.isEmpty() ? misc::IntervalSet::of(Token::INVALID_TYPE) : aSet) {
-}
-
-Transition::SerializationType SetTransition::getSerializationType() const {
-  return SET;
+SetTransition::SetTransition(TransitionType transitionType, ATNState *target, misc::IntervalSet aSet)
+  : Transition(transitionType, target), set(aSet.isEmpty() ? misc::IntervalSet::of(Token::INVALID_TYPE) : std::move(aSet)) {
 }
 
 misc::IntervalSet SetTransition::label() const {

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

@@ -14,16 +14,24 @@ namespace atn {
   /// A transition containing a set of values. </summary>
   class ANTLR4CPP_PUBLIC SetTransition : public Transition {
   public:
-    const misc::IntervalSet set;
+    static bool is(const Transition &transition) {
+      const auto transitionType = transition.getTransitionType();
+      return transitionType == TransitionType::SET || transitionType == TransitionType::NOT_SET;
+    }
+
+    static bool is(const Transition *transition) { return transition != nullptr && is(*transition); }
 
-    SetTransition(ATNState *target, const misc::IntervalSet &set);
+    const misc::IntervalSet set;
 
-    virtual SerializationType getSerializationType() const override;
+    SetTransition(ATNState *target, misc::IntervalSet set) : SetTransition(TransitionType::SET, target, std::move(set)) {}
 
     virtual misc::IntervalSet label() const override;
     virtual bool matches(size_t symbol, size_t minVocabSymbol, size_t maxVocabSymbol) const override;
 
     virtual std::string toString() const override;
+
+  protected:
+    SetTransition(TransitionType transitionType, ATNState *target, misc::IntervalSet set);
   };
 
 } // namespace atn

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

@@ -3,69 +3,74 @@
  * can be found in the LICENSE.txt file in the project root.
  */
 
-#include "atn/EmptyPredictionContext.h"
-
 #include "atn/SingletonPredictionContext.h"
 
+#include "support/Casts.h"
+#include "misc/MurmurHash.h"
+
 using namespace antlr4::atn;
+using namespace antlrcpp;
 
-SingletonPredictionContext::SingletonPredictionContext(Ref<PredictionContext> const& parent, size_t returnState)
-  : PredictionContext(parent ? calculateHashCode(parent, returnState) : calculateEmptyHashCode()),
-    parent(parent), returnState(returnState) {
-  assert(returnState != ATNState::INVALID_STATE_NUMBER);
-}
+namespace {
+
+  bool cachedHashCodeEqual(size_t lhs, size_t rhs) {
+    return lhs == rhs || lhs == 0 || rhs == 0;
+  }
 
-SingletonPredictionContext::~SingletonPredictionContext() {
 }
 
-Ref<SingletonPredictionContext> SingletonPredictionContext::create(Ref<PredictionContext> const& parent, size_t returnState) {
+SingletonPredictionContext::SingletonPredictionContext(Ref<const PredictionContext> parent, size_t returnState)
+    : PredictionContext(PredictionContextType::SINGLETON), parent(std::move(parent)), returnState(returnState) {
+  assert(returnState != ATNState::INVALID_STATE_NUMBER);
+}
 
-  if (returnState == EMPTY_RETURN_STATE && parent) {
+Ref<const SingletonPredictionContext> SingletonPredictionContext::create(Ref<const PredictionContext> parent, size_t returnState) {
+  if (returnState == EMPTY_RETURN_STATE && parent == nullptr) {
     // someone can pass in the bits of an array ctx that mean $
-    return std::dynamic_pointer_cast<SingletonPredictionContext>(EMPTY);
+    return std::dynamic_pointer_cast<const SingletonPredictionContext>(EMPTY);
   }
-  return std::make_shared<SingletonPredictionContext>(parent, returnState);
+  return std::make_shared<SingletonPredictionContext>(std::move(parent), returnState);
+}
+
+bool SingletonPredictionContext::isEmpty() const {
+  return parent == nullptr && returnState == EMPTY_RETURN_STATE;
 }
 
 size_t SingletonPredictionContext::size() const {
   return 1;
 }
 
-Ref<PredictionContext> SingletonPredictionContext::getParent(size_t index) const {
+const Ref<const PredictionContext>& SingletonPredictionContext::getParent(size_t index) const {
   assert(index == 0);
-  ((void)(index)); // Make Release build happy.
+  static_cast<void>(index);
   return parent;
 }
 
 size_t SingletonPredictionContext::getReturnState(size_t index) const {
   assert(index == 0);
-  ((void)(index)); // Make Release build happy.
+  static_cast<void>(index);
   return returnState;
 }
 
-bool SingletonPredictionContext::operator == (const PredictionContext &o) const {
-  if (this == &o) {
+size_t SingletonPredictionContext::hashCodeImpl() const {
+  size_t hash = misc::MurmurHash::initialize();
+  hash = misc::MurmurHash::update(hash, static_cast<size_t>(getContextType()));
+  hash = misc::MurmurHash::update(hash, parent);
+  hash = misc::MurmurHash::update(hash, returnState);
+  return misc::MurmurHash::finish(hash, 3);
+}
+
+bool SingletonPredictionContext::equals(const PredictionContext &other) const {
+  if (this == std::addressof(other)) {
     return true;
   }
-
-  const SingletonPredictionContext *other = dynamic_cast<const SingletonPredictionContext*>(&o);
-  if (other == nullptr) {
+  if (getContextType() != other.getContextType()) {
     return false;
   }
-
-  if (this->hashCode() != other->hashCode()) {
-    return false; // can't be same if hash is different
-  }
-
-  if (returnState != other->returnState)
-    return false;
-
-  if (!parent && !other->parent)
-    return true;
-  if (!parent || !other->parent)
-    return false;
-
-   return *parent == *other->parent;
+  const auto &singleton = downCast<const SingletonPredictionContext&>(other);
+  return returnState == singleton.returnState &&
+         cachedHashCodeEqual(cachedHashCode(), singleton.cachedHashCode()) &&
+         (parent == singleton.parent || (parent != nullptr && singleton.parent != nullptr && *parent == *singleton.parent));
 }
 
 std::string SingletonPredictionContext::toString() const {

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

@@ -10,26 +10,33 @@
 namespace antlr4 {
 namespace atn {
 
-  class ANTLR4CPP_PUBLIC SingletonPredictionContext : public PredictionContext {
+  class ANTLR4CPP_PUBLIC SingletonPredictionContext final : public PredictionContext {
   public:
+    static bool is(const PredictionContext &predictionContext) { return predictionContext.getContextType() == PredictionContextType::SINGLETON; }
+
+    static bool is(const PredictionContext *predictionContext) { return predictionContext != nullptr && is(*predictionContext); }
+
+    static Ref<const SingletonPredictionContext> create(Ref<const PredictionContext> parent, size_t returnState);
+
     // Usually a parent is linked via a weak ptr. Not so here as we have kinda reverse reference chain.
     // There are no child contexts stored here and often the parent context is left dangling when it's
     // owning ATNState is released. In order to avoid having this context released as well (leaving all other contexts
     // which got this one as parent with a null reference) we use a shared_ptr here instead, to keep those left alone
     // parent contexts alive.
-    const Ref<PredictionContext> parent;
+    const Ref<const PredictionContext> parent;
     const size_t returnState;
 
-    SingletonPredictionContext(Ref<PredictionContext> const& parent, size_t returnState);
-    virtual ~SingletonPredictionContext();
+    SingletonPredictionContext(Ref<const PredictionContext> parent, size_t returnState);
 
-    static Ref<SingletonPredictionContext> create(Ref<PredictionContext> const& parent, size_t returnState);
+    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 size_t size() const override;
-    virtual Ref<PredictionContext> getParent(size_t index) const override;
-    virtual size_t getReturnState(size_t index) const override;
-    virtual bool operator == (const PredictionContext &o) 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/StarBlockStartState.h

@@ -12,9 +12,12 @@ namespace atn {
 
   /// The block that begins a closure loop.
   class ANTLR4CPP_PUBLIC StarBlockStartState final : public BlockStartState {
-
   public:
-    virtual size_t getStateType() override;
+    static bool is(const ATNState &atnState) { return atnState.getStateType() == ATNStateType::STAR_BLOCK_START; }
+
+    static bool is(const ATNState *atnState) { return atnState != nullptr && is(*atnState); }
+
+    StarBlockStartState() : BlockStartState(ATNStateType::STAR_BLOCK_START) {}
   };
 
 } // namespace atn

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

@@ -12,7 +12,9 @@ namespace atn {
 
   class ANTLR4CPP_PUBLIC StarLoopEntryState final : public DecisionState {
   public:
-    StarLoopEntryState();
+    static bool is(const ATNState &atnState) { return atnState.getStateType() == ATNStateType::STAR_LOOP_ENTRY; }
+
+    static bool is(const ATNState *atnState) { return atnState != nullptr && is(*atnState); }
 
     /**
      * Indicates whether this state can benefit from a precedence DFA during SLL
@@ -28,7 +30,7 @@ namespace atn {
 
     StarLoopbackState *loopBackState = nullptr;
 
-    virtual size_t getStateType() override;
+    StarLoopEntryState() : DecisionState(ATNStateType::STAR_LOOP_ENTRY) {}
   };
 
 } // namespace atn

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

@@ -5,15 +5,15 @@
 
 #include "atn/StarLoopEntryState.h"
 #include "atn/Transition.h"
+#include "support/Casts.h"
 
 #include "atn/StarLoopbackState.h"
 
 using namespace antlr4::atn;
 
-StarLoopEntryState *StarLoopbackState::getLoopEntryState() {
-  return dynamic_cast<StarLoopEntryState *>(transitions[0]->target);
-}
-
-size_t StarLoopbackState::getStateType() {
-  return STAR_LOOP_BACK;
+StarLoopEntryState *StarLoopbackState::getLoopEntryState() const {
+  if (transitions[0]->target != nullptr && transitions[0]->target->getStateType() == ATNStateType::STAR_LOOP_ENTRY) {
+    return antlrcpp::downCast<StarLoopEntryState*>(transitions[0]->target);
+  }
+  return nullptr;
 }