Make JetStream 2
[WebKit-https.git] / PerformanceTests / JetStream2 / WSL / Visitor.js
1 /*
2  * Copyright (C) 2017 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25 "use strict";
26
27 class Visitor {
28     visitProgram(node)
29     {
30         for (let statement of node.topLevelStatements)
31             statement.visit(this);
32     }
33     
34     visitFunc(node)
35     {
36         node.returnType.visit(this);
37         for (let typeParameter of node.typeParameters)
38             typeParameter.visit(this);
39         for (let parameter of node.parameters)
40             parameter.visit(this);
41     }
42     
43     visitProtocolFuncDecl(node)
44     {
45         this.visitFunc(node);
46     }
47     
48     visitFuncParameter(node)
49     {
50         node.type.visit(this);
51     }
52     
53     visitFuncDef(node)
54     {
55         this.visitFunc(node);
56         node.body.visit(this);
57     }
58     
59     visitNativeFunc(node)
60     {
61         this.visitFunc(node);
62     }
63     
64     visitNativeFuncInstance(node)
65     {
66         this.visitFunc(node);
67         node.func.visitImplementationData(node.implementationData, this);
68     }
69     
70     visitBlock(node)
71     {
72         for (let statement of node.statements)
73             statement.visit(this);
74     }
75     
76     visitCommaExpression(node)
77     {
78         for (let expression of node.list)
79             expression.visit(this);
80     }
81     
82     visitProtocolRef(node)
83     {
84     }
85     
86     visitProtocolDecl(node)
87     {
88         for (let protocol of node.extends)
89             protocol.visit(this);
90         for (let signature of node.signatures)
91             signature.visit(this);
92     }
93     
94     visitTypeRef(node)
95     {
96         for (let typeArgument of node.typeArguments)
97             typeArgument.visit(this);
98     }
99     
100     visitNativeType(node)
101     {
102         for (let typeParameter of node.typeParameters)
103             typeParameter.visit(this);
104     }
105     
106     visitNativeTypeInstance(node)
107     {
108         node.type.visit(this);
109         for (let typeArgument of node.typeArguments)
110             typeArgument.visit(this);
111     }
112     
113     visitTypeDef(node)
114     {
115         for (let typeParameter of node.typeParameters)
116             typeParameter.visit(this);
117         node.type.visit(this);
118     }
119     
120     visitStructType(node)
121     {
122         for (let typeParameter of node.typeParameters)
123             typeParameter.visit(this);
124         for (let field of node.fields)
125             field.visit(this);
126     }
127     
128     visitTypeVariable(node)
129     {
130         Node.visit(node.protocol, this);
131     }
132     
133     visitConstexprTypeParameter(node)
134     {
135         node.type.visit(this);
136     }
137     
138     visitField(node)
139     {
140         node.type.visit(this);
141     }
142     
143     visitEnumType(node)
144     {
145         node.baseType.visit(this);
146         for (let member of node.members)
147             member.visit(this);
148     }
149     
150     visitEnumMember(node)
151     {
152         Node.visit(node.value, this);
153     }
154     
155     visitEnumLiteral(node)
156     {
157     }
158     
159     visitElementalType(node)
160     {
161         node.elementType.visit(this);
162     }
163     
164     visitReferenceType(node)
165     {
166         this.visitElementalType(node);
167     }
168     
169     visitPtrType(node)
170     {
171         this.visitReferenceType(node);
172     }
173     
174     visitArrayRefType(node)
175     {
176         this.visitReferenceType(node);
177     }
178     
179     visitArrayType(node)
180     {
181         this.visitElementalType(node);
182         node.numElements.visit(this);
183     }
184     
185     visitVariableDecl(node)
186     {
187         node.type.visit(this);
188         Node.visit(node.initializer, this);
189     }
190     
191     visitAssignment(node)
192     {
193         node.lhs.visit(this);
194         node.rhs.visit(this);
195         Node.visit(node.type, this);
196     }
197     
198     visitReadModifyWriteExpression(node)
199     {
200         node.lValue.visit(this);
201         node.oldValueVar.visit(this);
202         node.newValueVar.visit(this);
203         node.newValueExp.visit(this);
204         node.resultExp.visit(this);
205     }
206     
207     visitDereferenceExpression(node)
208     {
209         node.ptr.visit(this);
210     }
211     
212     _handlePropertyAccessExpression(node)
213     {
214         Node.visit(node.baseType, this);
215         Node.visit(node.callForGet, this);
216         Node.visit(node.resultTypeForGet, this);
217         Node.visit(node.callForAnd, this);
218         Node.visit(node.resultTypeForAnd, this);
219         Node.visit(node.callForSet, this);
220     }
221     
222     visitDotExpression(node)
223     {
224         node.struct.visit(this);
225         this._handlePropertyAccessExpression(node);
226     }
227     
228     visitIndexExpression(node)
229     {
230         node.array.visit(this);
231         node.index.visit(this);
232         this._handlePropertyAccessExpression(node);
233     }
234     
235     visitMakePtrExpression(node)
236     {
237         node.lValue.visit(this);
238     }
239     
240     visitMakeArrayRefExpression(node)
241     {
242         node.lValue.visit(this);
243         Node.visit(node.numElements, this);
244     }
245     
246     visitConvertPtrToArrayRefExpression(node)
247     {
248         node.lValue.visit(this);
249     }
250     
251     visitVariableRef(node)
252     {
253     }
254     
255     visitIfStatement(node)
256     {
257         node.conditional.visit(this);
258         node.body.visit(this);
259         Node.visit(node.elseBody, this);
260     }
261     
262     visitWhileLoop(node)
263     {
264         node.conditional.visit(this);
265         node.body.visit(this);
266     }
267     
268     visitDoWhileLoop(node)
269     {
270         node.body.visit(this);
271         node.conditional.visit(this);
272     }
273     
274     visitForLoop(node)
275     {
276         Node.visit(node.initialization, this);
277         Node.visit(node.condition, this);
278         Node.visit(node.increment, this);
279         node.body.visit(this);
280     }
281     
282     visitSwitchStatement(node)
283     {
284         node.value.visit(this);
285         for (let switchCase of node.switchCases)
286             switchCase.visit(this);
287     }
288     
289     visitSwitchCase(node)
290     {
291         Node.visit(node.value, this);
292         node.body.visit(this);
293     }
294
295     visitReturn(node)
296     {
297         Node.visit(node.value, this);
298     }
299
300     visitContinue(node)
301     {
302     }
303
304     visitBreak(node)
305     {
306     }
307
308     visitTrapStatement(node)
309     {
310     }
311     
312     visitGenericLiteral(node)
313     {
314         node.type.visit(this);
315     }
316     
317     visitGenericLiteralType(node)
318     {
319         Node.visit(node.type, this);
320         node.preferredType.visit(this);
321     }
322     
323     visitNullLiteral(node)
324     {
325         node.type.visit(this);
326     }
327     
328     visitBoolLiteral(node)
329     {
330     }
331     
332     visitNullType(node)
333     {
334         Node.visit(node.type, this);
335     }
336     
337     visitCallExpression(node)
338     {
339         for (let typeArgument of node.typeArguments)
340             typeArgument.visit(this);
341         for (let argument of node.argumentList)
342             Node.visit(argument, this);
343         let handleTypeArguments = actualTypeArguments => {
344             if (actualTypeArguments) {
345                 for (let argument of actualTypeArguments)
346                     argument.visit(this);
347             }
348         };
349         handleTypeArguments(node.actualTypeArguments);
350         handleTypeArguments(node.instantiatedActualTypeArguments);
351         Node.visit(node.nativeFuncInstance, this);
352         Node.visit(node.returnType, this);
353         Node.visit(node.resultType, this);
354     }
355     
356     visitLogicalNot(node)
357     {
358         node.operand.visit(this);
359     }
360     
361     visitLogicalExpression(node)
362     {
363         node.left.visit(this);
364         node.right.visit(this);
365     }
366     
367     visitFunctionLikeBlock(node)
368     {
369         Node.visit(node.returnType, this);
370         for (let argument of node.argumentList)
371             argument.visit(this);
372         for (let parameter of node.parameters)
373             parameter.visit(this);
374         node.body.visit(this);
375         Node.visit(node.resultType, this);
376     }
377     
378     visitAnonymousVariable(node)
379     {
380         Node.visit(node.type, this);
381     }
382     
383     visitIdentityExpression(node)
384     {
385         node.target.visit(this);
386     }
387 }
388