@@ -59,8 +59,7 @@ func FindRangesFromIndexList(stack *nodestack.NodeStack, indexList []string, vm
59
59
} else if start == "std" {
60
60
return nil , fmt .Errorf ("cannot get definition of std lib" )
61
61
} else if strings .Contains (start , "." ) {
62
- rootNode , _ , _ := vm .ImportAST ("" , start )
63
- foundDesugaredObjects = findTopLevelObjects (nodestack .NewNodeStack (rootNode ), vm )
62
+ foundDesugaredObjects = findTopLevelObjectsInFile (vm , start , "" )
64
63
} else if start == "$" {
65
64
sameFileOnly = true
66
65
foundDesugaredObjects = findTopLevelObjects (nodestack .NewNodeStack (stack .From ), vm )
@@ -88,8 +87,7 @@ func FindRangesFromIndexList(stack *nodestack.NodeStack, indexList []string, vm
88
87
foundDesugaredObjects = findTopLevelObjects (tmpStack , vm )
89
88
case * ast.Import :
90
89
filename := bodyNode .File .Value
91
- rootNode , _ , _ := vm .ImportAST ("" , filename )
92
- foundDesugaredObjects = findTopLevelObjects (nodestack .NewNodeStack (rootNode ), vm )
90
+ foundDesugaredObjects = findTopLevelObjectsInFile (vm , filename , "" )
93
91
case * ast.Index :
94
92
tempStack := nodestack .NewNodeStack (bodyNode )
95
93
indexList = append (tempStack .BuildIndexList (), indexList ... )
@@ -103,7 +101,7 @@ func FindRangesFromIndexList(stack *nodestack.NodeStack, indexList []string, vm
103
101
index := indexList [0 ]
104
102
indexList = indexList [1 :]
105
103
foundFields := findObjectFieldsInObjects (foundDesugaredObjects , index )
106
- foundDesugaredObjects = foundDesugaredObjects [: 0 ]
104
+ foundDesugaredObjects = nil
107
105
if len (foundFields ) == 0 {
108
106
return nil , fmt .Errorf ("field %s was not found in ast.DesugaredObject" , index )
109
107
}
@@ -119,31 +117,9 @@ func FindRangesFromIndexList(stack *nodestack.NodeStack, indexList []string, vm
119
117
return ranges , nil
120
118
}
121
119
122
- // Unpack:
123
- // - Binary nodes. A field could be either in the left or right side of the binary
124
- // - Self nodes. We want the object self refers to, not the self node itself
125
- var fieldNodes []ast.Node
126
- for _ , foundField := range foundFields {
127
- switch fieldNode := foundField .Body .(type ) {
128
- case * ast.Self :
129
- filename := fieldNode .LocRange .FileName
130
- rootNode , _ , _ := vm .ImportAST ("" , filename )
131
- tmpStack , err := FindNodeByPosition (rootNode , fieldNode .LocRange .Begin )
132
- if err != nil {
133
- return nil , err
134
- }
135
- for ! tmpStack .IsEmpty () {
136
- _ , node := tmpStack .Pop ()
137
- if _ , ok := node .(* ast.DesugaredObject ); ok {
138
- fieldNodes = append (fieldNodes , node )
139
- }
140
- }
141
- case * ast.Binary :
142
- fieldNodes = append (fieldNodes , fieldNode .Right )
143
- fieldNodes = append (fieldNodes , fieldNode .Left )
144
- default :
145
- fieldNodes = append (fieldNodes , fieldNode )
146
- }
120
+ fieldNodes , err := unpackFieldNodes (vm , foundFields )
121
+ if err != nil {
122
+ return nil , err
147
123
}
148
124
149
125
for _ , fieldNode := range fieldNodes {
@@ -155,7 +131,7 @@ func FindRangesFromIndexList(stack *nodestack.NodeStack, indexList []string, vm
155
131
}
156
132
foundDesugaredObjects = append (foundDesugaredObjects , varReference .(* ast.DesugaredObject ))
157
133
case * ast.DesugaredObject :
158
- stack = stack .Push (fieldNode )
134
+ stack .Push (fieldNode )
159
135
foundDesugaredObjects = append (foundDesugaredObjects , findDesugaredObjectFromStack (stack ))
160
136
case * ast.Index :
161
137
tempStack := nodestack .NewNodeStack (fieldNode )
@@ -168,15 +144,46 @@ func FindRangesFromIndexList(stack *nodestack.NodeStack, indexList []string, vm
168
144
return result , err
169
145
case * ast.Import :
170
146
filename := fieldNode .File .Value
171
- rootNode , _ , _ := vm . ImportAST ( string (fieldNode .Loc ().File .DiagnosticFileName ), filename )
172
- foundDesugaredObjects = append (foundDesugaredObjects , findTopLevelObjects ( nodestack . NewNodeStack ( rootNode ), vm ) ... )
147
+ newObjs := findTopLevelObjectsInFile ( vm , filename , string (fieldNode .Loc ().File .DiagnosticFileName ))
148
+ foundDesugaredObjects = append (foundDesugaredObjects , newObjs ... )
173
149
}
174
150
}
175
151
}
176
152
177
153
return ranges , nil
178
154
}
179
155
156
+ // unpackFieldNodes extracts nodes from fields
157
+ // - Binary nodes. A field could be either in the left or right side of the binary
158
+ // - Self nodes. We want the object self refers to, not the self node itself
159
+ func unpackFieldNodes (vm * jsonnet.VM , fields []* ast.DesugaredObjectField ) ([]ast.Node , error ) {
160
+ var fieldNodes []ast.Node
161
+ for _ , foundField := range fields {
162
+ switch fieldNode := foundField .Body .(type ) {
163
+ case * ast.Self :
164
+ filename := fieldNode .LocRange .FileName
165
+ rootNode , _ , _ := vm .ImportAST ("" , filename )
166
+ tmpStack , err := FindNodeByPosition (rootNode , fieldNode .LocRange .Begin )
167
+ if err != nil {
168
+ return nil , err
169
+ }
170
+ for ! tmpStack .IsEmpty () {
171
+ node := tmpStack .Pop ()
172
+ if _ , ok := node .(* ast.DesugaredObject ); ok {
173
+ fieldNodes = append (fieldNodes , node )
174
+ }
175
+ }
176
+ case * ast.Binary :
177
+ fieldNodes = append (fieldNodes , fieldNode .Right )
178
+ fieldNodes = append (fieldNodes , fieldNode .Left )
179
+ default :
180
+ fieldNodes = append (fieldNodes , fieldNode )
181
+ }
182
+ }
183
+
184
+ return fieldNodes , nil
185
+ }
186
+
180
187
func findObjectFieldsInObjects (objectNodes []* ast.DesugaredObject , index string ) []* ast.DesugaredObjectField {
181
188
var matchingFields []* ast.DesugaredObjectField
182
189
for _ , object := range objectNodes {
@@ -207,7 +214,7 @@ func findObjectFieldInObject(objectNode *ast.DesugaredObject, index string) *ast
207
214
208
215
func findDesugaredObjectFromStack (stack * nodestack.NodeStack ) * ast.DesugaredObject {
209
216
for ! stack .IsEmpty () {
210
- _ , curr := stack .Pop ()
217
+ curr := stack .Pop ()
211
218
switch curr := curr .(type ) {
212
219
case * ast.DesugaredObject :
213
220
return curr
@@ -216,47 +223,6 @@ func findDesugaredObjectFromStack(stack *nodestack.NodeStack) *ast.DesugaredObje
216
223
return nil
217
224
}
218
225
219
- // Find all ast.DesugaredObject's from NodeStack
220
- func findTopLevelObjects (stack * nodestack.NodeStack , vm * jsonnet.VM ) []* ast.DesugaredObject {
221
- var objects []* ast.DesugaredObject
222
- for ! stack .IsEmpty () {
223
- _ , curr := stack .Pop ()
224
- switch curr := curr .(type ) {
225
- case * ast.DesugaredObject :
226
- objects = append (objects , curr )
227
- case * ast.Binary :
228
- stack = stack .Push (curr .Left )
229
- stack = stack .Push (curr .Right )
230
- case * ast.Local :
231
- stack = stack .Push (curr .Body )
232
- case * ast.Import :
233
- filename := curr .File .Value
234
- rootNode , _ , _ := vm .ImportAST (string (curr .Loc ().File .DiagnosticFileName ), filename )
235
- stack = stack .Push (rootNode )
236
- case * ast.Index :
237
- container := stack .Peek ()
238
- if containerObj , containerIsObj := container .(* ast.DesugaredObject ); containerIsObj {
239
- indexValue , indexIsString := curr .Index .(* ast.LiteralString )
240
- if ! indexIsString {
241
- continue
242
- }
243
- obj := findObjectFieldInObject (containerObj , indexValue .Value )
244
- if obj != nil {
245
- stack .Push (obj .Body )
246
- }
247
- }
248
- case * ast.Var :
249
- varReference , err := findVarReference (curr , vm )
250
- if err != nil {
251
- log .WithError (err ).Errorf ("Error finding var reference, ignoring this node" )
252
- continue
253
- }
254
- stack .Push (varReference )
255
- }
256
- }
257
- return objects
258
- }
259
-
260
226
// findVarReference finds the object that the variable is referencing
261
227
// To do so, we get the stack where the var is used and search that stack for the var's definition
262
228
func findVarReference (varNode * ast.Var , vm * jsonnet.VM ) (ast.Node , error ) {
@@ -274,7 +240,7 @@ func findVarReference(varNode *ast.Var, vm *jsonnet.VM) (ast.Node, error) {
274
240
275
241
func findLhsDesugaredObject (stack * nodestack.NodeStack ) (* ast.DesugaredObject , error ) {
276
242
for ! stack .IsEmpty () {
277
- _ , curr := stack .Pop ()
243
+ curr := stack .Pop ()
278
244
switch curr := curr .(type ) {
279
245
case * ast.Binary :
280
246
lhsNode := curr .Left
@@ -289,10 +255,10 @@ func findLhsDesugaredObject(stack *nodestack.NodeStack) (*ast.DesugaredObject, e
289
255
}
290
256
case * ast.Local :
291
257
for _ , bind := range curr .Binds {
292
- stack = stack .Push (bind .Body )
258
+ stack .Push (bind .Body )
293
259
}
294
260
if curr .Body != nil {
295
- stack = stack .Push (curr .Body )
261
+ stack .Push (curr .Body )
296
262
}
297
263
}
298
264
}
0 commit comments