expressir 0.2.5-x64-mingw32 → 0.2.7-x64-mingw32

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

@@ -1,306 +0,0 @@
-/* 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.
- */
-
-#include "dfa/DFA.h"
-#include "atn/RuleStartState.h"
-#include "InterpreterRuleContext.h"
-#include "atn/ParserATNSimulator.h"
-#include "ANTLRErrorStrategy.h"
-#include "atn/LoopEndState.h"
-#include "FailedPredicateException.h"
-#include "atn/StarLoopEntryState.h"
-#include "atn/AtomTransition.h"
-#include "atn/RuleTransition.h"
-#include "atn/PredicateTransition.h"
-#include "atn/PrecedencePredicateTransition.h"
-#include "atn/ActionTransition.h"
-#include "atn/ATN.h"
-#include "atn/RuleStopState.h"
-#include "Lexer.h"
-#include "Token.h"
-#include "Vocabulary.h"
-#include "InputMismatchException.h"
-#include "CommonToken.h"
-#include "tree/ErrorNode.h"
-
-#include "support/CPPUtils.h"
-
-#include "ParserInterpreter.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-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);
-    _decisionToDFA.push_back(dfa::DFA(decisionState, i));
-  }
-
-  // get atn simulator that knows how to do predictions
-  _interpreter = new atn::ParserATNSimulator(this, atn, _decisionToDFA, _sharedContextCache); /* mem-check: deleted in d-tor */
-}
-
-ParserInterpreter::~ParserInterpreter() {
-  delete _interpreter;
-}
-
-void ParserInterpreter::reset() {
-  Parser::reset();
-  _overrideDecisionReached = false;
-  _overrideDecisionRoot = nullptr;
-}
-
-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;
-}
-
-const std::vector<std::string>& ParserInterpreter::getRuleNames() const {
-  return _ruleNames;
-}
-
-std::string ParserInterpreter::getGrammarFileName() const {
-  return _grammarFileName;
-}
-
-ParserRuleContext* ParserInterpreter::parse(size_t startRuleIndex) {
-  atn::RuleStartState *startRuleStartState = _atn.ruleToStartState[startRuleIndex];
-
-  _rootContext = createInterpreterRuleContext(nullptr, atn::ATNState::INVALID_STATE_NUMBER, startRuleIndex);
-
-  if (startRuleStartState->isLeftRecursiveRule) {
-    enterRecursionRule(_rootContext, startRuleStartState->stateNumber, startRuleIndex, 0);
-  } else {
-    enterRule(_rootContext, startRuleStartState->stateNumber, startRuleIndex);
-  }
-
-  while (true) {
-    atn::ATNState *p = getATNState();
-    switch (p->getStateType()) {
-      case atn::ATNState::RULE_STOP :
-        // pop; return from rule
-        if (_ctx->isEmpty()) {
-          if (startRuleStartState->isLeftRecursiveRule) {
-            ParserRuleContext *result = _ctx;
-            auto parentContext = _parentContextStack.top();
-            _parentContextStack.pop();
-            unrollRecursionContexts(parentContext.first);
-            return result;
-          } else {
-            exitRule();
-            return _rootContext;
-          }
-        }
-
-        visitRuleStopState(p);
-        break;
-
-      default :
-        try {
-          visitState(p);
-        }
-        catch (RecognitionException &e) {
-          setState(_atn.ruleToStopState[p->ruleIndex]->stateNumber);
-          getErrorHandler()->reportError(this, e);
-          getContext()->exception = std::current_exception();
-          recover(e);
-        }
-
-        break;
-    }
-  }
-}
-
-void ParserInterpreter::enterRecursionRule(ParserRuleContext *localctx, size_t state, size_t ruleIndex, int precedence) {
-  _parentContextStack.push({ _ctx, localctx->invokingState });
-  Parser::enterRecursionRule(localctx, state, ruleIndex, precedence);
-}
-
-void ParserInterpreter::addDecisionOverride(int decision, int tokenIndex, int forcedAlt) {
-  _overrideDecision = decision;
-  _overrideDecisionInputIndex = tokenIndex;
-  _overrideDecisionAlt = forcedAlt;
-}
-
-Ref<InterpreterRuleContext> ParserInterpreter::getOverrideDecisionRoot() const {
-  return _overrideDecisionRoot;
-}
-
-InterpreterRuleContext* ParserInterpreter::getRootContext() {
-  return _rootContext;
-}
-
-atn::ATNState* ParserInterpreter::getATNState() {
-  return _atn.states[getState()];
-}
-
-void ParserInterpreter::visitState(atn::ATNState *p) {
-  size_t predictedAlt = 1;
-  if (is<DecisionState *>(p)) {
-    predictedAlt = visitDecisionState(dynamic_cast<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)) {
-        // 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,
-          _parentContextStack.top().second, static_cast<int>(_ctx->getRuleIndex()));
-        pushNewRecursionContext(localctx, _atn.ruleToStartState[p->ruleIndex]->stateNumber, static_cast<int>(_ctx->getRuleIndex()));
-      }
-      break;
-
-    case atn::Transition::ATOM:
-      match(static_cast<int>(static_cast<atn::AtomTransition*>(transition)->_label));
-      break;
-
-    case atn::Transition::RANGE:
-    case atn::Transition::SET:
-    case atn::Transition::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:
-      matchWildcard();
-      break;
-
-    case atn::Transition::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);
-      } else {
-        enterRule(newctx, transition->target->stateNumber, ruleIndex);
-      }
-    }
-      break;
-
-    case atn::Transition::PREDICATE:
-    {
-      atn::PredicateTransition *predicateTransition = static_cast<atn::PredicateTransition*>(transition);
-      if (!sempred(_ctx, predicateTransition->ruleIndex, predicateTransition->predIndex)) {
-        throw FailedPredicateException(this);
-      }
-    }
-      break;
-
-    case atn::Transition::ACTION:
-    {
-      atn::ActionTransition *actionTransition = static_cast<atn::ActionTransition*>(transition);
-      action(_ctx, actionTransition->ruleIndex, actionTransition->actionIndex);
-    }
-      break;
-
-    case atn::Transition::PRECEDENCE:
-    {
-      if (!precpred(_ctx, static_cast<atn::PrecedencePredicateTransition*>(transition)->precedence)) {
-        throw FailedPredicateException(this, "precpred(_ctx, " + std::to_string(static_cast<atn::PrecedencePredicateTransition*>(transition)->precedence) +  ")");
-      }
-    }
-      break;
-
-    default:
-      throw UnsupportedOperationException("Unrecognized ATN transition type.");
-  }
-
-  setState(transition->target->stateNumber);
-}
-
-size_t ParserInterpreter::visitDecisionState(DecisionState *p) {
-  size_t predictedAlt = 1;
-  if (p->transitions.size() > 1) {
-    getErrorHandler()->sync(this);
-    int decision = p->decision;
-    if (decision == _overrideDecision && _input->index() == _overrideDecisionInputIndex && !_overrideDecisionReached) {
-      predictedAlt = _overrideDecisionAlt;
-      _overrideDecisionReached = true;
-    } else {
-      predictedAlt = getInterpreter<ParserATNSimulator>()->adaptivePredict(_input, decision, _ctx);
-    }
-  }
-  return predictedAlt;
-}
-
-InterpreterRuleContext* ParserInterpreter::createInterpreterRuleContext(ParserRuleContext *parent,
-  size_t invokingStateNumber, size_t ruleIndex) {
-  return _tracker.createInstance<InterpreterRuleContext>(parent, invokingStateNumber, ruleIndex);
-}
-
-void ParserInterpreter::visitRuleStopState(atn::ATNState *p) {
-  atn::RuleStartState *ruleStartState = _atn.ruleToStartState[p->ruleIndex];
-  if (ruleStartState->isLeftRecursiveRule) {
-    std::pair<ParserRuleContext *, size_t> parentContext = _parentContextStack.top();
-    _parentContextStack.pop();
-
-    unrollRecursionContexts(parentContext.first);
-    setState(parentContext.second);
-  } else {
-    exitRule();
-  }
-
-  atn::RuleTransition *ruleTransition = static_cast<atn::RuleTransition*>(_atn.states[getState()]->transitions[0]);
-  setState(ruleTransition->followState->stateNumber);
-}
-
-void ParserInterpreter::recover(RecognitionException &e) {
-  size_t i = _input->index();
-  getErrorHandler()->recover(this, std::make_exception_ptr(e));
-
-  if (_input->index() == i) {
-    // no input consumed, better add an error node
-    if (is<InputMismatchException *>(&e)) {
-      InputMismatchException &ime = static_cast<InputMismatchException&>(e);
-      Token *tok = e.getOffendingToken();
-      size_t expectedTokenType = ime.getExpectedTokens().getMinElement(); // get any element
-      _errorToken = getTokenFactory()->create({ tok->getTokenSource(), tok->getTokenSource()->getInputStream() },
-        expectedTokenType, tok->getText(), Token::DEFAULT_CHANNEL, INVALID_INDEX, INVALID_INDEX, // invalid start/stop
-        tok->getLine(), tok->getCharPositionInLine());
-      _ctx->addChild(createErrorNode(_errorToken.get()));
-    }
-    else { // NoViableAlt
-      Token *tok = e.getOffendingToken();
-      _errorToken = getTokenFactory()->create({ tok->getTokenSource(), tok->getTokenSource()->getInputStream() },
-        Token::INVALID_TYPE, tok->getText(), Token::DEFAULT_CHANNEL, INVALID_INDEX, INVALID_INDEX, // invalid start/stop
-        tok->getLine(), tok->getCharPositionInLine());
-      _ctx->addChild(createErrorNode(_errorToken.get()));
-    }
-  }
-}
-
-Token* ParserInterpreter::recoverInline() {
-  return _errHandler->recoverInline(this);
-}

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

@@ -1,179 +0,0 @@
-/* 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 "Parser.h"
-#include "atn/ATN.h"
-#include "support/BitSet.h"
-#include "atn/PredictionContext.h"
-#include "Vocabulary.h"
-
-namespace antlr4 {
-
-  /// <summary>
-  /// A parser simulator that mimics what ANTLR's generated
-  ///  parser code does. A ParserATNSimulator is used to make
-  ///  predictions via adaptivePredict but this class moves a pointer through the
-  ///  ATN to simulate parsing. ParserATNSimulator just
-  ///  makes us efficient rather than having to backtrack, for example.
-  ///
-  ///  This properly creates parse trees even for left recursive rules.
-  ///
-  ///  We rely on the left recursive rule invocation and special predicate
-  ///  transitions to make left recursive rules work.
-  ///
-  ///  See TestParserInterpreter for examples.
-  /// </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();
-
-    virtual void reset() override;
-
-    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;
-    virtual std::string getGrammarFileName() const override;
-
-    /// Begin parsing at startRuleIndex
-    virtual ParserRuleContext* parse(size_t startRuleIndex);
-
-    virtual void enterRecursionRule(ParserRuleContext *localctx, size_t state, size_t ruleIndex, int precedence) override;
-
-
-    /** Override this parser interpreters normal decision-making process
-     *  at a particular decision and input token index. Instead of
-     *  allowing the adaptive prediction mechanism to choose the
-     *  first alternative within a block that leads to a successful parse,
-     *  force it to take the alternative, 1..n for n alternatives.
-     *
-     *  As an implementation limitation right now, you can only specify one
-     *  override. This is sufficient to allow construction of different
-     *  parse trees for ambiguous input. It means re-parsing the entire input
-     *  in general because you're never sure where an ambiguous sequence would
-     *  live in the various parse trees. For example, in one interpretation,
-     *  an ambiguous input sequence would be matched completely in expression
-     *  but in another it could match all the way back to the root.
-     *
-     *  s : e '!'? ;
-     *  e : ID
-     *    | ID '!'
-     *    ;
-     *
-     *  Here, x! can be matched as (s (e ID) !) or (s (e ID !)). In the first
-     *  case, the ambiguous sequence is fully contained only by the root.
-     *  In the second case, the ambiguous sequences fully contained within just
-     *  e, as in: (e ID !).
-     *
-     *  Rather than trying to optimize this and make
-     *  some intelligent decisions for optimization purposes, I settled on
-     *  just re-parsing the whole input and then using
-     *  {link Trees#getRootOfSubtreeEnclosingRegion} to find the minimal
-     *  subtree that contains the ambiguous sequence. I originally tried to
-     *  record the call stack at the point the parser detected and ambiguity but
-     *  left recursive rules create a parse tree stack that does not reflect
-     *  the actual call stack. That impedance mismatch was enough to make
-     *  it it challenging to restart the parser at a deeply nested rule
-     *  invocation.
-     *
-     *  Only parser interpreters can override decisions so as to avoid inserting
-     *  override checking code in the critical ALL(*) prediction execution path.
-     *
-     *  @since 4.5.1
-     */
-    void addDecisionOverride(int decision, int tokenIndex, int forcedAlt);
-
-    Ref<InterpreterRuleContext> getOverrideDecisionRoot() const;
-
-    /** Return the root of the parse, which can be useful if the parser
-     *  bails out. You still can access the top node. Note that,
-     *  because of the way left recursive rules add children, it's possible
-     *  that the root will not have any children if the start rule immediately
-     *  called and left recursive rule that fails.
-     *
-     * @since 4.5.1
-     */
-    InterpreterRuleContext* getRootContext();
-
-  protected:
-    const std::string _grammarFileName;
-    std::vector<std::string> _tokenNames;
-    const atn::ATN &_atn;
-
-    std::vector<std::string> _ruleNames;
-
-    std::vector<dfa::DFA> _decisionToDFA; // not shared like it is for generated parsers
-    atn::PredictionContextCache _sharedContextCache;
-
-    /** This stack corresponds to the _parentctx, _parentState pair of locals
-     *  that would exist on call stack frames with a recursive descent parser;
-     *  in the generated function for a left-recursive rule you'd see:
-     *
-     *  private EContext e(int _p) throws RecognitionException {
-     *      ParserRuleContext _parentctx = _ctx;    // Pair.a
-     *      int _parentState = getState();          // Pair.b
-     *      ...
-     *  }
-     *
-     *  Those values are used to create new recursive rule invocation contexts
-     *  associated with left operand of an alt like "expr '*' expr".
-     */
-    std::stack<std::pair<ParserRuleContext *, size_t>> _parentContextStack;
-
-    /** We need a map from (decision,inputIndex)->forced alt for computing ambiguous
-     *  parse trees. For now, we allow exactly one override.
-     */
-    int _overrideDecision = -1;
-    size_t _overrideDecisionInputIndex = INVALID_INDEX;
-    size_t _overrideDecisionAlt = INVALID_INDEX;
-    bool _overrideDecisionReached = false; // latch and only override once; error might trigger infinite loop
-
-    /** What is the current context when we override a decision? This tells
-     *  us what the root of the parse tree is when using override
-     *  for an ambiguity/lookahead check.
-     */
-    Ref<InterpreterRuleContext> _overrideDecisionRoot;
-    InterpreterRuleContext* _rootContext;
-
-    virtual atn::ATNState *getATNState();
-    virtual void visitState(atn::ATNState *p);
-
-    /** Method visitDecisionState() is called when the interpreter reaches
-     *  a decision state (instance of DecisionState). It gives an opportunity
-     *  for subclasses to track interesting things.
-     */
-    size_t visitDecisionState(atn::DecisionState *p);
-
-    /** Provide simple "factory" for InterpreterRuleContext's.
-     *  @since 4.5.1
-     */
-    InterpreterRuleContext* createInterpreterRuleContext(ParserRuleContext *parent, size_t invokingStateNumber, size_t ruleIndex);
-
-    virtual void visitRuleStopState(atn::ATNState *p);
-
-    /** Rely on the error handler for this parser but, if no tokens are consumed
-     *  to recover, add an error node. Otherwise, nothing is seen in the parse
-     *  tree.
-     */
-    void recover(RecognitionException &e);
-    Token* recoverInline();
-
-  private:
-    const dfa::Vocabulary &_vocabulary;
-    std::unique_ptr<Token> _errorToken;
-  };
-
-} // namespace antlr4

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

@@ -1,141 +0,0 @@
-/* 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.
- */
-
-#include "tree/TerminalNode.h"
-#include "tree/ErrorNode.h"
-#include "misc/Interval.h"
-#include "Parser.h"
-#include "Token.h"
-
-#include "support/CPPUtils.h"
-
-#include "ParserRuleContext.h"
-
-using namespace antlr4;
-using namespace antlr4::tree;
-
-using namespace antlrcpp;
-
-ParserRuleContext ParserRuleContext::EMPTY;
-
-ParserRuleContext::ParserRuleContext()
-  : start(nullptr), stop(nullptr) {
-}
-
-ParserRuleContext::ParserRuleContext(ParserRuleContext *parent, size_t invokingStateNumber)
-: RuleContext(parent, invokingStateNumber), start(nullptr), stop(nullptr) {
-}
-
-void ParserRuleContext::copyFrom(ParserRuleContext *ctx) {
-  // from RuleContext
-  this->parent = ctx->parent;
-  this->invokingState = ctx->invokingState;
-
-  this->start = ctx->start;
-  this->stop = ctx->stop;
-
-  // 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);
-      }
-    }
-
-    // Remove the just reparented error nodes from the source context.
-    ctx->children.erase(std::remove_if(ctx->children.begin(), ctx->children.end(), [this](tree::ParseTree *e) -> bool {
-      return std::find(children.begin(), children.end(), e) != children.end();
-    }), ctx->children.end());
-  }
-}
-
-void ParserRuleContext::enterRule(tree::ParseTreeListener * /*listener*/) {
-}
-
-void ParserRuleContext::exitRule(tree::ParseTreeListener * /*listener*/) {
-}
-
-tree::TerminalNode* ParserRuleContext::addChild(tree::TerminalNode *t) {
-  t->setParent(this);
-  children.push_back(t);
-  return t;
-}
-
-RuleContext* ParserRuleContext::addChild(RuleContext *ruleInvocation) {
-  children.push_back(ruleInvocation);
-  return ruleInvocation;
-}
-
-void ParserRuleContext::removeLastChild() {
-  if (!children.empty()) {
-    children.pop_back();
-  }
-}
-
-tree::TerminalNode* ParserRuleContext::getToken(size_t ttype, size_t i) {
-  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();
-      if (symbol->getType() == ttype) {
-        if (j++ == i) {
-          return tnode;
-        }
-      }
-    }
-  }
-
-  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();
-      if (symbol->getType() == ttype) {
-        tokens.push_back(tnode);
-      }
-    }
-  }
-
-  return tokens;
-}
-
-misc::Interval ParserRuleContext::getSourceInterval() {
-  if (start == nullptr) {
-    return misc::Interval::INVALID;
-  }
-
-  if (stop == nullptr || stop->getTokenIndex() < start->getTokenIndex()) {
-    return misc::Interval(start->getTokenIndex(), start->getTokenIndex() - 1); // empty
-  }
-  return misc::Interval(start->getTokenIndex(), stop->getTokenIndex());
-}
-
-Token* ParserRuleContext::getStart() {
-  return start;
-}
-
-Token* ParserRuleContext::getStop() {
-  return stop;
-}
-
-std::string ParserRuleContext::toInfoString(Parser *recognizer) {
-  std::vector<std::string> rules = recognizer->getRuleInvocationStack(this);
-  std::reverse(rules.begin(), rules.end());
-  std::string rulesStr = antlrcpp::arrayToString(rules);
-  return "ParserRuleContext" + rulesStr + "{start=" + std::to_string(start->getTokenIndex()) + ", stop=" +
-    std::to_string(stop->getTokenIndex()) + '}';
-}
-