Help us shape the future of Go! Take the 2026 Go Developer Survey

treesitter

package
v0.0.4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 28, 2025 License: AGPL-3.0 Imports: 11 Imported by: 0

README

Tree-Sitter Code Parsing

This package provides advanced code parsing and understanding using Tree-sitter.

Components

parser.go
  • Tree-sitter Go bindings integration
  • Multi-language AST parsing support:
    • Go
    • Python
    • JavaScript/TypeScript
    • Rust
    • Java
    • C/C++
  • Lazy loading of language grammars
  • Parser caching for performance
definitions.go
  • Code definition extraction from ASTs:
    • Function definitions
    • Method definitions with receivers (Go-specific)
    • Class/struct definitions
    • Interface definitions
    • Type declarations
  • Code summaries and signatures generation
  • Go-specific constructs (embedding, receivers, etc.)
queries.go
  • Language-specific tree-sitter queries
  • Query result processing and caching
  • Support for:
    • Function/method extraction
    • Type declarations
    • Import statements
    • Comments and documentation
    • Language-specific patterns

Features

  • Multi-Language Support: Parses 6+ programming languages
  • AST-Based Analysis: Deep understanding of code structure
  • Performance Optimized: Lazy loading and caching
  • Go-Aware: Special handling for Go idioms and patterns
  • Rich Queries: Sophisticated pattern matching for code elements

Usage

This package enables:

  • AI assistants to understand code structure and context
  • Intelligent code navigation and analysis
  • Extraction of function signatures and documentation
  • Context-aware code suggestions and edits
  • Integration with file editing for structure-aware modifications

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Definition 

type Definition struct {
	Type        DefinitionType         `json:"type"`
	Name        string                 `json:"name"`
	Signature   string                 `json:"signature"`
	Summary     string                 `json:"summary"`
	FilePath    string                 `json:"file_path"`
	StartLine   uint32                 `json:"start_line"`
	StartColumn uint32                 `json:"start_column"`
	EndLine     uint32                 `json:"end_line"`
	EndColumn   uint32                 `json:"end_column"`
	Language    Language               `json:"language"`
	Content     string                 `json:"content"`
	DocString   string                 `json:"doc_string,omitempty"`
	Parameters  []Parameter            `json:"parameters,omitempty"`
	ReturnType  string                 `json:"return_type,omitempty"`
	Receiver    string                 `json:"receiver,omitempty"` // For Go methods
	Package     string                 `json:"package,omitempty"`
	Modifiers   []string               `json:"modifiers,omitempty"` // public, private, static, etc.
	Metadata    map[string]interface{} `json:"metadata,omitempty"`
}

Definition represents a code definition extracted from AST

type DefinitionExtractor 

type DefinitionExtractor struct {
	// contains filtered or unexported fields
}

DefinitionExtractor extracts code definitions from AST

func NewDefinitionExtractor 

func NewDefinitionExtractor(parser *TreeSitterParser) *DefinitionExtractor

NewDefinitionExtractor creates a new definition extractor

func (*DefinitionExtractor) ExtractDefinitions 

func (de *DefinitionExtractor) ExtractDefinitions(result *ParseResult) ([]Definition, error)

ExtractDefinitions extracts all definitions from a parsed AST

func (*DefinitionExtractor) ExtractDefinitionsByType 

func (de *DefinitionExtractor) ExtractDefinitionsByType(result *ParseResult, defType DefinitionType) ([]Definition, error)

ExtractDefinitionsByType extracts definitions of a specific type

func (*DefinitionExtractor) FindDefinition 

func (de *DefinitionExtractor) FindDefinition(result *ParseResult, name string) (*Definition, error)

FindDefinition finds a specific definition by name

type DefinitionType 

type DefinitionType string

DefinitionType represents different types of code definitions 

const (
	DefFunction  DefinitionType = "function"
	DefMethod    DefinitionType = "method"
	DefClass     DefinitionType = "class"
	DefStruct    DefinitionType = "struct"
	DefInterface DefinitionType = "interface"
	DefType      DefinitionType = "type"
	DefVariable  DefinitionType = "variable"
	DefConstant  DefinitionType = "constant"
	DefImport    DefinitionType = "import"
	DefPackage   DefinitionType = "package"
)

type Language 

type Language string

Language represents a supported programming language 

const (
	LanguageGo         Language = "go"
	LanguagePython     Language = "python"
	LanguageJavaScript Language = "javascript"
	LanguageRust       Language = "rust"
	LanguageC          Language = "c"
	LanguageCPP        Language = "cpp"
	LanguageJava       Language = "java"
	LanguageUnknown    Language = "unknown"
)

type Parameter 

type Parameter struct {
	Name    string `json:"name"`
	Type    string `json:"type"`
	Default string `json:"default,omitempty"`
}

Parameter represents a function or method parameter

type ParseResult 

type ParseResult struct {
	Language  Language               `json:"language"`
	FilePath  string                 `json:"file_path"`
	Content   string                 `json:"content"`
	Tree      *sitter.Tree           `json:"-"`
	RootNode  *sitter.Node           `json:"-"`
	ParseTime time.Duration          `json:"parse_time"`
	NodeCount uint32                 `json:"node_count"`
	Error     string                 `json:"error,omitempty"`
	Metadata  map[string]interface{} `json:"metadata,omitempty"`
}

ParseResult contains the result of parsing a file

type ParserConfig 

type ParserConfig struct {
	CacheSize     int           `json:"cache_size"`
	ParseTimeout  time.Duration `json:"parse_timeout"`
	MaxFileSize   int64         `json:"max_file_size"`
	EnableLogging bool          `json:"enable_logging"`
	LazyLoad      bool          `json:"lazy_load"`
}

ParserConfig configures the tree-sitter parser behavior

type QueryBuilder 

type QueryBuilder struct {
	// contains filtered or unexported fields
}

QueryBuilder helps build complex queries programmatically

func NewQueryBuilder 

func NewQueryBuilder(language Language) *QueryBuilder

NewQueryBuilder creates a new query builder

func (*QueryBuilder) AddCapture 

func (qb *QueryBuilder) AddCapture(capture string) *QueryBuilder

AddCapture adds a capture to the query

func (*QueryBuilder) AddPattern 

func (qb *QueryBuilder) AddPattern(pattern string) *QueryBuilder

AddPattern adds a pattern to the query

func (*QueryBuilder) Build 

func (qb *QueryBuilder) Build() string

Build builds the final query string

type QueryMatch 

type QueryMatch struct {
	Node        *sitter.Node           `json:"-"`
	Text        string                 `json:"text"`
	StartLine   uint32                 `json:"start_line"`
	StartColumn uint32                 `json:"start_column"`
	EndLine     uint32                 `json:"end_line"`
	EndColumn   uint32                 `json:"end_column"`
	Captures    map[string]string      `json:"captures,omitempty"`
	Context     string                 `json:"context,omitempty"`
	Metadata    map[string]interface{} `json:"metadata,omitempty"`
}

QueryMatch represents a single match from a query

type QueryPattern 

type QueryPattern struct {
	Language Language  `json:"language"`
	Type     QueryType `json:"type"`
	Pattern  string    `json:"pattern"`
	Captures []string  `json:"captures"`
}

QueryPattern represents a tree-sitter query pattern for a specific language

type QueryResult 

type QueryResult struct {
	Type        QueryType              `json:"type"`
	Language    Language               `json:"language"`
	Matches     []QueryMatch           `json:"matches"`
	ExecuteTime time.Duration          `json:"execute_time"`
	NodeCount   int                    `json:"node_count"`
	Error       string                 `json:"error,omitempty"`
	Metadata    map[string]interface{} `json:"metadata,omitempty"`
}

QueryResult represents the result of a tree-sitter query

type QuerySystem 

type QuerySystem struct {
	// contains filtered or unexported fields
}

QuerySystem manages tree-sitter queries for multiple languages

func NewQuerySystem 

func NewQuerySystem(parser *TreeSitterParser) *QuerySystem

NewQuerySystem creates a new query system

func (*QuerySystem) AddCustomPattern 

func (qs *QuerySystem) AddCustomPattern(language Language, queryType QueryType, pattern string, captures []string) error

AddCustomPattern adds a custom query pattern

func (*QuerySystem) ClearCache 

func (qs *QuerySystem) ClearCache()

ClearCache clears the query result cache

func (*QuerySystem) ExecuteCustomQuery 

func (qs *QuerySystem) ExecuteCustomQuery(result *ParseResult, queryPattern string) (*QueryResult, error)

ExecuteCustomQuery executes a custom query pattern

func (*QuerySystem) ExecuteQuery 

func (qs *QuerySystem) ExecuteQuery(result *ParseResult, queryType QueryType) (*QueryResult, error)

ExecuteQuery executes a specific query type on a parse result

func (*QuerySystem) FindNodesByName 

func (qs *QuerySystem) FindNodesByName(result *ParseResult, name string) ([]QueryMatch, error)

FindNodesByName finds all nodes with a specific name

func (*QuerySystem) FindNodesByType 

func (qs *QuerySystem) FindNodesByType(result *ParseResult, nodeType string) ([]QueryMatch, error)

FindNodesByType finds all nodes of a specific type

func (*QuerySystem) GetAllDefinitions 

func (qs *QuerySystem) GetAllDefinitions(result *ParseResult) (map[QueryType][]QueryMatch, error)

GetAllDefinitions returns all definitions using the appropriate query types

func (*QuerySystem) GetAvailableQueries 

func (qs *QuerySystem) GetAvailableQueries(language Language) []QueryType

GetAvailableQueries returns available query types for a language

func (*QuerySystem) GetCacheStats 

func (qs *QuerySystem) GetCacheStats() map[string]interface{}

GetCacheStats returns cache statistics

func (*QuerySystem) GetPattern 

func (qs *QuerySystem) GetPattern(language Language, queryType QueryType) (*QueryPattern, error)

GetPattern returns a query pattern for a language and query type

type QueryType 

type QueryType string

QueryType represents different types of tree-sitter queries 

const (
	QueryFunctions  QueryType = "functions"
	QueryMethods    QueryType = "methods"
	QueryClasses    QueryType = "classes"
	QueryStructs    QueryType = "structs"
	QueryInterfaces QueryType = "interfaces"
	QueryTypes      QueryType = "types"
	QueryVariables  QueryType = "variables"
	QueryConstants  QueryType = "constants"
	QueryImports    QueryType = "imports"
	QueryComments   QueryType = "comments"
	QueryDocStrings QueryType = "docstrings"
	QueryErrors     QueryType = "errors"
	QueryAll        QueryType = "all"
)

type TreeSitterParser 

type TreeSitterParser struct {
	// contains filtered or unexported fields
}

TreeSitterParser provides multi-language AST parsing capabilities

func NewTreeSitterParser 

func NewTreeSitterParser(config ParserConfig) (*TreeSitterParser, error)

NewTreeSitterParser creates a new tree-sitter parser instance

func (*TreeSitterParser) ClearCache 

func (tsp *TreeSitterParser) ClearCache()

ClearCache clears the parser cache

func (*TreeSitterParser) DetectLanguage 

func (tsp *TreeSitterParser) DetectLanguage(filePath string) Language

DetectLanguage detects the programming language from file extension

func (*TreeSitterParser) FindNodesOfType 

func (tsp *TreeSitterParser) FindNodesOfType(root *sitter.Node, nodeType string) []*sitter.Node

FindNodesOfType finds all nodes of a specific type

func (*TreeSitterParser) GetCacheStats 

func (tsp *TreeSitterParser) GetCacheStats() map[string]interface{}

GetCacheStats returns cache statistics

func (*TreeSitterParser) GetChildByType 

func (tsp *TreeSitterParser) GetChildByType(node *sitter.Node, nodeType string) *sitter.Node

GetChildByType finds the first child node of a specific type

func (*TreeSitterParser) GetChildrenByType 

func (tsp *TreeSitterParser) GetChildrenByType(node *sitter.Node, nodeType string) []*sitter.Node

GetChildrenByType finds all child nodes of a specific type

func (*TreeSitterParser) GetNodeLocation 

func (tsp *TreeSitterParser) GetNodeLocation(node *sitter.Node) (startLine, startCol, endLine, endCol uint32)

GetNodeLocation returns the line and column information for a node

func (*TreeSitterParser) GetNodeText 

func (tsp *TreeSitterParser) GetNodeText(node *sitter.Node, content string) string

GetNodeText returns the text content of a node

func (*TreeSitterParser) GetSupportedLanguages 

func (tsp *TreeSitterParser) GetSupportedLanguages() []Language

GetSupportedLanguages returns a list of supported languages

func (*TreeSitterParser) IsLanguageSupported 

func (tsp *TreeSitterParser) IsLanguageSupported(language Language) bool

IsLanguageSupported checks if a language is supported

func (*TreeSitterParser) NodeToString 

func (tsp *TreeSitterParser) NodeToString(node *sitter.Node, content string, maxDepth int) string

NodeToString provides a debug representation of a node

func (*TreeSitterParser) ParseContent 

func (tsp *TreeSitterParser) ParseContent(content string, language Language, filePath string) (*ParseResult, error)

ParseContent parses the given content with the specified language

func (*TreeSitterParser) ParseFile 

func (tsp *TreeSitterParser) ParseFile(filePath string) (*ParseResult, error)

ParseFile parses a file and returns the AST

func (*TreeSitterParser) TraverseTree 

func (tsp *TreeSitterParser) TraverseTree(root *sitter.Node, visitor func(*sitter.Node, int) bool)

TraverseTree traverses the AST and calls the visitor function for each node

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.