Struct GoBehavior 

pub struct GoBehavior { /* private fields */ }

Go language behavior implementation

Implementations

impl GoBehavior

pub fn new() -> Self

Create a new Go behavior instance

Trait Implementations

impl Clone for GoBehavior

fn clone(&self) -> GoBehavior

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for GoBehavior

fn default() -> Self

Returns the “default value” for a type.

impl LanguageBehavior for GoBehavior

fn module_path_from_file( &self, file_path: &Path, project_root: &Path, extensions: &[&str], ) -> Option<String>

Get module path for a Go file using resolution rules from go.mod.

Uses cached resolution rules from GoProvider to construct proper Go module paths. Falls back to directory-based path if no rules are available.

fn parse_visibility(&self, signature: &str) -> Visibility

Parse visibility from Go symbol signature using capitalization rules

In Go, visibility is determined by the first character of the identifier:

• Uppercase first letter = Public/Exported (accessible outside package)
• Lowercase first letter = Private/Unexported (package-private)

fn supports_traits(&self) -> bool

Go uses interfaces instead of traits

Go’s interface system provides similar functionality to traits but uses structural typing (duck typing) rather than explicit implementation.

fn supports_inherent_methods(&self) -> bool

Go supports methods on types (inherent methods)

Methods can be defined on any named type using receiver syntax: func (r ReceiverType) MethodName() {}

fn create_resolution_context(&self, file_id: FileId) -> Box<dyn ResolutionScope>

Create a Go-specific resolution context for symbol resolution

Returns a GoResolutionContext that handles Go’s package-based scoping, import resolution, and module system integration.

fn language_id(&self) -> LanguageId

Get the language ID for this behavior

fn format_module_path(&self, base_path: &str, _symbol_name: &str) -> String

Format a module path according to language conventions

fn get_language(&self) -> Language

Get the tree-sitter Language for ABI-15 metadata access

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

Get the module separator for this language

fn format_path_as_module(&self, components: &[&str]) -> Option<String>

Format path components as a module path

fn create_inheritance_resolver(&self) -> Box<dyn InheritanceResolver>

Create a language-specific inheritance resolver

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

Get the inheritance relationship name for this language

fn map_relationship(&self, language_specific: &str) -> RelationKind

Map language-specific relationship to generic RelationKind

fn register_file(&self, path: PathBuf, file_id: FileId, module_path: String)

Register a file with its module path

fn add_import(&self, import: Import)

Add an import to the language’s import tracking

fn get_imports_for_file(&self, file_id: FileId) -> Vec<Import>

Get imports for a file

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

Check if a symbol should be resolvable (added to resolution context)

fn get_module_path_for_file(&self, file_id: FileId) -> Option<String>

Get the module path for a file from behavior state

fn configure_symbol(&self, symbol: &mut Symbol, module_path: Option<&str>)

Configure a symbol with language-specific rules

fn import_matches_symbol( &self, import_path: &str, symbol_module_path: &str, importing_module: Option<&str>, ) -> bool

Check if an import path matches a symbol’s module path

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

Get the source root directories for this language

fn validate_node_kind(&self, node_kind: &str) -> bool

Validate that a node kind exists in this language’s grammar Uses ABI-15 to check if the node type is valid

fn get_abi_version(&self) -> usize

Get the ABI version of the language grammar

fn normalize_caller_name(&self, name: &str, _file_id: FileId) -> String

Normalize a caller name before resolution.

fn add_trait_impl( &self, _type_name: String, _trait_name: String, _file_id: FileId, )

Add a trait/interface implementation

fn add_inherent_methods(&self, _type_name: String, _methods: Vec<String>)

Add inherent methods for a type

fn add_trait_methods(&self, _trait_name: String, _methods: Vec<String>)

Add methods that a trait/interface defines

fn resolve_method_trait(&self, _type_name: &str, _method: &str) -> Option<&str>

Resolve which trait/interface provides a method

fn format_method_call(&self, receiver: &str, method: &str) -> String

Format a method call for this language

fn resolve_instance_method( &self, type_name: &str, method_name: &str, context: &dyn ResolutionScope, document_index: &DocumentIndex, ) -> Option<SymbolId>

Resolve an instance method call to its symbol ID

fn resolve_method_call( &self, method_call: &MethodCall, receiver_types: &HashMap<String, String>, context: &dyn ResolutionScope, document_index: &DocumentIndex, ) -> Option<SymbolId>

Resolve a method call to its symbol ID

fn build_resolution_context_with_pipeline_cache( &self, file_id: FileId, imports: &[Import], cache: &dyn PipelineSymbolCache, extensions: &[&str], ) -> (Box<dyn ResolutionScope>, Vec<Import>)

Build resolution context for parallel pipeline (no Tantivy access).

fn is_symbol_visible_from_file( &self, symbol: &Symbol, from_file: FileId, ) -> bool

Check if a symbol is visible from another file

fn get_file_path(&self, _file_id: FileId) -> Option<PathBuf>

Get the file path for a FileId from behavior state

fn load_project_rules_for_file( &self, file_id: FileId, ) -> Option<ResolutionRules>

Load project resolution rules for a file from the persisted index

fn register_expression_types( &self, _file_id: FileId, _entries: &[(String, String)], )

Register expression-to-type mappings extracted during parsing

fn initialize_resolution_context( &self, _context: &mut dyn ResolutionScope, _file_id: FileId, )

Hook invoked after the base resolution context has been populated

fn is_compatible_relationship( &self, from_kind: SymbolKind, to_kind: SymbolKind, rel_kind: RelationKind, file_id: FileId, ) -> bool

Check if a relationship between two symbol kinds is valid

fn disambiguate_symbol( &self, _name: &str, candidates: &[(SymbolId, SymbolKind)], _rel_kind: RelationKind, _role: RelationRole, ) -> Option<SymbolId>

Disambiguate when multiple symbols share the same name

fn is_valid_relationship( &self, from_kind: SymbolKind, to_kind: SymbolKind, rel_kind: RelationKind, ) -> bool

Check if a relationship is valid for this language

impl StatefulBehavior for GoBehavior

fn state(&self) -> &BehaviorState

Get the behavior’s state container

fn register_file_with_state( &self, path: PathBuf, file_id: FileId, module_path: String, )

Register a file with state tracking

fn add_import_with_state(&self, import: Import)

Add an import with state tracking

fn get_imports_from_state(&self, file_id: FileId) -> Vec<Import>

Get imports for a file from state