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}