xonecas.io
62159
Sy

symb / files

symb / internal / treesitter / parser.go

7.5 KB
1package treesitter
2
3import (
4	"context"
5	"os"
6	"path/filepath"
7	"strings"
8
9	sitter "github.com/smacker/go-tree-sitter"
10	"github.com/smacker/go-tree-sitter/golang"
11)
12
13// langForExt returns the tree-sitter language for a file extension, or nil.
14func langForExt(ext string) *sitter.Language {
15	switch ext {
16	case ".go":
17		return golang.GetLanguage()
18	default:
19		return nil
20	}
21}
22
23// Supported returns true if the file extension has a tree-sitter grammar.
24func Supported(path string) bool {
25	return langForExt(strings.ToLower(filepath.Ext(path))) != nil
26}
27
28// ParseFile reads and parses a file, returning its top-level symbols.
29func ParseFile(path string) ([]Symbol, error) {
30	src, err := os.ReadFile(path)
31	if err != nil {
32		return nil, err
33	}
34	return ParseSource(path, src)
35}
36
37// ParseSource parses source bytes and returns top-level symbols.
38func ParseSource(path string, src []byte) ([]Symbol, error) {
39	lang := langForExt(strings.ToLower(filepath.Ext(path)))
40	if lang == nil {
41		return nil, nil
42	}
43
44	parser := sitter.NewParser()
45	defer parser.Close()
46	parser.SetLanguage(lang)
47
48	tree, err := parser.ParseCtx(context.Background(), nil, src)
49	if err != nil {
50		return nil, err
51	}
52	defer tree.Close()
53
54	return extractGo(tree.RootNode(), src), nil
55}
56
57// extractGo walks a Go AST root and extracts top-level symbols.
58func extractGo(root *sitter.Node, src []byte) []Symbol {
59	var syms []Symbol
60	count := int(root.ChildCount())
61
62	for i := 0; i < count; i++ {
63		child := root.Child(i)
64		switch child.Type() {
65		case "package_clause":
66			// package_identifier is a named child, not a field.
67			if nc := child.NamedChild(0); nc != nil && nc.Type() == "package_identifier" {
68				syms = append(syms, Symbol{
69					Name:      content(nc, src),
70					Kind:      KindPackage,
71					StartLine: line(child),
72					EndLine:   endLine(child),
73				})
74			}
75
76		case "import_declaration":
77			syms = append(syms, extractImport(child, src))
78
79		case "function_declaration":
80			syms = append(syms, extractFunc(child, src))
81
82		case "method_declaration":
83			syms = append(syms, extractMethod(child, src))
84
85		case "type_declaration":
86			syms = append(syms, extractTypeDecl(child, src)...)
87
88		case "const_declaration":
89			syms = append(syms, extractConstVar(child, src, KindConst)...)
90
91		case "var_declaration":
92			syms = append(syms, extractConstVar(child, src, KindVar)...)
93		}
94	}
95	return syms
96}
97
98func extractImport(node *sitter.Node, src []byte) Symbol {
99	return Symbol{
100		Name:      strings.TrimSpace(content(node, src)),
101		Kind:      KindImport,
102		StartLine: line(node),
103		EndLine:   endLine(node),
104	}
105}
106
107func extractFunc(node *sitter.Node, src []byte) Symbol {
108	name := node.ChildByFieldName("name")
109	params := node.ChildByFieldName("parameters")
110	result := node.ChildByFieldName("result")
111
112	sym := Symbol{
113		Kind:      KindFunction,
114		StartLine: line(node),
115		EndLine:   endLine(node),
116	}
117	if name != nil {
118		sym.Name = content(name, src)
119	}
120	sym.Signature = buildFuncSig("", sym.Name, params, result, src)
121	return sym
122}
123
124func extractMethod(node *sitter.Node, src []byte) Symbol {
125	name := node.ChildByFieldName("name")
126	receiver := node.ChildByFieldName("receiver")
127	params := node.ChildByFieldName("parameters")
128	result := node.ChildByFieldName("result")
129
130	sym := Symbol{
131		Kind:      KindMethod,
132		StartLine: line(node),
133		EndLine:   endLine(node),
134	}
135	if name != nil {
136		sym.Name = content(name, src)
137	}
138
139	var recvStr string
140	if receiver != nil {
141		recvStr = content(receiver, src)
142		// Extract just the type name from receiver for Receiver field.
143		sym.Receiver = extractReceiverType(receiver, src)
144	}
145	sym.Signature = buildFuncSig(recvStr, sym.Name, params, result, src)
146	return sym
147}
148
149func extractTypeDecl(node *sitter.Node, src []byte) []Symbol {
150	var syms []Symbol
151	count := int(node.ChildCount())
152	for i := 0; i < count; i++ {
153		child := node.Child(i)
154		switch child.Type() {
155		case "type_spec":
156			syms = append(syms, extractTypeSpec(child, src))
157		case "type_alias":
158			syms = append(syms, extractTypeSpec(child, src))
159		}
160	}
161	return syms
162}
163
164func extractTypeSpec(node *sitter.Node, src []byte) Symbol {
165	name := node.ChildByFieldName("name")
166	typeNode := node.ChildByFieldName("type")
167
168	sym := Symbol{
169		Kind:      KindType,
170		StartLine: line(node),
171		EndLine:   endLine(node),
172	}
173	if name != nil {
174		sym.Name = content(name, src)
175	}
176	if typeNode != nil {
177		switch typeNode.Type() {
178		case "struct_type":
179			sym.Kind = KindStruct
180			sym.Children = extractStructFields(typeNode, src)
181		case "interface_type":
182			sym.Kind = KindInterface
183			sym.Children = extractInterfaceMethods(typeNode, src)
184		}
185		sym.Signature = "type " + sym.Name + " " + typeNode.Type()
186	}
187	return sym
188}
189
190func extractStructFields(node *sitter.Node, src []byte) []Symbol {
191	var fields []Symbol
192	body := node.ChildByFieldName("body")
193	if body == nil {
194		// struct_type has field_declaration_list as child
195		for i := 0; i < int(node.ChildCount()); i++ {
196			child := node.Child(i)
197			if child.Type() == "field_declaration_list" {
198				body = child
199				break
200			}
201		}
202	}
203	if body == nil {
204		return nil
205	}
206	for i := 0; i < int(body.ChildCount()); i++ {
207		child := body.Child(i)
208		if child.Type() == "field_declaration" {
209			nameNode := child.ChildByFieldName("name")
210			typeNode := child.ChildByFieldName("type")
211			if nameNode != nil {
212				f := Symbol{
213					Name:      content(nameNode, src),
214					Kind:      KindVar,
215					StartLine: line(child),
216					EndLine:   endLine(child),
217				}
218				if typeNode != nil {
219					f.Signature = content(nameNode, src) + " " + content(typeNode, src)
220				}
221				fields = append(fields, f)
222			}
223		}
224	}
225	return fields
226}
227
228func extractInterfaceMethods(node *sitter.Node, src []byte) []Symbol {
229	var methods []Symbol
230	for i := 0; i < int(node.ChildCount()); i++ {
231		child := node.Child(i)
232		if child.Type() == "method_elem" || child.Type() == "method_spec" {
233			nameNode := child.ChildByFieldName("name")
234			if nameNode != nil {
235				m := Symbol{
236					Name:      content(nameNode, src),
237					Kind:      KindMethod,
238					StartLine: line(child),
239					EndLine:   endLine(child),
240					Signature: content(child, src),
241				}
242				methods = append(methods, m)
243			}
244		}
245	}
246	return methods
247}
248
249func extractConstVar(node *sitter.Node, src []byte, kind SymbolKind) []Symbol {
250	var syms []Symbol
251	count := int(node.ChildCount())
252	for i := 0; i < count; i++ {
253		child := node.Child(i)
254		if child.Type() == "const_spec" || child.Type() == "var_spec" {
255			nameNode := child.ChildByFieldName("name")
256			if nameNode != nil {
257				syms = append(syms, Symbol{
258					Name:      content(nameNode, src),
259					Kind:      kind,
260					StartLine: line(child),
261					EndLine:   endLine(child),
262				})
263			}
264		}
265	}
266	return syms
267}
268
269func extractReceiverType(receiver *sitter.Node, src []byte) string {
270	// Walk into parameter_list -> parameter_declaration -> type
271	for i := 0; i < int(receiver.ChildCount()); i++ {
272		child := receiver.Child(i)
273		if child.Type() == "parameter_declaration" {
274			typeNode := child.ChildByFieldName("type")
275			if typeNode != nil {
276				return content(typeNode, src)
277			}
278		}
279	}
280	return ""
281}
282
283func buildFuncSig(receiver, name string, params, result *sitter.Node, src []byte) string {
284	var b strings.Builder
285	b.WriteString("func ")
286	if receiver != "" {
287		b.WriteString(receiver)
288		b.WriteByte(' ')
289	}
290	b.WriteString(name)
291	if params != nil {
292		b.WriteString(content(params, src))
293	}
294	if result != nil {
295		b.WriteByte(' ')
296		b.WriteString(content(result, src))
297	}
298	return b.String()
299}
300
301// helpers
302
303func content(node *sitter.Node, src []byte) string {
304	return node.Content(src)
305}
306
307func line(node *sitter.Node) int {
308	return int(node.StartPoint().Row) + 1 // 1-indexed
309}
310
311func endLine(node *sitter.Node) int {
312	return int(node.EndPoint().Row) + 1
313}