walk.go raw
1 // Copyright 2025 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
4
5 package inspector
6
7 // This file is a fork of ast.Inspect to reduce unnecessary dynamic
8 // calls and to gather edge information.
9 //
10 // Consistency with the original is ensured by TestInspectAllNodes.
11
12 import (
13 "fmt"
14 "go/ast"
15
16 "golang.org/x/tools/go/ast/edge"
17 )
18
19 func walkList[N ast.Node](v *visitor, ek edge.Kind, list []N) {
20 for i, node := range list {
21 walk(v, ek, i, node)
22 }
23 }
24
25 func walk(v *visitor, ek edge.Kind, index int, node ast.Node) {
26 v.push(ek, index, node)
27
28 // walk children
29 // (the order of the cases matches the order
30 // of the corresponding node types in ast.go)
31 switch n := node.(type) {
32 // Comments and fields
33 case *ast.Comment:
34 // nothing to do
35
36 case *ast.CommentGroup:
37 walkList(v, edge.CommentGroup_List, n.List)
38
39 case *ast.Field:
40 if n.Doc != nil {
41 walk(v, edge.Field_Doc, -1, n.Doc)
42 }
43 walkList(v, edge.Field_Names, n.Names)
44 if n.Type != nil {
45 walk(v, edge.Field_Type, -1, n.Type)
46 }
47 if n.Tag != nil {
48 walk(v, edge.Field_Tag, -1, n.Tag)
49 }
50 if n.Comment != nil {
51 walk(v, edge.Field_Comment, -1, n.Comment)
52 }
53
54 case *ast.FieldList:
55 walkList(v, edge.FieldList_List, n.List)
56
57 // Expressions
58 case *ast.BadExpr, *ast.Ident, *ast.BasicLit:
59 // nothing to do
60
61 case *ast.Ellipsis:
62 if n.Elt != nil {
63 walk(v, edge.Ellipsis_Elt, -1, n.Elt)
64 }
65
66 case *ast.FuncLit:
67 walk(v, edge.FuncLit_Type, -1, n.Type)
68 walk(v, edge.FuncLit_Body, -1, n.Body)
69
70 case *ast.CompositeLit:
71 if n.Type != nil {
72 walk(v, edge.CompositeLit_Type, -1, n.Type)
73 }
74 walkList(v, edge.CompositeLit_Elts, n.Elts)
75
76 case *ast.ParenExpr:
77 walk(v, edge.ParenExpr_X, -1, n.X)
78
79 case *ast.SelectorExpr:
80 walk(v, edge.SelectorExpr_X, -1, n.X)
81 walk(v, edge.SelectorExpr_Sel, -1, n.Sel)
82
83 case *ast.IndexExpr:
84 walk(v, edge.IndexExpr_X, -1, n.X)
85 walk(v, edge.IndexExpr_Index, -1, n.Index)
86
87 case *ast.IndexListExpr:
88 walk(v, edge.IndexListExpr_X, -1, n.X)
89 walkList(v, edge.IndexListExpr_Indices, n.Indices)
90
91 case *ast.SliceExpr:
92 walk(v, edge.SliceExpr_X, -1, n.X)
93 if n.Low != nil {
94 walk(v, edge.SliceExpr_Low, -1, n.Low)
95 }
96 if n.High != nil {
97 walk(v, edge.SliceExpr_High, -1, n.High)
98 }
99 if n.Max != nil {
100 walk(v, edge.SliceExpr_Max, -1, n.Max)
101 }
102
103 case *ast.TypeAssertExpr:
104 walk(v, edge.TypeAssertExpr_X, -1, n.X)
105 if n.Type != nil {
106 walk(v, edge.TypeAssertExpr_Type, -1, n.Type)
107 }
108
109 case *ast.CallExpr:
110 walk(v, edge.CallExpr_Fun, -1, n.Fun)
111 walkList(v, edge.CallExpr_Args, n.Args)
112
113 case *ast.StarExpr:
114 walk(v, edge.StarExpr_X, -1, n.X)
115
116 case *ast.UnaryExpr:
117 walk(v, edge.UnaryExpr_X, -1, n.X)
118
119 case *ast.BinaryExpr:
120 walk(v, edge.BinaryExpr_X, -1, n.X)
121 walk(v, edge.BinaryExpr_Y, -1, n.Y)
122
123 case *ast.KeyValueExpr:
124 walk(v, edge.KeyValueExpr_Key, -1, n.Key)
125 walk(v, edge.KeyValueExpr_Value, -1, n.Value)
126
127 // Types
128 case *ast.ArrayType:
129 if n.Len != nil {
130 walk(v, edge.ArrayType_Len, -1, n.Len)
131 }
132 walk(v, edge.ArrayType_Elt, -1, n.Elt)
133
134 case *ast.StructType:
135 walk(v, edge.StructType_Fields, -1, n.Fields)
136
137 case *ast.FuncType:
138 if n.TypeParams != nil {
139 walk(v, edge.FuncType_TypeParams, -1, n.TypeParams)
140 }
141 if n.Params != nil {
142 walk(v, edge.FuncType_Params, -1, n.Params)
143 }
144 if n.Results != nil {
145 walk(v, edge.FuncType_Results, -1, n.Results)
146 }
147
148 case *ast.InterfaceType:
149 walk(v, edge.InterfaceType_Methods, -1, n.Methods)
150
151 case *ast.MapType:
152 walk(v, edge.MapType_Key, -1, n.Key)
153 walk(v, edge.MapType_Value, -1, n.Value)
154
155 case *ast.ChanType:
156 walk(v, edge.ChanType_Value, -1, n.Value)
157
158 // Statements
159 case *ast.BadStmt:
160 // nothing to do
161
162 case *ast.DeclStmt:
163 walk(v, edge.DeclStmt_Decl, -1, n.Decl)
164
165 case *ast.EmptyStmt:
166 // nothing to do
167
168 case *ast.LabeledStmt:
169 walk(v, edge.LabeledStmt_Label, -1, n.Label)
170 walk(v, edge.LabeledStmt_Stmt, -1, n.Stmt)
171
172 case *ast.ExprStmt:
173 walk(v, edge.ExprStmt_X, -1, n.X)
174
175 case *ast.SendStmt:
176 walk(v, edge.SendStmt_Chan, -1, n.Chan)
177 walk(v, edge.SendStmt_Value, -1, n.Value)
178
179 case *ast.IncDecStmt:
180 walk(v, edge.IncDecStmt_X, -1, n.X)
181
182 case *ast.AssignStmt:
183 walkList(v, edge.AssignStmt_Lhs, n.Lhs)
184 walkList(v, edge.AssignStmt_Rhs, n.Rhs)
185
186 case *ast.GoStmt:
187 walk(v, edge.GoStmt_Call, -1, n.Call)
188
189 case *ast.DeferStmt:
190 walk(v, edge.DeferStmt_Call, -1, n.Call)
191
192 case *ast.ReturnStmt:
193 walkList(v, edge.ReturnStmt_Results, n.Results)
194
195 case *ast.BranchStmt:
196 if n.Label != nil {
197 walk(v, edge.BranchStmt_Label, -1, n.Label)
198 }
199
200 case *ast.BlockStmt:
201 walkList(v, edge.BlockStmt_List, n.List)
202
203 case *ast.IfStmt:
204 if n.Init != nil {
205 walk(v, edge.IfStmt_Init, -1, n.Init)
206 }
207 walk(v, edge.IfStmt_Cond, -1, n.Cond)
208 walk(v, edge.IfStmt_Body, -1, n.Body)
209 if n.Else != nil {
210 walk(v, edge.IfStmt_Else, -1, n.Else)
211 }
212
213 case *ast.CaseClause:
214 walkList(v, edge.CaseClause_List, n.List)
215 walkList(v, edge.CaseClause_Body, n.Body)
216
217 case *ast.SwitchStmt:
218 if n.Init != nil {
219 walk(v, edge.SwitchStmt_Init, -1, n.Init)
220 }
221 if n.Tag != nil {
222 walk(v, edge.SwitchStmt_Tag, -1, n.Tag)
223 }
224 walk(v, edge.SwitchStmt_Body, -1, n.Body)
225
226 case *ast.TypeSwitchStmt:
227 if n.Init != nil {
228 walk(v, edge.TypeSwitchStmt_Init, -1, n.Init)
229 }
230 walk(v, edge.TypeSwitchStmt_Assign, -1, n.Assign)
231 walk(v, edge.TypeSwitchStmt_Body, -1, n.Body)
232
233 case *ast.CommClause:
234 if n.Comm != nil {
235 walk(v, edge.CommClause_Comm, -1, n.Comm)
236 }
237 walkList(v, edge.CommClause_Body, n.Body)
238
239 case *ast.SelectStmt:
240 walk(v, edge.SelectStmt_Body, -1, n.Body)
241
242 case *ast.ForStmt:
243 if n.Init != nil {
244 walk(v, edge.ForStmt_Init, -1, n.Init)
245 }
246 if n.Cond != nil {
247 walk(v, edge.ForStmt_Cond, -1, n.Cond)
248 }
249 if n.Post != nil {
250 walk(v, edge.ForStmt_Post, -1, n.Post)
251 }
252 walk(v, edge.ForStmt_Body, -1, n.Body)
253
254 case *ast.RangeStmt:
255 if n.Key != nil {
256 walk(v, edge.RangeStmt_Key, -1, n.Key)
257 }
258 if n.Value != nil {
259 walk(v, edge.RangeStmt_Value, -1, n.Value)
260 }
261 walk(v, edge.RangeStmt_X, -1, n.X)
262 walk(v, edge.RangeStmt_Body, -1, n.Body)
263
264 // Declarations
265 case *ast.ImportSpec:
266 if n.Doc != nil {
267 walk(v, edge.ImportSpec_Doc, -1, n.Doc)
268 }
269 if n.Name != nil {
270 walk(v, edge.ImportSpec_Name, -1, n.Name)
271 }
272 walk(v, edge.ImportSpec_Path, -1, n.Path)
273 if n.Comment != nil {
274 walk(v, edge.ImportSpec_Comment, -1, n.Comment)
275 }
276
277 case *ast.ValueSpec:
278 if n.Doc != nil {
279 walk(v, edge.ValueSpec_Doc, -1, n.Doc)
280 }
281 walkList(v, edge.ValueSpec_Names, n.Names)
282 if n.Type != nil {
283 walk(v, edge.ValueSpec_Type, -1, n.Type)
284 }
285 walkList(v, edge.ValueSpec_Values, n.Values)
286 if n.Comment != nil {
287 walk(v, edge.ValueSpec_Comment, -1, n.Comment)
288 }
289
290 case *ast.TypeSpec:
291 if n.Doc != nil {
292 walk(v, edge.TypeSpec_Doc, -1, n.Doc)
293 }
294 walk(v, edge.TypeSpec_Name, -1, n.Name)
295 if n.TypeParams != nil {
296 walk(v, edge.TypeSpec_TypeParams, -1, n.TypeParams)
297 }
298 walk(v, edge.TypeSpec_Type, -1, n.Type)
299 if n.Comment != nil {
300 walk(v, edge.TypeSpec_Comment, -1, n.Comment)
301 }
302
303 case *ast.BadDecl:
304 // nothing to do
305
306 case *ast.GenDecl:
307 if n.Doc != nil {
308 walk(v, edge.GenDecl_Doc, -1, n.Doc)
309 }
310 walkList(v, edge.GenDecl_Specs, n.Specs)
311
312 case *ast.FuncDecl:
313 if n.Doc != nil {
314 walk(v, edge.FuncDecl_Doc, -1, n.Doc)
315 }
316 if n.Recv != nil {
317 walk(v, edge.FuncDecl_Recv, -1, n.Recv)
318 }
319 walk(v, edge.FuncDecl_Name, -1, n.Name)
320 walk(v, edge.FuncDecl_Type, -1, n.Type)
321 if n.Body != nil {
322 walk(v, edge.FuncDecl_Body, -1, n.Body)
323 }
324
325 case *ast.File:
326 if n.Doc != nil {
327 walk(v, edge.File_Doc, -1, n.Doc)
328 }
329 walk(v, edge.File_Name, -1, n.Name)
330 walkList(v, edge.File_Decls, n.Decls)
331 // don't walk n.Comments - they have been
332 // visited already through the individual
333 // nodes
334
335 default:
336 // (includes *ast.Package)
337 panic(fmt.Sprintf("Walk: unexpected node type %T", n))
338 }
339
340 v.pop(node)
341 }
342