Struct tree_sitter_stack_graphs::loader::Loader

pub struct Loader(_);

The loader is created from either a tree-sitter configuration or a list of search paths, and an optional scope and search paths for stack graphs definitions and builtins; or a list of language configurations.

The loader is called with a file path and optional file content and tries to find the language for that file. The loader will search for tree-sitter languages in the given search paths, or in current directory and the paths defined in the tree-sitter configuration. If a scope is provided, it will be used to restrict the discovered languages to those with a matching scope. If no languages were found at all, an error is raised. Otherwise, a language matching the file path and content is returned, if it exists among the discovered languages.

The paths for stack graphs definitions and builtins can be regular or relative to the grammar directory. Paths may omit file extensions, in which case any supported file extension will be tried. The first path that exists will be selected. It is considered an error if no stack graphs definitions is found. Builtins are always optional.

Previously loaded languages are cached in the loader, so subsequent loads are fast.

Implementations

impl Loader

pub fn from_paths(
    paths: Vec<PathBuf>,
    scope: Option<String>,
    tsg_paths: Vec<LoadPath>,
    builtins_paths: Vec<LoadPath>
) -> Result<Self, LoadError>

pub fn from_tree_sitter_configuration(
    config: &TsConfig,
    scope: Option<String>,
    tsg_paths: Vec<LoadPath>,
    builtins_paths: Vec<LoadPath>
) -> Result<Self, LoadError>

pub fn from_language_configurations(
    configurations: Vec<LanguageConfiguration>,
    scope: Option<String>
) -> Result<Self, LoadError>

pub fn load_tree_sitter_language_for_file(
    &mut self,
    path: &Path,
    content: Option<&str>
) -> Result<Option<Language>, LoadError>

Load a Tree-sitter language for the given file. Loading is based on the loader configuration and the given file path. Most users should use Self::load_for_file, but this method can be useful if only the underlying Tree-sitter language is necessary, as it will not attempt to load the TSG file.

pub fn load_for_file(
    &mut self,
    path: &Path,
    content: Option<&str>,
    cancellation_flag: &dyn CancellationFlag
) -> Result<Option<&LanguageConfiguration>, LoadError>

Load a stack graph language for the given file. Loading is based on the loader configuration and the given file path.

pub fn load_globals_from_config_path(
    path: &Path,
    globals: &mut Variables<'_>
) -> Result<(), LoadError>

pub fn load_globals_from_config_str(
    config: &str,
    globals: &mut Variables<'_>
) -> Result<(), LoadError>