1 files changed, 1235 insertions, 0 deletions

diff --git a/vendor/github.com/mitjafelicijan/go-tree-sitter/bindings.go b/vendor/github.com/mitjafelicijan/go-tree-sitter/bindings.go
new file mode 100644
index 0000000..5c3cca3
--- /dev/null
+++ b/vendor/github.com/mitjafelicijan/go-tree-sitter/bindings.go
@@ -0,0 +1,1235 @@
+package sitter
+
+// #include "bindings.h"
+import "C"
+
+import (
+        "context"
+        "errors"
+        "fmt"
+        "math"
+        "reflect"
+        "regexp"
+        "runtime"
+        "strings"
+        "sync"
+        "sync/atomic"
+        "unsafe"
+)
+
+// maintain a map of read functions that can be called from C
+var readFuncs = &readFuncsMap{funcs: make(map[int]ReadFunc)}
+
+// Parse is a shortcut for parsing bytes of source code,
+// returns root node
+//
+// Deprecated: use ParseCtx instead
+func Parse(content []byte, lang *Language) *Node {
+        n, _ := ParseCtx(context.Background(), content, lang)
+        return n
+}
+
+// ParseCtx is a shortcut for parsing bytes of source code,
+// returns root node
+func ParseCtx(ctx context.Context, content []byte, lang *Language) (*Node, error) {
+        p := NewParser()
+        p.SetLanguage(lang)
+        tree, err := p.ParseCtx(ctx, nil, content)
+        if err != nil {
+                return nil, err
+        }
+
+        return tree.RootNode(), nil
+}
+
+// Parser produces concrete syntax tree based on source code using Language
+type Parser struct {
+        isClosed bool
+        c        *C.TSParser
+        cancel   *uintptr
+}
+
+// NewParser creates new Parser
+func NewParser() *Parser {
+        cancel := uintptr(0)
+        p := &Parser{c: C.ts_parser_new(), cancel: &cancel}
+        C.ts_parser_set_cancellation_flag(p.c, (*C.size_t)(unsafe.Pointer(p.cancel)))
+        runtime.SetFinalizer(p, (*Parser).Close)
+        return p
+}
+
+// SetLanguage assignes Language to a parser
+func (p *Parser) SetLanguage(lang *Language) {
+        cLang := (*C.struct_TSLanguage)(lang.ptr)
+        C.ts_parser_set_language(p.c, cLang)
+}
+
+// ReadFunc is a function to retrieve a chunk of text at a given byte offset and (row, column) position
+// it should return nil to indicate the end of the document
+type ReadFunc func(offset uint32, position Point) []byte
+
+// InputEncoding is a encoding of the text to parse
+type InputEncoding int
+
+const (
+        InputEncodingUTF8 InputEncoding = iota
+        InputEncodingUTF16
+)
+
+// Input defines parameters for parse method
+type Input struct {
+        Read     ReadFunc
+        Encoding InputEncoding
+}
+
+var (
+        ErrOperationLimit = errors.New("operation limit was hit")
+        ErrNoLanguage     = errors.New("cannot parse without language")
+)
+
+// Parse produces new Tree from content using old tree
+//
+// Deprecated: use ParseCtx instead
+func (p *Parser) Parse(oldTree *Tree, content []byte) *Tree {
+        t, _ := p.ParseCtx(context.Background(), oldTree, content)
+        return t
+}
+
+// ParseCtx produces new Tree from content using old tree
+func (p *Parser) ParseCtx(ctx context.Context, oldTree *Tree, content []byte) (*Tree, error) {
+        var BaseTree *C.TSTree
+        if oldTree != nil {
+                BaseTree = oldTree.c
+        }
+
+        parseComplete := make(chan struct{})
+
+        // run goroutine only if context is cancelable to avoid performance impact
+        if ctx.Done() != nil {
+                go func() {
+                        select {
+                        case <-ctx.Done():
+                                atomic.StoreUintptr(p.cancel, 1)
+                        case <-parseComplete:
+                                return
+                        }
+                }()
+        }
+
+        input := C.CBytes(content)
+        BaseTree = C.ts_parser_parse_string(p.c, BaseTree, (*C.char)(input), C.uint32_t(len(content)))
+        close(parseComplete)
+        C.free(input)
+
+        return p.convertTSTree(ctx, BaseTree)
+}
+
+// ParseInput produces new Tree by reading from a callback defined in input
+// it is useful if your data is stored in specialized data structure
+// as it will avoid copying the data into []bytes
+// and faster access to edited part of the data
+func (p *Parser) ParseInput(oldTree *Tree, input Input) *Tree {
+        t, _ := p.ParseInputCtx(context.Background(), oldTree, input)
+        return t
+}
+
+// ParseInputCtx produces new Tree by reading from a callback defined in input
+// it is useful if your data is stored in specialized data structure
+// as it will avoid copying the data into []bytes
+// and faster access to edited part of the data
+func (p *Parser) ParseInputCtx(ctx context.Context, oldTree *Tree, input Input) (*Tree, error) {
+        var BaseTree *C.TSTree
+        if oldTree != nil {
+                BaseTree = oldTree.c
+        }
+
+        funcID := readFuncs.register(input.Read)
+        BaseTree = C.call_ts_parser_parse(p.c, BaseTree, C.int(funcID), C.TSInputEncoding(input.Encoding))
+        readFuncs.unregister(funcID)
+
+        return p.convertTSTree(ctx, BaseTree)
+}
+
+// convertTSTree converts the tree-sitter response into a *Tree or an error.
+//
+// tree-sitter can fail for 3 reasons:
+// - cancelation
+// - operation limit hit
+// - no language set
+//
+// We check for all those conditions if ther return value is nil.
+// see: https://github.com/tree-sitter/tree-sitter/blob/7890a29db0b186b7b21a0a95d99fa6c562b8316b/lib/include/tree_sitter/api.h#L209-L246
+func (p *Parser) convertTSTree(ctx context.Context, tsTree *C.TSTree) (*Tree, error) {
+        if tsTree == nil {
+                if ctx.Err() != nil {
+                        // reset cancellation flag so the parse can be re-used
+                        atomic.StoreUintptr(p.cancel, 0)
+                        // context cancellation caused a timeout, return that error
+                        return nil, ctx.Err()
+                }
+
+                if C.ts_parser_language(p.c) == nil {
+                        return nil, ErrNoLanguage
+                }
+
+                return nil, ErrOperationLimit
+        }
+
+        return p.newTree(tsTree), nil
+}
+
+// OperationLimit returns the duration in microseconds that parsing is allowed to take
+func (p *Parser) OperationLimit() int {
+        return int(C.ts_parser_timeout_micros(p.c))
+}
+
+// SetOperationLimit limits the maximum duration in microseconds that parsing should be allowed to take before halting
+func (p *Parser) SetOperationLimit(limit int) {
+        C.ts_parser_set_timeout_micros(p.c, C.uint64_t(limit))
+}
+
+// Reset causes the parser to parse from scratch on the next call to parse, instead of resuming
+// so that it sees the changes to the beginning of the source code.
+func (p *Parser) Reset() {
+        C.ts_parser_reset(p.c)
+}
+
+// SetIncludedRanges sets text ranges of a file
+func (p *Parser) SetIncludedRanges(ranges []Range) {
+        cRanges := make([]C.TSRange, len(ranges))
+        for i, r := range ranges {
+                cRanges[i] = C.TSRange{
+                        start_point: C.TSPoint{
+                                row:    C.uint32_t(r.StartPoint.Row),
+                                column: C.uint32_t(r.StartPoint.Column),
+                        },
+                        end_point: C.TSPoint{
+                                row:    C.uint32_t(r.EndPoint.Row),
+                                column: C.uint32_t(r.EndPoint.Column),
+                        },
+                        start_byte: C.uint32_t(r.StartByte),
+                        end_byte:   C.uint32_t(r.EndByte),
+                }
+        }
+        C.ts_parser_set_included_ranges(p.c, (*C.TSRange)(unsafe.Pointer(&cRanges[0])), C.uint(len(ranges)))
+}
+
+// Debug enables debug output to stderr
+func (p *Parser) Debug() {
+        logger := C.stderr_logger_new(true)
+        C.ts_parser_set_logger(p.c, logger)
+}
+
+// Close should be called to ensure that all the memory used by the parse is freed.
+//
+// As the constructor in go-tree-sitter would set this func call through runtime.SetFinalizer,
+// parser.Close() will be called by Go's garbage collector and users would not have to call this manually.
+func (p *Parser) Close() {
+        if !p.isClosed {
+                C.ts_parser_delete(p.c)
+        }
+
+        p.isClosed = true
+}
+
+type Point struct {
+        Row    uint32
+        Column uint32
+}
+
+type Range struct {
+        StartPoint Point
+        EndPoint   Point
+        StartByte  uint32
+        EndByte    uint32
+}
+
+// we use cache for nodes on normal tree object
+// it prevent run of SetFinalizer as it introduces cycle
+// we can workaround it using separate object
+// for details see: https://github.com/golang/go/issues/7358#issuecomment-66091558
+type BaseTree struct {
+        c        *C.TSTree
+        isClosed bool
+}
+
+// newTree creates a new tree object from a C pointer. The function will set a finalizer for the object,
+// thus no free is needed for it.
+func (p *Parser) newTree(c *C.TSTree) *Tree {
+        base := &BaseTree{c: c}
+        runtime.SetFinalizer(base, (*BaseTree).Close)
+
+        newTree := &Tree{p: p, BaseTree: base, cache: make(map[C.TSNode]*Node)}
+        return newTree
+}
+
+// Tree represents the syntax tree of an entire source code file
+// Note: Tree instances are not thread safe;
+// you must copy a tree if you want to use it on multiple threads simultaneously.
+type Tree struct {
+        *BaseTree
+
+        // p is a pointer to a Parser that produced the Tree. Only used to keep Parser alive.
+        // Otherwise Parser may be GC'ed (and deleted by the finalizer) while some Tree objects are still in use.
+        p *Parser
+
+        // most probably better save node.id
+        cache map[C.TSNode]*Node
+}
+
+// Copy returns a new copy of a tree
+func (t *Tree) Copy() *Tree {
+        return t.p.newTree(C.ts_tree_copy(t.c))
+}
+
+// RootNode returns root node of a tree
+func (t *Tree) RootNode() *Node {
+        ptr := C.ts_tree_root_node(t.c)
+        return t.cachedNode(ptr)
+}
+
+func (t *Tree) cachedNode(ptr C.TSNode) *Node {
+        if ptr.id == nil {
+                return nil
+        }
+
+        if n, ok := t.cache[ptr]; ok {
+                return n
+        }
+
+        n := &Node{ptr, t}
+        t.cache[ptr] = n
+        return n
+}
+
+// Close should be called to ensure that all the memory used by the tree is freed.
+//
+// As the constructor in go-tree-sitter would set this func call through runtime.SetFinalizer,
+// parser.Close() will be called by Go's garbage collector and users would not have to call this manually.
+func (t *BaseTree) Close() {
+        if !t.isClosed {
+                C.ts_tree_delete(t.c)
+        }
+
+        t.isClosed = true
+}
+
+type EditInput struct {
+        StartIndex  uint32
+        OldEndIndex uint32
+        NewEndIndex uint32
+        StartPoint  Point
+        OldEndPoint Point
+        NewEndPoint Point
+}
+
+func (i EditInput) c() *C.TSInputEdit {
+        return &C.TSInputEdit{
+                start_byte:   C.uint32_t(i.StartIndex),
+                old_end_byte: C.uint32_t(i.OldEndIndex),
+                new_end_byte: C.uint32_t(i.NewEndIndex),
+                start_point: C.TSPoint{
+                        row:    C.uint32_t(i.StartPoint.Row),
+                        column: C.uint32_t(i.StartPoint.Column),
+                },
+                old_end_point: C.TSPoint{
+                        row:    C.uint32_t(i.OldEndPoint.Row),
+                        column: C.uint32_t(i.OldEndPoint.Column),
+                },
+                new_end_point: C.TSPoint{
+                        row:    C.uint32_t(i.OldEndPoint.Row),
+                        column: C.uint32_t(i.OldEndPoint.Column),
+                },
+        }
+}
+
+// Edit the syntax tree to keep it in sync with source code that has been edited.
+func (t *Tree) Edit(i EditInput) {
+        C.ts_tree_edit(t.c, i.c())
+}
+
+// Language defines how to parse a particular programming language
+type Language struct {
+        ptr unsafe.Pointer
+}
+
+// NewLanguage creates new Language from c pointer
+func NewLanguage(ptr unsafe.Pointer) *Language {
+        return &Language{ptr}
+}
+
+// SymbolName returns a node type string for the given Symbol.
+func (l *Language) SymbolName(s Symbol) string {
+        return C.GoString(C.ts_language_symbol_name((*C.TSLanguage)(l.ptr), s))
+}
+
+// SymbolType returns named, anonymous, or a hidden type for a Symbol.
+func (l *Language) SymbolType(s Symbol) SymbolType {
+        return SymbolType(C.ts_language_symbol_type((*C.TSLanguage)(l.ptr), s))
+}
+
+// SymbolCount returns the number of distinct field names in the language.
+func (l *Language) SymbolCount() uint32 {
+        return uint32(C.ts_language_symbol_count((*C.TSLanguage)(l.ptr)))
+}
+
+func (l *Language) FieldName(idx int) string {
+        return C.GoString(C.ts_language_field_name_for_id((*C.TSLanguage)(l.ptr), C.ushort(idx)))
+}
+
+// Node represents a single node in the syntax tree
+// It tracks its start and end positions in the source code,
+// as well as its relation to other nodes like its parent, siblings and children.
+type Node struct {
+        c C.TSNode
+        t *Tree // keep pointer on tree because node is valid only as long as tree is
+}
+
+type Symbol = C.TSSymbol
+
+type SymbolType int
+
+const (
+        SymbolTypeRegular SymbolType = iota
+        SymbolTypeAnonymous
+        SymbolTypeAuxiliary
+)
+
+var symbolTypeNames = []string{
+        "Regular",
+        "Anonymous",
+        "Auxiliary",
+}
+
+func (t SymbolType) String() string {
+        return symbolTypeNames[t]
+}
+
+func (n Node) ID() uintptr {
+        return uintptr(n.c.id)
+}
+
+// StartByte returns the node's start byte.
+func (n Node) StartByte() uint32 {
+        return uint32(C.ts_node_start_byte(n.c))
+}
+
+// EndByte returns the node's end byte.
+func (n Node) EndByte() uint32 {
+        return uint32(C.ts_node_end_byte(n.c))
+}
+
+// StartPoint returns the node's start position in terms of rows and columns.
+func (n Node) StartPoint() Point {
+        p := C.ts_node_start_point(n.c)
+        return Point{
+                Row:    uint32(p.row),
+                Column: uint32(p.column),
+        }
+}
+
+// EndPoint returns the node's end position in terms of rows and columns.
+func (n Node) EndPoint() Point {
+        p := C.ts_node_end_point(n.c)
+        return Point{
+                Row:    uint32(p.row),
+                Column: uint32(p.column),
+        }
+}
+
+func (n Node) Range() Range {
+        return Range{
+                StartByte:  n.StartByte(),
+                EndByte:    n.EndByte(),
+                StartPoint: n.StartPoint(),
+                EndPoint:   n.EndPoint(),
+        }
+}
+
+// Symbol returns the node's type as a Symbol.
+func (n Node) Symbol() Symbol {
+        return C.ts_node_symbol(n.c)
+}
+
+// Type returns the node's type as a string.
+func (n Node) Type() string {
+        return C.GoString(C.ts_node_type(n.c))
+}
+
+// String returns an S-expression representing the node as a string.
+func (n Node) String() string {
+        ptr := C.ts_node_string(n.c)
+        defer C.free(unsafe.Pointer(ptr))
+        return C.GoString(ptr)
+}
+
+// Equal checks if two nodes are identical.
+func (n Node) Equal(other *Node) bool {
+        return bool(C.ts_node_eq(n.c, other.c))
+}
+
+// IsNull checks if the node is null.
+func (n Node) IsNull() bool {
+        return bool(C.ts_node_is_null(n.c))
+}
+
+// IsNamed checks if the node is *named*.
+// Named nodes correspond to named rules in the grammar,
+// whereas *anonymous* nodes correspond to string literals in the grammar.
+func (n Node) IsNamed() bool {
+        return bool(C.ts_node_is_named(n.c))
+}
+
+// IsMissing checks if the node is *missing*.
+// Missing nodes are inserted by the parser in order to recover from certain kinds of syntax errors.
+func (n Node) IsMissing() bool {
+        return bool(C.ts_node_is_missing(n.c))
+}
+
+// IsExtra checks if the node is *extra*.
+// Extra nodes represent things like comments, which are not required the grammar, but can appear anywhere.
+func (n Node) IsExtra() bool {
+        return bool(C.ts_node_is_extra(n.c))
+}
+
+// IsError checks if the node is a syntax error.
+// Syntax errors represent parts of the code that could not be incorporated into a valid syntax tree.
+func (n Node) IsError() bool {
+        return n.Symbol() == math.MaxUint16
+}
+
+// HasChanges checks if a syntax node has been edited.
+func (n Node) HasChanges() bool {
+        return bool(C.ts_node_has_changes(n.c))
+}
+
+// HasError check if the node is a syntax error or contains any syntax errors.
+func (n Node) HasError() bool {
+        return bool(C.ts_node_has_error(n.c))
+}
+
+// Parent returns the node's immediate parent.
+func (n Node) Parent() *Node {
+        nn := C.ts_node_parent(n.c)
+        return n.t.cachedNode(nn)
+}
+
+// Child returns the node's child at the given index, where zero represents the first child.
+func (n Node) Child(idx int) *Node {
+        nn := C.ts_node_child(n.c, C.uint32_t(idx))
+        return n.t.cachedNode(nn)
+}
+
+// NamedChild returns the node's *named* child at the given index.
+func (n Node) NamedChild(idx int) *Node {
+        nn := C.ts_node_named_child(n.c, C.uint32_t(idx))
+        return n.t.cachedNode(nn)
+}
+
+// ChildCount returns the node's number of children.
+func (n Node) ChildCount() uint32 {
+        return uint32(C.ts_node_child_count(n.c))
+}
+
+// NamedChildCount returns the node's number of *named* children.
+func (n Node) NamedChildCount() uint32 {
+        return uint32(C.ts_node_named_child_count(n.c))
+}
+
+// ChildByFieldName returns the node's child with the given field name.
+func (n Node) ChildByFieldName(name string) *Node {
+        str := C.CString(name)
+        defer C.free(unsafe.Pointer(str))
+        nn := C.ts_node_child_by_field_name(n.c, str, C.uint32_t(len(name)))
+        return n.t.cachedNode(nn)
+}
+
+// FieldNameForChild returns the field name of the child at the given index, or "" if not named.
+func (n Node) FieldNameForChild(idx int) string {
+        return C.GoString(C.ts_node_field_name_for_child(n.c, C.uint32_t(idx)))
+}
+
+// NextSibling returns the node's next sibling.
+func (n Node) NextSibling() *Node {
+        nn := C.ts_node_next_sibling(n.c)
+        return n.t.cachedNode(nn)
+}
+
+// NextNamedSibling returns the node's next *named* sibling.
+func (n Node) NextNamedSibling() *Node {
+        nn := C.ts_node_next_named_sibling(n.c)
+        return n.t.cachedNode(nn)
+}
+
+// PrevSibling returns the node's previous sibling.
+func (n Node) PrevSibling() *Node {
+        nn := C.ts_node_prev_sibling(n.c)
+        return n.t.cachedNode(nn)
+}
+
+// PrevNamedSibling returns the node's previous *named* sibling.
+func (n Node) PrevNamedSibling() *Node {
+        nn := C.ts_node_prev_named_sibling(n.c)
+        return n.t.cachedNode(nn)
+}
+
+// Edit the node to keep it in-sync with source code that has been edited.
+func (n Node) Edit(i EditInput) {
+        C.ts_node_edit(&n.c, i.c())
+}
+
+// Content returns node's source code from input as a string
+func (n Node) Content(input []byte) string {
+        return string(input[n.StartByte():n.EndByte()])
+}
+
+func (n Node) NamedDescendantForPointRange(start Point, end Point) *Node {
+        cStartPoint := C.TSPoint{
+                row:    C.uint32_t(start.Row),
+                column: C.uint32_t(start.Column),
+        }
+        cEndPoint := C.TSPoint{
+                row:    C.uint32_t(end.Row),
+                column: C.uint32_t(end.Column),
+        }
+        nn := C.ts_node_named_descendant_for_point_range(n.c, cStartPoint, cEndPoint)
+        return n.t.cachedNode(nn)
+}
+
+// TreeCursor allows you to walk a syntax tree more efficiently than is
+// possible using the `Node` functions. It is a mutable object that is always
+// on a certain syntax node, and can be moved imperatively to different nodes.
+type TreeCursor struct {
+        c *C.TSTreeCursor
+        t *Tree
+
+        isClosed bool
+}
+
+// NewTreeCursor creates a new tree cursor starting from the given node.
+func NewTreeCursor(n *Node) *TreeCursor {
+        cc := C.ts_tree_cursor_new(n.c)
+        c := &TreeCursor{
+                c: &cc,
+                t: n.t,
+        }
+
+        runtime.SetFinalizer(c, (*TreeCursor).Close)
+        return c
+}
+
+// Close should be called to ensure that all the memory used by the tree cursor
+// is freed.
+//
+// As the constructor in go-tree-sitter would set this func call through runtime.SetFinalizer,
+// parser.Close() will be called by Go's garbage collector and users would not have to call this manually.
+func (c *TreeCursor) Close() {
+        if !c.isClosed {
+                C.ts_tree_cursor_delete(c.c)
+        }
+
+        c.isClosed = true
+}
+
+// Reset re-initializes a tree cursor to start at a different node.
+func (c *TreeCursor) Reset(n *Node) {
+        c.t = n.t
+        C.ts_tree_cursor_reset(c.c, n.c)
+}
+
+// CurrentNode of the tree cursor.
+func (c *TreeCursor) CurrentNode() *Node {
+        n := C.ts_tree_cursor_current_node(c.c)
+        return c.t.cachedNode(n)
+}
+
+// CurrentFieldName gets the field name of the tree cursor's current node.
+//
+// This returns empty string if the current node doesn't have a field.
+func (c *TreeCursor) CurrentFieldName() string {
+        return C.GoString(C.ts_tree_cursor_current_field_name(c.c))
+}
+
+// GoToParent moves 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).
+func (c *TreeCursor) GoToParent() bool {
+        return bool(C.ts_tree_cursor_goto_parent(c.c))
+}
+
+// GoToNextSibling moves 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.
+func (c *TreeCursor) GoToNextSibling() bool {
+        return bool(C.ts_tree_cursor_goto_next_sibling(c.c))
+}
+
+// GoToFirstChild moves 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.
+func (c *TreeCursor) GoToFirstChild() bool {
+        return bool(C.ts_tree_cursor_goto_first_child(c.c))
+}
+
+// GoToFirstChildForByte moves the cursor to the first child of its current node
+// that extends beyond the given byte offset.
+//
+// This returns the index of the child node if one was found, and returns -1
+// if no such child was found.
+func (c *TreeCursor) GoToFirstChildForByte(b uint32) int64 {
+        return int64(C.ts_tree_cursor_goto_first_child_for_byte(c.c, C.uint32_t(b)))
+}
+
+// QueryErrorType - value that indicates the type of QueryError.
+type QueryErrorType int
+
+const (
+        QueryErrorNone QueryErrorType = iota
+        QueryErrorSyntax
+        QueryErrorNodeType
+        QueryErrorField
+        QueryErrorCapture
+        QueryErrorStructure
+        QueryErrorLanguage
+)
+
+func QueryErrorTypeToString(errorType QueryErrorType) string {
+        switch errorType {
+        case QueryErrorNone:
+                return "none"
+        case QueryErrorNodeType:
+                return "node type"
+        case QueryErrorField:
+                return "field"
+        case QueryErrorCapture:
+                return "capture"
+        case QueryErrorSyntax:
+                return "syntax"
+        default:
+                return "unknown"
+        }
+
+}
+
+// QueryError - if there is an error in the query,
+// then the Offset argument will be set to the byte offset of the error,
+// and the Type argument will be set to a value that indicates the type of error.
+type QueryError struct {
+        Offset  uint32
+        Type    QueryErrorType
+        Message string
+}
+
+func (qe *QueryError) Error() string {
+        return qe.Message
+}
+
+// Query API
+type Query struct {
+        c        *C.TSQuery
+        isClosed bool
+}
+
+// NewQuery creates a query by specifying a string containing one or more patterns.
+// In case of error returns QueryError.
+func NewQuery(pattern []byte, lang *Language) (*Query, error) {
+        var (
+                erroff  C.uint32_t
+                errtype C.TSQueryError
+        )
+
+        input := C.CBytes(pattern)
+        c := C.ts_query_new(
+                (*C.struct_TSLanguage)(lang.ptr),
+                (*C.char)(input),
+                C.uint32_t(len(pattern)),
+                &erroff,
+                &errtype,
+        )
+        C.free(input)
+        if errtype != C.TSQueryError(QueryErrorNone) {
+                errorOffset := uint32(erroff)
+                // search for the line containing the offset
+                line := 1
+                line_start := 0
+                for i, c := range pattern {
+                        line_start = i
+                        if uint32(i) >= errorOffset {
+                                break
+                        }
+                        if c == '\n' {
+                                line++
+                        }
+                }
+                column := int(errorOffset) - line_start
+                errorType := QueryErrorType(errtype)
+                errorTypeToString := QueryErrorTypeToString(errorType)
+
+                var message string
+                switch errorType {
+                // errors that apply to a single identifier
+                case QueryErrorNodeType:
+                        fallthrough
+                case QueryErrorField:
+                        fallthrough
+                case QueryErrorCapture:
+                        // find identifier at input[errorOffset]
+                        // and report it in the error message
+                        s := string(pattern[errorOffset:])
+                        identifierRegexp := regexp.MustCompile(`^[a-zA-Z_][a-zA-Z0-9_-]*`)
+                        m := identifierRegexp.FindStringSubmatch(s)
+                        if len(m) > 0 {
+                                message = fmt.Sprintf("invalid %s '%s' at line %d column %d",
+                                        errorTypeToString, m[0], line, column)
+                        } else {
+                                message = fmt.Sprintf("invalid %s at line %d column %d",
+                                        errorTypeToString, line, column)
+                        }
+
+                // errors the report position
+                case QueryErrorSyntax:
+                        fallthrough
+                case QueryErrorStructure:
+                        fallthrough
+                case QueryErrorLanguage:
+                        fallthrough
+                default:
+                        s := string(pattern[errorOffset:])
+                        lines := strings.Split(s, "\n")
+                        whitespace := strings.Repeat(" ", column)
+                        message = fmt.Sprintf("invalid %s at line %d column %d\n%s\n%s^",
+                                errorTypeToString, line, column,
+                                lines[0], whitespace)
+                }
+
+                return nil, &QueryError{
+                        Offset:  errorOffset,
+                        Type:    errorType,
+                        Message: message,
+                }
+        }
+
+        q := &Query{c: c}
+
+        // Copied from: https://github.com/klothoplatform/go-tree-sitter/commit/e351b20167b26d515627a4a1a884528ede5fef79
+        // this is just used for syntax validation - it does not actually filter anything
+        for i := uint32(0); i < q.PatternCount(); i++ {
+                predicates := q.PredicatesForPattern(i)
+                for _, steps := range predicates {
+                        if len(steps) == 0 {
+                                continue
+                        }
+
+                        if steps[0].Type != QueryPredicateStepTypeString {
+                                return nil, errors.New("predicate must begin with a literal value")
+                        }
+
+                        operator := q.StringValueForId(steps[0].ValueId)
+                        switch operator {
+                        case "eq?", "not-eq?":
+                                if len(steps) != 4 {
+                                        return nil, fmt.Errorf("wrong number of arguments to `#%s` predicate. Expected 2, got %d", operator, len(steps)-2)
+                                }
+                                if steps[1].Type != QueryPredicateStepTypeCapture {
+                                        return nil, fmt.Errorf("first argument of `#%s` predicate must be a capture. Got %s", operator, q.StringValueForId(steps[1].ValueId))
+                                }
+                        case "match?", "not-match?":
+                                if len(steps) != 4 {
+                                        return nil, fmt.Errorf("wrong number of arguments to `#%s` predicate. Expected 2, got %d", operator, len(steps)-2)
+                                }
+                                if steps[1].Type != QueryPredicateStepTypeCapture {
+                                        return nil, fmt.Errorf("first argument of `#%s` predicate must be a capture. Got %s", operator, q.StringValueForId(steps[1].ValueId))
+                                }
+                                if steps[2].Type != QueryPredicateStepTypeString {
+                                        return nil, fmt.Errorf("second argument of `#%s` predicate must be a string. Got %s", operator, q.StringValueForId(steps[2].ValueId))
+                                }
+                        case "set!", "is?", "is-not?":
+                                if len(steps) < 3 || len(steps) > 4 {
+                                        return nil, fmt.Errorf("wrong number of arguments to `#%s` predicate. Expected 1 or 2, got %d", operator, len(steps)-2)
+                                }
+                                if steps[1].Type != QueryPredicateStepTypeString {
+                                        return nil, fmt.Errorf("first argument of `#%s` predicate must be a string. Got %s", operator, q.StringValueForId(steps[1].ValueId))
+                                }
+                                if len(steps) > 2 && steps[2].Type != QueryPredicateStepTypeString {
+                                        return nil, fmt.Errorf("second argument of `#%s` predicate must be a string. Got %s", operator, q.StringValueForId(steps[2].ValueId))
+                                }
+                        }
+                }
+        }
+
+        runtime.SetFinalizer(q, (*Query).Close)
+
+        return q, nil
+}
+
+// Close should be called to ensure that all the memory used by the query is freed.
+//
+// As the constructor in go-tree-sitter would set this func call through runtime.SetFinalizer,
+// parser.Close() will be called by Go's garbage collector and users would not have to call this manually.
+func (q *Query) Close() {
+        if !q.isClosed {
+                C.ts_query_delete(q.c)
+        }
+
+        q.isClosed = true
+}
+
+func (q *Query) PatternCount() uint32 {
+        return uint32(C.ts_query_pattern_count(q.c))
+}
+
+func (q *Query) CaptureCount() uint32 {
+        return uint32(C.ts_query_capture_count(q.c))
+}
+
+func (q *Query) StringCount() uint32 {
+        return uint32(C.ts_query_string_count(q.c))
+}
+
+type QueryPredicateStepType int
+
+const (
+        QueryPredicateStepTypeDone QueryPredicateStepType = iota
+        QueryPredicateStepTypeCapture
+        QueryPredicateStepTypeString
+)
+
+type QueryPredicateStep struct {
+        Type    QueryPredicateStepType
+        ValueId uint32
+}
+
+func (q *Query) PredicatesForPattern(patternIndex uint32) [][]QueryPredicateStep {
+        var (
+                length          C.uint32_t
+                cPredicateSteps []C.TSQueryPredicateStep
+                predicateSteps  []QueryPredicateStep
+        )
+
+        cPredicateStep := C.ts_query_predicates_for_pattern(q.c, C.uint32_t(patternIndex), &length)
+
+        count := int(length)
+        slice := (*reflect.SliceHeader)((unsafe.Pointer(&cPredicateSteps)))
+        slice.Cap = count
+        slice.Len = count
+        slice.Data = uintptr(unsafe.Pointer(cPredicateStep))
+        for _, s := range cPredicateSteps {
+                stepType := QueryPredicateStepType(s._type)
+                valueId := uint32(s.value_id)
+                predicateSteps = append(predicateSteps, QueryPredicateStep{stepType, valueId})
+        }
+
+        return splitPredicates(predicateSteps)
+}
+
+func (q *Query) CaptureNameForId(id uint32) string {
+        var length C.uint32_t
+        name := C.ts_query_capture_name_for_id(q.c, C.uint32_t(id), &length)
+        return C.GoStringN(name, C.int(length))
+}
+
+func (q *Query) StringValueForId(id uint32) string {
+        var length C.uint32_t
+        value := C.ts_query_string_value_for_id(q.c, C.uint32_t(id), &length)
+        return C.GoStringN(value, C.int(length))
+}
+
+type Quantifier int
+
+const (
+        QuantifierZero = iota
+        QuantifierZeroOrOne
+        QuantifierZeroOrMore
+        QuantifierOne
+        QuantifierOneOrMore
+)
+
+func (q *Query) CaptureQuantifierForId(id uint32, captureId uint32) Quantifier {
+        return Quantifier(C.ts_query_capture_quantifier_for_id(q.c, C.uint32_t(id), C.uint32_t(captureId)))
+}
+
+// QueryCursor carries the state needed for processing the queries.
+type QueryCursor struct {
+        c *C.TSQueryCursor
+        t *Tree
+        // keep a pointer to the query to avoid garbage collection
+        q *Query
+
+        isClosed bool
+}
+
+// NewQueryCursor creates a query cursor.
+func NewQueryCursor() *QueryCursor {
+        qc := &QueryCursor{c: C.ts_query_cursor_new(), t: nil}
+        runtime.SetFinalizer(qc, (*QueryCursor).Close)
+
+        return qc
+}
+
+// Exec executes the query on a given syntax node.
+func (qc *QueryCursor) Exec(q *Query, n *Node) {
+        qc.q = q
+        qc.t = n.t
+        C.ts_query_cursor_exec(qc.c, q.c, n.c)
+}
+
+func (qc *QueryCursor) SetPointRange(startPoint Point, endPoint Point) {
+        cStartPoint := C.TSPoint{
+                row:    C.uint32_t(startPoint.Row),
+                column: C.uint32_t(startPoint.Column),
+        }
+        cEndPoint := C.TSPoint{
+                row:    C.uint32_t(endPoint.Row),
+                column: C.uint32_t(endPoint.Column),
+        }
+        C.ts_query_cursor_set_point_range(qc.c, cStartPoint, cEndPoint)
+}
+
+// Close should be called to ensure that all the memory used by the query cursor is freed.
+//
+// As the constructor in go-tree-sitter would set this func call through runtime.SetFinalizer,
+// parser.Close() will be called by Go's garbage collector and users would not have to call this manually.
+func (qc *QueryCursor) Close() {
+        if !qc.isClosed {
+                C.ts_query_cursor_delete(qc.c)
+        }
+
+        qc.isClosed = true
+}
+
+// QueryCapture is a captured node by a query with an index
+type QueryCapture struct {
+        Index uint32
+        Node  *Node
+}
+
+// QueryMatch - you can then iterate over the matches.
+type QueryMatch struct {
+        ID           uint32
+        PatternIndex uint16
+        Captures     []QueryCapture
+}
+
+// NextMatch iterates over matches.
+// This function will return (nil, false) when there are no more matches.
+// Otherwise, it will populate the QueryMatch with data
+// about which pattern matched and which nodes were captured.
+func (qc *QueryCursor) NextMatch() (*QueryMatch, bool) {
+        var (
+                cqm C.TSQueryMatch
+                cqc []C.TSQueryCapture
+        )
+
+        if ok := C.ts_query_cursor_next_match(qc.c, &cqm); !bool(ok) {
+                return nil, false
+        }
+
+        qm := &QueryMatch{
+                ID:           uint32(cqm.id),
+                PatternIndex: uint16(cqm.pattern_index),
+        }
+
+        count := int(cqm.capture_count)
+        slice := (*reflect.SliceHeader)((unsafe.Pointer(&cqc)))
+        slice.Cap = count
+        slice.Len = count
+        slice.Data = uintptr(unsafe.Pointer(cqm.captures))
+        for _, c := range cqc {
+                idx := uint32(c.index)
+                node := qc.t.cachedNode(c.node)
+                qm.Captures = append(qm.Captures, QueryCapture{idx, node})
+        }
+
+        return qm, true
+}
+
+func (qc *QueryCursor) NextCapture() (*QueryMatch, uint32, bool) {
+        var (
+                cqm          C.TSQueryMatch
+                cqc          []C.TSQueryCapture
+                captureIndex C.uint32_t
+        )
+
+        if ok := C.ts_query_cursor_next_capture(qc.c, &cqm, &captureIndex); !bool(ok) {
+                return nil, 0, false
+        }
+
+        qm := &QueryMatch{
+                ID:           uint32(cqm.id),
+                PatternIndex: uint16(cqm.pattern_index),
+        }
+
+        count := int(cqm.capture_count)
+        slice := (*reflect.SliceHeader)((unsafe.Pointer(&cqc)))
+        slice.Cap = count
+        slice.Len = count
+        slice.Data = uintptr(unsafe.Pointer(cqm.captures))
+        for _, c := range cqc {
+                idx := uint32(c.index)
+                node := qc.t.cachedNode(c.node)
+                qm.Captures = append(qm.Captures, QueryCapture{idx, node})
+        }
+
+        return qm, uint32(captureIndex), true
+}
+
+// Copied From: https://github.com/klothoplatform/go-tree-sitter/commit/e351b20167b26d515627a4a1a884528ede5fef79
+
+func splitPredicates(steps []QueryPredicateStep) [][]QueryPredicateStep {
+        var predicateSteps [][]QueryPredicateStep
+        var currentSteps []QueryPredicateStep
+        for _, step := range steps {
+                currentSteps = append(currentSteps, step)
+                if step.Type == QueryPredicateStepTypeDone {
+                        predicateSteps = append(predicateSteps, currentSteps)
+                        currentSteps = []QueryPredicateStep{}
+                }
+        }
+        return predicateSteps
+}
+
+func (qc *QueryCursor) FilterPredicates(m *QueryMatch, input []byte) *QueryMatch {
+        qm := &QueryMatch{
+                ID:           m.ID,
+                PatternIndex: m.PatternIndex,
+        }
+
+        q := qc.q
+
+        predicates := q.PredicatesForPattern(uint32(qm.PatternIndex))
+        if len(predicates) == 0 {
+                qm.Captures = m.Captures
+                return qm
+        }
+
+        // track if we matched all predicates globally
+        matchedAll := true
+
+        // check each predicate against the match
+        for _, steps := range predicates {
+                operator := q.StringValueForId(steps[0].ValueId)
+
+                switch operator {
+                case "eq?", "not-eq?":
+                        isPositive := operator == "eq?"
+
+                        expectedCaptureNameLeft := q.CaptureNameForId(steps[1].ValueId)
+
+                        if steps[2].Type == QueryPredicateStepTypeCapture {
+                                expectedCaptureNameRight := q.CaptureNameForId(steps[2].ValueId)
+
+                                var nodeLeft, nodeRight *Node
+
+                                for _, c := range m.Captures {
+                                        captureName := q.CaptureNameForId(c.Index)
+
+                                        if captureName == expectedCaptureNameLeft {
+                                                nodeLeft = c.Node
+                                        }
+                                        if captureName == expectedCaptureNameRight {
+                                                nodeRight = c.Node
+                                        }
+
+                                        if nodeLeft != nil && nodeRight != nil {
+                                                if (nodeLeft.Content(input) == nodeRight.Content(input)) != isPositive {
+                                                        matchedAll = false
+                                                }
+                                                break
+                                        }
+                                }
+                        } else {
+                                expectedValueRight := q.StringValueForId(steps[2].ValueId)
+
+                                for _, c := range m.Captures {
+                                        captureName := q.CaptureNameForId(c.Index)
+
+                                        if expectedCaptureNameLeft != captureName {
+                                                continue
+                                        }
+
+                                        if (c.Node.Content(input) == expectedValueRight) != isPositive {
+                                                matchedAll = false
+                                                break
+                                        }
+                                }
+                        }
+
+                        if matchedAll == false {
+                                break
+                        }
+
+                case "match?", "not-match?":
+                        isPositive := operator == "match?"
+
+                        expectedCaptureName := q.CaptureNameForId(steps[1].ValueId)
+                        regex := regexp.MustCompile(q.StringValueForId(steps[2].ValueId))
+
+                        for _, c := range m.Captures {
+                                captureName := q.CaptureNameForId(c.Index)
+                                if expectedCaptureName != captureName {
+                                        continue
+                                }
+
+                                if regex.Match([]byte(c.Node.Content(input))) != isPositive {
+                                        matchedAll = false
+                                        break
+                                }
+                        }
+                }
+        }
+
+        if matchedAll {
+                qm.Captures = append(qm.Captures, m.Captures...)
+        }
+
+        return qm
+
+}
+
+// keeps callbacks for parser.parse method
+type readFuncsMap struct {
+        sync.Mutex
+
+        funcs map[int]ReadFunc
+        count int
+}
+
+func (m *readFuncsMap) register(f ReadFunc) int {
+        m.Lock()
+        defer m.Unlock()
+
+        m.count++
+        m.funcs[m.count] = f
+        return m.count
+}
+
+func (m *readFuncsMap) unregister(id int) {
+        m.Lock()
+        defer m.Unlock()
+
+        delete(m.funcs, id)
+}
+
+func (m *readFuncsMap) get(id int) ReadFunc {
+        m.Lock()
+        defer m.Unlock()
+
+        return m.funcs[id]
+}
+
+//export callReadFunc
+func callReadFunc(id C.int, byteIndex C.uint32_t, position C.TSPoint, bytesRead *C.uint32_t) *C.char {
+        readFunc := readFuncs.get(int(id))
+        content := readFunc(uint32(byteIndex), Point{
+                Row:    uint32(position.row),
+                Column: uint32(position.column),
+        })
+        *bytesRead = C.uint32_t(len(content))
+
+        // Note: This memory is freed inside the C code; see bindings.c
+        input := C.CBytes(content)
+        return (*C.char)(input)
+}