WSL should be able to trap when something fatal happens
[WebKit-https.git] / Tools / WebGPUShadingLanguageRI / 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         Node.visit(node.type, this);
99     }
100     
101     visitNativeType(node)
102     {
103         for (let typeParameter of node.typeParameters)
104             typeParameter.visit(this);
105     }
106     
107     visitNativeTypeInstance(node)
108     {
109         node.type.visit(this);
110         for (let typeArgument of node.typeArguments)
111             typeArgument.visit(this);
112     }
113     
114     visitTypeDef(node)
115     {
116         for (let typeParameter of node.typeParameters)
117             typeParameter.visit(this);
118         node.type.visit(this);
119     }
120     
121     visitStructType(node)
122     {
123         for (let typeParameter of node.typeParameters)
124             typeParameter.visit(this);
125         for (let field of node.fields)
126             field.visit(this);
127     }
128     
129     visitTypeVariable(node)
130     {
131         Node.visit(node.protocol, this);
132     }
133     
134     visitConstexprTypeParameter(node)
135     {
136         node.type.visit(this);
137     }
138     
139     visitField(node)
140     {
141         node.type.visit(this);
142     }
143     
144     visitEnumType(node)
145     {
146         node.baseType.visit(this);
147         for (let member of node.members)
148             member.visit(this);
149     }
150     
151     visitEnumMember(node)
152     {
153         Node.visit(node.value, this);
154     }
155     
156     visitEnumLiteral(node)
157     {
158     }
159     
160     visitElementalType(node)
161     {
162         node.elementType.visit(this);
163     }
164     
165     visitReferenceType(node)
166     {
167         this.visitElementalType(node);
168     }
169     
170     visitPtrType(node)
171     {
172         this.visitReferenceType(node);
173     }
174     
175     visitArrayRefType(node)
176     {
177         this.visitReferenceType(node);
178     }
179     
180     visitArrayType(node)
181     {
182         this.visitElementalType(node);
183         node.numElements.visit(this);
184     }
185     
186     visitVariableDecl(node)
187     {
188         node.type.visit(this);
189         Node.visit(node.initializer, this);
190     }
191     
192     visitAssignment(node)
193     {
194         node.lhs.visit(this);
195         node.rhs.visit(this);
196         Node.visit(node.type, this);
197     }
198     
199     visitReadModifyWriteExpression(node)
200     {
201         node.lValue.visit(this);
202         node.oldValueVar.visit(this);
203         node.newValueVar.visit(this);
204         node.newValueExp.visit(this);
205         node.resultExp.visit(this);
206     }
207     
208     visitDereferenceExpression(node)
209     {
210         node.ptr.visit(this);
211     }
212     
213     _handlePropertyAccessExpression(node)
214     {
215         Node.visit(node.baseType, this);
216         Node.visit(node.callForGet, this);
217         Node.visit(node.resultTypeForGet, this);
218         Node.visit(node.callForAnd, this);
219         Node.visit(node.resultTypeForAnd, this);
220         Node.visit(node.callForSet, this);
221     }
222     
223     visitDotExpression(node)
224     {
225         node.struct.visit(this);
226         this._handlePropertyAccessExpression(node);
227     }
228     
229     visitIndexExpression(node)
230     {
231         node.array.visit(this);
232         node.index.visit(this);
233         this._handlePropertyAccessExpression(node);
234     }
235     
236     visitMakePtrExpression(node)
237     {
238         node.lValue.visit(this);
239     }
240     
241     visitMakeArrayRefExpression(node)
242     {
243         node.lValue.visit(this);
244         Node.visit(node.numElements, this);
245     }
246     
247     visitConvertPtrToArrayRefExpression(node)
248     {
249         node.lValue.visit(this);
250     }
251     
252     visitVariableRef(node)
253     {
254     }
255     
256     visitIfStatement(node)
257     {
258         node.conditional.visit(this);
259         node.body.visit(this);
260         Node.visit(node.elseBody, this);
261     }
262     
263     visitWhileLoop(node)
264     {
265         node.conditional.visit(this);
266         node.body.visit(this);
267     }
268     
269     visitDoWhileLoop(node)
270     {
271         node.body.visit(this);
272         node.conditional.visit(this);
273     }
274     
275     visitForLoop(node)
276     {
277         Node.visit(node.initialization, this);
278         Node.visit(node.condition, this);
279         Node.visit(node.increment, this);
280         node.body.visit(this);
281     }
282
283     visitReturn(node)
284     {
285         Node.visit(node.value, this);
286     }
287
288     visitContinue(node)
289     {
290     }
291
292     visitBreak(node)
293     {
294     }
295
296     visitTrapStatement(node)
297     {
298     }
299     
300     visitGenericLiteral(node)
301     {
302         node.type.visit(this);
303     }
304     
305     visitGenericLiteralType(node)
306     {
307         Node.visit(node.type, this);
308         node.preferredType.visit(this);
309     }
310     
311     visitNullLiteral(node)
312     {
313         node.type.visit(this);
314     }
315     
316     visitBoolLiteral(node)
317     {
318     }
319     
320     visitNullType(node)
321     {
322         Node.visit(node.type, this);
323     }
324     
325     visitCallExpression(node)
326     {
327         for (let typeArgument of node.typeArguments)
328             typeArgument.visit(this);
329         for (let argument of node.argumentList)
330             Node.visit(argument, this);
331         let actualTypeArguments = node.actualTypeArguments;
332         if (actualTypeArguments) {
333             for (let argument of actualTypeArguments)
334                 argument.visit(this);
335         }
336         Node.visit(node.nativeFuncInstance, this);
337         Node.visit(node.returnType, this);
338         Node.visit(node.resultType, this);
339     }
340     
341     visitLogicalNot(node)
342     {
343         node.operand.visit(this);
344     }
345     
346     visitLogicalExpression(node)
347     {
348         node.left.visit(this);
349         node.right.visit(this);
350     }
351     
352     visitFunctionLikeBlock(node)
353     {
354         Node.visit(node.returnType, this);
355         for (let argument of node.argumentList)
356             argument.visit(this);
357         for (let parameter of node.parameters)
358             parameter.visit(this);
359         node.body.visit(this);
360         Node.visit(node.resultType, this);
361     }
362     
363     visitAnonymousVariable(node)
364     {
365         Node.visit(node.type, this);
366     }
367     
368     visitIdentityExpression(node)
369     {
370         node.target.visit(this);
371     }
372 }
373