fhirpath-rb 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 386fdadfc9286fb53c26e7b958d24b794931720c5f289e846290def5f85d032d
-  data.tar.gz: e3f288571780f12833b512ad1ca730fd9783534eb93898192d431f21102bb152
+  metadata.gz: 698e1507f8b58721cf71927b13b456791d4055f47564d9ae1828e722aee9fdb5
+  data.tar.gz: 75d902543883669eb47e44f84833523c0c52612d147c9f3eb8c42debaf742994
 SHA512:
-  metadata.gz: bc6396439374fc4072acc765b8300265972e68daab0458ed585f230e291c8e03b7bcf96c0eee50ea33eda8d03b831a26d0220387f1dd57f44c8916c9c0283a45
-  data.tar.gz: aa748f5c286c44eaade1a1cc99e6ce66bd8335d60cba9f9ef9f2c76460fa8f3cda91adb5d4c31abb29d46972c36eba0fab2f2eae09f5ea598350c60968039cdc
+  metadata.gz: f7de67754cd7b219cc456519cc4516f43bc5f189cfecb460f79dc926a1d9fcc7f255889a9b21ff807cf133b8e3630ba6f82cb11fc4fa2f3869488588c8758887
+  data.tar.gz: 5f87c96b7178408b61b401b3c05bf1438a459098f1b7a0a06a2316c82079bdaec5d58e5ec453e5a923b9c303f7990edef2f889c38a8250814cefa16b0436e2f8

data/.rubocop.yml

@@ -1,5 +1,9 @@
 AllCops:
   TargetRubyVersion: 3.0
+  # Standalone app with its own Gemfile/CI/.rubocop.yml (server/.rubocop.yml) - not part of this
+  # gem's bundle or lint run.
+  Exclude:
+    - "server/**/*"
 
 Style/StringLiterals:
   EnforcedStyle: double_quotes

data/CLAUDE.md

@@ -57,3 +57,55 @@ miss otherwise.
   (the default Rake task) and must stay clean.
 - No implementation code should be added speculatively — this file describes the target shape
   so future work has a map, not a request to build it all now.
+
+## Release process ("bump")
+
+The maintainer typing **"bump"** (or "bump X.Y.Z") to Claude is standing, in-the-moment
+authorization for the full state-changing sequence below — commit, push, tag, push tag, and
+GitHub release — for that one release only. No separate confirmation is needed per step; run
+the whole sequence end-to-end without pausing to ask "should I push now?" etc.
+
+**Version to release:**
+- Plain **"bump"** → increment the patch version (Z in X.Y.Z) of whatever's currently in
+  `lib/fhirpath/version.rb`.
+- **"bump X.Y.Z"** (an explicit version, e.g. for a minor/major bump like `0.2.0`) → set the
+  version to exactly that string instead of incrementing.
+
+**Steps, in order:**
+1. `git status` — working tree must be clean and up to date with `origin/main` before starting.
+   If it isn't (uncommitted changes, unrelated local commits), stop and ask rather than
+   assuming they should be swept into the release.
+2. Edit `lib/fhirpath/version.rb` to the new version.
+3. Run `bundle exec rake` (specs + RuboCop) and confirm it's green. If parser sources aren't
+   already built, run `bundle exec rake parser:setup compile` first (see rakelib/parser.rake).
+4. **Mandatory packaging sanity check** — this is the step that was skipped before 0.1.1/0.1.2
+   shipped a broken native extension (the gemspec's generated-files glob had silently gone
+   missing and nothing caught it until a user hit a `LoadError` in production):
+   - `gem build fhirpath-rb.gemspec`
+   - Install the built `.gem` into a throwaway isolated `GEM_HOME` (e.g. under a scratch dir),
+     with `env -u BUNDLE_GEMFILE -u RUBYOPT` to avoid this repo's own bundler env leaking in,
+     and with `GEM_PATH` pointing at a location that already has `rice`/`fhir_models` installed
+     (or allow network) so dependencies resolve.
+   - From that isolated `GEM_HOME`, `require "fhirpath"` and call `Fhirpath.evaluate` on a
+     trivial resource. Confirm the native extension (`fhir_path_parser.bundle`/`.so`) actually
+     got compiled into that GEM_HOME's `extensions/` dir and the require succeeds.
+   - Clean up the scratch gem/dirs afterward. If this check fails, stop — do not tag or release
+     a broken build; fix the gemspec/extension setup first.
+5. `git add lib/fhirpath/version.rb` (plus any other files that were part of this bump, e.g. a
+   packaging fix) and commit as `Bump X.Y.Z`, with whatever commit attribution footer is
+   currently in effect for the session.
+6. `git push origin main`.
+7. `git tag -a vX.Y.Z -m "Version X.Y.Z"` and `git push origin vX.Y.Z`.
+8. `gh release create vX.Y.Z --title "vX.Y.Z" --generate-notes` — this triggers
+   `.github/workflows/release.yml`, which publishes to rubygems.org via Trusted Publishing.
+9. `gh run watch <run-id> --exit-status` (find the run with `gh run list --workflow=release.yml
+   --limit 1`) and confirm it completes successfully.
+10. Final live-artifact check: in a scratch dir, `gem install fhirpath-rb -v X.Y.Z` from
+    rubygems.org (not the local build) and `require "fhirpath"` to confirm what's actually
+    published works, not just what was built locally.
+11. Report back: new version, release URL, and confirmation that the published gem loads.
+
+If step 4 or 10 fails, the release is broken in the same way 0.1.1/0.1.2 were — do not consider
+the release done, and do not stop at "gem pushed successfully" as the definition of success.
+`gem push` succeeding only means RubyGems accepted the upload; it says nothing about whether
+the native extension actually compiles for an installer.

data/ext/fhir_path_parser/antlr4-upstream/runtime/Cpp/runtime/src/ANTLRErrorListener.cpp

@@ -0,0 +1,10 @@
+/* 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 "ANTLRErrorListener.h"
+
+antlr4::ANTLRErrorListener::~ANTLRErrorListener()
+{
+}

data/ext/fhir_path_parser/antlr4-upstream/runtime/Cpp/runtime/src/ANTLRErrorListener.h

@@ -0,0 +1,167 @@
+/* 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 "RecognitionException.h"
+
+namespace antlrcpp {
+  class BitSet;
+}
+
+namespace antlr4 {
+
+  /// How to emit recognition errors (an interface in Java).
+  class ANTLR4CPP_PUBLIC ANTLRErrorListener {
+  public:
+    virtual ~ANTLRErrorListener();
+
+    /// <summary>
+    /// Upon syntax error, notify any interested parties. This is not how to
+    /// recover from errors or compute error messages. <seealso cref="ANTLRErrorStrategy"/>
+    /// specifies how to recover from syntax errors and how to compute error
+    /// messages. This listener's job is simply to emit a computed message,
+    /// though it has enough information to create its own message in many cases.
+    /// <p/>
+    /// The <seealso cref="RecognitionException"/> is non-null for all syntax errors except
+    /// when we discover mismatched token errors that we can recover from
+    /// in-line, without returning from the surrounding rule (via the single
+    /// token insertion and deletion mechanism).
+    /// </summary>
+    /// <param name="recognizer">
+    ///        What parser got the error. From this
+    /// 		  object, you can access the context as well
+    /// 		  as the input stream. </param>
+    /// <param name="offendingSymbol">
+    ///        The offending token in the input token
+    /// 		  stream, unless recognizer is a lexer (then it's null). If
+    /// 		  no viable alternative error, {@code e} has token at which we
+    /// 		  started production for the decision. </param>
+    /// <param name="line">
+    /// 		  The line number in the input where the error occurred. </param>
+    /// <param name="charPositionInLine">
+    /// 		  The character position within that line where the error occurred. </param>
+    /// <param name="msg">
+    /// 		  The message to emit. </param>
+    /// <param name="e">
+    ///        The exception generated by the parser that led to
+    ///        the reporting of an error. It is null in the case where
+    ///        the parser was able to recover in line without exiting the
+    ///        surrounding rule. </param>
+    virtual void syntaxError(Recognizer *recognizer, Token *offendingSymbol, size_t line,
+                             size_t charPositionInLine, const std::string &msg, std::exception_ptr e) = 0;
+
+    /**
+     * This method is called by the parser when a full-context prediction
+     * results in an ambiguity.
+     *
+     * <p>Each full-context prediction which does not result in a syntax error
+     * will call either {@link #reportContextSensitivity} or
+     * {@link #reportAmbiguity}.</p>
+     *
+     * <p>When {@code ambigAlts} is not null, it contains the set of potentially
+     * viable alternatives identified by the prediction algorithm. When
+     * {@code ambigAlts} is null, use {@link ATNConfigSet#getAlts} to obtain the
+     * represented alternatives from the {@code configs} argument.</p>
+     *
+     * <p>When {@code exact} is {@code true}, <em>all</em> of the potentially
+     * viable alternatives are truly viable, i.e. this is reporting an exact
+     * ambiguity. When {@code exact} is {@code false}, <em>at least two</em> of
+     * the potentially viable alternatives are viable for the current input, but
+     * the prediction algorithm terminated as soon as it determined that at
+     * least the <em>minimum</em> potentially viable alternative is truly
+     * viable.</p>
+     *
+     * <p>When the {@link PredictionMode#LL_EXACT_AMBIG_DETECTION} prediction
+     * mode is used, the parser is required to identify exact ambiguities so
+     * {@code exact} will always be {@code true}.</p>
+     *
+     * <p>This method is not used by lexers.</p>
+     *
+     * @param recognizer the parser instance
+     * @param dfa the DFA for the current decision
+     * @param startIndex the input index where the decision started
+     * @param stopIndex the input input where the ambiguity was identified
+     * @param exact {@code true} if the ambiguity is exactly known, otherwise
+     * {@code false}. This is always {@code true} when
+     * {@link PredictionMode#LL_EXACT_AMBIG_DETECTION} is used.
+     * @param ambigAlts the potentially ambiguous alternatives, or {@code null}
+     * to indicate that the potentially ambiguous alternatives are the complete
+     * set of represented alternatives in {@code configs}
+     * @param configs the ATN configuration set where the ambiguity was
+     * identified
+     */
+    virtual void reportAmbiguity(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex, size_t stopIndex, bool exact,
+      const antlrcpp::BitSet &ambigAlts, atn::ATNConfigSet *configs) = 0;
+
+    /**
+     * This method is called when an SLL conflict occurs and the parser is about
+     * to use the full context information to make an LL decision.
+     *
+     * <p>If one or more configurations in {@code configs} contains a semantic
+     * predicate, the predicates are evaluated before this method is called. The
+     * subset of alternatives which are still viable after predicates are
+     * evaluated is reported in {@code conflictingAlts}.</p>
+     *
+     * <p>This method is not used by lexers.</p>
+     *
+     * @param recognizer the parser instance
+     * @param dfa the DFA for the current decision
+     * @param startIndex the input index where the decision started
+     * @param stopIndex the input index where the SLL conflict occurred
+     * @param conflictingAlts The specific conflicting alternatives. If this is
+     * {@code null}, the conflicting alternatives are all alternatives
+     * represented in {@code configs}. At the moment, conflictingAlts is non-null
+     * (for the reference implementation, but Sam's optimized version can see this
+     * as null).
+     * @param configs the ATN configuration set where the SLL conflict was
+     * detected
+     */
+    virtual void reportAttemptingFullContext(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex, size_t stopIndex,
+      const antlrcpp::BitSet &conflictingAlts, atn::ATNConfigSet *configs) = 0;
+
+    /**
+     * This method is called by the parser when a full-context prediction has a
+     * unique result.
+     *
+     * <p>Each full-context prediction which does not result in a syntax error
+     * will call either {@link #reportContextSensitivity} or
+     * {@link #reportAmbiguity}.</p>
+     *
+     * <p>For prediction implementations that only evaluate full-context
+     * predictions when an SLL conflict is found (including the default
+     * {@link ParserATNSimulator} implementation), this method reports cases
+     * where SLL conflicts were resolved to unique full-context predictions,
+     * i.e. the decision was context-sensitive. This report does not necessarily
+     * indicate a problem, and it may appear even in completely unambiguous
+     * grammars.</p>
+     *
+     * <p>{@code configs} may have more than one represented alternative if the
+     * full-context prediction algorithm does not evaluate predicates before
+     * beginning the full-context prediction. In all cases, the final prediction
+     * is passed as the {@code prediction} argument.</p>
+     *
+     * <p>Note that the definition of "context sensitivity" in this method
+     * differs from the concept in {@link DecisionInfo#contextSensitivities}.
+     * This method reports all instances where an SLL conflict occurred but LL
+     * parsing produced a unique result, whether or not that unique result
+     * matches the minimum alternative in the SLL conflicting set.</p>
+     *
+     * <p>This method is not used by lexers.</p>
+     *
+     * @param recognizer the parser instance
+     * @param dfa the DFA for the current decision
+     * @param startIndex the input index where the decision started
+     * @param stopIndex the input index where the context sensitivity was
+     * finally determined
+     * @param prediction the unambiguous result of the full-context prediction
+     * @param configs the ATN configuration set where the unambiguous prediction
+     * was determined
+     */
+    virtual void reportContextSensitivity(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex, size_t stopIndex,
+      size_t prediction, atn::ATNConfigSet *configs) = 0;
+  };
+
+} // namespace antlr4

data/ext/fhir_path_parser/antlr4-upstream/runtime/Cpp/runtime/src/ANTLRErrorStrategy.cpp

@@ -0,0 +1,10 @@
+/* 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 "ANTLRErrorStrategy.h"
+
+antlr4::ANTLRErrorStrategy::~ANTLRErrorStrategy()
+{
+}

data/ext/fhir_path_parser/antlr4-upstream/runtime/Cpp/runtime/src/ANTLRErrorStrategy.h

@@ -0,0 +1,121 @@
+/* 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 "Token.h"
+
+namespace antlr4 {
+
+  /// <summary>
+  /// The interface for defining strategies to deal with syntax errors encountered
+  /// during a parse by ANTLR-generated parsers. We distinguish between three
+  /// different kinds of errors:
+  ///
+  /// <ul>
+  /// <li>The parser could not figure out which path to take in the ATN (none of
+  /// the available alternatives could possibly match)</li>
+  /// <li>The current input does not match what we were looking for</li>
+  /// <li>A predicate evaluated to false</li>
+  /// </ul>
+  ///
+  /// Implementations of this interface report syntax errors by calling
+  /// <seealso cref="Parser#notifyErrorListeners"/>.
+  /// <p/>
+  /// TODO: what to do about lexers
+  /// </summary>
+  class ANTLR4CPP_PUBLIC ANTLRErrorStrategy {
+  public:
+
+    /// <summary>
+    /// Reset the error handler state for the specified {@code recognizer}. </summary>
+    /// <param name="recognizer"> the parser instance </param>
+    virtual ~ANTLRErrorStrategy();
+
+    virtual void reset(Parser *recognizer) = 0;
+
+    /**
+     * This method is called when an unexpected symbol is encountered during an
+     * inline match operation, such as {@link Parser#match}. If the error
+     * strategy successfully recovers from the match failure, this method
+     * returns the {@link Token} instance which should be treated as the
+     * successful result of the match.
+     *
+     * <p>This method handles the consumption of any tokens - the caller should
+     * <b>not</b> call {@link Parser#consume} after a successful recovery.</p>
+     *
+     * <p>Note that the calling code will not report an error if this method
+     * returns successfully. The error strategy implementation is responsible
+     * for calling {@link Parser#notifyErrorListeners} as appropriate.</p>
+     *
+     * @param recognizer the parser instance
+     * @throws RecognitionException if the error strategy was not able to
+     * recover from the unexpected input symbol
+     */
+    virtual Token* recoverInline(Parser *recognizer) = 0;
+
+    /// <summary>
+    /// This method is called to recover from exception {@code e}. This method is
+    /// called after <seealso cref="#reportError"/> by the default exception handler
+    /// generated for a rule method.
+    /// </summary>
+    /// <seealso cref= #reportError
+    /// </seealso>
+    /// <param name="recognizer"> the parser instance </param>
+    /// <param name="e"> the recognition exception to recover from </param>
+    /// <exception cref="RecognitionException"> if the error strategy could not recover from
+    /// the recognition exception </exception>
+    virtual void recover(Parser *recognizer, std::exception_ptr e) = 0;
+
+    /// <summary>
+    /// This method provides the error handler with an opportunity to handle
+    /// syntactic or semantic errors in the input stream before they result in a
+    /// <seealso cref="RecognitionException"/>.
+    /// <p/>
+    /// The generated code currently contains calls to <seealso cref="#sync"/> after
+    /// entering the decision state of a closure block ({@code (...)*} or
+    /// {@code (...)+}).
+    /// <p/>
+    /// For an implementation based on Jim Idle's "magic sync" mechanism, see
+    /// <seealso cref="DefaultErrorStrategy#sync"/>.
+    /// </summary>
+    /// <seealso cref= DefaultErrorStrategy#sync
+    /// </seealso>
+    /// <param name="recognizer"> the parser instance </param>
+    /// <exception cref="RecognitionException"> if an error is detected by the error
+    /// strategy but cannot be automatically recovered at the current state in
+    /// the parsing process </exception>
+    virtual void sync(Parser *recognizer) = 0;
+
+    /// <summary>
+    /// Tests whether or not {@code recognizer} is in the process of recovering
+    /// from an error. In error recovery mode, <seealso cref="Parser#consume"/> adds
+    /// symbols to the parse tree by calling
+    /// {@link Parser#createErrorNode(ParserRuleContext, Token)} then
+    /// {@link ParserRuleContext#addErrorNode(ErrorNode)} instead of
+    /// {@link Parser#createTerminalNode(ParserRuleContext, Token)}.
+    /// </summary>
+    /// <param name="recognizer"> the parser instance </param>
+    /// <returns> {@code true} if the parser is currently recovering from a parse
+    /// error, otherwise {@code false} </returns>
+    virtual bool inErrorRecoveryMode(Parser *recognizer) = 0;
+
+    /// <summary>
+    /// This method is called by when the parser successfully matches an input
+    /// symbol.
+    /// </summary>
+    /// <param name="recognizer"> the parser instance </param>
+    virtual void reportMatch(Parser *recognizer) = 0;
+
+    /// <summary>
+    /// Report any kind of <seealso cref="RecognitionException"/>. This method is called by
+    /// the default exception handler generated for a rule method.
+    /// </summary>
+    /// <param name="recognizer"> the parser instance </param>
+    /// <param name="e"> the recognition exception to report </param>
+    virtual void reportError(Parser *recognizer, const RecognitionException &e) = 0;
+  };
+
+} // namespace antlr4

data/ext/fhir_path_parser/antlr4-upstream/runtime/Cpp/runtime/src/ANTLRFileStream.cpp

@@ -0,0 +1,23 @@
+/* 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 "ANTLRFileStream.h"
+
+using namespace antlr4;
+
+void ANTLRFileStream::loadFromFile(const std::string &fileName) {
+  _fileName = fileName;
+  if (_fileName.empty()) {
+    return;
+  }
+
+  std::ifstream stream(fileName, std::ios::binary);
+
+  ANTLRInputStream::load(stream);
+}
+
+std::string ANTLRFileStream::getSourceName() const {
+  return _fileName;
+}

data/ext/fhir_path_parser/antlr4-upstream/runtime/Cpp/runtime/src/ANTLRFileStream.h

@@ -0,0 +1,30 @@
+/* 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 "ANTLRInputStream.h"
+
+namespace antlr4 {
+
+  /// This is an ANTLRInputStream that is loaded from a file all at once
+  /// when you construct the object (or call load()).
+  // TODO: this class needs testing.
+  class ANTLR4CPP_PUBLIC ANTLRFileStream : public ANTLRInputStream {
+  public:
+    ANTLRFileStream() = default;
+    ANTLRFileStream(const std::string &) = delete;
+    ANTLRFileStream(const char *data, size_t length) = delete;
+    ANTLRFileStream(std::istream &stream) = delete;
+
+    // Assumes a file name encoded in UTF-8 and file content in the same encoding (with or w/o BOM).
+    virtual void loadFromFile(const std::string &fileName);
+    virtual std::string getSourceName() const override;
+
+  private:
+    std::string _fileName; // UTF-8 encoded file name.
+  };
+
+} // namespace antlr4

data/ext/fhir_path_parser/antlr4-upstream/runtime/Cpp/runtime/src/ANTLRInputStream.cpp

@@ -0,0 +1,180 @@
+/* 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 <string.h>
+
+#include "Exceptions.h"
+#include "misc/Interval.h"
+#include "IntStream.h"
+
+#include "support/Utf8.h"
+#include "support/CPPUtils.h"
+
+#include "ANTLRInputStream.h"
+
+using namespace antlr4;
+using namespace antlrcpp;
+
+using misc::Interval;
+
+ANTLRInputStream::ANTLRInputStream() {
+  InitializeInstanceFields();
+}
+
+ANTLRInputStream::ANTLRInputStream(std::string_view input): ANTLRInputStream() {
+  load(input.data(), input.length());
+}
+
+ANTLRInputStream::ANTLRInputStream(const char *data, size_t length) {
+  load(data, length);
+}
+
+ANTLRInputStream::ANTLRInputStream(std::istream &stream): ANTLRInputStream() {
+  load(stream);
+}
+
+void ANTLRInputStream::load(const std::string &input, bool lenient) {
+  load(input.data(), input.size(), lenient);
+}
+
+void ANTLRInputStream::load(const char *data, size_t length, bool lenient) {
+  // Remove the UTF-8 BOM if present.
+  const char *bom = "\xef\xbb\xbf";
+  if (length >= 3 && strncmp(data, bom, 3) == 0) {
+    data += 3;
+    length -= 3;
+  }
+  if (lenient) {
+    _data = Utf8::lenientDecode(std::string_view(data, length));
+  } else {
+    auto maybe_utf32 = Utf8::strictDecode(std::string_view(data, length));
+    if (!maybe_utf32.has_value()) {
+      throw IllegalArgumentException("UTF-8 string contains an illegal byte sequence");
+    }
+    _data = std::move(maybe_utf32).value();
+  }
+  p = 0;
+}
+
+void ANTLRInputStream::load(std::istream &stream, bool lenient) {
+  if (!stream.good() || stream.eof()) // No fail, bad or EOF.
+    return;
+
+  _data.clear();
+
+  std::string s((std::istreambuf_iterator<char>(stream)), std::istreambuf_iterator<char>());
+  load(s.data(), s.length(), lenient);
+}
+
+void ANTLRInputStream::reset() {
+  p = 0;
+}
+
+void ANTLRInputStream::consume() {
+  if (p >= _data.size()) {
+    assert(LA(1) == IntStream::EOF);
+    throw IllegalStateException("cannot consume EOF");
+  }
+
+  if (p < _data.size()) {
+    p++;
+  }
+}
+
+size_t ANTLRInputStream::LA(ssize_t i) {
+  if (i == 0) {
+    return 0; // undefined
+  }
+
+  ssize_t position = static_cast<ssize_t>(p);
+  if (i < 0) {
+    i++; // e.g., translate LA(-1) to use offset i=0; then _data[p+0-1]
+    if ((position + i - 1) < 0) {
+      return IntStream::EOF; // invalid; no char before first char
+    }
+  }
+
+  if ((position + i - 1) >= static_cast<ssize_t>(_data.size())) {
+    return IntStream::EOF;
+  }
+
+  return _data[static_cast<size_t>((position + i - 1))];
+}
+
+size_t ANTLRInputStream::LT(ssize_t i) {
+  return LA(i);
+}
+
+size_t ANTLRInputStream::index() {
+  return p;
+}
+
+size_t ANTLRInputStream::size() {
+  return _data.size();
+}
+
+// Mark/release do nothing. We have entire buffer.
+ssize_t ANTLRInputStream::mark() {
+  return -1;
+}
+
+void ANTLRInputStream::release(ssize_t /* marker */) {
+}
+
+void ANTLRInputStream::seek(size_t index) {
+  if (index <= p) {
+    p = index; // just jump; don't update stream state (line, ...)
+    return;
+  }
+  // seek forward, consume until p hits index or n (whichever comes first)
+  index = std::min(index, _data.size());
+  while (p < index) {
+    consume();
+  }
+}
+
+std::string ANTLRInputStream::getText(const Interval &interval) {
+  if (interval.a < 0 || interval.b < 0) {
+    return "";
+  }
+
+  size_t start = static_cast<size_t>(interval.a);
+  size_t stop = static_cast<size_t>(interval.b);
+
+
+  if (stop >= _data.size()) {
+    stop = _data.size() - 1;
+  }
+
+  size_t count = stop - start + 1;
+  if (start >= _data.size()) {
+    return "";
+  }
+
+  auto maybeUtf8 = Utf8::strictEncode(std::u32string_view(_data).substr(start, count));
+  if (!maybeUtf8.has_value()) {
+    throw IllegalArgumentException("Input stream contains invalid Unicode code points");
+  }
+  return std::move(maybeUtf8).value();
+}
+
+std::string ANTLRInputStream::getSourceName() const {
+  if (name.empty()) {
+    return IntStream::UNKNOWN_SOURCE_NAME;
+  }
+  return name;
+}
+
+std::string ANTLRInputStream::toString() const {
+  auto maybeUtf8 = Utf8::strictEncode(_data);
+  if (!maybeUtf8.has_value()) {
+    throw IllegalArgumentException("Input stream contains invalid Unicode code points");
+  }
+  return std::move(maybeUtf8).value();
+}
+
+void ANTLRInputStream::InitializeInstanceFields() {
+  p = 0;
+}