Mercurial > hg > graal-compiler

comparison graal/com.oracle.truffle.api.dsl.test/src/com/oracle/truffle/api/dsl/test/ExecuteMethodTest.java @ 18776:c0fb70634640

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
author Christian Humer <christian.humer@gmail.com>
date Mon, 05 Jan 2015 01:31:08 +0100
parents a069a87b9a02
children ae827362559d
comparison
equal deleted inserted replaced
18775:a069a87b9a02 18776:c0fb70634640
21 * questions. 21 * questions.
22 */ 22 */
23 package com.oracle.truffle.api.dsl.test; 23 package com.oracle.truffle.api.dsl.test;
24 24
25 import com.oracle.truffle.api.dsl.*; 25 import com.oracle.truffle.api.dsl.*;
26 import com.oracle.truffle.api.dsl.internal.*;
27 import com.oracle.truffle.api.frame.*;
26 import com.oracle.truffle.api.nodes.*; 28 import com.oracle.truffle.api.nodes.*;
27 29
28 public class ExecuteMethodTest { 30 public class ExecuteMethodTest {
29 31
30 private static final String NO_EXECUTE = "No accessible and overridable generic execute method found. Generic execute methods usually have the signature 'public abstract {Type} " 32 private static final String ERROR_NO_EXECUTE = "No accessible and overridable generic execute method found. Generic execute methods usually have the signature 'public abstract {Type} "
31 + "executeGeneric(VirtualFrame)' and must not throw any checked exceptions."; 33 + "execute(VirtualFrame)' and must not throw any checked exceptions.";
32 34
33 @TypeSystem({int.class, Object[].class}) 35 @TypeSystem({int.class})
34 static class ExecuteTypeSystem { 36 @DSLOptions(useNewLayout = true)
35 37 static class ExecuteMethodTypes {
36 } 38 }
37 39
38 @TypeSystemReference(ExecuteTypeSystem.class) 40 @TypeSystemReference(ExecuteMethodTypes.class)
39 abstract static class ValidChildNode extends Node { 41 abstract static class ChildNoFrame extends Node {
40 abstract Object execute(); 42 abstract Object execute();
41 } 43 }
42 44
43 @TypeSystemReference(ExecuteTypeSystem.class) 45 @TypeSystemReference(ExecuteMethodTypes.class)
44 @NodeChild(value = "a", type = ValidChildNode.class) 46 @NodeChild(value = "a", type = ChildNoFrame.class)
45 @ExpectError(NO_EXECUTE) 47 @ExpectError(ERROR_NO_EXECUTE)
46 abstract static class ExecuteThis1 extends Node { 48 abstract static class ExecuteThis1 extends Node {
47 49
48 @Specialization 50 @Specialization
49 int doInt(int a) { 51 int doInt(int a) {
50 return a; 52 return a;
51 } 53 }
52 } 54 }
53 55
54 @TypeSystemReference(ExecuteTypeSystem.class) 56 @TypeSystemReference(ExecuteMethodTypes.class)
55 @NodeChild(value = "a", type = ValidChildNode.class) 57 @NodeChild(value = "a", type = ChildNoFrame.class)
56 @ExpectError(NO_EXECUTE) 58 @ExpectError(ERROR_NO_EXECUTE)
57 abstract static class ExecuteThis2 extends Node { 59 abstract static class ExecuteThis2 extends Node {
58 60
59 abstract Object execute() throws UnexpectedResultException; 61 abstract Object execute() throws UnexpectedResultException;
60 62
61 @Specialization 63 @Specialization
62 int doInt(int a) { 64 int doInt(int a) {
63 return a; 65 return a;
64 } 66 }
65 } 67 }
66 68
67 @TypeSystemReference(ExecuteTypeSystem.class) 69 @TypeSystemReference(ExecuteMethodTypes.class)
68 @NodeChild(value = "a", type = ValidChildNode.class) 70 @NodeChild(value = "a", type = ChildNoFrame.class)
69 @ExpectError(NO_EXECUTE) 71 @ExpectError(ERROR_NO_EXECUTE)
70 abstract static class ExecuteThis3 extends Node { 72 abstract static class ExecuteThis3 extends Node {
71 73
72 abstract int execute() throws UnexpectedResultException; 74 abstract int execute() throws UnexpectedResultException;
73 75
74 @Specialization 76 @Specialization
75 int doInt(int a) { 77 int doInt(int a) {
76 return a; 78 return a;
77 } 79 }
78 } 80 }
79 81
80 @TypeSystemReference(ExecuteTypeSystem.class) 82 @TypeSystemReference(ExecuteMethodTypes.class)
81 @NodeChild(value = "a", type = ValidChildNode.class) 83 @NodeChild(value = "a", type = ChildNoFrame.class)
82 abstract static class ExecuteThis4 extends Node { 84 abstract static class ExecuteThis4 extends Node {
83 85
84 protected abstract Object execute(); 86 protected abstract Object execute();
85 87
86 @Specialization 88 @Specialization
87 int doInt(int a) { 89 int doInt(int a) {
88 return a; 90 return a;
89 } 91 }
90 } 92 }
91 93
92 @TypeSystemReference(ExecuteTypeSystem.class) 94 @TypeSystemReference(ExecuteMethodTypes.class)
93 @NodeChild(value = "a", type = ValidChildNode.class) 95 @NodeChild(value = "a", type = ChildNoFrame.class)
94 abstract static class ExecuteThis5 extends Node { 96 abstract static class ExecuteThis5 extends Node {
95 97
96 public abstract Object execute(); 98 public abstract Object execute();
97 99
98 @Specialization 100 @Specialization
99 int doInt(int a) { 101 int doInt(int a) {
100 return a; 102 return a;
101 } 103 }
102 } 104 }
103 105
104 @TypeSystemReference(ExecuteTypeSystem.class) 106 @TypeSystemReference(ExecuteMethodTypes.class)
105 @NodeChild(value = "a", type = ValidChildNode.class) 107 @NodeChild(value = "a", type = ChildNoFrame.class)
106 @ExpectError(NO_EXECUTE) 108 @ExpectError(ERROR_NO_EXECUTE)
107 abstract static class ExecuteThis6 extends Node { 109 abstract static class ExecuteThis6 extends Node {
108 110
109 @SuppressWarnings({"unused", "static-method"}) 111 @SuppressWarnings({"unused", "static-method"})
110 private Object execute() { 112 private Object execute() {
111 return 0; 113 return 0;
115 int doInt(int a) { 117 int doInt(int a) {
116 return a; 118 return a;
117 } 119 }
118 } 120 }
119 121
120 @TypeSystemReference(ExecuteTypeSystem.class) 122 @TypeSystemReference(ExecuteMethodTypes.class)
121 @NodeChild(value = "a", type = ValidChildNode.class) 123 @NodeChild(value = "a", type = ChildNoFrame.class)
122 @ExpectError(NO_EXECUTE) 124 @ExpectError(ERROR_NO_EXECUTE)
123 abstract static class ExecuteThis7 extends Node { 125 abstract static class ExecuteThis7 extends Node {
124 126
125 @SuppressWarnings("static-method") 127 @SuppressWarnings("static-method")
126 public final int executeInt() { 128 public final int executeInt() {
127 return 0; 129 return 0;
131 int doInt(int a) { 133 int doInt(int a) {
132 return a; 134 return a;
133 } 135 }
134 } 136 }
135 137
136 @TypeSystemReference(ExecuteTypeSystem.class) 138 @TypeSystemReference(ExecuteMethodTypes.class)
137 @NodeChild(value = "a", type = ValidChildNode.class) 139 @NodeChild(value = "a", type = ChildNoFrame.class)
138 @ExpectError("Multiple accessible and overridable generic execute methods found [executeInt(), executeObject()]. Remove all but one or mark all but one as final.") 140 @ExpectError("Multiple accessible and overridable generic execute methods found [executeInt(), executeObject()]. Remove all but one or mark all but one as final.")
139 abstract static class ExecuteThis8 extends Node { 141 abstract static class ExecuteThis8 extends Node {
140 142
141 abstract int executeInt(); 143 abstract int executeInt();
142 144
147 return a; 149 return a;
148 } 150 }
149 151
150 } 152 }
151 153
152 @TypeSystemReference(ExecuteTypeSystem.class) 154 @TypeSystemReference(ExecuteMethodTypes.class)
153 @NodeChild(value = "a", type = ValidChildNode.class) 155 @NodeChild(value = "a", type = ChildNoFrame.class)
154 abstract static class ExecuteThis9 extends Node { 156 abstract static class ExecuteThis9 extends Node {
155 157
156 abstract int executeInt(); 158 abstract int executeInt();
157 159
158 // disambiguate executeObject 160 // disambiguate executeObject
164 int doInt(int a) { 166 int doInt(int a) {
165 return a; 167 return a;
166 } 168 }
167 } 169 }
168 170
171 @TypeSystemReference(ExecuteMethodTypes.class)
172 @NodeChild(value = "a", type = ChildNoFrame.class)
173 abstract static class ExecuteThisVoid1 extends Node {
174
175 abstract void executeVoid();
176
177 @Specialization
178 int doInt(int a) {
179 return a;
180 }
181 }
182
183 @TypeSystemReference(ExecuteMethodTypes.class)
184 @NodeChild(value = "a", type = ChildNoFrame.class)
185 abstract static class ExecuteThisVoid2 extends Node {
186
187 // allow one execute void
188 abstract void executeVoid();
189
190 abstract Object executeObject();
191
192 @Specialization
193 int doInt(int a) {
194 return a;
195 }
196 }
197
198 @TypeSystemReference(ExecuteMethodTypes.class)
199 @NodeChild(value = "a", type = ChildNoFrame.class)
200 @ExpectError("Multiple accessible and overridable generic execute methods found [executeObject(), executeVoid1(), executeVoid2()]. Remove all but one or mark all but one as final.")
201 abstract static class ExecuteThisVoid3 extends Node {
202
203 // allow only one execute void
204 abstract void executeVoid1();
205
206 abstract void executeVoid2();
207
208 abstract Object executeObject();
209
210 @Specialization
211 int doInt(int a) {
212 return a;
213 }
214 }
215
216 @TypeSystemReference(ExecuteMethodTypes.class)
217 @NodeChild(value = "a", type = ChildNoFrame.class)
218 abstract static class ExecuteWithFrame1 extends Node {
219
220 // no frame in execute. no parameter in specializations
221 abstract Object executeNoFrame();
222
223 @Specialization
224 int doInt(int a) {
225 return a;
226 }
227 }
228
229 @TypeSystemReference(ExecuteMethodTypes.class)
230 @NodeChild(value = "a", type = ChildNoFrame.class)
231 abstract static class ExecuteWithFrame2 extends Node {
232
233 // frame in execute also usable in specialization
234 abstract Object executeWithFrame(VirtualFrame frame);
235
236 @Specialization
237 int doInt(@SuppressWarnings("unused") VirtualFrame frame, int a) {
238 return a;
239 }
240 }
241
242 @TypeSystemReference(ExecuteMethodTypes.class)
243 @NodeChild(value = "a", type = ChildNoFrame.class)
244 abstract static class ExecuteWithFrame3 extends Node {
245
246 abstract Object executeWithFrame(Frame frame);
247
248 @Specialization
249 int doInt(@SuppressWarnings("unused") Frame frame, int a) {
250 return a;
251 }
252 }
253
254 @TypeSystemReference(ExecuteMethodTypes.class)
255 @NodeChild(value = "a", type = ExecuteWithFrame4.class)
256 abstract static class ExecuteWithFrame4 extends Node {
257
258 abstract Object executeWithFrame(MaterializedFrame frame);
259
260 @Specialization
261 int doInt(@SuppressWarnings("unused") MaterializedFrame frame, int a) {
262 return a;
263 }
264 }
265
266 @TypeSystemReference(ExecuteMethodTypes.class)
267 @NodeChild(value = "a", type = ChildNoFrame.class)
268 abstract static class ExecuteWithFrameError1 extends Node {
269
270 abstract Object executeNoFrame();
271
272 @Specialization
273 @ExpectError("Method signature (VirtualFrame, int) does not match to the expected signature:%")
274 int doInt(@SuppressWarnings("unused") VirtualFrame frame, int a) {
275 return a;
276 }
277 }
278
279 @TypeSystemReference(ExecuteMethodTypes.class)
280 @NodeChild(value = "a", type = ChildNoFrame.class)
281 abstract static class ExecuteWithFrameError2 extends Node {
282
283 abstract Object executeFrame(MaterializedFrame frame);
284
285 @Specialization
286 @ExpectError("Method signature (VirtualFrame, int) does not match to the expected signature:%")
287 int doInt(@SuppressWarnings("unused") VirtualFrame frame, int a) {
288 return a;
289 }
290 }
291
292 @TypeSystemReference(ExecuteMethodTypes.class)
293 @NodeChild(value = "a", type = ChildNoFrame.class)
294 abstract static class ExecuteWithFrameError3 extends Node {
295
296 abstract Object executeFrame(VirtualFrame frame);
297
298 @Specialization
299 @ExpectError("Method signature (MaterializedFrame, int) does not match to the expected signature:%")
300 int doInt(@SuppressWarnings("unused") MaterializedFrame frame, int a) {
301 return a;
302 }
303 }
304
305 @TypeSystemReference(ExecuteMethodTypes.class)
306 @NodeChild(value = "a", type = ChildNoFrame.class)
307 @ExpectError("Invalid inconsistent frame types [MaterializedFrame, VirtualFrame] found for the declared execute methods.%")
308 abstract static class ExecuteWithFrameError4 extends Node {
309
310 abstract Object execute(VirtualFrame frame);
311
312 abstract int executeInt(MaterializedFrame frame) throws UnexpectedResultException;
313
314 @Specialization
315 int doInt(int a) {
316 return a;
317 }
318 }
319
320 @TypeSystemReference(ExecuteMethodTypes.class)
321 @NodeChild(value = "a", type = ChildNoFrame.class)
322 @ExpectError("Invalid inconsistent frame types [MaterializedFrame, void] found for the declared execute methods.%")
323 abstract static class ExecuteWithFrameError5 extends Node {
324
325 abstract Object execute();
326
327 abstract int executeInt(MaterializedFrame frame) throws UnexpectedResultException;
328
329 @Specialization
330 int doInt(int a) {
331 return a;
332 }
333 }
334
335 @TypeSystemReference(ExecuteMethodTypes.class)
336 abstract static class ChildVirtualFrame extends Node {
337 abstract Object execute(VirtualFrame frame);
338 }
339
340 @TypeSystemReference(ExecuteMethodTypes.class)
341 abstract static class ChildMaterializedFrame extends Node {
342 abstract Object execute(MaterializedFrame frame);
343 }
344
345 @TypeSystemReference(ExecuteMethodTypes.class)
346 abstract static class ChildFrame extends Node {
347 abstract Object execute(Frame frame);
348 }
349
350 @TypeSystemReference(ExecuteMethodTypes.class)
351 @NodeChild(value = "a", type = ChildNoFrame.class)
352 abstract static class ExecuteChildFrame1 extends Node {
353
354 abstract Object execute(VirtualFrame frame);
355
356 @Specialization
357 int doInt(int a) {
358 return a;
359 }
360 }
361
362 @TypeSystemReference(ExecuteMethodTypes.class)
363 @NodeChild(value = "a", type = ChildFrame.class)
364 abstract static class ExecuteChildFrame2 extends Node {
365
366 abstract Object execute(VirtualFrame frame);
367
368 @Specialization
369 int doInt(int a) {
370 return a;
371 }
372 }
373
374 @TypeSystemReference(ExecuteMethodTypes.class)
375 @NodeChild(value = "a", type = ChildFrame.class)
376 abstract static class ExecuteChildFrame3 extends Node {
377
378 abstract Object execute(MaterializedFrame frame);
379
380 @Specialization
381 int doInt(int a) {
382 return a;
383 }
384 }
385
386 @TypeSystemReference(ExecuteMethodTypes.class)
387 @NodeChild(value = "a", type = ChildFrame.class)
388 abstract static class ExecuteChildFrame4 extends Node {
389
390 abstract Object execute(Frame frame);
391
392 @Specialization
393 int doInt(int a) {
394 return a;
395 }
396 }
397
398 @ExpectError("No generic execute method found with 0 evaluated arguments for node type ChildVirtualFrame and frame types [com.oracle.truffle.api.frame.Frame].")
399 @TypeSystemReference(ExecuteMethodTypes.class)
400 @NodeChild(value = "a", type = ChildVirtualFrame.class)
401 abstract static class ExecuteChildFrameError1 extends Node {
402
403 abstract Object execute(Frame frame);
404
405 @Specialization
406 int doInt(int a) {
407 return a;
408 }
409 }
410
411 @ExpectError("No generic execute method found with 0 evaluated arguments for node type ChildFrame and frame types [].")
412 @TypeSystemReference(ExecuteMethodTypes.class)
413 @NodeChild(value = "a", type = ChildFrame.class)
414 abstract static class ExecuteChildFrameError2 extends Node {
415
416 abstract Object execute();
417
418 @Specialization
419 int doInt(int a) {
420 return a;
421 }
422 }
423
424 @ExpectError("No generic execute method found with 0 evaluated arguments for node type ChildVirtualFrame and frame types [].")
425 @TypeSystemReference(ExecuteMethodTypes.class)
426 @NodeChild(value = "a", type = ChildVirtualFrame.class)
427 abstract static class ExecuteChildFrameError3 extends Node {
428
429 abstract Object execute();
430
431 @Specialization
432 int doInt(int a) {
433 return a;
434 }
435 }
436
169 } 437 }