fhirpath-rb 0.1.2 → 0.1.4

data/ext/fhir_path_parser/antlrgen/FHIRPathParser.cpp

@@ -0,0 +1,2517 @@
+
+// Generated from /home/runner/work/fhirpath-ruby/fhirpath-ruby/lib/fhirpath/parser/FHIRPath.g4 by ANTLR 4.10.1
+
+
+#include "FHIRPathListener.h"
+#include "FHIRPathVisitor.h"
+
+#include "FHIRPathParser.h"
+
+
+using namespace antlrcpp;
+
+using namespace antlr4;
+
+namespace {
+
+struct FHIRPathParserStaticData final {
+  FHIRPathParserStaticData(std::vector<std::string> ruleNames,
+                        std::vector<std::string> literalNames,
+                        std::vector<std::string> symbolicNames)
+      : ruleNames(std::move(ruleNames)), literalNames(std::move(literalNames)),
+        symbolicNames(std::move(symbolicNames)),
+        vocabulary(this->literalNames, this->symbolicNames) {}
+
+  FHIRPathParserStaticData(const FHIRPathParserStaticData&) = delete;
+  FHIRPathParserStaticData(FHIRPathParserStaticData&&) = delete;
+  FHIRPathParserStaticData& operator=(const FHIRPathParserStaticData&) = delete;
+  FHIRPathParserStaticData& operator=(FHIRPathParserStaticData&&) = delete;
+
+  std::vector<antlr4::dfa::DFA> decisionToDFA;
+  antlr4::atn::PredictionContextCache sharedContextCache;
+  const std::vector<std::string> ruleNames;
+  const std::vector<std::string> literalNames;
+  const std::vector<std::string> symbolicNames;
+  const antlr4::dfa::Vocabulary vocabulary;
+  antlr4::atn::SerializedATNView serializedATN;
+  std::unique_ptr<antlr4::atn::ATN> atn;
+};
+
+std::once_flag fhirpathParserOnceFlag;
+FHIRPathParserStaticData *fhirpathParserStaticData = nullptr;
+
+void fhirpathParserInitialize() {
+  assert(fhirpathParserStaticData == nullptr);
+  auto staticData = std::make_unique<FHIRPathParserStaticData>(
+    std::vector<std::string>{
+      "entireExpression", "expression", "term", "literal", "externalConstant", 
+      "invocation", "functn", "paramList", "quantity", "unit", "dateTimePrecision", 
+      "pluralDateTimePrecision", "typeSpecifier", "qualifiedIdentifier", 
+      "identifier"
+    },
+    std::vector<std::string>{
+      "", "'.'", "'['", "']'", "'+'", "'-'", "'*'", "'/'", "'div'", "'mod'", 
+      "'&'", "'|'", "'<='", "'<'", "'>'", "'>='", "'is'", "'as'", "'='", 
+      "'~'", "'!='", "'!~'", "'in'", "'contains'", "'and'", "'or'", "'xor'", 
+      "'implies'", "'('", "')'", "'{'", "'}'", "'true'", "'false'", "'%'", 
+      "'$this'", "'$index'", "'$total'", "','", "'year'", "'month'", "'week'", 
+      "'day'", "'hour'", "'minute'", "'second'", "'millisecond'", "'years'", 
+      "'months'", "'weeks'", "'days'", "'hours'", "'minutes'", "'seconds'", 
+      "'milliseconds'"
+    },
+    std::vector<std::string>{
+      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
+      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
+      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
+      "", "", "", "", "DATETIME", "TIME", "IDENTIFIER", "DELIMITEDIDENTIFIER", 
+      "STRING", "NUMBER", "WS", "COMMENT", "LINE_COMMENT"
+    }
+  );
+  static const int32_t serializedATNSegment[] = {
+  	4,1,63,154,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,2,
+  	7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,2,14,7,
+  	14,1,0,1,0,1,0,1,1,1,1,1,1,1,1,3,1,38,8,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,1,78,8,1,10,1,
+  	12,1,81,9,1,1,2,1,2,1,2,1,2,1,2,1,2,1,2,3,2,90,8,2,1,3,1,3,1,3,1,3,1,
+  	3,1,3,1,3,1,3,3,3,100,8,3,1,4,1,4,1,4,3,4,105,8,4,1,5,1,5,1,5,1,5,1,5,
+  	3,5,112,8,5,1,6,1,6,1,6,3,6,117,8,6,1,6,1,6,1,7,1,7,1,7,5,7,124,8,7,10,
+  	7,12,7,127,9,7,1,8,1,8,3,8,131,8,8,1,9,1,9,1,9,3,9,136,8,9,1,10,1,10,
+  	1,11,1,11,1,12,1,12,1,13,1,13,1,13,5,13,147,8,13,10,13,12,13,150,9,13,
+  	1,14,1,14,1,14,0,1,2,15,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,0,12,
+  	1,0,4,5,1,0,6,9,2,0,4,5,10,10,1,0,12,15,1,0,18,21,1,0,22,23,1,0,25,26,
+  	1,0,16,17,1,0,32,33,1,0,39,46,1,0,47,54,3,0,16,17,22,23,57,58,171,0,30,
+  	1,0,0,0,2,37,1,0,0,0,4,89,1,0,0,0,6,99,1,0,0,0,8,101,1,0,0,0,10,111,1,
+  	0,0,0,12,113,1,0,0,0,14,120,1,0,0,0,16,128,1,0,0,0,18,135,1,0,0,0,20,
+  	137,1,0,0,0,22,139,1,0,0,0,24,141,1,0,0,0,26,143,1,0,0,0,28,151,1,0,0,
+  	0,30,31,3,2,1,0,31,32,5,0,0,1,32,1,1,0,0,0,33,34,6,1,-1,0,34,38,3,4,2,
+  	0,35,36,7,0,0,0,36,38,3,2,1,11,37,33,1,0,0,0,37,35,1,0,0,0,38,79,1,0,
+  	0,0,39,40,10,10,0,0,40,41,7,1,0,0,41,78,3,2,1,11,42,43,10,9,0,0,43,44,
+  	7,2,0,0,44,78,3,2,1,10,45,46,10,8,0,0,46,47,5,11,0,0,47,78,3,2,1,9,48,
+  	49,10,7,0,0,49,50,7,3,0,0,50,78,3,2,1,8,51,52,10,5,0,0,52,53,7,4,0,0,
+  	53,78,3,2,1,6,54,55,10,4,0,0,55,56,7,5,0,0,56,78,3,2,1,5,57,58,10,3,0,
+  	0,58,59,5,24,0,0,59,78,3,2,1,4,60,61,10,2,0,0,61,62,7,6,0,0,62,78,3,2,
+  	1,3,63,64,10,1,0,0,64,65,5,27,0,0,65,78,3,2,1,2,66,67,10,13,0,0,67,68,
+  	5,1,0,0,68,78,3,10,5,0,69,70,10,12,0,0,70,71,5,2,0,0,71,72,3,2,1,0,72,
+  	73,5,3,0,0,73,78,1,0,0,0,74,75,10,6,0,0,75,76,7,7,0,0,76,78,3,24,12,0,
+  	77,39,1,0,0,0,77,42,1,0,0,0,77,45,1,0,0,0,77,48,1,0,0,0,77,51,1,0,0,0,
+  	77,54,1,0,0,0,77,57,1,0,0,0,77,60,1,0,0,0,77,63,1,0,0,0,77,66,1,0,0,0,
+  	77,69,1,0,0,0,77,74,1,0,0,0,78,81,1,0,0,0,79,77,1,0,0,0,79,80,1,0,0,0,
+  	80,3,1,0,0,0,81,79,1,0,0,0,82,90,3,10,5,0,83,90,3,6,3,0,84,90,3,8,4,0,
+  	85,86,5,28,0,0,86,87,3,2,1,0,87,88,5,29,0,0,88,90,1,0,0,0,89,82,1,0,0,
+  	0,89,83,1,0,0,0,89,84,1,0,0,0,89,85,1,0,0,0,90,5,1,0,0,0,91,92,5,30,0,
+  	0,92,100,5,31,0,0,93,100,7,8,0,0,94,100,5,59,0,0,95,100,5,60,0,0,96,100,
+  	5,55,0,0,97,100,5,56,0,0,98,100,3,16,8,0,99,91,1,0,0,0,99,93,1,0,0,0,
+  	99,94,1,0,0,0,99,95,1,0,0,0,99,96,1,0,0,0,99,97,1,0,0,0,99,98,1,0,0,0,
+  	100,7,1,0,0,0,101,104,5,34,0,0,102,105,3,28,14,0,103,105,5,59,0,0,104,
+  	102,1,0,0,0,104,103,1,0,0,0,105,9,1,0,0,0,106,112,3,28,14,0,107,112,3,
+  	12,6,0,108,112,5,35,0,0,109,112,5,36,0,0,110,112,5,37,0,0,111,106,1,0,
+  	0,0,111,107,1,0,0,0,111,108,1,0,0,0,111,109,1,0,0,0,111,110,1,0,0,0,112,
+  	11,1,0,0,0,113,114,3,28,14,0,114,116,5,28,0,0,115,117,3,14,7,0,116,115,
+  	1,0,0,0,116,117,1,0,0,0,117,118,1,0,0,0,118,119,5,29,0,0,119,13,1,0,0,
+  	0,120,125,3,2,1,0,121,122,5,38,0,0,122,124,3,2,1,0,123,121,1,0,0,0,124,
+  	127,1,0,0,0,125,123,1,0,0,0,125,126,1,0,0,0,126,15,1,0,0,0,127,125,1,
+  	0,0,0,128,130,5,60,0,0,129,131,3,18,9,0,130,129,1,0,0,0,130,131,1,0,0,
+  	0,131,17,1,0,0,0,132,136,3,20,10,0,133,136,3,22,11,0,134,136,5,59,0,0,
+  	135,132,1,0,0,0,135,133,1,0,0,0,135,134,1,0,0,0,136,19,1,0,0,0,137,138,
+  	7,9,0,0,138,21,1,0,0,0,139,140,7,10,0,0,140,23,1,0,0,0,141,142,3,26,13,
+  	0,142,25,1,0,0,0,143,148,3,28,14,0,144,145,5,1,0,0,145,147,3,28,14,0,
+  	146,144,1,0,0,0,147,150,1,0,0,0,148,146,1,0,0,0,148,149,1,0,0,0,149,27,
+  	1,0,0,0,150,148,1,0,0,0,151,152,7,11,0,0,152,29,1,0,0,0,12,37,77,79,89,
+  	99,104,111,116,125,130,135,148
+  };
+  staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0]));
+
+  antlr4::atn::ATNDeserializer deserializer;
+  staticData->atn = deserializer.deserialize(staticData->serializedATN);
+
+  const size_t count = staticData->atn->getNumberOfDecisions();
+  staticData->decisionToDFA.reserve(count);
+  for (size_t i = 0; i < count; i++) { 
+    staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i);
+  }
+  fhirpathParserStaticData = staticData.release();
+}
+
+}
+
+FHIRPathParser::FHIRPathParser(TokenStream *input) : FHIRPathParser(input, antlr4::atn::ParserATNSimulatorOptions()) {}
+
+FHIRPathParser::FHIRPathParser(TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options) : Parser(input) {
+  FHIRPathParser::initialize();
+  _interpreter = new atn::ParserATNSimulator(this, *fhirpathParserStaticData->atn, fhirpathParserStaticData->decisionToDFA, fhirpathParserStaticData->sharedContextCache, options);
+}
+
+FHIRPathParser::~FHIRPathParser() {
+  delete _interpreter;
+}
+
+const atn::ATN& FHIRPathParser::getATN() const {
+  return *fhirpathParserStaticData->atn;
+}
+
+std::string FHIRPathParser::getGrammarFileName() const {
+  return "FHIRPath.g4";
+}
+
+const std::vector<std::string>& FHIRPathParser::getRuleNames() const {
+  return fhirpathParserStaticData->ruleNames;
+}
+
+const dfa::Vocabulary& FHIRPathParser::getVocabulary() const {
+  return fhirpathParserStaticData->vocabulary;
+}
+
+antlr4::atn::SerializedATNView FHIRPathParser::getSerializedATN() const {
+  return fhirpathParserStaticData->serializedATN;
+}
+
+
+//----------------- EntireExpressionContext ------------------------------------------------------------------
+
+FHIRPathParser::EntireExpressionContext::EntireExpressionContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+FHIRPathParser::ExpressionContext* FHIRPathParser::EntireExpressionContext::expression() {
+  return getRuleContext<FHIRPathParser::ExpressionContext>(0);
+}
+
+tree::TerminalNode* FHIRPathParser::EntireExpressionContext::EOF() {
+  return getToken(FHIRPathParser::EOF, 0);
+}
+
+
+size_t FHIRPathParser::EntireExpressionContext::getRuleIndex() const {
+  return FHIRPathParser::RuleEntireExpression;
+}
+
+void FHIRPathParser::EntireExpressionContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterEntireExpression(this);
+}
+
+void FHIRPathParser::EntireExpressionContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitEntireExpression(this);
+}
+
+
+std::any FHIRPathParser::EntireExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitEntireExpression(this);
+  else
+    return visitor->visitChildren(this);
+}
+
+FHIRPathParser::EntireExpressionContext* FHIRPathParser::entireExpression() {
+  EntireExpressionContext *_localctx = _tracker.createInstance<EntireExpressionContext>(_ctx, getState());
+  enterRule(_localctx, 0, FHIRPathParser::RuleEntireExpression);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(30);
+    expression(0);
+    setState(31);
+    match(FHIRPathParser::EOF);
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- ExpressionContext ------------------------------------------------------------------
+
+FHIRPathParser::ExpressionContext::ExpressionContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+
+size_t FHIRPathParser::ExpressionContext::getRuleIndex() const {
+  return FHIRPathParser::RuleExpression;
+}
+
+void FHIRPathParser::ExpressionContext::copyFrom(ExpressionContext *ctx) {
+  ParserRuleContext::copyFrom(ctx);
+}
+
+//----------------- IndexerExpressionContext ------------------------------------------------------------------
+
+std::vector<FHIRPathParser::ExpressionContext *> FHIRPathParser::IndexerExpressionContext::expression() {
+  return getRuleContexts<FHIRPathParser::ExpressionContext>();
+}
+
+FHIRPathParser::ExpressionContext* FHIRPathParser::IndexerExpressionContext::expression(size_t i) {
+  return getRuleContext<FHIRPathParser::ExpressionContext>(i);
+}
+
+FHIRPathParser::IndexerExpressionContext::IndexerExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::IndexerExpressionContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterIndexerExpression(this);
+}
+void FHIRPathParser::IndexerExpressionContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitIndexerExpression(this);
+}
+
+std::any FHIRPathParser::IndexerExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitIndexerExpression(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- PolarityExpressionContext ------------------------------------------------------------------
+
+FHIRPathParser::ExpressionContext* FHIRPathParser::PolarityExpressionContext::expression() {
+  return getRuleContext<FHIRPathParser::ExpressionContext>(0);
+}
+
+FHIRPathParser::PolarityExpressionContext::PolarityExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::PolarityExpressionContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterPolarityExpression(this);
+}
+void FHIRPathParser::PolarityExpressionContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitPolarityExpression(this);
+}
+
+std::any FHIRPathParser::PolarityExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitPolarityExpression(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- AdditiveExpressionContext ------------------------------------------------------------------
+
+std::vector<FHIRPathParser::ExpressionContext *> FHIRPathParser::AdditiveExpressionContext::expression() {
+  return getRuleContexts<FHIRPathParser::ExpressionContext>();
+}
+
+FHIRPathParser::ExpressionContext* FHIRPathParser::AdditiveExpressionContext::expression(size_t i) {
+  return getRuleContext<FHIRPathParser::ExpressionContext>(i);
+}
+
+FHIRPathParser::AdditiveExpressionContext::AdditiveExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::AdditiveExpressionContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterAdditiveExpression(this);
+}
+void FHIRPathParser::AdditiveExpressionContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitAdditiveExpression(this);
+}
+
+std::any FHIRPathParser::AdditiveExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitAdditiveExpression(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- MultiplicativeExpressionContext ------------------------------------------------------------------
+
+std::vector<FHIRPathParser::ExpressionContext *> FHIRPathParser::MultiplicativeExpressionContext::expression() {
+  return getRuleContexts<FHIRPathParser::ExpressionContext>();
+}
+
+FHIRPathParser::ExpressionContext* FHIRPathParser::MultiplicativeExpressionContext::expression(size_t i) {
+  return getRuleContext<FHIRPathParser::ExpressionContext>(i);
+}
+
+FHIRPathParser::MultiplicativeExpressionContext::MultiplicativeExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::MultiplicativeExpressionContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterMultiplicativeExpression(this);
+}
+void FHIRPathParser::MultiplicativeExpressionContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitMultiplicativeExpression(this);
+}
+
+std::any FHIRPathParser::MultiplicativeExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitMultiplicativeExpression(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- UnionExpressionContext ------------------------------------------------------------------
+
+std::vector<FHIRPathParser::ExpressionContext *> FHIRPathParser::UnionExpressionContext::expression() {
+  return getRuleContexts<FHIRPathParser::ExpressionContext>();
+}
+
+FHIRPathParser::ExpressionContext* FHIRPathParser::UnionExpressionContext::expression(size_t i) {
+  return getRuleContext<FHIRPathParser::ExpressionContext>(i);
+}
+
+FHIRPathParser::UnionExpressionContext::UnionExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::UnionExpressionContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterUnionExpression(this);
+}
+void FHIRPathParser::UnionExpressionContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitUnionExpression(this);
+}
+
+std::any FHIRPathParser::UnionExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitUnionExpression(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- OrExpressionContext ------------------------------------------------------------------
+
+std::vector<FHIRPathParser::ExpressionContext *> FHIRPathParser::OrExpressionContext::expression() {
+  return getRuleContexts<FHIRPathParser::ExpressionContext>();
+}
+
+FHIRPathParser::ExpressionContext* FHIRPathParser::OrExpressionContext::expression(size_t i) {
+  return getRuleContext<FHIRPathParser::ExpressionContext>(i);
+}
+
+FHIRPathParser::OrExpressionContext::OrExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::OrExpressionContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterOrExpression(this);
+}
+void FHIRPathParser::OrExpressionContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitOrExpression(this);
+}
+
+std::any FHIRPathParser::OrExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitOrExpression(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- AndExpressionContext ------------------------------------------------------------------
+
+std::vector<FHIRPathParser::ExpressionContext *> FHIRPathParser::AndExpressionContext::expression() {
+  return getRuleContexts<FHIRPathParser::ExpressionContext>();
+}
+
+FHIRPathParser::ExpressionContext* FHIRPathParser::AndExpressionContext::expression(size_t i) {
+  return getRuleContext<FHIRPathParser::ExpressionContext>(i);
+}
+
+FHIRPathParser::AndExpressionContext::AndExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::AndExpressionContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterAndExpression(this);
+}
+void FHIRPathParser::AndExpressionContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitAndExpression(this);
+}
+
+std::any FHIRPathParser::AndExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitAndExpression(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- MembershipExpressionContext ------------------------------------------------------------------
+
+std::vector<FHIRPathParser::ExpressionContext *> FHIRPathParser::MembershipExpressionContext::expression() {
+  return getRuleContexts<FHIRPathParser::ExpressionContext>();
+}
+
+FHIRPathParser::ExpressionContext* FHIRPathParser::MembershipExpressionContext::expression(size_t i) {
+  return getRuleContext<FHIRPathParser::ExpressionContext>(i);
+}
+
+FHIRPathParser::MembershipExpressionContext::MembershipExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::MembershipExpressionContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterMembershipExpression(this);
+}
+void FHIRPathParser::MembershipExpressionContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitMembershipExpression(this);
+}
+
+std::any FHIRPathParser::MembershipExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitMembershipExpression(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- InequalityExpressionContext ------------------------------------------------------------------
+
+std::vector<FHIRPathParser::ExpressionContext *> FHIRPathParser::InequalityExpressionContext::expression() {
+  return getRuleContexts<FHIRPathParser::ExpressionContext>();
+}
+
+FHIRPathParser::ExpressionContext* FHIRPathParser::InequalityExpressionContext::expression(size_t i) {
+  return getRuleContext<FHIRPathParser::ExpressionContext>(i);
+}
+
+FHIRPathParser::InequalityExpressionContext::InequalityExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::InequalityExpressionContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterInequalityExpression(this);
+}
+void FHIRPathParser::InequalityExpressionContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitInequalityExpression(this);
+}
+
+std::any FHIRPathParser::InequalityExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitInequalityExpression(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- InvocationExpressionContext ------------------------------------------------------------------
+
+FHIRPathParser::ExpressionContext* FHIRPathParser::InvocationExpressionContext::expression() {
+  return getRuleContext<FHIRPathParser::ExpressionContext>(0);
+}
+
+FHIRPathParser::InvocationContext* FHIRPathParser::InvocationExpressionContext::invocation() {
+  return getRuleContext<FHIRPathParser::InvocationContext>(0);
+}
+
+FHIRPathParser::InvocationExpressionContext::InvocationExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::InvocationExpressionContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterInvocationExpression(this);
+}
+void FHIRPathParser::InvocationExpressionContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitInvocationExpression(this);
+}
+
+std::any FHIRPathParser::InvocationExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitInvocationExpression(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- EqualityExpressionContext ------------------------------------------------------------------
+
+std::vector<FHIRPathParser::ExpressionContext *> FHIRPathParser::EqualityExpressionContext::expression() {
+  return getRuleContexts<FHIRPathParser::ExpressionContext>();
+}
+
+FHIRPathParser::ExpressionContext* FHIRPathParser::EqualityExpressionContext::expression(size_t i) {
+  return getRuleContext<FHIRPathParser::ExpressionContext>(i);
+}
+
+FHIRPathParser::EqualityExpressionContext::EqualityExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::EqualityExpressionContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterEqualityExpression(this);
+}
+void FHIRPathParser::EqualityExpressionContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitEqualityExpression(this);
+}
+
+std::any FHIRPathParser::EqualityExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitEqualityExpression(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- ImpliesExpressionContext ------------------------------------------------------------------
+
+std::vector<FHIRPathParser::ExpressionContext *> FHIRPathParser::ImpliesExpressionContext::expression() {
+  return getRuleContexts<FHIRPathParser::ExpressionContext>();
+}
+
+FHIRPathParser::ExpressionContext* FHIRPathParser::ImpliesExpressionContext::expression(size_t i) {
+  return getRuleContext<FHIRPathParser::ExpressionContext>(i);
+}
+
+FHIRPathParser::ImpliesExpressionContext::ImpliesExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::ImpliesExpressionContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterImpliesExpression(this);
+}
+void FHIRPathParser::ImpliesExpressionContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitImpliesExpression(this);
+}
+
+std::any FHIRPathParser::ImpliesExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitImpliesExpression(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- TermExpressionContext ------------------------------------------------------------------
+
+FHIRPathParser::TermContext* FHIRPathParser::TermExpressionContext::term() {
+  return getRuleContext<FHIRPathParser::TermContext>(0);
+}
+
+FHIRPathParser::TermExpressionContext::TermExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::TermExpressionContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterTermExpression(this);
+}
+void FHIRPathParser::TermExpressionContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitTermExpression(this);
+}
+
+std::any FHIRPathParser::TermExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitTermExpression(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- TypeExpressionContext ------------------------------------------------------------------
+
+FHIRPathParser::ExpressionContext* FHIRPathParser::TypeExpressionContext::expression() {
+  return getRuleContext<FHIRPathParser::ExpressionContext>(0);
+}
+
+FHIRPathParser::TypeSpecifierContext* FHIRPathParser::TypeExpressionContext::typeSpecifier() {
+  return getRuleContext<FHIRPathParser::TypeSpecifierContext>(0);
+}
+
+FHIRPathParser::TypeExpressionContext::TypeExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::TypeExpressionContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterTypeExpression(this);
+}
+void FHIRPathParser::TypeExpressionContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitTypeExpression(this);
+}
+
+std::any FHIRPathParser::TypeExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitTypeExpression(this);
+  else
+    return visitor->visitChildren(this);
+}
+
+FHIRPathParser::ExpressionContext* FHIRPathParser::expression() {
+   return expression(0);
+}
+
+FHIRPathParser::ExpressionContext* FHIRPathParser::expression(int precedence) {
+  ParserRuleContext *parentContext = _ctx;
+  size_t parentState = getState();
+  FHIRPathParser::ExpressionContext *_localctx = _tracker.createInstance<ExpressionContext>(_ctx, parentState);
+  FHIRPathParser::ExpressionContext *previousContext = _localctx;
+  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
+  size_t startState = 2;
+  enterRecursionRule(_localctx, 2, FHIRPathParser::RuleExpression, precedence);
+
+    size_t _la = 0;
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    unrollRecursionContexts(parentContext);
+  });
+  try {
+    size_t alt;
+    enterOuterAlt(_localctx, 1);
+    setState(37);
+    _errHandler->sync(this);
+    switch (_input->LA(1)) {
+      case FHIRPathParser::T__15:
+      case FHIRPathParser::T__16:
+      case FHIRPathParser::T__21:
+      case FHIRPathParser::T__22:
+      case FHIRPathParser::T__27:
+      case FHIRPathParser::T__29:
+      case FHIRPathParser::T__31:
+      case FHIRPathParser::T__32:
+      case FHIRPathParser::T__33:
+      case FHIRPathParser::T__34:
+      case FHIRPathParser::T__35:
+      case FHIRPathParser::T__36:
+      case FHIRPathParser::DATETIME:
+      case FHIRPathParser::TIME:
+      case FHIRPathParser::IDENTIFIER:
+      case FHIRPathParser::DELIMITEDIDENTIFIER:
+      case FHIRPathParser::STRING:
+      case FHIRPathParser::NUMBER: {
+        _localctx = _tracker.createInstance<TermExpressionContext>(_localctx);
+        _ctx = _localctx;
+        previousContext = _localctx;
+
+        setState(34);
+        term();
+        break;
+      }
+
+      case FHIRPathParser::T__3:
+      case FHIRPathParser::T__4: {
+        _localctx = _tracker.createInstance<PolarityExpressionContext>(_localctx);
+        _ctx = _localctx;
+        previousContext = _localctx;
+        setState(35);
+        _la = _input->LA(1);
+        if (!(_la == FHIRPathParser::T__3
+
+        || _la == FHIRPathParser::T__4)) {
+        _errHandler->recoverInline(this);
+        }
+        else {
+          _errHandler->reportMatch(this);
+          consume();
+        }
+        setState(36);
+        expression(11);
+        break;
+      }
+
+    default:
+      throw NoViableAltException(this);
+    }
+    _ctx->stop = _input->LT(-1);
+    setState(79);
+    _errHandler->sync(this);
+    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 2, _ctx);
+    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
+      if (alt == 1) {
+        if (!_parseListeners.empty())
+          triggerExitRuleEvent();
+        previousContext = _localctx;
+        setState(77);
+        _errHandler->sync(this);
+        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1, _ctx)) {
+        case 1: {
+          auto newContext = _tracker.createInstance<MultiplicativeExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
+          _localctx = newContext;
+          pushNewRecursionContext(newContext, startState, RuleExpression);
+          setState(39);
+
+          if (!(precpred(_ctx, 10))) throw FailedPredicateException(this, "precpred(_ctx, 10)");
+          setState(40);
+          _la = _input->LA(1);
+          if (!((((_la & ~ 0x3fULL) == 0) &&
+            ((1ULL << _la) & ((1ULL << FHIRPathParser::T__5)
+            | (1ULL << FHIRPathParser::T__6)
+            | (1ULL << FHIRPathParser::T__7)
+            | (1ULL << FHIRPathParser::T__8))) != 0))) {
+          _errHandler->recoverInline(this);
+          }
+          else {
+            _errHandler->reportMatch(this);
+            consume();
+          }
+          setState(41);
+          expression(11);
+          break;
+        }
+
+        case 2: {
+          auto newContext = _tracker.createInstance<AdditiveExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
+          _localctx = newContext;
+          pushNewRecursionContext(newContext, startState, RuleExpression);
+          setState(42);
+
+          if (!(precpred(_ctx, 9))) throw FailedPredicateException(this, "precpred(_ctx, 9)");
+          setState(43);
+          _la = _input->LA(1);
+          if (!((((_la & ~ 0x3fULL) == 0) &&
+            ((1ULL << _la) & ((1ULL << FHIRPathParser::T__3)
+            | (1ULL << FHIRPathParser::T__4)
+            | (1ULL << FHIRPathParser::T__9))) != 0))) {
+          _errHandler->recoverInline(this);
+          }
+          else {
+            _errHandler->reportMatch(this);
+            consume();
+          }
+          setState(44);
+          expression(10);
+          break;
+        }
+
+        case 3: {
+          auto newContext = _tracker.createInstance<UnionExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
+          _localctx = newContext;
+          pushNewRecursionContext(newContext, startState, RuleExpression);
+          setState(45);
+
+          if (!(precpred(_ctx, 8))) throw FailedPredicateException(this, "precpred(_ctx, 8)");
+          setState(46);
+          match(FHIRPathParser::T__10);
+          setState(47);
+          expression(9);
+          break;
+        }
+
+        case 4: {
+          auto newContext = _tracker.createInstance<InequalityExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
+          _localctx = newContext;
+          pushNewRecursionContext(newContext, startState, RuleExpression);
+          setState(48);
+
+          if (!(precpred(_ctx, 7))) throw FailedPredicateException(this, "precpred(_ctx, 7)");
+          setState(49);
+          _la = _input->LA(1);
+          if (!((((_la & ~ 0x3fULL) == 0) &&
+            ((1ULL << _la) & ((1ULL << FHIRPathParser::T__11)
+            | (1ULL << FHIRPathParser::T__12)
+            | (1ULL << FHIRPathParser::T__13)
+            | (1ULL << FHIRPathParser::T__14))) != 0))) {
+          _errHandler->recoverInline(this);
+          }
+          else {
+            _errHandler->reportMatch(this);
+            consume();
+          }
+          setState(50);
+          expression(8);
+          break;
+        }
+
+        case 5: {
+          auto newContext = _tracker.createInstance<EqualityExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
+          _localctx = newContext;
+          pushNewRecursionContext(newContext, startState, RuleExpression);
+          setState(51);
+
+          if (!(precpred(_ctx, 5))) throw FailedPredicateException(this, "precpred(_ctx, 5)");
+          setState(52);
+          _la = _input->LA(1);
+          if (!((((_la & ~ 0x3fULL) == 0) &&
+            ((1ULL << _la) & ((1ULL << FHIRPathParser::T__17)
+            | (1ULL << FHIRPathParser::T__18)
+            | (1ULL << FHIRPathParser::T__19)
+            | (1ULL << FHIRPathParser::T__20))) != 0))) {
+          _errHandler->recoverInline(this);
+          }
+          else {
+            _errHandler->reportMatch(this);
+            consume();
+          }
+          setState(53);
+          expression(6);
+          break;
+        }
+
+        case 6: {
+          auto newContext = _tracker.createInstance<MembershipExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
+          _localctx = newContext;
+          pushNewRecursionContext(newContext, startState, RuleExpression);
+          setState(54);
+
+          if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)");
+          setState(55);
+          _la = _input->LA(1);
+          if (!(_la == FHIRPathParser::T__21
+
+          || _la == FHIRPathParser::T__22)) {
+          _errHandler->recoverInline(this);
+          }
+          else {
+            _errHandler->reportMatch(this);
+            consume();
+          }
+          setState(56);
+          expression(5);
+          break;
+        }
+
+        case 7: {
+          auto newContext = _tracker.createInstance<AndExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
+          _localctx = newContext;
+          pushNewRecursionContext(newContext, startState, RuleExpression);
+          setState(57);
+
+          if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
+          setState(58);
+          match(FHIRPathParser::T__23);
+          setState(59);
+          expression(4);
+          break;
+        }
+
+        case 8: {
+          auto newContext = _tracker.createInstance<OrExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
+          _localctx = newContext;
+          pushNewRecursionContext(newContext, startState, RuleExpression);
+          setState(60);
+
+          if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
+          setState(61);
+          _la = _input->LA(1);
+          if (!(_la == FHIRPathParser::T__24
+
+          || _la == FHIRPathParser::T__25)) {
+          _errHandler->recoverInline(this);
+          }
+          else {
+            _errHandler->reportMatch(this);
+            consume();
+          }
+          setState(62);
+          expression(3);
+          break;
+        }
+
+        case 9: {
+          auto newContext = _tracker.createInstance<ImpliesExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
+          _localctx = newContext;
+          pushNewRecursionContext(newContext, startState, RuleExpression);
+          setState(63);
+
+          if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)");
+          setState(64);
+          match(FHIRPathParser::T__26);
+          setState(65);
+          expression(2);
+          break;
+        }
+
+        case 10: {
+          auto newContext = _tracker.createInstance<InvocationExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
+          _localctx = newContext;
+          pushNewRecursionContext(newContext, startState, RuleExpression);
+          setState(66);
+
+          if (!(precpred(_ctx, 13))) throw FailedPredicateException(this, "precpred(_ctx, 13)");
+          setState(67);
+          match(FHIRPathParser::T__0);
+          setState(68);
+          invocation();
+          break;
+        }
+
+        case 11: {
+          auto newContext = _tracker.createInstance<IndexerExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
+          _localctx = newContext;
+          pushNewRecursionContext(newContext, startState, RuleExpression);
+          setState(69);
+
+          if (!(precpred(_ctx, 12))) throw FailedPredicateException(this, "precpred(_ctx, 12)");
+          setState(70);
+          match(FHIRPathParser::T__1);
+          setState(71);
+          expression(0);
+          setState(72);
+          match(FHIRPathParser::T__2);
+          break;
+        }
+
+        case 12: {
+          auto newContext = _tracker.createInstance<TypeExpressionContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
+          _localctx = newContext;
+          pushNewRecursionContext(newContext, startState, RuleExpression);
+          setState(74);
+
+          if (!(precpred(_ctx, 6))) throw FailedPredicateException(this, "precpred(_ctx, 6)");
+          setState(75);
+          _la = _input->LA(1);
+          if (!(_la == FHIRPathParser::T__15
+
+          || _la == FHIRPathParser::T__16)) {
+          _errHandler->recoverInline(this);
+          }
+          else {
+            _errHandler->reportMatch(this);
+            consume();
+          }
+          setState(76);
+          typeSpecifier();
+          break;
+        }
+
+        default:
+          break;
+        } 
+      }
+      setState(81);
+      _errHandler->sync(this);
+      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 2, _ctx);
+    }
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+  return _localctx;
+}
+
+//----------------- TermContext ------------------------------------------------------------------
+
+FHIRPathParser::TermContext::TermContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+
+size_t FHIRPathParser::TermContext::getRuleIndex() const {
+  return FHIRPathParser::RuleTerm;
+}
+
+void FHIRPathParser::TermContext::copyFrom(TermContext *ctx) {
+  ParserRuleContext::copyFrom(ctx);
+}
+
+//----------------- ExternalConstantTermContext ------------------------------------------------------------------
+
+FHIRPathParser::ExternalConstantContext* FHIRPathParser::ExternalConstantTermContext::externalConstant() {
+  return getRuleContext<FHIRPathParser::ExternalConstantContext>(0);
+}
+
+FHIRPathParser::ExternalConstantTermContext::ExternalConstantTermContext(TermContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::ExternalConstantTermContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterExternalConstantTerm(this);
+}
+void FHIRPathParser::ExternalConstantTermContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitExternalConstantTerm(this);
+}
+
+std::any FHIRPathParser::ExternalConstantTermContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitExternalConstantTerm(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- LiteralTermContext ------------------------------------------------------------------
+
+FHIRPathParser::LiteralContext* FHIRPathParser::LiteralTermContext::literal() {
+  return getRuleContext<FHIRPathParser::LiteralContext>(0);
+}
+
+FHIRPathParser::LiteralTermContext::LiteralTermContext(TermContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::LiteralTermContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterLiteralTerm(this);
+}
+void FHIRPathParser::LiteralTermContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitLiteralTerm(this);
+}
+
+std::any FHIRPathParser::LiteralTermContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitLiteralTerm(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- ParenthesizedTermContext ------------------------------------------------------------------
+
+FHIRPathParser::ExpressionContext* FHIRPathParser::ParenthesizedTermContext::expression() {
+  return getRuleContext<FHIRPathParser::ExpressionContext>(0);
+}
+
+FHIRPathParser::ParenthesizedTermContext::ParenthesizedTermContext(TermContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::ParenthesizedTermContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterParenthesizedTerm(this);
+}
+void FHIRPathParser::ParenthesizedTermContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitParenthesizedTerm(this);
+}
+
+std::any FHIRPathParser::ParenthesizedTermContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitParenthesizedTerm(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- InvocationTermContext ------------------------------------------------------------------
+
+FHIRPathParser::InvocationContext* FHIRPathParser::InvocationTermContext::invocation() {
+  return getRuleContext<FHIRPathParser::InvocationContext>(0);
+}
+
+FHIRPathParser::InvocationTermContext::InvocationTermContext(TermContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::InvocationTermContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterInvocationTerm(this);
+}
+void FHIRPathParser::InvocationTermContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitInvocationTerm(this);
+}
+
+std::any FHIRPathParser::InvocationTermContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitInvocationTerm(this);
+  else
+    return visitor->visitChildren(this);
+}
+FHIRPathParser::TermContext* FHIRPathParser::term() {
+  TermContext *_localctx = _tracker.createInstance<TermContext>(_ctx, getState());
+  enterRule(_localctx, 4, FHIRPathParser::RuleTerm);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    setState(89);
+    _errHandler->sync(this);
+    switch (_input->LA(1)) {
+      case FHIRPathParser::T__15:
+      case FHIRPathParser::T__16:
+      case FHIRPathParser::T__21:
+      case FHIRPathParser::T__22:
+      case FHIRPathParser::T__34:
+      case FHIRPathParser::T__35:
+      case FHIRPathParser::T__36:
+      case FHIRPathParser::IDENTIFIER:
+      case FHIRPathParser::DELIMITEDIDENTIFIER: {
+        _localctx = _tracker.createInstance<FHIRPathParser::InvocationTermContext>(_localctx);
+        enterOuterAlt(_localctx, 1);
+        setState(82);
+        invocation();
+        break;
+      }
+
+      case FHIRPathParser::T__29:
+      case FHIRPathParser::T__31:
+      case FHIRPathParser::T__32:
+      case FHIRPathParser::DATETIME:
+      case FHIRPathParser::TIME:
+      case FHIRPathParser::STRING:
+      case FHIRPathParser::NUMBER: {
+        _localctx = _tracker.createInstance<FHIRPathParser::LiteralTermContext>(_localctx);
+        enterOuterAlt(_localctx, 2);
+        setState(83);
+        literal();
+        break;
+      }
+
+      case FHIRPathParser::T__33: {
+        _localctx = _tracker.createInstance<FHIRPathParser::ExternalConstantTermContext>(_localctx);
+        enterOuterAlt(_localctx, 3);
+        setState(84);
+        externalConstant();
+        break;
+      }
+
+      case FHIRPathParser::T__27: {
+        _localctx = _tracker.createInstance<FHIRPathParser::ParenthesizedTermContext>(_localctx);
+        enterOuterAlt(_localctx, 4);
+        setState(85);
+        match(FHIRPathParser::T__27);
+        setState(86);
+        expression(0);
+        setState(87);
+        match(FHIRPathParser::T__28);
+        break;
+      }
+
+    default:
+      throw NoViableAltException(this);
+    }
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- LiteralContext ------------------------------------------------------------------
+
+FHIRPathParser::LiteralContext::LiteralContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+
+size_t FHIRPathParser::LiteralContext::getRuleIndex() const {
+  return FHIRPathParser::RuleLiteral;
+}
+
+void FHIRPathParser::LiteralContext::copyFrom(LiteralContext *ctx) {
+  ParserRuleContext::copyFrom(ctx);
+}
+
+//----------------- TimeLiteralContext ------------------------------------------------------------------
+
+tree::TerminalNode* FHIRPathParser::TimeLiteralContext::TIME() {
+  return getToken(FHIRPathParser::TIME, 0);
+}
+
+FHIRPathParser::TimeLiteralContext::TimeLiteralContext(LiteralContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::TimeLiteralContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterTimeLiteral(this);
+}
+void FHIRPathParser::TimeLiteralContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitTimeLiteral(this);
+}
+
+std::any FHIRPathParser::TimeLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitTimeLiteral(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- NullLiteralContext ------------------------------------------------------------------
+
+FHIRPathParser::NullLiteralContext::NullLiteralContext(LiteralContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::NullLiteralContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterNullLiteral(this);
+}
+void FHIRPathParser::NullLiteralContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitNullLiteral(this);
+}
+
+std::any FHIRPathParser::NullLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitNullLiteral(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- DateTimeLiteralContext ------------------------------------------------------------------
+
+tree::TerminalNode* FHIRPathParser::DateTimeLiteralContext::DATETIME() {
+  return getToken(FHIRPathParser::DATETIME, 0);
+}
+
+FHIRPathParser::DateTimeLiteralContext::DateTimeLiteralContext(LiteralContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::DateTimeLiteralContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterDateTimeLiteral(this);
+}
+void FHIRPathParser::DateTimeLiteralContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitDateTimeLiteral(this);
+}
+
+std::any FHIRPathParser::DateTimeLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitDateTimeLiteral(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- StringLiteralContext ------------------------------------------------------------------
+
+tree::TerminalNode* FHIRPathParser::StringLiteralContext::STRING() {
+  return getToken(FHIRPathParser::STRING, 0);
+}
+
+FHIRPathParser::StringLiteralContext::StringLiteralContext(LiteralContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::StringLiteralContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterStringLiteral(this);
+}
+void FHIRPathParser::StringLiteralContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitStringLiteral(this);
+}
+
+std::any FHIRPathParser::StringLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitStringLiteral(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- BooleanLiteralContext ------------------------------------------------------------------
+
+FHIRPathParser::BooleanLiteralContext::BooleanLiteralContext(LiteralContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::BooleanLiteralContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterBooleanLiteral(this);
+}
+void FHIRPathParser::BooleanLiteralContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitBooleanLiteral(this);
+}
+
+std::any FHIRPathParser::BooleanLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitBooleanLiteral(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- NumberLiteralContext ------------------------------------------------------------------
+
+tree::TerminalNode* FHIRPathParser::NumberLiteralContext::NUMBER() {
+  return getToken(FHIRPathParser::NUMBER, 0);
+}
+
+FHIRPathParser::NumberLiteralContext::NumberLiteralContext(LiteralContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::NumberLiteralContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterNumberLiteral(this);
+}
+void FHIRPathParser::NumberLiteralContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitNumberLiteral(this);
+}
+
+std::any FHIRPathParser::NumberLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitNumberLiteral(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- QuantityLiteralContext ------------------------------------------------------------------
+
+FHIRPathParser::QuantityContext* FHIRPathParser::QuantityLiteralContext::quantity() {
+  return getRuleContext<FHIRPathParser::QuantityContext>(0);
+}
+
+FHIRPathParser::QuantityLiteralContext::QuantityLiteralContext(LiteralContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::QuantityLiteralContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterQuantityLiteral(this);
+}
+void FHIRPathParser::QuantityLiteralContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitQuantityLiteral(this);
+}
+
+std::any FHIRPathParser::QuantityLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitQuantityLiteral(this);
+  else
+    return visitor->visitChildren(this);
+}
+FHIRPathParser::LiteralContext* FHIRPathParser::literal() {
+  LiteralContext *_localctx = _tracker.createInstance<LiteralContext>(_ctx, getState());
+  enterRule(_localctx, 6, FHIRPathParser::RuleLiteral);
+  size_t _la = 0;
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    setState(99);
+    _errHandler->sync(this);
+    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 4, _ctx)) {
+    case 1: {
+      _localctx = _tracker.createInstance<FHIRPathParser::NullLiteralContext>(_localctx);
+      enterOuterAlt(_localctx, 1);
+      setState(91);
+      match(FHIRPathParser::T__29);
+      setState(92);
+      match(FHIRPathParser::T__30);
+      break;
+    }
+
+    case 2: {
+      _localctx = _tracker.createInstance<FHIRPathParser::BooleanLiteralContext>(_localctx);
+      enterOuterAlt(_localctx, 2);
+      setState(93);
+      _la = _input->LA(1);
+      if (!(_la == FHIRPathParser::T__31
+
+      || _la == FHIRPathParser::T__32)) {
+      _errHandler->recoverInline(this);
+      }
+      else {
+        _errHandler->reportMatch(this);
+        consume();
+      }
+      break;
+    }
+
+    case 3: {
+      _localctx = _tracker.createInstance<FHIRPathParser::StringLiteralContext>(_localctx);
+      enterOuterAlt(_localctx, 3);
+      setState(94);
+      match(FHIRPathParser::STRING);
+      break;
+    }
+
+    case 4: {
+      _localctx = _tracker.createInstance<FHIRPathParser::NumberLiteralContext>(_localctx);
+      enterOuterAlt(_localctx, 4);
+      setState(95);
+      match(FHIRPathParser::NUMBER);
+      break;
+    }
+
+    case 5: {
+      _localctx = _tracker.createInstance<FHIRPathParser::DateTimeLiteralContext>(_localctx);
+      enterOuterAlt(_localctx, 5);
+      setState(96);
+      match(FHIRPathParser::DATETIME);
+      break;
+    }
+
+    case 6: {
+      _localctx = _tracker.createInstance<FHIRPathParser::TimeLiteralContext>(_localctx);
+      enterOuterAlt(_localctx, 6);
+      setState(97);
+      match(FHIRPathParser::TIME);
+      break;
+    }
+
+    case 7: {
+      _localctx = _tracker.createInstance<FHIRPathParser::QuantityLiteralContext>(_localctx);
+      enterOuterAlt(_localctx, 7);
+      setState(98);
+      quantity();
+      break;
+    }
+
+    default:
+      break;
+    }
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- ExternalConstantContext ------------------------------------------------------------------
+
+FHIRPathParser::ExternalConstantContext::ExternalConstantContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+FHIRPathParser::IdentifierContext* FHIRPathParser::ExternalConstantContext::identifier() {
+  return getRuleContext<FHIRPathParser::IdentifierContext>(0);
+}
+
+tree::TerminalNode* FHIRPathParser::ExternalConstantContext::STRING() {
+  return getToken(FHIRPathParser::STRING, 0);
+}
+
+
+size_t FHIRPathParser::ExternalConstantContext::getRuleIndex() const {
+  return FHIRPathParser::RuleExternalConstant;
+}
+
+void FHIRPathParser::ExternalConstantContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterExternalConstant(this);
+}
+
+void FHIRPathParser::ExternalConstantContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitExternalConstant(this);
+}
+
+
+std::any FHIRPathParser::ExternalConstantContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitExternalConstant(this);
+  else
+    return visitor->visitChildren(this);
+}
+
+FHIRPathParser::ExternalConstantContext* FHIRPathParser::externalConstant() {
+  ExternalConstantContext *_localctx = _tracker.createInstance<ExternalConstantContext>(_ctx, getState());
+  enterRule(_localctx, 8, FHIRPathParser::RuleExternalConstant);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(101);
+    match(FHIRPathParser::T__33);
+    setState(104);
+    _errHandler->sync(this);
+    switch (_input->LA(1)) {
+      case FHIRPathParser::T__15:
+      case FHIRPathParser::T__16:
+      case FHIRPathParser::T__21:
+      case FHIRPathParser::T__22:
+      case FHIRPathParser::IDENTIFIER:
+      case FHIRPathParser::DELIMITEDIDENTIFIER: {
+        setState(102);
+        identifier();
+        break;
+      }
+
+      case FHIRPathParser::STRING: {
+        setState(103);
+        match(FHIRPathParser::STRING);
+        break;
+      }
+
+    default:
+      throw NoViableAltException(this);
+    }
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- InvocationContext ------------------------------------------------------------------
+
+FHIRPathParser::InvocationContext::InvocationContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+
+size_t FHIRPathParser::InvocationContext::getRuleIndex() const {
+  return FHIRPathParser::RuleInvocation;
+}
+
+void FHIRPathParser::InvocationContext::copyFrom(InvocationContext *ctx) {
+  ParserRuleContext::copyFrom(ctx);
+}
+
+//----------------- TotalInvocationContext ------------------------------------------------------------------
+
+FHIRPathParser::TotalInvocationContext::TotalInvocationContext(InvocationContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::TotalInvocationContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterTotalInvocation(this);
+}
+void FHIRPathParser::TotalInvocationContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitTotalInvocation(this);
+}
+
+std::any FHIRPathParser::TotalInvocationContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitTotalInvocation(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- ThisInvocationContext ------------------------------------------------------------------
+
+FHIRPathParser::ThisInvocationContext::ThisInvocationContext(InvocationContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::ThisInvocationContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterThisInvocation(this);
+}
+void FHIRPathParser::ThisInvocationContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitThisInvocation(this);
+}
+
+std::any FHIRPathParser::ThisInvocationContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitThisInvocation(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- IndexInvocationContext ------------------------------------------------------------------
+
+FHIRPathParser::IndexInvocationContext::IndexInvocationContext(InvocationContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::IndexInvocationContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterIndexInvocation(this);
+}
+void FHIRPathParser::IndexInvocationContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitIndexInvocation(this);
+}
+
+std::any FHIRPathParser::IndexInvocationContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitIndexInvocation(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- FunctionInvocationContext ------------------------------------------------------------------
+
+FHIRPathParser::FunctnContext* FHIRPathParser::FunctionInvocationContext::functn() {
+  return getRuleContext<FHIRPathParser::FunctnContext>(0);
+}
+
+FHIRPathParser::FunctionInvocationContext::FunctionInvocationContext(InvocationContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::FunctionInvocationContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterFunctionInvocation(this);
+}
+void FHIRPathParser::FunctionInvocationContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitFunctionInvocation(this);
+}
+
+std::any FHIRPathParser::FunctionInvocationContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitFunctionInvocation(this);
+  else
+    return visitor->visitChildren(this);
+}
+//----------------- MemberInvocationContext ------------------------------------------------------------------
+
+FHIRPathParser::IdentifierContext* FHIRPathParser::MemberInvocationContext::identifier() {
+  return getRuleContext<FHIRPathParser::IdentifierContext>(0);
+}
+
+FHIRPathParser::MemberInvocationContext::MemberInvocationContext(InvocationContext *ctx) { copyFrom(ctx); }
+
+void FHIRPathParser::MemberInvocationContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterMemberInvocation(this);
+}
+void FHIRPathParser::MemberInvocationContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitMemberInvocation(this);
+}
+
+std::any FHIRPathParser::MemberInvocationContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitMemberInvocation(this);
+  else
+    return visitor->visitChildren(this);
+}
+FHIRPathParser::InvocationContext* FHIRPathParser::invocation() {
+  InvocationContext *_localctx = _tracker.createInstance<InvocationContext>(_ctx, getState());
+  enterRule(_localctx, 10, FHIRPathParser::RuleInvocation);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    setState(111);
+    _errHandler->sync(this);
+    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 6, _ctx)) {
+    case 1: {
+      _localctx = _tracker.createInstance<FHIRPathParser::MemberInvocationContext>(_localctx);
+      enterOuterAlt(_localctx, 1);
+      setState(106);
+      identifier();
+      break;
+    }
+
+    case 2: {
+      _localctx = _tracker.createInstance<FHIRPathParser::FunctionInvocationContext>(_localctx);
+      enterOuterAlt(_localctx, 2);
+      setState(107);
+      functn();
+      break;
+    }
+
+    case 3: {
+      _localctx = _tracker.createInstance<FHIRPathParser::ThisInvocationContext>(_localctx);
+      enterOuterAlt(_localctx, 3);
+      setState(108);
+      match(FHIRPathParser::T__34);
+      break;
+    }
+
+    case 4: {
+      _localctx = _tracker.createInstance<FHIRPathParser::IndexInvocationContext>(_localctx);
+      enterOuterAlt(_localctx, 4);
+      setState(109);
+      match(FHIRPathParser::T__35);
+      break;
+    }
+
+    case 5: {
+      _localctx = _tracker.createInstance<FHIRPathParser::TotalInvocationContext>(_localctx);
+      enterOuterAlt(_localctx, 5);
+      setState(110);
+      match(FHIRPathParser::T__36);
+      break;
+    }
+
+    default:
+      break;
+    }
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- FunctnContext ------------------------------------------------------------------
+
+FHIRPathParser::FunctnContext::FunctnContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+FHIRPathParser::IdentifierContext* FHIRPathParser::FunctnContext::identifier() {
+  return getRuleContext<FHIRPathParser::IdentifierContext>(0);
+}
+
+FHIRPathParser::ParamListContext* FHIRPathParser::FunctnContext::paramList() {
+  return getRuleContext<FHIRPathParser::ParamListContext>(0);
+}
+
+
+size_t FHIRPathParser::FunctnContext::getRuleIndex() const {
+  return FHIRPathParser::RuleFunctn;
+}
+
+void FHIRPathParser::FunctnContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterFunctn(this);
+}
+
+void FHIRPathParser::FunctnContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitFunctn(this);
+}
+
+
+std::any FHIRPathParser::FunctnContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitFunctn(this);
+  else
+    return visitor->visitChildren(this);
+}
+
+FHIRPathParser::FunctnContext* FHIRPathParser::functn() {
+  FunctnContext *_localctx = _tracker.createInstance<FunctnContext>(_ctx, getState());
+  enterRule(_localctx, 12, FHIRPathParser::RuleFunctn);
+  size_t _la = 0;
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(113);
+    identifier();
+    setState(114);
+    match(FHIRPathParser::T__27);
+    setState(116);
+    _errHandler->sync(this);
+
+    _la = _input->LA(1);
+    if ((((_la & ~ 0x3fULL) == 0) &&
+      ((1ULL << _la) & ((1ULL << FHIRPathParser::T__3)
+      | (1ULL << FHIRPathParser::T__4)
+      | (1ULL << FHIRPathParser::T__15)
+      | (1ULL << FHIRPathParser::T__16)
+      | (1ULL << FHIRPathParser::T__21)
+      | (1ULL << FHIRPathParser::T__22)
+      | (1ULL << FHIRPathParser::T__27)
+      | (1ULL << FHIRPathParser::T__29)
+      | (1ULL << FHIRPathParser::T__31)
+      | (1ULL << FHIRPathParser::T__32)
+      | (1ULL << FHIRPathParser::T__33)
+      | (1ULL << FHIRPathParser::T__34)
+      | (1ULL << FHIRPathParser::T__35)
+      | (1ULL << FHIRPathParser::T__36)
+      | (1ULL << FHIRPathParser::DATETIME)
+      | (1ULL << FHIRPathParser::TIME)
+      | (1ULL << FHIRPathParser::IDENTIFIER)
+      | (1ULL << FHIRPathParser::DELIMITEDIDENTIFIER)
+      | (1ULL << FHIRPathParser::STRING)
+      | (1ULL << FHIRPathParser::NUMBER))) != 0)) {
+      setState(115);
+      paramList();
+    }
+    setState(118);
+    match(FHIRPathParser::T__28);
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- ParamListContext ------------------------------------------------------------------
+
+FHIRPathParser::ParamListContext::ParamListContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+std::vector<FHIRPathParser::ExpressionContext *> FHIRPathParser::ParamListContext::expression() {
+  return getRuleContexts<FHIRPathParser::ExpressionContext>();
+}
+
+FHIRPathParser::ExpressionContext* FHIRPathParser::ParamListContext::expression(size_t i) {
+  return getRuleContext<FHIRPathParser::ExpressionContext>(i);
+}
+
+
+size_t FHIRPathParser::ParamListContext::getRuleIndex() const {
+  return FHIRPathParser::RuleParamList;
+}
+
+void FHIRPathParser::ParamListContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterParamList(this);
+}
+
+void FHIRPathParser::ParamListContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitParamList(this);
+}
+
+
+std::any FHIRPathParser::ParamListContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitParamList(this);
+  else
+    return visitor->visitChildren(this);
+}
+
+FHIRPathParser::ParamListContext* FHIRPathParser::paramList() {
+  ParamListContext *_localctx = _tracker.createInstance<ParamListContext>(_ctx, getState());
+  enterRule(_localctx, 14, FHIRPathParser::RuleParamList);
+  size_t _la = 0;
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(120);
+    expression(0);
+    setState(125);
+    _errHandler->sync(this);
+    _la = _input->LA(1);
+    while (_la == FHIRPathParser::T__37) {
+      setState(121);
+      match(FHIRPathParser::T__37);
+      setState(122);
+      expression(0);
+      setState(127);
+      _errHandler->sync(this);
+      _la = _input->LA(1);
+    }
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- QuantityContext ------------------------------------------------------------------
+
+FHIRPathParser::QuantityContext::QuantityContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+tree::TerminalNode* FHIRPathParser::QuantityContext::NUMBER() {
+  return getToken(FHIRPathParser::NUMBER, 0);
+}
+
+FHIRPathParser::UnitContext* FHIRPathParser::QuantityContext::unit() {
+  return getRuleContext<FHIRPathParser::UnitContext>(0);
+}
+
+
+size_t FHIRPathParser::QuantityContext::getRuleIndex() const {
+  return FHIRPathParser::RuleQuantity;
+}
+
+void FHIRPathParser::QuantityContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterQuantity(this);
+}
+
+void FHIRPathParser::QuantityContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitQuantity(this);
+}
+
+
+std::any FHIRPathParser::QuantityContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitQuantity(this);
+  else
+    return visitor->visitChildren(this);
+}
+
+FHIRPathParser::QuantityContext* FHIRPathParser::quantity() {
+  QuantityContext *_localctx = _tracker.createInstance<QuantityContext>(_ctx, getState());
+  enterRule(_localctx, 16, FHIRPathParser::RuleQuantity);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(128);
+    match(FHIRPathParser::NUMBER);
+    setState(130);
+    _errHandler->sync(this);
+
+    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 9, _ctx)) {
+    case 1: {
+      setState(129);
+      unit();
+      break;
+    }
+
+    default:
+      break;
+    }
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- UnitContext ------------------------------------------------------------------
+
+FHIRPathParser::UnitContext::UnitContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+FHIRPathParser::DateTimePrecisionContext* FHIRPathParser::UnitContext::dateTimePrecision() {
+  return getRuleContext<FHIRPathParser::DateTimePrecisionContext>(0);
+}
+
+FHIRPathParser::PluralDateTimePrecisionContext* FHIRPathParser::UnitContext::pluralDateTimePrecision() {
+  return getRuleContext<FHIRPathParser::PluralDateTimePrecisionContext>(0);
+}
+
+tree::TerminalNode* FHIRPathParser::UnitContext::STRING() {
+  return getToken(FHIRPathParser::STRING, 0);
+}
+
+
+size_t FHIRPathParser::UnitContext::getRuleIndex() const {
+  return FHIRPathParser::RuleUnit;
+}
+
+void FHIRPathParser::UnitContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterUnit(this);
+}
+
+void FHIRPathParser::UnitContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitUnit(this);
+}
+
+
+std::any FHIRPathParser::UnitContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitUnit(this);
+  else
+    return visitor->visitChildren(this);
+}
+
+FHIRPathParser::UnitContext* FHIRPathParser::unit() {
+  UnitContext *_localctx = _tracker.createInstance<UnitContext>(_ctx, getState());
+  enterRule(_localctx, 18, FHIRPathParser::RuleUnit);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    setState(135);
+    _errHandler->sync(this);
+    switch (_input->LA(1)) {
+      case FHIRPathParser::T__38:
+      case FHIRPathParser::T__39:
+      case FHIRPathParser::T__40:
+      case FHIRPathParser::T__41:
+      case FHIRPathParser::T__42:
+      case FHIRPathParser::T__43:
+      case FHIRPathParser::T__44:
+      case FHIRPathParser::T__45: {
+        enterOuterAlt(_localctx, 1);
+        setState(132);
+        dateTimePrecision();
+        break;
+      }
+
+      case FHIRPathParser::T__46:
+      case FHIRPathParser::T__47:
+      case FHIRPathParser::T__48:
+      case FHIRPathParser::T__49:
+      case FHIRPathParser::T__50:
+      case FHIRPathParser::T__51:
+      case FHIRPathParser::T__52:
+      case FHIRPathParser::T__53: {
+        enterOuterAlt(_localctx, 2);
+        setState(133);
+        pluralDateTimePrecision();
+        break;
+      }
+
+      case FHIRPathParser::STRING: {
+        enterOuterAlt(_localctx, 3);
+        setState(134);
+        match(FHIRPathParser::STRING);
+        break;
+      }
+
+    default:
+      throw NoViableAltException(this);
+    }
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- DateTimePrecisionContext ------------------------------------------------------------------
+
+FHIRPathParser::DateTimePrecisionContext::DateTimePrecisionContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+
+size_t FHIRPathParser::DateTimePrecisionContext::getRuleIndex() const {
+  return FHIRPathParser::RuleDateTimePrecision;
+}
+
+void FHIRPathParser::DateTimePrecisionContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterDateTimePrecision(this);
+}
+
+void FHIRPathParser::DateTimePrecisionContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitDateTimePrecision(this);
+}
+
+
+std::any FHIRPathParser::DateTimePrecisionContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitDateTimePrecision(this);
+  else
+    return visitor->visitChildren(this);
+}
+
+FHIRPathParser::DateTimePrecisionContext* FHIRPathParser::dateTimePrecision() {
+  DateTimePrecisionContext *_localctx = _tracker.createInstance<DateTimePrecisionContext>(_ctx, getState());
+  enterRule(_localctx, 20, FHIRPathParser::RuleDateTimePrecision);
+  size_t _la = 0;
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(137);
+    _la = _input->LA(1);
+    if (!((((_la & ~ 0x3fULL) == 0) &&
+      ((1ULL << _la) & ((1ULL << FHIRPathParser::T__38)
+      | (1ULL << FHIRPathParser::T__39)
+      | (1ULL << FHIRPathParser::T__40)
+      | (1ULL << FHIRPathParser::T__41)
+      | (1ULL << FHIRPathParser::T__42)
+      | (1ULL << FHIRPathParser::T__43)
+      | (1ULL << FHIRPathParser::T__44)
+      | (1ULL << FHIRPathParser::T__45))) != 0))) {
+    _errHandler->recoverInline(this);
+    }
+    else {
+      _errHandler->reportMatch(this);
+      consume();
+    }
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- PluralDateTimePrecisionContext ------------------------------------------------------------------
+
+FHIRPathParser::PluralDateTimePrecisionContext::PluralDateTimePrecisionContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+
+size_t FHIRPathParser::PluralDateTimePrecisionContext::getRuleIndex() const {
+  return FHIRPathParser::RulePluralDateTimePrecision;
+}
+
+void FHIRPathParser::PluralDateTimePrecisionContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterPluralDateTimePrecision(this);
+}
+
+void FHIRPathParser::PluralDateTimePrecisionContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitPluralDateTimePrecision(this);
+}
+
+
+std::any FHIRPathParser::PluralDateTimePrecisionContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitPluralDateTimePrecision(this);
+  else
+    return visitor->visitChildren(this);
+}
+
+FHIRPathParser::PluralDateTimePrecisionContext* FHIRPathParser::pluralDateTimePrecision() {
+  PluralDateTimePrecisionContext *_localctx = _tracker.createInstance<PluralDateTimePrecisionContext>(_ctx, getState());
+  enterRule(_localctx, 22, FHIRPathParser::RulePluralDateTimePrecision);
+  size_t _la = 0;
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(139);
+    _la = _input->LA(1);
+    if (!((((_la & ~ 0x3fULL) == 0) &&
+      ((1ULL << _la) & ((1ULL << FHIRPathParser::T__46)
+      | (1ULL << FHIRPathParser::T__47)
+      | (1ULL << FHIRPathParser::T__48)
+      | (1ULL << FHIRPathParser::T__49)
+      | (1ULL << FHIRPathParser::T__50)
+      | (1ULL << FHIRPathParser::T__51)
+      | (1ULL << FHIRPathParser::T__52)
+      | (1ULL << FHIRPathParser::T__53))) != 0))) {
+    _errHandler->recoverInline(this);
+    }
+    else {
+      _errHandler->reportMatch(this);
+      consume();
+    }
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- TypeSpecifierContext ------------------------------------------------------------------
+
+FHIRPathParser::TypeSpecifierContext::TypeSpecifierContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+FHIRPathParser::QualifiedIdentifierContext* FHIRPathParser::TypeSpecifierContext::qualifiedIdentifier() {
+  return getRuleContext<FHIRPathParser::QualifiedIdentifierContext>(0);
+}
+
+
+size_t FHIRPathParser::TypeSpecifierContext::getRuleIndex() const {
+  return FHIRPathParser::RuleTypeSpecifier;
+}
+
+void FHIRPathParser::TypeSpecifierContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterTypeSpecifier(this);
+}
+
+void FHIRPathParser::TypeSpecifierContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitTypeSpecifier(this);
+}
+
+
+std::any FHIRPathParser::TypeSpecifierContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitTypeSpecifier(this);
+  else
+    return visitor->visitChildren(this);
+}
+
+FHIRPathParser::TypeSpecifierContext* FHIRPathParser::typeSpecifier() {
+  TypeSpecifierContext *_localctx = _tracker.createInstance<TypeSpecifierContext>(_ctx, getState());
+  enterRule(_localctx, 24, FHIRPathParser::RuleTypeSpecifier);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(141);
+    qualifiedIdentifier();
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- QualifiedIdentifierContext ------------------------------------------------------------------
+
+FHIRPathParser::QualifiedIdentifierContext::QualifiedIdentifierContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+std::vector<FHIRPathParser::IdentifierContext *> FHIRPathParser::QualifiedIdentifierContext::identifier() {
+  return getRuleContexts<FHIRPathParser::IdentifierContext>();
+}
+
+FHIRPathParser::IdentifierContext* FHIRPathParser::QualifiedIdentifierContext::identifier(size_t i) {
+  return getRuleContext<FHIRPathParser::IdentifierContext>(i);
+}
+
+
+size_t FHIRPathParser::QualifiedIdentifierContext::getRuleIndex() const {
+  return FHIRPathParser::RuleQualifiedIdentifier;
+}
+
+void FHIRPathParser::QualifiedIdentifierContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterQualifiedIdentifier(this);
+}
+
+void FHIRPathParser::QualifiedIdentifierContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitQualifiedIdentifier(this);
+}
+
+
+std::any FHIRPathParser::QualifiedIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitQualifiedIdentifier(this);
+  else
+    return visitor->visitChildren(this);
+}
+
+FHIRPathParser::QualifiedIdentifierContext* FHIRPathParser::qualifiedIdentifier() {
+  QualifiedIdentifierContext *_localctx = _tracker.createInstance<QualifiedIdentifierContext>(_ctx, getState());
+  enterRule(_localctx, 26, FHIRPathParser::RuleQualifiedIdentifier);
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    size_t alt;
+    enterOuterAlt(_localctx, 1);
+    setState(143);
+    identifier();
+    setState(148);
+    _errHandler->sync(this);
+    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 11, _ctx);
+    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
+      if (alt == 1) {
+        setState(144);
+        match(FHIRPathParser::T__0);
+        setState(145);
+        identifier(); 
+      }
+      setState(150);
+      _errHandler->sync(this);
+      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 11, _ctx);
+    }
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+//----------------- IdentifierContext ------------------------------------------------------------------
+
+FHIRPathParser::IdentifierContext::IdentifierContext(ParserRuleContext *parent, size_t invokingState)
+  : ParserRuleContext(parent, invokingState) {
+}
+
+tree::TerminalNode* FHIRPathParser::IdentifierContext::IDENTIFIER() {
+  return getToken(FHIRPathParser::IDENTIFIER, 0);
+}
+
+tree::TerminalNode* FHIRPathParser::IdentifierContext::DELIMITEDIDENTIFIER() {
+  return getToken(FHIRPathParser::DELIMITEDIDENTIFIER, 0);
+}
+
+
+size_t FHIRPathParser::IdentifierContext::getRuleIndex() const {
+  return FHIRPathParser::RuleIdentifier;
+}
+
+void FHIRPathParser::IdentifierContext::enterRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->enterIdentifier(this);
+}
+
+void FHIRPathParser::IdentifierContext::exitRule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast<FHIRPathListener *>(listener);
+  if (parserListener != nullptr)
+    parserListener->exitIdentifier(this);
+}
+
+
+std::any FHIRPathParser::IdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast<FHIRPathVisitor*>(visitor))
+    return parserVisitor->visitIdentifier(this);
+  else
+    return visitor->visitChildren(this);
+}
+
+FHIRPathParser::IdentifierContext* FHIRPathParser::identifier() {
+  IdentifierContext *_localctx = _tracker.createInstance<IdentifierContext>(_ctx, getState());
+  enterRule(_localctx, 28, FHIRPathParser::RuleIdentifier);
+  size_t _la = 0;
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+    exitRule();
+  });
+  try {
+    enterOuterAlt(_localctx, 1);
+    setState(151);
+    _la = _input->LA(1);
+    if (!((((_la & ~ 0x3fULL) == 0) &&
+      ((1ULL << _la) & ((1ULL << FHIRPathParser::T__15)
+      | (1ULL << FHIRPathParser::T__16)
+      | (1ULL << FHIRPathParser::T__21)
+      | (1ULL << FHIRPathParser::T__22)
+      | (1ULL << FHIRPathParser::IDENTIFIER)
+      | (1ULL << FHIRPathParser::DELIMITEDIDENTIFIER))) != 0))) {
+    _errHandler->recoverInline(this);
+    }
+    else {
+      _errHandler->reportMatch(this);
+      consume();
+    }
+   
+  }
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+    _localctx->exception = std::current_exception();
+    _errHandler->recover(this, _localctx->exception);
+  }
+
+  return _localctx;
+}
+
+bool FHIRPathParser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) {
+  switch (ruleIndex) {
+    case 1: return expressionSempred(antlrcpp::downCast<ExpressionContext *>(context), predicateIndex);
+
+  default:
+    break;
+  }
+  return true;
+}
+
+bool FHIRPathParser::expressionSempred(ExpressionContext *_localctx, size_t predicateIndex) {
+  switch (predicateIndex) {
+    case 0: return precpred(_ctx, 10);
+    case 1: return precpred(_ctx, 9);
+    case 2: return precpred(_ctx, 8);
+    case 3: return precpred(_ctx, 7);
+    case 4: return precpred(_ctx, 5);
+    case 5: return precpred(_ctx, 4);
+    case 6: return precpred(_ctx, 3);
+    case 7: return precpred(_ctx, 2);
+    case 8: return precpred(_ctx, 1);
+    case 9: return precpred(_ctx, 13);
+    case 10: return precpred(_ctx, 12);
+    case 11: return precpred(_ctx, 6);
+
+  default:
+    break;
+  }
+  return true;
+}
+
+void FHIRPathParser::initialize() {
+  std::call_once(fhirpathParserOnceFlag, fhirpathParserInitialize);
+}