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