interpreter_tree first iteration

.clangd

@@ -0,0 +1,2 @@
+CompileFlags:
+  Add: [-std=c++17]

CMakeLists.txt

@@ -8,8 +8,10 @@ find_package(Catch2 2 REQUIRED)
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
 
+include_directories(include)
+include(tree_sitter/api.h)
+
 # add_executable(interpreter_tests tests/tests.cpp)
 # target_link_libraries(tests PRIVATE Catch2::Catch2WithMain)
 
 # add_executable(lang_interpreter src/main.cpp)
-

include/contexts.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <unordered_map>
+
+// for clangd
+#include "symbols_info.hpp"
+
+namespace info {
+
+class ContextManager {
+public:
+  void CallFunction(const std::vector<VariableInfo>&);
+  void EnterContext();
+  void ExitContext();
+
+  void DefineVariable(const VariableInfo& variable);
+  void ChangeVariableValue(const std::string& name, const Value& new_value);
+  const Value& GetVariableValue(const std::string& name);
+private:
+  class Context {
+  public:
+    Context(bool hide_previous = false) : hide_previous_(hide_previous) {}
+
+    void DefineVariable(const VariableInfo& variable);
+    void ChangeVaraibleValue(const std::string& name, const Value& neew_value);
+    const Value& GetVariableValue(const std::string& name);
+
+    bool IsFirst() { return hide_previous_; }
+  private:
+    bool hide_previous_;
+    std::unordered_map<std::string, VariableInfo> variables_;
+  };
+
+  // TODO handle current namespace (for class names, function names, etc.)
+  // TODO ?? are global variables forbidden ??
+
+  Context global_context_;
+  std::vector<Context> contexts_;
+};
+
+} // namespace info

include/global_info.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <string>
+#include <unordered_map>
+
+// for clangd
+#include "symbols_info.hpp"
+
+namespace info {
+
+class GlobalInfo {
+public:
+  GlobalInfo();
+
+  // ?? EnterNamespace / ExitNamespace ??
+  // concurrent work ??
+  // AddType, AddFunction
+  // TODO
+private:
+  std::unordered_map<std::string, NamespaceInfo> namespaces_;
+  NamespaceInfo global_namespace_;
+  // lock for concurrency ??
+};
+
+} // namespace info

include/interpreter_tree.hpp

@@ -0,0 +1,549 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <variant>
+#include <memory>
+
+// for clangd
+#include "node.hpp"
+
+
+namespace interpreter {
+
+namespace  tokens {
+
+// ----------------- Declarations -----------------
+
+using AnyIdentifier = std::string;
+using NameOrOperatorIdentifier = std::string;
+using NameIdentifier = std::string;
+using AnyTypeIdentifier = std::string;
+using TypeIdentifier = std::string;
+using AbstractTypeIdentifier = std::string;
+using OperatorIdentifier = std::string;
+using TypeclassIdentifier = std::string;
+
+// Sources -----------------
+
+struct SourceFile; // TODO partitions
+struct Sources;
+
+// Namespaces, partittions -----------------
+
+struct Partition;
+struct Namespace;
+
+// Definitions -----------------
+
+struct ImportStatement;
+struct UsageDefinition;
+struct AliasDefinition;
+struct VariableDefinition;
+struct FunctionDeclaration;
+struct FunctionDefinition;
+struct AliasTypeDefinition; // | Parts of type definition
+struct TypeDefinition;      // |
+struct TypeclassDefinition;
+
+using SourceStatement = std::variant<
+  ImportStatement,
+  UsageDefinition,
+  AliasDefinition,
+  VariableDefinition, // ??
+  FunctionDeclaration,
+  FunctionDefinition,
+  AliasTypeDefinition,
+  TypeDefinition,
+  TypeclassDefinition,
+  Namespace>;
+
+// Definition parts
+
+struct ParametrizedType;
+struct TupleType;
+struct VariantType;
+struct ParametrizedTypeclass;
+using FunctionDeclarationType = std::variant<
+  ParametrizedType,
+  TupleType,
+  VariantType,
+  ParametrizedTypeclass>;
+
+struct DefinedName;
+struct DefinedAnnotatedName;
+struct DefinedType;
+struct DefinedTypeclass;
+struct DefinitionParameter;
+struct DefinitionArgument;
+
+// Flow control -----------------
+
+struct Match;
+struct Condition;
+struct WhileLoop; // WhileLoop <-> DoWhileLoop
+struct ForLoop;
+struct LoopLoop;
+
+using FlowControl = std::variant<
+  Match,
+  Condition,
+  WhileLoop,
+  ForLoop,
+  LoopLoop>;
+
+// Statements, expressions, blocks, etc. -----------------
+
+struct Block;
+
+//
+
+struct NameExpression;
+struct ScopedStatement;
+
+using SubExpressionToken = std::variant<
+  NameExpression,
+  ScopedStatement>;
+
+//
+
+struct FunctionCallExpression;
+struct BinaryOperatorExpression;
+
+using SubExpression = std::variant<
+  FunctionCallExpression,
+  BinaryOperatorExpression,
+  SubExpressionToken>;
+
+//
+
+struct ReturnExpression;
+
+enum class LoopControlExpression {
+    Break,
+    Continue,
+};
+
+using PrefixedExpression = std::variant<
+  ReturnExpression,
+  LoopControlExpression,
+  Block>;
+
+//
+
+struct LambdaFunction;
+struct TypeConstructor;
+struct UnaryOperatorExpression;
+
+using Expression = std::variant<
+  LambdaFunction,
+  TypeConstructor,
+  PrefixedExpression,
+  UnaryOperatorExpression,
+  SubExpression>;
+
+//
+
+struct TupleExpression;
+struct VariantExpression;
+
+using SuperExpression = std::variant<
+  FlowControl,
+  TupleExpression,
+  VariantExpression,
+  Expression>;
+
+//
+
+struct ScopedStatement; // ?? scoped statement is _superexpression ??
+
+// Operators
+
+struct BinaryOperatorExpression;
+struct UnaryOperatorExpression;
+
+// Simple Expressions
+
+struct FunctionCallExpression;
+struct TupleExpression;
+struct VariantExpression;
+struct ReturnExpression;
+
+// Lambda
+
+struct LambdaFunction;
+
+// Name
+
+struct NameSuperExpression;
+struct NameExpression;
+struct TupleName;
+struct VariantName;
+struct AnnotatedName;
+
+using AnyName = std::variant<
+  AnnotatedName,
+  TupleName,
+  VariantName>;
+
+// Type
+
+struct TypeConstructor;
+
+// // TypeOrAnyType <-> AnyType
+
+struct TupleType;
+struct VariantType;
+struct VariantType;
+
+using AnyType = std::variant<
+  ParametrizedType,
+  TupleType,
+  VariantType>;
+
+// // TypeIdentifierDefinition <-> some '.' + TypeIdentifier
+using TypeIdentifierDefinition = std::string;
+
+struct AnnotatedType;
+// // TypeAnnotations - inplace ??
+struct ParametrizedType;
+struct TypeExpression;
+
+using TypeSubExpression = std::variant<
+  AnyTypeIdentifier,
+  ParametrizedType>;
+
+// Typeclass
+
+struct AnnotatedTypeclass;
+struct ParametrizedTypeclass;
+struct TypeclassExpression;
+
+// Comments [IGNORE] -----------------
+// Identifiers, constants, etc. -----------------
+
+struct FloatNumberLiteral;
+struct NumberLiteral;
+struct StringLiteral;
+struct CharLiteral;
+
+using Literal = std::variant<
+  FloatNumberLiteral,
+  NumberLiteral,
+  StringLiteral,
+  CharLiteral>;
+
+//
+
+using NameSubSuperExpression = std::variant<
+  NameIdentifier,
+  Literal,
+  SuperExpression>;
+
+// ----------------- Sources -----------------
+
+struct SourceFile : public Node {
+  std::vector<std::variant<SourceStatement, Partition>> statements;
+};
+
+struct Sources : public Node {
+  std::vector<SourceStatement> statemets;
+};
+
+// ----------------- Namespaces, partittions -----------------
+
+struct Partition : public Node {
+  enum class PartitionType {
+    Test,
+    Interface,
+    Core,
+    Lib,
+    Module, // rename ??
+    Exe,
+  };
+
+  PartitionType type;
+  std::unique_ptr<Sources> scope;
+};
+
+struct Namespace : public Node {
+  std::unique_ptr<std::variant<DefinedAnnotatedName, DefinedType>> name;
+  // TODO add const / var specification
+  std::unique_ptr<Sources> scope;
+};
+
+// ----------------- Definitions -----------------
+
+struct ImportStatement : public Node {
+  std::string module_name;
+  std::vector<AnyIdentifier> symbols; // TODO parametric import support
+};
+
+struct UsageDefinition : public Node {
+  TypeIdentifier module_identifier;
+  std::unique_ptr<ImportStatement> import_statement;
+};
+
+struct AliasDefinition : public Node {
+  std::unique_ptr<DefinedType> name;
+  std::unique_ptr<ParametrizedType> value;
+};
+
+struct VariableDefinition : public Node {
+  NameIdentifier name;
+  std::unique_ptr<SuperExpression> value;
+};
+
+struct FunctionDeclaration : public Node {
+  NameIdentifier name;
+  std::vector<std::unique_ptr<FunctionDeclarationType>> argument_types;
+};
+
+struct FunctionDefintion : public Node {
+  std::unique_ptr<DefinedName> name;
+  std::unique_ptr<SuperExpression> value;
+};
+
+struct AliasTypeDefinition : public Node {
+  std::unique_ptr<DefinedType> name;
+  std::unique_ptr<ParametrizedType> value;
+};
+
+struct TypeDefinition : public Node {
+  std::unique_ptr<DefinedType> name;
+  std::unique_ptr<AnyType> value;
+};
+
+struct TypeclassDefinition : public Node {
+  std::unique_ptr<DefinedTypeclass> name;
+  std::vector<std::unique_ptr<FunctionDeclaration>> requirements;
+};
+
+// Definition parts -----------------
+
+struct DefinedName : public Node {
+  bool is_operator = false; // other format ??
+  NameOrOperatorIdentifier name; // function name or operator
+  std::vector<std::unique_ptr<DefinitionParameter>> parameters;
+  std::vector<std::unique_ptr<DefinitionArgument>> arguments;
+};
+
+struct DefinedAnnotatedName : public Node {
+  NameIdentifier name;
+  std::unique_ptr<std::variant<DefinedType, DefinedTypeclass>> type;
+};
+
+struct DefinedType : public Node {
+  std::unique_ptr<AnnotatedType> type;
+  std::vector<std::unique_ptr<DefinitionParameter>> parameters;
+  std::vector<std::unique_ptr<DefinitionArgument>> arguments;
+};
+
+struct DefinedTypeclass : public Node {
+  std::unique_ptr<AnnotatedTypeclass> typeclass;
+  std::vector<std::unique_ptr<DefinitionParameter>> parameters;
+  std::vector<std::unique_ptr<DefinitionArgument>> arguments;
+};
+
+struct DefinitionParameter : public Node {
+  AbstractTypeIdentifier abstract_type;
+  std::vector<std::unique_ptr<ParametrizedTypeclass>> typeclasses;
+};
+
+struct DefinitionArgument : public Node {
+  NameIdentifier name;
+  std::vector<std::unique_ptr<ParametrizedType>> types;
+};
+
+// ----------------- Flow control -----------------
+
+struct MatchCase {
+  std::unique_ptr<Expression> value;
+  std::unique_ptr<Expression> condition;
+  std::unique_ptr<Expression> statement;
+};
+
+struct Match : public Node {
+  std::unique_ptr<Expression> value;
+  std::vector<MatchCase> matches;
+};
+
+struct Condition : public Node {
+  std::vector<std::unique_ptr<Expression>> conditions; // if, elif
+  std::vector<std::unique_ptr<Expression>> stetemets; // if, elif, else
+};
+
+struct WhileLoop : public Node { // WhileLoop <-> DoWhileLoop
+  std::unique_ptr<Expression> condition;
+  std::unique_ptr<Expression> statement;
+};
+
+struct ForLoop : public Node {
+  std::unique_ptr<AnyName> variable;
+  std::unique_ptr<Expression> interval;
+  std::unique_ptr<Expression> statement;
+};
+
+struct LoopLoop : public Node {
+  std::unique_ptr<Expression> statement;
+};
+
+// ----------------- Statements, expressions, blocks, etc. -----------------
+
+using BlockStatement = std::variant<
+  Expression,
+  AliasDefinition,
+  VariableDefinition,
+  FlowControl,
+  PrefixedExpression>;
+
+struct Block : public Node {
+  std::vector<std::unique_ptr<BlockStatement>> statements;
+};
+
+struct ScopedStatement : public Node {
+  std::unique_ptr<SuperExpression> statement;
+};
+
+// Operators -----------------
+
+struct BinaryOperatorExpression : public Node {
+  OperatorIdentifier operator_name;
+  std::unique_ptr<SubExpression> left_expression;
+  std::unique_ptr<SubExpression> right_expression;
+};
+
+struct UnaryOperatorExpression : public Node { // TODO fix prescendence
+  OperatorIdentifier operator_name;
+  std::unique_ptr<Expression> expression;
+};
+
+// Simple Expressions -----------------
+
+using FunctionArgument = std::variant<SubExpressionToken, TypeSubExpression>;
+
+struct FunctionCallExpression : public Node {
+  std::unique_ptr<NameSuperExpression> name;
+  std::vector<std::unique_ptr<FunctionArgument>> arguments;
+};
+
+struct TupleExpression : public Node {
+  std::vector<std::unique_ptr<SubExpression>> expressions;
+};
+
+struct VariantExpression : public Node {
+  std::vector<std::unique_ptr<SubExpression>> expressions;
+};
+
+struct ReturnExpression : public Node {
+  std::unique_ptr<Expression> expression;
+};
+
+// Lambda -----------------
+
+struct LambdaFunction : public Node {
+  std::vector<std::unique_ptr<DefinitionParameter>> parameters;
+  std::vector<std::unique_ptr<DefinitionArgument>> arguments;
+  std::unique_ptr<Expression> expression;
+};
+
+// Name -----------------
+
+struct NameSuperExpression : public Node {
+  std::vector<std::unique_ptr<TypeSubExpression>> namespaces;
+  std::vector<std::unique_ptr<NameSubSuperExpression>> expressions; // last is not SuperExpression
+};
+
+struct NameExpression : public Node {
+  std::vector<TypeSubExpression> namespaces;
+  std::vector<NameIdentifier> names;
+};
+
+struct TupleName : public Node {
+  std::vector<std::unique_ptr<AnnotatedName>> names;
+};
+
+struct VariantName : public Node {
+  std::vector<std::unique_ptr<AnnotatedName>> names;
+};
+
+struct AnnotatedName : public Node {
+  NameIdentifier name;
+  std::unique_ptr<ParametrizedType> type; // optional
+};
+
+// TODO ?? mark all optional fields ??
+
+// Type -----------------
+
+struct TypeConstructor : public Node {
+  std::unique_ptr<ParametrizedType> type;
+  std::vector<std::pair<NameIdentifier, std::unique_ptr<SubExpression>>> parameters;
+};
+
+struct TupleType : public Node {
+  TypeIdentifierDefinition type; // optional
+  std::vector<std::pair<NameIdentifier, std::unique_ptr<AnyType>>> entities; // NameIdentifier is optional
+};
+
+struct VariantType : public Node {
+  TypeIdentifierDefinition type; // optional
+  std::vector<std::pair<TypeIdentifierDefinition, std::unique_ptr<TupleType>>> constructors;
+};
+
+struct AnnotatedType : public Node {
+  std::unique_ptr<TypeExpression> type_expression;
+  std::vector<std::unique_ptr<ParametrizedTypeclass>> annotations;
+};
+
+using TypeParameter = std::variant<ParametrizedType, Expression>;
+
+struct ParametrizedType : public Node {
+  std::unique_ptr<TypeExpression> type_expression;
+  std::vector<std::unique_ptr<TypeParameter>> parameters;
+};
+
+struct TypeExpression : public Node {
+  std::vector<std::unique_ptr<TypeSubExpression>> namespaces;
+  AnyTypeIdentifier type;
+};
+
+// Typeclass -----------------
+
+struct AnnotatedTypeclass : public Node {
+    std::unique_ptr<TypeclassExpression> typeclass_expression;
+    std::vector<std::unique_ptr<ParametrizedTypeclass>> annotations;
+};
+
+struct ParametrizedTypeclass : public Node {
+    std::unique_ptr<TypeclassExpression> typeclass_expression;
+    std::vector<std::unique_ptr<TypeParameter>> parameters;
+};
+
+struct TypeclassExpression : public Node {
+    std::vector<std::unique_ptr<TypeSubExpression>> namespaces;
+    TypeclassIdentifier typeclass;
+};
+
+// ----------------- Comments [IGNORE] -----------------
+// ----------------- Identifiers, constants, etc. -----------------
+
+struct FloatNumberLiteral : public Node {
+  double value;
+};
+
+struct NumberLiteral : public Node {
+  int64_t value;
+};
+
+struct StringLiteral : public Node {
+  std::string value;
+};
+
+struct CharLiteral : public Node {
+  char value;
+};
+
+} // namespace tokens
+
+} // namespace interpereter

include/node.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <cstddef>
+
+// for clangd
+#include "parse_tree.hpp"
+
+namespace info {
+  class GlobalInfo;
+  class Context;
+} // namespace info
+
+namespace interpreter {
+class Visitor;
+
+struct Node {
+//public:
+  Node(info::GlobalInfo& global_info) : global_info_(global_info) {}
+
+  virtual void Accept(Visitor* visitor);
+
+  /* ------------ use visitor instead ------------
+  virtual void build(parser::ParseTree::Cursor& cursor) = 0; // build tree from parse tree
+
+  virtual void find_symbols() = 0; // find types, typeclasses, namespaces, ..
+  virtual void assign_types() = 0; // typecheck
+  virtual void execute(info::Context& context) = 0; // execute part of tree
+  */
+/*private:
+  size_t start_position_; // ??
+  size_t end_position_; // ??
+  Node* parent_; // ??
+  info::GlobalInfo& global_info_;*/
+};
+
+} // namespace interpreter

include/parse_tree.hpp

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <string>
+
+// for clangd
+#include "tree_sitter/api.h"
+
+
+namespace parser {
+
+class ParseTree {
+public:
+  class Node {
+  public:
+    Node() = delete;
+
+    std::string GetType();
+    std::pair<size_t, size_t> GetStartPoint();
+    std::pair<size_t, size_t> GetEndPoint();
+    std::string GetAsSExpression();
+
+    bool IsNull();
+    bool IsNamed();
+    bool IsMissing();
+    bool IsExtra(); // comments, etc.
+    bool HasError();
+
+    Node NthChild(size_t n);
+    size_t ChildCount();
+
+    Node NthNamedChild(size_t n);
+    size_t NamedChildCount();
+
+    Node ChildByName(const std::string& name);
+
+    // ?? use field id instaed of name ??
+    // ?? node equality check needed ??
+  private:
+    TSNode node_;
+  };
+  class Cursor {
+  public:
+    Cursor(const Node& node);
+
+    void ResetTo(const Node& node);
+
+    Node GetCurrentNode();
+    std::string GetCurrentNodeName();
+
+    bool GoToParent();
+    bool GoToNextSibling();
+    bool GoToFirstChild();
+  private:
+    TSTreeCursor cursor_;
+  };
+
+  ParseTree(const std::string& input);
+
+  Node GetRoot();
+private:
+  TSTree* tree_;
+};
+
+} // namespace parser

include/symbols_info.hpp

@@ -0,0 +1,96 @@
+#pragma once
+
+#include <string>
+#include <variant>
+#include <optional>
+#include <vector>
+#include <unordered_map>
+
+// for clangd
+
+namespace interpreter {
+  class Node;
+} // namespace interpreter
+
+namespace info {
+
+using NumberValue = long long;
+using FloatNumberValue = float;
+using StringValue = std::string;
+
+struct SimpleValue {
+  std::variant<NumberValue, FloatNumberValue, StringValue> value;
+};
+
+struct Value {
+  enum class ValueStructure {
+    Simple, // one value
+    Variant, // one value from list, can have arguments
+    // MultiVariant, // constructed variant // ??
+    Tuple, // tuple of values
+  };
+  ValueStructure structure;
+  std::vector<std::variant<SimpleValue, Value>> values;
+};
+// better variant value storage (then string) ??
+
+struct Info {
+  std::string name;
+};
+
+struct VariantTypeInfo;
+struct TupleTypeInfo;
+struct AliasTypeInfo;
+
+enum class BuiltInTypeInfo {
+  StringT,
+  IntT,
+  FloatT,
+};
+
+using TypeInfo = std::variant<VariantTypeInfo, TupleTypeInfo, AliasTypeInfo, BuiltInTypeInfo>;
+
+struct VariableInfo : public Info {
+  Value value;
+  TypeInfo* type = nullptr;
+};
+// TODO lambda functions as values
+
+// TODO aliases ??
+
+struct TupleTypeInfo : public Info {
+  std::vector<std::pair<std::optional<std::string>, TypeInfo>> fields;
+};
+
+struct VariantTypeInfo : public Info {
+  std::vector<std::variant<std::string, TupleTypeInfo>> constructors;
+  // ?? any type instead of tuple type ??
+};
+
+struct AliasTypeInfo : public Info {
+  bool isAnotherType; // = true by default ??
+  TypeInfo* type = nullptr;
+};
+
+struct TypeclassInfo : public Info {
+    // TODO
+};
+
+struct PointerInfo {
+  VariableInfo* variable;
+};
+
+struct FunctionInfo : public Info {
+  interpreter::Node* definition;
+  std::vector<VariableInfo> args;
+  // add requirements ??
+};
+
+struct NamespaceInfo : public Info {
+  std::unordered_map<std::string, TypeInfo> types;
+  std::unordered_map<std::string, VariableInfo> variables;
+  std::unordered_map<std::string, FunctionInfo> functions;
+  std::unordered_map<std::string, NamespaceInfo> namespaces;
+};
+
+} // namespace info

include/visitor.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+// for clangd
+#include "interpreter_tree.hpp"
+
+namespace interpreter {
+
+class Visitor {
+public:
+  virtual void Visit(Node* node) = 0; // ??
+  //  visit(SomethingNode node)
+  // ...
+private:
+};
+
+} // namespace interpreter

src/node.cpp

@@ -0,0 +1,12 @@
+// for clangd
+#include "../include/node.hpp"
+#include "../include/visitor.hpp"
+
+
+namespace interpreter {
+
+void Node::Accept(Visitor* visitor) {
+  visitor->Visit(this);
+}
+
+} // namespace interpreter

tree_sitter/api.h

@@ -0,0 +1,983 @@
+#ifndef TREE_SITTER_API_H_
+#define TREE_SITTER_API_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+/****************************/
+/* Section - ABI Versioning */
+/****************************/
+
+/**
+ * The latest ABI version that is supported by the current version of the
+ * library. When Languages are generated by the Tree-sitter CLI, they are
+ * assigned an ABI version number that corresponds to the current CLI version.
+ * The Tree-sitter library is generally backwards-compatible with languages
+ * generated using older CLI versions, but is not forwards-compatible.
+ */
+#define TREE_SITTER_LANGUAGE_VERSION 14
+
+/**
+ * The earliest ABI version that is supported by the current version of the
+ * library.
+ */
+#define TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION 13
+
+/*******************/
+/* Section - Types */
+/*******************/
+
+typedef uint16_t TSSymbol;
+typedef uint16_t TSFieldId;
+typedef struct TSLanguage TSLanguage;
+typedef struct TSParser TSParser;
+typedef struct TSTree TSTree;
+typedef struct TSQuery TSQuery;
+typedef struct TSQueryCursor TSQueryCursor;
+
+typedef enum {
+  TSInputEncodingUTF8,
+  TSInputEncodingUTF16,
+} TSInputEncoding;
+
+typedef enum {
+  TSSymbolTypeRegular,
+  TSSymbolTypeAnonymous,
+  TSSymbolTypeAuxiliary,
+} TSSymbolType;
+
+typedef struct {
+  uint32_t row;
+  uint32_t column;
+} TSPoint;
+
+typedef struct {
+  TSPoint start_point;
+  TSPoint end_point;
+  uint32_t start_byte;
+  uint32_t end_byte;
+} TSRange;
+
+typedef struct {
+  void *payload;
+  const char *(*read)(void *payload, uint32_t byte_index, TSPoint position, uint32_t *bytes_read);
+  TSInputEncoding encoding;
+} TSInput;
+
+typedef enum {
+  TSLogTypeParse,
+  TSLogTypeLex,
+} TSLogType;
+
+typedef struct {
+  void *payload;
+  void (*log)(void *payload, TSLogType, const char *);
+} TSLogger;
+
+typedef struct {
+  uint32_t start_byte;
+  uint32_t old_end_byte;
+  uint32_t new_end_byte;
+  TSPoint start_point;
+  TSPoint old_end_point;
+  TSPoint new_end_point;
+} TSInputEdit;
+
+typedef struct {
+  uint32_t context[4];
+  const void *id;
+  const TSTree *tree;
+} TSNode;
+
+typedef struct {
+  const void *tree;
+  const void *id;
+  uint32_t context[2];
+} TSTreeCursor;
+
+typedef struct {
+  TSNode node;
+  uint32_t index;
+} TSQueryCapture;
+
+typedef enum {
+  TSQuantifierZero = 0, // must match the array initialization value
+  TSQuantifierZeroOrOne,
+  TSQuantifierZeroOrMore,
+  TSQuantifierOne,
+  TSQuantifierOneOrMore,
+} TSQuantifier;
+
+typedef struct {
+  uint32_t id;
+  uint16_t pattern_index;
+  uint16_t capture_count;
+  const TSQueryCapture *captures;
+} TSQueryMatch;
+
+typedef enum {
+  TSQueryPredicateStepTypeDone,
+  TSQueryPredicateStepTypeCapture,
+  TSQueryPredicateStepTypeString,
+} TSQueryPredicateStepType;
+
+typedef struct {
+  TSQueryPredicateStepType type;
+  uint32_t value_id;
+} TSQueryPredicateStep;
+
+typedef enum {
+  TSQueryErrorNone = 0,
+  TSQueryErrorSyntax,
+  TSQueryErrorNodeType,
+  TSQueryErrorField,
+  TSQueryErrorCapture,
+  TSQueryErrorStructure,
+  TSQueryErrorLanguage,
+} TSQueryError;
+
+/********************/
+/* Section - Parser */
+/********************/
+
+/**
+ * Create a new parser.
+ */
+TSParser *ts_parser_new(void);
+
+/**
+ * Delete the parser, freeing all of the memory that it used.
+ */
+void ts_parser_delete(TSParser *parser);
+
+/**
+ * Set the language that the parser should use for parsing.
+ *
+ * Returns a boolean indicating whether or not the language was successfully
+ * assigned. True means assignment succeeded. False means there was a version
+ * mismatch: the language was generated with an incompatible version of the
+ * Tree-sitter CLI. Check the language's version using `ts_language_version`
+ * and compare it to this library's `TREE_SITTER_LANGUAGE_VERSION` and
+ * `TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION` constants.
+ */
+bool ts_parser_set_language(TSParser *self, const TSLanguage *language);
+
+/**
+ * Get the parser's current language.
+ */
+const TSLanguage *ts_parser_language(const TSParser *self);
+
+/**
+ * Set the ranges of text that the parser should include when parsing.
+ *
+ * By default, the parser will always include entire documents. This function
+ * allows you to parse only a *portion* of a document but still return a syntax
+ * tree whose ranges match up with the document as a whole. You can also pass
+ * multiple disjoint ranges.
+ *
+ * The second and third parameters specify the location and length of an array
+ * of ranges. The parser does *not* take ownership of these ranges; it copies
+ * the data, so it doesn't matter how these ranges are allocated.
+ *
+ * If `length` is zero, then the entire document will be parsed. Otherwise,
+ * the given ranges must be ordered from earliest to latest in the document,
+ * and they must not overlap. That is, the following must hold for all
+ * `i` < `length - 1`: ranges[i].end_byte <= ranges[i + 1].start_byte
+ *
+ * If this requirement is not satisfied, the operation will fail, the ranges
+ * will not be assigned, and this function will return `false`. On success,
+ * this function returns `true`
+ */
+bool ts_parser_set_included_ranges(
+  TSParser *self,
+  const TSRange *ranges,
+  uint32_t length
+);
+
+/**
+ * Get the ranges of text that the parser will include when parsing.
+ *
+ * The returned pointer is owned by the parser. The caller should not free it
+ * or write to it. The length of the array will be written to the given
+ * `length` pointer.
+ */
+const TSRange *ts_parser_included_ranges(
+  const TSParser *self,
+  uint32_t *length
+);
+
+/**
+ * Use the parser to parse some source code and create a syntax tree.
+ *
+ * If you are parsing this document for the first time, pass `NULL` for the
+ * `old_tree` parameter. Otherwise, if you have already parsed an earlier
+ * version of this document and the document has since been edited, pass the
+ * previous syntax tree so that the unchanged parts of it can be reused.
+ * This will save time and memory. For this to work correctly, you must have
+ * already edited the old syntax tree using the `ts_tree_edit` function in a
+ * way that exactly matches the source code changes.
+ *
+ * The `TSInput` parameter lets you specify how to read the text. It has the
+ * following three fields:
+ * 1. `read`: A function to retrieve a chunk of text at a given byte offset
+ *    and (row, column) position. The function should return a pointer to the
+ *    text and write its length to the `bytes_read` pointer. The parser does
+ *    not take ownership of this buffer; it just borrows it until it has
+ *    finished reading it. The function should write a zero value to the
+ *    `bytes_read` pointer to indicate the end of the document.
+ * 2. `payload`: An arbitrary pointer that will be passed to each invocation
+ *    of the `read` function.
+ * 3. `encoding`: An indication of how the text is encoded. Either
+ *    `TSInputEncodingUTF8` or `TSInputEncodingUTF16`.
+ *
+ * This function returns a syntax tree on success, and `NULL` on failure. There
+ * are three possible reasons for failure:
+ * 1. The parser does not have a language assigned. Check for this using the
+      `ts_parser_language` function.
+ * 2. Parsing was cancelled due to a timeout that was set by an earlier call to
+ *    the `ts_parser_set_timeout_micros` function. You can resume parsing from
+ *    where the parser left out by calling `ts_parser_parse` again with the
+ *    same arguments. Or you can start parsing from scratch by first calling
+ *    `ts_parser_reset`.
+ * 3. Parsing was cancelled using a cancellation flag that was set by an
+ *    earlier call to `ts_parser_set_cancellation_flag`. You can resume parsing
+ *    from where the parser left out by calling `ts_parser_parse` again with
+ *    the same arguments.
+ */
+TSTree *ts_parser_parse(
+  TSParser *self,
+  const TSTree *old_tree,
+  TSInput input
+);
+
+/**
+ * Use the parser to parse some source code stored in one contiguous buffer.
+ * The first two parameters are the same as in the `ts_parser_parse` function
+ * above. The second two parameters indicate the location of the buffer and its
+ * length in bytes.
+ */
+TSTree *ts_parser_parse_string(
+  TSParser *self,
+  const TSTree *old_tree,
+  const char *string,
+  uint32_t length
+);
+
+/**
+ * Use the parser to parse some source code stored in one contiguous buffer with
+ * a given encoding. The first four parameters work the same as in the
+ * `ts_parser_parse_string` method above. The final parameter indicates whether
+ * the text is encoded as UTF8 or UTF16.
+ */
+TSTree *ts_parser_parse_string_encoding(
+  TSParser *self,
+  const TSTree *old_tree,
+  const char *string,
+  uint32_t length,
+  TSInputEncoding encoding
+);
+
+/**
+ * Instruct the parser to start the next parse from the beginning.
+ *
+ * If the parser previously failed because of a timeout or a cancellation, then
+ * by default, it will resume where it left off on the next call to
+ * `ts_parser_parse` or other parsing functions. If you don't want to resume,
+ * and instead intend to use this parser to parse some other document, you must
+ * call `ts_parser_reset` first.
+ */
+void ts_parser_reset(TSParser *self);
+
+/**
+ * Set the maximum duration in microseconds that parsing should be allowed to
+ * take before halting.
+ *
+ * If parsing takes longer than this, it will halt early, returning NULL.
+ * See `ts_parser_parse` for more information.
+ */
+void ts_parser_set_timeout_micros(TSParser *self, uint64_t timeout);
+
+/**
+ * Get the duration in microseconds that parsing is allowed to take.
+ */
+uint64_t ts_parser_timeout_micros(const TSParser *self);
+
+/**
+ * Set the parser's current cancellation flag pointer.
+ *
+ * If a non-null pointer is assigned, then the parser will periodically read
+ * from this pointer during parsing. If it reads a non-zero value, it will
+ * halt early, returning NULL. See `ts_parser_parse` for more information.
+ */
+void ts_parser_set_cancellation_flag(TSParser *self, const size_t *flag);
+
+/**
+ * Get the parser's current cancellation flag pointer.
+ */
+const size_t *ts_parser_cancellation_flag(const TSParser *self);
+
+/**
+ * Set the logger that a parser should use during parsing.
+ *
+ * The parser does not take ownership over the logger payload. If a logger was
+ * previously assigned, the caller is responsible for releasing any memory
+ * owned by the previous logger.
+ */
+void ts_parser_set_logger(TSParser *self, TSLogger logger);
+
+/**
+ * Get the parser's current logger.
+ */
+TSLogger ts_parser_logger(const TSParser *self);
+
+/**
+ * Set the file descriptor to which the parser should write debugging graphs
+ * during parsing. The graphs are formatted in the DOT language. You may want
+ * to pipe these graphs directly to a `dot(1)` process in order to generate
+ * SVG output. You can turn off this logging by passing a negative number.
+ */
+void ts_parser_print_dot_graphs(TSParser *self, int file);
+
+/******************/
+/* Section - Tree */
+/******************/
+
+/**
+ * Create a shallow copy of the syntax tree. This is very fast.
+ *
+ * You need to copy a syntax tree in order to use it on more than one thread at
+ * a time, as syntax trees are not thread safe.
+ */
+TSTree *ts_tree_copy(const TSTree *self);
+
+/**
+ * Delete the syntax tree, freeing all of the memory that it used.
+ */
+void ts_tree_delete(TSTree *self);
+
+/**
+ * Get the root node of the syntax tree.
+ */
+TSNode ts_tree_root_node(const TSTree *self);
+
+/**
+ * Get the root node of the syntax tree, but with its position
+ * shifted forward by the given offset.
+ */
+TSNode ts_tree_root_node_with_offset(
+  const TSTree *self,
+  uint32_t offset_bytes,
+  TSPoint offset_point
+);
+
+/**
+ * Get the language that was used to parse the syntax tree.
+ */
+const TSLanguage *ts_tree_language(const TSTree *);
+
+/**
+ * Get the array of included ranges that was used to parse the syntax tree.
+ *
+ * The returned pointer must be freed by the caller.
+ */
+TSRange *ts_tree_included_ranges(const TSTree *, uint32_t *length);
+
+/**
+ * Edit the syntax tree to keep it in sync with source code that has been
+ * edited.
+ *
+ * You must describe the edit both in terms of byte offsets and in terms of
+ * (row, column) coordinates.
+ */
+void ts_tree_edit(TSTree *self, const TSInputEdit *edit);
+
+/**
+ * Compare an old edited syntax tree to a new syntax tree representing the same
+ * document, returning an array of ranges whose syntactic structure has changed.
+ *
+ * For this to work correctly, the old syntax tree must have been edited such
+ * that its ranges match up to the new tree. Generally, you'll want to call
+ * this function right after calling one of the `ts_parser_parse` functions.
+ * You need to pass the old tree that was passed to parse, as well as the new
+ * tree that was returned from that function.
+ *
+ * The returned array is allocated using `malloc` and the caller is responsible
+ * for freeing it using `free`. The length of the array will be written to the
+ * given `length` pointer.
+ */
+TSRange *ts_tree_get_changed_ranges(
+  const TSTree *old_tree,
+  const TSTree *new_tree,
+  uint32_t *length
+);
+
+/**
+ * Write a DOT graph describing the syntax tree to the given file.
+ */
+void ts_tree_print_dot_graph(const TSTree *, int file_descriptor);
+
+/******************/
+/* Section - Node */
+/******************/
+
+/**
+ * Get the node's type as a null-terminated string.
+ */
+const char *ts_node_type(TSNode);
+
+/**
+ * Get the node's type as a numerical id.
+ */
+TSSymbol ts_node_symbol(TSNode);
+
+/**
+ * Get the node's start byte.
+ */
+uint32_t ts_node_start_byte(TSNode);
+
+/**
+ * Get the node's start position in terms of rows and columns.
+ */
+TSPoint ts_node_start_point(TSNode);
+
+/**
+ * Get the node's end byte.
+ */
+uint32_t ts_node_end_byte(TSNode);
+
+/**
+ * Get the node's end position in terms of rows and columns.
+ */
+TSPoint ts_node_end_point(TSNode);
+
+/**
+ * Get an S-expression representing the node as a string.
+ *
+ * This string is allocated with `malloc` and the caller is responsible for
+ * freeing it using `free`.
+ */
+char *ts_node_string(TSNode);
+
+/**
+ * Check if the node is null. Functions like `ts_node_child` and
+ * `ts_node_next_sibling` will return a null node to indicate that no such node
+ * was found.
+ */
+bool ts_node_is_null(TSNode);
+
+/**
+ * Check if the node is *named*. Named nodes correspond to named rules in the
+ * grammar, whereas *anonymous* nodes correspond to string literals in the
+ * grammar.
+ */
+bool ts_node_is_named(TSNode);
+
+/**
+ * Check if the node is *missing*. Missing nodes are inserted by the parser in
+ * order to recover from certain kinds of syntax errors.
+ */
+bool ts_node_is_missing(TSNode);
+
+/**
+ * Check if the node is *extra*. Extra nodes represent things like comments,
+ * which are not required the grammar, but can appear anywhere.
+ */
+bool ts_node_is_extra(TSNode);
+
+/**
+ * Check if a syntax node has been edited.
+ */
+bool ts_node_has_changes(TSNode);
+
+/**
+ * Check if the node is a syntax error or contains any syntax errors.
+ */
+bool ts_node_has_error(TSNode);
+
+/**
+ * Get the node's immediate parent.
+ */
+TSNode ts_node_parent(TSNode);
+
+/**
+ * Get the node's child at the given index, where zero represents the first
+ * child.
+ */
+TSNode ts_node_child(TSNode, uint32_t);
+
+/**
+ * Get the field name for node's child at the given index, where zero represents
+ * the first child. Returns NULL, if no field is found.
+ */
+const char *ts_node_field_name_for_child(TSNode, uint32_t);
+
+/**
+ * Get the node's number of children.
+ */
+uint32_t ts_node_child_count(TSNode);
+
+/**
+ * Get the node's *named* child at the given index.
+ *
+ * See also `ts_node_is_named`.
+ */
+TSNode ts_node_named_child(TSNode, uint32_t);
+
+/**
+ * Get the node's number of *named* children.
+ *
+ * See also `ts_node_is_named`.
+ */
+uint32_t ts_node_named_child_count(TSNode);
+
+/**
+ * Get the node's child with the given field name.
+ */
+TSNode ts_node_child_by_field_name(
+  TSNode self,
+  const char *field_name,
+  uint32_t field_name_length
+);
+
+/**
+ * Get the node's child with the given numerical field id.
+ *
+ * You can convert a field name to an id using the
+ * `ts_language_field_id_for_name` function.
+ */
+TSNode ts_node_child_by_field_id(TSNode, TSFieldId);
+
+/**
+ * Get the node's next / previous sibling.
+ */
+TSNode ts_node_next_sibling(TSNode);
+TSNode ts_node_prev_sibling(TSNode);
+
+/**
+ * Get the node's next / previous *named* sibling.
+ */
+TSNode ts_node_next_named_sibling(TSNode);
+TSNode ts_node_prev_named_sibling(TSNode);
+
+/**
+ * Get the node's first child that extends beyond the given byte offset.
+ */
+TSNode ts_node_first_child_for_byte(TSNode, uint32_t);
+
+/**
+ * Get the node's first named child that extends beyond the given byte offset.
+ */
+TSNode ts_node_first_named_child_for_byte(TSNode, uint32_t);
+
+/**
+ * Get the smallest node within this node that spans the given range of bytes
+ * or (row, column) positions.
+ */
+TSNode ts_node_descendant_for_byte_range(TSNode, uint32_t, uint32_t);
+TSNode ts_node_descendant_for_point_range(TSNode, TSPoint, TSPoint);
+
+/**
+ * Get the smallest named node within this node that spans the given range of
+ * bytes or (row, column) positions.
+ */
+TSNode ts_node_named_descendant_for_byte_range(TSNode, uint32_t, uint32_t);
+TSNode ts_node_named_descendant_for_point_range(TSNode, TSPoint, TSPoint);
+
+/**
+ * Edit the node to keep it in-sync with source code that has been edited.
+ *
+ * This function is only rarely needed. When you edit a syntax tree with the
+ * `ts_tree_edit` function, all of the nodes that you retrieve from the tree
+ * afterward will already reflect the edit. You only need to use `ts_node_edit`
+ * when you have a `TSNode` instance that you want to keep and continue to use
+ * after an edit.
+ */
+void ts_node_edit(TSNode *, const TSInputEdit *);
+
+/**
+ * Check if two nodes are identical.
+ */
+bool ts_node_eq(TSNode, TSNode);
+
+/************************/
+/* Section - TreeCursor */
+/************************/
+
+/**
+ * Create a new tree cursor starting from the given node.
+ *
+ * A tree cursor allows you to walk a syntax tree more efficiently than is
+ * possible using the `TSNode` functions. It is a mutable object that is always
+ * on a certain syntax node, and can be moved imperatively to different nodes.
+ */
+TSTreeCursor ts_tree_cursor_new(TSNode);
+
+/**
+ * Delete a tree cursor, freeing all of the memory that it used.
+ */
+void ts_tree_cursor_delete(TSTreeCursor *);
+
+/**
+ * Re-initialize a tree cursor to start at a different node.
+ */
+void ts_tree_cursor_reset(TSTreeCursor *, TSNode);
+
+/**
+ * Get the tree cursor's current node.
+ */
+TSNode ts_tree_cursor_current_node(const TSTreeCursor *);
+
+/**
+ * Get the field name of the tree cursor's current node.
+ *
+ * This returns `NULL` if the current node doesn't have a field.
+ * See also `ts_node_child_by_field_name`.
+ */
+const char *ts_tree_cursor_current_field_name(const TSTreeCursor *);
+
+/**
+ * Get the field id of the tree cursor's current node.
+ *
+ * This returns zero if the current node doesn't have a field.
+ * See also `ts_node_child_by_field_id`, `ts_language_field_id_for_name`.
+ */
+TSFieldId ts_tree_cursor_current_field_id(const TSTreeCursor *);
+
+/**
+ * Move the cursor to the parent of its current node.
+ *
+ * This returns `true` if the cursor successfully moved, and returns `false`
+ * if there was no parent node (the cursor was already on the root node).
+ */
+bool ts_tree_cursor_goto_parent(TSTreeCursor *);
+
+/**
+ * Move the cursor to the next sibling of its current node.
+ *
+ * This returns `true` if the cursor successfully moved, and returns `false`
+ * if there was no next sibling node.
+ */
+bool ts_tree_cursor_goto_next_sibling(TSTreeCursor *);
+
+/**
+ * Move the cursor to the first child of its current node.
+ *
+ * This returns `true` if the cursor successfully moved, and returns `false`
+ * if there were no children.
+ */
+bool ts_tree_cursor_goto_first_child(TSTreeCursor *);
+
+/**
+ * Move the cursor to the first child of its current node that extends beyond
+ * the given byte offset or point.
+ *
+ * This returns the index of the child node if one was found, and returns -1
+ * if no such child was found.
+ */
+int64_t ts_tree_cursor_goto_first_child_for_byte(TSTreeCursor *, uint32_t);
+int64_t ts_tree_cursor_goto_first_child_for_point(TSTreeCursor *, TSPoint);
+
+TSTreeCursor ts_tree_cursor_copy(const TSTreeCursor *);
+
+/*******************/
+/* Section - Query */
+/*******************/
+
+/**
+ * Create a new query from a string containing one or more S-expression
+ * patterns. The query is associated with a particular language, and can
+ * only be run on syntax nodes parsed with that language.
+ *
+ * If all of the given patterns are valid, this returns a `TSQuery`.
+ * If a pattern is invalid, this returns `NULL`, and provides two pieces
+ * of information about the problem:
+ * 1. The byte offset of the error is written to the `error_offset` parameter.
+ * 2. The type of error is written to the `error_type` parameter.
+ */
+TSQuery *ts_query_new(
+  const TSLanguage *language,
+  const char *source,
+  uint32_t source_len,
+  uint32_t *error_offset,
+  TSQueryError *error_type
+);
+
+/**
+ * Delete a query, freeing all of the memory that it used.
+ */
+void ts_query_delete(TSQuery *);
+
+/**
+ * Get the number of patterns, captures, or string literals in the query.
+ */
+uint32_t ts_query_pattern_count(const TSQuery *);
+uint32_t ts_query_capture_count(const TSQuery *);
+uint32_t ts_query_string_count(const TSQuery *);
+
+/**
+ * Get the byte offset where the given pattern starts in the query's source.
+ *
+ * This can be useful when combining queries by concatenating their source
+ * code strings.
+ */
+uint32_t ts_query_start_byte_for_pattern(const TSQuery *, uint32_t);
+
+/**
+ * Get all of the predicates for the given pattern in the query.
+ *
+ * The predicates are represented as a single array of steps. There are three
+ * types of steps in this array, which correspond to the three legal values for
+ * the `type` field:
+ * - `TSQueryPredicateStepTypeCapture` - Steps with this type represent names
+ *    of captures. Their `value_id` can be used with the
+ *   `ts_query_capture_name_for_id` function to obtain the name of the capture.
+ * - `TSQueryPredicateStepTypeString` - Steps with this type represent literal
+ *    strings. Their `value_id` can be used with the
+ *    `ts_query_string_value_for_id` function to obtain their string value.
+ * - `TSQueryPredicateStepTypeDone` - Steps with this type are *sentinels*
+ *    that represent the end of an individual predicate. If a pattern has two
+ *    predicates, then there will be two steps with this `type` in the array.
+ */
+const TSQueryPredicateStep *ts_query_predicates_for_pattern(
+  const TSQuery *self,
+  uint32_t pattern_index,
+  uint32_t *length
+);
+
+/*
+ * Check if the given pattern in the query has a single root node.
+ */
+bool ts_query_is_pattern_rooted(const TSQuery *self, uint32_t pattern_index);
+
+/*
+ * Check if the given pattern in the query is 'non local'.
+ *
+ * A non-local pattern has multiple root nodes and can match within a
+ * repeating sequence of nodes, as specified by the grammar. Non-local
+ * patterns disable certain optimizations that would otherwise be possible
+ * when executing a query on a specific range of a syntax tree.
+ */
+bool ts_query_is_pattern_non_local(const TSQuery *self, uint32_t pattern_index);
+
+/*
+ * Check if a given pattern is guaranteed to match once a given step is reached.
+ * The step is specified by its byte offset in the query's source code.
+ */
+bool ts_query_is_pattern_guaranteed_at_step(const TSQuery *self, uint32_t byte_offset);
+
+/**
+ * Get the name and length of one of the query's captures, or one of the
+ * query's string literals. Each capture and string is associated with a
+ * numeric id based on the order that it appeared in the query's source.
+ */
+const char *ts_query_capture_name_for_id(
+  const TSQuery *,
+  uint32_t id,
+  uint32_t *length
+);
+
+/**
+ * Get the quantifier of the query's captures. Each capture is * associated
+ * with a numeric id based on the order that it appeared in the query's source.
+ */
+TSQuantifier ts_query_capture_quantifier_for_id(
+  const TSQuery *,
+  uint32_t pattern_id,
+  uint32_t capture_id
+);
+
+const char *ts_query_string_value_for_id(
+  const TSQuery *,
+  uint32_t id,
+  uint32_t *length
+);
+
+/**
+ * Disable a certain capture within a query.
+ *
+ * This prevents the capture from being returned in matches, and also avoids
+ * any resource usage associated with recording the capture. Currently, there
+ * is no way to undo this.
+ */
+void ts_query_disable_capture(TSQuery *, const char *, uint32_t);
+
+/**
+ * Disable a certain pattern within a query.
+ *
+ * This prevents the pattern from matching and removes most of the overhead
+ * associated with the pattern. Currently, there is no way to undo this.
+ */
+void ts_query_disable_pattern(TSQuery *, uint32_t);
+
+/**
+ * Create a new cursor for executing a given query.
+ *
+ * The cursor stores the state that is needed to iteratively search
+ * for matches. To use the query cursor, first call `ts_query_cursor_exec`
+ * to start running a given query on a given syntax node. Then, there are
+ * two options for consuming the results of the query:
+ * 1. Repeatedly call `ts_query_cursor_next_match` to iterate over all of the
+ *    *matches* in the order that they were found. Each match contains the
+ *    index of the pattern that matched, and an array of captures. Because
+ *    multiple patterns can match the same set of nodes, one match may contain
+ *    captures that appear *before* some of the captures from a previous match.
+ * 2. Repeatedly call `ts_query_cursor_next_capture` to iterate over all of the
+ *    individual *captures* in the order that they appear. This is useful if
+ *    don't care about which pattern matched, and just want a single ordered
+ *    sequence of captures.
+ *
+ * If you don't care about consuming all of the results, you can stop calling
+ * `ts_query_cursor_next_match` or `ts_query_cursor_next_capture` at any point.
+ *  You can then start executing another query on another node by calling
+ *  `ts_query_cursor_exec` again.
+ */
+TSQueryCursor *ts_query_cursor_new(void);
+
+/**
+ * Delete a query cursor, freeing all of the memory that it used.
+ */
+void ts_query_cursor_delete(TSQueryCursor *);
+
+/**
+ * Start running a given query on a given node.
+ */
+void ts_query_cursor_exec(TSQueryCursor *, const TSQuery *, TSNode);
+
+/**
+ * Manage the maximum number of in-progress matches allowed by this query
+ * cursor.
+ *
+ * Query cursors have an optional maximum capacity for storing lists of
+ * in-progress captures. If this capacity is exceeded, then the
+ * earliest-starting match will silently be dropped to make room for further
+ * matches. This maximum capacity is optional — by default, query cursors allow
+ * any number of pending matches, dynamically allocating new space for them as
+ * needed as the query is executed.
+ */
+bool ts_query_cursor_did_exceed_match_limit(const TSQueryCursor *);
+uint32_t ts_query_cursor_match_limit(const TSQueryCursor *);
+void ts_query_cursor_set_match_limit(TSQueryCursor *, uint32_t);
+
+/**
+ * Set the range of bytes or (row, column) positions in which the query
+ * will be executed.
+ */
+void ts_query_cursor_set_byte_range(TSQueryCursor *, uint32_t, uint32_t);
+void ts_query_cursor_set_point_range(TSQueryCursor *, TSPoint, TSPoint);
+
+/**
+ * Advance to the next match of the currently running query.
+ *
+ * If there is a match, write it to `*match` and return `true`.
+ * Otherwise, return `false`.
+ */
+bool ts_query_cursor_next_match(TSQueryCursor *, TSQueryMatch *match);
+void ts_query_cursor_remove_match(TSQueryCursor *, uint32_t id);
+
+/**
+ * Advance to the next capture of the currently running query.
+ *
+ * If there is a capture, write its match to `*match` and its index within
+ * the matche's capture list to `*capture_index`. Otherwise, return `false`.
+ */
+bool ts_query_cursor_next_capture(
+  TSQueryCursor *,
+  TSQueryMatch *match,
+  uint32_t *capture_index
+);
+
+/**********************/
+/* Section - Language */
+/**********************/
+
+/**
+ * Get the number of distinct node types in the language.
+ */
+uint32_t ts_language_symbol_count(const TSLanguage *);
+
+/**
+ * Get a node type string for the given numerical id.
+ */
+const char *ts_language_symbol_name(const TSLanguage *, TSSymbol);
+
+/**
+ * Get the numerical id for the given node type string.
+ */
+TSSymbol ts_language_symbol_for_name(
+  const TSLanguage *self,
+  const char *string,
+  uint32_t length,
+  bool is_named
+);
+
+/**
+ * Get the number of distinct field names in the language.
+ */
+uint32_t ts_language_field_count(const TSLanguage *);
+
+/**
+ * Get the field name string for the given numerical id.
+ */
+const char *ts_language_field_name_for_id(const TSLanguage *, TSFieldId);
+
+/**
+ * Get the numerical id for the given field name string.
+ */
+TSFieldId ts_language_field_id_for_name(const TSLanguage *, const char *, uint32_t);
+
+/**
+ * Check whether the given node type id belongs to named nodes, anonymous nodes,
+ * or a hidden nodes.
+ *
+ * See also `ts_node_is_named`. Hidden nodes are never returned from the API.
+ */
+TSSymbolType ts_language_symbol_type(const TSLanguage *, TSSymbol);
+
+/**
+ * Get the ABI version number for this language. This version number is used
+ * to ensure that languages were generated by a compatible version of
+ * Tree-sitter.
+ *
+ * See also `ts_parser_set_language`.
+ */
+uint32_t ts_language_version(const TSLanguage *);
+
+/**********************************/
+/* Section - Global Configuration */
+/**********************************/
+
+/**
+ * Set the allocation functions used by the library.
+ *
+ * By default, Tree-sitter uses the standard libc allocation functions,
+ * but aborts the process when an allocation fails. This function lets
+ * you supply alternative allocation functions at runtime.
+ *
+ * If you pass `NULL` for any parameter, Tree-sitter will switch back to
+ * its default implementation of that function.
+ *
+ * If you call this function after the library has already been used, then
+ * you must ensure that either:
+ *  1. All the existing objects have been freed.
+ *  2. The new allocator shares its state with the old one, so it is capable
+ *     of freeing memory that was allocated by the old allocator.
+ */
+void ts_set_allocator(
+  void *(*new_malloc)(size_t),
+	void *(*new_calloc)(size_t, size_t),
+	void *(*new_realloc)(void *, size_t),
+	void (*new_free)(void *)
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TREE_SITTER_API_H_
+