expressir 1.2.4 → 1.2.5

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

@@ -0,0 +1,242 @@
+/* Copyright (c) 2021 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 <cassert>
+#include <cstdint>
+
+#include "support/Utf8.h"
+#include "support/Unicode.h"
+
+// The below implementation is based off of https://github.com/google/cel-cpp/internal/utf8.cc,
+// which is itself based off of https://go.googlesource.com/go/+/refs/heads/master/src/unicode/utf8/utf8.go.
+// If for some reason you feel the need to copy this implementation, please retain a comment
+// referencing the two source files and giving credit, as well as maintaining any and all
+// obligations required by the BSD 3-clause license that governs this file.
+
+namespace antlrcpp {
+
+namespace {
+
+#undef SELF
+  constexpr uint8_t SELF = 0x80;
+
+#undef LOW
+  constexpr uint8_t LOW = 0x80;
+#undef HIGH
+  constexpr uint8_t HIGH = 0xbf;
+
+#undef MASKX
+  constexpr uint8_t MASKX = 0x3f;
+#undef MASK2
+  constexpr uint8_t MASK2 = 0x1f;
+#undef MASK3
+  constexpr uint8_t MASK3 = 0xf;
+#undef MASK4
+  constexpr uint8_t MASK4 = 0x7;
+
+#undef TX
+  constexpr uint8_t TX = 0x80;
+#undef T2
+  constexpr uint8_t T2 = 0xc0;
+#undef T3
+  constexpr uint8_t T3 = 0xe0;
+#undef T4
+  constexpr uint8_t T4 = 0xf0;
+
+#undef XX
+  constexpr uint8_t XX = 0xf1;
+#undef AS
+  constexpr uint8_t AS = 0xf0;
+#undef S1
+  constexpr uint8_t S1 = 0x02;
+#undef S2
+  constexpr uint8_t S2 = 0x13;
+#undef S3
+  constexpr uint8_t S3 = 0x03;
+#undef S4
+  constexpr uint8_t S4 = 0x23;
+#undef S5
+  constexpr uint8_t S5 = 0x34;
+#undef S6
+  constexpr uint8_t S6 = 0x04;
+#undef S7
+  constexpr uint8_t S7 = 0x44;
+
+  // NOLINTBEGIN
+  // clang-format off
+#undef LEADING
+  constexpr uint8_t LEADING[256] = {
+    //   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
+    AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, // 0x00-0x0F
+    AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, // 0x10-0x1F
+    AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, // 0x20-0x2F
+    AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, // 0x30-0x3F
+    AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, // 0x40-0x4F
+    AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, // 0x50-0x5F
+    AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, // 0x60-0x6F
+    AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, // 0x70-0x7F
+    //   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
+    XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, // 0x80-0x8F
+    XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, // 0x90-0x9F
+    XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, // 0xA0-0xAF
+    XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, // 0xB0-0xBF
+    XX, XX, S1, S1, S1, S1, S1, S1, S1, S1, S1, S1, S1, S1, S1, S1, // 0xC0-0xCF
+    S1, S1, S1, S1, S1, S1, S1, S1, S1, S1, S1, S1, S1, S1, S1, S1, // 0xD0-0xDF
+    S2, S3, S3, S3, S3, S3, S3, S3, S3, S3, S3, S3, S3, S4, S3, S3, // 0xE0-0xEF
+    S5, S6, S6, S6, S7, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, // 0xF0-0xFF
+  };
+  // clang-format on
+  // NOLINTEND
+
+#undef ACCEPT
+  constexpr std::pair<uint8_t, uint8_t> ACCEPT[16] = {
+      {LOW, HIGH}, {0xa0, HIGH}, {LOW, 0x9f}, {0x90, HIGH},
+      {LOW, 0x8f}, {0x0, 0x0},   {0x0, 0x0},  {0x0, 0x0},
+      {0x0, 0x0},  {0x0, 0x0},   {0x0, 0x0},  {0x0, 0x0},
+      {0x0, 0x0},  {0x0, 0x0},   {0x0, 0x0},  {0x0, 0x0},
+  };
+
+}  // namespace
+
+  std::pair<char32_t, size_t> Utf8::decode(std::string_view input) {
+    assert(!input.empty());
+    const auto b = static_cast<uint8_t>(input.front());
+    input.remove_prefix(1);
+    if (b < SELF) {
+      return {static_cast<char32_t>(b), 1};
+    }
+    const auto leading = LEADING[b];
+    if (leading == XX) {
+      return {Unicode::REPLACEMENT_CHARACTER, 1};
+    }
+    auto size = static_cast<size_t>(leading & 7) - 1;
+    if (size > input.size()) {
+      return {Unicode::REPLACEMENT_CHARACTER, 1};
+    }
+    const auto& accept = ACCEPT[leading >> 4];
+    const auto b1 = static_cast<uint8_t>(input.front());
+    input.remove_prefix(1);
+    if (b1 < accept.first || b1 > accept.second) {
+      return {Unicode::REPLACEMENT_CHARACTER, 1};
+    }
+    if (size <= 1) {
+      return {(static_cast<char32_t>(b & MASK2) << 6) |
+                  static_cast<char32_t>(b1 & MASKX),
+              2};
+    }
+    const auto b2 = static_cast<uint8_t>(input.front());
+    input.remove_prefix(1);
+    if (b2 < LOW || b2 > HIGH) {
+      return {Unicode::REPLACEMENT_CHARACTER, 1};
+    }
+    if (size <= 2) {
+      return {(static_cast<char32_t>(b & MASK3) << 12) |
+                  (static_cast<char32_t>(b1 & MASKX) << 6) |
+                  static_cast<char32_t>(b2 & MASKX),
+              3};
+    }
+    const auto b3 = static_cast<uint8_t>(input.front());
+    input.remove_prefix(1);
+    if (b3 < LOW || b3 > HIGH) {
+      return {Unicode::REPLACEMENT_CHARACTER, 1};
+    }
+    return {(static_cast<char32_t>(b & MASK4) << 18) |
+                (static_cast<char32_t>(b1 & MASKX) << 12) |
+                (static_cast<char32_t>(b2 & MASKX) << 6) |
+                static_cast<char32_t>(b3 & MASKX),
+            4};
+  }
+
+  std::optional<std::u32string> Utf8::strictDecode(std::string_view input) {
+    std::u32string output;
+    char32_t codePoint;
+    size_t codeUnits;
+    output.reserve(input.size());  // Worst case is each byte is a single Unicode code point.
+    for (size_t index = 0; index < input.size(); index += codeUnits) {
+      std::tie(codePoint, codeUnits) = Utf8::decode(input.substr(index));
+      if (codePoint == Unicode::REPLACEMENT_CHARACTER && codeUnits == 1) {
+        // Condition is only met when an illegal byte sequence is encountered. See Utf8::decode.
+        return std::nullopt;
+      }
+      output.push_back(codePoint);
+    }
+    output.shrink_to_fit();
+    return output;
+  }
+
+  std::u32string Utf8::lenientDecode(std::string_view input) {
+    std::u32string output;
+    char32_t codePoint;
+    size_t codeUnits;
+    output.reserve(input.size());  // Worst case is each byte is a single Unicode code point.
+    for (size_t index = 0; index < input.size(); index += codeUnits) {
+      std::tie(codePoint, codeUnits) = Utf8::decode(input.substr(index));
+      output.push_back(codePoint);
+    }
+    output.shrink_to_fit();
+    return output;
+  }
+
+  std::string& Utf8::encode(std::string* buffer, char32_t codePoint) {
+    assert(buffer != nullptr);
+    if (!Unicode::isValid(codePoint)) {
+      codePoint = Unicode::REPLACEMENT_CHARACTER;
+    }
+    if (codePoint <= 0x7f) {
+      buffer->push_back(static_cast<char>(static_cast<uint8_t>(codePoint)));
+    } else if (codePoint <= 0x7ff) {
+      buffer->push_back(
+          static_cast<char>(T2 | static_cast<uint8_t>(codePoint >> 6)));
+      buffer->push_back(
+          static_cast<char>(TX | (static_cast<uint8_t>(codePoint) & MASKX)));
+    } else if (codePoint <= 0xffff) {
+      buffer->push_back(
+          static_cast<char>(T3 | static_cast<uint8_t>(codePoint >> 12)));
+      buffer->push_back(static_cast<char>(
+          TX | (static_cast<uint8_t>(codePoint >> 6) & MASKX)));
+      buffer->push_back(
+          static_cast<char>(TX | (static_cast<uint8_t>(codePoint) & MASKX)));
+    } else {
+      buffer->push_back(
+          static_cast<char>(T4 | static_cast<uint8_t>(codePoint >> 18)));
+      buffer->push_back(static_cast<char>(
+          TX | (static_cast<uint8_t>(codePoint >> 12) & MASKX)));
+      buffer->push_back(static_cast<char>(
+          TX | (static_cast<uint8_t>(codePoint >> 6) & MASKX)));
+      buffer->push_back(
+          static_cast<char>(TX | (static_cast<uint8_t>(codePoint) & MASKX)));
+    }
+    return *buffer;
+  }
+
+  std::optional<std::string> Utf8::strictEncode(std::u32string_view input) {
+    std::string output;
+    output.reserve(input.size() * 4);  // Worst case is each Unicode code point encodes to 4 bytes.
+    for (size_t index = 0; index < input.size(); index++) {
+      char32_t codePoint = input[index];
+      if (!Unicode::isValid(codePoint)) {
+        return std::nullopt;
+      }
+      Utf8::encode(&output, codePoint);
+    }
+    output.shrink_to_fit();
+    return output;
+  }
+
+  std::string Utf8::lenientEncode(std::u32string_view input) {
+    std::string output;
+    output.reserve(input.size() * 4);  // Worst case is each Unicode code point encodes to 4 bytes.
+    for (size_t index = 0; index < input.size(); index++) {
+      char32_t codePoint = input[index];
+      if (!Unicode::isValid(codePoint)) {
+        codePoint = Unicode::REPLACEMENT_CHARACTER;
+      }
+      Utf8::encode(&output, codePoint);
+    }
+    output.shrink_to_fit();
+    return output;
+  }
+
+}

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

@@ -0,0 +1,54 @@
+/* Copyright (c) 2021 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 <optional>
+#include <string>
+#include <string_view>
+#include <tuple>
+
+#include "antlr4-common.h"
+
+namespace antlrcpp {
+
+  class ANTLR4CPP_PUBLIC Utf8 final {
+  public:
+    // Decodes the next code point, returning the decoded code point and the number
+    // of code units (a.k.a. bytes) consumed. In the event that an invalid code unit
+    // sequence is returned the replacement character, U+FFFD, is returned with a
+    // code unit count of 1. As U+FFFD requires 3 code units when encoded, this can
+    // be used to differentiate valid input from malformed input.
+    static std::pair<char32_t, size_t> decode(std::string_view input);
+
+    // Decodes the given UTF-8 encoded input into a string of code points.
+    static std::optional<std::u32string> strictDecode(std::string_view input);
+
+    // Decodes the given UTF-8 encoded input into a string of code points. Unlike strictDecode(),
+    // each byte in an illegal byte sequence is replaced with the Unicode replacement character,
+    // U+FFFD.
+    static std::u32string lenientDecode(std::string_view input);
+
+    // Encodes the given code point and appends it to the buffer. If the code point
+    // is an unpaired surrogate or outside of the valid Unicode range it is replaced
+    // with the replacement character, U+FFFD.
+    static std::string& encode(std::string *buffer, char32_t codePoint);
+
+    // Encodes the given Unicode code point string as UTF-8.
+    static std::optional<std::string> strictEncode(std::u32string_view input);
+
+    // Encodes the given Unicode code point string as UTF-8. Unlike strictEncode(),
+    // each invalid Unicode code point is replaced with the Unicode replacement character, U+FFFD.
+    static std::string lenientEncode(std::u32string_view input);
+
+  private:
+    Utf8() = delete;
+    Utf8(const Utf8&) = delete;
+    Utf8(Utf8&&) = delete;
+    Utf8& operator=(const Utf8&) = delete;
+    Utf8& operator=(Utf8&&) = delete;
+  };
+
+}

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

@@ -5,6 +5,7 @@
 
 #pragma once
 
+#include "tree/ParseTree.h"
 #include "tree/ParseTreeVisitor.h"
 
 namespace antlr4 {
@@ -14,7 +15,7 @@ namespace tree {
   public:
     /// The default implementation calls <seealso cref="ParseTree#accept"/> on the
     /// specified tree.
-    virtual antlrcpp::Any visit(ParseTree *tree) override {
+    virtual std::any visit(ParseTree *tree) override {
       return tree->accept(this);
     }
 
@@ -31,16 +32,16 @@ namespace tree {
      * the tree structure. Visitors that modify the tree should override this
      * method to behave properly in respect to the specific algorithm in use.</p>
      */
-    virtual antlrcpp::Any visitChildren(ParseTree *node) override {
-      antlrcpp::Any result = defaultResult();
+    virtual std::any visitChildren(ParseTree *node) override {
+      std::any result = defaultResult();
       size_t n = node->children.size();
       for (size_t i = 0; i < n; i++) {
         if (!shouldVisitNextChild(node, result)) {
           break;
         }
 
-        antlrcpp::Any childResult = node->children[i]->accept(this);
-        result = aggregateResult(result, childResult);
+        std::any childResult = node->children[i]->accept(this);
+        result = aggregateResult(std::move(result), std::move(childResult));
       }
 
       return result;
@@ -48,13 +49,13 @@ namespace tree {
 
     /// The default implementation returns the result of
     /// <seealso cref="#defaultResult defaultResult"/>.
-    virtual antlrcpp::Any visitTerminal(TerminalNode * /*node*/) override {
+    virtual std::any visitTerminal(TerminalNode * /*node*/) override {
       return defaultResult();
     }
 
     /// The default implementation returns the result of
     /// <seealso cref="#defaultResult defaultResult"/>.
-    virtual antlrcpp::Any visitErrorNode(ErrorNode * /*node*/) override {
+    virtual std::any visitErrorNode(ErrorNode * /*node*/) override {
       return defaultResult();
     }
 
@@ -66,11 +67,11 @@ namespace tree {
     /// The default implementation of <seealso cref="#visitChildren visitChildren"/>
     /// initializes its aggregate result to this value.
     /// <p/>
-    /// The base implementation returns {@code null}.
+    /// The base implementation returns {@code std::any()}.
     /// </summary>
     /// <returns> The default value returned by visitor methods. </returns>
-    virtual antlrcpp::Any defaultResult() {
-      return nullptr; // support isNotNull
+    virtual std::any defaultResult() {
+      return std::any();
     }
 
     /// <summary>
@@ -91,7 +92,7 @@ namespace tree {
     /// a child node.
     /// </param>
     /// <returns> The updated aggregate result. </returns>
-    virtual antlrcpp::Any aggregateResult(antlrcpp::Any /*aggregate*/, const antlrcpp::Any &nextResult) {
+    virtual std::any aggregateResult(std::any /*aggregate*/, std::any nextResult) {
       return nextResult;
     }
 
@@ -118,7 +119,7 @@ namespace tree {
     /// <returns> {@code true} to continue visiting children. Otherwise return
     /// {@code false} to stop visiting children and immediately return the
     /// current aggregate result from <seealso cref="#visitChildren"/>. </returns>
-    virtual bool shouldVisitNextChild(ParseTree * /*node*/, const antlrcpp::Any &/*currentResult*/) {
+    virtual bool shouldVisitNextChild(ParseTree * /*node*/, const std::any &/*currentResult*/) {
       return true;
     }
 

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

@@ -10,9 +10,14 @@
 namespace antlr4 {
 namespace tree {
 
-  class ANTLR4CPP_PUBLIC ErrorNode : public virtual TerminalNode {
+  class ANTLR4CPP_PUBLIC ErrorNode : public TerminalNode {
   public:
-    ~ErrorNode() override;
+    static bool is(const tree::ParseTree &parseTree) { return parseTree.getTreeType() == tree::ParseTreeType::ERROR; }
+
+    static bool is(const tree::ParseTree *parseTree) { return parseTree != nullptr && is(*parseTree); }
+
+  protected:
+    using TerminalNode::TerminalNode;
   };
 
 } // namespace tree

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

@@ -3,21 +3,52 @@
  * can be found in the LICENSE.txt file in the project root.
  */
 
-#include "Exceptions.h"
+#include "misc/Interval.h"
+#include "Token.h"
+#include "RuleContext.h"
 #include "tree/ParseTreeVisitor.h"
 
 #include "tree/ErrorNodeImpl.h"
 
 using namespace antlr4;
-using namespace antlr4::misc;
 using namespace antlr4::tree;
 
-ErrorNodeImpl::ErrorNodeImpl(Token *token) : TerminalNodeImpl(token) {
+Token* ErrorNodeImpl::getSymbol() const {
+  return symbol;
 }
 
-ErrorNodeImpl::~ErrorNodeImpl() {
+void ErrorNodeImpl::setParent(RuleContext *parent_) {
+  this->parent = parent_;
 }
 
-antlrcpp::Any ErrorNodeImpl::accept(ParseTreeVisitor *visitor) {
+misc::Interval ErrorNodeImpl::getSourceInterval() {
+  if (symbol == nullptr) {
+    return misc::Interval::INVALID;
+  }
+
+  size_t tokenIndex = symbol->getTokenIndex();
+  return misc::Interval(tokenIndex, tokenIndex);
+}
+
+std::any ErrorNodeImpl::accept(ParseTreeVisitor *visitor) {
   return visitor->visitErrorNode(this);
 }
+
+std::string ErrorNodeImpl::getText() {
+  return symbol->getText();
+}
+
+std::string ErrorNodeImpl::toStringTree(Parser * /*parser*/, bool /*pretty*/) {
+  return toString();
+}
+
+std::string ErrorNodeImpl::toString() {
+  if (symbol->getType() == Token::EOF) {
+    return "<EOF>";
+  }
+  return symbol->getText();
+}
+
+std::string ErrorNodeImpl::toStringTree(bool /*pretty*/) {
+  return toString();
+}

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

@@ -21,12 +21,22 @@ namespace tree {
   ///  and deletion as well as during "consume until error recovery set"
   ///  upon no viable alternative exceptions.
   /// </summary>
-  class ANTLR4CPP_PUBLIC ErrorNodeImpl : public virtual TerminalNodeImpl, public virtual ErrorNode {
+  class ANTLR4CPP_PUBLIC ErrorNodeImpl : public ErrorNode {
   public:
-    ErrorNodeImpl(Token *token);
-    ~ErrorNodeImpl() override;
+    Token *symbol;
 
-    virtual antlrcpp::Any accept(ParseTreeVisitor *visitor) override;
+    explicit ErrorNodeImpl(Token *symbol) : ErrorNode(ParseTreeType::ERROR), symbol(symbol) {}
+
+    virtual Token* getSymbol() const override;
+    virtual void setParent(RuleContext *parent) override;
+    virtual misc::Interval getSourceInterval() override;
+
+    virtual std::any accept(ParseTreeVisitor *visitor) override;
+
+    virtual std::string getText() override;
+    virtual std::string toStringTree(Parser *parser, bool pretty = false) override;
+    virtual std::string toString() override;
+    virtual std::string toStringTree(bool pretty = false) override;
   };
 
 } // namespace tree

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

@@ -4,6 +4,7 @@
  */
 
 #include "support/CPPUtils.h"
+#include "support/Casts.h"
 
 #include "tree/ParseTreeListener.h"
 #include "tree/ParseTree.h"
@@ -12,29 +13,26 @@
 #include "IterativeParseTreeWalker.h"
 
 using namespace antlr4::tree;
+using namespace antlrcpp;
 
 void IterativeParseTreeWalker::walk(ParseTreeListener *listener, ParseTree *t) const {
-
-  std::vector<ParseTree *> nodeStack;
-  std::vector<size_t> indexStack;
-
+  std::vector<std::pair<ParseTree*, size_t>> stack;
   ParseTree *currentNode = t;
   size_t currentIndex = 0;
 
   while (currentNode != nullptr) {
     // pre-order visit
-    if (antlrcpp::is<ErrorNode *>(currentNode)) {
-      listener->visitErrorNode(dynamic_cast<ErrorNode *>(currentNode));
-    } else if (antlrcpp::is<TerminalNode *>(currentNode)) {
-      listener->visitTerminal((TerminalNode *)currentNode);
+    if (ErrorNode::is(*currentNode)) {
+      listener->visitErrorNode(downCast<ErrorNode*>(currentNode));
+    } else if (TerminalNode::is(*currentNode)) {
+      listener->visitTerminal(downCast<TerminalNode*>(currentNode));
     } else {
       enterRule(listener, currentNode);
     }
 
     // Move down to first child, if it exists.
     if (!currentNode->children.empty()) {
-      nodeStack.push_back(currentNode);
-      indexStack.push_back(currentIndex);
+      stack.push_back(std::make_pair(currentNode, currentIndex));
       currentIndex = 0;
       currentNode = currentNode->children[0];
       continue;
@@ -43,29 +41,26 @@ void IterativeParseTreeWalker::walk(ParseTreeListener *listener, ParseTree *t) c
     // No child nodes, so walk tree.
     do {
       // post-order visit
-      if (!antlrcpp::is<TerminalNode *>(currentNode)) {
+      if (!TerminalNode::is(*currentNode)) {
         exitRule(listener, currentNode);
       }
 
       // No parent, so no siblings.
-      if (nodeStack.empty()) {
+      if (stack.empty()) {
         currentNode = nullptr;
         currentIndex = 0;
         break;
       }
 
       // Move to next sibling if possible.
-      if (nodeStack.back()->children.size() > ++currentIndex) {
-        currentNode = nodeStack.back()->children[currentIndex];
+      if (stack.back().first->children.size() > ++currentIndex) {
+        currentNode = stack.back().first->children[currentIndex];
         break;
       }
 
       // No next sibling, so move up.
-      currentNode = nodeStack.back();
-      nodeStack.pop_back();
-      currentIndex = indexStack.back();
-      indexStack.pop_back();
-
+      std::tie(currentNode, currentIndex) = stack.back();
+      stack.pop_back();
     } while (currentNode != nullptr);
   }
 }

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

@@ -7,9 +7,6 @@
 
 using namespace antlr4::tree;
 
-ParseTree::ParseTree() : parent(nullptr) {
-}
-
 bool ParseTree::operator == (const ParseTree &other) const {
   return &other == this;
 }

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

@@ -6,6 +6,7 @@
 #pragma once
 
 #include "support/Any.h"
+#include "tree/ParseTreeType.h"
 
 namespace antlr4 {
 namespace tree {
@@ -19,15 +20,15 @@ namespace tree {
   // ml: This class unites 4 Java classes: RuleNode, ParseTree, SyntaxTree and Tree.
   class ANTLR4CPP_PUBLIC ParseTree {
   public:
-    ParseTree();
     ParseTree(ParseTree const&) = delete;
-    virtual ~ParseTree() {}
+
+    virtual ~ParseTree() = default;
 
     ParseTree& operator=(ParseTree const&) = delete;
 
     /// The parent of this node. If the return value is null, then this
     /// node is the root of the tree.
-    ParseTree *parent;
+    ParseTree *parent = nullptr;
 
     /// If we are debugging or building a parse tree for a visitor,
     /// we need to track all of the tokens and rule invocations associated
@@ -50,7 +51,7 @@ namespace tree {
 
     /// The <seealso cref="ParseTreeVisitor"/> needs a double dispatch method.
     // ml: This has been changed to use Any instead of a template parameter, to avoid the need of a virtual template function.
-    virtual antlrcpp::Any accept(ParseTreeVisitor *visitor) = 0;
+    virtual std::any accept(ParseTreeVisitor *visitor) = 0;
 
     /// Return the combined text of all leaf nodes. Does not get any
     /// off-channel tokens (if any) so won't return whitespace and
@@ -74,6 +75,14 @@ namespace tree {
      * EOF is unspecified.</p>
      */
     virtual misc::Interval getSourceInterval() = 0;
+
+    ParseTreeType getTreeType() const { return _treeType; }
+
+  protected:
+    explicit ParseTree(ParseTreeType treeType) : _treeType(treeType) {}
+
+  private:
+    const ParseTreeType _treeType;
   };
 
   // A class to help managing ParseTree instances without the need of a shared_ptr.

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

@@ -0,0 +1,22 @@
+/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+ * Use of this file is governed by the BSD 3-clause license that
+ * can be found in the LICENSE.txt file in the project root.
+ */
+
+#pragma once
+
+#include <cstddef>
+
+#include "antlr4-common.h"
+
+namespace antlr4 {
+namespace tree {
+
+  enum class ParseTreeType : size_t {
+    TERMINAL = 1,
+    ERROR = 2,
+    RULE = 3,
+  };
+
+} // namespace tree
+} // namespace antlr4