expressir 1.2.4 → 1.2.5

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

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

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

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

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

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

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

@@ -4,10 +4,11 @@
  */
 
 #include "RuntimeMetaData.h"
+#include "Version.h"
 
 using namespace antlr4;
 
-const std::string RuntimeMetaData::VERSION = "4.9.2";
+const std::string RuntimeMetaData::VERSION = ANTLRCPP_VERSION_STRING;
 
 std::string RuntimeMetaData::getRuntimeVersion() {
   return VERSION;

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

@@ -14,50 +14,24 @@ namespace antlr4 {
   /// we obtained this token.
   class ANTLR4CPP_PUBLIC Token {
   public:
-#if __cplusplus >= 201703L
     static constexpr size_t INVALID_TYPE = 0;
-#else
-    enum : size_t {
-      INVALID_TYPE = 0,
-    };
-#endif
 
     /// During lookahead operations, this "token" signifies we hit rule end ATN state
     /// and did not follow it despite needing to.
-#if __cplusplus >= 201703L
     static constexpr size_t EPSILON = std::numeric_limits<size_t>::max() - 1;
     static constexpr size_t MIN_USER_TOKEN_TYPE = 1;
     static constexpr size_t EOF = IntStream::EOF;
-#else
-    enum : size_t {
-      EPSILON = static_cast<size_t>(-2), // std::numeric_limits<size_t>::max() - 1; doesn't work in VS 2013
-      MIN_USER_TOKEN_TYPE = 1,
-      EOF = IntStream::EOF,
-    };
-#endif
 
     virtual ~Token();
 
     /// All tokens go to the parser (unless skip() is called in that rule)
     /// on a particular "channel".  The parser tunes to a particular channel
     /// so that whitespace etc... can go to the parser on a "hidden" channel.
-#if __cplusplus >= 201703L
     static constexpr size_t DEFAULT_CHANNEL = 0;
-#else
-    enum : size_t {
-      DEFAULT_CHANNEL = 0,
-    };
-#endif
 
     /// Anything on different channel than DEFAULT_CHANNEL is not parsed
     /// by parser.
-#if __cplusplus >= 201703L
     static constexpr size_t HIDDEN_CHANNEL = 1;
-#else
-    enum : size_t {
-      HIDDEN_CHANNEL = 1,
-    };
-#endif
 
     /**
      * This is the minimum constant value which can be assigned to a
@@ -70,13 +44,7 @@ namespace antlr4 {
      *
      * @see Token#getChannel()
      */
-#if __cplusplus >= 201703L
     static constexpr size_t MIN_USER_CHANNEL_VALUE = 2;
-#else
-    enum : size_t {
-      MIN_USER_CHANNEL_VALUE = 2,
-    };
-#endif
 
     /// Get the text of the token.
     virtual std::string getText() const = 0;

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

@@ -93,7 +93,7 @@ TokenStreamRewriter::TokenStreamRewriter(TokenStream *tokens_) : tokens(tokens_)
 }
 
 TokenStreamRewriter::~TokenStreamRewriter() {
-  for (auto program : _programs) {
+  for (const auto &program : _programs) {
     for (auto *operation : program.second) {
       delete operation;
     }

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

@@ -5,6 +5,8 @@
 
 #pragma once
 
+#include "antlr4-common.h"
+
 namespace antlr4 {
 
   /**
@@ -86,15 +88,8 @@ namespace antlr4 {
   class ANTLR4CPP_PUBLIC TokenStreamRewriter {
   public:
     static const std::string DEFAULT_PROGRAM_NAME;
-#if __cplusplus >= 201703L
     static constexpr size_t PROGRAM_INIT_SIZE = 100;
     static constexpr size_t MIN_TOKEN_INDEX = 0;
-#else
-    enum : size_t {
-      PROGRAM_INIT_SIZE = 100,
-      MIN_TOKEN_INDEX = 0,
-    };
-#endif
 
     TokenStreamRewriter(TokenStream *tokens);
     virtual ~TokenStreamRewriter();

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

@@ -5,7 +5,7 @@
 
 #include "misc/Interval.h"
 #include "Exceptions.h"
-#include "support/StringUtils.h"
+#include "support/Utf8.h"
 
 #include "UnbufferedCharStream.h"
 
@@ -13,9 +13,8 @@ using namespace antlrcpp;
 using namespace antlr4;
 using namespace antlr4::misc;
 
-UnbufferedCharStream::UnbufferedCharStream(std::wistream &input) : _input(input) {
-  InitializeInstanceFields();
-
+UnbufferedCharStream::UnbufferedCharStream(std::wistream &input)
+    : _p(0), _numMarkers(0), _lastChar(0), _lastCharBufferStart(0), _currentCharIndex(0), _input(input) {
   // The vector's size is what used to be n in Java code.
   fill(1); // prime
 }
@@ -74,9 +73,7 @@ size_t UnbufferedCharStream::fill(size_t n) {
 }
 
 char32_t UnbufferedCharStream::nextChar()  {
-  wchar_t result = 0;
-  _input >> result;
-  return result;
+  return _input.get();
 }
 
 void UnbufferedCharStream::add(char32_t c) {
@@ -101,7 +98,7 @@ size_t UnbufferedCharStream::LA(ssize_t i) {
     return EOF;
   }
 
-  if (_data[static_cast<size_t>(index)] == 0xFFFF) {
+  if (_data[static_cast<size_t>(index)] == std::char_traits<wchar_t>::eof()) {
     return EOF;
   }
 
@@ -178,7 +175,7 @@ std::string UnbufferedCharStream::getSourceName() const {
 }
 
 std::string UnbufferedCharStream::getText(const misc::Interval &interval) {
-  if (interval.a < 0 || interval.b >= interval.a - 1) {
+  if (interval.a < 0 || interval.b < interval.a - 1) {
     throw IllegalArgumentException("invalid interval");
   }
 
@@ -195,17 +192,17 @@ std::string UnbufferedCharStream::getText(const misc::Interval &interval) {
   }
   // convert from absolute to local index
   size_t i = interval.a - bufferStartIndex;
-  return utf32_to_utf8(_data.substr(i, interval.length()));
+  auto maybeUtf8 = Utf8::strictEncode(std::u32string_view(_data).substr(i, interval.length()));
+  if (!maybeUtf8.has_value()) {
+    throw IllegalArgumentException("Unbuffered stream contains invalid Unicode code points");
+  }
+  return std::move(maybeUtf8).value();
 }
 
-size_t UnbufferedCharStream::getBufferStartIndex() const {
-  return _currentCharIndex - _p;
+std::string UnbufferedCharStream::toString() const {
+  throw UnsupportedOperationException("Unbuffered stream cannot be materialized to a string");
 }
 
-void UnbufferedCharStream::InitializeInstanceFields() {
-  _p = 0;
-  _numMarkers = 0;
-  _lastChar = 0;
-  _lastCharBufferStart = 0;
-  _currentCharIndex = 0;
+size_t UnbufferedCharStream::getBufferStartIndex() const {
+  return _currentCharIndex - _p;
 }

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

@@ -18,10 +18,10 @@ namespace antlr4 {
     /// The name or source of this char stream.
     std::string name;
 
-    UnbufferedCharStream(std::wistream &input);
+    explicit UnbufferedCharStream(std::wistream &input);
 
-    virtual void consume() override;
-    virtual size_t LA(ssize_t i) override;
+    void consume() override;
+    size_t LA(ssize_t i) override;
 
     /// <summary>
     /// Return a marker that we can release later.
@@ -30,35 +30,32 @@ namespace antlr4 {
     /// protection against misuse where {@code seek()} is called on a mark or
     /// {@code release()} is called in the wrong order.
     /// </summary>
-    virtual ssize_t mark() override;
+    ssize_t mark() override;
 
     /// <summary>
     /// Decrement number of markers, resetting buffer if we hit 0. </summary>
     /// <param name="marker"> </param>
-    virtual void release(ssize_t marker) override;
-    virtual size_t index() override;
+    void release(ssize_t marker) override;
+    size_t index() override;
 
     /// <summary>
     /// Seek to absolute character index, which might not be in the current
     ///  sliding window.  Move {@code p} to {@code index-bufferStartIndex}.
     /// </summary>
-    virtual void seek(size_t index) override;
-    virtual size_t size() override;
-    virtual std::string getSourceName() const override;
-    virtual std::string getText(const misc::Interval &interval) override;
+    void seek(size_t index) override;
+    size_t size() override;
+    std::string getSourceName() const override;
+    std::string getText(const misc::Interval &interval) override;
+
+    std::string toString() const override;
 
   protected:
     /// A moving window buffer of the data being scanned. While there's a marker,
     /// we keep adding to buffer. Otherwise, <seealso cref="#consume consume()"/> resets so
     /// we start filling at index 0 again.
     // UTF-32 encoded.
-#if defined(_MSC_VER) && _MSC_VER == 1900
-    i32string _data; // Custom type for VS 2015.
-    typedef __int32 storage_type;
-#else
     std::u32string _data;
     typedef char32_t storage_type;
-#endif
 
     /// <summary>
     /// 0..n-1 index into <seealso cref="#data data"/> of next character.
@@ -115,9 +112,6 @@ namespace antlr4 {
     virtual char32_t nextChar();
     virtual void add(char32_t c);
     size_t getBufferStartIndex() const;
-
-  private:
-    void InitializeInstanceFields();
   };
 
 } // namespace antlr4

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

@@ -0,0 +1,42 @@
+// 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 "antlr4-common.h"
+
+#define ANTLRCPP_VERSION_MAJOR 4
+#define ANTLRCPP_VERSION_MINOR 10
+#define ANTLRCPP_VERSION_PATCH 1
+
+#define ANTLRCPP_MAKE_VERSION(major, minor, patch) ((major) * 100000 + (minor) * 1000 + (patch))
+
+#define ANTLRCPP_VERSION \
+  ANTLRCPP_MAKE_VERSION(ANTLR4CPP_VERSION_MAJOR, ANTLR4CPP_VERSION_MINOR, ANTLR4CPP_VERSION_PATCH)
+
+#define ANTLRCPP_VERSION_STRING \
+  ANTLR4CPP_STRINGIFY(ANTLR4CPP_VERSION_MAJOR) "." \
+  ANTLR4CPP_STRINGIFY(ANTLR4CPP_VERSION_MINOR) "." \
+  ANTLR4CPP_STRINGIFY(ANTLR4CPP_VERSION_PATCH)

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

@@ -11,50 +11,18 @@ using namespace antlr4::dfa;
 
 const Vocabulary Vocabulary::EMPTY_VOCABULARY;
 
-Vocabulary::Vocabulary(const std::vector<std::string> &literalNames, const std::vector<std::string> &symbolicNames)
-: Vocabulary(literalNames, symbolicNames, {}) {
+Vocabulary::Vocabulary(std::vector<std::string> literalNames, std::vector<std::string> symbolicNames)
+: Vocabulary(std::move(literalNames), std::move(symbolicNames), {}) {
 }
 
-Vocabulary::Vocabulary(const std::vector<std::string> &literalNames,
-  const std::vector<std::string> &symbolicNames, const std::vector<std::string> &displayNames)
-  : _literalNames(literalNames), _symbolicNames(symbolicNames), _displayNames(displayNames),
+Vocabulary::Vocabulary(std::vector<std::string> literalNames,
+  std::vector<std::string> symbolicNames, std::vector<std::string> displayNames)
+  : _literalNames(std::move(literalNames)), _symbolicNames(std::move(symbolicNames)), _displayNames(std::move(displayNames)),
     _maxTokenType(std::max(_displayNames.size(), std::max(_literalNames.size(), _symbolicNames.size())) - 1) {
   // See note here on -1 part: https://github.com/antlr/antlr4/pull/1146
 }
 
-Vocabulary::~Vocabulary() = default;
-
-Vocabulary Vocabulary::fromTokenNames(const std::vector<std::string> &tokenNames) {
-  if (tokenNames.empty()) {
-    return EMPTY_VOCABULARY;
-  }
-
-  std::vector<std::string> literalNames = tokenNames;
-  std::vector<std::string> symbolicNames = tokenNames;
-  std::locale locale;
-  for (size_t i = 0; i < tokenNames.size(); i++) {
-    const std::string& tokenName = tokenNames[i];
-    if (tokenName.empty()) {
-      continue;
-    } else if (tokenName.front() == '\'') {
-      symbolicNames[i].clear();
-    } else if (std::isupper(tokenName.front(), locale)) {
-      literalNames[i].clear();
-    } else {
-      // wasn't a literal or symbolic name
-      literalNames[i].clear();
-      symbolicNames[i].clear();
-    }
-  }
-
-  return Vocabulary(literalNames, symbolicNames, tokenNames);
-}
-
-size_t Vocabulary::getMaxTokenType() const {
-  return _maxTokenType;
-}
-
-std::string Vocabulary::getLiteralName(size_t tokenType) const {
+std::string_view Vocabulary::getLiteralName(size_t tokenType) const {
   if (tokenType < _literalNames.size()) {
     return _literalNames[tokenType];
   }
@@ -62,7 +30,7 @@ std::string Vocabulary::getLiteralName(size_t tokenType) const {
   return "";
 }
 
-std::string Vocabulary::getSymbolicName(size_t tokenType) const {
+std::string_view Vocabulary::getSymbolicName(size_t tokenType) const {
   if (tokenType == Token::EOF) {
     return "EOF";
   }
@@ -76,20 +44,20 @@ std::string Vocabulary::getSymbolicName(size_t tokenType) const {
 
 std::string Vocabulary::getDisplayName(size_t tokenType) const {
   if (tokenType < _displayNames.size()) {
-    std::string displayName = _displayNames[tokenType];
+    std::string_view displayName = _displayNames[tokenType];
     if (!displayName.empty()) {
-      return displayName;
+      return std::string(displayName);
     }
   }
 
-  std::string literalName = getLiteralName(tokenType);
+  std::string_view literalName = getLiteralName(tokenType);
   if (!literalName.empty()) {
-    return literalName;
+    return std::string(literalName);
   }
 
-  std::string symbolicName = getSymbolicName(tokenType);
+  std::string_view symbolicName = getSymbolicName(tokenType);
   if (!symbolicName.empty()) {
-    return symbolicName;
+    return std::string(symbolicName);
   }
 
   return std::to_string(tokenType);

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

@@ -12,7 +12,7 @@ namespace dfa {
 
   /// This class provides a default implementation of the <seealso cref="Vocabulary"/>
   /// interface.
-  class ANTLR4CPP_PUBLIC Vocabulary {
+  class ANTLR4CPP_PUBLIC Vocabulary final {
   public:
     /// Gets an empty <seealso cref="Vocabulary"/> instance.
     ///
@@ -20,11 +20,11 @@ namespace dfa {
     /// No literal or symbol names are assigned to token types, so
     /// <seealso cref="#getDisplayName(int)"/> returns the numeric value for all tokens
     /// except <seealso cref="Token#EOF"/>.</para>
-    static const Vocabulary EMPTY_VOCABULARY;
+    [[deprecated("Use the default constructor of Vocabulary instead.")]] static const Vocabulary EMPTY_VOCABULARY;
 
     Vocabulary() {}
-    Vocabulary(Vocabulary const&) = default;
-    virtual ~Vocabulary();
+
+    Vocabulary(const Vocabulary&) = default;
 
     /// <summary>
     /// Constructs a new instance of <seealso cref="Vocabulary"/> from the specified
@@ -37,7 +37,7 @@ namespace dfa {
     /// </param>
     /// <seealso cref= #getLiteralName(int) </seealso>
     /// <seealso cref= #getSymbolicName(int) </seealso>
-    Vocabulary(const std::vector<std::string> &literalNames, const std::vector<std::string> &symbolicNames);
+    Vocabulary(std::vector<std::string> literalNames, std::vector<std::string> symbolicNames);
 
     /// <summary>
     /// Constructs a new instance of <seealso cref="Vocabulary"/> from the specified
@@ -55,29 +55,14 @@ namespace dfa {
     /// <seealso cref= #getLiteralName(int) </seealso>
     /// <seealso cref= #getSymbolicName(int) </seealso>
     /// <seealso cref= #getDisplayName(int) </seealso>
-    Vocabulary(const std::vector<std::string> &literalNames, const std::vector<std::string> &symbolicNames,
-                   const std::vector<std::string> &displayNames);
-
-    /// <summary>
-    /// Returns a <seealso cref="Vocabulary"/> instance from the specified set of token
-    /// names. This method acts as a compatibility layer for the single
-    /// {@code tokenNames} array generated by previous releases of ANTLR.
-    ///
-    /// <para>The resulting vocabulary instance returns {@code null} for
-    /// <seealso cref="#getLiteralName(int)"/> and <seealso cref="#getSymbolicName(int)"/>, and the
-    /// value from {@code tokenNames} for the display names.</para>
-    /// </summary>
-    /// <param name="tokenNames"> The token names, or {@code null} if no token names are
-    /// available. </param>
-    /// <returns> A <seealso cref="Vocabulary"/> instance which uses {@code tokenNames} for
-    /// the display names of tokens. </returns>
-    static Vocabulary fromTokenNames(const std::vector<std::string> &tokenNames);
+    Vocabulary(std::vector<std::string> literalNames, std::vector<std::string> symbolicNames,
+               std::vector<std::string> displayNames);
 
     /// <summary>
     /// Returns the highest token type value. It can be used to iterate from
     /// zero to that number, inclusively, thus querying all stored entries. </summary>
     /// <returns> the highest token type value </returns>
-    virtual size_t getMaxTokenType() const;
+    constexpr size_t getMaxTokenType() const { return _maxTokenType; }
 
     /// <summary>
     /// Gets the string literal associated with a token type. The string returned
@@ -114,7 +99,7 @@ namespace dfa {
     /// </param>
     /// <returns> The string literal associated with the specified token type, or
     /// {@code null} if no string literal is associated with the type. </returns>
-    virtual std::string getLiteralName(size_t tokenType) const;
+    std::string_view getLiteralName(size_t tokenType) const;
 
     /// <summary>
     /// Gets the symbolic name associated with a token type. The string returned
@@ -158,7 +143,7 @@ namespace dfa {
     /// </param>
     /// <returns> The symbolic name associated with the specified token type, or
     /// {@code null} if no symbolic name is associated with the type. </returns>
-    virtual std::string getSymbolicName(size_t tokenType) const;
+    std::string_view getSymbolicName(size_t tokenType) const;
 
     /// <summary>
     /// Gets the display name of a token type.
@@ -179,7 +164,7 @@ namespace dfa {
     /// </param>
     /// <returns> The display name of the token type, for use in error reporting or
     /// other user-visible messages which reference specific token types. </returns>
-    virtual std::string getDisplayName(size_t tokenType) const;
+    std::string getDisplayName(size_t tokenType) const;
 
   private:
     std::vector<std::string> const _literalNames;