Mercurial > hg > graal-jvmci-8

comparison graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/generator/NodeBaseFactory.java @ 18752:1acaa69ff61b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Truffle-DSL: refactor generator classes
author Christian Humer <christian.humer@gmail.com>
date Mon, 29 Dec 2014 23:38:16 +0100
parents
children f6b8787dc113
comparison
equal deleted inserted replaced
18751:e55e18c1f40d 18752:1acaa69ff61b
1 /*
2 * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23 package com.oracle.truffle.dsl.processor.generator;
24
25 import static com.oracle.truffle.dsl.processor.java.ElementUtils.*;
26 import static javax.lang.model.element.Modifier.*;
27
28 import java.util.*;
29
30 import javax.lang.model.element.*;
31 import javax.lang.model.type.*;
32 import javax.lang.model.util.*;
33
34 import com.oracle.truffle.api.dsl.*;
35 import com.oracle.truffle.api.nodes.*;
36 import com.oracle.truffle.dsl.processor.*;
37 import com.oracle.truffle.dsl.processor.java.*;
38 import com.oracle.truffle.dsl.processor.java.model.*;
39 import com.oracle.truffle.dsl.processor.java.model.CodeTypeMirror.ArrayCodeTypeMirror;
40 import com.oracle.truffle.dsl.processor.model.*;
41 import com.oracle.truffle.dsl.processor.model.NodeChildData.Cardinality;
42 import com.oracle.truffle.dsl.processor.parser.*;
43 import com.oracle.truffle.dsl.processor.parser.SpecializationGroup.TypeGuard;
44
45 class NodeBaseFactory extends AbstractClassElementFactory<SpecializationData> {
46
47 private static final String THIS_NODE_LOCAL_VAR_NAME = "thisNode";
48
49 static final String EXECUTE_CHAINED = "executeChained0";
50 private static final String SPECIALIZE = "specialize0";
51 private static final String DSLSHARE_REWRITE = "rewrite";
52 private static final String DSLSHARE_FIND_ROOT = "findRoot";
53 private static final String DSLSHARE_REWRITE_TO_POLYMORHPIC = "rewriteToPolymorphic";
54 static final String EXECUTE_UNINITIALIZED = "executeUninitialized0";
55 private static final String REWRITE = "rewrite0";
56 private static final String CREATE_INFO = "createInfo0";
57 static final String CONTAINS_FALLBACK = "containsFallback";
58
59 static final String EMPTY_CLASS_ARRAY = "EMPTY_CLASS_ARRAY";
60
61 static final String METADATA_FIELD_NAME = "METADATA";
62
63 public static List<ExecutableElement> findUserConstructors(TypeMirror nodeType) {
64 List<ExecutableElement> constructors = new ArrayList<>();
65 for (ExecutableElement constructor : ElementFilter.constructorsIn(ElementUtils.fromTypeMirror(nodeType).getEnclosedElements())) {
66 if (constructor.getModifiers().contains(PRIVATE)) {
67 continue;
68 }
69 if (isCopyConstructor(constructor)) {
70 continue;
71 }
72 constructors.add(constructor);
73 }
74
75 if (constructors.isEmpty()) {
76 constructors.add(new CodeExecutableElement(null, ElementUtils.getSimpleName(nodeType)));
77 }
78
79 return constructors;
80 }
81
82 public static boolean isCopyConstructor(ExecutableElement element) {
83 if (element.getParameters().size() != 1) {
84 return false;
85 }
86 VariableElement var = element.getParameters().get(0);
87 TypeElement enclosingType = ElementUtils.findNearestEnclosingType(var);
88 if (ElementUtils.typeEquals(var.asType(), enclosingType.asType())) {
89 return true;
90 }
91 List<TypeElement> types = ElementUtils.getDirectSuperTypes(enclosingType);
92 for (TypeElement type : types) {
93 if (!(type instanceof CodeTypeElement)) {
94 // no copy constructors which are not generated types
95 return false;
96 }
97
98 if (ElementUtils.typeEquals(var.asType(), type.asType())) {
99 return true;
100 }
101 }
102 return false;
103 }
104
105 @Override
106 protected CodeTypeElement create(SpecializationData specialization) {
107 NodeData node = specialization.getNode();
108 CodeTypeElement clazz = createClass(node, modifiers(PRIVATE, ABSTRACT, STATIC), baseClassName(node), node.getNodeType(), false);
109 clazz.getImplements().add(context.getTruffleTypes().getDslNode());
110
111 for (NodeChildData child : node.getChildren()) {
112 clazz.add(createChildField(child));
113
114 if (child.getAccessElement() != null && child.getAccessElement().getModifiers().contains(Modifier.ABSTRACT)) {
115 ExecutableElement getter = (ExecutableElement) child.getAccessElement();
116 CodeExecutableElement method = CodeExecutableElement.clone(getContext().getEnvironment(), getter);
117 method.getModifiers().remove(Modifier.ABSTRACT);
118 CodeTreeBuilder builder = method.createBuilder();
119 builder.startReturn().string("this.").string(child.getName()).end();
120 clazz.add(method);
121 }
122 }
123
124 for (NodeFieldData field : node.getFields()) {
125 if (!field.isGenerated()) {
126 continue;
127 }
128
129 clazz.add(new CodeVariableElement(modifiers(PROTECTED, FINAL), field.getType(), field.getName()));
130 if (field.getGetter() != null && field.getGetter().getModifiers().contains(Modifier.ABSTRACT)) {
131 CodeExecutableElement method = CodeExecutableElement.clone(getContext().getEnvironment(), field.getGetter());
132 method.getModifiers().remove(Modifier.ABSTRACT);
133 method.createBuilder().startReturn().string("this.").string(field.getName()).end();
134 clazz.add(method);
135 }
136 }
137
138 for (String assumption : node.getAssumptions()) {
139 clazz.add(createAssumptionField(assumption));
140 }
141
142 createConstructors(node, clazz);
143
144 return clazz;
145 }
146
147 @Override
148 protected void createChildren(SpecializationData specialization) {
149 NodeData node = specialization.getNode();
150 CodeTypeElement clazz = getElement();
151
152 SpecializationGroup rootGroup = createSpecializationGroups(node);
153
154 if (node.needsRewrites(context)) {
155 if (node.isPolymorphic(context)) {
156
157 CodeVariableElement var = new CodeVariableElement(modifiers(PROTECTED), clazz.asType(), "next0");
158 var.getAnnotationMirrors().add(new CodeAnnotationMirror(getContext().getTruffleTypes().getChildAnnotation()));
159 clazz.add(var);
160
161 CodeExecutableElement genericCachedExecute = createCachedExecute(node, node.getPolymorphicSpecialization());
162 clazz.add(genericCachedExecute);
163
164 }
165
166 for (CodeExecutableElement method : createImplicitChildrenAccessors()) {
167 clazz.add(method);
168 }
169 clazz.add(createInfoMessage(node));
170 clazz.add(createMonomorphicRewrite());
171 clazz.add(createCreateSpecializationMethod(node, rootGroup));
172 }
173
174 clazz.add(createAdoptChildren0());
175 clazz.add(createGetMetadata0(true));
176 clazz.add(createUpdateTypes0());
177 clazz.add(createGetNext());
178 }
179
180 private Element createGetNext() {
181 CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC, FINAL), context.getType(Node.class), "getNext0");
182 CodeTreeBuilder builder = method.createBuilder();
183 NodeData node = getModel().getNode();
184
185 if (node.isPolymorphic(context)) {
186 builder.startReturn().string("next0").end();
187 } else {
188 builder.returnNull();
189 }
190
191 return method;
192 }
193
194 protected final CodeExecutableElement createUpdateTypes0() {
195 ArrayType classArray = new ArrayCodeTypeMirror(context.getType(Class.class));
196 CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC), context.getType(void.class), "updateTypes0");
197 method.getParameters().add(new CodeVariableElement(classArray, "types"));
198
199 if (getModel().isPolymorphic()) {
200 CodeTreeBuilder builder = method.createBuilder();
201
202 int index = 0;
203 for (NodeExecutionData execution : getModel().getNode().getChildExecutions()) {
204 String fieldName = polymorphicTypeName(execution);
205
206 builder.startStatement();
207 builder.string(fieldName).string(" = ").string("types[").string(String.valueOf(index)).string("]");
208 builder.end();
209 index++;
210 }
211 }
212
213 return method;
214 }
215
216 protected final CodeExecutableElement createGetMetadata0(boolean empty) {
217 CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC), context.getTruffleTypes().getDslMetadata(), "getMetadata0");
218 if (empty) {
219 method.createBuilder().startReturn().staticReference(context.getTruffleTypes().getDslMetadata(), "NONE").end();
220 } else {
221 method.createBuilder().startReturn().string(METADATA_FIELD_NAME).end();
222 }
223 return method;
224 }
225
226 private CodeExecutableElement createAdoptChildren0() {
227 CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC, FINAL), context.getType(void.class), "adoptChildren0");
228 method.getParameters().add(new CodeVariableElement(context.getTruffleTypes().getNode(), "other"));
229 method.getParameters().add(new CodeVariableElement(context.getTruffleTypes().getNode(), "newNext"));
230 NodeData node = getModel().getNode();
231 CodeTreeBuilder builder = method.createBuilder();
232 List<NodeExecutionData> executions = node.getChildExecutions();
233
234 if (executions.size() > 0) {
235 builder.startIf().string("other == null").end().startBlock();
236 for (NodeExecutionData execution : executions) {
237 builder.startStatement().tree(createAccessChild(execution, "this")).string(" = null").end();
238 }
239 builder.end().startElseBlock();
240
241 String access;
242 if (executions.size() > 1) {
243 builder.declaration(baseClassName(node), "otherCast", builder.create().cast(baseClassName(node)).string("other"));
244 access = "otherCast";
245 } else {
246 assert executions.size() == 1;
247 access = "((" + baseClassName(node) + ") other)";
248 }
249 for (NodeExecutionData execution : executions) {
250 builder.startStatement().tree(createAccessChild(execution, "this")).string(" = ").tree(createAccessChild(execution, access)).end();
251 }
252
253 builder.end();
254 }
255
256 if (getModel().getNode().isPolymorphic(context)) {
257 builder.startIf().string("newNext == null").end().startBlock();
258 builder.statement("this.next0 = null");
259 builder.end().startElseBlock();
260 builder.statement("this.next0 = (" + baseClassName(getModel().getNode()) + ") newNext");
261 builder.end();
262 }
263
264 return method;
265 }
266
267 private List<CodeExecutableElement> createImplicitChildrenAccessors() {
268 NodeData node = getModel().getNode();
269 List<Set<TypeData>> prototype = Collections.nCopies(node.getGenericSpecialization().getParameters().size(), null);
270 List<Set<TypeData>> expectTypes = new ArrayList<>(prototype);
271
272 for (ExecutableTypeData executableType : node.getExecutableTypes()) {
273 for (int i = 0; i < executableType.getEvaluatedCount(); i++) {
274 Parameter parameter = executableType.getSignatureParameter(i);
275 if (i >= expectTypes.size()) {
276 break;
277 }
278 Set<TypeData> types = expectTypes.get(i);
279 if (types == null) {
280 types = new TreeSet<>();
281 expectTypes.set(i, types);
282 }
283 types.add(parameter.getTypeSystemType());
284 }
285 }
286
287 List<CodeExecutableElement> methods = new ArrayList<>();
288 List<Set<TypeData>> visitedList = new ArrayList<>(prototype);
289 for (SpecializationData spec : node.getSpecializations()) {
290 int signatureIndex = -1;
291 for (Parameter param : spec.getParameters()) {
292 if (!param.getSpecification().isSignature()) {
293 continue;
294 }
295 signatureIndex++;
296 Set<TypeData> visitedTypeData = visitedList.get(signatureIndex);
297 if (visitedTypeData == null) {
298 visitedTypeData = new TreeSet<>();
299 visitedList.set(signatureIndex, visitedTypeData);
300 }
301
302 if (visitedTypeData.contains(param.getTypeSystemType())) {
303 continue;
304 }
305 visitedTypeData.add(param.getTypeSystemType());
306
307 Set<TypeData> expect = expectTypes.get(signatureIndex);
308 if (expect == null) {
309 expect = Collections.emptySet();
310 }
311
312 methods.addAll(createExecuteChilds(param, expect));
313 }
314 }
315 return methods;
316 }
317
318 private CodeTree truffleBooleanOption(CodeTreeBuilder parent, String name) {
319 CodeTreeBuilder builder = parent.create();
320 builder.staticReference(getContext().getTruffleTypes().getTruffleOptions(), name);
321 return builder.getRoot();
322 }
323
324 private final void addInternalValueParameters(CodeExecutableElement method, TemplateMethod specialization, boolean forceFrame, boolean disableFrame, boolean evaluated) {
325 if (forceFrame && !disableFrame && specialization.getSpecification().findParameterSpec("frame") != null) {
326 method.addParameter(new CodeVariableElement(getContext().getTruffleTypes().getFrame(), "frameValue"));
327 }
328 for (Parameter parameter : specialization.getParameters()) {
329 ParameterSpec spec = parameter.getSpecification();
330 if ((disableFrame || forceFrame) && spec.getName().equals("frame")) {
331 continue;
332 }
333 if (spec.isLocal()) {
334 continue;
335 }
336
337 String name = valueName(parameter);
338 if (evaluated && spec.isSignature()) {
339 name = valueNameEvaluated(parameter);
340 }
341
342 method.addParameter(new CodeVariableElement(parameter.getType(), name));
343 }
344 }
345
346 private Element createInfoMessage(NodeData node) {
347 CodeExecutableElement method = new CodeExecutableElement(modifiers(PROTECTED, STATIC), getContext().getType(String.class), CREATE_INFO);
348 method.addParameter(new CodeVariableElement(getContext().getType(String.class), "message"));
349 addInternalValueParameters(method, node.getGenericSpecialization(), false, false, false);
350
351 CodeTreeBuilder builder = method.createBuilder();
352
353 builder.startIf().tree(truffleBooleanOption(builder, TruffleTypes.OPTION_DETAILED_REWRITE_REASONS)).end();
354 builder.startBlock();
355
356 builder.startStatement().string("StringBuilder builder = new StringBuilder(message)").end();
357 builder.startStatement().startCall("builder", "append").doubleQuote(" (").end().end();
358
359 String sep = null;
360 for (Parameter parameter : node.getGenericSpecialization().getSignatureParameters()) {
361 builder.startStatement();
362 builder.string("builder");
363 if (sep != null) {
364 builder.startCall(".append").doubleQuote(sep).end();
365 }
366 builder.startCall(".append").doubleQuote(parameter.getLocalName()).end();
367 builder.startCall(".append").doubleQuote(" = ").end();
368 builder.startCall(".append").string(parameter.getLocalName()).end();
369 builder.end();
370
371 if (!ElementUtils.isPrimitive(parameter.getType())) {
372 builder.startIf().string(parameter.getLocalName() + " != null").end();
373 builder.startBlock();
374 }
375 builder.startStatement();
376 if (ElementUtils.isPrimitive(parameter.getType())) {
377 builder.startCall("builder.append").doubleQuote(" (" + ElementUtils.getSimpleName(parameter.getType()) + ")").end();
378 } else {
379 builder.startCall("builder.append").doubleQuote(" (").end();
380 builder.startCall(".append").string(parameter.getLocalName() + ".getClass().getSimpleName()").end();
381 builder.startCall(".append").doubleQuote(")").end();
382 }
383 builder.end();
384 if (!ElementUtils.isPrimitive(parameter.getType())) {
385 builder.end();
386 }
387
388 sep = ", ";
389 }
390
391 builder.startStatement().startCall("builder", "append").doubleQuote(")").end().end();
392 builder.startReturn().string("builder.toString()").end();
393
394 builder.end();
395 builder.startElseBlock();
396 builder.startReturn().string("message").end();
397 builder.end();
398
399 return method;
400 }
401
402 private CodeExecutableElement createCachedExecute(NodeData node, SpecializationData polymorph) {
403 CodeExecutableElement cachedExecute = new CodeExecutableElement(modifiers(PROTECTED, ABSTRACT), polymorph.getReturnType().getType(), EXECUTE_CHAINED);
404 addInternalValueParameters(cachedExecute, polymorph, true, false, false);
405
406 ExecutableTypeData sourceExecutableType = node.findExecutableType(polymorph.getReturnType().getTypeSystemType(), 0);
407 boolean sourceThrowsUnexpected = sourceExecutableType != null && sourceExecutableType.hasUnexpectedValue(getContext());
408 if (sourceThrowsUnexpected && sourceExecutableType.getType().equals(node.getGenericSpecialization().getReturnType().getTypeSystemType())) {
409 sourceThrowsUnexpected = false;
410 }
411 if (sourceThrowsUnexpected) {
412 cachedExecute.getThrownTypes().add(getContext().getType(UnexpectedResultException.class));
413 }
414 return cachedExecute;
415
416 }
417
418 private void createConstructors(NodeData node, CodeTypeElement clazz) {
419 List<ExecutableElement> constructors = findUserConstructors(node.getNodeType());
420 ExecutableElement sourceSectionConstructor = null;
421 if (constructors.isEmpty()) {
422 clazz.add(createUserConstructor(clazz, null));
423 } else {
424 for (ExecutableElement constructor : constructors) {
425 clazz.add(createUserConstructor(clazz, constructor));
426 if (NodeParser.isSourceSectionConstructor(context, constructor)) {
427 sourceSectionConstructor = constructor;
428 }
429 }
430 }
431 if (node.needsRewrites(getContext())) {
432 ExecutableElement copyConstructor = findCopyConstructor(node.getNodeType());
433 clazz.add(createCopyConstructor(clazz, copyConstructor, sourceSectionConstructor));
434 }
435 }
436
437 private CodeExecutableElement createUserConstructor(CodeTypeElement type, ExecutableElement superConstructor) {
438 CodeExecutableElement method = new CodeExecutableElement(null, type.getSimpleName().toString());
439 CodeTreeBuilder builder = method.createBuilder();
440
441 NodeData node = getModel().getNode();
442
443 if (superConstructor != null) {
444 for (VariableElement param : superConstructor.getParameters()) {
445 method.getParameters().add(CodeVariableElement.clone(param));
446 }
447 }
448
449 if (superConstructor != null) {
450 builder.startStatement().startSuperCall();
451 for (VariableElement param : superConstructor.getParameters()) {
452 builder.string(param.getSimpleName().toString());
453 }
454 builder.end().end();
455 }
456
457 for (VariableElement var : type.getFields()) {
458 if (var.getModifiers().contains(STATIC)) {
459 continue;
460 }
461 NodeChildData child = node.findChild(var.getSimpleName().toString());
462
463 if (child != null) {
464 method.getParameters().add(new CodeVariableElement(child.getOriginalType(), child.getName()));
465 } else {
466 method.getParameters().add(new CodeVariableElement(var.asType(), var.getSimpleName().toString()));
467 }
468
469 builder.startStatement();
470 String fieldName = var.getSimpleName().toString();
471
472 CodeTree init = createStaticCast(builder, child, fieldName);
473
474 builder.string("this.").string(fieldName).string(" = ").tree(init);
475 builder.end();
476 }
477 return method;
478 }
479
480 private CodeTree createStaticCast(CodeTreeBuilder parent, NodeChildData child, String fieldName) {
481 NodeData parentNode = getModel().getNode();
482 if (child != null) {
483 CreateCastData createCast = parentNode.findCast(child.getName());
484 if (createCast != null) {
485 return createTemplateMethodCall(parent, null, parentNode.getGenericSpecialization(), createCast, null, fieldName);
486 }
487 }
488 return CodeTreeBuilder.singleString(fieldName);
489 }
490
491 private CodeExecutableElement createCopyConstructor(CodeTypeElement type, ExecutableElement superConstructor, ExecutableElement sourceSectionConstructor) {
492 CodeExecutableElement method = new CodeExecutableElement(null, type.getSimpleName().toString());
493 CodeTreeBuilder builder = method.createBuilder();
494 method.getParameters().add(new CodeVariableElement(type.asType(), "copy"));
495
496 if (superConstructor != null) {
497 builder.startStatement().startSuperCall().string("copy").end().end();
498 } else if (sourceSectionConstructor != null) {
499 builder.startStatement().startSuperCall().string("copy.getSourceSection()").end().end();
500 }
501
502 for (VariableElement var : type.getFields()) {
503 if (var.getModifiers().contains(STATIC) || !var.getModifiers().contains(FINAL)) {
504 continue;
505 }
506 final String varName = var.getSimpleName().toString();
507 final TypeMirror varType = var.asType();
508 if (ElementUtils.isAssignable(varType, getContext().getTruffleTypes().getNodeArray())) {
509 CodeTree size = builder.create().string("copy.", varName, ".length").getRoot();
510 builder.startStatement().string("this.").string(varName).string(" = ").startNewArray((ArrayType) varType, size).end().end();
511 } else {
512 builder.startStatement().string("this.", varName, " = copy.", varName).end();
513 }
514 }
515
516 return method;
517 }
518
519 private CodeVariableElement createAssumptionField(String assumption) {
520 CodeVariableElement var = new CodeVariableElement(getContext().getTruffleTypes().getAssumption(), assumption);
521 var.getModifiers().add(Modifier.FINAL);
522 return var;
523 }
524
525 private CodeVariableElement createChildField(NodeChildData child) {
526 TypeMirror type = child.getNodeType();
527 CodeVariableElement var = new CodeVariableElement(type, child.getName());
528 var.getModifiers().add(Modifier.PROTECTED);
529
530 DeclaredType annotationType;
531 if (child.getCardinality() == Cardinality.MANY) {
532 var.getModifiers().add(Modifier.FINAL);
533 annotationType = getContext().getTruffleTypes().getChildrenAnnotation();
534 } else {
535 annotationType = getContext().getTruffleTypes().getChildAnnotation();
536 }
537
538 var.getAnnotationMirrors().add(new CodeAnnotationMirror(annotationType));
539 return var;
540 }
541
542 private static SpecializationGroup createSpecializationGroups(final NodeData node) {
543 List<SpecializationData> specializations = node.getSpecializations();
544 List<SpecializationData> filteredSpecializations = new ArrayList<>();
545 for (SpecializationData current : specializations) {
546 if (current.isUninitialized() || current.isPolymorphic() || !current.isReachable()) {
547 continue;
548 }
549 filteredSpecializations.add(current);
550 }
551
552 return SpecializationGroup.create(filteredSpecializations);
553 }
554
555 protected final CodeExecutableElement createExecuteUninitialized() {
556 NodeData node = getModel().getNode();
557 SpecializationData generic = node.getGenericSpecialization();
558 CodeExecutableElement method = new CodeExecutableElement(modifiers(PROTECTED), generic.getReturnType().getType(), EXECUTE_UNINITIALIZED);
559 addInternalValueParameters(method, generic, true, false, false);
560 CodeTreeBuilder builder = method.createBuilder();
561
562 boolean needsFrame = node.isFrameUsedByAnyGuard(getContext());
563 CodeTreeBuilder createSpecializationCall = builder.create();
564 createSpecializationCall.startCall(SPECIALIZE);
565 addInternalValueParameterNames(createSpecializationCall, generic, generic, null, needsFrame, !needsFrame, null);
566 createSpecializationCall.end();
567 builder.declaration(baseClassName(node), "newNode", createSpecializationCall);
568
569 if (generic.isReachable()) {
570 builder.startIf().string("newNode == null").end().startBlock();
571
572 builder.startIf().startStaticCall(context.getTruffleTypes().getCompilerDirectives(), "inInterpreter").end().end().startBlock();
573 builder.statement("containsFallback = true");
574 builder.end();
575 builder.tree(createGenericInvoke(builder, generic, generic));
576 builder.end();
577 builder.startElseBlock();
578 builder.tree(createDeoptimize(builder));
579 builder.end();
580 }
581
582 builder.startReturn();
583 builder.startStaticCall(context.getTruffleTypes().getDslShare(), "rewriteUninitialized").string("this").string("newNode").end();
584 builder.string(".").startCall(EXECUTE_CHAINED);
585 addInternalValueParameterNames(builder, generic, generic, null, true, false, null);
586 builder.end();
587 builder.end();
588
589 if (generic.isReachable()) {
590 builder.end();
591 }
592
593 return method;
594 }
595
596 private static CodeTree createInfoCall(CodeTreeBuilder parent, SpecializationData specialization, String reason) {
597 CodeTreeBuilder builder = parent.create();
598 builder.startCall(CREATE_INFO).string(reason);
599 addInternalValueParameterNames(builder, specialization, specialization, null, false, false, null);
600 builder.end();
601 return builder.getRoot();
602 }
603
604 private CodeExecutableElement createMonomorphicRewrite() {
605 NodeData node = getModel().getNode();
606
607 SpecializationData generic = node.getGenericSpecialization();
608 CodeExecutableElement method = new CodeExecutableElement(modifiers(PROTECTED, FINAL), generic.getReturnType().getType(), REWRITE);
609 addInternalValueParameters(method, generic, true, false, false);
610 method.addParameter(new CodeVariableElement(getContext().getType(String.class), "reason"));
611
612 boolean needsFrame = node.isFrameUsedByAnyGuard(getContext());
613 CodeTreeBuilder builder = method.createBuilder();
614
615 builder.startStatement().startStaticCall(context.getTruffleTypes().getCompilerAsserts(), "neverPartOfCompilation").end().end();
616 String baseClassName = baseClassName(getModel().getNode());
617 CodeTreeBuilder createSpecializationCall = builder.create();
618 createSpecializationCall.startCall(SPECIALIZE);
619 addInternalValueParameterNames(createSpecializationCall, generic, generic, null, needsFrame, !needsFrame, null);
620 createSpecializationCall.end();
621 builder.declaration(baseClassName, "newNode", createSpecializationCall);
622
623 builder.startIf().string("newNode == null").end().startBlock();
624 builder.startStatement();
625 String uninitializedName = nodeSpecializationClassName(node.getUninitializedSpecialization());
626 builder.string("newNode = ").startNew(uninitializedName).string("this").end();
627 builder.end();
628 if (node.isFallbackReachable()) {
629 builder.startStatement().string("((", uninitializedName, ") newNode).containsFallback = true").end();
630 }
631 builder.end();
632
633 builder.startStatement();
634 builder.type(getContext().getType(String.class)).string(" message = ").tree(createInfoCall(builder, generic, "reason"));
635 builder.end();
636
637 builder.declaration(baseClassName, "returnNode",
638 builder.create().startStaticCall(context.getTruffleTypes().getDslShare(), DSLSHARE_REWRITE).string("this").string("newNode").string("message").end().getRoot());
639 builder.startIf().string("returnNode == null").end().startBlock();
640 builder.tree(createRewritePolymorphic(builder, node, "this"));
641 builder.end();
642
643 builder.startReturn();
644 builder.startCall("returnNode", EXECUTE_CHAINED);
645 addInternalValueParameterNames(builder, node.getGenericSpecialization(), node.getGenericSpecialization(), null, true, false, null);
646 builder.end();
647 builder.end();
648
649 return method;
650 }
651
652 private CodeTree createRewritePolymorphic(CodeTreeBuilder parent, NodeData node, String currentNode) {
653 String polyClassName = nodePolymorphicClassName(node);
654 CodeTreeBuilder builder = parent.create();
655
656 builder.startStatement().string("returnNode = ");
657 builder.startStaticCall(context.getTruffleTypes().getDslShare(), DSLSHARE_REWRITE_TO_POLYMORHPIC);
658 builder.string("this");
659 builder.tree(builder.create().startNew(nodeSpecializationClassName(node.getUninitializedSpecialization())).string(currentNode).end().getRoot());
660 builder.tree(builder.create().startNew(polyClassName).string(currentNode).end().getRoot());
661 builder.startGroup().cast(baseClassName(node)).startCall("copy").end().end();
662 builder.string("newNode");
663 builder.string("message");
664 builder.end();
665 builder.end();
666
667 return builder.getRoot();
668 }
669
670 private CodeExecutableElement createCreateSpecializationMethod(NodeData node, SpecializationGroup group) {
671 CodeExecutableElement method = new CodeExecutableElement(modifiers(PROTECTED, FINAL), new GeneratedTypeMirror(ElementUtils.getPackageName(node.getTemplateType()), baseClassName(node)),
672 SPECIALIZE);
673
674 final boolean needsFrame = node.isFrameUsedByAnyGuard(getContext());
675
676 if (!needsFrame) {
677 method.getAnnotationMirrors().add(new CodeAnnotationMirror(getContext().getTruffleTypes().getTruffleBoundary()));
678 }
679
680 addInternalValueParameters(method, node.getGenericSpecialization(), needsFrame, !needsFrame, false);
681 final CodeTreeBuilder builder = method.createBuilder();
682 builder.tree(createExecuteTree(builder, node.getGenericSpecialization(), group, new CodeBlock<SpecializationData>() {
683
684 public CodeTree create(CodeTreeBuilder b, SpecializationData current) {
685 return createCreateSpecializationMethodBody0(builder, current, needsFrame);
686 }
687 }, null, false, true, false, true));
688
689 emitUnreachableSpecializations(builder, node);
690
691 return method;
692 }
693
694 private CodeTree createCreateSpecializationMethodBody0(CodeTreeBuilder parent, SpecializationData current, boolean useDeoptimize) {
695 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
696 if (current.isGeneric()) {
697 builder.startReturn().nullLiteral().end();
698 } else {
699 String className = nodeSpecializationClassName(current);
700 if (!current.getExcludedBy().isEmpty()) {
701 builder.startIf().string("!").startStaticCall(context.getTruffleTypes().getDslShare(), "isExcluded");
702 builder.string("this").string(nodeSpecializationClassName(current), ".", METADATA_FIELD_NAME).end().end();
703 builder.startBlock();
704 }
705
706 if (current.getNode().getGenericSpecialization().isReachable() && useDeoptimize) {
707 builder.tree(createDeoptimize(builder));
708 }
709 builder.startReturn();
710 builder.cast(baseClassName(getModel().getNode()));
711 builder.startGroup().startCall(className, NodeFactoryFactory.FACTORY_METHOD_NAME).string("this");
712 for (Parameter param : current.getSignatureParameters()) {
713 NodeChildData child = param.getSpecification().getExecution().getChild();
714 List<TypeData> types = child.getNodeData().getTypeSystem().lookupSourceTypes(param.getTypeSystemType());
715 if (types.size() > 1) {
716 builder.string(implicitTypeName(param));
717 }
718 }
719 builder.end().end();
720 builder.end();
721
722 if (!current.getExcludedBy().isEmpty()) {
723 builder.end();
724 }
725 }
726 return builder.getRoot();
727
728 }
729
730 private static void emitUnreachableSpecializations(final CodeTreeBuilder builder, NodeData node) {
731 for (SpecializationData current : node.getSpecializations()) {
732 if (current.isReachable()) {
733 continue;
734 }
735 builder.string("// unreachable ").string(current.getId()).newLine();
736 }
737 }
738
739 protected CodeTree createExecuteTree(CodeTreeBuilder outerParent, final SpecializationData source, final SpecializationGroup group, final CodeBlock<SpecializationData> guardedblock,
740 final CodeTree elseBlock, boolean forceElse, final boolean emitAssumptions, final boolean typedCasts, final boolean castForGuardsOnly) {
741 return guard(outerParent, source, group, new CodeBlock<Integer>() {
742
743 public CodeTree create(CodeTreeBuilder parent, Integer ifCount) {
744 CodeTreeBuilder builder = parent.create();
745
746 if (group.getSpecialization() != null) {
747 builder.tree(guardedblock.create(builder, group.getSpecialization()));
748
749 assert group.getChildren().isEmpty() : "missed a specialization";
750
751 } else {
752 for (SpecializationGroup childGroup : group.getChildren()) {
753 builder.tree(createExecuteTree(builder, source, childGroup, guardedblock, null, false, emitAssumptions, typedCasts, castForGuardsOnly));
754 }
755 }
756
757 return builder.getRoot();
758 }
759 }, elseBlock, forceElse, emitAssumptions, typedCasts, castForGuardsOnly);
760 }
761
762 private CodeTree guard(CodeTreeBuilder parent, SpecializationData source, SpecializationGroup group, CodeBlock<Integer> bodyBlock, CodeTree elseBlock, boolean forceElse, boolean emitAssumptions,
763 boolean typedCasts, boolean castForGuardsOnly) {
764 CodeTreeBuilder builder = parent.create();
765
766 int ifCount = emitGuards(builder, source, group, emitAssumptions, typedCasts, castForGuardsOnly);
767
768 if (isReachableGroup(group, ifCount)) {
769 builder.tree(bodyBlock.create(builder, ifCount));
770 }
771
772 builder.end(ifCount);
773
774 if (elseBlock != null) {
775 if (ifCount > 0 || forceElse) {
776 builder.tree(elseBlock);
777 }
778 }
779
780 return builder.getRoot();
781 }
782
783 private static boolean isReachableGroup(SpecializationGroup group, int ifCount) {
784 if (ifCount != 0) {
785 return true;
786 }
787 SpecializationGroup previous = group.getPreviousGroup();
788 if (previous == null || previous.findElseConnectableGuards().isEmpty()) {
789 return true;
790 }
791
792 /*
793 * Hacky else case. In this case the specialization is not reachable due to previous else
794 * branch. This is only true if the minimum state is not checked.
795 */
796 if (previous.getGuards().size() == 1 && previous.getTypeGuards().isEmpty() && previous.getAssumptions().isEmpty() &&
797 (previous.getParent() == null || previous.getMaxSpecializationIndex() != previous.getParent().getMaxSpecializationIndex())) {
798 return false;
799 }
800
801 return true;
802 }
803
804 private int emitGuards(CodeTreeBuilder builder, SpecializationData source, SpecializationGroup group, boolean emitAssumptions, boolean typedCasts, boolean castForGuardsOnly) {
805 NodeData node = source.getNode();
806
807 CodeTreeBuilder guardsBuilder = builder.create();
808 CodeTreeBuilder castBuilder = builder.create();
809 CodeTreeBuilder guardsCastBuilder = builder.create();
810
811 String guardsAnd = "";
812 String guardsCastAnd = "";
813
814 if (emitAssumptions) {
815 for (String assumption : group.getAssumptions()) {
816 guardsBuilder.string(guardsAnd);
817 guardsBuilder.string("this");
818 guardsBuilder.string(".").string(assumption).string(".isValid()");
819 guardsAnd = " && ";
820 }
821 }
822
823 for (TypeGuard typeGuard : group.getTypeGuards()) {
824 Parameter valueParam = source.getSignatureParameter(typeGuard.getSignatureIndex());
825
826 if (valueParam == null) {
827 /*
828 * If used inside a execute evaluated method then the value param may not exist. In
829 * that case we assume that the value is executed generic or of the current
830 * specialization.
831 */
832 if (group.getSpecialization() != null) {
833 valueParam = group.getSpecialization().getSignatureParameter(typeGuard.getSignatureIndex());
834 } else {
835 valueParam = node.getGenericSpecialization().getSignatureParameter(typeGuard.getSignatureIndex());
836 }
837 }
838
839 NodeExecutionData execution = valueParam.getSpecification().getExecution();
840 CodeTree implicitGuard = createTypeGuard(guardsBuilder, execution, valueParam, typeGuard.getType(), typedCasts);
841 if (implicitGuard != null) {
842 guardsBuilder.string(guardsAnd);
843 guardsBuilder.tree(implicitGuard);
844 guardsAnd = " && ";
845 }
846
847 CodeTree implicitGetType = null;
848 if (castForGuardsOnly) {
849 implicitGetType = createGetImplicitType(builder, execution, valueParam, typeGuard.getType());
850 }
851
852 boolean performCast = true;
853 if (castForGuardsOnly) {
854 // if cast for guards we just cast if the type guard is used inside a guard.
855 performCast = group.isTypeGuardUsedInAnyGuardBelow(context, source, typeGuard);
856 }
857
858 if (performCast) {
859 CodeTree cast = createCast(castBuilder, execution, valueParam, typeGuard.getType(), typedCasts);
860 if (cast != null) {
861 castBuilder.tree(cast);
862 }
863 }
864 if (implicitGetType != null) {
865 castBuilder.tree(implicitGetType);
866 }
867 }
868 List<GuardExpression> elseGuards = group.findElseConnectableGuards();
869
870 for (GuardExpression guard : group.getGuards()) {
871 if (elseGuards.contains(guard)) {
872 continue;
873 }
874
875 if (needsTypeGuard(source, group, guard)) {
876 guardsCastBuilder.tree(createMethodGuard(builder, guardsCastAnd, source, guard));
877 guardsCastAnd = " && ";
878 } else {
879 guardsBuilder.tree(createMethodGuard(builder, guardsAnd, source, guard));
880 guardsAnd = " && ";
881 }
882 }
883
884 int ifCount = startGuardIf(builder, guardsBuilder, 0, elseGuards);
885 builder.tree(castBuilder.getRoot());
886 ifCount = startGuardIf(builder, guardsCastBuilder, ifCount, elseGuards);
887 return ifCount;
888 }
889
890 private static int startGuardIf(CodeTreeBuilder builder, CodeTreeBuilder conditionBuilder, int ifCount, List<GuardExpression> elseGuard) {
891 int newIfCount = ifCount;
892
893 if (!conditionBuilder.isEmpty()) {
894 if (ifCount == 0 && !elseGuard.isEmpty()) {
895 builder.startElseIf();
896 } else {
897 builder.startIf();
898 }
899 builder.tree(conditionBuilder.getRoot());
900 builder.end().startBlock();
901 newIfCount++;
902 } else if (ifCount == 0 && !elseGuard.isEmpty()) {
903 builder.startElseBlock();
904 newIfCount++;
905 }
906 return newIfCount;
907 }
908
909 private static boolean needsTypeGuard(SpecializationData source, SpecializationGroup group, GuardExpression guard) {
910 for (Parameter parameter : guard.getResolvedGuard().getParameters()) {
911 if (!parameter.getSpecification().isSignature()) {
912 continue;
913 }
914
915 int signatureIndex = source.getNode().getChildExecutions().indexOf(parameter.getSpecification().getExecution());
916 if (signatureIndex == -1) {
917 continue;
918 }
919
920 TypeGuard typeGuard = group.findTypeGuard(signatureIndex);
921 if (typeGuard != null) {
922 TypeData requiredType = typeGuard.getType();
923
924 Parameter sourceParameter = source.findParameter(parameter.getLocalName());
925 if (sourceParameter == null) {
926 sourceParameter = source.getNode().getGenericSpecialization().findParameter(parameter.getLocalName());
927 }
928
929 if (ElementUtils.needsCastTo(sourceParameter.getType(), requiredType.getPrimitiveType())) {
930 return true;
931 }
932 }
933 }
934 return false;
935 }
936
937 private CodeTree createTypeGuard(CodeTreeBuilder parent, NodeExecutionData execution, Parameter source, TypeData targetType, boolean typedCasts) {
938 NodeData node = execution.getChild().getNodeData();
939
940 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
941
942 TypeData sourceType = source.getTypeSystemType();
943
944 if (!sourceType.needsCastTo(targetType)) {
945 return null;
946 }
947
948 builder.startGroup();
949
950 if (execution.isShortCircuit()) {
951 Parameter shortCircuit = source.getPreviousParameter();
952 assert shortCircuit != null;
953 builder.string("(");
954 builder.string("!").string(valueName(shortCircuit));
955 builder.string(" || ");
956 }
957
958 String castMethodName;
959 String castTypeName = null;
960 List<TypeData> types = getModel().getNode().getTypeSystem().lookupSourceTypes(targetType);
961 if (types.size() > 1) {
962 castMethodName = TypeSystemCodeGenerator.isImplicitTypeMethodName(targetType);
963 if (typedCasts) {
964 castTypeName = implicitTypeName(source);
965 }
966 } else {
967 castMethodName = TypeSystemCodeGenerator.isTypeMethodName(targetType);
968 }
969
970 startCallTypeSystemMethod(builder, node.getTypeSystem(), castMethodName);
971 builder.string(valueName(source));
972 if (castTypeName != null) {
973 builder.string(castTypeName);
974 }
975 builder.end().end(); // call
976
977 if (execution.isShortCircuit()) {
978 builder.string(")");
979 }
980
981 builder.end(); // group
982
983 return builder.getRoot();
984 }
985
986 // TODO merge redundancies with #createTypeGuard
987 private CodeTree createCast(CodeTreeBuilder parent, NodeExecutionData execution, Parameter source, TypeData targetType, boolean typedCasts) {
988 NodeData node = execution.getChild().getNodeData();
989 TypeData sourceType = source.getTypeSystemType();
990
991 if (!sourceType.needsCastTo(targetType)) {
992 return null;
993 }
994
995 CodeTree condition = null;
996 if (execution.isShortCircuit()) {
997 Parameter shortCircuit = source.getPreviousParameter();
998 assert shortCircuit != null;
999 condition = CodeTreeBuilder.singleString(valueName(shortCircuit));
1000 }
1001
1002 String castMethodName;
1003 String castTypeName = null;
1004 List<TypeData> types = getModel().getNode().getTypeSystem().lookupSourceTypes(targetType);
1005 if (types.size() > 1) {
1006 castMethodName = TypeSystemCodeGenerator.asImplicitTypeMethodName(targetType);
1007 if (typedCasts) {
1008 castTypeName = implicitTypeName(source);
1009 }
1010 } else {
1011 castMethodName = TypeSystemCodeGenerator.asTypeMethodName(targetType);
1012 }
1013
1014 List<CodeTree> args = new ArrayList<>();
1015 args.add(CodeTreeBuilder.singleString(valueName(source)));
1016 if (castTypeName != null) {
1017 args.add(CodeTreeBuilder.singleString(castTypeName));
1018 }
1019
1020 CodeTree cast = createCallTypeSystemMethod(parent, node, castMethodName, args.toArray(new CodeTree[0]));
1021
1022 CodeTreeBuilder builder = parent.create();
1023 builder.tree(createLazyAssignment(parent, castValueName(source), targetType.getPrimitiveType(), condition, cast));
1024
1025 return builder.getRoot();
1026 }
1027
1028 private CodeTree createGetImplicitType(CodeTreeBuilder parent, NodeExecutionData execution, Parameter source, TypeData targetType) {
1029 CodeTree condition = null;
1030 if (execution.isShortCircuit()) {
1031 Parameter shortCircuit = source.getPreviousParameter();
1032 assert shortCircuit != null;
1033 condition = CodeTreeBuilder.singleString(valueName(shortCircuit));
1034 }
1035
1036 CodeTreeBuilder builder = parent.create();
1037 List<TypeData> types = getModel().getNode().getTypeSystem().lookupSourceTypes(targetType);
1038 if (types.size() > 1) {
1039 CodeTree castType = createCallTypeSystemMethod(parent, execution.getChild().getNodeData(), TypeSystemCodeGenerator.getImplicitClass(targetType),
1040 CodeTreeBuilder.singleString(valueName(source)));
1041 builder.tree(createLazyAssignment(builder, implicitTypeName(source), getContext().getType(Class.class), condition, castType));
1042 }
1043 return builder.getRoot();
1044 }
1045
1046 private static CodeTree createMethodGuard(CodeTreeBuilder parent, String prefix, SpecializationData source, GuardExpression guard) {
1047 CodeTreeBuilder builder = parent.create();
1048 builder.string(prefix);
1049 if (guard.isNegated()) {
1050 builder.string("!");
1051 }
1052 builder.tree(createTemplateMethodCall(builder, null, source, guard.getResolvedGuard(), null));
1053 return builder.getRoot();
1054 }
1055
1056 protected CodeTree createGenericInvoke(CodeTreeBuilder parent, SpecializationData source, SpecializationData current) {
1057 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
1058
1059 if (current.getMethod() == null) {
1060 emitEncounteredSynthetic(builder, getModel().getNode(), current);
1061 } else {
1062 builder.startReturn().tree(createTemplateMethodCall(builder, null, source, current, null)).end();
1063 }
1064
1065 return encloseThrowsWithFallThrough(parent, current, builder.getRoot());
1066 }
1067
1068 private CodeTree encloseThrowsWithFallThrough(CodeTreeBuilder parent, SpecializationData current, CodeTree tree) {
1069 if (current.getExceptions().isEmpty()) {
1070 return tree;
1071 }
1072 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
1073
1074 builder.startTryBlock();
1075 builder.tree(tree);
1076 for (SpecializationThrowsData exception : current.getExceptions()) {
1077 builder.end().startCatchBlock(exception.getJavaClass(), "rewriteEx");
1078 builder.tree(createDeoptimize(builder));
1079 builder.tree(createCallRewriteMonomorphic(builder, false, current.getNode().getGenericSpecialization().getReturnType().getTypeSystemType(), current, null,
1080 "Thrown " + ElementUtils.getSimpleName(exception.getJavaClass())));
1081 }
1082 builder.end();
1083
1084 return builder.getRoot();
1085 }
1086
1087 protected CodeTree createCastingExecute(CodeTreeBuilder parent, SpecializationData specialization, ExecutableTypeData executable, ExecutableTypeData castExecutable) {
1088 TypeData type = executable.getType();
1089 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
1090 NodeData node = specialization.getNode();
1091
1092 TypeData primaryType = castExecutable.getType();
1093
1094 boolean needsTry = castExecutable.hasUnexpectedValue(getContext());
1095 boolean returnVoid = type.isVoid();
1096
1097 List<Parameter> executeParameters = new ArrayList<>();
1098 for (Parameter sourceParameter : executable.getSignatureParameters()) {
1099 Parameter targetParameter = castExecutable.findParameter(sourceParameter.getLocalName());
1100 if (targetParameter != null) {
1101 executeParameters.add(targetParameter);
1102 }
1103 }
1104
1105 // execute names are enforced no cast
1106 String[] executeParameterNames = new String[executeParameters.size()];
1107 for (int i = 0; i < executeParameterNames.length; i++) {
1108 executeParameterNames[i] = valueName(executeParameters.get(i));
1109 }
1110
1111 builder.tree(createExecuteChildren(builder, executable, specialization, executeParameters, null));
1112 boolean hasUnexpected = executable.hasUnexpectedValue(getContext());
1113
1114 CodeTree primaryExecuteCall = createTemplateMethodCall(builder, null, executable, castExecutable, null, executeParameterNames);
1115 if (needsTry) {
1116 if (!returnVoid) {
1117 builder.declaration(primaryType.getPrimitiveType(), "value");
1118 }
1119 builder.startTryBlock();
1120
1121 if (returnVoid) {
1122 builder.statement(primaryExecuteCall);
1123 } else {
1124 builder.startStatement();
1125 builder.string("value = ");
1126 builder.tree(primaryExecuteCall);
1127 builder.end();
1128 }
1129
1130 builder.end().startCatchBlock(getUnexpectedValueException(), "ex");
1131 if (returnVoid) {
1132 builder.string("// ignore").newLine();
1133 } else {
1134 builder.startReturn();
1135 builder.tree(createExpectExecutableType(node, specialization.getNode().getTypeSystem().getGenericTypeData(), hasUnexpected, executable.getType(),
1136 CodeTreeBuilder.singleString("ex.getResult()")));
1137 builder.end();
1138 }
1139 builder.end();
1140
1141 if (!returnVoid) {
1142 builder.startReturn();
1143 builder.tree(createExpectExecutableType(node, castExecutable.getReturnType().getTypeSystemType(), hasUnexpected, executable.getType(), CodeTreeBuilder.singleString("value")));
1144 builder.end();
1145 }
1146 } else {
1147 if (returnVoid) {
1148 builder.statement(primaryExecuteCall);
1149 } else {
1150 builder.startReturn();
1151 builder.tree(createExpectExecutableType(node, castExecutable.getReturnType().getTypeSystemType(), hasUnexpected, executable.getType(), primaryExecuteCall));
1152 builder.end();
1153 }
1154 }
1155
1156 return builder.getRoot();
1157 }
1158
1159 private static CodeTree createExpectExecutableType(NodeData node, TypeData sourceType, boolean hasUnexpected, TypeData exepctedType, CodeTree value) {
1160 return createCastType(node.getTypeSystem(), sourceType, exepctedType, hasUnexpected, value);
1161 }
1162
1163 protected CodeTree createExecuteChildren(CodeTreeBuilder parent, ExecutableTypeData sourceExecutable, SpecializationData specialization, List<Parameter> targetParameters,
1164 Parameter unexpectedParameter) {
1165 CodeTreeBuilder builder = parent.create();
1166 for (Parameter targetParameter : targetParameters) {
1167 if (!targetParameter.getSpecification().isSignature()) {
1168 continue;
1169 }
1170 NodeExecutionData execution = targetParameter.getSpecification().getExecution();
1171 CodeTree executionExpressions = createExecuteChild(builder, execution, sourceExecutable, targetParameter, unexpectedParameter);
1172 CodeTree unexpectedTree = createCatchUnexpectedTree(builder, executionExpressions, specialization, sourceExecutable, targetParameter, execution.isShortCircuit(), unexpectedParameter);
1173 CodeTree shortCircuitTree = createShortCircuitTree(builder, unexpectedTree, specialization, targetParameter, unexpectedParameter);
1174
1175 if (shortCircuitTree == executionExpressions) {
1176 if (containsNewLine(executionExpressions)) {
1177 builder.declaration(targetParameter.getType(), valueName(targetParameter));
1178 builder.tree(shortCircuitTree);
1179 } else {
1180 builder.startStatement().type(targetParameter.getType()).string(" ").tree(shortCircuitTree).end();
1181 }
1182 } else {
1183 builder.tree(shortCircuitTree);
1184 }
1185
1186 }
1187 return builder.getRoot();
1188 }
1189
1190 private ExecutableTypeData resolveExecutableType(NodeExecutionData execution, TypeData type) {
1191 ExecutableTypeData targetExecutable = execution.getChild().findExecutableType(getContext(), type);
1192 if (targetExecutable == null) {
1193 targetExecutable = execution.getChild().findAnyGenericExecutableType(getContext());
1194 }
1195 return targetExecutable;
1196 }
1197
1198 private CodeTree createExecuteChild(CodeTreeBuilder parent, NodeExecutionData execution, ExecutableTypeData sourceExecutable, Parameter targetParameter, Parameter unexpectedParameter) {
1199 SpecializationData specialization = getModel();
1200 if (specialization.isPolymorphic() && targetParameter.getTypeSystemType().isGeneric() && unexpectedParameter == null) {
1201 List<TypeData> possiblePolymorphicTypes = lookupPolymorphicTargetTypes(targetParameter);
1202 if (possiblePolymorphicTypes.size() > 1) {
1203 CodeTreeBuilder builder = parent.create();
1204
1205 boolean elseIf = false;
1206 for (TypeData possiblePolymoprhicType : possiblePolymorphicTypes) {
1207 if (possiblePolymoprhicType.isGeneric()) {
1208 continue;
1209 }
1210 elseIf = builder.startIf(elseIf);
1211
1212 Parameter sourceParameter = sourceExecutable.findParameter(targetParameter.getLocalName());
1213 TypeData sourceType = sourceParameter != null ? sourceParameter.getTypeSystemType() : null;
1214 builder.string(polymorphicTypeName(targetParameter.getSpecification().getExecution())).string(" == ").typeLiteral(possiblePolymoprhicType.getPrimitiveType());
1215 builder.end().startBlock();
1216 builder.startStatement();
1217 builder.tree(createExecuteChildExpression(parent, execution, sourceType, new Parameter(targetParameter, possiblePolymoprhicType), unexpectedParameter, null));
1218 builder.end();
1219 builder.end();
1220 }
1221
1222 builder.startElseBlock();
1223 builder.startStatement().tree(createExecuteChildImplicit(parent, execution, sourceExecutable, targetParameter, unexpectedParameter)).end();
1224 builder.end();
1225
1226 return builder.getRoot();
1227 }
1228 }
1229 return createExecuteChildImplicit(parent, execution, sourceExecutable, targetParameter, unexpectedParameter);
1230 }
1231
1232 protected static final List<Parameter> getImplicitTypeParameters(SpecializationData model) {
1233 List<Parameter> parameter = new ArrayList<>();
1234 for (Parameter param : model.getSignatureParameters()) {
1235 NodeChildData child = param.getSpecification().getExecution().getChild();
1236 List<TypeData> types = child.getNodeData().getTypeSystem().lookupSourceTypes(param.getTypeSystemType());
1237 if (types.size() > 1) {
1238 parameter.add(param);
1239 }
1240 }
1241 return parameter;
1242 }
1243
1244 private final List<TypeData> lookupPolymorphicTargetTypes(Parameter param) {
1245 SpecializationData specialization = getModel();
1246 Set<TypeData> possiblePolymorphicTypes = new HashSet<>();
1247 for (SpecializationData otherSpecialization : specialization.getNode().getSpecializations()) {
1248 if (!otherSpecialization.isSpecialized()) {
1249 continue;
1250 }
1251 Parameter otherParameter = otherSpecialization.findParameter(param.getLocalName());
1252 if (otherParameter != null) {
1253 possiblePolymorphicTypes.add(otherParameter.getTypeSystemType());
1254 }
1255 }
1256 List<TypeData> types = new ArrayList<>(possiblePolymorphicTypes);
1257 Collections.sort(types);
1258 return types;
1259 }
1260
1261 private CodeTree createExecuteChildImplicit(CodeTreeBuilder parent, NodeExecutionData execution, ExecutableTypeData sourceExecutable, Parameter param, Parameter unexpectedParameter) {
1262 CodeTreeBuilder builder = parent.create();
1263 Parameter sourceParameter = sourceExecutable.findParameter(param.getLocalName());
1264 String childExecuteName = createExecuteChildMethodName(param, sourceParameter != null);
1265 if (childExecuteName != null) {
1266 builder.string(valueName(param));
1267 builder.string(" = ");
1268 builder.startCall(childExecuteName);
1269
1270 for (Parameter parameters : sourceExecutable.getParameters()) {
1271 if (parameters.getSpecification().isSignature()) {
1272 continue;
1273 }
1274 builder.string(parameters.getLocalName());
1275 }
1276
1277 if (sourceParameter != null) {
1278 builder.string(valueNameEvaluated(sourceParameter));
1279 }
1280
1281 builder.string(implicitTypeName(param));
1282
1283 builder.end();
1284 } else {
1285 List<TypeData> sourceTypes = execution.getChild().getNodeData().getTypeSystem().lookupSourceTypes(param.getTypeSystemType());
1286 TypeData expectType = sourceParameter != null ? sourceParameter.getTypeSystemType() : null;
1287 if (sourceTypes.size() > 1) {
1288 builder.tree(createExecuteChildImplicitExpressions(parent, param, expectType));
1289 } else {
1290 builder.tree(createExecuteChildExpression(parent, execution, expectType, param, unexpectedParameter, null));
1291 }
1292 }
1293 return builder.getRoot();
1294 }
1295
1296 private static String createExecuteChildMethodName(Parameter param, boolean expect) {
1297 NodeExecutionData execution = param.getSpecification().getExecution();
1298 NodeChildData child = execution.getChild();
1299 if (child.getExecuteWith().size() > 0) {
1300 return null;
1301 }
1302 List<TypeData> sourceTypes = child.getNodeData().getTypeSystem().lookupSourceTypes(param.getTypeSystemType());
1303 if (sourceTypes.size() <= 1) {
1304 return null;
1305 }
1306 String prefix = expect ? "expect" : "execute";
1307 String suffix = execution.getIndex() > -1 ? String.valueOf(execution.getIndex()) : "";
1308 return prefix + ElementUtils.firstLetterUpperCase(child.getName()) + ElementUtils.firstLetterUpperCase(ElementUtils.getTypeId(param.getType())) + suffix;
1309 }
1310
1311 private List<CodeExecutableElement> createExecuteChilds(Parameter param, Set<TypeData> expectTypes) {
1312 CodeExecutableElement executeMethod = createExecuteChild(param, null);
1313 if (executeMethod == null) {
1314 return Collections.emptyList();
1315 }
1316 List<CodeExecutableElement> childs = new ArrayList<>();
1317 childs.add(executeMethod);
1318
1319 for (TypeData expectType : expectTypes) {
1320 CodeExecutableElement method = createExecuteChild(param, expectType);
1321 if (method != null) {
1322 childs.add(method);
1323 }
1324 }
1325 return childs;
1326 }
1327
1328 private CodeExecutableElement createExecuteChild(Parameter param, TypeData expectType) {
1329 String childExecuteName = createExecuteChildMethodName(param, expectType != null);
1330 if (childExecuteName == null) {
1331 return null;
1332 }
1333
1334 CodeExecutableElement method = new CodeExecutableElement(modifiers(PROTECTED, expectType != null ? STATIC : FINAL), param.getType(), childExecuteName);
1335 method.getThrownTypes().add(getContext().getTruffleTypes().getUnexpectedValueException());
1336 method.addParameter(new CodeVariableElement(getContext().getTruffleTypes().getFrame(), "frameValue"));
1337 if (expectType != null) {
1338 method.addParameter(new CodeVariableElement(expectType.getPrimitiveType(), valueNameEvaluated(param)));
1339 }
1340 method.addParameter(new CodeVariableElement(getContext().getType(Class.class), implicitTypeName(param)));
1341
1342 CodeTreeBuilder builder = method.createBuilder();
1343 builder.declaration(param.getType(), valueName(param));
1344 builder.tree(createExecuteChildImplicitExpressions(builder, param, expectType));
1345 builder.startReturn().string(valueName(param)).end();
1346
1347 return method;
1348 }
1349
1350 private CodeTree createExecuteChildImplicitExpressions(CodeTreeBuilder parent, Parameter targetParameter, TypeData expectType) {
1351 CodeTreeBuilder builder = parent.create();
1352 NodeData node = getModel().getNode();
1353 NodeExecutionData execution = targetParameter.getSpecification().getExecution();
1354 List<TypeData> sourceTypes = node.getTypeSystem().lookupSourceTypes(targetParameter.getTypeSystemType());
1355 boolean elseIf = false;
1356 int index = 0;
1357 for (TypeData sourceType : sourceTypes) {
1358 if (index < sourceTypes.size() - 1) {
1359 elseIf = builder.startIf(elseIf);
1360 builder.string(implicitTypeName(targetParameter)).string(" == ").typeLiteral(sourceType.getPrimitiveType());
1361 builder.end();
1362 builder.startBlock();
1363 } else {
1364 builder.startElseBlock();
1365 }
1366
1367 ExecutableTypeData implictExecutableTypeData = execution.getChild().findExecutableType(getContext(), sourceType);
1368 if (implictExecutableTypeData == null) {
1369 /*
1370 * For children with executeWith.size() > 0 an executable type may not exist so use
1371 * the generic executable type which is guaranteed to exist. An expect call is
1372 * inserted automatically by #createExecuteExpression.
1373 */
1374 implictExecutableTypeData = execution.getChild().getNodeData().findExecutableType(node.getTypeSystem().getGenericTypeData(), execution.getChild().getExecuteWith().size());
1375 }
1376
1377 ImplicitCastData cast = execution.getChild().getNodeData().getTypeSystem().lookupCast(sourceType, targetParameter.getTypeSystemType());
1378 CodeTree execute = createExecuteChildExpression(builder, execution, expectType, targetParameter, null, cast);
1379 builder.statement(execute);
1380 builder.end();
1381 index++;
1382 }
1383 return builder.getRoot();
1384 }
1385
1386 private CodeTree createExecuteChildExpression(CodeTreeBuilder parent, NodeExecutionData execution, TypeData sourceParameterType, Parameter targetParameter, Parameter unexpectedParameter,
1387 ImplicitCastData cast) {
1388 // assignments: targetType <- castTargetType <- castSourceType <- sourceType
1389 TypeData sourceType = sourceParameterType;
1390 TypeData targetType = targetParameter.getTypeSystemType();
1391 TypeData castSourceType = targetType;
1392 TypeData castTargetType = targetType;
1393
1394 if (cast != null) {
1395 castSourceType = cast.getSourceType();
1396 castTargetType = cast.getTargetType();
1397 }
1398
1399 CodeTree expression;
1400 if (sourceType == null) {
1401 ExecutableTypeData targetExecutable = resolveExecutableType(execution, castSourceType);
1402 expression = createExecuteChildExpression(parent, execution, targetExecutable, unexpectedParameter);
1403 sourceType = targetExecutable.getType();
1404 } else {
1405 expression = CodeTreeBuilder.singleString(valueNameEvaluated(targetParameter));
1406 }
1407
1408 // target = expectTargetType(implicitCast(expectCastSourceType(source)))
1409 TypeSystemData typeSystem = execution.getChild().getNodeData().getTypeSystem();
1410 expression = createExpectType(typeSystem, sourceType, castSourceType, expression);
1411 expression = createImplicitCast(parent, typeSystem, cast, expression);
1412 expression = createExpectType(typeSystem, castTargetType, targetType, expression);
1413
1414 CodeTreeBuilder builder = parent.create();
1415 builder.string(valueName(targetParameter));
1416 builder.string(" = ");
1417 builder.tree(expression);
1418 return builder.getRoot();
1419 }
1420
1421 private static CodeTree createImplicitCast(CodeTreeBuilder parent, TypeSystemData typeSystem, ImplicitCastData cast, CodeTree expression) {
1422 if (cast == null) {
1423 return expression;
1424 }
1425 CodeTreeBuilder builder = parent.create();
1426 startCallTypeSystemMethod(builder, typeSystem, cast.getMethodName());
1427 builder.tree(expression);
1428 builder.end().end();
1429 return builder.getRoot();
1430 }
1431
1432 private boolean containsNewLine(CodeTree tree) {
1433 if (tree.getCodeKind() == CodeTreeKind.NEW_LINE) {
1434 return true;
1435 }
1436
1437 List<CodeTree> enclosing = tree.getEnclosedElements();
1438 if (enclosing != null) {
1439 for (CodeTree codeTree : enclosing) {
1440 if (containsNewLine(codeTree)) {
1441 return true;
1442 }
1443 }
1444 }
1445 return false;
1446 }
1447
1448 private boolean hasUnexpected(Parameter sourceParameter, Parameter targetParameter, Parameter unexpectedParameter) {
1449 NodeExecutionData execution = targetParameter.getSpecification().getExecution();
1450
1451 if (getModel().isPolymorphic() && targetParameter.getTypeSystemType().isGeneric() && unexpectedParameter == null) {
1452 // check for other polymorphic types
1453 List<TypeData> polymorphicTargetTypes = lookupPolymorphicTargetTypes(targetParameter);
1454 if (polymorphicTargetTypes.size() > 1) {
1455 for (TypeData polymorphicTargetType : polymorphicTargetTypes) {
1456 if (hasUnexpectedType(execution, sourceParameter, polymorphicTargetType)) {
1457 return true;
1458 }
1459 }
1460 }
1461 }
1462
1463 if (hasUnexpectedType(execution, sourceParameter, targetParameter.getTypeSystemType())) {
1464 return true;
1465 }
1466 return false;
1467 }
1468
1469 private boolean hasUnexpectedType(NodeExecutionData execution, Parameter sourceParameter, TypeData targetType) {
1470 List<TypeData> implicitSourceTypes = getModel().getNode().getTypeSystem().lookupSourceTypes(targetType);
1471
1472 for (TypeData implicitSourceType : implicitSourceTypes) {
1473 TypeData sourceType;
1474 ExecutableTypeData targetExecutable = resolveExecutableType(execution, implicitSourceType);
1475 if (sourceParameter != null) {
1476 sourceType = sourceParameter.getTypeSystemType();
1477 } else {
1478 if (targetExecutable.hasUnexpectedValue(getContext())) {
1479 return true;
1480 }
1481 sourceType = targetExecutable.getType();
1482 }
1483
1484 ImplicitCastData cast = getModel().getNode().getTypeSystem().lookupCast(implicitSourceType, targetType);
1485 if (cast != null) {
1486 if (cast.getSourceType().needsCastTo(targetType)) {
1487 return true;
1488 }
1489 }
1490
1491 if (sourceType.needsCastTo(targetType)) {
1492 return true;
1493 }
1494 }
1495 return false;
1496 }
1497
1498 private CodeTree createCatchUnexpectedTree(CodeTreeBuilder parent, CodeTree body, SpecializationData specialization, ExecutableTypeData currentExecutable, Parameter param, boolean shortCircuit,
1499 Parameter unexpectedParameter) {
1500 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
1501 Parameter sourceParameter = currentExecutable.findParameter(param.getLocalName());
1502 boolean unexpected = hasUnexpected(sourceParameter, param, unexpectedParameter);
1503 if (!unexpected) {
1504 return body;
1505 }
1506
1507 if (!shortCircuit) {
1508 builder.declaration(param.getType(), valueName(param));
1509 }
1510 builder.startTryBlock();
1511
1512 if (containsNewLine(body)) {
1513 builder.tree(body);
1514 } else {
1515 builder.statement(body);
1516 }
1517
1518 builder.end().startCatchBlock(getUnexpectedValueException(), "ex");
1519 SpecializationData generic = specialization.getNode().getGenericSpecialization();
1520 Parameter genericParameter = generic.findParameter(param.getLocalName());
1521
1522 List<Parameter> genericParameters = generic.getParametersAfter(genericParameter);
1523 builder.tree(createExecuteChildren(parent, currentExecutable, generic, genericParameters, genericParameter));
1524 if (specialization.isPolymorphic()) {
1525 builder.tree(createReturnOptimizeTypes(builder, currentExecutable, specialization, param));
1526 } else {
1527 builder.tree(createCallRewriteMonomorphic(builder, currentExecutable.hasUnexpectedValue(context), currentExecutable.getType(), specialization, param, "Expected " + param.getLocalName() +
1528 " instanceof " + ElementUtils.getSimpleName(param.getType())));
1529 }
1530 builder.end(); // catch block
1531
1532 return builder.getRoot();
1533 }
1534
1535 private CodeTree createReturnOptimizeTypes(CodeTreeBuilder parent, ExecutableTypeData currentExecutable, SpecializationData specialization, Parameter param) {
1536 NodeData node = specialization.getNode();
1537 SpecializationData polymorphic = node.getPolymorphicSpecialization();
1538
1539 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
1540 builder.startStatement().string(polymorphicTypeName(param.getSpecification().getExecution())).string(" = ").typeLiteral(getContext().getType(Object.class)).end();
1541
1542 builder.startReturn();
1543
1544 CodeTreeBuilder execute = new CodeTreeBuilder(builder);
1545 execute.startCall("next0", EXECUTE_CHAINED);
1546 addInternalValueParameterNames(execute, specialization, polymorphic, param.getLocalName(), true, false, null);
1547 execute.end();
1548
1549 TypeData sourceType = polymorphic.getReturnType().getTypeSystemType();
1550
1551 builder.tree(createExpectExecutableType(node, sourceType, currentExecutable.hasUnexpectedValue(context), currentExecutable.getType(), execute.getRoot()));
1552
1553 builder.end();
1554 return builder.getRoot();
1555 }
1556
1557 private CodeTree createExecuteChildExpression(CodeTreeBuilder parent, NodeExecutionData targetExecution, ExecutableTypeData targetExecutable, Parameter unexpectedParameter) {
1558 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
1559 if (targetExecution != null) {
1560 builder.tree(createAccessChild(targetExecution, null));
1561 builder.string(".");
1562 }
1563
1564 builder.startCall(targetExecutable.getMethodName());
1565
1566 // TODO this should be merged with #createTemplateMethodCall
1567 int index = 0;
1568 for (Parameter parameter : targetExecutable.getParameters()) {
1569
1570 if (!parameter.getSpecification().isSignature()) {
1571 builder.string(parameter.getLocalName());
1572 } else {
1573
1574 if (index < targetExecution.getChild().getExecuteWith().size()) {
1575 NodeChildData child = targetExecution.getChild().getExecuteWith().get(index);
1576
1577 ParameterSpec spec = getModel().getSpecification().findParameterSpec(child.getName());
1578 List<Parameter> specializationParams = getModel().findParameters(spec);
1579
1580 if (specializationParams.isEmpty()) {
1581 builder.defaultValue(parameter.getType());
1582 continue;
1583 }
1584
1585 Parameter specializationParam = specializationParams.get(0);
1586
1587 TypeData targetType = parameter.getTypeSystemType();
1588 TypeData sourceType = specializationParam.getTypeSystemType();
1589 String localName = specializationParam.getLocalName();
1590
1591 if (unexpectedParameter != null && unexpectedParameter.getLocalName().equals(specializationParam.getLocalName())) {
1592 localName = "ex.getResult()";
1593 sourceType = getModel().getNode().getTypeSystem().getGenericTypeData();
1594 }
1595
1596 CodeTree value = CodeTreeBuilder.singleString(localName);
1597
1598 if (sourceType.needsCastTo(targetType)) {
1599 value = createCallTypeSystemMethod(builder, getModel().getNode(), TypeSystemCodeGenerator.asTypeMethodName(targetType), value);
1600 }
1601 builder.tree(value);
1602 } else {
1603 builder.defaultValue(parameter.getType());
1604 }
1605 index++;
1606 }
1607 }
1608
1609 builder.end();
1610
1611 return builder.getRoot();
1612 }
1613
1614 private CodeTree createShortCircuitTree(CodeTreeBuilder parent, CodeTree body, SpecializationData specialization, Parameter parameter, Parameter exceptionParam) {
1615 NodeExecutionData execution = parameter.getSpecification().getExecution();
1616 if (execution == null || !execution.isShortCircuit()) {
1617 return body;
1618 }
1619
1620 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
1621 Parameter shortCircuitParam = specialization.getPreviousParam(parameter);
1622 builder.tree(createShortCircuitValue(builder, specialization, execution, shortCircuitParam, exceptionParam));
1623 builder.declaration(parameter.getType(), valueName(parameter), CodeTreeBuilder.createBuilder().defaultValue(parameter.getType()));
1624 builder.startIf().string(shortCircuitParam.getLocalName()).end();
1625 builder.startBlock();
1626
1627 if (containsNewLine(body)) {
1628 builder.tree(body);
1629 } else {
1630 builder.statement(body);
1631 }
1632 builder.end();
1633
1634 return builder.getRoot();
1635 }
1636
1637 private static CodeTree createShortCircuitValue(CodeTreeBuilder parent, SpecializationData specialization, NodeExecutionData execution, Parameter shortCircuitParam, Parameter exceptionParam) {
1638 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
1639 int shortCircuitIndex = 0;
1640 for (NodeExecutionData otherExectuion : specialization.getNode().getChildExecutions()) {
1641 if (otherExectuion.isShortCircuit()) {
1642 if (otherExectuion == execution) {
1643 break;
1644 }
1645 shortCircuitIndex++;
1646 }
1647 }
1648
1649 builder.startStatement().type(shortCircuitParam.getType()).string(" ").string(valueName(shortCircuitParam)).string(" = ");
1650 ShortCircuitData shortCircuitData = specialization.getShortCircuits().get(shortCircuitIndex);
1651 builder.tree(createTemplateMethodCall(builder, null, specialization, shortCircuitData, exceptionParam != null ? exceptionParam.getLocalName() : null));
1652 builder.end(); // statement
1653
1654 return builder.getRoot();
1655 }
1656
1657 protected CodeTree createCallRewriteMonomorphic(CodeTreeBuilder parent, boolean hasUnexpected, TypeData returnType, SpecializationData current, Parameter exceptionParam, String reason) {
1658 NodeData node = current.getNode();
1659 SpecializationData generic = node.getGenericSpecialization();
1660 CodeTreeBuilder specializeCall = new CodeTreeBuilder(parent);
1661 specializeCall.startCall(REWRITE);
1662 addInternalValueParameterNames(specializeCall, generic, node.getGenericSpecialization(), exceptionParam != null ? exceptionParam.getLocalName() : null, true, false, null);
1663 specializeCall.doubleQuote(reason);
1664 specializeCall.end().end();
1665
1666 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
1667
1668 builder.startReturn();
1669 builder.tree(createExpectExecutableType(node, generic.getReturnType().getTypeSystemType(), hasUnexpected, returnType, specializeCall.getRoot()));
1670 builder.end();
1671
1672 return builder.getRoot();
1673 }
1674
1675 static String valueNameEvaluated(Parameter targetParameter) {
1676 return valueName(targetParameter) + "Evaluated";
1677 }
1678
1679 static String implicitTypeName(Parameter param) {
1680 return param.getLocalName() + "ImplicitType";
1681 }
1682
1683 static String polymorphicTypeName(NodeExecutionData param) {
1684 return param.getName() + "PolymorphicType";
1685 }
1686
1687 static String valueName(Parameter param) {
1688 return param.getLocalName();
1689 }
1690
1691 private static CodeTree createAccessChild(NodeExecutionData targetExecution, String thisReference) {
1692 String reference = thisReference;
1693 if (reference == null) {
1694 reference = "this";
1695 }
1696 CodeTreeBuilder builder = CodeTreeBuilder.createBuilder();
1697 Element accessElement = targetExecution.getChild().getAccessElement();
1698 if (accessElement == null || accessElement.getKind() == ElementKind.METHOD) {
1699 builder.string(reference).string(".").string(targetExecution.getChild().getName());
1700 } else if (accessElement.getKind() == ElementKind.FIELD) {
1701 builder.string(reference).string(".").string(accessElement.getSimpleName().toString());
1702 } else {
1703 throw new AssertionError();
1704 }
1705 if (targetExecution.isIndexed()) {
1706 builder.string("[" + targetExecution.getIndex() + "]");
1707 }
1708 return builder.getRoot();
1709 }
1710
1711 private static String castValueName(Parameter parameter) {
1712 return valueName(parameter) + "Cast";
1713 }
1714
1715 static void addInternalValueParameterNames(CodeTreeBuilder builder, TemplateMethod source, TemplateMethod specialization, String unexpectedValueName, boolean forceFrame, boolean disableFrame,
1716 Map<String, String> customNames) {
1717 if (forceFrame && !disableFrame && specialization.getSpecification().findParameterSpec("frame") != null) {
1718 builder.string("frameValue");
1719 }
1720 for (Parameter parameter : specialization.getParameters()) {
1721 ParameterSpec spec = parameter.getSpecification();
1722 if ((disableFrame || forceFrame) && spec.getName().equals("frame")) {
1723 continue;
1724 }
1725
1726 if (parameter.getSpecification().isLocal()) {
1727 continue;
1728 }
1729
1730 Parameter sourceParameter = source.findParameter(parameter.getLocalName());
1731
1732 if (customNames != null && customNames.containsKey(parameter.getLocalName())) {
1733 builder.string(customNames.get(parameter.getLocalName()));
1734 } else if (unexpectedValueName != null && parameter.getLocalName().equals(unexpectedValueName)) {
1735 builder.cast(parameter.getType(), CodeTreeBuilder.singleString("ex.getResult()"));
1736 } else if (sourceParameter != null) {
1737 builder.string(valueName(sourceParameter, parameter));
1738 } else {
1739 builder.string(valueName(parameter));
1740 }
1741 }
1742 }
1743
1744 private static String valueName(Parameter sourceParameter, Parameter targetParameter) {
1745 if (!sourceParameter.getSpecification().isSignature()) {
1746 return valueName(targetParameter);
1747 } else if (sourceParameter.getTypeSystemType() != null && targetParameter.getTypeSystemType() != null) {
1748 if (sourceParameter.getTypeSystemType().needsCastTo(targetParameter.getTypeSystemType())) {
1749 return castValueName(targetParameter);
1750 }
1751 }
1752 return valueName(targetParameter);
1753 }
1754
1755 static CodeTree createTemplateMethodCall(CodeTreeBuilder parent, CodeTree target, TemplateMethod sourceMethod, TemplateMethod targetMethod, String unexpectedValueName,
1756 String... customSignatureValueNames) {
1757 CodeTreeBuilder builder = parent.create();
1758
1759 boolean castedValues = sourceMethod != targetMethod;
1760
1761 builder.startGroup();
1762 ExecutableElement method = targetMethod.getMethod();
1763 if (method == null) {
1764 throw new UnsupportedOperationException();
1765 }
1766 TypeElement targetClass = ElementUtils.findNearestEnclosingType(method.getEnclosingElement());
1767 NodeData node = (NodeData) targetMethod.getTemplate();
1768
1769 if (target == null) {
1770 boolean accessible = targetMethod.canBeAccessedByInstanceOf(node.getNodeType());
1771 if (accessible) {
1772 if (builder.findMethod().getModifiers().contains(STATIC)) {
1773 if (method.getModifiers().contains(STATIC)) {
1774 builder.type(targetClass.asType());
1775 } else {
1776 builder.string(THIS_NODE_LOCAL_VAR_NAME);
1777 }
1778 } else {
1779 if (targetMethod instanceof ExecutableTypeData) {
1780 builder.string("this");
1781 } else {
1782 builder.string("super");
1783 }
1784 }
1785 } else {
1786 if (method.getModifiers().contains(STATIC)) {
1787 builder.type(targetClass.asType());
1788 } else {
1789 Parameter firstParameter = null;
1790 for (Parameter searchParameter : targetMethod.getParameters()) {
1791 if (searchParameter.getSpecification().isSignature()) {
1792 firstParameter = searchParameter;
1793 break;
1794 }
1795 }
1796 if (firstParameter == null) {
1797 throw new AssertionError();
1798 }
1799
1800 Parameter sourceParameter = sourceMethod.findParameter(firstParameter.getLocalName());
1801
1802 if (castedValues && sourceParameter != null) {
1803 builder.string(valueName(sourceParameter, firstParameter));
1804 } else {
1805 builder.string(valueName(firstParameter));
1806 }
1807 }
1808 }
1809 builder.string(".");
1810 } else {
1811 builder.tree(target);
1812 }
1813 builder.startCall(method.getSimpleName().toString());
1814
1815 int signatureIndex = 0;
1816
1817 for (Parameter targetParameter : targetMethod.getParameters()) {
1818 Parameter valueParameter = null;
1819 if (sourceMethod != null) {
1820 valueParameter = sourceMethod.findParameter(targetParameter.getLocalName());
1821 }
1822 if (valueParameter == null) {
1823 valueParameter = targetParameter;
1824 }
1825 TypeMirror targetType = targetParameter.getType();
1826 TypeMirror valueType = null;
1827 if (valueParameter != null) {
1828 valueType = valueParameter.getType();
1829 }
1830
1831 if (signatureIndex < customSignatureValueNames.length && targetParameter.getSpecification().isSignature()) {
1832 builder.string(customSignatureValueNames[signatureIndex]);
1833 signatureIndex++;
1834 } else if (targetParameter.getSpecification().isLocal()) {
1835 builder.startGroup();
1836 if (builder.findMethod().getModifiers().contains(Modifier.STATIC)) {
1837 builder.string(THIS_NODE_LOCAL_VAR_NAME).string(".");
1838 } else {
1839 builder.string("this.");
1840 }
1841 builder.string(targetParameter.getSpecification().getName());
1842 builder.end();
1843 } else if (unexpectedValueName != null && targetParameter.getLocalName().equals(unexpectedValueName)) {
1844 builder.cast(targetParameter.getType(), CodeTreeBuilder.singleString("ex.getResult()"));
1845 } else if (!ElementUtils.needsCastTo(valueType, targetType)) {
1846 builder.startGroup();
1847 builder.string(valueName(targetParameter));
1848 builder.end();
1849 } else {
1850 builder.string(castValueName(targetParameter));
1851 }
1852 }
1853
1854 builder.end().end();
1855
1856 return builder.getRoot();
1857 }
1858
1859 private static String baseClassName(NodeData node) {
1860 String nodeid = resolveNodeId(node);
1861 String name = ElementUtils.firstLetterUpperCase(nodeid);
1862 name += "BaseNode";
1863 return name;
1864 }
1865
1866 static CodeTree createCallTypeSystemMethod(CodeTreeBuilder parent, NodeData node, String methodName, CodeTree... args) {
1867 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
1868 startCallTypeSystemMethod(builder, node.getTypeSystem(), methodName);
1869 for (CodeTree arg : args) {
1870 builder.tree(arg);
1871 }
1872 builder.end().end();
1873 return builder.getRoot();
1874 }
1875
1876 private static void startCallTypeSystemMethod(CodeTreeBuilder body, TypeSystemData typeSystem, String methodName) {
1877 GeneratedTypeMirror typeMirror = new GeneratedTypeMirror(ElementUtils.getPackageName(typeSystem.getTemplateType()), TypeSystemCodeGenerator.typeName(typeSystem));
1878 body.startGroup();
1879 body.staticReference(typeMirror, TypeSystemCodeGenerator.singletonName(typeSystem));
1880 body.string(".").startCall(methodName);
1881 }
1882
1883 /**
1884 * <pre>
1885 * variant1 $condition != null
1886 *
1887 * $type $name = defaultValue($type);
1888 * if ($condition) {
1889 * $name = $value;
1890 * }
1891 *
1892 * variant2 $condition != null
1893 * $type $name = $value;
1894 * </pre>
1895 *
1896 * .
1897 */
1898 private static CodeTree createLazyAssignment(CodeTreeBuilder parent, String name, TypeMirror type, CodeTree condition, CodeTree value) {
1899 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
1900 if (condition == null) {
1901 builder.declaration(type, name, value);
1902 } else {
1903 builder.declaration(type, name, new CodeTreeBuilder(parent).defaultValue(type).getRoot());
1904
1905 builder.startIf().tree(condition).end();
1906 builder.startBlock();
1907 builder.startStatement();
1908 builder.string(name);
1909 builder.string(" = ");
1910 builder.tree(value);
1911 builder.end(); // statement
1912 builder.end(); // block
1913 }
1914 return builder.getRoot();
1915 }
1916
1917 void emitEncounteredSynthetic(CodeTreeBuilder builder, NodeData model, TemplateMethod current) {
1918 CodeTreeBuilder nodes = builder.create();
1919 CodeTreeBuilder arguments = builder.create();
1920 nodes.startCommaGroup();
1921 arguments.startCommaGroup();
1922 boolean empty = true;
1923 for (Parameter parameter : current.getParameters()) {
1924 NodeExecutionData executionData = parameter.getSpecification().getExecution();
1925 if (executionData != null) {
1926 if (executionData.isShortCircuit()) {
1927 nodes.nullLiteral();
1928 arguments.string(valueName(parameter.getPreviousParameter()));
1929 }
1930 nodes.tree(createAccessChild(executionData, "rootNode"));
1931 arguments.string(valueName(parameter));
1932 empty = false;
1933 }
1934 }
1935 nodes.end();
1936 arguments.end();
1937 builder.startStatement().startStaticCall(context.getTruffleTypes().getCompilerDirectives(), "transferToInterpreter").end().end();
1938
1939 builder.declaration(baseClassName(model), "rootNode", builder.create().startStaticCall(context.getTruffleTypes().getDslShare(), DSLSHARE_FIND_ROOT).string("this").end());
1940 builder.startThrow().startNew(context.getType(UnsupportedSpecializationException.class));
1941 builder.string("rootNode");
1942 builder.startNewArray(context.getTruffleTypes().getNodeArray(), null);
1943 builder.tree(nodes.getRoot());
1944 builder.end();
1945 if (!empty) {
1946 builder.tree(arguments.getRoot());
1947 }
1948 builder.end().end();
1949 }
1950
1951 private static ExecutableElement findCopyConstructor(TypeMirror type) {
1952 for (ExecutableElement constructor : ElementFilter.constructorsIn(ElementUtils.fromTypeMirror(type).getEnclosedElements())) {
1953 if (constructor.getModifiers().contains(PRIVATE)) {
1954 continue;
1955 }
1956 if (isCopyConstructor(constructor)) {
1957 return constructor;
1958 }
1959 }
1960
1961 return null;
1962 }
1963
1964 static String nodeSpecializationClassName(SpecializationData specialization) {
1965 String nodeid = resolveNodeId(specialization.getNode());
1966 String name = ElementUtils.firstLetterUpperCase(nodeid);
1967 name += ElementUtils.firstLetterUpperCase(specialization.getId());
1968 name += "Node";
1969 return name;
1970 }
1971
1972 static String nodePolymorphicClassName(NodeData node) {
1973 return ElementUtils.firstLetterUpperCase(resolveNodeId(node)) + "PolymorphicNode";
1974 }
1975
1976 private static String resolveNodeId(NodeData node) {
1977 String nodeid = node.getNodeId();
1978 if (nodeid.endsWith("Node") && !nodeid.equals("Node")) {
1979 nodeid = nodeid.substring(0, nodeid.length() - 4);
1980 }
1981 return nodeid;
1982 }
1983
1984 private static CodeTree createCastType(TypeSystemData typeSystem, TypeData sourceType, TypeData targetType, boolean expect, CodeTree value) {
1985 if (targetType == null) {
1986 return value;
1987 } else if (sourceType != null && !sourceType.needsCastTo(targetType)) {
1988 return value;
1989 }
1990
1991 CodeTreeBuilder builder = CodeTreeBuilder.createBuilder();
1992 String targetMethodName;
1993 if (expect) {
1994 targetMethodName = TypeSystemCodeGenerator.expectTypeMethodName(targetType);
1995 } else {
1996 targetMethodName = TypeSystemCodeGenerator.asTypeMethodName(targetType);
1997 }
1998 startCallTypeSystemMethod(builder, typeSystem, targetMethodName);
1999 builder.tree(value);
2000 builder.end().end();
2001 return builder.getRoot();
2002 }
2003
2004 private static CodeTree createExpectType(TypeSystemData typeSystem, TypeData sourceType, TypeData targetType, CodeTree expression) {
2005 return createCastType(typeSystem, sourceType, targetType, true, expression);
2006 }
2007
2008 static CodeTree createDeoptimize(CodeTreeBuilder parent) {
2009 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
2010 builder.startStatement();
2011 builder.startStaticCall(ProcessorContext.getInstance().getTruffleTypes().getCompilerDirectives(), "transferToInterpreterAndInvalidate").end();
2012 builder.end();
2013 return builder.getRoot();
2014 }
2015
2016 private TypeMirror getUnexpectedValueException() {
2017 return getContext().getTruffleTypes().getUnexpectedValueException();
2018 }
2019
2020 interface CodeBlock<T> {
2021
2022 CodeTree create(CodeTreeBuilder parent, T value);
2023
2024 }
2025
2026 }