C API Reference

C API Reference v1.9.1¶

Functions¶

ts_pack_detect_language_from_extension()¶

Detect language name from a file extension (without leading dot).

Returns NULL for unrecognized extensions. The match is case-insensitive.

Signature:

const char** ts_pack_detect_language_from_extension(const char* ext);

Example:

const char** result = ts_pack_detect_language_from_extension("value");

Parameters:

Returns: const char**

ts_pack_detect_language_from_path()¶

Detect language name from a file path.

Extracts the file extension and looks it up. Returns NULL if the path has no extension or the extension is not recognized.

Signature:

const char** ts_pack_detect_language_from_path(const char* path);

Example:

const char** result = ts_pack_detect_language_from_path("value");

Parameters:

Returns: const char**

ts_pack_detect_language_from_content()¶

Detect language name from file content using the shebang line (#!).

Inspects only the first line of content. If it begins with #!, the interpreter name is extracted and mapped to a language name.

Handles common patterns:

• #!/usr/bin/env python3 → "python"
• #!/bin/bash → "bash"
• #!/usr/bin/env node → "javascript"

The -S flag accepted by some env implementations is skipped automatically. Version suffixes (e.g. python3.11, ruby3.2) are stripped before matching.

Returns NULL when content does not start with #!, the shebang is malformed, or the interpreter is not recognised.

Signature:

const char** ts_pack_detect_language_from_content(const char* content);

Example:

const char** result = ts_pack_detect_language_from_content("value");

Parameters:

Returns: const char**

ts_pack_get_highlights_query()¶

Get the highlights query for a language, if bundled.

Returns the contents of highlights.scm as a static string, or NULL if no highlights query is bundled for this language.

Signature:

const char** ts_pack_get_highlights_query(const char* language);

Example:

const char** result = ts_pack_get_highlights_query("value");

Parameters:

Returns: const char**

ts_pack_get_injections_query()¶

Get the injections query for a language, if bundled.

Returns the contents of injections.scm as a static string, or NULL if no injections query is bundled for this language.

Signature:

const char** ts_pack_get_injections_query(const char* language);

Example:

const char** result = ts_pack_get_injections_query("value");

Parameters:

Returns: const char**

ts_pack_get_locals_query()¶

Get the locals query for a language, if bundled.

Returns the contents of locals.scm as a static string, or NULL if no locals query is bundled for this language.

Signature:

const char** ts_pack_get_locals_query(const char* language);

Example:

const char** result = ts_pack_get_locals_query("value");

Parameters:

Returns: const char**

ts_pack_get_tags_query()¶

Get the tags query for a language, if bundled.

Returns the contents of tags.scm as a static string, or NULL if no tags query is bundled for this language.

Signature:

const char** ts_pack_get_tags_query(const char* language);

Example:

const char** result = ts_pack_get_tags_query("value");

Parameters:

Returns: const char**

ts_pack_get_language()¶

Get a tree-sitter Language by name using the global registry.

Resolves language aliases (e.g., "shell" maps to "bash"). When the download feature is enabled (default), automatically downloads the parser from GitHub releases if not found locally.

Errors:

Returns Error.LanguageNotFound if the language is not recognized, or Error.Download if auto-download fails.

Signature:

TsPackLanguage* ts_pack_get_language(const char* name);

Example:

TsPackLanguage *result = ts_pack_get_language("value");

Parameters:

Returns: TsPackLanguage

Errors: Returns NULL on error.

ts_pack_get_parser()¶

Get a Parser pre-configured for the given language.

This is a convenience function that calls get_language and configures a new parser in one step.

Errors:

Returns Error.LanguageNotFound if the language is not recognized, or Error.ParserSetup if the language cannot be applied to the parser.

Signature:

TsPackParser* ts_pack_get_parser(const char* name);

Example:

TsPackParser *result = ts_pack_get_parser("value");

Parameters:

Returns: TsPackParser

Errors: Returns NULL on error.

ts_pack_detect_language()¶

Detect language name from a file path or extension.

This compatibility alias matches the pre-Alef Python binding API.

Signature:

const char** ts_pack_detect_language(const char* path);

Example:

const char** result = ts_pack_detect_language("value");

Parameters:

Returns: const char**

ts_pack_available_languages()¶

List all available language names (sorted, deduplicated, includes aliases).

Returns names of both statically compiled and dynamically loadable languages, plus any configured aliases.

Signature:

const char** ts_pack_available_languages();

Example:

const char** result = ts_pack_available_languages();

Returns: const char**

ts_pack_has_language()¶

Check if a language is available by name or alias.

Returns true if the language can be loaded (statically compiled, dynamically available, or a known alias for one of these).

Signature:

bool ts_pack_has_language(const char* name);

Example:

bool result = ts_pack_has_language("value");

Parameters:

Returns: bool

ts_pack_language_count()¶

Return the number of available languages.

Includes statically compiled languages, dynamically loadable languages, and aliases.

Signature:

uintptr_t ts_pack_language_count();

Example:

uintptr_t result = ts_pack_language_count();

Returns: uintptr_t

ts_pack_process()¶

Process source code and extract file intelligence using the global registry.

Parses the source with tree-sitter and extracts metrics, structure, imports, exports, comments, docstrings, symbols, diagnostics, and/or chunks based on the flags set in ProcessConfig.

Errors:

Returns an error if the language is not found or parsing fails.

Signature:

TsPackProcessResult* ts_pack_process(const char* source, TsPackProcessConfig config);

Example:

TsPackProcessResult *result = ts_pack_process("value", NULL);

Parameters:

Returns: TsPackProcessResult

Errors: Returns NULL on error.

ts_pack_init()¶

Initialize the language pack with the given configuration.

Applies any custom cache directory, then downloads all languages and groups specified in the config. This is the recommended entry point when you want to pre-warm the cache before use.

Errors:

Returns an error if configuration cannot be applied or if downloads fail.

Signature:

void ts_pack_init(TsPackPackConfig config);

Example:

ts_pack_init(NULL);

Parameters:

Returns: No return value.

Errors: Returns NULL on error.

ts_pack_configure()¶

Apply download configuration without downloading anything.

Use this to set a custom cache directory before the first call to get_language or any download function. Changing the cache dir after languages have been registered has no effect on already-loaded languages.

Errors:

Returns an error if the lock cannot be acquired.

Signature:

void ts_pack_configure(TsPackPackConfig config);

Example:

ts_pack_configure(NULL);

Parameters:

Returns: No return value.

Errors: Returns NULL on error.

ts_pack_download()¶

Download specific languages to the local cache.

Returns the number of requested languages available after the call. Already compiled or cached languages are included in the count.

Errors:

Returns an error if any language is not available in the manifest or if the download fails.

Signature:

uintptr_t ts_pack_download(const char** names);

Example:

uintptr_t result = ts_pack_download(NULL);

Parameters:

Returns: uintptr_t

Errors: Returns NULL on error.

ts_pack_download_all()¶

Download all available languages from the remote manifest.

Downloads the platform bundle and extracts every library it contains. Languages that appear in the manifest but are absent from the bundle (e.g. grammars that failed to compile at release time) are silently skipped — they are not treated as an error.

Returns the total number of languages now available (statically compiled plus downloaded and cached).

Errors:

Returns an error if the manifest cannot be fetched or the bundle download fails.

Signature:

uintptr_t ts_pack_download_all();

Example:

uintptr_t result = ts_pack_download_all();

Returns: uintptr_t

Errors: Returns NULL on error.

ts_pack_download_group()¶

Download every language in a named group (e.g. "web", "data").

Groups are defined in the remote manifest and let you ensure a curated set of related grammars in one call instead of listing each name to download(). Already-cached languages are skipped.

Returns the total number of languages now available (statically compiled plus downloaded and cached).

Errors:

Returns an error if the manifest cannot be fetched, the group is unknown, or any constituent language fails to download.

Signature:

uintptr_t ts_pack_download_group(const char* name);

Example:

uintptr_t result = ts_pack_download_group("value");

Parameters:

Returns: uintptr_t

Errors: Returns NULL on error.

ts_pack_manifest_languages()¶

Return all language names available in the remote manifest (306).

Fetches (and caches) the remote manifest to discover the full list of downloadable languages. Use downloaded_languages to list what is already cached locally.

Errors:

Returns an error if the manifest cannot be fetched.

Signature:

const char** ts_pack_manifest_languages();

Example:

const char** result = ts_pack_manifest_languages();

Returns: const char**

Errors: Returns NULL on error.

ts_pack_downloaded_languages()¶

Return languages that are already downloaded and cached locally.

Does not perform any network requests. Returns an empty list if the cache directory does not exist or cannot be read.

Signature:

const char** ts_pack_downloaded_languages();

Example:

const char** result = ts_pack_downloaded_languages();

Returns: const char**

ts_pack_clean_cache()¶

Delete all cached parser shared libraries.

Resets the cache registration so the next call to get_language or a download function will re-register the (now empty) cache directory.

Errors:

Returns an error if the cache directory cannot be removed.

Signature:

void ts_pack_clean_cache();

Example:

ts_pack_clean_cache();

Returns: No return value.

Errors: Returns NULL on error.

ts_pack_cache_dir()¶

Return the effective cache directory path.

This is either the custom path set via configure / init or the default: ~/.cache/tree-sitter-language-pack/v{version}/libs/.

Errors:

Returns an error if the system cache directory cannot be determined.

Signature:

const char* ts_pack_cache_dir();

Example:

const char *result = ts_pack_cache_dir();

Returns: const char*

Errors: Returns NULL on error.

Types¶

TsPackByteRange¶

A byte range — start (inclusive) to end (exclusive).

TsPackChunkContext¶

Metadata for a single chunk of source code.

TsPackCodeChunk¶

A chunk of source code with rich metadata.

TsPackCommentInfo¶

A comment extracted from source code.

TsPackDataAttribute¶

An XML-style attribute attached to an Element node.

Populated only for DataNodeKind.Element; always empty for KeyValue and Sequence nodes.

TsPackDataNode¶

A node in the hierarchical data tree produced by data-format extraction.

When ProcessConfig.data_extraction is true, ProcessResult.data is populated with a root DataNode whose children mirror the structure of the parsed file.

The kind field determines which other fields are meaningful:

TsPackDiagnostic¶

A diagnostic (syntax error, missing node, etc.) from parsing.

TsPackDocSection¶

A section within a docstring (e.g., Args, Returns, Raises).

TsPackDocstringInfo¶

A docstring extracted from source code.

TsPackDownloadManager¶

Manages downloading and caching of pre-built parser shared libraries.

Methods¶

ts_pack_new()¶

Create a new download manager for the given version.

Signature:

TsPackDownloadManager ts_pack_new(const char* version);

Example:

TsPackDownloadManager *result = ts_pack_new("value");

Parameters:

Returns: TsPackDownloadManager

Errors: Returns NULL on error.

ts_pack_installed_languages()¶

List languages that are already downloaded and cached.

Signature:

const char** ts_pack_installed_languages();

Example:

const char** result = ts_pack_installed_languages(instance);

Returns: const char**

ts_pack_download_all_best_effort()¶

Download the platform bundle and extract every library file it contains.

Unlike Self.ensure_languages, this does not check the manifest language list against archive contents — it simply extracts all .so/.dylib/.dll files from the bundle. Languages in the manifest that are missing from the archive are silently ignored rather than returning an error.

Returns the number of library files extracted (including those already cached).

Signature:

uintptr_t ts_pack_download_all_best_effort();

Example:

uintptr_t result = ts_pack_download_all_best_effort(instance);

Returns: uintptr_t

Errors: Returns NULL on error.

ts_pack_clean_cache()¶

Remove all cached parser libraries.

Acquires the cross-process lock so clean_cache cannot race a concurrent downloader (avoids Windows sharing-violation errors against an in-flight bundle write). The .download.lock file itself is not removed — it is permanent infrastructure; deleting it could allow a concurrent process that already opened the file to continue holding a stale lock handle while a new process opens a fresh inode, breaking the mutual-exclusion guarantee.

Signature:

void ts_pack_clean_cache();

Example:

ts_pack_clean_cache(instance);

Returns: No return value.

Errors: Returns NULL on error.

TsPackExportInfo¶

An export statement extracted from source code.

TsPackFileMetrics¶

Aggregate metrics for a source file.

TsPackImportInfo¶

An import statement extracted from source code.

TsPackLanguage¶

TsPackLanguageRegistry¶

Thread-safe registry of tree-sitter language parsers.

Manages both statically compiled and dynamically loaded language grammars. Use LanguageRegistry.new() for the default registry, or access the global instance via the module-level convenience functions (get_language, available_languages, etc.).

Methods¶

ts_pack_new()¶

Create a new registry populated with all statically compiled languages.

When the dynamic-loading feature is enabled, the registry also knows about dynamically loadable grammars and will load them on demand.

Signature:

TsPackLanguageRegistry ts_pack_new();

Example:

TsPackLanguageRegistry *result = ts_pack_new();

Returns: TsPackLanguageRegistry

ts_pack_get_language()¶

Get a tree-sitter Language by name.

Resolves aliases (e.g., "shell" -> "bash", "makefile" -> "make"), then looks up the language in the static table. When the dynamic-loading feature is enabled, falls back to loading a shared library on demand.

Errors:

Returns Error.LanguageNotFound if the name (after alias resolution) does not match any known grammar.

Signature:

TsPackLanguage ts_pack_get_language(const char* name);

Example:

TsPackLanguage *result = ts_pack_get_language(instance, "value");

Parameters:

Returns: TsPackLanguage

Errors: Returns NULL on error.

ts_pack_available_languages()¶

List all available language names, sorted and deduplicated.

Includes statically compiled languages, dynamically loadable languages (if the dynamic-loading feature is enabled), and all configured aliases.

Signature:

const char** ts_pack_available_languages();

Example:

const char** result = ts_pack_available_languages(instance);

Returns: const char**

ts_pack_has_parser()¶

Check whether a parser is statically compiled into this build.

Returns true only when the grammar was compiled in at build time (i.e. it appears in the STATIC_LANGUAGES table). This is independent of the extension-to-language mapping: detect_language_from_extension consults the static ext table for all 306 grammars regardless of which parsers are compiled in.

Use this when you need to distinguish "we know the language name" from "we can actually parse files in that language right now".

use tree_sitter_language_pack::{detect_language_from_extension, LanguageRegistry};

let registry = LanguageRegistry::new();
// Extension detection uses the static table — independent of compiled parsers.
let lang = detect_language_from_extension("feature"); // always returns Some("gherkin")
// Parser availability depends on which grammars were compiled in.
let can_parse = lang.map(|name| registry.has_parser(name)).unwrap_or(false);

Signature:

bool ts_pack_has_parser(const char* name);

Example:

bool result = ts_pack_has_parser(instance, "value");

Parameters:

Returns: bool

ts_pack_has_language()¶

Check whether a language is available by name or alias.

Returns true if the language can be loaded, either from the static table or from a dynamic library on disk.

Signature:

bool ts_pack_has_language(const char* name);

Example:

bool result = ts_pack_has_language(instance, "value");

Parameters:

Returns: bool

ts_pack_language_count()¶

Return the total number of available languages (including aliases).

Signature:

uintptr_t ts_pack_language_count();

Example:

uintptr_t result = ts_pack_language_count(instance);

Returns: uintptr_t

ts_pack_process()¶

Parse source code and extract file intelligence based on config in a single pass.

Signature:

TsPackProcessResult ts_pack_process(const char* source, TsPackProcessConfig config);

Example:

TsPackProcessResult *result = ts_pack_process(instance, "value", NULL);

Parameters:

Returns: TsPackProcessResult

Errors: Returns NULL on error.

ts_pack_default()¶

Signature:

TsPackLanguageRegistry ts_pack_default();

Example:

TsPackLanguageRegistry *result = ts_pack_default();

Returns: TsPackLanguageRegistry

TsPackNode¶

A single syntax node within a Tree.

Nodes hold a strong reference to their parent tree so they remain valid regardless of how the tree is moved or stored at the FFI boundary.

Methods¶

ts_pack_clone()¶

Signature:

TsPackNode ts_pack_clone();

Example:

TsPackNode *result = ts_pack_clone(instance);

Returns: TsPackNode

ts_pack_kind()¶

Return the node's kind name (e.g. "function_definition").

Signature:

const char* ts_pack_kind();

Example:

const char *result = ts_pack_kind(instance);

Returns: const char*

ts_pack_kind_id()¶

Return the node's numeric kind ID.

Tree-sitter assigns a stable u16 ID to every node kind in a grammar (e.g. "function_definition" → 42). Comparing kind_id() is cheaper than comparing the string kind() in tight AST loops.

Signature:

uint16_t ts_pack_kind_id();

Example:

uint16_t result = ts_pack_kind_id(instance);

Returns: uint16_t

ts_pack_start_byte()¶

Return the inclusive start byte offset of this node.

Signature:

uintptr_t ts_pack_start_byte();

Example:

uintptr_t result = ts_pack_start_byte(instance);

Returns: uintptr_t

ts_pack_end_byte()¶

Return the exclusive end byte offset of this node.

Signature:

uintptr_t ts_pack_end_byte();

Example:

uintptr_t result = ts_pack_end_byte(instance);

Returns: uintptr_t

ts_pack_byte_range()¶

Return the node's byte range as a ByteRange.

Callers should slice their own source bytes — this is a zero-copy text accessor.

Signature:

TsPackByteRange ts_pack_byte_range();

Example:

TsPackByteRange *result = ts_pack_byte_range(instance);

Returns: TsPackByteRange

ts_pack_start_position()¶

Return the start Point (row, column).

Signature:

TsPackPoint ts_pack_start_position();

Example:

TsPackPoint *result = ts_pack_start_position(instance);

Returns: TsPackPoint

ts_pack_end_position()¶

Return the end Point (row, column).

Signature:

TsPackPoint ts_pack_end_position();

Example:

TsPackPoint *result = ts_pack_end_position(instance);

Returns: TsPackPoint

ts_pack_is_named()¶

True when this node is named (not punctuation/whitespace).

Signature:

bool ts_pack_is_named();

Example:

bool result = ts_pack_is_named(instance);

Returns: bool

ts_pack_is_error()¶

True when this is an error node.

Signature:

bool ts_pack_is_error();

Example:

bool result = ts_pack_is_error(instance);

Returns: bool

ts_pack_is_missing()¶

True when this is a missing-token node.

Signature:

bool ts_pack_is_missing();

Example:

bool result = ts_pack_is_missing(instance);

Returns: bool

ts_pack_is_extra()¶

True when this is an "extra" node (e.g. a comment).

Signature:

bool ts_pack_is_extra();

Example:

bool result = ts_pack_is_extra(instance);

Returns: bool

ts_pack_has_error()¶

True when this node or any descendant is an error.

Signature:

bool ts_pack_has_error();

Example:

bool result = ts_pack_has_error(instance);

Returns: bool

ts_pack_parent()¶

Return this node's parent, if any.

Signature:

TsPackNode* ts_pack_parent();

Example:

TsPackNode* result = ts_pack_parent(instance);

Returns: TsPackNode*

ts_pack_child()¶

Return the i-th child of this node, if any.

Signature:

TsPackNode* ts_pack_child(uint32_t index);

Example:

TsPackNode* result = ts_pack_child(instance, 42);

Parameters:

Returns: TsPackNode*

ts_pack_child_count()¶

Total number of children (including unnamed).

Signature:

uintptr_t ts_pack_child_count();

Example:

uintptr_t result = ts_pack_child_count(instance);

Returns: uintptr_t

ts_pack_named_child()¶

Return the i-th named child of this node, if any.

Signature:

TsPackNode* ts_pack_named_child(uint32_t index);

Example:

TsPackNode* result = ts_pack_named_child(instance, 42);

Parameters:

Returns: TsPackNode*

ts_pack_named_child_count()¶

Number of named children of this node.

Signature:

uintptr_t ts_pack_named_child_count();

Example:

uintptr_t result = ts_pack_named_child_count(instance);

Returns: uintptr_t

ts_pack_child_by_field_name()¶

Look up a child by its grammar-defined field name.

Signature:

TsPackNode* ts_pack_child_by_field_name(const char* name);

Example:

TsPackNode* result = ts_pack_child_by_field_name(instance, "value");

Parameters:

Returns: TsPackNode*

ts_pack_to_sexp()¶

Return the S-expression form of this node's subtree.

Signature:

const char* ts_pack_to_sexp();

Example:

const char *result = ts_pack_to_sexp(instance);

Returns: const char*

ts_pack_walk()¶

Return a TreeCursor positioned at this node.

Signature:

TsPackTreeCursor ts_pack_walk();

Example:

TsPackTreeCursor *result = ts_pack_walk(instance);

Returns: TsPackTreeCursor

TsPackPackConfig¶

Configuration for the tree-sitter language pack.

Controls cache directory and which languages to pre-download. Can be loaded from a TOML file, constructed programmatically, or passed as a dict/object from language bindings.

TsPackParser¶

A tree-sitter parser configured for one language at a time.

Methods¶

ts_pack_new()¶

Construct a new parser with no language set.

Call Parser.set_language before parsing.

Signature:

TsPackParser ts_pack_new();

Example:

TsPackParser *result = ts_pack_new();

Returns: TsPackParser

ts_pack_set_language()¶

Configure the parser to use the language identified by name (e.g. "python").

Resolves the language through the global registry — auto-downloading if necessary, when the download feature is enabled.

Errors:

Returns Error.LanguageNotFound if the language is not recognized, or Error.ParserSetup if the language ABI is incompatible.

Signature:

void ts_pack_set_language(const char* name);

Example:

ts_pack_set_language(instance, "value");

Parameters:

Returns: No return value.

Errors: Returns NULL on error.

ts_pack_parse()¶

Parse a UTF-8 source string. Returns NULL if parsing was cancelled or no language is set.

Signature:

TsPackTree* ts_pack_parse(const char* source);

Example:

TsPackTree* result = ts_pack_parse(instance, "value");

Parameters:

Returns: TsPackTree*

ts_pack_parse_bytes()¶

Parse a raw byte slice. Returns NULL if parsing was cancelled or no language is set.

Signature:

TsPackTree* ts_pack_parse_bytes(const uint8_t* source);

Example:

TsPackTree* result = ts_pack_parse_bytes(instance, (const uint8_t *)"data");

Parameters:

Returns: TsPackTree*

ts_pack_reset()¶

Reset internal state. The next call to parse will not be incremental.

Signature:

void ts_pack_reset();

Example:

ts_pack_reset(instance);

Returns: No return value.

ts_pack_default()¶

Signature:

TsPackParser ts_pack_default();

Example:

TsPackParser *result = ts_pack_default();

Returns: TsPackParser

TsPackPoint¶

A source position — row + column, zero-indexed.

TsPackProcessConfig¶

Configuration for the process() function.

Controls which analysis features are enabled and whether chunking is performed.

Methods¶

ts_pack_default()¶

Signature:

TsPackProcessConfig ts_pack_default();

Example:

TsPackProcessConfig *result = ts_pack_default();

Returns: TsPackProcessConfig

ts_pack_with_chunking()¶

Enable chunking with the given maximum chunk size in bytes.

Signature:

TsPackProcessConfig ts_pack_with_chunking(uintptr_t max_size);

Example:

TsPackProcessConfig *result = ts_pack_with_chunking(instance, 42);

Parameters:

Returns: TsPackProcessConfig

ts_pack_all()¶

Enable all analysis features.

Signature:

TsPackProcessConfig ts_pack_all();

Example:

TsPackProcessConfig *result = ts_pack_all(instance);

Returns: TsPackProcessConfig

ts_pack_minimal()¶

Disable all analysis features (only metrics computed).

Signature:

TsPackProcessConfig ts_pack_minimal();

Example:

TsPackProcessConfig *result = ts_pack_minimal(instance);

Returns: TsPackProcessConfig

ts_pack_with_data_extraction()¶

Enable or disable hierarchical data extraction for data-format files.

When true, ProcessResult.data is populated with a key/value tree for supported data-format languages.

Signature:

TsPackProcessConfig ts_pack_with_data_extraction(bool enabled);

Example:

TsPackProcessConfig *result = ts_pack_with_data_extraction(instance, true);

Parameters:

Returns: TsPackProcessConfig

TsPackProcessResult¶

Complete analysis result from processing a source file.

Contains metrics, structural analysis, imports/exports, comments, docstrings, symbols, diagnostics, and optionally chunked code segments. Fields are populated based on the ProcessConfig flags.

TsPackSpan¶

Byte and line/column range in source code.

Represents both byte offsets (for slicing) and human-readable line/column positions (for display and diagnostics).

TsPackStructureItem¶

A structural item (function, class, struct, etc.) in source code.

TsPackSymbolInfo¶

A symbol (variable, function, type, etc.) extracted from source code.

TsPackTree¶

A parsed syntax tree. Cheap to clone (refcount bump).

Methods¶

ts_pack_root_node()¶

Return the root Node of this tree.

Signature:

TsPackNode ts_pack_root_node();

Example:

TsPackNode *result = ts_pack_root_node(instance);

Returns: TsPackNode

ts_pack_walk()¶

Return a TreeCursor positioned at the root.

Signature:

TsPackTreeCursor ts_pack_walk();

Example:

TsPackTreeCursor *result = ts_pack_walk(instance);

Returns: TsPackTreeCursor

TsPackTreeCursor¶

A cursor for traversing a Tree.

Methods¶

ts_pack_node()¶

Return the Node at the cursor's current position.

Signature:

TsPackNode ts_pack_node();

Example:

TsPackNode *result = ts_pack_node(instance);

Returns: TsPackNode

ts_pack_goto_first_child()¶

Move the cursor to the first child of the current node. Returns true if a child existed.

Signature:

bool ts_pack_goto_first_child();

Example:

bool result = ts_pack_goto_first_child(instance);

Returns: bool

ts_pack_goto_parent()¶

Move the cursor to the parent of the current node. Returns true if a parent existed.

Signature:

bool ts_pack_goto_parent();

Example:

bool result = ts_pack_goto_parent(instance);

Returns: bool

ts_pack_goto_next_sibling()¶

Move the cursor to the next sibling of the current node. Returns true if a sibling existed.

Signature:

bool ts_pack_goto_next_sibling();

Example:

bool result = ts_pack_goto_next_sibling(instance);

Returns: bool

ts_pack_field_name()¶

Return the field name for the current node, if any.

Signature:

const char** ts_pack_field_name();

Example:

const char** result = ts_pack_field_name(instance);

Returns: const char**

Enums¶

TsPackDataNodeKind¶

The kind of a data node extracted from a data-format file.

Classifies each node in the hierarchical DataNode tree returned when data_extraction is enabled on ProcessConfig.

Wire format (public JSON contract)¶

Unit variants serialize as a bare string ("KeyValue"). DO NOT add #[serde(tag = "...")] or rename variants — every language binding has a hand-written deserializer matching this exact shape, and any change breaks all bindings' process() tests simultaneously. Covered by tests/wire_format.rs.

TsPackStructureKind¶

The kind of structural item found in source code.

Categorizes top-level and nested declarations such as functions, classes, structs, enums, traits, and more. Use Other for language-specific constructs that do not fit a standard category.

Wire format (public JSON contract)¶

Unit variants serialize as a bare string ("Function"); the Other variant serializes as a single-keyed object ({"Other": "macro"}). DO NOT add #[serde(tag = "...")] or rename variants — every language binding has a hand-written deserializer matching this exact shape, and any change breaks all bindings' process() tests simultaneously. Covered by tests/wire_format.rs.

TsPackCommentKind¶

The kind of a comment found in source code.

Distinguishes between single-line comments, block (multi-line) comments, and documentation comments.

TsPackDocstringFormat¶

The format of a docstring extracted from source code.

Identifies the docstring convention used, which varies by language (e.g., Python triple-quoted strings, JSDoc, Rustdoc /// comments).

Wire format (public JSON contract)¶

Unit variants serialize as a bare string ("JSDoc"); the Other variant serializes as a single-keyed object ({"Other": "rst"}). DO NOT add #[serde(tag = "...")]. Covered by tests/wire_format.rs.

TsPackExportKind¶

The kind of an export statement found in source code.

Covers named exports, default exports, and re-exports from other modules.

TsPackSymbolKind¶

The kind of a symbol definition found in source code.

Categorizes symbol definitions such as variables, constants, functions, classes, types, interfaces, enums, and modules.

Wire format (public JSON contract)¶

Unit variants serialize as a bare string ("Function"); the Other variant serializes as a single-keyed object ({"Other": "macro"}). DO NOT add #[serde(tag = "...")]. Covered by tests/wire_format.rs.

TsPackDiagnosticSeverity¶

Severity level of a diagnostic produced during parsing.

Used to classify parse errors, warnings, and informational messages found in the syntax tree.

Errors¶

TsPackError¶

Errors that can occur when using the tree-sitter language pack.

Covers language lookup failures, parse errors, query errors, and I/O issues. Feature-gated variants are included when config, download, or related features are enabled.

Edit this page on GitHub