Mercurial > hg > graal-jvmci-8
annotate graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/node/NodeCodeGenerator.java @ 7846:91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
author | Christian Humer <christian.humer@gmail.com> |
---|---|
date | Tue, 19 Feb 2013 14:29:12 +0100 |
parents | 0110e781b6fa |
children | 06a7cd6aaf00 |
rev | line source |
---|---|
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
1 /* |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
2 * Copyright (c) 2012, 2012, Oracle and/or its affiliates. All rights reserved. |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
4 * |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
5 * This code is free software; you can redistribute it and/or modify it |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
6 * under the terms of the GNU General Public License version 2 only, as |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
7 * published by the Free Software Foundation. |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
8 * |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
9 * This code is distributed in the hope that it will be useful, but WITHOUT |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
12 * version 2 for more details (a copy is included in the LICENSE file that |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
13 * accompanied this code). |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
14 * |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
15 * You should have received a copy of the GNU General Public License version |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
16 * 2 along with this work; if not, write to the Free Software Foundation, |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
18 * |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
21 * questions. |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
22 */ |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
23 package com.oracle.truffle.codegen.processor.node; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
24 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
25 import static com.oracle.truffle.codegen.processor.Utils.*; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
26 import static javax.lang.model.element.Modifier.*; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
27 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
28 import java.util.*; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
29 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
30 import javax.lang.model.element.*; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
31 import javax.lang.model.type.*; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
32 import javax.lang.model.util.*; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
33 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
34 import com.oracle.truffle.codegen.processor.*; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
35 import com.oracle.truffle.codegen.processor.ast.*; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
36 import com.oracle.truffle.codegen.processor.node.NodeFieldData.ExecutionKind; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
37 import com.oracle.truffle.codegen.processor.template.*; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
38 import com.oracle.truffle.codegen.processor.typesystem.*; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
39 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
40 public class NodeCodeGenerator extends CompilationUnitFactory<NodeData> { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
41 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
42 private static final String THIS_NODE_LOCAL_VAR_NAME = "thisNode"; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
43 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
44 public NodeCodeGenerator(ProcessorContext context) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
45 super(context); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
46 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
47 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
48 private TypeMirror getUnexpectedValueException() { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
49 return getContext().getTruffleTypes().getUnexpectedValueException(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
50 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
51 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
52 private static String factoryClassName(NodeData node) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
53 return nodeClassName(node) + "Factory"; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
54 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
55 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
56 private static String nodeClassName(NodeData node) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
57 return Utils.getSimpleName(node.getTemplateType().asType()); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
58 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
59 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
60 private static String nodeClassName(SpecializationData specialization) { |
7777
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
61 String name = specializationId(specialization); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
62 name += nodeClassName(specialization.getNode()); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
63 if (name.equals(Utils.getSimpleName(specialization.getNode().getNodeType())) || name.equals(Utils.getSimpleName(specialization.getNode().getTemplateType()))) { |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
64 name = name + "Impl"; |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
65 } |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
66 |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
67 return name; |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
68 } |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
69 |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
70 private static String specializationId(SpecializationData specialization) { |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
71 String name = ""; |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
72 NodeData node = specialization.getNode(); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
73 if (node.getSpecializations().length > 1) { |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
74 name = specialization.getMethodName(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
75 if (name.startsWith("do")) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
76 name = name.substring(2); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
77 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
78 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
79 return name; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
80 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
81 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
82 private static String valueName(NodeFieldData field) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
83 return field.getName() + "Value"; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
84 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
85 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
86 private static String valueName(TemplateMethod method, ActualParameter param) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
87 NodeData node = (NodeData) method.getTemplate(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
88 NodeFieldData field = node.findField(param.getSpecification().getName()); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
89 if (field != null) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
90 return valueName(field); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
91 } else { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
92 return param.getSpecification().getName(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
93 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
94 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
95 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
96 private void addValueParameters(CodeExecutableElement method, TemplateMethod specialization, boolean forceFrame) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
97 if (forceFrame) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
98 method.addParameter(new CodeVariableElement(getContext().getTruffleTypes().getFrame(), "frame")); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
99 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
100 for (ActualParameter parameter : specialization.getParameters()) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
101 ParameterSpec spec = parameter.getSpecification(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
102 if (forceFrame && spec.getName().equals("frame")) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
103 continue; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
104 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
105 method.addParameter(new CodeVariableElement(parameter.getActualType(), valueName(specialization, parameter))); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
106 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
107 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
108 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
109 private static void addValueParameterNames(CodeTreeBuilder builder, TemplateMethod specialization, String unexpectedValueName, boolean forceFrame) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
110 if (forceFrame) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
111 builder.string("frame"); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
112 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
113 for (ActualParameter parameter : specialization.getParameters()) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
114 ParameterSpec spec = parameter.getSpecification(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
115 if (forceFrame && spec.getName().equals("frame")) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
116 continue; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
117 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
118 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
119 if (unexpectedValueName != null && spec.getName().equals(unexpectedValueName)) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
120 builder.string("ex.getResult()"); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
121 } else { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
122 builder.string(valueName(specialization, parameter)); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
123 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
124 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
125 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
126 |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
127 private static void addValueParameterNamesWithCasts(ProcessorContext context, CodeTreeBuilder body, SpecializationData valueSpecialization, SpecializationData targetSpecialization) { |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
128 NodeData node = targetSpecialization.getNode(); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
129 TypeSystemData typeSystem = node.getTypeSystem(); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
130 |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
131 for (ActualParameter targetParameter : targetSpecialization.getParameters()) { |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
132 ActualParameter valueParameter = valueSpecialization.findParameter(targetParameter.getSpecification().getName()); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
133 TypeData targetType = targetParameter.getActualTypeData(typeSystem); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
134 |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
135 TypeData valueType = null; |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
136 if (valueParameter != null) { |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
137 valueType = valueParameter.getActualTypeData(typeSystem); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
138 } |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
139 |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
140 if (targetType == null || targetType.isGeneric() || (valueType != null && valueType.equalsType(targetType))) { |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
141 body.string(valueName(targetSpecialization, targetParameter)); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
142 } else { |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
143 String methodName = TypeSystemCodeGenerator.asTypeMethodName(targetType); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
144 startCallTypeSystemMethod(context, body, node, methodName); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
145 body.string(valueName(targetSpecialization, targetParameter)); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
146 body.end().end(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
147 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
148 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
149 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
150 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
151 private static String genClassName(Template operation) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
152 return getSimpleName(operation.getTemplateType()) + "Gen"; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
153 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
154 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
155 private static void startCallOperationMethod(CodeTreeBuilder body, TemplateMethod method) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
156 body.startGroup(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
157 if (body.findMethod().getModifiers().contains(STATIC)) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
158 body.string(THIS_NODE_LOCAL_VAR_NAME); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
159 } else { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
160 body.string("super"); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
161 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
162 body.string("."); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
163 body.startCall(method.getMethodName()); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
164 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
165 |
7777
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
166 private static String generatedGenericMethodName(SpecializationData specialization) { |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
167 final String prefix = "generic"; |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
168 |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
169 if (specialization == null) { |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
170 return prefix; |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
171 } |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
172 |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
173 SpecializationData prev = null; |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
174 for (SpecializationData current : specialization.getNode().getSpecializations()) { |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
175 if (specialization == current) { |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
176 if (prev == null || prev.isUninitialized()) { |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
177 return prefix; |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
178 } else { |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
179 return prefix + specializationId(current); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
180 } |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
181 } |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
182 prev = current; |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
183 } |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
184 return prefix; |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
185 } |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
186 |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7502
diff
changeset
|
187 private static void startCallTypeSystemMethod(ProcessorContext context, CodeTreeBuilder body, NodeData node, String methodName) { |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
188 VariableElement singleton = TypeSystemCodeGenerator.findSingleton(context, node.getTypeSystem()); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
189 assert singleton != null; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
190 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
191 body.startGroup(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
192 body.staticReference(singleton.getEnclosingElement().asType(), singleton.getSimpleName().toString()); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
193 body.string(".").startCall(methodName); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
194 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
195 |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
196 private static CodeTree createGuardAndCast(ProcessorContext context, CodeTreeBuilder parent, String prefix, SpecializationData valueSpecialization, SpecializationData guardedSpecialization, |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
197 boolean onSpecialization, CodeTree guardedStatements, CodeTree elseStatements) { |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
198 |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
199 CodeTreeBuilder builder = new CodeTreeBuilder(parent); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
200 CodeTree implicitGuards = createImplicitGuards(context, parent, prefix, valueSpecialization, guardedSpecialization); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
201 CodeTree explicitGuards = createExplicitGuards(context, parent, implicitGuards == null ? prefix : null, valueSpecialization, guardedSpecialization, onSpecialization); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
202 |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
203 int ifCount = 0; |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
204 |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
205 if (implicitGuards != null) { |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
206 builder.startIf(); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
207 builder.tree(implicitGuards); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
208 builder.end(); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
209 builder.startBlock(); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
210 ifCount++; |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
211 } |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
212 |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
213 if (explicitGuards != null) { |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
214 builder.startIf(); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
215 builder.tree(explicitGuards); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
216 builder.end(); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
217 builder.startBlock(); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
218 ifCount++; |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
219 } |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
220 |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
221 if (implicitGuards == null && explicitGuards == null && prefix != null && !prefix.isEmpty()) { |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
222 builder.startIf().string(prefix).end().startBlock(); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
223 ifCount++; |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
224 } |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
225 |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
226 builder.tree(guardedStatements); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
227 |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
228 builder.end(ifCount); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
229 if (ifCount > 0 && elseStatements != null) { |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
230 builder.startElseBlock(); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
231 builder.tree(elseStatements); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
232 builder.end(); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
233 } |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
234 |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
235 return builder.getRoot(); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
236 } |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
237 |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
238 private static CodeTree createExplicitGuards(ProcessorContext context, CodeTreeBuilder parent, String prefix, SpecializationData valueSpecialization, SpecializationData guardedSpecialization, |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
239 boolean onSpecialization) { |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
240 CodeTreeBuilder builder = new CodeTreeBuilder(parent); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
241 String andOperator = (prefix != null && !prefix.isEmpty()) ? (prefix + " && ") : ""; |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
242 if (guardedSpecialization.getGuards().length > 0) { |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
243 // Explicitly specified guards |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
244 for (SpecializationGuardData guard : guardedSpecialization.getGuards()) { |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7502
diff
changeset
|
245 if ((guard.isOnSpecialization() && onSpecialization) || (guard.isOnExecution() && !onSpecialization)) { |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
246 builder.string(andOperator); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
247 |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
248 startCallOperationMethod(builder, guard.getGuardDeclaration()); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
249 addValueParameterNamesWithCasts(context, builder, valueSpecialization, guardedSpecialization); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
250 |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
251 builder.end().end(); // call |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
252 andOperator = " && "; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
253 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
254 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
255 } |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
256 |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
257 return builder.isEmpty() ? null : builder.getRoot(); |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
258 } |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
259 |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
260 private static CodeTree createImplicitGuards(ProcessorContext context, CodeTreeBuilder parent, String prefix, SpecializationData valueSpecialization, SpecializationData guardedSpecialization) { |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
261 NodeData node = guardedSpecialization.getNode(); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
262 TypeSystemData typeSystem = node.getTypeSystem(); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
263 |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
264 CodeTreeBuilder builder = new CodeTreeBuilder(parent); |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
265 // Implict guards based on method signature |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
266 String andOperator = (prefix != null && !prefix.isEmpty()) ? (prefix + " && ") : ""; |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
267 for (NodeFieldData field : node.getFields()) { |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
268 ActualParameter guardedParam = guardedSpecialization.findParameter(field.getName()); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
269 ActualParameter valueParam = valueSpecialization.findParameter(field.getName()); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
270 |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
271 TypeData guardedType = guardedParam.getActualTypeData(typeSystem); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
272 TypeData valueType = valueParam.getActualTypeData(typeSystem); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
273 |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
274 if (guardedType.equalsType(valueType) || guardedType.isGeneric()) { |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
275 continue; |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
276 } |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
277 |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
278 builder.string(andOperator); |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
279 |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
280 builder.startGroup(); |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
281 |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
282 if (field.isShortCircuit()) { |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
283 ActualParameter shortCircuit = guardedSpecialization.getPreviousParam(guardedParam); |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
284 builder.string("("); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
285 builder.string("!").string(valueName(guardedSpecialization, shortCircuit)); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
286 builder.string(" || "); |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
287 } |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
288 |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
289 startCallTypeSystemMethod(context, builder, guardedSpecialization.getNode(), TypeSystemCodeGenerator.isTypeMethodName(guardedType)); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
290 builder.string(valueName(guardedSpecialization, guardedParam)); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
291 builder.end().end(); // call |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
292 |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
293 if (field.isShortCircuit()) { |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
294 builder.string(")"); |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
295 } |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
296 |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
297 builder.end(); // group |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
298 andOperator = " && "; |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
299 } |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
300 |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
301 return builder.isEmpty() ? null : builder.getRoot(); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
302 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
303 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
304 @Override |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
305 protected void createChildren(NodeData node) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
306 Map<NodeData, List<TypeElement>> childTypes = new LinkedHashMap<>(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
307 if (node.getDeclaredChildren() != null && !node.getDeclaredChildren().isEmpty()) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
308 for (NodeData nodeChild : node.getDeclaredChildren()) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
309 NodeCodeGenerator generator = new NodeCodeGenerator(getContext()); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
310 childTypes.put(nodeChild, generator.process(null, nodeChild).getEnclosedElements()); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
311 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
312 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
313 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
314 if (node.getExtensionElements() != null && !node.getExtensionElements().isEmpty()) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
315 NodeGenFactory factory = new NodeGenFactory(context); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
316 add(factory, node); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
317 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
318 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
319 if (node.getSpecializations() == null) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
320 return; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
321 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
322 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
323 if (node.needsFactory() || childTypes.size() > 0) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
324 add(new NodeFactoryFactory(context, childTypes), node); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
325 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
326 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
327 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
328 private class NodeGenFactory extends ClassElementFactory<NodeData> { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
329 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
330 public NodeGenFactory(ProcessorContext context) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
331 super(context); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
332 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
333 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
334 @Override |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
335 protected CodeTypeElement create(NodeData node) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
336 CodeTypeElement clazz = createClass(node, modifiers(PUBLIC, ABSTRACT), genClassName(node), node.getTemplateType().asType(), false); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
337 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
338 for (ExecutableElement executable : ElementFilter.constructorsIn(node.getTemplateType().getEnclosedElements())) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
339 CodeExecutableElement superConstructor = createSuperConstructor(clazz, executable); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
340 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
341 if (superConstructor != null) { |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7502
diff
changeset
|
342 if (superConstructor.getParameters().size() == 1 && Utils.typeEquals(superConstructor.getParameters().get(0).asType(), node.getTemplateType().asType())) { |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
343 String originalName = superConstructor.getParameters().get(0).getSimpleName().toString(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
344 superConstructor.getParameters().clear(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
345 superConstructor.getParameters().add(new CodeVariableElement(clazz.asType(), originalName)); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
346 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
347 clazz.add(superConstructor); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
348 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
349 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
350 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
351 if (node.getExtensionElements() != null) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
352 clazz.getEnclosedElements().addAll(node.getExtensionElements()); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
353 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
354 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
355 node.setNodeType(clazz.asType()); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
356 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
357 return clazz; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
358 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
359 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
360 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
361 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
362 private class NodeFactoryFactory extends ClassElementFactory<NodeData> { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
363 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
364 private final Map<NodeData, List<TypeElement>> childTypes; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
365 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
366 public NodeFactoryFactory(ProcessorContext context, Map<NodeData, List<TypeElement>> childElements) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
367 super(context); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
368 this.childTypes = childElements; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
369 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
370 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
371 @Override |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
372 protected CodeTypeElement create(NodeData node) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
373 Modifier visibility = Utils.getVisibility(node.getTemplateType().getModifiers()); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
374 CodeTypeElement clazz = createClass(node, modifiers(), factoryClassName(node), null, false); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
375 if (visibility != null) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
376 clazz.getModifiers().add(visibility); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
377 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
378 clazz.getModifiers().add(Modifier.FINAL); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
379 clazz.add(createConstructorUsingFields(modifiers(PRIVATE), clazz)); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
380 return clazz; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
381 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
382 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
383 @Override |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
384 protected void createChildren(NodeData node) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
385 CodeTypeElement clazz = getElement(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
386 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
387 Modifier createVisibility = Utils.getVisibility(clazz.getModifiers()); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
388 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
389 if (node.needsFactory()) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
390 createFactoryMethods(node, clazz, createVisibility); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
391 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
392 if (node.getSpecializations().length > 1) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
393 clazz.add(createCreateSpecializedMethod(node, createVisibility)); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
394 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
395 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
396 if (node.needsRewrites(getContext())) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
397 clazz.add(createSpecializeMethod(node)); |
7777
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
398 |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
399 List<CodeExecutableElement> genericMethods = createGeneratedGenericMethod(node); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
400 for (CodeExecutableElement method : genericMethods) { |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
401 clazz.add(method); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
402 } |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
403 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
404 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
405 for (SpecializationData specialization : node.getSpecializations()) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
406 add(new SpecializedNodeFactory(context), specialization); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
407 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
408 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
409 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
410 for (NodeData childNode : childTypes.keySet()) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
411 if (childNode.getTemplateType().getModifiers().contains(Modifier.PRIVATE)) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
412 continue; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
413 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
414 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
415 for (TypeElement type : childTypes.get(childNode)) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
416 Set<Modifier> typeModifiers = ((CodeTypeElement) type).getModifiers(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
417 Modifier visibility = Utils.getVisibility(type.getModifiers()); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
418 typeModifiers.clear(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
419 if (visibility != null) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
420 typeModifiers.add(visibility); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
421 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
422 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
423 typeModifiers.add(Modifier.STATIC); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
424 typeModifiers.add(Modifier.FINAL); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
425 clazz.add(type); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
426 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
427 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
428 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
429 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
430 private void createFactoryMethods(NodeData node, CodeTypeElement clazz, Modifier createVisibility) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
431 for (ExecutableElement constructor : ElementFilter.constructorsIn(Utils.fromTypeMirror(node.getNodeType()).getEnclosedElements())) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
432 if (constructor.getModifiers().contains(PRIVATE)) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
433 continue; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
434 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
435 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
436 // skip node rewrite constructor |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7502
diff
changeset
|
437 if (constructor.getParameters().size() == 1 && typeEquals(constructor.getParameters().get(0).asType(), node.getNodeType())) { |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
438 continue; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
439 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
440 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
441 clazz.add(createCreateMethod(node, createVisibility, constructor)); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
442 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
443 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
444 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
445 private CodeExecutableElement createCreateMethod(NodeData node, Modifier visibility, ExecutableElement constructor) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
446 CodeExecutableElement method = CodeExecutableElement.clone(getContext().getEnvironment(), constructor); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
447 method.setSimpleName(CodeNames.of("create")); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
448 method.getModifiers().clear(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
449 if (visibility != null) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
450 method.getModifiers().add(visibility); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
451 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
452 method.getModifiers().add(Modifier.STATIC); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
453 method.setReturnType(node.getNodeType()); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
454 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
455 CodeTreeBuilder body = method.createBuilder(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
456 body.startReturn(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
457 if (node.getSpecializations().length == 0) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
458 body.null_(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
459 } else { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
460 body.startNew(nodeClassName(node.getSpecializations()[0])); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
461 for (VariableElement var : method.getParameters()) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
462 body.string(var.getSimpleName().toString()); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
463 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
464 body.end(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
465 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
466 body.end(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
467 return method; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
468 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
469 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
470 private CodeExecutableElement createCreateSpecializedMethod(NodeData node, Modifier visibility) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
471 CodeExecutableElement method = new CodeExecutableElement(modifiers(), node.getNodeType(), "createSpecialized"); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
472 if (visibility != null) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
473 method.getModifiers().add(visibility); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
474 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
475 method.getModifiers().add(Modifier.STATIC); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
476 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
477 method.addParameter(new CodeVariableElement(node.getNodeType(), THIS_NODE_LOCAL_VAR_NAME)); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
478 method.addParameter(new CodeVariableElement(getContext().getType(Class.class), "specializationClass")); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
479 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
480 CodeTreeBuilder body = method.createBuilder(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
481 boolean first = true; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
482 for (TypeData type : node.getTypeSystem().getTypes()) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
483 SpecializationData specialization = node.findUniqueSpecialization(type); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
484 if (specialization != null && !type.isGeneric()) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
485 if (first) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
486 body.startIf(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
487 first = false; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
488 } else { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
489 body.startElseIf(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
490 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
491 body.string("specializationClass == ").type(type.getBoxedType()).string(".class").end().startBlock(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
492 body.startReturn().startNew(nodeClassName(specialization)); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
493 body.string(THIS_NODE_LOCAL_VAR_NAME); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
494 body.end().end(); // new, return |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
495 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
496 body.end(); // if |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
497 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
498 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
499 body.startReturn().startNew(nodeClassName(node.getGenericSpecialization())); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
500 body.string(THIS_NODE_LOCAL_VAR_NAME); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
501 body.end().end(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
502 return method; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
503 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
504 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
505 private CodeExecutableElement createSpecializeMethod(NodeData node) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
506 CodeExecutableElement method = new CodeExecutableElement(modifiers(PRIVATE, STATIC), node.getNodeType(), "specialize"); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
507 method.addParameter(new CodeVariableElement(node.getNodeType(), THIS_NODE_LOCAL_VAR_NAME)); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
508 method.addParameter(new CodeVariableElement(getContext().getType(Class.class), "minimumState")); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
509 addValueParameters(method, node.getGenericSpecialization(), false); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
510 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
511 CodeTreeBuilder body = method.createBuilder(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
512 body.startStatement().string("boolean allowed = (minimumState == ").string(nodeClassName(node.getSpecializations()[0])).string(".class)").end(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
513 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
514 for (int i = 1; i < node.getSpecializations().length; i++) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
515 SpecializationData specialization = node.getSpecializations()[i]; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
516 body.startStatement().string("allowed = allowed || (minimumState == ").string(nodeClassName(specialization)).string(".class)").end(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
517 |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
518 CodeTreeBuilder guarded = new CodeTreeBuilder(body); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
519 guarded.startReturn().startNew(nodeClassName(specialization)); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
520 guarded.string(THIS_NODE_LOCAL_VAR_NAME); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
521 guarded.end().end(); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
522 |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
523 body.tree(createGuardAndCast(getContext(), body, "allowed", node.getGenericSpecialization(), specialization, true, guarded.getRoot(), null)); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
524 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
525 body.startThrow().startNew(getContext().getType(IllegalArgumentException.class)).end().end(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
526 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
527 return method; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
528 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
529 |
7777
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
530 private List<CodeExecutableElement> createGeneratedGenericMethod(NodeData node) { |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
531 TypeMirror genericReturnType = node.getGenericSpecialization().getReturnType().getActualType(); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
532 if (node.getGenericSpecialization().isUseSpecializationsForGeneric()) { |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
533 List<CodeExecutableElement> methods = new ArrayList<>(); |
7751
ef1b41ea0a90
Implemented an option to turn off generated generic generation using specializations in @Generic.
Christian Humer <christian.humer@gmail.com>
parents:
7750
diff
changeset
|
534 |
7777
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
535 SpecializationData[] specializations = node.getSpecializations(); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
536 SpecializationData prev = null; |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
537 for (int i = 0; i < specializations.length; i++) { |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
538 SpecializationData current = specializations[i]; |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
539 SpecializationData next = i + 1 < specializations.length ? specializations[i + 1] : null; |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
540 if (prev == null || current.isUninitialized()) { |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
541 prev = current; |
7751
ef1b41ea0a90
Implemented an option to turn off generated generic generation using specializations in @Generic.
Christian Humer <christian.humer@gmail.com>
parents:
7750
diff
changeset
|
542 continue; |
7777
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
543 } else { |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
544 String methodName = generatedGenericMethodName(current); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
545 CodeExecutableElement method = new CodeExecutableElement(modifiers(PRIVATE, STATIC), genericReturnType, methodName); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
546 method.addParameter(new CodeVariableElement(node.getNodeType(), THIS_NODE_LOCAL_VAR_NAME)); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
547 addValueParameters(method, node.getGenericSpecialization(), true); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
548 |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
549 emitGeneratedGenericSpecialization(method.createBuilder(), current, next); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
550 |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
551 methods.add(method); |
7751
ef1b41ea0a90
Implemented an option to turn off generated generic generation using specializations in @Generic.
Christian Humer <christian.humer@gmail.com>
parents:
7750
diff
changeset
|
552 } |
7777
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
553 prev = current; |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
554 } |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
555 |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
556 return methods; |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
557 } else { |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
558 CodeExecutableElement method = new CodeExecutableElement(modifiers(PRIVATE, STATIC), genericReturnType, generatedGenericMethodName(null)); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
559 method.addParameter(new CodeVariableElement(node.getNodeType(), THIS_NODE_LOCAL_VAR_NAME)); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
560 addValueParameters(method, node.getGenericSpecialization(), true); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
561 emitInvokeDoMethod(method.createBuilder(), node.getGenericSpecialization(), 0); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
562 return Arrays.asList(method); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
563 } |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
564 } |
7751
ef1b41ea0a90
Implemented an option to turn off generated generic generation using specializations in @Generic.
Christian Humer <christian.humer@gmail.com>
parents:
7750
diff
changeset
|
565 |
7777
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
566 private void emitGeneratedGenericSpecialization(CodeTreeBuilder builder, SpecializationData current, SpecializationData next) { |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
567 CodeTreeBuilder invokeMethodBuilder = new CodeTreeBuilder(builder); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
568 emitInvokeDoMethod(invokeMethodBuilder, current, 0); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
569 CodeTree invokeMethod = invokeMethodBuilder.getRoot(); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
570 |
7777
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
571 if (next != null) { |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
572 invokeMethod = createGuardAndCast(getContext(), builder, "", current.getNode().getGenericSpecialization(), current, false, invokeMethod, null); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
573 } |
7777
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
574 |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
575 builder.tree(invokeMethod); |
7777
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
576 |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
577 if (next != null) { |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
578 builder.end(); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
579 |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
580 builder.startReturn().startCall(generatedGenericMethodName(next)); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
581 builder.string(THIS_NODE_LOCAL_VAR_NAME); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
582 addValueParameterNames(builder, next, null, true); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
583 builder.end().end(); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
584 } |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
585 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
586 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
587 private void emitInvokeDoMethod(CodeTreeBuilder builder, SpecializationData specialization, int level) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
588 if (specialization.getExceptions().length > 0) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
589 builder.startTryBlock(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
590 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
591 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
592 builder.startReturn(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
593 startCallOperationMethod(builder, specialization); |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
594 addValueParameterNamesWithCasts(context, builder, specialization.getNode().getGenericSpecialization(), specialization); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
595 builder.end().end(); // start call operation |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
596 builder.end(); // return |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
597 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
598 if (specialization.getExceptions().length > 0) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
599 for (SpecializationThrowsData exception : specialization.getExceptions()) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
600 builder.end().startCatchBlock(exception.getJavaClass(), "ex" + level); |
7777
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
601 |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
602 builder.startReturn().startCall(generatedGenericMethodName(exception.getTransitionTo())); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
603 builder.string(THIS_NODE_LOCAL_VAR_NAME); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
604 addValueParameterNames(builder, exception.getTransitionTo(), null, true); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
605 builder.end().end(); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
606 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
607 builder.end(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
608 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
609 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
610 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
611 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
612 private class SpecializedNodeFactory extends ClassElementFactory<SpecializationData> { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
613 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
614 public SpecializedNodeFactory(ProcessorContext context) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
615 super(context); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
616 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
617 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
618 @Override |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
619 public CodeTypeElement create(SpecializationData specialization) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
620 NodeData node = specialization.getNode(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
621 CodeTypeElement clazz = createClass(node, modifiers(PRIVATE, STATIC, FINAL), nodeClassName(specialization), node.getNodeType(), false); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
622 return clazz; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
623 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
624 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
625 @Override |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
626 protected void createChildren(SpecializationData specialization) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
627 CodeTypeElement clazz = getElement(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
628 NodeData node = specialization.getNode(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
629 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
630 TypeElement superTypeElement = Utils.fromTypeMirror(clazz.getSuperclass()); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
631 for (ExecutableElement constructor : ElementFilter.constructorsIn(superTypeElement.getEnclosedElements())) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
632 ExecutableElement superConstructor = createSuperConstructor(clazz, constructor); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
633 if (superConstructor != null) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
634 clazz.add(superConstructor); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
635 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
636 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
637 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
638 for (ExecutableTypeData execType : node.getExecutableTypes()) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
639 if (execType.isFinal()) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
640 continue; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
641 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
642 CodeExecutableElement method = CodeExecutableElement.clone(getContext().getEnvironment(), execType.getMethod()); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
643 if (method.getParameters().size() == 1) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
644 CodeVariableElement var = CodeVariableElement.clone(method.getParameters().get(0)); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
645 var.setName("frame"); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
646 method.getParameters().set(0, var); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
647 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
648 method.getModifiers().remove(Modifier.ABSTRACT); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
649 clazz.add(method); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
650 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
651 TypeData primaryType = specialization.getReturnType().getActualTypeData(node.getTypeSystem()); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
652 if (primaryType == execType.getType()) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
653 buildFunctionalExecuteMethod(method.createBuilder(), specialization); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
654 } else { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
655 buildCastingExecuteMethod(method.createBuilder(), specialization, execType.getType()); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
656 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
657 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
658 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
659 if (node.needsRewrites(getContext()) && !specialization.isGeneric() && !specialization.isUninitialized()) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
660 buildSpecializeStateMethod(clazz, specialization); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
661 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
662 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
663 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
664 private void buildCastingExecuteMethod(CodeTreeBuilder builder, SpecializationData specialization, TypeData type) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
665 NodeData node = specialization.getNode(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
666 TypeSystemData typeSystem = node.getTypeSystem(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
667 |
7750
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
668 ExecutableTypeData castedType = node.findExecutableType(type); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
669 TypeData primaryType = specialization.getReturnType().getActualTypeData(typeSystem); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
670 ExecutableTypeData execType = specialization.getNode().findExecutableType(primaryType); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
671 |
7750
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
672 boolean needsTry = execType.hasUnexpectedValue(getContext()); |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
673 boolean returnVoid = type.isVoid(); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
674 |
7750
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
675 CodeTree primaryExecuteCall = null; |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
676 |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
677 CodeTreeBuilder executeBuilder = CodeTreeBuilder.createBuilder(); |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
678 buildExecute(executeBuilder, null, execType); |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
679 primaryExecuteCall = executeBuilder.getRoot(); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
680 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
681 if (needsTry) { |
7750
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
682 if (!returnVoid) { |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
683 builder.declaration(primaryType.getPrimitiveType(), "value"); |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
684 } |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
685 builder.startTryBlock(); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
686 |
7750
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
687 if (returnVoid) { |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
688 builder.statement(primaryExecuteCall); |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
689 } else { |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
690 builder.startStatement(); |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
691 builder.string("value = "); |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
692 builder.tree(primaryExecuteCall); |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
693 builder.end(); |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
694 } |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
695 |
7750
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
696 builder.end().startCatchBlock(getUnexpectedValueException(), "ex"); |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
697 if (returnVoid) { |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
698 builder.string("// ignore").newLine(); |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
699 } else { |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
700 builder.startReturn(); |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
701 builder.tree(castPrimaryExecute(node, castedType, CodeTreeBuilder.singleString("ex.getResult()"))); |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
702 builder.end(); |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
703 } |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
704 builder.end(); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
705 |
7750
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
706 if (!returnVoid) { |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
707 builder.startReturn(); |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
708 builder.tree(castPrimaryExecute(node, castedType, CodeTreeBuilder.singleString("value"))); |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
709 builder.end(); |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
710 } |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
711 } else { |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
712 if (returnVoid) { |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
713 builder.statement(primaryExecuteCall); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
714 } else { |
7750
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
715 builder.startReturn(); |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
716 builder.tree(castPrimaryExecute(node, castedType, primaryExecuteCall)); |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
717 builder.end(); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
718 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
719 } |
7750
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
720 } |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
721 |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
722 private CodeTree castPrimaryExecute(NodeData node, ExecutableTypeData castedType, CodeTree value) { |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
723 if (castedType == null) { |
7750
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
724 return value; |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
725 } else if (castedType.getType().isVoid()) { |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
726 return value; |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
727 } else if (castedType.getType().isGeneric()) { |
7750
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
728 return value; |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
729 } |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
730 |
7750
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
731 CodeTreeBuilder builder = CodeTreeBuilder.createBuilder(); |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
732 if (castedType.hasUnexpectedValue(getContext())) { |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
733 startCallTypeSystemMethod(getContext(), builder, node, TypeSystemCodeGenerator.expectTypeMethodName(castedType.getType())); |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
734 } else { |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
735 startCallTypeSystemMethod(getContext(), builder, node, TypeSystemCodeGenerator.asTypeMethodName(castedType.getType())); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
736 } |
7750
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
737 builder.tree(value); |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
738 builder.end().end(); |
bdcb3cc47e16
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE.
Christian Humer <christian.humer@gmail.com>
parents:
7679
diff
changeset
|
739 return builder.getRoot(); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
740 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
741 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
742 private void buildFunctionalExecuteMethod(CodeTreeBuilder builder, SpecializationData specialization) { |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
743 if (specialization.isUninitialized()) { |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
744 builder.tree(createDeoptimize(builder)); |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
745 } |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
746 |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
747 builder.tree(createExecuteChildren(builder, specialization)); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
748 |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
749 if (specialization.isUninitialized()) { |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
750 builder.tree(createSpecializeCall(builder, specialization)); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
751 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
752 |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
753 CodeTree executeNode = createExecute(builder, specialization); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
754 |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
755 SpecializationData next = specialization.findNextSpecialization(); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
756 CodeTree returnSpecialized = null; |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
757 if (next != null) { |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
758 returnSpecialized = createReturnSpecializeAndExecute(builder, next, null); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
759 } |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
760 builder.tree(createGuardAndCast(context, builder, "", specialization, specialization, false, executeNode, returnSpecialized)); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
761 } |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
762 |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
763 private CodeTree createDeoptimize(CodeTreeBuilder parent) { |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
764 CodeTreeBuilder builder = new CodeTreeBuilder(parent); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
765 builder.startStatement(); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
766 builder.startStaticCall(getContext().getTruffleTypes().getTruffleIntrinsics(), "deoptimize").end(); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
767 builder.end(); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
768 return builder.getRoot(); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
769 } |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
770 |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
771 private CodeTree createSpecializeCall(CodeTreeBuilder parent, SpecializationData specialization) { |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
772 NodeData node = specialization.getNode(); |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
773 |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
774 CodeTreeBuilder builder = new CodeTreeBuilder(parent); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
775 emitSpecializationListeners(builder, node); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
776 |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
777 builder.startStatement(); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
778 builder.startCall("replace"); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
779 if (node.needsRewrites(getContext())) { |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
780 builder.startCall(factoryClassName(node), "specialize"); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
781 builder.string("this"); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
782 builder.typeLiteral(builder.findMethod().getEnclosingElement().asType()); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
783 addValueParameterNames(builder, specialization, null, false); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
784 builder.end(); // call replace, call specialize |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
785 } else { |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
786 builder.startCall(factoryClassName(node), "createSpecialized").string("this").string("null").end(); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
787 } |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
788 builder.end().end(); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
789 return builder.getRoot(); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
790 } |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
791 |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
792 private CodeTree createExecute(CodeTreeBuilder parent, SpecializationData specialization) { |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
793 NodeData node = specialization.getNode(); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
794 CodeTreeBuilder builder = new CodeTreeBuilder(parent); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
795 if (specialization.getExceptions().length > 0) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
796 builder.startTryBlock(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
797 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
798 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
799 if ((specialization.isUninitialized() || specialization.isGeneric()) && node.needsRewrites(getContext())) { |
7777
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
800 builder.startReturn().startCall(factoryClassName(node), generatedGenericMethodName(null)); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
801 builder.string("this"); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
802 addValueParameterNames(builder, specialization, null, true); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
803 builder.end().end(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
804 } else { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
805 builder.startReturn(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
806 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
807 if (specialization.isUninitialized()) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
808 startCallOperationMethod(builder, specialization.getNode().getGenericSpecialization()); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
809 } else { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
810 startCallOperationMethod(builder, specialization); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
811 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
812 addValueParameterNames(builder, specialization, null, false); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
813 builder.end().end(); // operation call |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
814 builder.end(); // return |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
815 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
816 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
817 if (specialization.getExceptions().length > 0) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
818 for (SpecializationThrowsData exception : specialization.getExceptions()) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
819 builder.end().startCatchBlock(exception.getJavaClass(), "ex"); |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
820 builder.tree(createReturnSpecializeAndExecute(parent, exception.getTransitionTo(), null)); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
821 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
822 builder.end(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
823 } |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
824 return builder.getRoot(); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
825 } |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
826 |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
827 private CodeTree createExecuteChildren(CodeTreeBuilder parent, SpecializationData specialization) { |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
828 CodeTreeBuilder builder = new CodeTreeBuilder(parent); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
829 for (NodeFieldData field : specialization.getNode().getFields()) { |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
830 if (field.getExecutionKind() == ExecutionKind.IGNORE) { |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
831 continue; |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
832 } |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
833 |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
834 ActualParameter parameterType = specialization.findParameter(field.getName()); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
835 |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
836 if (parameterType.getActualTypeData(specialization.getNode().getTypeSystem()).isGeneric()) { |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
837 buildGenericValueExecute(builder, specialization, field, null); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
838 } else { |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
839 buildSpecializedValueExecute(builder, specialization, field); |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
840 } |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
841 } |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
842 return builder.getRoot(); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
843 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
844 |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
845 private void emitSpecializationListeners(CodeTreeBuilder builder, NodeData node) { |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
846 for (TemplateMethod listener : node.getSpecializationListeners()) { |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
847 builder.startStatement(); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
848 startCallOperationMethod(builder, listener); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
849 addValueParameterNames(builder, listener, null, false); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
850 builder.end().end(); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
851 builder.end(); // statement |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
852 } |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
853 } |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
854 |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
855 private void buildGenericValueExecute(CodeTreeBuilder builder, SpecializationData specialization, NodeFieldData field, NodeFieldData exceptionSpec) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
856 ActualParameter specParameter = specialization.findParameter(field.getName()); |
7794
b891ec348f8a
Made the usage of generic types more flexible for short circuits and generic specializations.
Christian Humer <christian.humer@gmail.com>
parents:
7777
diff
changeset
|
857 NodeData node = specialization.getNode(); |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7502
diff
changeset
|
858 boolean shortCircuit = startShortCircuit(builder, specialization, field, exceptionSpec); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
859 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
860 builder.startStatement(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
861 if (!shortCircuit) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
862 builder.type(specialization.getNode().getTypeSystem().getGenericType()); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
863 builder.string(" "); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
864 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
865 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
866 builder.string(valueName(specialization, specParameter)); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
867 builder.string(" = "); |
7794
b891ec348f8a
Made the usage of generic types more flexible for short circuits and generic specializations.
Christian Humer <christian.humer@gmail.com>
parents:
7777
diff
changeset
|
868 ExecutableTypeData genericExecutableType = field.getNodeData().findGenericExecutableType(getContext(), specParameter.getActualTypeData(node.getTypeSystem())); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
869 if (genericExecutableType == null) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
870 throw new AssertionError("Must have generic executable type. Parser validation most likely failed. " + Arrays.toString(field.getNodeData().getExecutableTypes())); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
871 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
872 buildExecute(builder, field, genericExecutableType); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
873 builder.end(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
874 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
875 endShortCircuit(builder, shortCircuit); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
876 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
877 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
878 private void buildExecute(CodeTreeBuilder builder, NodeFieldData field, ExecutableTypeData execType) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
879 if (field != null) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
880 Element accessElement = field.getAccessElement(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
881 if (accessElement.getKind() == ElementKind.METHOD) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
882 builder.startCall(accessElement.getSimpleName().toString()).end(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
883 } else if (accessElement.getKind() == ElementKind.FIELD) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
884 builder.string("this.").string(accessElement.getSimpleName().toString()); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
885 } else { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
886 throw new AssertionError(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
887 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
888 builder.string("."); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
889 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
890 builder.startCall(execType.getMethodName()); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
891 if (execType.getParameters().length == 1) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
892 builder.string("frame"); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
893 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
894 builder.end(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
895 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
896 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
897 private void buildSpecializedValueExecute(CodeTreeBuilder builder, SpecializationData specialization, NodeFieldData field) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
898 ActualParameter param = specialization.findParameter(field.getName()); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
899 boolean shortCircuit = startShortCircuit(builder, specialization, field, null); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
900 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
901 if (!shortCircuit) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
902 builder.startStatement().type(param.getActualType()).string(" ").string(valueName(specialization, param)).end(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
903 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
904 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
905 ExecutableTypeData execType = field.getNodeData().findExecutableType(param.getActualTypeData(field.getNodeData().getTypeSystem())); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
906 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
907 if (execType.hasUnexpectedValue(getContext())) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
908 builder.startTryBlock(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
909 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
910 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
911 builder.startStatement().string(valueName(field)).string(" = "); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
912 buildExecute(builder, field, execType); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
913 builder.end(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
914 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
915 if (execType.hasUnexpectedValue(getContext())) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
916 builder.end().startCatchBlock(getUnexpectedValueException(), "ex"); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
917 boolean execute = false; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
918 for (NodeFieldData exField : specialization.getNode().getFields()) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
919 if (exField.getExecutionKind() == ExecutionKind.IGNORE) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
920 continue; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
921 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
922 if (execute) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
923 buildGenericValueExecute(builder, specialization.getNode().getGenericSpecialization(), exField, field); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
924 } else if (exField == field) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
925 execute = true; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
926 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
927 } |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
928 builder.tree(createReturnSpecializeAndExecute(builder, specialization.findNextSpecialization(), param.getSpecification())); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
929 builder.end(); // catch block |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
930 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
931 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
932 endShortCircuit(builder, shortCircuit); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
933 builder.newLine(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
934 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
935 |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7502
diff
changeset
|
936 private boolean startShortCircuit(CodeTreeBuilder builder, SpecializationData specialization, NodeFieldData forField, NodeFieldData exceptionField) { |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
937 if (forField.getExecutionKind() != ExecutionKind.SHORT_CIRCUIT) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
938 return false; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
939 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
940 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
941 ActualParameter parameter = specialization.findParameter(forField.getName()); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
942 ActualParameter shortCircuitParam = specialization.getPreviousParam(parameter); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
943 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
944 int shortCircuitIndex = 0; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
945 for (NodeFieldData field : specialization.getNode().getFields()) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
946 if (field.getExecutionKind() == ExecutionKind.SHORT_CIRCUIT) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
947 if (field == forField) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
948 break; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
949 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
950 shortCircuitIndex++; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
951 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
952 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
953 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
954 builder.startStatement().type(shortCircuitParam.getActualType()).string(" ").string(valueName(specialization, shortCircuitParam)).string(" = "); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
955 ShortCircuitData shortCircuitData = specialization.getShortCircuits()[shortCircuitIndex]; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
956 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
957 startCallOperationMethod(builder, shortCircuitData); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
958 addValueParameterNames(builder, shortCircuitData, exceptionField != null ? exceptionField.getName() : null, false); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
959 builder.end().end(); // call operation |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
960 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
961 builder.end(); // statement |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
962 |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7502
diff
changeset
|
963 builder.declaration(parameter.getActualType(), valueName(specialization, parameter), CodeTreeBuilder.createBuilder().defaultValue(parameter.getActualType())); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
964 builder.startIf().string(shortCircuitParam.getSpecification().getName()).end(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
965 builder.startBlock(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
966 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
967 return true; |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
968 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
969 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
970 private void endShortCircuit(CodeTreeBuilder builder, boolean shortCircuit) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
971 if (shortCircuit) { |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
972 builder.end(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
973 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
974 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
975 |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
976 private CodeTree createReturnSpecializeAndExecute(CodeTreeBuilder parent, SpecializationData nextSpecialization, ParameterSpec exceptionSpec) { |
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
977 CodeTreeBuilder specializeCall = new CodeTreeBuilder(parent); |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
978 specializeCall.startCall("specializeAndExecute"); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
979 specializeCall.string(nodeClassName(nextSpecialization) + ".class"); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
980 addValueParameterNames(specializeCall, nextSpecialization.getNode().getGenericSpecialization(), exceptionSpec != null ? exceptionSpec.getName() : null, true); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
981 specializeCall.end().end(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
982 |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
983 CodeTreeBuilder builder = new CodeTreeBuilder(parent); |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
984 builder.startReturn(); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
985 builder.tree(specializeCall.getRoot()); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
986 builder.end(); |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
987 return builder.getRoot(); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
988 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
989 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
990 private void buildSpecializeStateMethod(CodeTypeElement clazz, SpecializationData specialization) { |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
991 NodeData node = specialization.getNode(); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
992 TypeData returnType = specialization.getReturnType().getActualTypeData(node.getTypeSystem()); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
993 ExecutableTypeData returnExecutableType = node.findExecutableType(returnType); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
994 boolean canThrowUnexpected = returnExecutableType == null ? true : returnExecutableType.hasUnexpectedValue(getContext()); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
995 |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
996 CodeExecutableElement method = new CodeExecutableElement(modifiers(PRIVATE), returnType.getPrimitiveType(), "specializeAndExecute"); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
997 method.addParameter(new CodeVariableElement(getContext().getType(Class.class), "minimumState")); |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
998 if (canThrowUnexpected) { |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
999 method.addThrownType(getUnexpectedValueException()); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
1000 } |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
1001 addValueParameters(method, specialization.getNode().getGenericSpecialization(), true); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
1002 clazz.add(method); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
1003 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
1004 CodeTreeBuilder builder = method.createBuilder(); |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
1005 |
7846
91cc98eae8ee
Refactor guard creation methods are not flexible enough to handle two if guards.
Christian Humer <christian.humer@gmail.com>
parents:
7845
diff
changeset
|
1006 builder.tree(createDeoptimize(builder)); |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
1007 emitSpecializationListeners(builder, specialization.getNode()); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
1008 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
1009 builder.startStatement(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
1010 builder.startCall("replace"); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
1011 builder.startCall(factoryClassName(specialization.getNode()), "specialize").string("this").string("minimumState"); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
1012 addValueParameterNames(builder, specialization.getNode().getGenericSpecialization(), null, false); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
1013 builder.end(); |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
1014 builder.end(); // call replace |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
1015 builder.end(); // statement |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
1016 |
7777
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
1017 String generatedMethodName = generatedGenericMethodName(specialization.findNextSpecialization()); |
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
1018 ExecutableElement generatedGeneric = clazz.getEnclosingClass().getMethod(generatedMethodName); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
1019 |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
1020 CodeTreeBuilder genericExecute = CodeTreeBuilder.createBuilder(); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
1021 genericExecute.startCall(factoryClassName(specialization.getNode()), generatedMethodName); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
1022 genericExecute.string("this"); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
1023 addValueParameterNames(genericExecute, specialization.getNode().getGenericSpecialization(), null, true); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
1024 genericExecute.end(); // call generated generic |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
1025 |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
1026 CodeTree genericInvocation = castPrimaryExecute(node, returnExecutableType, genericExecute.getRoot()); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
1027 |
7777
ca51efac4d57
Fixed rewrite in generated generic did not invoke guards.
Christian Humer <christian.humer@gmail.com>
parents:
7751
diff
changeset
|
1028 if (generatedGeneric != null && Utils.isVoid(generatedGeneric.getReturnType())) { |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
1029 builder.statement(genericInvocation); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
1030 |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
1031 if (!Utils.isVoid(builder.findMethod().asType())) { |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
1032 builder.startReturn().defaultValue(returnType.getPrimitiveType()).end(); |
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
1033 } |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
1034 } else { |
7843
4969921f57b7
Renamed generated specialize to specializeAndExecute.
Christian Humer <christian.humer@gmail.com>
parents:
7799
diff
changeset
|
1035 builder.startReturn().tree(genericInvocation).end(); |
7502
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
1036 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
1037 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
1038 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
1039 } |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
1040 |
6343a09b2ec1
Codegen operation generation is inferred from the node type hierarchy.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
1041 } |