expressir 1.2.3 → 1.2.6

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

@@ -26,6 +26,7 @@
 #include "tree/ErrorNode.h"
 
 #include "support/CPPUtils.h"
+#include "support/Casts.h"
 
 #include "ParserInterpreter.h"
 
@@ -35,19 +36,10 @@ using namespace antlr4::misc;
 
 using namespace antlrcpp;
 
-ParserInterpreter::ParserInterpreter(const std::string &grammarFileName, const std::vector<std::string>& tokenNames,
-  const std::vector<std::string>& ruleNames, const atn::ATN &atn, TokenStream *input)
-  : ParserInterpreter(grammarFileName, dfa::Vocabulary::fromTokenNames(tokenNames), ruleNames, atn, input) {
-}
-
 ParserInterpreter::ParserInterpreter(const std::string &grammarFileName, const dfa::Vocabulary &vocabulary,
   const std::vector<std::string> &ruleNames, const atn::ATN &atn, TokenStream *input)
   : Parser(input), _grammarFileName(grammarFileName), _atn(atn), _ruleNames(ruleNames), _vocabulary(vocabulary) {
 
-  for (size_t i = 0; i < atn.maxTokenType; ++i) {
-    _tokenNames.push_back(vocabulary.getDisplayName(i));
-  }
-
   // init decision DFA
   for (size_t i = 0; i < atn.getNumberOfDecisions(); ++i) {
     atn::DecisionState *decisionState = atn.getDecisionState(i);
@@ -72,10 +64,6 @@ const atn::ATN& ParserInterpreter::getATN() const {
   return _atn;
 }
 
-const std::vector<std::string>& ParserInterpreter::getTokenNames() const {
-  return _tokenNames;
-}
-
 const dfa::Vocabulary& ParserInterpreter::getVocabulary() const {
   return _vocabulary;
 }
@@ -102,7 +90,7 @@ ParserRuleContext* ParserInterpreter::parse(size_t startRuleIndex) {
   while (true) {
     atn::ATNState *p = getATNState();
     switch (p->getStateType()) {
-      case atn::ATNState::RULE_STOP :
+      case atn::ATNStateType::RULE_STOP :
         // pop; return from rule
         if (_ctx->isEmpty()) {
           if (startRuleStartState->isLeftRecursiveRule) {
@@ -161,16 +149,16 @@ atn::ATNState* ParserInterpreter::getATNState() {
 
 void ParserInterpreter::visitState(atn::ATNState *p) {
   size_t predictedAlt = 1;
-  if (is<DecisionState *>(p)) {
-    predictedAlt = visitDecisionState(dynamic_cast<DecisionState *>(p));
+  if (DecisionState::is(p)) {
+    predictedAlt = visitDecisionState(downCast<DecisionState*>(p));
   }
 
-  atn::Transition *transition = p->transitions[predictedAlt - 1];
-  switch (transition->getSerializationType()) {
-    case atn::Transition::EPSILON:
-      if (p->getStateType() == ATNState::STAR_LOOP_ENTRY &&
-        (dynamic_cast<StarLoopEntryState *>(p))->isPrecedenceDecision &&
-        !is<LoopEndState *>(transition->target)) {
+  const atn::Transition *transition = p->transitions[predictedAlt - 1].get();
+  switch (transition->getTransitionType()) {
+    case atn::TransitionType::EPSILON:
+      if (p->getStateType() == ATNStateType::STAR_LOOP_ENTRY &&
+        (downCast<StarLoopEntryState *>(p))->isPrecedenceDecision &&
+        !LoopEndState::is(transition->target)) {
         // We are at the start of a left recursive rule's (...)* loop
         // and we're not taking the exit branch of loop.
         InterpreterRuleContext *localctx = createInterpreterRuleContext(_parentContextStack.top().first,
@@ -179,56 +167,56 @@ void ParserInterpreter::visitState(atn::ATNState *p) {
       }
       break;
 
-    case atn::Transition::ATOM:
-      match(static_cast<int>(static_cast<atn::AtomTransition*>(transition)->_label));
+    case atn::TransitionType::ATOM:
+      match(static_cast<int>(static_cast<const atn::AtomTransition*>(transition)->_label));
       break;
 
-    case atn::Transition::RANGE:
-    case atn::Transition::SET:
-    case atn::Transition::NOT_SET:
+    case atn::TransitionType::RANGE:
+    case atn::TransitionType::SET:
+    case atn::TransitionType::NOT_SET:
       if (!transition->matches(static_cast<int>(_input->LA(1)), Token::MIN_USER_TOKEN_TYPE, Lexer::MAX_CHAR_VALUE)) {
         recoverInline();
       }
       matchWildcard();
       break;
 
-    case atn::Transition::WILDCARD:
+    case atn::TransitionType::WILDCARD:
       matchWildcard();
       break;
 
-    case atn::Transition::RULE:
+    case atn::TransitionType::RULE:
     {
       atn::RuleStartState *ruleStartState = static_cast<atn::RuleStartState*>(transition->target);
       size_t ruleIndex = ruleStartState->ruleIndex;
       InterpreterRuleContext *newctx = createInterpreterRuleContext(_ctx, p->stateNumber, ruleIndex);
       if (ruleStartState->isLeftRecursiveRule) {
-        enterRecursionRule(newctx, ruleStartState->stateNumber, ruleIndex, static_cast<atn::RuleTransition*>(transition)->precedence);
+        enterRecursionRule(newctx, ruleStartState->stateNumber, ruleIndex, static_cast<const atn::RuleTransition*>(transition)->precedence);
       } else {
         enterRule(newctx, transition->target->stateNumber, ruleIndex);
       }
     }
       break;
 
-    case atn::Transition::PREDICATE:
+    case atn::TransitionType::PREDICATE:
     {
-      atn::PredicateTransition *predicateTransition = static_cast<atn::PredicateTransition*>(transition);
-      if (!sempred(_ctx, predicateTransition->ruleIndex, predicateTransition->predIndex)) {
+      const atn::PredicateTransition *predicateTransition = static_cast<const atn::PredicateTransition*>(transition);
+      if (!sempred(_ctx, predicateTransition->getRuleIndex(), predicateTransition->getPredIndex())) {
         throw FailedPredicateException(this);
       }
     }
       break;
 
-    case atn::Transition::ACTION:
+    case atn::TransitionType::ACTION:
     {
-      atn::ActionTransition *actionTransition = static_cast<atn::ActionTransition*>(transition);
+      const atn::ActionTransition *actionTransition = static_cast<const atn::ActionTransition*>(transition);
       action(_ctx, actionTransition->ruleIndex, actionTransition->actionIndex);
     }
       break;
 
-    case atn::Transition::PRECEDENCE:
+    case atn::TransitionType::PRECEDENCE:
     {
-      if (!precpred(_ctx, static_cast<atn::PrecedencePredicateTransition*>(transition)->precedence)) {
-        throw FailedPredicateException(this, "precpred(_ctx, " + std::to_string(static_cast<atn::PrecedencePredicateTransition*>(transition)->precedence) +  ")");
+      if (!precpred(_ctx, static_cast<const atn::PrecedencePredicateTransition*>(transition)->getPrecedence())) {
+        throw FailedPredicateException(this, "precpred(_ctx, " + std::to_string(static_cast<const atn::PrecedencePredicateTransition*>(transition)->getPrecedence()) +  ")");
       }
     }
       break;
@@ -272,7 +260,7 @@ void ParserInterpreter::visitRuleStopState(atn::ATNState *p) {
     exitRule();
   }
 
-  atn::RuleTransition *ruleTransition = static_cast<atn::RuleTransition*>(_atn.states[getState()]->transitions[0]);
+  const atn::RuleTransition *ruleTransition = static_cast<const atn::RuleTransition*>(_atn.states[getState()]->transitions[0].get());
   setState(ruleTransition->followState->stateNumber);
 }
 

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

@@ -9,6 +9,7 @@
 #include "atn/ATN.h"
 #include "support/BitSet.h"
 #include "atn/PredictionContext.h"
+#include "atn/PredictionContextCache.h"
 #include "Vocabulary.h"
 
 namespace antlr4 {
@@ -29,9 +30,6 @@ namespace antlr4 {
   /// </summary>
   class ANTLR4CPP_PUBLIC ParserInterpreter : public Parser {
   public:
-    // @deprecated
-    ParserInterpreter(const std::string &grammarFileName, const std::vector<std::string>& tokenNames,
-      const std::vector<std::string>& ruleNames, const atn::ATN &atn, TokenStream *input);
     ParserInterpreter(const std::string &grammarFileName, const dfa::Vocabulary &vocabulary,
                       const std::vector<std::string> &ruleNames, const atn::ATN &atn, TokenStream *input);
     ~ParserInterpreter();
@@ -40,9 +38,6 @@ namespace antlr4 {
 
     virtual const atn::ATN& getATN() const override;
 
-    // @deprecated
-    virtual const std::vector<std::string>& getTokenNames() const override;
-
     virtual const dfa::Vocabulary& getVocabulary() const override;
 
     virtual const std::vector<std::string>& getRuleNames() const override;
@@ -110,7 +105,6 @@ namespace antlr4 {
 
   protected:
     const std::string _grammarFileName;
-    std::vector<std::string> _tokenNames;
     const atn::ATN &_atn;
 
     std::vector<std::string> _ruleNames;

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

@@ -9,6 +9,7 @@
 #include "Parser.h"
 #include "Token.h"
 
+#include "support/Casts.h"
 #include "support/CPPUtils.h"
 
 #include "ParserRuleContext.h"
@@ -38,11 +39,10 @@ void ParserRuleContext::copyFrom(ParserRuleContext *ctx) {
 
   // copy any error nodes to alt label node
   if (!ctx->children.empty()) {
-    for (auto child : ctx->children) {
-      auto errorNode = dynamic_cast<ErrorNode *>(child);
-      if (errorNode != nullptr) {
-        errorNode->setParent(this);
-        children.push_back(errorNode);
+    for (auto *child : ctx->children) {
+      if (ErrorNode::is(child)) {
+        downCast<ErrorNode*>(child)->setParent(this);
+        children.push_back(child);
       }
     }
 
@@ -76,39 +76,36 @@ void ParserRuleContext::removeLastChild() {
   }
 }
 
-tree::TerminalNode* ParserRuleContext::getToken(size_t ttype, size_t i) {
+tree::TerminalNode* ParserRuleContext::getToken(size_t ttype, size_t i) const {
   if (i >= children.size()) {
     return nullptr;
   }
-
   size_t j = 0; // what token with ttype have we found?
-  for (auto o : children) {
-    if (is<tree::TerminalNode *>(o)) {
-      tree::TerminalNode *tnode = dynamic_cast<tree::TerminalNode *>(o);
-      Token *symbol = tnode->getSymbol();
+  for (auto *child : children) {
+    if (TerminalNode::is(child)) {
+      tree::TerminalNode *typedChild = downCast<tree::TerminalNode*>(child);
+      Token *symbol = typedChild->getSymbol();
       if (symbol->getType() == ttype) {
         if (j++ == i) {
-          return tnode;
+          return typedChild;
         }
       }
     }
   }
-
   return nullptr;
 }
 
-std::vector<tree::TerminalNode *> ParserRuleContext::getTokens(size_t ttype) {
-  std::vector<tree::TerminalNode *> tokens;
-  for (auto &o : children) {
-    if (is<tree::TerminalNode *>(o)) {
-      tree::TerminalNode *tnode = dynamic_cast<tree::TerminalNode *>(o);
-      Token *symbol = tnode->getSymbol();
+std::vector<tree::TerminalNode *> ParserRuleContext::getTokens(size_t ttype) const {
+  std::vector<tree::TerminalNode*> tokens;
+  for (auto *child : children) {
+    if (TerminalNode::is(child)) {
+      tree::TerminalNode *typedChild = downCast<tree::TerminalNode*>(child);
+      Token *symbol = typedChild->getSymbol();
       if (symbol->getType() == ttype) {
-        tokens.push_back(tnode);
+        tokens.push_back(typedChild);
       }
     }
   }
-
   return tokens;
 }
 
@@ -123,11 +120,11 @@ misc::Interval ParserRuleContext::getSourceInterval() {
   return misc::Interval(start->getTokenIndex(), stop->getTokenIndex());
 }
 
-Token* ParserRuleContext::getStart() {
+Token* ParserRuleContext::getStart() const {
   return start;
 }
 
-Token* ParserRuleContext::getStop() {
+Token* ParserRuleContext::getStop() const {
   return stop;
 }
 

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

@@ -67,7 +67,6 @@ namespace antlr4 {
 
     ParserRuleContext();
     ParserRuleContext(ParserRuleContext *parent, size_t invokingStateNumber);
-    virtual ~ParserRuleContext() {}
 
     /** COPY a ctx (I'm deliberately not using copy constructor) to avoid
      *  confusion with creating node with parent. Does not copy children
@@ -88,23 +87,22 @@ namespace antlr4 {
     /// Used by enterOuterAlt to toss out a RuleContext previously added as
     /// we entered a rule. If we have # label, we will need to remove
     /// generic ruleContext object.
-    virtual void removeLastChild();
+    void removeLastChild();
 
-    virtual tree::TerminalNode* getToken(size_t ttype, std::size_t i);
+    tree::TerminalNode* getToken(size_t ttype, std::size_t i) const;
 
-    virtual std::vector<tree::TerminalNode *> getTokens(size_t ttype);
+    std::vector<tree::TerminalNode*> getTokens(size_t ttype) const;
 
     template<typename T>
-    T* getRuleContext(size_t i) {
-      if (children.empty()) {
-        return nullptr;
-      }
-
+    T* getRuleContext(size_t i) const {
+      static_assert(std::is_base_of_v<RuleContext, T>, "T must be derived from RuleContext");
       size_t j = 0; // what element have we found with ctxType?
-      for (auto &child : children) {
-        if (antlrcpp::is<T *>(child)) {
-          if (j++ == i) {
-            return dynamic_cast<T *>(child);
+      for (auto *child : children) {
+        if (RuleContext::is(child)) {
+          if (auto *typedChild = dynamic_cast<T*>(child); typedChild != nullptr) {
+            if (j++ == i) {
+              return typedChild;
+            }
           }
         }
       }
@@ -112,14 +110,16 @@ namespace antlr4 {
     }
 
     template<typename T>
-    std::vector<T *> getRuleContexts() {
-      std::vector<T *> contexts;
-      for (auto child : children) {
-        if (antlrcpp::is<T *>(child)) {
-          contexts.push_back(dynamic_cast<T *>(child));
+    std::vector<T*> getRuleContexts() const {
+      static_assert(std::is_base_of_v<RuleContext, T>, "T must be derived from RuleContext");
+      std::vector<T*> contexts;
+      for (auto *child : children) {
+        if (RuleContext::is(child)) {
+          if (auto *typedChild = dynamic_cast<T*>(child); typedChild != nullptr) {
+            contexts.push_back(typedChild);
+          }
         }
       }
-
       return contexts;
     }
 
@@ -130,14 +130,14 @@ namespace antlr4 {
      * Note that the range from start to stop is inclusive, so for rules that do not consume anything
      * (for example, zero length or error productions) this token may exceed stop.
      */
-    virtual Token *getStart();
+    Token* getStart() const;
 
     /**
      * Get the final token in this context.
      * Note that the range from start to stop is inclusive, so for rules that do not consume anything
      * (for example, zero length or error productions) this token may precede start.
      */
-    virtual Token *getStop();
+    Token* getStop() const;
 
     /// <summary>
     /// Used for rule context info debugging during parse-time, not so much for ATN debugging </summary>

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

@@ -26,28 +26,28 @@ void ProxyErrorListener::removeErrorListeners() {
 void ProxyErrorListener::syntaxError(Recognizer *recognizer, Token *offendingSymbol, size_t line,
   size_t charPositionInLine, const std::string &msg, std::exception_ptr e) {
 
-  for (auto listener : _delegates) {
+  for (auto *listener : _delegates) {
     listener->syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, e);
   }
 }
 
 void ProxyErrorListener::reportAmbiguity(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex, size_t stopIndex,
   bool exact, const antlrcpp::BitSet &ambigAlts, atn::ATNConfigSet *configs) {
-  for (auto listener : _delegates) {
+  for (auto *listener : _delegates) {
     listener->reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs);
   }
 }
 
 void ProxyErrorListener::reportAttemptingFullContext(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex,
   size_t stopIndex, const antlrcpp::BitSet &conflictingAlts, atn::ATNConfigSet *configs) {
-  for (auto listener : _delegates) {
+  for (auto *listener : _delegates) {
     listener->reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs);
   }
 }
 
 void ProxyErrorListener::reportContextSensitivity(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex, size_t stopIndex,
   size_t prediction, atn::ATNConfigSet *configs) {
-  for (auto listener : _delegates) {
+  for (auto *listener : _delegates) {
     listener->reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs);
   }
 }

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

@@ -5,7 +5,6 @@
 
 #include "atn/ATN.h"
 #include "Recognizer.h"
-#include "support/StringUtils.h"
 #include "ParserRuleContext.h"
 #include "misc/IntervalSet.h"
 

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

@@ -6,11 +6,11 @@
 #include "ConsoleErrorListener.h"
 #include "RecognitionException.h"
 #include "support/CPPUtils.h"
-#include "support/StringUtils.h"
 #include "Token.h"
 #include "atn/ATN.h"
 #include "atn/ATNSimulator.h"
 #include "support/CPPUtils.h"
+#include "support/StringUtils.h"
 
 #include "Vocabulary.h"
 
@@ -19,7 +19,7 @@
 using namespace antlr4;
 using namespace antlr4::atn;
 
-std::map<const dfa::Vocabulary*, std::map<std::string, size_t>> Recognizer::_tokenTypeMapCache;
+std::map<const dfa::Vocabulary*, std::map<std::string_view, size_t>> Recognizer::_tokenTypeMapCache;
 std::map<std::vector<std::string>, std::map<std::string, size_t>> Recognizer::_ruleIndexMapCache;
 
 Recognizer::Recognizer() {
@@ -30,31 +30,26 @@ Recognizer::Recognizer() {
 Recognizer::~Recognizer() {
 }
 
-dfa::Vocabulary const& Recognizer::getVocabulary() const {
-  static dfa::Vocabulary vocabulary = dfa::Vocabulary::fromTokenNames(getTokenNames());
-  return vocabulary;
-}
-
-std::map<std::string, size_t> Recognizer::getTokenTypeMap() {
+std::map<std::string_view, size_t> Recognizer::getTokenTypeMap() {
   const dfa::Vocabulary& vocabulary = getVocabulary();
 
   std::lock_guard<std::mutex> lck(_mutex);
-  std::map<std::string, size_t> result;
+  std::map<std::string_view, size_t> result;
   auto iterator = _tokenTypeMapCache.find(&vocabulary);
   if (iterator != _tokenTypeMapCache.end()) {
     result = iterator->second;
   } else {
     for (size_t i = 0; i <= getATN().maxTokenType; ++i) {
-      std::string literalName = vocabulary.getLiteralName(i);
+      std::string_view literalName = vocabulary.getLiteralName(i);
       if (!literalName.empty()) {
         result[literalName] = i;
       }
 
-      std::string symbolicName = vocabulary.getSymbolicName(i);
+      std::string_view symbolicName = vocabulary.getSymbolicName(i);
       if (!symbolicName.empty()) {
         result[symbolicName] = i;
       }
-				}
+    }
     result["EOF"] = EOF;
     _tokenTypeMapCache[&vocabulary] = result;
   }
@@ -80,8 +75,8 @@ std::map<std::string, size_t> Recognizer::getRuleIndexMap() {
   return result;
 }
 
-size_t Recognizer::getTokenType(const std::string &tokenName) {
-  const std::map<std::string, size_t> &map = getTokenTypeMap();
+size_t Recognizer::getTokenType(std::string_view tokenName) {
+  const std::map<std::string_view, size_t> &map = getTokenTypeMap();
   auto iterator = map.find(tokenName);
   if (iterator == map.end())
     return Token::INVALID_TYPE;
@@ -118,11 +113,13 @@ std::string Recognizer::getTokenErrorDisplay(Token *t) {
     }
   }
 
-  antlrcpp::replaceAll(s, "\n", "\\n");
-  antlrcpp::replaceAll(s, "\r","\\r");
-  antlrcpp::replaceAll(s, "\t", "\\t");
-
-  return "'" + s + "'";
+  std::string result;
+  result.reserve(s.size() + 2);
+  result.push_back('\'');
+  antlrcpp::escapeWhitespace(result, s);
+  result.push_back('\'');
+  result.shrink_to_fit();
+  return result;
 }
 
 void Recognizer::addErrorListener(ANTLRErrorListener *listener) {
@@ -152,14 +149,6 @@ bool Recognizer::precpred(RuleContext * /*localctx*/, int /*precedence*/) {
 void Recognizer::action(RuleContext * /*localctx*/, size_t /*ruleIndex*/, size_t /*actionIndex*/) {
 }
 
-size_t Recognizer::getState() const {
-  return _stateNumber;
-}
-
-void Recognizer::setState(size_t atnState) {
-  _stateNumber = atnState;
-}
-
 void Recognizer::InitializeInstanceFields() {
   _stateNumber = ATNState::INVALID_STATE_NUMBER;
   _interpreter = nullptr;

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

@@ -6,12 +6,14 @@
 #pragma once
 
 #include "ProxyErrorListener.h"
+#include "support/Casts.h"
+#include "atn/SerializedATNView.h"
 
 namespace antlr4 {
 
   class ANTLR4CPP_PUBLIC Recognizer {
   public:
-    static const size_t EOF = static_cast<size_t>(-1); // std::numeric_limits<size_t>::max(); doesn't work in VS 2013.
+    static constexpr size_t EOF = std::numeric_limits<size_t>::max();
 
     Recognizer();
     Recognizer(Recognizer const&) = delete;
@@ -19,13 +21,6 @@ namespace antlr4 {
 
     Recognizer& operator=(Recognizer const&) = delete;
 
-    /** Used to print out token names like ID during debugging and
-     *  error reporting.  The generated parsers implement a method
-     *  that overrides this to point to their String[] tokenNames.
-     *
-     * @deprecated Use {@link #getVocabulary()} instead.
-     */
-    virtual std::vector<std::string> const& getTokenNames() const = 0;
     virtual std::vector<std::string> const& getRuleNames() const = 0;
 
     /**
@@ -34,14 +29,14 @@ namespace antlr4 {
      * @return A {@link Vocabulary} instance providing information about the
      * vocabulary used by the grammar.
      */
-    virtual dfa::Vocabulary const& getVocabulary() const;
+    virtual dfa::Vocabulary const& getVocabulary() const = 0;
 
     /// <summary>
     /// Get a map from token names to token types.
     /// <p/>
     /// Used for XPath and tree pattern compilation.
     /// </summary>
-    virtual std::map<std::string, size_t> getTokenTypeMap();
+    virtual std::map<std::string_view, size_t> getTokenTypeMap();
 
     /// <summary>
     /// Get a map from rule names to rule indexes.
@@ -50,7 +45,7 @@ namespace antlr4 {
     /// </summary>
     virtual std::map<std::string, size_t> getRuleIndexMap();
 
-    virtual size_t getTokenType(const std::string &tokenName);
+    virtual size_t getTokenType(std::string_view tokenName);
 
     /// <summary>
     /// If this recognizer was generated, it will have a serialized ATN
@@ -59,7 +54,7 @@ namespace antlr4 {
     /// For interpreters, we don't know their serialized ATN despite having
     /// created the interpreter from it.
     /// </summary>
-    virtual const std::vector<uint16_t> getSerializedATN() const {
+    virtual atn::SerializedATNView getSerializedATN() const {
       throw "there is no serialized ATN";
     }
 
@@ -73,7 +68,7 @@ namespace antlr4 {
     /// @returns The ATN interpreter used by the recognizer for prediction.
     template <class T>
     T* getInterpreter() const {
-      return dynamic_cast<T *>(_interpreter);
+      return antlrcpp::downCast<T *>(_interpreter);
     }
 
     /**
@@ -119,7 +114,7 @@ namespace antlr4 {
 
     virtual void action(RuleContext *localctx, size_t ruleIndex, size_t actionIndex);
 
-    virtual size_t getState() const ;
+    size_t getState() const { return _stateNumber; }
 
     // Get the ATN used by the recognizer for prediction.
     virtual const atn::ATN& getATN() const = 0;
@@ -132,13 +127,13 @@ namespace antlr4 {
     ///  invoking rules. Combine this and we have complete ATN
     ///  configuration information.
     /// </summary>
-    void setState(size_t atnState);
+    void setState(size_t atnState) { _stateNumber = atnState; }
 
     virtual IntStream* getInputStream() = 0;
 
     virtual void setInputStream(IntStream *input) = 0;
 
-    virtual Ref<TokenFactory<CommonToken>> getTokenFactory() = 0;
+    virtual TokenFactory<CommonToken>* getTokenFactory() = 0;
 
     template<typename T1>
     void setTokenFactory(TokenFactory<T1> *input);
@@ -150,7 +145,7 @@ namespace antlr4 {
     std::mutex _mutex;
 
   private:
-    static std::map<const dfa::Vocabulary*, std::map<std::string, size_t>> _tokenTypeMapCache;
+    static std::map<const dfa::Vocabulary*, std::map<std::string_view, size_t>> _tokenTypeMapCache;
     static std::map<std::vector<std::string>, std::map<std::string, size_t>> _ruleIndexMapCache;
 
     ProxyErrorListener _proxListener; // Manages a collection of listeners.

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

@@ -14,12 +14,13 @@
 
 using namespace antlr4;
 using namespace antlr4::atn;
+using namespace antlr4::tree;
 
-RuleContext::RuleContext() {
+RuleContext::RuleContext() : ParseTree(ParseTreeType::RULE) {
   InitializeInstanceFields();
 }
 
-RuleContext::RuleContext(RuleContext *parent_, size_t invokingState_) {
+RuleContext::RuleContext(RuleContext *parent_, size_t invokingState_) : ParseTree(ParseTreeType::RULE) {
   InitializeInstanceFields();
   this->parent = parent_;
   this->invokingState = invokingState_;
@@ -71,7 +72,7 @@ size_t RuleContext::getAltNumber() const {
 void RuleContext::setAltNumber(size_t /*altNumber*/) {
 }
 
-antlrcpp::Any RuleContext::accept(tree::ParseTreeVisitor *visitor) {
+std::any RuleContext::accept(tree::ParseTreeVisitor *visitor) {
   return visitor->visitChildren(this);
 }
 

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

@@ -61,6 +61,10 @@ namespace antlr4 {
    */
   class ANTLR4CPP_PUBLIC RuleContext : public tree::ParseTree {
   public:
+    static bool is(const tree::ParseTree &parseTree) { return parseTree.getTreeType() == tree::ParseTreeType::RULE; }
+
+    static bool is(const tree::ParseTree *parseTree) { return parseTree != nullptr && is(*parseTree); }
+
     /// What state invoked the rule associated with this context?
     /// The "return address" is the followState of invokingState
     /// If parent is null, this should be -1 and this context object represents the start rule.
@@ -103,7 +107,7 @@ namespace antlr4 {
      */
     virtual void setAltNumber(size_t altNumber);
 
-    virtual antlrcpp::Any accept(tree::ParseTreeVisitor *visitor) override;
+    virtual std::any accept(tree::ParseTreeVisitor *visitor) override;
 
     /// <summary>
     /// Print out a whole tree, not just a node, in LISP format