fhirpath-rb 0.1.2 → 0.1.3

data/ext/fhir_path_parser/fhir_path_parser.cpp

@@ -0,0 +1,3161 @@
+#include <iostream>
+#include <cxxabi.h>
+#include <cstdlib>
+
+#include <antlr4-runtime.h>
+
+#include "antlrgen/FHIRPathParser.h"
+#include "antlrgen/FHIRPathBaseVisitor.h"
+#include "antlrgen/FHIRPathLexer.h"
+
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+#ifdef _WIN32
+#undef OPTIONAL
+#undef IN
+#undef OUT
+#endif
+
+#undef FALSE
+#undef TRUE
+
+#undef TYPE
+
+using namespace std;
+using namespace Rice;
+using namespace antlr4;
+
+Class rb_cEntireExpressionContext;
+Class rb_cExpressionContext;
+Class rb_cIndexerExpressionContext;
+Class rb_cPolarityExpressionContext;
+Class rb_cAdditiveExpressionContext;
+Class rb_cMultiplicativeExpressionContext;
+Class rb_cUnionExpressionContext;
+Class rb_cOrExpressionContext;
+Class rb_cAndExpressionContext;
+Class rb_cMembershipExpressionContext;
+Class rb_cInequalityExpressionContext;
+Class rb_cInvocationExpressionContext;
+Class rb_cInvocationContext;
+Class rb_cEqualityExpressionContext;
+Class rb_cImpliesExpressionContext;
+Class rb_cTermContext;
+Class rb_cTermExpressionContext;
+Class rb_cTypeExpressionContext;
+Class rb_cTypeSpecifierContext;
+Class rb_cExternalConstantContext;
+Class rb_cExternalConstantTermContext;
+Class rb_cLiteralContext;
+Class rb_cLiteralTermContext;
+Class rb_cParenthesizedTermContext;
+Class rb_cInvocationTermContext;
+Class rb_cTimeLiteralContext;
+Class rb_cNullLiteralContext;
+Class rb_cDateTimeLiteralContext;
+Class rb_cStringLiteralContext;
+Class rb_cBooleanLiteralContext;
+Class rb_cNumberLiteralContext;
+Class rb_cQuantityContext;
+Class rb_cQuantityLiteralContext;
+Class rb_cIdentifierContext;
+Class rb_cTotalInvocationContext;
+Class rb_cThisInvocationContext;
+Class rb_cIndexInvocationContext;
+Class rb_cFunctnContext;
+Class rb_cFunctionInvocationContext;
+Class rb_cMemberInvocationContext;
+Class rb_cParamListContext;
+Class rb_cUnitContext;
+Class rb_cDateTimePrecisionContext;
+Class rb_cPluralDateTimePrecisionContext;
+Class rb_cQualifiedIdentifierContext;
+Class rb_cToken;
+Class rb_cParser;
+Class rb_cParseTree;
+Class rb_cTerminalNode;
+Class rb_cContextProxy;
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<Token*> {
+  public:
+    VALUE convert(Token* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<Token>(x, false, rb_cToken);
+    }
+  };
+
+  template <>
+  class To_Ruby<tree::ParseTree*> {
+  public:
+    VALUE convert(tree::ParseTree* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<tree::ParseTree>(x, false, rb_cParseTree);
+    }
+  };
+
+  template <>
+  class To_Ruby<tree::TerminalNode*> {
+  public:
+    VALUE convert(tree::TerminalNode* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<tree::TerminalNode>(x, false, rb_cTerminalNode);
+    }
+  };
+}
+
+class ContextProxy {
+public:
+  ContextProxy(tree::ParseTree* orig) {
+    this -> orig = orig;
+  }
+
+  tree::ParseTree* getOriginal() {
+    return orig;
+  }
+
+  std::string getText() {
+    return orig -> getText();
+  }
+
+  Object getStart() {
+    auto token = ((ParserRuleContext*) orig) -> getStart();
+
+    return detail::To_Ruby<Token*>().convert(token);
+  }
+
+  Object getStop() {
+    auto token = ((ParserRuleContext*) orig) -> getStop();
+
+    return detail::To_Ruby<Token*>().convert(token);
+  }
+
+  Array getChildren() {
+    Array children;
+    if (orig != nullptr) {
+      for (auto it = orig -> children.begin(); it != orig -> children.end(); it ++) {
+        Object parseTree = ContextProxy::wrapParseTree(*it);
+
+        if (!parseTree.is_nil()) {
+          children.push(parseTree);
+        }
+      }
+    }
+    return children;
+  }
+
+  Object getParent() {
+    return orig == nullptr ? Rice::Object(Qnil) : ContextProxy::wrapParseTree(orig -> parent);
+  }
+
+  size_t childCount() {
+    return orig == nullptr ? 0 : orig -> children.size();
+  }
+
+std::string getTypeName() {
+  if (orig == nullptr) return "";
+
+  int status = 0;
+  char *demangled = abi::__cxa_demangle(typeid(*orig).name(), nullptr, nullptr, &status);
+  std::string result = (status == 0 && demangled != nullptr)
+    ? std::string(demangled)
+    : std::string(typeid(*orig).name());
+
+  if (demangled != nullptr) {
+    free(demangled);
+  }
+
+  return result;
+}
+
+  bool doubleEquals(Object other) {
+    if (other.is_a(rb_cContextProxy)) {
+      return detail::From_Ruby<ContextProxy*>().convert(other) -> getOriginal() == getOriginal();
+    } else {
+      return false;
+    }
+  }
+
+private:
+
+  static Object wrapParseTree(tree::ParseTree* node);
+
+protected:
+  tree::ParseTree* orig = nullptr;
+};
+
+class TerminalNodeProxy : public ContextProxy {
+public:
+  TerminalNodeProxy(tree::ParseTree* tree) : ContextProxy(tree) { }
+};
+
+
+class EntireExpressionContextProxy : public ContextProxy {
+public:
+  EntireExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object expression();
+  Object EOF();
+};
+
+class ExpressionContextProxy : public ContextProxy {
+public:
+  ExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+
+
+};
+
+class IndexerExpressionContextProxy : public ContextProxy {
+public:
+  IndexerExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object expression();
+  Object expressionAt(size_t i);
+
+};
+
+class PolarityExpressionContextProxy : public ContextProxy {
+public:
+  PolarityExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object expression();
+
+};
+
+class AdditiveExpressionContextProxy : public ContextProxy {
+public:
+  AdditiveExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object expression();
+  Object expressionAt(size_t i);
+
+};
+
+class MultiplicativeExpressionContextProxy : public ContextProxy {
+public:
+  MultiplicativeExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object expression();
+  Object expressionAt(size_t i);
+
+};
+
+class UnionExpressionContextProxy : public ContextProxy {
+public:
+  UnionExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object expression();
+  Object expressionAt(size_t i);
+
+};
+
+class OrExpressionContextProxy : public ContextProxy {
+public:
+  OrExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object expression();
+  Object expressionAt(size_t i);
+
+};
+
+class AndExpressionContextProxy : public ContextProxy {
+public:
+  AndExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object expression();
+  Object expressionAt(size_t i);
+
+};
+
+class MembershipExpressionContextProxy : public ContextProxy {
+public:
+  MembershipExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object expression();
+  Object expressionAt(size_t i);
+
+};
+
+class InequalityExpressionContextProxy : public ContextProxy {
+public:
+  InequalityExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object expression();
+  Object expressionAt(size_t i);
+
+};
+
+class InvocationExpressionContextProxy : public ContextProxy {
+public:
+  InvocationExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object expression();
+  Object invocation();
+
+};
+
+class InvocationContextProxy : public ContextProxy {
+public:
+  InvocationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+
+
+};
+
+class EqualityExpressionContextProxy : public ContextProxy {
+public:
+  EqualityExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object expression();
+  Object expressionAt(size_t i);
+
+};
+
+class ImpliesExpressionContextProxy : public ContextProxy {
+public:
+  ImpliesExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object expression();
+  Object expressionAt(size_t i);
+
+};
+
+class TermContextProxy : public ContextProxy {
+public:
+  TermContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+
+
+};
+
+class TermExpressionContextProxy : public ContextProxy {
+public:
+  TermExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object term();
+
+};
+
+class TypeExpressionContextProxy : public ContextProxy {
+public:
+  TypeExpressionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object expression();
+  Object typeSpecifier();
+
+};
+
+class TypeSpecifierContextProxy : public ContextProxy {
+public:
+  TypeSpecifierContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object qualifiedIdentifier();
+
+};
+
+class ExternalConstantContextProxy : public ContextProxy {
+public:
+  ExternalConstantContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object identifier();
+  Object STRING();
+};
+
+class ExternalConstantTermContextProxy : public ContextProxy {
+public:
+  ExternalConstantTermContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object externalConstant();
+
+};
+
+class LiteralContextProxy : public ContextProxy {
+public:
+  LiteralContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+
+
+};
+
+class LiteralTermContextProxy : public ContextProxy {
+public:
+  LiteralTermContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object literal();
+
+};
+
+class ParenthesizedTermContextProxy : public ContextProxy {
+public:
+  ParenthesizedTermContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object expression();
+
+};
+
+class InvocationTermContextProxy : public ContextProxy {
+public:
+  InvocationTermContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object invocation();
+
+};
+
+class TimeLiteralContextProxy : public ContextProxy {
+public:
+  TimeLiteralContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+
+  Object TIME();
+};
+
+class NullLiteralContextProxy : public ContextProxy {
+public:
+  NullLiteralContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+
+
+};
+
+class DateTimeLiteralContextProxy : public ContextProxy {
+public:
+  DateTimeLiteralContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+
+  Object DATETIME();
+};
+
+class StringLiteralContextProxy : public ContextProxy {
+public:
+  StringLiteralContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+
+  Object STRING();
+};
+
+class BooleanLiteralContextProxy : public ContextProxy {
+public:
+  BooleanLiteralContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+
+
+};
+
+class NumberLiteralContextProxy : public ContextProxy {
+public:
+  NumberLiteralContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+
+  Object NUMBER();
+};
+
+class QuantityContextProxy : public ContextProxy {
+public:
+  QuantityContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object unit();
+  Object NUMBER();
+};
+
+class QuantityLiteralContextProxy : public ContextProxy {
+public:
+  QuantityLiteralContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object quantity();
+
+};
+
+class IdentifierContextProxy : public ContextProxy {
+public:
+  IdentifierContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+
+  Object IDENTIFIER();
+  Object DELIMITEDIDENTIFIER();
+};
+
+class TotalInvocationContextProxy : public ContextProxy {
+public:
+  TotalInvocationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+
+
+};
+
+class ThisInvocationContextProxy : public ContextProxy {
+public:
+  ThisInvocationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+
+
+};
+
+class IndexInvocationContextProxy : public ContextProxy {
+public:
+  IndexInvocationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+
+
+};
+
+class FunctnContextProxy : public ContextProxy {
+public:
+  FunctnContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object identifier();
+  Object paramList();
+
+};
+
+class FunctionInvocationContextProxy : public ContextProxy {
+public:
+  FunctionInvocationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object functn();
+
+};
+
+class MemberInvocationContextProxy : public ContextProxy {
+public:
+  MemberInvocationContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object identifier();
+
+};
+
+class ParamListContextProxy : public ContextProxy {
+public:
+  ParamListContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object expression();
+  Object expressionAt(size_t i);
+
+};
+
+class UnitContextProxy : public ContextProxy {
+public:
+  UnitContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object dateTimePrecision();
+  Object pluralDateTimePrecision();
+  Object STRING();
+};
+
+class DateTimePrecisionContextProxy : public ContextProxy {
+public:
+  DateTimePrecisionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+
+
+};
+
+class PluralDateTimePrecisionContextProxy : public ContextProxy {
+public:
+  PluralDateTimePrecisionContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+
+
+};
+
+class QualifiedIdentifierContextProxy : public ContextProxy {
+public:
+  QualifiedIdentifierContextProxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+  Object identifier();
+  Object identifierAt(size_t i);
+
+};
+
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::EntireExpressionContext*> {
+  public:
+    VALUE convert(FHIRPathParser::EntireExpressionContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::EntireExpressionContext>(x, false, rb_cEntireExpressionContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<EntireExpressionContextProxy*> {
+  public:
+    VALUE convert(EntireExpressionContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<EntireExpressionContextProxy>(x, false, rb_cEntireExpressionContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::ExpressionContext*> {
+  public:
+    VALUE convert(FHIRPathParser::ExpressionContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::ExpressionContext>(x, false, rb_cExpressionContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<ExpressionContextProxy*> {
+  public:
+    VALUE convert(ExpressionContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<ExpressionContextProxy>(x, false, rb_cExpressionContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::IndexerExpressionContext*> {
+  public:
+    VALUE convert(FHIRPathParser::IndexerExpressionContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::IndexerExpressionContext>(x, false, rb_cIndexerExpressionContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<IndexerExpressionContextProxy*> {
+  public:
+    VALUE convert(IndexerExpressionContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<IndexerExpressionContextProxy>(x, false, rb_cIndexerExpressionContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::PolarityExpressionContext*> {
+  public:
+    VALUE convert(FHIRPathParser::PolarityExpressionContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::PolarityExpressionContext>(x, false, rb_cPolarityExpressionContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<PolarityExpressionContextProxy*> {
+  public:
+    VALUE convert(PolarityExpressionContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<PolarityExpressionContextProxy>(x, false, rb_cPolarityExpressionContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::AdditiveExpressionContext*> {
+  public:
+    VALUE convert(FHIRPathParser::AdditiveExpressionContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::AdditiveExpressionContext>(x, false, rb_cAdditiveExpressionContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<AdditiveExpressionContextProxy*> {
+  public:
+    VALUE convert(AdditiveExpressionContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<AdditiveExpressionContextProxy>(x, false, rb_cAdditiveExpressionContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::MultiplicativeExpressionContext*> {
+  public:
+    VALUE convert(FHIRPathParser::MultiplicativeExpressionContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::MultiplicativeExpressionContext>(x, false, rb_cMultiplicativeExpressionContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<MultiplicativeExpressionContextProxy*> {
+  public:
+    VALUE convert(MultiplicativeExpressionContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<MultiplicativeExpressionContextProxy>(x, false, rb_cMultiplicativeExpressionContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::UnionExpressionContext*> {
+  public:
+    VALUE convert(FHIRPathParser::UnionExpressionContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::UnionExpressionContext>(x, false, rb_cUnionExpressionContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<UnionExpressionContextProxy*> {
+  public:
+    VALUE convert(UnionExpressionContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<UnionExpressionContextProxy>(x, false, rb_cUnionExpressionContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::OrExpressionContext*> {
+  public:
+    VALUE convert(FHIRPathParser::OrExpressionContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::OrExpressionContext>(x, false, rb_cOrExpressionContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<OrExpressionContextProxy*> {
+  public:
+    VALUE convert(OrExpressionContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<OrExpressionContextProxy>(x, false, rb_cOrExpressionContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::AndExpressionContext*> {
+  public:
+    VALUE convert(FHIRPathParser::AndExpressionContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::AndExpressionContext>(x, false, rb_cAndExpressionContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<AndExpressionContextProxy*> {
+  public:
+    VALUE convert(AndExpressionContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<AndExpressionContextProxy>(x, false, rb_cAndExpressionContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::MembershipExpressionContext*> {
+  public:
+    VALUE convert(FHIRPathParser::MembershipExpressionContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::MembershipExpressionContext>(x, false, rb_cMembershipExpressionContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<MembershipExpressionContextProxy*> {
+  public:
+    VALUE convert(MembershipExpressionContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<MembershipExpressionContextProxy>(x, false, rb_cMembershipExpressionContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::InequalityExpressionContext*> {
+  public:
+    VALUE convert(FHIRPathParser::InequalityExpressionContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::InequalityExpressionContext>(x, false, rb_cInequalityExpressionContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<InequalityExpressionContextProxy*> {
+  public:
+    VALUE convert(InequalityExpressionContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<InequalityExpressionContextProxy>(x, false, rb_cInequalityExpressionContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::InvocationExpressionContext*> {
+  public:
+    VALUE convert(FHIRPathParser::InvocationExpressionContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::InvocationExpressionContext>(x, false, rb_cInvocationExpressionContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<InvocationExpressionContextProxy*> {
+  public:
+    VALUE convert(InvocationExpressionContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<InvocationExpressionContextProxy>(x, false, rb_cInvocationExpressionContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::InvocationContext*> {
+  public:
+    VALUE convert(FHIRPathParser::InvocationContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::InvocationContext>(x, false, rb_cInvocationContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<InvocationContextProxy*> {
+  public:
+    VALUE convert(InvocationContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<InvocationContextProxy>(x, false, rb_cInvocationContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::EqualityExpressionContext*> {
+  public:
+    VALUE convert(FHIRPathParser::EqualityExpressionContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::EqualityExpressionContext>(x, false, rb_cEqualityExpressionContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<EqualityExpressionContextProxy*> {
+  public:
+    VALUE convert(EqualityExpressionContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<EqualityExpressionContextProxy>(x, false, rb_cEqualityExpressionContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::ImpliesExpressionContext*> {
+  public:
+    VALUE convert(FHIRPathParser::ImpliesExpressionContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::ImpliesExpressionContext>(x, false, rb_cImpliesExpressionContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<ImpliesExpressionContextProxy*> {
+  public:
+    VALUE convert(ImpliesExpressionContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<ImpliesExpressionContextProxy>(x, false, rb_cImpliesExpressionContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::TermContext*> {
+  public:
+    VALUE convert(FHIRPathParser::TermContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::TermContext>(x, false, rb_cTermContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<TermContextProxy*> {
+  public:
+    VALUE convert(TermContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<TermContextProxy>(x, false, rb_cTermContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::TermExpressionContext*> {
+  public:
+    VALUE convert(FHIRPathParser::TermExpressionContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::TermExpressionContext>(x, false, rb_cTermExpressionContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<TermExpressionContextProxy*> {
+  public:
+    VALUE convert(TermExpressionContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<TermExpressionContextProxy>(x, false, rb_cTermExpressionContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::TypeExpressionContext*> {
+  public:
+    VALUE convert(FHIRPathParser::TypeExpressionContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::TypeExpressionContext>(x, false, rb_cTypeExpressionContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<TypeExpressionContextProxy*> {
+  public:
+    VALUE convert(TypeExpressionContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<TypeExpressionContextProxy>(x, false, rb_cTypeExpressionContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::TypeSpecifierContext*> {
+  public:
+    VALUE convert(FHIRPathParser::TypeSpecifierContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::TypeSpecifierContext>(x, false, rb_cTypeSpecifierContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<TypeSpecifierContextProxy*> {
+  public:
+    VALUE convert(TypeSpecifierContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<TypeSpecifierContextProxy>(x, false, rb_cTypeSpecifierContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::ExternalConstantContext*> {
+  public:
+    VALUE convert(FHIRPathParser::ExternalConstantContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::ExternalConstantContext>(x, false, rb_cExternalConstantContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<ExternalConstantContextProxy*> {
+  public:
+    VALUE convert(ExternalConstantContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<ExternalConstantContextProxy>(x, false, rb_cExternalConstantContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::ExternalConstantTermContext*> {
+  public:
+    VALUE convert(FHIRPathParser::ExternalConstantTermContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::ExternalConstantTermContext>(x, false, rb_cExternalConstantTermContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<ExternalConstantTermContextProxy*> {
+  public:
+    VALUE convert(ExternalConstantTermContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<ExternalConstantTermContextProxy>(x, false, rb_cExternalConstantTermContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::LiteralContext*> {
+  public:
+    VALUE convert(FHIRPathParser::LiteralContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::LiteralContext>(x, false, rb_cLiteralContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<LiteralContextProxy*> {
+  public:
+    VALUE convert(LiteralContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<LiteralContextProxy>(x, false, rb_cLiteralContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::LiteralTermContext*> {
+  public:
+    VALUE convert(FHIRPathParser::LiteralTermContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::LiteralTermContext>(x, false, rb_cLiteralTermContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<LiteralTermContextProxy*> {
+  public:
+    VALUE convert(LiteralTermContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<LiteralTermContextProxy>(x, false, rb_cLiteralTermContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::ParenthesizedTermContext*> {
+  public:
+    VALUE convert(FHIRPathParser::ParenthesizedTermContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::ParenthesizedTermContext>(x, false, rb_cParenthesizedTermContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<ParenthesizedTermContextProxy*> {
+  public:
+    VALUE convert(ParenthesizedTermContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<ParenthesizedTermContextProxy>(x, false, rb_cParenthesizedTermContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::InvocationTermContext*> {
+  public:
+    VALUE convert(FHIRPathParser::InvocationTermContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::InvocationTermContext>(x, false, rb_cInvocationTermContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<InvocationTermContextProxy*> {
+  public:
+    VALUE convert(InvocationTermContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<InvocationTermContextProxy>(x, false, rb_cInvocationTermContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::TimeLiteralContext*> {
+  public:
+    VALUE convert(FHIRPathParser::TimeLiteralContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::TimeLiteralContext>(x, false, rb_cTimeLiteralContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<TimeLiteralContextProxy*> {
+  public:
+    VALUE convert(TimeLiteralContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<TimeLiteralContextProxy>(x, false, rb_cTimeLiteralContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::NullLiteralContext*> {
+  public:
+    VALUE convert(FHIRPathParser::NullLiteralContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::NullLiteralContext>(x, false, rb_cNullLiteralContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<NullLiteralContextProxy*> {
+  public:
+    VALUE convert(NullLiteralContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<NullLiteralContextProxy>(x, false, rb_cNullLiteralContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::DateTimeLiteralContext*> {
+  public:
+    VALUE convert(FHIRPathParser::DateTimeLiteralContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::DateTimeLiteralContext>(x, false, rb_cDateTimeLiteralContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<DateTimeLiteralContextProxy*> {
+  public:
+    VALUE convert(DateTimeLiteralContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<DateTimeLiteralContextProxy>(x, false, rb_cDateTimeLiteralContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::StringLiteralContext*> {
+  public:
+    VALUE convert(FHIRPathParser::StringLiteralContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::StringLiteralContext>(x, false, rb_cStringLiteralContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<StringLiteralContextProxy*> {
+  public:
+    VALUE convert(StringLiteralContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<StringLiteralContextProxy>(x, false, rb_cStringLiteralContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::BooleanLiteralContext*> {
+  public:
+    VALUE convert(FHIRPathParser::BooleanLiteralContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::BooleanLiteralContext>(x, false, rb_cBooleanLiteralContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<BooleanLiteralContextProxy*> {
+  public:
+    VALUE convert(BooleanLiteralContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<BooleanLiteralContextProxy>(x, false, rb_cBooleanLiteralContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::NumberLiteralContext*> {
+  public:
+    VALUE convert(FHIRPathParser::NumberLiteralContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::NumberLiteralContext>(x, false, rb_cNumberLiteralContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<NumberLiteralContextProxy*> {
+  public:
+    VALUE convert(NumberLiteralContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<NumberLiteralContextProxy>(x, false, rb_cNumberLiteralContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::QuantityContext*> {
+  public:
+    VALUE convert(FHIRPathParser::QuantityContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::QuantityContext>(x, false, rb_cQuantityContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<QuantityContextProxy*> {
+  public:
+    VALUE convert(QuantityContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<QuantityContextProxy>(x, false, rb_cQuantityContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::QuantityLiteralContext*> {
+  public:
+    VALUE convert(FHIRPathParser::QuantityLiteralContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::QuantityLiteralContext>(x, false, rb_cQuantityLiteralContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<QuantityLiteralContextProxy*> {
+  public:
+    VALUE convert(QuantityLiteralContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<QuantityLiteralContextProxy>(x, false, rb_cQuantityLiteralContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::IdentifierContext*> {
+  public:
+    VALUE convert(FHIRPathParser::IdentifierContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::IdentifierContext>(x, false, rb_cIdentifierContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<IdentifierContextProxy*> {
+  public:
+    VALUE convert(IdentifierContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<IdentifierContextProxy>(x, false, rb_cIdentifierContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::TotalInvocationContext*> {
+  public:
+    VALUE convert(FHIRPathParser::TotalInvocationContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::TotalInvocationContext>(x, false, rb_cTotalInvocationContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<TotalInvocationContextProxy*> {
+  public:
+    VALUE convert(TotalInvocationContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<TotalInvocationContextProxy>(x, false, rb_cTotalInvocationContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::ThisInvocationContext*> {
+  public:
+    VALUE convert(FHIRPathParser::ThisInvocationContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::ThisInvocationContext>(x, false, rb_cThisInvocationContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<ThisInvocationContextProxy*> {
+  public:
+    VALUE convert(ThisInvocationContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<ThisInvocationContextProxy>(x, false, rb_cThisInvocationContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::IndexInvocationContext*> {
+  public:
+    VALUE convert(FHIRPathParser::IndexInvocationContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::IndexInvocationContext>(x, false, rb_cIndexInvocationContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<IndexInvocationContextProxy*> {
+  public:
+    VALUE convert(IndexInvocationContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<IndexInvocationContextProxy>(x, false, rb_cIndexInvocationContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::FunctnContext*> {
+  public:
+    VALUE convert(FHIRPathParser::FunctnContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::FunctnContext>(x, false, rb_cFunctnContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<FunctnContextProxy*> {
+  public:
+    VALUE convert(FunctnContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FunctnContextProxy>(x, false, rb_cFunctnContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::FunctionInvocationContext*> {
+  public:
+    VALUE convert(FHIRPathParser::FunctionInvocationContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::FunctionInvocationContext>(x, false, rb_cFunctionInvocationContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<FunctionInvocationContextProxy*> {
+  public:
+    VALUE convert(FunctionInvocationContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FunctionInvocationContextProxy>(x, false, rb_cFunctionInvocationContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::MemberInvocationContext*> {
+  public:
+    VALUE convert(FHIRPathParser::MemberInvocationContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::MemberInvocationContext>(x, false, rb_cMemberInvocationContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<MemberInvocationContextProxy*> {
+  public:
+    VALUE convert(MemberInvocationContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<MemberInvocationContextProxy>(x, false, rb_cMemberInvocationContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::ParamListContext*> {
+  public:
+    VALUE convert(FHIRPathParser::ParamListContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::ParamListContext>(x, false, rb_cParamListContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<ParamListContextProxy*> {
+  public:
+    VALUE convert(ParamListContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<ParamListContextProxy>(x, false, rb_cParamListContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::UnitContext*> {
+  public:
+    VALUE convert(FHIRPathParser::UnitContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::UnitContext>(x, false, rb_cUnitContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<UnitContextProxy*> {
+  public:
+    VALUE convert(UnitContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<UnitContextProxy>(x, false, rb_cUnitContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::DateTimePrecisionContext*> {
+  public:
+    VALUE convert(FHIRPathParser::DateTimePrecisionContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::DateTimePrecisionContext>(x, false, rb_cDateTimePrecisionContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<DateTimePrecisionContextProxy*> {
+  public:
+    VALUE convert(DateTimePrecisionContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<DateTimePrecisionContextProxy>(x, false, rb_cDateTimePrecisionContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::PluralDateTimePrecisionContext*> {
+  public:
+    VALUE convert(FHIRPathParser::PluralDateTimePrecisionContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::PluralDateTimePrecisionContext>(x, false, rb_cPluralDateTimePrecisionContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<PluralDateTimePrecisionContextProxy*> {
+  public:
+    VALUE convert(PluralDateTimePrecisionContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<PluralDateTimePrecisionContextProxy>(x, false, rb_cPluralDateTimePrecisionContext);
+    }
+  };
+}
+
+namespace Rice::detail {
+  template <>
+  class To_Ruby<FHIRPathParser::QualifiedIdentifierContext*> {
+  public:
+    VALUE convert(FHIRPathParser::QualifiedIdentifierContext* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<FHIRPathParser::QualifiedIdentifierContext>(x, false, rb_cQualifiedIdentifierContext);
+    }
+  };
+
+  template <>
+  class To_Ruby<QualifiedIdentifierContextProxy*> {
+  public:
+    VALUE convert(QualifiedIdentifierContextProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<QualifiedIdentifierContextProxy>(x, false, rb_cQualifiedIdentifierContext);
+    }
+  };
+}
+
+
+Object EntireExpressionContextProxy::expression() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::EntireExpressionContext*)orig) -> expression();
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object EntireExpressionContextProxy::EOF() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto token = ((FHIRPathParser::EntireExpressionContext*)orig) -> EOF();
+
+  if (token == nullptr) {
+    return Qnil;
+  }
+
+  TerminalNodeProxy proxy(token);
+  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
+}
+
+Object IndexerExpressionContextProxy::expression() {
+  Array a;
+
+  if (orig != nullptr) {
+    size_t count = ((FHIRPathParser::IndexerExpressionContext*)orig) -> expression().size();
+
+    for (size_t i = 0; i < count; i ++) {
+      a.push(expressionAt(i));
+    }
+  }
+
+  return std::move(a);
+}
+
+Object IndexerExpressionContextProxy::expressionAt(size_t i) {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::IndexerExpressionContext*)orig) -> expression(i);
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object PolarityExpressionContextProxy::expression() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::PolarityExpressionContext*)orig) -> expression();
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object AdditiveExpressionContextProxy::expression() {
+  Array a;
+
+  if (orig != nullptr) {
+    size_t count = ((FHIRPathParser::AdditiveExpressionContext*)orig) -> expression().size();
+
+    for (size_t i = 0; i < count; i ++) {
+      a.push(expressionAt(i));
+    }
+  }
+
+  return std::move(a);
+}
+
+Object AdditiveExpressionContextProxy::expressionAt(size_t i) {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::AdditiveExpressionContext*)orig) -> expression(i);
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object MultiplicativeExpressionContextProxy::expression() {
+  Array a;
+
+  if (orig != nullptr) {
+    size_t count = ((FHIRPathParser::MultiplicativeExpressionContext*)orig) -> expression().size();
+
+    for (size_t i = 0; i < count; i ++) {
+      a.push(expressionAt(i));
+    }
+  }
+
+  return std::move(a);
+}
+
+Object MultiplicativeExpressionContextProxy::expressionAt(size_t i) {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::MultiplicativeExpressionContext*)orig) -> expression(i);
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object UnionExpressionContextProxy::expression() {
+  Array a;
+
+  if (orig != nullptr) {
+    size_t count = ((FHIRPathParser::UnionExpressionContext*)orig) -> expression().size();
+
+    for (size_t i = 0; i < count; i ++) {
+      a.push(expressionAt(i));
+    }
+  }
+
+  return std::move(a);
+}
+
+Object UnionExpressionContextProxy::expressionAt(size_t i) {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::UnionExpressionContext*)orig) -> expression(i);
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object OrExpressionContextProxy::expression() {
+  Array a;
+
+  if (orig != nullptr) {
+    size_t count = ((FHIRPathParser::OrExpressionContext*)orig) -> expression().size();
+
+    for (size_t i = 0; i < count; i ++) {
+      a.push(expressionAt(i));
+    }
+  }
+
+  return std::move(a);
+}
+
+Object OrExpressionContextProxy::expressionAt(size_t i) {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::OrExpressionContext*)orig) -> expression(i);
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object AndExpressionContextProxy::expression() {
+  Array a;
+
+  if (orig != nullptr) {
+    size_t count = ((FHIRPathParser::AndExpressionContext*)orig) -> expression().size();
+
+    for (size_t i = 0; i < count; i ++) {
+      a.push(expressionAt(i));
+    }
+  }
+
+  return std::move(a);
+}
+
+Object AndExpressionContextProxy::expressionAt(size_t i) {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::AndExpressionContext*)orig) -> expression(i);
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object MembershipExpressionContextProxy::expression() {
+  Array a;
+
+  if (orig != nullptr) {
+    size_t count = ((FHIRPathParser::MembershipExpressionContext*)orig) -> expression().size();
+
+    for (size_t i = 0; i < count; i ++) {
+      a.push(expressionAt(i));
+    }
+  }
+
+  return std::move(a);
+}
+
+Object MembershipExpressionContextProxy::expressionAt(size_t i) {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::MembershipExpressionContext*)orig) -> expression(i);
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object InequalityExpressionContextProxy::expression() {
+  Array a;
+
+  if (orig != nullptr) {
+    size_t count = ((FHIRPathParser::InequalityExpressionContext*)orig) -> expression().size();
+
+    for (size_t i = 0; i < count; i ++) {
+      a.push(expressionAt(i));
+    }
+  }
+
+  return std::move(a);
+}
+
+Object InequalityExpressionContextProxy::expressionAt(size_t i) {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::InequalityExpressionContext*)orig) -> expression(i);
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object InvocationExpressionContextProxy::expression() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::InvocationExpressionContext*)orig) -> expression();
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object InvocationExpressionContextProxy::invocation() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::InvocationExpressionContext*)orig) -> invocation();
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object EqualityExpressionContextProxy::expression() {
+  Array a;
+
+  if (orig != nullptr) {
+    size_t count = ((FHIRPathParser::EqualityExpressionContext*)orig) -> expression().size();
+
+    for (size_t i = 0; i < count; i ++) {
+      a.push(expressionAt(i));
+    }
+  }
+
+  return std::move(a);
+}
+
+Object EqualityExpressionContextProxy::expressionAt(size_t i) {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::EqualityExpressionContext*)orig) -> expression(i);
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object ImpliesExpressionContextProxy::expression() {
+  Array a;
+
+  if (orig != nullptr) {
+    size_t count = ((FHIRPathParser::ImpliesExpressionContext*)orig) -> expression().size();
+
+    for (size_t i = 0; i < count; i ++) {
+      a.push(expressionAt(i));
+    }
+  }
+
+  return std::move(a);
+}
+
+Object ImpliesExpressionContextProxy::expressionAt(size_t i) {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::ImpliesExpressionContext*)orig) -> expression(i);
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object TermExpressionContextProxy::term() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::TermExpressionContext*)orig) -> term();
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object TypeExpressionContextProxy::expression() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::TypeExpressionContext*)orig) -> expression();
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object TypeExpressionContextProxy::typeSpecifier() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::TypeExpressionContext*)orig) -> typeSpecifier();
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object TypeSpecifierContextProxy::qualifiedIdentifier() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::TypeSpecifierContext*)orig) -> qualifiedIdentifier();
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object ExternalConstantContextProxy::identifier() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::ExternalConstantContext*)orig) -> identifier();
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object ExternalConstantContextProxy::STRING() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto token = ((FHIRPathParser::ExternalConstantContext*)orig) -> STRING();
+
+  if (token == nullptr) {
+    return Qnil;
+  }
+
+  TerminalNodeProxy proxy(token);
+  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
+}
+
+Object ExternalConstantTermContextProxy::externalConstant() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::ExternalConstantTermContext*)orig) -> externalConstant();
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object LiteralTermContextProxy::literal() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::LiteralTermContext*)orig) -> literal();
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object ParenthesizedTermContextProxy::expression() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::ParenthesizedTermContext*)orig) -> expression();
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object InvocationTermContextProxy::invocation() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::InvocationTermContext*)orig) -> invocation();
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object TimeLiteralContextProxy::TIME() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto token = ((FHIRPathParser::TimeLiteralContext*)orig) -> TIME();
+
+  if (token == nullptr) {
+    return Qnil;
+  }
+
+  TerminalNodeProxy proxy(token);
+  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
+}
+
+Object DateTimeLiteralContextProxy::DATETIME() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto token = ((FHIRPathParser::DateTimeLiteralContext*)orig) -> DATETIME();
+
+  if (token == nullptr) {
+    return Qnil;
+  }
+
+  TerminalNodeProxy proxy(token);
+  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
+}
+
+Object StringLiteralContextProxy::STRING() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto token = ((FHIRPathParser::StringLiteralContext*)orig) -> STRING();
+
+  if (token == nullptr) {
+    return Qnil;
+  }
+
+  TerminalNodeProxy proxy(token);
+  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
+}
+
+Object NumberLiteralContextProxy::NUMBER() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto token = ((FHIRPathParser::NumberLiteralContext*)orig) -> NUMBER();
+
+  if (token == nullptr) {
+    return Qnil;
+  }
+
+  TerminalNodeProxy proxy(token);
+  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
+}
+
+Object QuantityContextProxy::unit() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::QuantityContext*)orig) -> unit();
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object QuantityContextProxy::NUMBER() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto token = ((FHIRPathParser::QuantityContext*)orig) -> NUMBER();
+
+  if (token == nullptr) {
+    return Qnil;
+  }
+
+  TerminalNodeProxy proxy(token);
+  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
+}
+
+Object QuantityLiteralContextProxy::quantity() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::QuantityLiteralContext*)orig) -> quantity();
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object IdentifierContextProxy::IDENTIFIER() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto token = ((FHIRPathParser::IdentifierContext*)orig) -> IDENTIFIER();
+
+  if (token == nullptr) {
+    return Qnil;
+  }
+
+  TerminalNodeProxy proxy(token);
+  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
+}
+
+Object IdentifierContextProxy::DELIMITEDIDENTIFIER() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto token = ((FHIRPathParser::IdentifierContext*)orig) -> DELIMITEDIDENTIFIER();
+
+  if (token == nullptr) {
+    return Qnil;
+  }
+
+  TerminalNodeProxy proxy(token);
+  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
+}
+
+Object FunctnContextProxy::identifier() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::FunctnContext*)orig) -> identifier();
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object FunctnContextProxy::paramList() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::FunctnContext*)orig) -> paramList();
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object FunctionInvocationContextProxy::functn() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::FunctionInvocationContext*)orig) -> functn();
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object MemberInvocationContextProxy::identifier() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::MemberInvocationContext*)orig) -> identifier();
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object ParamListContextProxy::expression() {
+  Array a;
+
+  if (orig != nullptr) {
+    size_t count = ((FHIRPathParser::ParamListContext*)orig) -> expression().size();
+
+    for (size_t i = 0; i < count; i ++) {
+      a.push(expressionAt(i));
+    }
+  }
+
+  return std::move(a);
+}
+
+Object ParamListContextProxy::expressionAt(size_t i) {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::ParamListContext*)orig) -> expression(i);
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object UnitContextProxy::dateTimePrecision() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::UnitContext*)orig) -> dateTimePrecision();
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object UnitContextProxy::pluralDateTimePrecision() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::UnitContext*)orig) -> pluralDateTimePrecision();
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+Object UnitContextProxy::STRING() {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto token = ((FHIRPathParser::UnitContext*)orig) -> STRING();
+
+  if (token == nullptr) {
+    return Qnil;
+  }
+
+  TerminalNodeProxy proxy(token);
+  return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
+}
+
+Object QualifiedIdentifierContextProxy::identifier() {
+  Array a;
+
+  if (orig != nullptr) {
+    size_t count = ((FHIRPathParser::QualifiedIdentifierContext*)orig) -> identifier().size();
+
+    for (size_t i = 0; i < count; i ++) {
+      a.push(identifierAt(i));
+    }
+  }
+
+  return std::move(a);
+}
+
+Object QualifiedIdentifierContextProxy::identifierAt(size_t i) {
+  if (orig == nullptr) {
+    return Qnil;
+  }
+
+  auto ctx = ((FHIRPathParser::QualifiedIdentifierContext*)orig) -> identifier(i);
+
+  if (ctx == nullptr) {
+    return Qnil;
+  }
+
+  for (auto child : getChildren()) {
+    if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
+      return Rice::Object(child);
+    }
+  }
+
+  return Qnil;
+}
+
+
+class VisitorProxy : public FHIRPathBaseVisitor, public Director {
+public:
+  VisitorProxy(Object self) : Director(self) { }
+
+  Object ruby_visit(ContextProxy* proxy) {
+    auto result = visit(proxy -> getOriginal());
+    try {
+      return std::any_cast<Object>(result);
+    } catch(std::bad_cast) {
+      return Qnil;
+    }
+  }
+
+  Object ruby_visitChildren(ContextProxy* proxy) {
+    auto result = visitChildren(proxy -> getOriginal());
+    try {
+      return std::any_cast<Object>(result);
+    } catch(std::bad_cast) {
+      return Qnil;
+    }
+  }
+
+  virtual antlrcpp::Any visitEntireExpression(FHIRPathParser::EntireExpressionContext *ctx) override {
+    EntireExpressionContextProxy proxy(ctx);
+    return getSelf().call("visit_entire_expression", &proxy);
+  }
+
+  virtual antlrcpp::Any visitIndexerExpression(FHIRPathParser::IndexerExpressionContext *ctx) override {
+    IndexerExpressionContextProxy proxy(ctx);
+    return getSelf().call("visit_indexer_expression", &proxy);
+  }
+
+  virtual antlrcpp::Any visitPolarityExpression(FHIRPathParser::PolarityExpressionContext *ctx) override {
+    PolarityExpressionContextProxy proxy(ctx);
+    return getSelf().call("visit_polarity_expression", &proxy);
+  }
+
+  virtual antlrcpp::Any visitAdditiveExpression(FHIRPathParser::AdditiveExpressionContext *ctx) override {
+    AdditiveExpressionContextProxy proxy(ctx);
+    return getSelf().call("visit_additive_expression", &proxy);
+  }
+
+  virtual antlrcpp::Any visitMultiplicativeExpression(FHIRPathParser::MultiplicativeExpressionContext *ctx) override {
+    MultiplicativeExpressionContextProxy proxy(ctx);
+    return getSelf().call("visit_multiplicative_expression", &proxy);
+  }
+
+  virtual antlrcpp::Any visitUnionExpression(FHIRPathParser::UnionExpressionContext *ctx) override {
+    UnionExpressionContextProxy proxy(ctx);
+    return getSelf().call("visit_union_expression", &proxy);
+  }
+
+  virtual antlrcpp::Any visitOrExpression(FHIRPathParser::OrExpressionContext *ctx) override {
+    OrExpressionContextProxy proxy(ctx);
+    return getSelf().call("visit_or_expression", &proxy);
+  }
+
+  virtual antlrcpp::Any visitAndExpression(FHIRPathParser::AndExpressionContext *ctx) override {
+    AndExpressionContextProxy proxy(ctx);
+    return getSelf().call("visit_and_expression", &proxy);
+  }
+
+  virtual antlrcpp::Any visitMembershipExpression(FHIRPathParser::MembershipExpressionContext *ctx) override {
+    MembershipExpressionContextProxy proxy(ctx);
+    return getSelf().call("visit_membership_expression", &proxy);
+  }
+
+  virtual antlrcpp::Any visitInequalityExpression(FHIRPathParser::InequalityExpressionContext *ctx) override {
+    InequalityExpressionContextProxy proxy(ctx);
+    return getSelf().call("visit_inequality_expression", &proxy);
+  }
+
+  virtual antlrcpp::Any visitInvocationExpression(FHIRPathParser::InvocationExpressionContext *ctx) override {
+    InvocationExpressionContextProxy proxy(ctx);
+    return getSelf().call("visit_invocation_expression", &proxy);
+  }
+
+  virtual antlrcpp::Any visitEqualityExpression(FHIRPathParser::EqualityExpressionContext *ctx) override {
+    EqualityExpressionContextProxy proxy(ctx);
+    return getSelf().call("visit_equality_expression", &proxy);
+  }
+
+  virtual antlrcpp::Any visitImpliesExpression(FHIRPathParser::ImpliesExpressionContext *ctx) override {
+    ImpliesExpressionContextProxy proxy(ctx);
+    return getSelf().call("visit_implies_expression", &proxy);
+  }
+
+  virtual antlrcpp::Any visitTermExpression(FHIRPathParser::TermExpressionContext *ctx) override {
+    TermExpressionContextProxy proxy(ctx);
+    return getSelf().call("visit_term_expression", &proxy);
+  }
+
+  virtual antlrcpp::Any visitTypeExpression(FHIRPathParser::TypeExpressionContext *ctx) override {
+    TypeExpressionContextProxy proxy(ctx);
+    return getSelf().call("visit_type_expression", &proxy);
+  }
+
+  virtual antlrcpp::Any visitInvocationTerm(FHIRPathParser::InvocationTermContext *ctx) override {
+    InvocationTermContextProxy proxy(ctx);
+    return getSelf().call("visit_invocation_term", &proxy);
+  }
+
+  virtual antlrcpp::Any visitLiteralTerm(FHIRPathParser::LiteralTermContext *ctx) override {
+    LiteralTermContextProxy proxy(ctx);
+    return getSelf().call("visit_literal_term", &proxy);
+  }
+
+  virtual antlrcpp::Any visitExternalConstantTerm(FHIRPathParser::ExternalConstantTermContext *ctx) override {
+    ExternalConstantTermContextProxy proxy(ctx);
+    return getSelf().call("visit_external_constant_term", &proxy);
+  }
+
+  virtual antlrcpp::Any visitParenthesizedTerm(FHIRPathParser::ParenthesizedTermContext *ctx) override {
+    ParenthesizedTermContextProxy proxy(ctx);
+    return getSelf().call("visit_parenthesized_term", &proxy);
+  }
+
+  virtual antlrcpp::Any visitNullLiteral(FHIRPathParser::NullLiteralContext *ctx) override {
+    NullLiteralContextProxy proxy(ctx);
+    return getSelf().call("visit_null_literal", &proxy);
+  }
+
+  virtual antlrcpp::Any visitBooleanLiteral(FHIRPathParser::BooleanLiteralContext *ctx) override {
+    BooleanLiteralContextProxy proxy(ctx);
+    return getSelf().call("visit_boolean_literal", &proxy);
+  }
+
+  virtual antlrcpp::Any visitStringLiteral(FHIRPathParser::StringLiteralContext *ctx) override {
+    StringLiteralContextProxy proxy(ctx);
+    return getSelf().call("visit_string_literal", &proxy);
+  }
+
+  virtual antlrcpp::Any visitNumberLiteral(FHIRPathParser::NumberLiteralContext *ctx) override {
+    NumberLiteralContextProxy proxy(ctx);
+    return getSelf().call("visit_number_literal", &proxy);
+  }
+
+  virtual antlrcpp::Any visitDateTimeLiteral(FHIRPathParser::DateTimeLiteralContext *ctx) override {
+    DateTimeLiteralContextProxy proxy(ctx);
+    return getSelf().call("visit_date_time_literal", &proxy);
+  }
+
+  virtual antlrcpp::Any visitTimeLiteral(FHIRPathParser::TimeLiteralContext *ctx) override {
+    TimeLiteralContextProxy proxy(ctx);
+    return getSelf().call("visit_time_literal", &proxy);
+  }
+
+  virtual antlrcpp::Any visitQuantityLiteral(FHIRPathParser::QuantityLiteralContext *ctx) override {
+    QuantityLiteralContextProxy proxy(ctx);
+    return getSelf().call("visit_quantity_literal", &proxy);
+  }
+
+  virtual antlrcpp::Any visitExternalConstant(FHIRPathParser::ExternalConstantContext *ctx) override {
+    ExternalConstantContextProxy proxy(ctx);
+    return getSelf().call("visit_external_constant", &proxy);
+  }
+
+  virtual antlrcpp::Any visitMemberInvocation(FHIRPathParser::MemberInvocationContext *ctx) override {
+    MemberInvocationContextProxy proxy(ctx);
+    return getSelf().call("visit_member_invocation", &proxy);
+  }
+
+  virtual antlrcpp::Any visitFunctionInvocation(FHIRPathParser::FunctionInvocationContext *ctx) override {
+    FunctionInvocationContextProxy proxy(ctx);
+    return getSelf().call("visit_function_invocation", &proxy);
+  }
+
+  virtual antlrcpp::Any visitThisInvocation(FHIRPathParser::ThisInvocationContext *ctx) override {
+    ThisInvocationContextProxy proxy(ctx);
+    return getSelf().call("visit_this_invocation", &proxy);
+  }
+
+  virtual antlrcpp::Any visitIndexInvocation(FHIRPathParser::IndexInvocationContext *ctx) override {
+    IndexInvocationContextProxy proxy(ctx);
+    return getSelf().call("visit_index_invocation", &proxy);
+  }
+
+  virtual antlrcpp::Any visitTotalInvocation(FHIRPathParser::TotalInvocationContext *ctx) override {
+    TotalInvocationContextProxy proxy(ctx);
+    return getSelf().call("visit_total_invocation", &proxy);
+  }
+
+  virtual antlrcpp::Any visitFunctn(FHIRPathParser::FunctnContext *ctx) override {
+    FunctnContextProxy proxy(ctx);
+    return getSelf().call("visit_functn", &proxy);
+  }
+
+  virtual antlrcpp::Any visitParamList(FHIRPathParser::ParamListContext *ctx) override {
+    ParamListContextProxy proxy(ctx);
+    return getSelf().call("visit_param_list", &proxy);
+  }
+
+  virtual antlrcpp::Any visitQuantity(FHIRPathParser::QuantityContext *ctx) override {
+    QuantityContextProxy proxy(ctx);
+    return getSelf().call("visit_quantity", &proxy);
+  }
+
+  virtual antlrcpp::Any visitUnit(FHIRPathParser::UnitContext *ctx) override {
+    UnitContextProxy proxy(ctx);
+    return getSelf().call("visit_unit", &proxy);
+  }
+
+  virtual antlrcpp::Any visitDateTimePrecision(FHIRPathParser::DateTimePrecisionContext *ctx) override {
+    DateTimePrecisionContextProxy proxy(ctx);
+    return getSelf().call("visit_date_time_precision", &proxy);
+  }
+
+  virtual antlrcpp::Any visitPluralDateTimePrecision(FHIRPathParser::PluralDateTimePrecisionContext *ctx) override {
+    PluralDateTimePrecisionContextProxy proxy(ctx);
+    return getSelf().call("visit_plural_date_time_precision", &proxy);
+  }
+
+  virtual antlrcpp::Any visitTypeSpecifier(FHIRPathParser::TypeSpecifierContext *ctx) override {
+    TypeSpecifierContextProxy proxy(ctx);
+    return getSelf().call("visit_type_specifier", &proxy);
+  }
+
+  virtual antlrcpp::Any visitQualifiedIdentifier(FHIRPathParser::QualifiedIdentifierContext *ctx) override {
+    QualifiedIdentifierContextProxy proxy(ctx);
+    return getSelf().call("visit_qualified_identifier", &proxy);
+  }
+
+  virtual antlrcpp::Any visitIdentifier(FHIRPathParser::IdentifierContext *ctx) override {
+    IdentifierContextProxy proxy(ctx);
+    return getSelf().call("visit_identifier", &proxy);
+  }
+
+};
+
+
+class CountingErrorListener : public BaseErrorListener {
+public:
+  size_t *counter = nullptr;
+
+  void syntaxError(Recognizer *recognizer, Token *offendingSymbol, size_t line,
+                    size_t charPositionInLine, const std::string &msg,
+                    std::exception_ptr e) override {
+    if (counter != nullptr) {
+      (*counter)++;
+    }
+  }
+};
+
+class ParserProxy {
+public:
+  size_t syntaxErrorCount() { return errorCount; }
+
+  static ParserProxy* parse(string code) {
+    auto input = new ANTLRInputStream(code);
+    return parseStream(input);
+  }
+
+  static ParserProxy* parseFile(string file) {
+    ifstream stream;
+    stream.open(file);
+
+    auto input = new ANTLRInputStream(stream);
+    auto parser = parseStream(input);
+
+    stream.close();
+
+    return parser;
+  }
+
+  Object expression() {
+    auto ctx = this -> parser -> expression();
+
+    ExpressionContextProxy proxy((FHIRPathParser::ExpressionContext*) ctx);
+    return detail::To_Ruby<ExpressionContextProxy>().convert(proxy);
+  }
+
+  Object visit(VisitorProxy* visitor) {
+    auto result = visitor -> visit(this -> parser -> expression());
+
+    // reset for the next visit call
+    this -> lexer -> reset();
+    this -> parser -> reset();
+
+    return std::any_cast<Object>(result);
+  }
+
+  ~ParserProxy() {
+    delete this -> parser;
+    delete this -> tokens;
+    delete this -> lexer;
+    delete this -> input;
+  }
+
+private:
+  static ParserProxy* parseStream(ANTLRInputStream* input) {
+    ParserProxy* parser = new ParserProxy();
+
+    parser -> input = input;
+    parser -> lexer = new FHIRPathLexer(parser -> input);
+    parser -> tokens = new CommonTokenStream(parser -> lexer);
+    parser -> parser = new FHIRPathParser(parser -> tokens);
+
+    parser -> errorListener.counter = &parser -> errorCount;
+    parser -> lexer -> removeErrorListeners();
+    parser -> lexer -> addErrorListener(&parser -> errorListener);
+    parser -> parser -> removeErrorListeners();
+    parser -> parser -> addErrorListener(&parser -> errorListener);
+
+    return parser;
+  }
+
+  ParserProxy() {};
+
+  ANTLRInputStream* input;
+  FHIRPathLexer* lexer;
+  CommonTokenStream* tokens;
+  FHIRPathParser* parser;
+  CountingErrorListener errorListener;
+  size_t errorCount = 0;
+};
+
+namespace Rice::detail {
+  template <>
+  struct Type<ParserProxy*> {
+    static bool verify() {
+      return true;
+    }
+  };
+
+  template <>
+  class To_Ruby<ParserProxy*> {
+  public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Arg* arg) : arg_(arg) {}
+
+    VALUE convert(ParserProxy* const &x) {
+      if (!x) return Qnil;
+      return Data_Object<ParserProxy>(x, false, rb_cParser);
+    }
+  private:
+    Arg* arg_ = nullptr;
+  };
+}
+
+
+Object ContextProxy::wrapParseTree(tree::ParseTree* node) {
+  if (antlrcpp::is<FHIRPathParser::EntireExpressionContext*>(node)) {
+    EntireExpressionContextProxy proxy((FHIRPathParser::EntireExpressionContext*)node);
+    return detail::To_Ruby<EntireExpressionContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::ExpressionContext*>(node)) {
+    ExpressionContextProxy proxy((FHIRPathParser::ExpressionContext*)node);
+    return detail::To_Ruby<ExpressionContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::IndexerExpressionContext*>(node)) {
+    IndexerExpressionContextProxy proxy((FHIRPathParser::IndexerExpressionContext*)node);
+    return detail::To_Ruby<IndexerExpressionContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::PolarityExpressionContext*>(node)) {
+    PolarityExpressionContextProxy proxy((FHIRPathParser::PolarityExpressionContext*)node);
+    return detail::To_Ruby<PolarityExpressionContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::AdditiveExpressionContext*>(node)) {
+    AdditiveExpressionContextProxy proxy((FHIRPathParser::AdditiveExpressionContext*)node);
+    return detail::To_Ruby<AdditiveExpressionContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::MultiplicativeExpressionContext*>(node)) {
+    MultiplicativeExpressionContextProxy proxy((FHIRPathParser::MultiplicativeExpressionContext*)node);
+    return detail::To_Ruby<MultiplicativeExpressionContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::UnionExpressionContext*>(node)) {
+    UnionExpressionContextProxy proxy((FHIRPathParser::UnionExpressionContext*)node);
+    return detail::To_Ruby<UnionExpressionContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::OrExpressionContext*>(node)) {
+    OrExpressionContextProxy proxy((FHIRPathParser::OrExpressionContext*)node);
+    return detail::To_Ruby<OrExpressionContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::AndExpressionContext*>(node)) {
+    AndExpressionContextProxy proxy((FHIRPathParser::AndExpressionContext*)node);
+    return detail::To_Ruby<AndExpressionContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::MembershipExpressionContext*>(node)) {
+    MembershipExpressionContextProxy proxy((FHIRPathParser::MembershipExpressionContext*)node);
+    return detail::To_Ruby<MembershipExpressionContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::InequalityExpressionContext*>(node)) {
+    InequalityExpressionContextProxy proxy((FHIRPathParser::InequalityExpressionContext*)node);
+    return detail::To_Ruby<InequalityExpressionContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::InvocationExpressionContext*>(node)) {
+    InvocationExpressionContextProxy proxy((FHIRPathParser::InvocationExpressionContext*)node);
+    return detail::To_Ruby<InvocationExpressionContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::InvocationContext*>(node)) {
+    InvocationContextProxy proxy((FHIRPathParser::InvocationContext*)node);
+    return detail::To_Ruby<InvocationContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::EqualityExpressionContext*>(node)) {
+    EqualityExpressionContextProxy proxy((FHIRPathParser::EqualityExpressionContext*)node);
+    return detail::To_Ruby<EqualityExpressionContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::ImpliesExpressionContext*>(node)) {
+    ImpliesExpressionContextProxy proxy((FHIRPathParser::ImpliesExpressionContext*)node);
+    return detail::To_Ruby<ImpliesExpressionContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::TermContext*>(node)) {
+    TermContextProxy proxy((FHIRPathParser::TermContext*)node);
+    return detail::To_Ruby<TermContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::TermExpressionContext*>(node)) {
+    TermExpressionContextProxy proxy((FHIRPathParser::TermExpressionContext*)node);
+    return detail::To_Ruby<TermExpressionContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::TypeExpressionContext*>(node)) {
+    TypeExpressionContextProxy proxy((FHIRPathParser::TypeExpressionContext*)node);
+    return detail::To_Ruby<TypeExpressionContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::TypeSpecifierContext*>(node)) {
+    TypeSpecifierContextProxy proxy((FHIRPathParser::TypeSpecifierContext*)node);
+    return detail::To_Ruby<TypeSpecifierContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::ExternalConstantContext*>(node)) {
+    ExternalConstantContextProxy proxy((FHIRPathParser::ExternalConstantContext*)node);
+    return detail::To_Ruby<ExternalConstantContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::ExternalConstantTermContext*>(node)) {
+    ExternalConstantTermContextProxy proxy((FHIRPathParser::ExternalConstantTermContext*)node);
+    return detail::To_Ruby<ExternalConstantTermContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::LiteralContext*>(node)) {
+    LiteralContextProxy proxy((FHIRPathParser::LiteralContext*)node);
+    return detail::To_Ruby<LiteralContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::LiteralTermContext*>(node)) {
+    LiteralTermContextProxy proxy((FHIRPathParser::LiteralTermContext*)node);
+    return detail::To_Ruby<LiteralTermContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::ParenthesizedTermContext*>(node)) {
+    ParenthesizedTermContextProxy proxy((FHIRPathParser::ParenthesizedTermContext*)node);
+    return detail::To_Ruby<ParenthesizedTermContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::InvocationTermContext*>(node)) {
+    InvocationTermContextProxy proxy((FHIRPathParser::InvocationTermContext*)node);
+    return detail::To_Ruby<InvocationTermContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::TimeLiteralContext*>(node)) {
+    TimeLiteralContextProxy proxy((FHIRPathParser::TimeLiteralContext*)node);
+    return detail::To_Ruby<TimeLiteralContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::NullLiteralContext*>(node)) {
+    NullLiteralContextProxy proxy((FHIRPathParser::NullLiteralContext*)node);
+    return detail::To_Ruby<NullLiteralContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::DateTimeLiteralContext*>(node)) {
+    DateTimeLiteralContextProxy proxy((FHIRPathParser::DateTimeLiteralContext*)node);
+    return detail::To_Ruby<DateTimeLiteralContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::StringLiteralContext*>(node)) {
+    StringLiteralContextProxy proxy((FHIRPathParser::StringLiteralContext*)node);
+    return detail::To_Ruby<StringLiteralContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::BooleanLiteralContext*>(node)) {
+    BooleanLiteralContextProxy proxy((FHIRPathParser::BooleanLiteralContext*)node);
+    return detail::To_Ruby<BooleanLiteralContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::NumberLiteralContext*>(node)) {
+    NumberLiteralContextProxy proxy((FHIRPathParser::NumberLiteralContext*)node);
+    return detail::To_Ruby<NumberLiteralContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::QuantityContext*>(node)) {
+    QuantityContextProxy proxy((FHIRPathParser::QuantityContext*)node);
+    return detail::To_Ruby<QuantityContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::QuantityLiteralContext*>(node)) {
+    QuantityLiteralContextProxy proxy((FHIRPathParser::QuantityLiteralContext*)node);
+    return detail::To_Ruby<QuantityLiteralContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::IdentifierContext*>(node)) {
+    IdentifierContextProxy proxy((FHIRPathParser::IdentifierContext*)node);
+    return detail::To_Ruby<IdentifierContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::TotalInvocationContext*>(node)) {
+    TotalInvocationContextProxy proxy((FHIRPathParser::TotalInvocationContext*)node);
+    return detail::To_Ruby<TotalInvocationContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::ThisInvocationContext*>(node)) {
+    ThisInvocationContextProxy proxy((FHIRPathParser::ThisInvocationContext*)node);
+    return detail::To_Ruby<ThisInvocationContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::IndexInvocationContext*>(node)) {
+    IndexInvocationContextProxy proxy((FHIRPathParser::IndexInvocationContext*)node);
+    return detail::To_Ruby<IndexInvocationContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::FunctnContext*>(node)) {
+    FunctnContextProxy proxy((FHIRPathParser::FunctnContext*)node);
+    return detail::To_Ruby<FunctnContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::FunctionInvocationContext*>(node)) {
+    FunctionInvocationContextProxy proxy((FHIRPathParser::FunctionInvocationContext*)node);
+    return detail::To_Ruby<FunctionInvocationContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::MemberInvocationContext*>(node)) {
+    MemberInvocationContextProxy proxy((FHIRPathParser::MemberInvocationContext*)node);
+    return detail::To_Ruby<MemberInvocationContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::ParamListContext*>(node)) {
+    ParamListContextProxy proxy((FHIRPathParser::ParamListContext*)node);
+    return detail::To_Ruby<ParamListContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::UnitContext*>(node)) {
+    UnitContextProxy proxy((FHIRPathParser::UnitContext*)node);
+    return detail::To_Ruby<UnitContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::DateTimePrecisionContext*>(node)) {
+    DateTimePrecisionContextProxy proxy((FHIRPathParser::DateTimePrecisionContext*)node);
+    return detail::To_Ruby<DateTimePrecisionContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::PluralDateTimePrecisionContext*>(node)) {
+    PluralDateTimePrecisionContextProxy proxy((FHIRPathParser::PluralDateTimePrecisionContext*)node);
+    return detail::To_Ruby<PluralDateTimePrecisionContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<FHIRPathParser::QualifiedIdentifierContext*>(node)) {
+    QualifiedIdentifierContextProxy proxy((FHIRPathParser::QualifiedIdentifierContext*)node);
+    return detail::To_Ruby<QualifiedIdentifierContextProxy>().convert(proxy);
+  }
+  else if (antlrcpp::is<tree::TerminalNodeImpl*>(node)) {
+    TerminalNodeProxy proxy(node);
+    return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
+  } else {
+    return Qnil;
+  }
+}
+
+
+extern "C"
+void Init_fhir_path_parser() {
+  Module rb_mFHIRPathParser = define_module("FHIRPathParser");
+
+  rb_cToken = define_class_under<Token>(rb_mFHIRPathParser, "Token")
+    .define_method("text", &Token::getText)
+    .define_method("channel", &Token::getChannel)
+    .define_method("token_index", &Token::getTokenIndex);
+
+  rb_cParseTree = define_class_under<tree::ParseTree>(rb_mFHIRPathParser, "ParseTree");
+
+  rb_cContextProxy = define_class_under<ContextProxy>(rb_mFHIRPathParser, "Context")
+    .define_method("children", &ContextProxy::getChildren)
+    .define_method("child_count", &ContextProxy::childCount)
+    .define_method("text", &ContextProxy::getText)
+    .define_method("start", &ContextProxy::getStart)
+    .define_method("stop", &ContextProxy::getStop)
+    .define_method("parent", &ContextProxy::getParent)
+    .define_method("==", &ContextProxy::doubleEquals)
+    .define_method("type_name", &ContextProxy::getTypeName);
+
+  rb_cTerminalNode = define_class_under<TerminalNodeProxy, ContextProxy>(rb_mFHIRPathParser, "TerminalNodeImpl");
+
+  define_class_under<FHIRPathBaseVisitor>(rb_mFHIRPathParser, "Visitor")
+    .define_director<VisitorProxy>()
+    .define_constructor(Constructor<VisitorProxy, Object>())
+    .define_method("visit", &VisitorProxy::ruby_visit)
+    .define_method("visit_children", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_entire_expression", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_indexer_expression", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_polarity_expression", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_additive_expression", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_multiplicative_expression", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_union_expression", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_or_expression", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_and_expression", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_membership_expression", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_inequality_expression", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_invocation_expression", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_equality_expression", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_implies_expression", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_term_expression", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_type_expression", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_invocation_term", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_literal_term", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_external_constant_term", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_parenthesized_term", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_null_literal", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_boolean_literal", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_string_literal", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_number_literal", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_date_time_literal", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_time_literal", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_quantity_literal", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_external_constant", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_member_invocation", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_function_invocation", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_this_invocation", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_index_invocation", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_total_invocation", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_functn", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_param_list", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_quantity", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_unit", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_date_time_precision", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_plural_date_time_precision", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_type_specifier", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_qualified_identifier", &VisitorProxy::ruby_visitChildren)
+    .define_method("visit_identifier", &VisitorProxy::ruby_visitChildren);
+
+  rb_cParser = define_class_under<ParserProxy>(rb_mFHIRPathParser, "Parser")
+    .define_singleton_function("parse", &ParserProxy::parse)
+    .define_singleton_function("parse_file", &ParserProxy::parseFile)
+    .define_method("expression", &ParserProxy::expression)
+    .define_method("visit", &ParserProxy::visit)
+    .define_method("syntax_error_count", &ParserProxy::syntaxErrorCount);
+
+  rb_cEntireExpressionContext = define_class_under<EntireExpressionContextProxy, ContextProxy>(rb_mFHIRPathParser, "EntireExpressionContext")
+    .define_method("expression", &EntireExpressionContextProxy::expression)
+    .define_method("EOF", &EntireExpressionContextProxy::EOF);
+
+  rb_cExpressionContext = define_class_under<ExpressionContextProxy, ContextProxy>(rb_mFHIRPathParser, "ExpressionContext");
+
+  rb_cIndexerExpressionContext = define_class_under<IndexerExpressionContextProxy, ContextProxy>(rb_mFHIRPathParser, "IndexerExpressionContext")
+    .define_method("expression", &IndexerExpressionContextProxy::expression)
+    .define_method("expression_at", &IndexerExpressionContextProxy::expressionAt);
+
+  rb_cPolarityExpressionContext = define_class_under<PolarityExpressionContextProxy, ContextProxy>(rb_mFHIRPathParser, "PolarityExpressionContext")
+    .define_method("expression", &PolarityExpressionContextProxy::expression);
+
+  rb_cAdditiveExpressionContext = define_class_under<AdditiveExpressionContextProxy, ContextProxy>(rb_mFHIRPathParser, "AdditiveExpressionContext")
+    .define_method("expression", &AdditiveExpressionContextProxy::expression)
+    .define_method("expression_at", &AdditiveExpressionContextProxy::expressionAt);
+
+  rb_cMultiplicativeExpressionContext = define_class_under<MultiplicativeExpressionContextProxy, ContextProxy>(rb_mFHIRPathParser, "MultiplicativeExpressionContext")
+    .define_method("expression", &MultiplicativeExpressionContextProxy::expression)
+    .define_method("expression_at", &MultiplicativeExpressionContextProxy::expressionAt);
+
+  rb_cUnionExpressionContext = define_class_under<UnionExpressionContextProxy, ContextProxy>(rb_mFHIRPathParser, "UnionExpressionContext")
+    .define_method("expression", &UnionExpressionContextProxy::expression)
+    .define_method("expression_at", &UnionExpressionContextProxy::expressionAt);
+
+  rb_cOrExpressionContext = define_class_under<OrExpressionContextProxy, ContextProxy>(rb_mFHIRPathParser, "OrExpressionContext")
+    .define_method("expression", &OrExpressionContextProxy::expression)
+    .define_method("expression_at", &OrExpressionContextProxy::expressionAt);
+
+  rb_cAndExpressionContext = define_class_under<AndExpressionContextProxy, ContextProxy>(rb_mFHIRPathParser, "AndExpressionContext")
+    .define_method("expression", &AndExpressionContextProxy::expression)
+    .define_method("expression_at", &AndExpressionContextProxy::expressionAt);
+
+  rb_cMembershipExpressionContext = define_class_under<MembershipExpressionContextProxy, ContextProxy>(rb_mFHIRPathParser, "MembershipExpressionContext")
+    .define_method("expression", &MembershipExpressionContextProxy::expression)
+    .define_method("expression_at", &MembershipExpressionContextProxy::expressionAt);
+
+  rb_cInequalityExpressionContext = define_class_under<InequalityExpressionContextProxy, ContextProxy>(rb_mFHIRPathParser, "InequalityExpressionContext")
+    .define_method("expression", &InequalityExpressionContextProxy::expression)
+    .define_method("expression_at", &InequalityExpressionContextProxy::expressionAt);
+
+  rb_cInvocationExpressionContext = define_class_under<InvocationExpressionContextProxy, ContextProxy>(rb_mFHIRPathParser, "InvocationExpressionContext")
+    .define_method("expression", &InvocationExpressionContextProxy::expression)
+    .define_method("invocation", &InvocationExpressionContextProxy::invocation);
+
+  rb_cInvocationContext = define_class_under<InvocationContextProxy, ContextProxy>(rb_mFHIRPathParser, "InvocationContext");
+
+  rb_cEqualityExpressionContext = define_class_under<EqualityExpressionContextProxy, ContextProxy>(rb_mFHIRPathParser, "EqualityExpressionContext")
+    .define_method("expression", &EqualityExpressionContextProxy::expression)
+    .define_method("expression_at", &EqualityExpressionContextProxy::expressionAt);
+
+  rb_cImpliesExpressionContext = define_class_under<ImpliesExpressionContextProxy, ContextProxy>(rb_mFHIRPathParser, "ImpliesExpressionContext")
+    .define_method("expression", &ImpliesExpressionContextProxy::expression)
+    .define_method("expression_at", &ImpliesExpressionContextProxy::expressionAt);
+
+  rb_cTermContext = define_class_under<TermContextProxy, ContextProxy>(rb_mFHIRPathParser, "TermContext");
+
+  rb_cTermExpressionContext = define_class_under<TermExpressionContextProxy, ContextProxy>(rb_mFHIRPathParser, "TermExpressionContext")
+    .define_method("term", &TermExpressionContextProxy::term);
+
+  rb_cTypeExpressionContext = define_class_under<TypeExpressionContextProxy, ContextProxy>(rb_mFHIRPathParser, "TypeExpressionContext")
+    .define_method("expression", &TypeExpressionContextProxy::expression)
+    .define_method("type_specifier", &TypeExpressionContextProxy::typeSpecifier);
+
+  rb_cTypeSpecifierContext = define_class_under<TypeSpecifierContextProxy, ContextProxy>(rb_mFHIRPathParser, "TypeSpecifierContext")
+    .define_method("qualified_identifier", &TypeSpecifierContextProxy::qualifiedIdentifier);
+
+  rb_cExternalConstantContext = define_class_under<ExternalConstantContextProxy, ContextProxy>(rb_mFHIRPathParser, "ExternalConstantContext")
+    .define_method("identifier", &ExternalConstantContextProxy::identifier)
+    .define_method("STRING", &ExternalConstantContextProxy::STRING);
+
+  rb_cExternalConstantTermContext = define_class_under<ExternalConstantTermContextProxy, ContextProxy>(rb_mFHIRPathParser, "ExternalConstantTermContext")
+    .define_method("external_constant", &ExternalConstantTermContextProxy::externalConstant);
+
+  rb_cLiteralContext = define_class_under<LiteralContextProxy, ContextProxy>(rb_mFHIRPathParser, "LiteralContext");
+
+  rb_cLiteralTermContext = define_class_under<LiteralTermContextProxy, ContextProxy>(rb_mFHIRPathParser, "LiteralTermContext")
+    .define_method("literal", &LiteralTermContextProxy::literal);
+
+  rb_cParenthesizedTermContext = define_class_under<ParenthesizedTermContextProxy, ContextProxy>(rb_mFHIRPathParser, "ParenthesizedTermContext")
+    .define_method("expression", &ParenthesizedTermContextProxy::expression);
+
+  rb_cInvocationTermContext = define_class_under<InvocationTermContextProxy, ContextProxy>(rb_mFHIRPathParser, "InvocationTermContext")
+    .define_method("invocation", &InvocationTermContextProxy::invocation);
+
+  rb_cTimeLiteralContext = define_class_under<TimeLiteralContextProxy, ContextProxy>(rb_mFHIRPathParser, "TimeLiteralContext")
+    .define_method("TIME", &TimeLiteralContextProxy::TIME);
+
+  rb_cNullLiteralContext = define_class_under<NullLiteralContextProxy, ContextProxy>(rb_mFHIRPathParser, "NullLiteralContext");
+
+  rb_cDateTimeLiteralContext = define_class_under<DateTimeLiteralContextProxy, ContextProxy>(rb_mFHIRPathParser, "DateTimeLiteralContext")
+    .define_method("DATETIME", &DateTimeLiteralContextProxy::DATETIME);
+
+  rb_cStringLiteralContext = define_class_under<StringLiteralContextProxy, ContextProxy>(rb_mFHIRPathParser, "StringLiteralContext")
+    .define_method("STRING", &StringLiteralContextProxy::STRING);
+
+  rb_cBooleanLiteralContext = define_class_under<BooleanLiteralContextProxy, ContextProxy>(rb_mFHIRPathParser, "BooleanLiteralContext");
+
+  rb_cNumberLiteralContext = define_class_under<NumberLiteralContextProxy, ContextProxy>(rb_mFHIRPathParser, "NumberLiteralContext")
+    .define_method("NUMBER", &NumberLiteralContextProxy::NUMBER);
+
+  rb_cQuantityContext = define_class_under<QuantityContextProxy, ContextProxy>(rb_mFHIRPathParser, "QuantityContext")
+    .define_method("unit", &QuantityContextProxy::unit)
+    .define_method("NUMBER", &QuantityContextProxy::NUMBER);
+
+  rb_cQuantityLiteralContext = define_class_under<QuantityLiteralContextProxy, ContextProxy>(rb_mFHIRPathParser, "QuantityLiteralContext")
+    .define_method("quantity", &QuantityLiteralContextProxy::quantity);
+
+  rb_cIdentifierContext = define_class_under<IdentifierContextProxy, ContextProxy>(rb_mFHIRPathParser, "IdentifierContext")
+    .define_method("IDENTIFIER", &IdentifierContextProxy::IDENTIFIER)
+    .define_method("DELIMITEDIDENTIFIER", &IdentifierContextProxy::DELIMITEDIDENTIFIER);
+
+  rb_cTotalInvocationContext = define_class_under<TotalInvocationContextProxy, ContextProxy>(rb_mFHIRPathParser, "TotalInvocationContext");
+
+  rb_cThisInvocationContext = define_class_under<ThisInvocationContextProxy, ContextProxy>(rb_mFHIRPathParser, "ThisInvocationContext");
+
+  rb_cIndexInvocationContext = define_class_under<IndexInvocationContextProxy, ContextProxy>(rb_mFHIRPathParser, "IndexInvocationContext");
+
+  rb_cFunctnContext = define_class_under<FunctnContextProxy, ContextProxy>(rb_mFHIRPathParser, "FunctnContext")
+    .define_method("identifier", &FunctnContextProxy::identifier)
+    .define_method("param_list", &FunctnContextProxy::paramList);
+
+  rb_cFunctionInvocationContext = define_class_under<FunctionInvocationContextProxy, ContextProxy>(rb_mFHIRPathParser, "FunctionInvocationContext")
+    .define_method("functn", &FunctionInvocationContextProxy::functn);
+
+  rb_cMemberInvocationContext = define_class_under<MemberInvocationContextProxy, ContextProxy>(rb_mFHIRPathParser, "MemberInvocationContext")
+    .define_method("identifier", &MemberInvocationContextProxy::identifier);
+
+  rb_cParamListContext = define_class_under<ParamListContextProxy, ContextProxy>(rb_mFHIRPathParser, "ParamListContext")
+    .define_method("expression", &ParamListContextProxy::expression)
+    .define_method("expression_at", &ParamListContextProxy::expressionAt);
+
+  rb_cUnitContext = define_class_under<UnitContextProxy, ContextProxy>(rb_mFHIRPathParser, "UnitContext")
+    .define_method("date_time_precision", &UnitContextProxy::dateTimePrecision)
+    .define_method("plural_date_time_precision", &UnitContextProxy::pluralDateTimePrecision)
+    .define_method("STRING", &UnitContextProxy::STRING);
+
+  rb_cDateTimePrecisionContext = define_class_under<DateTimePrecisionContextProxy, ContextProxy>(rb_mFHIRPathParser, "DateTimePrecisionContext");
+
+  rb_cPluralDateTimePrecisionContext = define_class_under<PluralDateTimePrecisionContextProxy, ContextProxy>(rb_mFHIRPathParser, "PluralDateTimePrecisionContext");
+
+  rb_cQualifiedIdentifierContext = define_class_under<QualifiedIdentifierContextProxy, ContextProxy>(rb_mFHIRPathParser, "QualifiedIdentifierContext")
+    .define_method("identifier", &QualifiedIdentifierContextProxy::identifier)
+    .define_method("identifier_at", &QualifiedIdentifierContextProxy::identifierAt);
+}
+