expressir 1.4.2 → 2.0.0

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/ATNSimulator.h

@@ -1,71 +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 "atn/ATN.h"
-#include "atn/PredictionContext.h"
-#include "atn/PredictionContextCache.h"
-#include "misc/IntervalSet.h"
-#include "support/CPPUtils.h"
-
-namespace antlr4 {
-namespace atn {
-
-  class ANTLR4CPP_PUBLIC ATNSimulator {
-  public:
-    /// Must distinguish between missing edge and edge we know leads nowhere.
-    static const Ref<dfa::DFAState> ERROR;
-    const ATN &atn;
-
-    ATNSimulator(const ATN &atn, PredictionContextCache &sharedContextCache);
-
-    virtual ~ATNSimulator() = default;
-
-    virtual void reset() = 0;
-
-    /**
-     * Clear the DFA cache used by the current instance. Since the DFA cache may
-     * be shared by multiple ATN simulators, this method may affect the
-     * performance (but not accuracy) of other parsers which are being used
-     * concurrently.
-     *
-     * @throws UnsupportedOperationException if the current instance does not
-     * support clearing the DFA.
-     *
-     * @since 4.3
-     */
-    virtual void clearDFA();
-
-    PredictionContextCache& getSharedContextCache() const;
-    Ref<const PredictionContext> getCachedContext(const Ref<const PredictionContext> &context);
-
-  protected:
-    /// <summary>
-    /// The context cache maps all PredictionContext objects that are equals()
-    ///  to a single cached copy. This cache is shared across all contexts
-    ///  in all ATNConfigs in all DFA states.  We rebuild each ATNConfigSet
-    ///  to use only cached nodes/graphs in addDFAState(). We don't want to
-    ///  fill this during closure() since there are lots of contexts that
-    ///  pop up but are not used ever again. It also greatly slows down closure().
-    ///  <p/>
-    ///  This cache makes a huge difference in memory and a little bit in speed.
-    ///  For the Java grammar on java.*, it dropped the memory requirements
-    ///  at the end from 25M to 16M. We don't store any of the full context
-    ///  graphs in the DFA because they are limited to local context only,
-    ///  but apparently there's a lot of repetition there as well. We optimize
-    ///  the config contexts before storing the config set in the DFA states
-    ///  by literally rebuilding them with cached subgraphs only.
-    ///  <p/>
-    ///  I tried a cache for use during closure operations, that was
-    ///  whacked after each adaptivePredict(). It cost a little bit
-    ///  more time I think and doesn't save on the overall footprint
-    ///  so it's not worth the complexity.
-    /// </summary>
-    PredictionContextCache &_sharedContextCache;
-  };
-
-} // namespace atn
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/ATNState.cpp

@@ -1,56 +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 "atn/ATN.h"
-#include "atn/Transition.h"
-#include "misc/IntervalSet.h"
-#include "support/CPPUtils.h"
-
-#include "atn/ATNState.h"
-
-using namespace antlr4::atn;
-using namespace antlrcpp;
-
-size_t ATNState::hashCode() const {
-  return stateNumber;
-}
-
-bool ATNState::equals(const ATNState &other) const {
-  return stateNumber == other.stateNumber;
-}
-
-bool ATNState::isNonGreedyExitState() const {
-  return false;
-}
-
-std::string ATNState::toString() const {
-  return std::to_string(stateNumber);
-}
-
-void ATNState::addTransition(ConstTransitionPtr e) {
-  addTransition(transitions.size(), std::move(e));
-}
-
-void ATNState::addTransition(size_t index, ConstTransitionPtr e) {
-  for (const auto &transition : transitions)
-    if (transition->target->stateNumber == e->target->stateNumber) {
-      return;
-    }
-
-  if (transitions.empty()) {
-    epsilonOnlyTransitions = e->isEpsilon();
-  } else if (epsilonOnlyTransitions != e->isEpsilon()) {
-    std::cerr << "ATN state %d has both epsilon and non-epsilon transitions.\n" << stateNumber;
-    epsilonOnlyTransitions = false;
-  }
-
-  transitions.insert(transitions.begin() + index, std::move(e));
-}
-
-ConstTransitionPtr ATNState::removeTransition(size_t index) {
-  ConstTransitionPtr result = std::move(transitions[index]);
-  transitions.erase(transitions.begin() + index);
-  return result;
-}

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/ATNState.h

@@ -1,139 +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 "misc/IntervalSet.h"
-#include "atn/Transition.h"
-#include "atn/ATNStateType.h"
-
-namespace antlr4 {
-namespace atn {
-
-  /// <summary>
-  /// The following images show the relation of states and
-  /// <seealso cref="ATNState#transitions"/> for various grammar constructs.
-  ///
-  /// <ul>
-  ///
-  /// <li>Solid edges marked with an &#0949; indicate a required
-  /// <seealso cref="EpsilonTransition"/>.</li>
-  ///
-  /// <li>Dashed edges indicate locations where any transition derived from
-  /// <seealso cref="Transition"/> might appear.</li>
-  ///
-  /// <li>Dashed nodes are place holders for either a sequence of linked
-  /// <seealso cref="BasicState"/> states or the inclusion of a block representing a nested
-  /// construct in one of the forms below.</li>
-  ///
-  /// <li>Nodes showing multiple outgoing alternatives with a {@code ...} support
-  /// any number of alternatives (one or more). Nodes without the {@code ...} only
-  /// support the exact number of alternatives shown in the diagram.</li>
-  ///
-  /// </ul>
-  ///
-  /// <h2>Basic Blocks</h2>
-  ///
-  /// <h3>Rule</h3>
-  ///
-  /// <embed src="images/Rule.svg" type="image/svg+xml"/>
-  ///
-  /// <h3>Block of 1 or more alternatives</h3>
-  ///
-  /// <embed src="images/Block.svg" type="image/svg+xml"/>
-  ///
-  /// <h2>Greedy Loops</h2>
-  ///
-  /// <h3>Greedy Closure: {@code (...)*}</h3>
-  ///
-  /// <embed src="images/ClosureGreedy.svg" type="image/svg+xml"/>
-  ///
-  /// <h3>Greedy Positive Closure: {@code (...)+}</h3>
-  ///
-  /// <embed src="images/PositiveClosureGreedy.svg" type="image/svg+xml"/>
-  ///
-  /// <h3>Greedy Optional: {@code (...)?}</h3>
-  ///
-  /// <embed src="images/OptionalGreedy.svg" type="image/svg+xml"/>
-  ///
-  /// <h2>Non-Greedy Loops</h2>
-  ///
-  /// <h3>Non-Greedy Closure: {@code (...)*?}</h3>
-  ///
-  /// <embed src="images/ClosureNonGreedy.svg" type="image/svg+xml"/>
-  ///
-  /// <h3>Non-Greedy Positive Closure: {@code (...)+?}</h3>
-  ///
-  /// <embed src="images/PositiveClosureNonGreedy.svg" type="image/svg+xml"/>
-  ///
-  /// <h3>Non-Greedy Optional: {@code (...)??}</h3>
-  ///
-  /// <embed src="images/OptionalNonGreedy.svg" type="image/svg+xml"/>
-  /// </summary>
-
-// GCC generates a warning here if ATN has already been declared due to the
-// attributes added by ANTLR4CPP_PUBLIC.
-// See: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=39159
-// Only forward-declare if it hasn't already been declared.
-#ifndef ANTLR4CPP_ATN_DECLARED
-  class ANTLR4CPP_PUBLIC ATN;
-#endif
-
-  class ANTLR4CPP_PUBLIC ATNState {
-  public:
-    static constexpr size_t INITIAL_NUM_TRANSITIONS = 4;
-    static constexpr size_t INVALID_STATE_NUMBER = std::numeric_limits<size_t>::max();
-
-    size_t stateNumber = INVALID_STATE_NUMBER;
-    size_t ruleIndex = 0; // at runtime, we don't have Rule objects
-    bool epsilonOnlyTransitions = false;
-
-    /// Track the transitions emanating from this ATN state.
-    std::vector<ConstTransitionPtr> transitions;
-
-    ATNState() = delete;
-
-    ATNState(ATNState const&) = delete;
-
-    ATNState(ATNState&&) = delete;
-
-    virtual ~ATNState() = default;
-
-    ATNState& operator=(ATNState const&) = delete;
-
-    ATNState& operator=(ATNState&&) = delete;
-
-    void addTransition(ConstTransitionPtr e);
-    void addTransition(size_t index, ConstTransitionPtr e);
-    ConstTransitionPtr removeTransition(size_t index);
-
-    virtual size_t hashCode() const;
-    virtual bool equals(const ATNState &other) const;
-
-    virtual bool isNonGreedyExitState() const;
-    virtual std::string toString() const;
-
-    ATNStateType getStateType() const { return _stateType; }
-
-  protected:
-    explicit ATNState(ATNStateType stateType) : _stateType(stateType) {}
-
-  private:
-    /// Used to cache lookahead during parsing, not used during construction.
-
-    misc::IntervalSet _nextTokenWithinRule;
-    std::atomic<bool> _nextTokenUpdated { false };
-
-    const ATNStateType _stateType;
-
-    friend class ATN;
-  };
-
-  inline bool operator==(const ATNState &lhs, const ATNState &rhs) { return lhs.equals(rhs); }
-
-  inline bool operator!=(const ATNState &lhs, const ATNState &rhs) { return !operator==(lhs, rhs); }
-
-} // namespace atn
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/ATNStateType.cpp

@@ -1,33 +0,0 @@
-#include "atn/ATNStateType.h"
-
-std::string antlr4::atn::atnStateTypeName(ATNStateType atnStateType) {
-  switch (atnStateType) {
-    case ATNStateType::INVALID:
-      return "INVALID";
-    case ATNStateType::BASIC:
-      return "BASIC";
-    case ATNStateType::RULE_START:
-      return "RULE_START";
-    case ATNStateType::BLOCK_START:
-      return "BLOCK_START";
-    case ATNStateType::PLUS_BLOCK_START:
-      return "PLUS_BLOCK_START";
-    case ATNStateType::STAR_BLOCK_START:
-      return "STAR_BLOCK_START";
-    case ATNStateType::TOKEN_START:
-      return "TOKEN_START";
-    case ATNStateType::RULE_STOP:
-      return "RULE_STOP";
-    case ATNStateType::BLOCK_END:
-      return "BLOCK_END";
-    case ATNStateType::STAR_LOOP_BACK:
-      return "STAR_LOOP_BACK";
-    case ATNStateType::STAR_LOOP_ENTRY:
-      return "STAR_LOOP_ENTRY";
-    case ATNStateType::PLUS_LOOP_BACK:
-      return "PLUS_LOOP_BACK";
-    case ATNStateType::LOOP_END:
-      return "LOOP_END";
-  }
-  return "UNKNOWN";
-}

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/ATNStateType.h

@@ -1,36 +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 <cstddef>
-#include <string>
-
-#include "antlr4-common.h"
-
-namespace antlr4 {
-namespace atn {
-
-  // Constants for ATNState serialization.
-  enum class ATNStateType : size_t {
-    INVALID = 0,
-    BASIC = 1,
-    RULE_START = 2,
-    BLOCK_START = 3,
-    PLUS_BLOCK_START = 4,
-    STAR_BLOCK_START = 5,
-    TOKEN_START = 6,
-    RULE_STOP = 7,
-    BLOCK_END = 8,
-    STAR_LOOP_BACK = 9,
-    STAR_LOOP_ENTRY = 10,
-    PLUS_LOOP_BACK = 11,
-    LOOP_END = 12,
-  };
-
-  ANTLR4CPP_PUBLIC std::string atnStateTypeName(ATNStateType atnStateType);
-
-} // namespace atn
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/ATNType.h

@@ -1,20 +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 "antlr4-common.h"
-
-namespace antlr4 {
-namespace atn {
-
-  /// Represents the type of recognizer an ATN applies to.
-  enum class ATNType {
-    LEXER = 0,
-    PARSER = 1,
-  };
-
-} // namespace atn
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/ActionTransition.cpp

@@ -1,29 +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 "atn/ActionTransition.h"
-
-using namespace antlr4::atn;
-
-ActionTransition::ActionTransition(ATNState *target, size_t ruleIndex)
-  : Transition(TransitionType::ACTION, target), ruleIndex(ruleIndex), actionIndex(INVALID_INDEX), isCtxDependent(false) {
-}
-
-ActionTransition::ActionTransition(ATNState *target, size_t ruleIndex, size_t actionIndex, bool isCtxDependent)
-  : Transition(TransitionType::ACTION, target), ruleIndex(ruleIndex), actionIndex(actionIndex), isCtxDependent(isCtxDependent) {
-}
-
-bool ActionTransition::isEpsilon() const {
-  return true; // we are to be ignored by analysis 'cept for predicates
-}
-
-bool ActionTransition::matches(size_t /*symbol*/, size_t /*minVocabSymbol*/, size_t /*maxVocabSymbol*/) const {
-  return false;
-}
-
-std::string ActionTransition::toString() const {
-  return " ACTION " + Transition::toString() + " { ruleIndex: " + std::to_string(ruleIndex) + ", actionIndex: " +
-  std::to_string(actionIndex) + ", isCtxDependent: " + std::to_string(isCtxDependent) + " }";
-}

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/ActionTransition.h

@@ -1,35 +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 "atn/Transition.h"
-
-namespace antlr4 {
-namespace atn {
-
-  class ANTLR4CPP_PUBLIC ActionTransition final : public Transition {
-  public:
-    static bool is(const Transition &transition) { return transition.getTransitionType() == TransitionType::ACTION; }
-
-    static bool is(const Transition *transition) { return transition != nullptr && is(*transition); }
-
-    const size_t ruleIndex;
-    const size_t actionIndex;
-    const bool isCtxDependent; // e.g., $i ref in action
-
-    ActionTransition(ATNState *target, size_t ruleIndex);
-
-    ActionTransition(ATNState *target, size_t ruleIndex, size_t actionIndex, bool isCtxDependent);
-
-    virtual bool isEpsilon() const override;
-
-    virtual bool matches(size_t symbol, size_t minVocabSymbol, size_t maxVocabSymbol) const override;
-
-    virtual std::string toString() const override;
-  };
-
-} // namespace atn
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/AmbiguityInfo.cpp

@@ -1,16 +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 "atn/AmbiguityInfo.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-
-AmbiguityInfo::AmbiguityInfo(size_t decision, ATNConfigSet *configs, const antlrcpp::BitSet &ambigAlts,
-                             TokenStream *input, size_t startIndex, size_t stopIndex, bool fullCtx)
-  : DecisionEventInfo(decision, configs, input, startIndex, stopIndex, fullCtx) {
-
-  this->ambigAlts = ambigAlts;
-}

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/AmbiguityInfo.h

@@ -1,68 +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 "atn/DecisionEventInfo.h"
-#include "support/BitSet.h"
-
-namespace antlr4 {
-namespace atn {
-
-  /// <summary>
-  /// This class represents profiling event information for an ambiguity.
-  /// Ambiguities are decisions where a particular input resulted in an SLL
-  /// conflict, followed by LL prediction also reaching a conflict state
-  /// (indicating a true ambiguity in the grammar).
-  ///
-  /// <para>
-  /// This event may be reported during SLL prediction in cases where the
-  /// conflicting SLL configuration set provides sufficient information to
-  /// determine that the SLL conflict is truly an ambiguity. For example, if none
-  /// of the ATN configurations in the conflicting SLL configuration set have
-  /// traversed a global follow transition (i.e.
-  /// <seealso cref="ATNConfig#reachesIntoOuterContext"/> is 0 for all configurations), then
-  /// the result of SLL prediction for that input is known to be equivalent to the
-  /// result of LL prediction for that input.</para>
-  ///
-  /// <para>
-  /// In some cases, the minimum represented alternative in the conflicting LL
-  /// configuration set is not equal to the minimum represented alternative in the
-  /// conflicting SLL configuration set. Grammars and inputs which result in this
-  /// scenario are unable to use <seealso cref="PredictionMode#SLL"/>, which in turn means
-  /// they cannot use the two-stage parsing strategy to improve parsing performance
-  /// for that input.</para>
-  /// </summary>
-  /// <seealso cref= ParserATNSimulator#reportAmbiguity </seealso>
-  /// <seealso cref= ANTLRErrorListener#reportAmbiguity
-  ///
-  /// @since 4.3 </seealso>
-  class ANTLR4CPP_PUBLIC AmbiguityInfo : public DecisionEventInfo {
-  public:
-    /// The set of alternative numbers for this decision event that lead to a valid parse.
-    antlrcpp::BitSet ambigAlts;
-
-    /// <summary>
-    /// Constructs a new instance of the <seealso cref="AmbiguityInfo"/> class with the
-    /// specified detailed ambiguity information.
-    /// </summary>
-    /// <param name="decision"> The decision number </param>
-    /// <param name="configs"> The final configuration set identifying the ambiguous
-    /// alternatives for the current input </param>
-    /// <param name="ambigAlts"> The set of alternatives in the decision that lead to a valid parse.
-    ///                  The predicted alt is the min(ambigAlts) </param>
-    /// <param name="input"> The input token stream </param>
-    /// <param name="startIndex"> The start index for the current prediction </param>
-    /// <param name="stopIndex"> The index at which the ambiguity was identified during
-    /// prediction </param>
-    /// <param name="fullCtx"> {@code true} if the ambiguity was identified during LL
-    /// prediction; otherwise, {@code false} if the ambiguity was identified
-    /// during SLL prediction </param>
-    AmbiguityInfo(size_t decision, ATNConfigSet *configs, const antlrcpp::BitSet &ambigAlts, TokenStream *input,
-                  size_t startIndex, size_t stopIndex, bool fullCtx);
-  };
-
-} // namespace atn
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/ArrayPredictionContext.cpp

@@ -1,129 +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 "atn/ArrayPredictionContext.h"
-
-#include <cstring>
-
-#include "atn/SingletonPredictionContext.h"
-#include "atn/HashUtils.h"
-#include "misc/MurmurHash.h"
-#include "support/Casts.h"
-
-using namespace antlr4::atn;
-using namespace antlr4::misc;
-using namespace antlrcpp;
-
-namespace {
-
-  bool predictionContextEqual(const Ref<const PredictionContext> &lhs, const Ref<const PredictionContext> &rhs) {
-    // parent PredictionContext pointers can be null during full context mode and
-    // the ctxs are in an ArrayPredictionContext.  If both are null, return true
-    // if just one is null, return false. If both are non-null, do comparison.
-    if ( lhs == nullptr ) return rhs == nullptr;
-    if ( rhs == nullptr ) return false; // lhs!=null and rhs==null
-    return *lhs == *rhs;                // both nonnull
-  }
-
-}
-
-ArrayPredictionContext::ArrayPredictionContext(const SingletonPredictionContext &predictionContext)
-    : ArrayPredictionContext({ predictionContext.parent }, { predictionContext.returnState }) {}
-
-ArrayPredictionContext::ArrayPredictionContext(std::vector<Ref<const PredictionContext>> parents,
-                                               std::vector<size_t> returnStates)
-    : PredictionContext(PredictionContextType::ARRAY), parents(std::move(parents)), returnStates(std::move(returnStates)) {
-  assert(this->parents.size() > 0);
-  assert(this->returnStates.size() > 0);
-  assert(this->parents.size() == this->returnStates.size());
-}
-
-bool ArrayPredictionContext::isEmpty() const {
-  // Since EMPTY_RETURN_STATE can only appear in the last position, we don't need to verify that size == 1.
-  return returnStates[0] == EMPTY_RETURN_STATE;
-}
-
-size_t ArrayPredictionContext::size() const {
-  return returnStates.size();
-}
-
-const Ref<const PredictionContext>& ArrayPredictionContext::getParent(size_t index) const {
-  return parents[index];
-}
-
-size_t ArrayPredictionContext::getReturnState(size_t index) const {
-  return returnStates[index];
-}
-
-size_t ArrayPredictionContext::hashCodeImpl() const {
-  size_t hash = MurmurHash::initialize();
-  hash = MurmurHash::update(hash, static_cast<size_t>(getContextType()));
-  for (const auto &parent : parents) {
-    hash = MurmurHash::update(hash, parent);
-  }
-  for (const auto &returnState : returnStates) {
-    hash = MurmurHash::update(hash, returnState);
-  }
-  return MurmurHash::finish(hash, 1 + parents.size() + returnStates.size());
-}
-
-bool ArrayPredictionContext::equals(const PredictionContext &other) const {
-  if (this == std::addressof(other)) {
-    return true;
-  }
-  if (getContextType() != other.getContextType()) {
-    return false;
-  }
-  const auto &array = downCast<const ArrayPredictionContext&>(other);
-  const bool sameSize = returnStates.size() == array.returnStates.size() &&
-                        parents.size() == array.parents.size();
-  if ( !sameSize ) {
-      return false;
-  }
-
-  const bool sameHash = cachedHashCodeEqual(cachedHashCode(), array.cachedHashCode());
-  if ( !sameHash ) {
-      return false;
-  }
-
-  const size_t stateSizeBytes = sizeof(decltype(returnStates)::value_type);
-  const bool returnStateArraysEqual =
-          std::memcmp(returnStates.data(), array.returnStates.data(),
-                      returnStates.size() * stateSizeBytes) == 0;
-  if ( !returnStateArraysEqual ) {
-      return false;
-  }
-
-  // stack of contexts is the same
-  const bool parentCtxEqual =
-          std::equal(parents.begin(), parents.end(), array.parents.begin(), predictionContextEqual);
-  return parentCtxEqual;
-}
-
-std::string ArrayPredictionContext::toString() const {
-  if (isEmpty()) {
-    return "[]";
-  }
-
-  std::stringstream ss;
-  ss << "[";
-  for (size_t i = 0; i < returnStates.size(); i++) {
-    if (i > 0) {
-      ss << ", ";
-    }
-    if (returnStates[i] == EMPTY_RETURN_STATE) {
-      ss << "$";
-      continue;
-    }
-    ss << returnStates[i];
-    if (parents[i] != nullptr) {
-      ss << " " << parents[i]->toString();
-    } else {
-      ss << "nul";
-    }
-  }
-  ss << "]";
-  return ss.str();
-}