IntLiteral should prefer int32 during overload resolution
[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 extends VisitorBase {
28     constructor()
29     {
30         super();
31     }
32     
33     visitProgram(node)
34     {
35         for (let statement of node.topLevelStatements)
36             statement.visit(this);
37     }
38     
39     visitFunc(node)
40     {
41         node.returnType.visit(this);
42         for (let typeParameter of node.typeParameters)
43             typeParameter.visit(this);
44         for (let parameter of node.parameters)
45             parameter.visit(this);
46     }
47     
48     visitProtocolFuncDecl(node)
49     {
50         this.visitFunc(node);
51     }
52     
53     visitFuncParameter(node)
54     {
55         node.type.visit(this);
56     }
57     
58     visitFuncDef(node)
59     {
60         this.visitFunc(node);
61         node.body.visit(this);
62     }
63     
64     visitNativeFunc(node)
65     {
66         this.visitFunc(node);
67     }
68     
69     visitNativeFuncInstance(node)
70     {
71         node.func.visit(this);
72         this.visitFunc(node);
73     }
74     
75     visitBlock(node)
76     {
77         for (let statement of node.statements)
78             statement.visit(this);
79     }
80     
81     visitCommaExpression(node)
82     {
83         for (let expression of node.list)
84             expression.visit(this);
85     }
86     
87     visitProtocolRef(node)
88     {
89     }
90     
91     visitProtocolDecl(node)
92     {
93         for (let signature of node.signatures)
94             signature.visit(this);
95     }
96     
97     visitTypeRef(node)
98     {
99         for (let typeArgument of node.typeArguments)
100             typeArgument.visit(this);
101         if (node.type)
102             node.type.visit(this);
103     }
104     
105     visitNativeType(node)
106     {
107         for (let typeParameter of node.typeParameters)
108             typeParameter.visit(this);
109     }
110     
111     visitNativeTypeInstance(node)
112     {
113         node.type.visit(node);
114         for (let typeArgument of node.typeArguments)
115             typeArgument.visit(this);
116     }
117     
118     visitTypeDef(node)
119     {
120         for (let typeParameter of node.typeParameters)
121             typeParameter.visit(this);
122         node.type.visit(this);
123     }
124     
125     visitStructType(node)
126     {
127         for (let typeParameter of node.typeParameters)
128             typeParameter.visit(this);
129         for (let field of node.fields)
130             field.visit(this);
131     }
132     
133     visitTypeVariable(node)
134     {
135         if (node.protocol)
136             node.protocol.visit(this);
137     }
138     
139     visitConstexprTypeParameter(node)
140     {
141         node.type.visit(this);
142     }
143     
144     visitField(node)
145     {
146         node.type.visit(this);
147     }
148     
149     visitElementalType(node)
150     {
151         node.elementType.visit(this);
152     }
153     
154     visitReferenceType(node)
155     {
156         this.visitElementalType(node);
157     }
158     
159     visitPtrType(node)
160     {
161         this.visitReferenceType(node);
162     }
163     
164     visitArrayRefType(node)
165     {
166         this.visitReferenceType(node);
167     }
168     
169     visitArrayType(node)
170     {
171         this.visitElementalType(node);
172         node.numElements.visit(this);
173     }
174     
175     visitVariableDecl(node)
176     {
177         node.type.visit(this);
178         if (node.initializer)
179             node.initializer.visit(this);
180     }
181     
182     visitAssignment(node)
183     {
184         node.lhs.visit(this);
185         node.rhs.visit(this);
186     }
187     
188     visitDereferenceExpression(node)
189     {
190         node.ptr.visit(this);
191     }
192     
193     visitDotExpression(node)
194     {
195         node.struct.visit(this);
196         if (node.structType)
197             node.structType.visit(this);
198     }
199     
200     visitMakePtrExpression(node)
201     {
202         node.lValue.visit(this);
203     }
204     
205     visitVariableRef(node)
206     {
207         if (node.variable)
208             node.variable.visit(this);
209     }
210     
211     visitIfStatement(node)
212     {
213         node.conditional.visit(this);
214         node.body.visit(this);
215         if (node.elseBody)
216             node.elseBody.visit(this);
217     }
218     
219     visitWhileLoop(node)
220     {
221         node.conditional.visit(this);
222         node.body.visit(this);
223     }
224     
225     visitDoWhileLoop(node)
226     {
227         node.body.visit(this);
228         node.conditional.visit(this);
229     }
230
231     visitReturn(node)
232     {
233         if (node.value)
234             node.value.visit(this);
235     }
236
237     visitContinue(node)
238     {
239     }
240
241     visitBreak(node)
242     {
243     }
244     
245     visitIntLiteral(node)
246     {
247         node.type.visit(this);
248     }
249     
250     visitIntLiteralType(node)
251     {
252         if (node.type)
253             node.type.visit(this);
254         node.intType.visit(this);
255     }
256     
257     visitUintLiteral(node)
258     {
259     }
260     
261     visitNullLiteral(node)
262     {
263         node.type.visit(this);
264     }
265     
266     visitBoolLiteral(node)
267     {
268     }
269     
270     visitNullType(node)
271     {
272         if (node.type)
273             node.type.visit(this);
274     }
275     
276     visitCallExpression(node)
277     {
278         for (let typeArgument of node.typeArguments)
279             typeArgument.visit(this);
280         for (let argument of node.argumentList)
281             argument.visit(this);
282         let actualTypeArguments = node.actualTypeArguments;
283         if (actualTypeArguments) {
284             for (let argument of actualTypeArguments)
285                 argument.visit(this);
286         }
287         if (node.returnType)
288             node.returnType.visit(this);
289     }
290     
291     visitLogicalNot(node)
292     {
293         node.operand.visit(this);
294     }
295     
296     visitFunctionLikeBlock(node)
297     {
298         for (let argument of node.argumentList)
299             argument.visit(this);
300         for (let parameter of node.parameters)
301             parameter.visit(this);
302         node.body.visit(this);
303     }
304 }
305