Struct Go 

pub struct Go;

Go language support.

Trait Implementations

impl Language for Go

fn name(&self) -> &'static str

Display name for this language (e.g., “Python”, “C++”)

fn extensions(&self) -> &'static [&'static str]

File extensions this language handles (e.g., [“py”, “pyi”, “pyw”])

fn grammar_name(&self) -> &'static str

Grammar name for arborium (e.g., “python”, “rust”)

fn has_symbols(&self) -> bool

Whether this language has code symbols (functions, classes, etc.)

fn container_kinds(&self) -> &'static [&'static str]

Container nodes that can hold methods (class, impl, module)

fn function_kinds(&self) -> &'static [&'static str]

Function/method definition nodes

fn type_kinds(&self) -> &'static [&'static str]

Type definition nodes (struct, enum, interface, type alias)

fn import_kinds(&self) -> &'static [&'static str]

Import statement nodes

fn public_symbol_kinds(&self) -> &'static [&'static str]

AST node kinds that may contain publicly visible symbols. For JS/TS: export_statement nodes. For Go/Java/Python: function/class/type declaration nodes. The extract_public_symbols() method filters by actual visibility.

fn visibility_mechanism(&self) -> VisibilityMechanism

How this language determines symbol visibility

fn scope_creating_kinds(&self) -> &'static [&'static str]

Nodes that create new variable scopes (for scope analysis) Includes: loops, blocks, comprehensions, lambdas, with statements Note: Functions and containers (from function_kinds/container_kinds) also create scopes

fn control_flow_kinds(&self) -> &'static [&'static str]

Nodes that affect control flow (for CFG analysis) Includes: if, for, while, return, break, continue, try, match

fn complexity_nodes(&self) -> &'static [&'static str]

Nodes that increase cyclomatic complexity

fn nesting_nodes(&self) -> &'static [&'static str]

Nodes that indicate nesting depth

fn signature_suffix(&self) -> &'static str

Suffix to append to signatures for tree-sitter parsing. Function signatures are incomplete code fragments that need closing tokens to parse correctly (e.g., Rust fn foo() needs {}, Lua function foo() needs end). Returns the suffix to append, or empty string if none needed.

fn extract_function( &self, node: &Node<'_>, content: &str, in_container: bool, ) -> Option<Symbol>

Extract symbol from a function/method node

fn extract_container(&self, _node: &Node<'_>, _content: &str) -> Option<Symbol>

Extract symbol from a container node (class, impl, module)

fn extract_type(&self, node: &Node<'_>, content: &str) -> Option<Symbol>

Extract symbol from a type definition node

fn extract_imports(&self, node: &Node<'_>, content: &str) -> Vec<Import>

Extract imports from an import node (may return multiple)

fn format_import(&self, import: &Import, _names: Option<&[&str]>) -> String

Format an import as source code. If names is Some, only include those names (for multi-import filtering). If names is None, format the complete import.

fn extract_public_symbols(&self, node: &Node<'_>, content: &str) -> Vec<Export>

Extract public symbols from a node. The node is one of the kinds from public_symbol_kinds(). For JS/TS: extracts exported names from export statements. For Go/Java/Python: checks visibility and returns public symbols.

fn is_public(&self, node: &Node<'_>, content: &str) -> bool

Check if a node is public/exported

fn get_visibility(&self, node: &Node<'_>, content: &str) -> Visibility

Get visibility of a node

fn is_test_symbol(&self, symbol: &Symbol) -> bool

Check if a symbol is a test (for filtering). Each language must implement this - test conventions are language-specific.

fn embedded_content( &self, _node: &Node<'_>, _content: &str, ) -> Option<EmbeddedBlock>

Extract embedded content from a node (e.g., JS/CSS in Vue/HTML). Returns None for nodes that don’t contain embedded code in another language.

fn extract_docstring(&self, _node: &Node<'_>, _content: &str) -> Option<String>

Extract docstring/doc comment for a node

fn extract_attributes(&self, _node: &Node<'_>, _content: &str) -> Vec<String>

Extract attributes/decorators for a node (e.g., #test, @Test)

fn container_body<'a>(&self, node: &'a Node<'a>) -> Option<Node<'a>>

Find the body node of a container (for prepend/append)

fn body_has_docstring(&self, _body: &Node<'_>, _content: &str) -> bool

Detect if first child of body is a docstring

fn node_name<'a>(&self, node: &Node<'_>, content: &'a str) -> Option<&'a str>

Get the name of a node (typically via “name” field)

fn file_path_to_module_name(&self, path: &Path) -> Option<String>

Convert a file path to a module name for this language. Used to find “importers” - files that import a given file. Returns None for languages without module systems or where not applicable.

fn module_name_to_paths(&self, module: &str) -> Vec<String>

Convert a module name to candidate file paths (inverse of file_path_to_module_name). Returns relative paths that could contain the module. Used for wildcard import resolution (e.g., from foo import *).

fn lang_key(&self) -> &'static str

Language key for package index cache (e.g., “python”, “go”, “js”).

fn resolve_local_import( &self, import_path: &str, current_file: &Path, _project_root: &Path, ) -> Option<PathBuf>

Resolve a local import within the project.

fn resolve_external_import( &self, import_name: &str, _project_root: &Path, ) -> Option<ResolvedPackage>

Resolve an external import to its source location.

fn is_stdlib_import(&self, import_name: &str, _project_root: &Path) -> bool

Check if an import is from the standard library.

fn get_version(&self, _project_root: &Path) -> Option<String>

Get the language/runtime version (for package index versioning).

fn find_package_cache(&self, _project_root: &Path) -> Option<PathBuf>

Find package cache/installation directory.

fn indexable_extensions(&self) -> &'static [&'static str]

File extensions to index when caching a package.

fn find_stdlib(&self, _project_root: &Path) -> Option<PathBuf>

Find standard library directory (if applicable). Returns None for languages without a separate stdlib to index.

fn package_sources(&self, project_root: &Path) -> Vec<PackageSource>

Return package sources to index for this language. Each source describes a directory containing packages.

fn should_skip_package_entry(&self, name: &str, is_dir: bool) -> bool

Should this entry be skipped when indexing packages? Called for each file/directory in package directories. Use helper functions skip_dotfiles() and has_extension(name, self.indexable_extensions()) for common checks.

fn package_module_name(&self, entry_name: &str) -> String

Get the module/package name from a directory entry name.

fn discover_packages(&self, source: &PackageSource) -> Vec<(String, PathBuf)>

Discover packages in a source directory. Returns (package_name, path) pairs for all packages found. Use provided helpers: discover_flat_packages, discover_recursive_packages, discover_npm_scoped_packages.

fn find_package_entry(&self, path: &Path) -> Option<PathBuf>

Find the entry point file for a package path. If path is a file, returns it directly. If path is a directory, looks for language-specific entry points.

fn discover_flat_packages(&self, source_path: &Path) -> Vec<(String, PathBuf)>

Discover packages in a flat directory (each entry is a package).

fn discover_recursive_packages( &self, base_path: &Path, current_path: &Path, ) -> Vec<(String, PathBuf)>

Discover packages recursively (each file with matching extension is a package).

fn discover_npm_scoped_packages( &self, source_path: &Path, ) -> Vec<(String, PathBuf)>

Discover packages in npm-scoped directory (handles @scope/package).