graal-compiler: graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/node/NodeCodeGenerator.java annotate

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 }

Mercurial > hg > graal-compiler

annotate graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/node/NodeCodeGenerator.java @ 7846:91cc98eae8ee