expressir 1.2.3 → 1.2.6

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

@@ -5,24 +5,30 @@
 
 #pragma once
 
+#include <atomic>
+
 #include "Recognizer.h"
 #include "atn/ATN.h"
 #include "atn/ATNState.h"
+#include "atn/PredictionContextType.h"
 
 namespace antlr4 {
+
+  class RuleContext;
+
 namespace atn {
 
-  struct PredictionContextHasher;
-  struct PredictionContextComparer;
+  class ATN;
+  class ArrayPredictionContext;
+  class SingletonPredictionContext;
+  class PredictionContextCache;
   class PredictionContextMergeCache;
 
-  typedef std::unordered_set<Ref<PredictionContext>, PredictionContextHasher, PredictionContextComparer> PredictionContextCache;
-
   class ANTLR4CPP_PUBLIC PredictionContext {
   public:
     /// Represents $ in local context prediction, which means wildcard.
     /// *+x = *.
-    static const Ref<PredictionContext> EMPTY;
+    static const Ref<const PredictionContext> EMPTY;
 
     /// Represents $ in an array in full context mode, when $
     /// doesn't mean wildcard: $ + x = [$,x]. Here,
@@ -30,68 +36,13 @@ namespace atn {
     // ml: originally Integer.MAX_VALUE, which would be -1 for us, but this is already used in places where
     //     -1 is converted to unsigned, so we use a different value here. Any value does the job provided it doesn't
     //     conflict with real return states.
-    static const size_t EMPTY_RETURN_STATE = static_cast<size_t>(-10); // std::numeric_limits<size_t>::max() - 9;
-
-  private:
-    static const size_t INITIAL_HASH = 1;
-
-  public:
-    static size_t globalNodeCount;
-    const size_t id;
-
-    /// <summary>
-    /// Stores the computed hash code of this <seealso cref="PredictionContext"/>. The hash
-    /// code is computed in parts to match the following reference algorithm.
-    ///
-    /// <pre>
-    ///  private int referenceHashCode() {
-    ///      int hash = <seealso cref="MurmurHash#initialize"/>(<seealso cref="#INITIAL_HASH"/>);
-    ///
-    ///      for (int i = 0; i < <seealso cref="#size()"/>; i++) {
-    ///          hash = <seealso cref="MurmurHash#update"/>(hash, <seealso cref="#getParent"/>(i));
-    ///      }
-    ///
-    ///      for (int i = 0; i < <seealso cref="#size()"/>; i++) {
-    ///          hash = <seealso cref="MurmurHash#update"/>(hash, <seealso cref="#getReturnState"/>(i));
-    ///      }
-    ///
-    ///      hash = <seealso cref="MurmurHash#finish"/>(hash, 2 * <seealso cref="#size()"/>);
-    ///      return hash;
-    ///  }
-    /// </pre>
-    /// </summary>
-    const size_t cachedHashCode;
+    static constexpr size_t EMPTY_RETURN_STATE = std::numeric_limits<size_t>::max() - 9;
 
-  protected:
-    PredictionContext(size_t cachedHashCode);
-    ~PredictionContext();
-
-  public:
-    /// Convert a RuleContext tree to a PredictionContext graph.
-    /// Return EMPTY if outerContext is empty.
-    static Ref<PredictionContext> fromRuleContext(const ATN &atn, RuleContext *outerContext);
-
-    virtual size_t size() const = 0;
-    virtual Ref<PredictionContext> getParent(size_t index) const = 0;
-    virtual size_t getReturnState(size_t index) const = 0;
-
-    virtual bool operator == (const PredictionContext &o) const = 0;
-
-    /// This means only the EMPTY (wildcard? not sure) context is in set.
-    virtual bool isEmpty() const;
-    virtual bool hasEmptyPath() const;
-    virtual size_t hashCode() const;
-
-  protected:
-    static size_t calculateEmptyHashCode();
-    static size_t calculateHashCode(Ref<PredictionContext> parent, size_t returnState);
-    static size_t calculateHashCode(const std::vector<Ref<PredictionContext>> &parents,
-                                    const std::vector<size_t> &returnStates);
-
-  public:
     // dispatch
-    static Ref<PredictionContext> merge(const Ref<PredictionContext> &a, const Ref<PredictionContext> &b,
-                                        bool rootIsWildcard, PredictionContextMergeCache *mergeCache);
+    static Ref<const PredictionContext> merge(Ref<const PredictionContext> a,
+                                              Ref<const PredictionContext> b,
+                                              bool rootIsWildcard,
+                                              PredictionContextMergeCache *mergeCache);
 
     /// <summary>
     /// Merge two <seealso cref="SingletonPredictionContext"/> instances.
@@ -127,8 +78,10 @@ namespace atn {
     /// <param name="rootIsWildcard"> {@code true} if this is a local-context merge,
     /// otherwise false to indicate a full-context merge </param>
     /// <param name="mergeCache"> </param>
-    static Ref<PredictionContext> mergeSingletons(const Ref<SingletonPredictionContext> &a,
-      const Ref<SingletonPredictionContext> &b, bool rootIsWildcard, PredictionContextMergeCache *mergeCache);
+    static Ref<const PredictionContext> mergeSingletons(Ref<const SingletonPredictionContext> a,
+                                                        Ref<const SingletonPredictionContext> b,
+                                                        bool rootIsWildcard,
+                                                        PredictionContextMergeCache *mergeCache);
 
     /**
      * Handle case where at least one of {@code a} or {@code b} is
@@ -168,8 +121,9 @@ namespace atn {
      * @param rootIsWildcard {@code true} if this is a local-context merge,
      * otherwise false to indicate a full-context merge
      */
-    static Ref<PredictionContext> mergeRoot(const Ref<SingletonPredictionContext> &a,
-      const Ref<SingletonPredictionContext> &b, bool rootIsWildcard);
+    static Ref<const PredictionContext> mergeRoot(Ref<const SingletonPredictionContext> a,
+                                                  Ref<const SingletonPredictionContext> b,
+                                                  bool rootIsWildcard);
 
     /**
      * Merge two {@link ArrayPredictionContext} instances.
@@ -190,65 +144,82 @@ namespace atn {
      * {@link SingletonPredictionContext}.<br>
      * <embed src="images/ArrayMerge_EqualTop.svg" type="image/svg+xml"/></p>
      */
-    static Ref<PredictionContext> mergeArrays(const Ref<ArrayPredictionContext> &a,
-      const Ref<ArrayPredictionContext> &b, bool rootIsWildcard, PredictionContextMergeCache *mergeCache);
+    static Ref<const PredictionContext> mergeArrays(Ref<const ArrayPredictionContext> a,
+                                                    Ref<const ArrayPredictionContext> b,
+                                                    bool rootIsWildcard,
+                                                    PredictionContextMergeCache *mergeCache);
 
-  protected:
-    /// Make pass over all M parents; merge any equal() ones.
-    /// @returns true if the list has been changed (i.e. duplicates where found).
-    static bool combineCommonParents(std::vector<Ref<PredictionContext>> &parents);
+    static std::string toDOTString(const Ref<const PredictionContext> &context);
 
-  public:
-    static std::string toDOTString(const Ref<PredictionContext> &context);
+    static Ref<const PredictionContext> getCachedContext(const Ref<const PredictionContext> &context,
+                                                         PredictionContextCache &contextCache);
 
-    static Ref<PredictionContext> getCachedContext(const Ref<PredictionContext> &context,
-      PredictionContextCache &contextCache,
-      std::map<Ref<PredictionContext>, Ref<PredictionContext>> &visited);
+    static std::vector<Ref<const PredictionContext>> getAllContextNodes(const Ref<const PredictionContext> &context);
 
-    // ter's recursive version of Sam's getAllNodes()
-    static std::vector<Ref<PredictionContext>> getAllContextNodes(const Ref<PredictionContext> &context);
-    static void getAllContextNodes_(const Ref<PredictionContext> &context,
-      std::vector<Ref<PredictionContext>> &nodes, std::set<PredictionContext *> &visited);
+    /// Convert a RuleContext tree to a PredictionContext graph.
+    /// Return EMPTY if outerContext is empty.
+    static Ref<const PredictionContext> fromRuleContext(const ATN &atn, RuleContext *outerContext);
 
-    virtual std::string toString() const;
-    virtual std::string toString(Recognizer *recog) const;
+    PredictionContext(const PredictionContext&) = delete;
 
-    std::vector<std::string> toStrings(Recognizer *recognizer, int currentState);
-    std::vector<std::string> toStrings(Recognizer *recognizer, const Ref<PredictionContext> &stop, int currentState);
-  };
+    virtual ~PredictionContext() = default;
 
-  struct PredictionContextHasher {
-    size_t operator () (const Ref<PredictionContext> &k) const {
-      return k->hashCode();
-    }
-  };
+    PredictionContext& operator=(const PredictionContext&) = delete;
+    PredictionContext& operator=(PredictionContext&&) = delete;
 
-  struct PredictionContextComparer {
-    bool operator () (const Ref<PredictionContext> &lhs, const Ref<PredictionContext> &rhs) const
-    {
-      if (lhs == rhs) // Object identity.
-        return true;
-      return (lhs->hashCode() == rhs->hashCode()) && (*lhs == *rhs);
-    }
-  };
+    PredictionContextType getContextType() const { return _contextType; }
 
-  class PredictionContextMergeCache {
-  public:
-    Ref<PredictionContext> put(Ref<PredictionContext> const& key1, Ref<PredictionContext> const& key2,
-                               Ref<PredictionContext> const& value);
-    Ref<PredictionContext> get(Ref<PredictionContext> const& key1, Ref<PredictionContext> const& key2);
+    virtual size_t size() const = 0;
+    virtual const Ref<const PredictionContext>& getParent(size_t index) const = 0;
+    virtual size_t getReturnState(size_t index) const = 0;
 
-    void clear();
-    std::string toString() const;
-    size_t count() const;
+    /// This means only the EMPTY (wildcard? not sure) context is in set.
+    virtual bool isEmpty() const = 0;
+    bool hasEmptyPath() const;
 
-  private:
-    std::unordered_map<Ref<PredictionContext>,
-      std::unordered_map<Ref<PredictionContext>, Ref<PredictionContext>, PredictionContextHasher, PredictionContextComparer>,
-      PredictionContextHasher, PredictionContextComparer> _data;
+    size_t hashCode() const;
+
+    virtual bool equals(const PredictionContext &other) const = 0;
 
+    virtual std::string toString() const = 0;
+
+    std::vector<std::string> toStrings(Recognizer *recognizer, int currentState) const;
+    std::vector<std::string> toStrings(Recognizer *recognizer,
+                                       const Ref<const PredictionContext> &stop,
+                                       int currentState) const;
+
+  protected:
+    explicit PredictionContext(PredictionContextType contextType);
+
+    PredictionContext(PredictionContext&& other);
+
+    virtual size_t hashCodeImpl() const = 0;
+
+    size_t cachedHashCode() const { return _hashCode.load(std::memory_order_relaxed); }
+
+  private:
+    const PredictionContextType _contextType;
+    mutable std::atomic<size_t> _hashCode;
   };
 
-} // namespace atn
-} // namespace antlr4
+  inline bool operator==(const PredictionContext &lhs, const PredictionContext &rhs) {
+    return lhs.equals(rhs);
+  }
+
+  inline bool operator!=(const PredictionContext &lhs, const PredictionContext &rhs) {
+    return !operator==(lhs, rhs);
+  }
+
+}  // namespace atn
+}  // namespace antlr4
+
+namespace std {
+
+  template <>
+  struct hash<::antlr4::atn::PredictionContext> {
+    size_t operator()(const ::antlr4::atn::PredictionContext &predictionContext) const {
+      return predictionContext.hashCode();
+    }
+  };
 
+}  // namespace std

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

@@ -0,0 +1,56 @@
+// Copyright 2012-2022 The ANTLR Project
+//
+// Redistribution and use in source and binary forms, with or without modification, are permitted
+// provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of conditions
+//    and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list of
+//    conditions and the following disclaimer in the documentation and/or other materials provided
+//    with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be used to
+//    endorse or promote products derived from this software without specific prior written
+//    permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
+// WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "atn/PredictionContextCache.h"
+
+using namespace antlr4::atn;
+
+void PredictionContextCache::put(const Ref<const PredictionContext> &value) {
+  assert(value);
+
+  _data.insert(value);
+}
+
+Ref<const PredictionContext> PredictionContextCache::get(
+    const Ref<const PredictionContext> &value) const {
+  assert(value);
+
+  auto iterator = _data.find(value);
+  if (iterator == _data.end()) {
+    return nullptr;
+  }
+  return *iterator;
+}
+
+size_t PredictionContextCache::PredictionContextHasher::operator()(
+    const Ref<const PredictionContext> &predictionContext) const {
+  return predictionContext->hashCode();
+}
+
+bool PredictionContextCache::PredictionContextComparer::operator()(
+    const Ref<const PredictionContext> &lhs,
+    const Ref<const PredictionContext> &rhs) const {
+  return *lhs == *rhs;
+}

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

@@ -0,0 +1,64 @@
+// Copyright 2012-2022 The ANTLR Project
+//
+// Redistribution and use in source and binary forms, with or without modification, are permitted
+// provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of conditions
+//    and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list of
+//    conditions and the following disclaimer in the documentation and/or other materials provided
+//    with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be used to
+//    endorse or promote products derived from this software without specific prior written
+//    permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
+// WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <unordered_set>
+
+#include "atn/PredictionContext.h"
+
+namespace antlr4 {
+namespace atn {
+
+  class ANTLR4CPP_PUBLIC PredictionContextCache final {
+  public:
+    PredictionContextCache() = default;
+
+    PredictionContextCache(const PredictionContextCache&) = delete;
+    PredictionContextCache(PredictionContextCache&&) = delete;
+
+    PredictionContextCache& operator=(const PredictionContextCache&) = delete;
+    PredictionContextCache& operator=(PredictionContextCache&&) = delete;
+
+    void put(const Ref<const PredictionContext> &value);
+
+    Ref<const PredictionContext> get(const Ref<const PredictionContext> &value) const;
+
+  private:
+    struct ANTLR4CPP_PUBLIC PredictionContextHasher final {
+      size_t operator()(const Ref<const PredictionContext> &predictionContext) const;
+    };
+
+    struct ANTLR4CPP_PUBLIC PredictionContextComparer final {
+      bool operator()(const Ref<const PredictionContext> &lhs,
+                      const Ref<const PredictionContext> &rhs) const;
+    };
+
+    std::unordered_set<Ref<const PredictionContext>,
+                       PredictionContextHasher, PredictionContextComparer> _data;
+  };
+
+}  // namespace atn
+}  // namespace antlr4

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

@@ -0,0 +1,167 @@
+// Copyright 2012-2022 The ANTLR Project
+//
+// Redistribution and use in source and binary forms, with or without modification, are permitted
+// provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of conditions
+//    and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list of
+//    conditions and the following disclaimer in the documentation and/or other materials provided
+//    with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be used to
+//    endorse or promote products derived from this software without specific prior written
+//    permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
+// WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "atn/PredictionContextMergeCache.h"
+
+#include "misc/MurmurHash.h"
+
+using namespace antlr4::atn;
+using namespace antlr4::misc;
+
+PredictionContextMergeCache::PredictionContextMergeCache(
+    const PredictionContextMergeCacheOptions &options) : _options(options) {}
+
+Ref<const PredictionContext> PredictionContextMergeCache::put(
+    const Ref<const PredictionContext> &key1,
+    const Ref<const PredictionContext> &key2,
+    Ref<const PredictionContext> value) {
+  assert(key1);
+  assert(key2);
+
+  if (getOptions().getMaxSize() == 0) {
+    // Cache is effectively disabled.
+    return value;
+  }
+
+  auto [existing, inserted] = _entries.try_emplace(std::make_pair(key1.get(), key2.get()));
+  if (inserted) {
+    try {
+      existing->second.reset(new Entry());
+    } catch (...) {
+      _entries.erase(existing);
+      throw;
+    }
+    existing->second->key = std::make_pair(key1, key2);
+    existing->second->value = std::move(value);
+    pushToFront(existing->second.get());
+  } else {
+    if (existing->second->value != value) {
+      existing->second->value = std::move(value);
+    }
+    moveToFront(existing->second.get());
+  }
+  compact(existing->second.get());
+  return existing->second->value;
+}
+
+Ref<const PredictionContext> PredictionContextMergeCache::get(
+    const Ref<const PredictionContext> &key1,
+    const Ref<const PredictionContext> &key2) const {
+  assert(key1);
+  assert(key2);
+
+  if (getOptions().getMaxSize() == 0) {
+    // Cache is effectively disabled.
+    return nullptr;
+  }
+
+  auto iterator = _entries.find(std::make_pair(key1.get(), key2.get()));
+  if (iterator == _entries.end()) {
+    return nullptr;
+  }
+  moveToFront(iterator->second.get());
+  return iterator->second->value;
+}
+
+void PredictionContextMergeCache::clear() {
+  Container().swap(_entries);
+  _head = _tail = nullptr;
+  _size = 0;
+}
+
+void PredictionContextMergeCache::moveToFront(Entry *entry) const {
+  if (entry->prev == nullptr) {
+    assert(entry == _head);
+    return;
+  }
+  entry->prev->next = entry->next;
+  if (entry->next != nullptr) {
+    entry->next->prev = entry->prev;
+  } else {
+    assert(entry == _tail);
+    _tail = entry->prev;
+  }
+  entry->prev = nullptr;
+  entry->next = _head;
+  _head->prev = entry;
+  _head = entry;
+  assert(entry->prev == nullptr);
+}
+
+void PredictionContextMergeCache::pushToFront(Entry *entry) {
+  ++_size;
+  entry->prev = nullptr;
+  entry->next = _head;
+  if (_head != nullptr) {
+    _head->prev = entry;
+    _head = entry;
+  } else {
+    assert(entry->next == nullptr);
+    _head = entry;
+    _tail = entry;
+  }
+  assert(entry->prev == nullptr);
+}
+
+void PredictionContextMergeCache::remove(Entry *entry) {
+  if (entry->prev != nullptr) {
+    entry->prev->next = entry->next;
+  } else {
+    assert(entry == _head);
+    _head = entry->next;
+  }
+  if (entry->next != nullptr) {
+    entry->next->prev = entry->prev;
+  } else {
+    assert(entry == _tail);
+    _tail = entry->prev;
+  }
+  --_size;
+  _entries.erase(std::make_pair(entry->key.first.get(), entry->key.second.get()));
+}
+
+void PredictionContextMergeCache::compact(const Entry *preserve) {
+  Entry *entry = _tail;
+  while (entry != nullptr && _size > getOptions().getMaxSize()) {
+    Entry *next = entry->prev;
+    if (entry != preserve) {
+      remove(entry);
+    }
+    entry = next;
+  }
+}
+
+size_t PredictionContextMergeCache::PredictionContextHasher::operator()(
+    const PredictionContextPair &value) const {
+  size_t hash = MurmurHash::initialize();
+  hash = MurmurHash::update(hash, value.first->hashCode());
+  hash = MurmurHash::update(hash, value.second->hashCode());
+  return MurmurHash::finish(hash, 2);
+}
+
+bool PredictionContextMergeCache::PredictionContextComparer::operator()(
+    const PredictionContextPair &lhs, const PredictionContextPair &rhs) const {
+  return *lhs.first == *rhs.first && *lhs.second == *rhs.second;
+}

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

@@ -0,0 +1,101 @@
+// Copyright 2012-2022 The ANTLR Project
+//
+// Redistribution and use in source and binary forms, with or without modification, are permitted
+// provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of conditions
+//    and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list of
+//    conditions and the following disclaimer in the documentation and/or other materials provided
+//    with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be used to
+//    endorse or promote products derived from this software without specific prior written
+//    permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
+// WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <unordered_map>
+#include <utility>
+
+#include "atn/PredictionContext.h"
+#include "atn/PredictionContextMergeCacheOptions.h"
+
+namespace antlr4 {
+namespace atn {
+
+  class ANTLR4CPP_PUBLIC PredictionContextMergeCache final {
+  public:
+    PredictionContextMergeCache()
+        : PredictionContextMergeCache(PredictionContextMergeCacheOptions()) {}
+
+    explicit PredictionContextMergeCache(const PredictionContextMergeCacheOptions &options);
+
+    PredictionContextMergeCache(const PredictionContextMergeCache&) = delete;
+    PredictionContextMergeCache(PredictionContextMergeCache&&) = delete;
+
+    PredictionContextMergeCache& operator=(const PredictionContextMergeCache&) = delete;
+    PredictionContextMergeCache& operator=(PredictionContextMergeCache&&) = delete;
+
+    Ref<const PredictionContext> put(const Ref<const PredictionContext> &key1,
+                                     const Ref<const PredictionContext> &key2,
+                                     Ref<const PredictionContext> value);
+
+    Ref<const PredictionContext> get(const Ref<const PredictionContext> &key1,
+                                     const Ref<const PredictionContext> &key2) const;
+
+    const PredictionContextMergeCacheOptions& getOptions() const { return _options; }
+
+    void clear();
+
+  private:
+    using PredictionContextPair = std::pair<const PredictionContext*, const PredictionContext*>;
+
+    struct ANTLR4CPP_PUBLIC PredictionContextHasher final {
+      size_t operator()(const PredictionContextPair &value) const;
+    };
+
+    struct ANTLR4CPP_PUBLIC PredictionContextComparer final {
+      bool operator()(const PredictionContextPair &lhs, const PredictionContextPair &rhs) const;
+    };
+
+    struct ANTLR4CPP_PUBLIC Entry final {
+      std::pair<Ref<const PredictionContext>, Ref<const PredictionContext>> key;
+      Ref<const PredictionContext> value;
+      Entry *prev = nullptr;
+      Entry *next = nullptr;
+    };
+
+    void moveToFront(Entry *entry) const;
+
+    void pushToFront(Entry *entry);
+
+    void remove(Entry *entry);
+
+    void compact(const Entry *preserve);
+
+    using Container = std::unordered_map<PredictionContextPair, std::unique_ptr<Entry>,
+                                         PredictionContextHasher, PredictionContextComparer>;
+
+    const PredictionContextMergeCacheOptions _options;
+
+    Container _entries;
+
+    mutable Entry *_head = nullptr;
+    mutable Entry *_tail = nullptr;
+
+    size_t _size = 0;
+  };
+
+}  // namespace atn
+}  // namespace antlr4