graal-jvmci-8: 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 @ 7847:06a7cd6aaf00

Casting is now done on demand using local variables for explicit guards.

author	Christian Humer <christian.humer@gmail.com>
date	Tue, 19 Feb 2013 17:20:45 +0100
parents	91cc98eae8ee
children	6e4fb0ccebb1

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
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	86 private static String valueName(ActualParameter param) {
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	87 NodeData node = (NodeData) param.getMethod().getTemplate();
7502 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
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	96 private static String castValueName(ActualParameter parameter) {
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	97 return valueName(parameter) + "Cast";
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	98 }
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	99
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	100 private static String castValueName(NodeFieldData field) {
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	101 return valueName(field) + "Cast";
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	102 }
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	103
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	104 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	105 if (forceFrame) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	106 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	107 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	108 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	109 ParameterSpec spec = parameter.getSpecification();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	110 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	111 continue;
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	112 }
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	113 method.addParameter(new CodeVariableElement(parameter.getActualType(), valueName(parameter)));
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	114 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	115 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	116
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	117 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	118 if (forceFrame) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	119 builder.string("frame");
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	120 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	121 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	122 ParameterSpec spec = parameter.getSpecification();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	123 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	124 continue;
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
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	127 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	128 builder.string("ex.getResult()");
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	129 } else {
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	130 builder.string(valueName(parameter));
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	131 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	132 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	133 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	134
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	135 private static void addValueParameterNamesWithCasts(CodeTreeBuilder body, SpecializationData valueSpecialization, SpecializationData targetSpecialization) {
7843 4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	136 NodeData node = targetSpecialization.getNode();
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	137 TypeSystemData typeSystem = node.getTypeSystem();
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 for (ActualParameter targetParameter : targetSpecialization.getParameters()) {
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	140 ActualParameter valueParameter = valueSpecialization.findParameter(targetParameter.getSpecification().getName());
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	141 TypeData targetType = targetParameter.getActualTypeData(typeSystem);
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	142
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	143 TypeData valueType = null;
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	144 if (valueParameter != null) {
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	145 valueType = valueParameter.getActualTypeData(typeSystem);
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	146 }
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	147
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	148 if (targetType == null \|\| targetType.isGeneric() \|\| (valueType != null && valueType.equalsType(targetType))) {
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	149 body.string(valueName(targetParameter));
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	150 } else {
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	151 body.string(castValueName(targetParameter));
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	152 }
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
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	156 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	157 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	158 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	159
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	160 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	161 body.startGroup();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	162 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	163 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	164 } else {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	165 body.string("super");
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	166 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	167 body.string(".");
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	168 body.startCall(method.getMethodName());
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	169 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	170
7777 ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	171 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	172 final String prefix = "generic";
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	173
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	174 if (specialization == null) {
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	175 return prefix;
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	176 }
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	177
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	178 SpecializationData prev = null;
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	179 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	180 if (specialization == current) {
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	181 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	182 return prefix;
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	183 } else {
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	184 return prefix + specializationId(current);
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 }
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	187 prev = current;
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	188 }
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	189 return prefix;
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	190 }
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	191
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	192 private static CodeTree createCallTypeSystemMethod(ProcessorContext context, CodeTreeBuilder parent, NodeData node, String methodName, String value) {
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	193 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	194 startCallTypeSystemMethod(context, builder, node, methodName);
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	195 builder.string(value);
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	196 builder.end().end();
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	197 return builder.getRoot();
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	198 }
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	199
7530 5e3d1a68664e applied mx eclipseformat to all Java files Doug Simon <doug.simon@oracle.com> parents: 7502 diff changeset	200 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	201 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	202 assert singleton != null;
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	203
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	204 body.startGroup();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	205 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	206 body.string(".").startCall(methodName);
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	207 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	208
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	209 private CodeTree createGuardAndCast(CodeTreeBuilder parent, String conditionPrefix, SpecializationData valueSpecialization, SpecializationData guardedSpecialization, boolean onSpecialization,
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	210 CodeTree guardedStatements, CodeTree elseStatements) {
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	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 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	213 CodeTree implicitGuards = createImplicitGuards(parent, conditionPrefix, valueSpecialization, guardedSpecialization);
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	214 CodeTree explicitGuards = createExplicitGuards(parent, implicitGuards == null ? conditionPrefix : null, valueSpecialization, guardedSpecialization, 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	215
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 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	217
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 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	219 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	220 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	221 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	222 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	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
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	226 if (explicitGuards != null \|\| !onSpecialization) {
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	227 builder.tree(createCasts(parent, valueSpecialization, guardedSpecialization));
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	228 }
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	229
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	230 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	231 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	232 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	233 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	234 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	235 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	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
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	238 if (implicitGuards == null && explicitGuards == null && conditionPrefix != null && !conditionPrefix.isEmpty()) {
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	239 builder.startIf().string(conditionPrefix).end().startBlock();
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 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	241 }
91cc98eae8ee Refactor guard creation methods are not flexible enough to handle two if guards. Christian Humer <christian.humer@gmail.com> parents: 7845 diff changeset	242
91cc98eae8ee Refactor guard creation methods are not flexible enough to handle two if guards. Christian Humer <christian.humer@gmail.com> parents: 7845 diff changeset	243 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	244
91cc98eae8ee Refactor guard creation methods are not flexible enough to handle two if guards. Christian Humer <christian.humer@gmail.com> parents: 7845 diff changeset	245 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	246 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	247 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	248 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	249 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	250 }
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
91cc98eae8ee Refactor guard creation methods are not flexible enough to handle two if guards. Christian Humer <christian.humer@gmail.com> parents: 7845 diff changeset	252 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	253 }
91cc98eae8ee Refactor guard creation methods are not flexible enough to handle two if guards. Christian Humer <christian.humer@gmail.com> parents: 7845 diff changeset	254
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	255 private static CodeTree createExplicitGuards(CodeTreeBuilder parent, String conditionPrefix, SpecializationData valueSpecialization, SpecializationData guardedSpecialization,
7843 4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	256 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	257 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	258 String andOperator = conditionPrefix != null ? conditionPrefix + " && " : "";
7843 4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	259 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	260 // Explicitly specified guards
7843 4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	261 for (SpecializationGuardData guard : guardedSpecialization.getGuards()) {
7530 5e3d1a68664e applied mx eclipseformat to all Java files Doug Simon <doug.simon@oracle.com> parents: 7502 diff changeset	262 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	263 builder.string(andOperator);
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	264
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	265 startCallOperationMethod(builder, guard.getGuardDeclaration());
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	266 addValueParameterNamesWithCasts(builder, valueSpecialization, guardedSpecialization);
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	267
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	268 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	269 andOperator = " && ";
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	270 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	271 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	272 }
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	273
91cc98eae8ee Refactor guard creation methods are not flexible enough to handle two if guards. Christian Humer <christian.humer@gmail.com> parents: 7845 diff changeset	274 return builder.isEmpty() ? null : builder.getRoot();
7843 4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	275 }
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	276
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	277 private CodeTree createCasts(CodeTreeBuilder parent, SpecializationData valueSpecialization, SpecializationData guardedSpecialization) {
7843 4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	278 NodeData node = guardedSpecialization.getNode();
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 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
7843 4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	281 // Implict guards based on method signature
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	282 for (NodeFieldData field : node.getFields()) {
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	283 ActualParameter guardedParam = guardedSpecialization.findParameter(field.getName());
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	284 ActualParameter valueParam = valueSpecialization.findParameter(field.getName());
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	285
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	286 CodeTree cast = createCast(parent, field, valueParam, guardedParam);
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	287 if (cast == null) {
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	288 continue;
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	289 }
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	290 builder.tree(cast);
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	291 }
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	292
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	293 return builder.getRoot();
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	294 }
7843 4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	295
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	296 private CodeTree createImplicitGuards(CodeTreeBuilder parent, String conditionPrefix, SpecializationData valueSpecialization, SpecializationData guardedSpecialization) {
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	297 NodeData node = guardedSpecialization.getNode();
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	298
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	299 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	300 // Implict guards based on method signature
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	301 String andOperator = conditionPrefix != null ? conditionPrefix + " && " : "";
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	302 for (NodeFieldData field : node.getFields()) {
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	303 ActualParameter guardedParam = guardedSpecialization.findParameter(field.getName());
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	304 ActualParameter valueParam = valueSpecialization.findParameter(field.getName());
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	305
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	306 CodeTree implicitGuard = createImplicitGuard(builder, field, valueParam, guardedParam);
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	307 if (implicitGuard == null) {
7843 4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	308 continue;
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	309 }
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	310
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	311 builder.string(andOperator);
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	312 builder.tree(implicitGuard);
7843 4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	313 andOperator = " && ";
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	314 }
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	315
91cc98eae8ee Refactor guard creation methods are not flexible enough to handle two if guards. Christian Humer <christian.humer@gmail.com> parents: 7845 diff changeset	316 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	317 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	318
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	319 private CodeTree createImplicitGuard(CodeTreeBuilder parent, NodeFieldData field, ActualParameter source, ActualParameter target) {
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	320 NodeData node = field.getNodeData();
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	321 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	322
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	323 TypeData targetType = target.getActualTypeData(node.getTypeSystem());
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	324 TypeData sourceType = source.getActualTypeData(node.getTypeSystem());
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	325
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	326 if (targetType.equalsType(sourceType) \|\| targetType.isGeneric()) {
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	327 return null;
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	328 }
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	329
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	330 builder.startGroup();
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	331
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	332 if (field.isShortCircuit()) {
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	333 ActualParameter shortCircuit = target.getPreviousParameter();
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	334 assert shortCircuit != null;
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	335 builder.string("(");
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	336 builder.string("!").string(valueName(shortCircuit));
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	337 builder.string(" \|\| ");
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	338 }
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	339
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	340 startCallTypeSystemMethod(getContext(), builder, node, TypeSystemCodeGenerator.isTypeMethodName(target.getActualTypeData(node.getTypeSystem())));
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	341 builder.string(valueName(field));
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	342 builder.end().end(); // call
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	343
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	344 if (field.isShortCircuit()) {
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	345 builder.string(")");
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	346 }
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	347
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	348 builder.end(); // group
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	349
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	350 return builder.getRoot();
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	351 }
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	352
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	353 private CodeTree createCast(CodeTreeBuilder parent, NodeFieldData field, ActualParameter source, ActualParameter target) {
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	354 NodeData node = field.getNodeData();
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	355 TypeSystemData typeSystem = node.getTypeSystem();
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	356
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	357 TypeData sourceType = source.getActualTypeData(typeSystem);
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	358 TypeData targetType = target.getActualTypeData(typeSystem);
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	359
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	360 if (targetType.equalsType(sourceType) \|\| targetType.isGeneric()) {
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	361 return null;
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	362 }
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	363
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	364 CodeTree condition = null;
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	365 if (field.isShortCircuit()) {
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	366 ActualParameter shortCircuit = target.getPreviousParameter();
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	367 assert shortCircuit != null;
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	368 condition = CodeTreeBuilder.singleString(valueName(shortCircuit));
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	369 }
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	370
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	371 CodeTree value = createCallTypeSystemMethod(context, parent, node, TypeSystemCodeGenerator.asTypeMethodName(targetType), valueName(target));
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	372
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	373 return createLazyAssignment(parent, castValueName(field), target.getActualType(), condition, value);
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	374 }
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	375
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	376 /**
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	377 * <pre>
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	378 * variant1 $condition != null
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	379 *
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	380 * $type $name = defaultValue($type);
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	381 * if ($condition) {
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	382 * $name = $value;
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	383 * }
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	384 *
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	385 * variant2 $condition != null
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	386 * $type $name = $value;
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	387 * </pre>
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	388 *
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	389 * .
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	390 */
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	391 private static CodeTree createLazyAssignment(CodeTreeBuilder parent, String name, TypeMirror type, CodeTree condition, CodeTree value) {
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	392 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	393 if (condition == null) {
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	394 builder.declaration(type, name, value);
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	395 } else {
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	396 builder.declaration(type, name, new CodeTreeBuilder(parent).defaultValue(type).getRoot());
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	397
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	398 builder.startIf().tree(condition).end();
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	399 builder.startBlock();
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	400 builder.startStatement();
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	401 builder.string(name);
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	402 builder.string(" = ");
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	403 builder.tree(value);
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	404 builder.end(); // statement
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	405 builder.end(); // block
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	406 }
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	407 return builder.getRoot();
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	408 }
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	409
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	410 @Override
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	411 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	412 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	413 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	414 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	415 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	416 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	417 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	418 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	419
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	420 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	421 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	422 add(factory, node);
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	423 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	424
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	425 if (node.getSpecializations() == null) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	426 return;
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 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	430 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	431 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	432 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	433
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	434 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	435
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	436 public NodeGenFactory(ProcessorContext context) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	437 super(context);
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	438 }
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 @Override
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	441 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	442 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	443
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	444 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	445 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	446
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	447 if (superConstructor != null) {
7530 5e3d1a68664e applied mx eclipseformat to all Java files Doug Simon <doug.simon@oracle.com> parents: 7502 diff changeset	448 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	449 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	450 superConstructor.getParameters().clear();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	451 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	452 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	453 clazz.add(superConstructor);
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 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	456
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	457 if (node.getExtensionElements() != null) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	458 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	459 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	460
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	461 node.setNodeType(clazz.asType());
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	462
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	463 return clazz;
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	464 }
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 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	467
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	468 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	469
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	470 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	471
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	472 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	473 super(context);
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	474 this.childTypes = childElements;
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	475 }
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 @Override
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	478 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	479 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	480 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	481 if (visibility != null) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	482 clazz.getModifiers().add(visibility);
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	483 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	484 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	485 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	486 return clazz;
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	487 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	488
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	489 @Override
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	490 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	491 CodeTypeElement clazz = getElement();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	492
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	493 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	494
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	495 if (node.needsFactory()) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	496 createFactoryMethods(node, clazz, createVisibility);
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 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	499 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	500 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	501
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	502 if (node.needsRewrites(getContext())) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	503 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	504
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	505 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	506 for (CodeExecutableElement method : genericMethods) {
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	507 clazz.add(method);
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	508 }
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	509 }
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 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	512 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	513 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	514 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	515
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	516 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	517 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	518 continue;
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	519 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	520
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	521 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	522 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	523 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	524 typeModifiers.clear();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	525 if (visibility != null) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	526 typeModifiers.add(visibility);
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	527 }
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 typeModifiers.add(Modifier.STATIC);
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	530 typeModifiers.add(Modifier.FINAL);
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	531 clazz.add(type);
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	532 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	533 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	534 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	535
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	536 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	537 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	538 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	539 continue;
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	540 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	541
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	542 // skip node rewrite constructor
7530 5e3d1a68664e applied mx eclipseformat to all Java files Doug Simon <doug.simon@oracle.com> parents: 7502 diff changeset	543 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	544 continue;
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	545 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	546
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	547 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	548 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	549 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	550
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	551 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	552 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	553 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	554 method.getModifiers().clear();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	555 if (visibility != null) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	556 method.getModifiers().add(visibility);
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	557 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	558 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	559 method.setReturnType(node.getNodeType());
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	560
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	561 CodeTreeBuilder body = method.createBuilder();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	562 body.startReturn();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	563 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	564 body.null_();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	565 } else {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	566 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	567 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	568 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	569 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	570 body.end();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	571 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	572 body.end();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	573 return method;
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	574 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	575
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	576 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	577 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	578 if (visibility != null) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	579 method.getModifiers().add(visibility);
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	580 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	581 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	582
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	583 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	584 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	585
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	586 CodeTreeBuilder body = method.createBuilder();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	587 boolean first = true;
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	588 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	589 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	590 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	591 if (first) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	592 body.startIf();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	593 first = false;
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	594 } else {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	595 body.startElseIf();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	596 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	597 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	598 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	599 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	600 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	601
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	602 body.end(); // if
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	603 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	604 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	605 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	606 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	607 body.end().end();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	608 return method;
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 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	612 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	613 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	614 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	615 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	616
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	617 CodeTreeBuilder body = method.createBuilder();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	618 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	619
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	620 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	621 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	622 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	623
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	624 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	625 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	626 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	627 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	628
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	629 body.tree(createGuardAndCast(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	630 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	631 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	632
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	633 return method;
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	634 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	635
7777 ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	636 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	637 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	638 if (node.getGenericSpecialization().isUseSpecializationsForGeneric()) {
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	639 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	640
7777 ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	641 SpecializationData[] specializations = node.getSpecializations();
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	642 SpecializationData prev = null;
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	643 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	644 SpecializationData current = specializations[i];
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	645 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	646 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	647 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	648 continue;
7777 ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	649 } else {
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	650 String methodName = generatedGenericMethodName(current);
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	651 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	652 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	653 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	654
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	655 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	656
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	657 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	658 }
7777 ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	659 prev = current;
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	660 }
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	661
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	662 return methods;
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	663 } else {
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	664 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	665 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	666 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	667 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	668 return Arrays.asList(method);
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	669 }
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	670 }
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	671
7777 ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	672 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	673 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	674 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	675 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	676
7777 ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	677 if (next != null) {
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	678 invokeMethod = createGuardAndCast(builder, null, 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	679 }
7777 ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	680
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	681 builder.tree(invokeMethod);
7777 ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	682
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	683 if (next != null) {
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	684 builder.end();
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	685
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	686 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	687 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	688 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	689 builder.end().end();
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	690 }
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	691 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	692
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	693 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	694 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	695 builder.startTryBlock();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	696 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	697
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	698 builder.startReturn();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	699 startCallOperationMethod(builder, specialization);
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	700 addValueParameterNamesWithCasts(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	701 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	702 builder.end(); // return
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	703
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	704 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	705 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	706 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	707
ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	708 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	709 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	710 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	711 builder.end().end();
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	712 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	713 builder.end();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	714 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	715 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	716 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	717
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	718 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	719
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	720 public SpecializedNodeFactory(ProcessorContext context) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	721 super(context);
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	722 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	723
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	724 @Override
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	725 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	726 NodeData node = specialization.getNode();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	727 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	728 return clazz;
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	729 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	730
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	731 @Override
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	732 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	733 CodeTypeElement clazz = getElement();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	734 NodeData node = specialization.getNode();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	735
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	736 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	737 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	738 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	739 if (superConstructor != null) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	740 clazz.add(superConstructor);
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 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	743
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	744 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	745 if (execType.isFinal()) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	746 continue;
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	747 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	748 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	749 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	750 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	751 var.setName("frame");
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	752 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	753 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	754 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	755 clazz.add(method);
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	756
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	757 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	758 if (primaryType == execType.getType()) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	759 buildFunctionalExecuteMethod(method.createBuilder(), specialization);
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	760 } else {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	761 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	762 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	763 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	764
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	765 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	766 buildSpecializeStateMethod(clazz, specialization);
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	767 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	768 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	769
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	770 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	771 NodeData node = specialization.getNode();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	772 TypeSystemData typeSystem = node.getTypeSystem();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	773
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	774 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	775 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	776 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	777
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	778 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	779 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	780
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	781 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	782
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	783 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	784 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	785 primaryExecuteCall = executeBuilder.getRoot();
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	786
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	787 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	788 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	789 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	790 }
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	791 builder.startTryBlock();
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	792
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	793 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	794 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	795 } 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	796 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	797 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	798 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	799 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	800 }
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	801
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	802 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	803 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	804 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	805 } 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	806 builder.startReturn();
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	807 builder.tree(createExpectType(node, castedType, CodeTreeBuilder.singleString("ex.getResult()")));
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	808 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	809 }
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	810 builder.end();
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	811
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	812 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	813 builder.startReturn();
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	814 builder.tree(createExpectType(node, castedType, CodeTreeBuilder.singleString("value")));
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	815 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	816 }
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	817 } 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	818 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	819 builder.statement(primaryExecuteCall);
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	820 } 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	821 builder.startReturn();
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	822 builder.tree(createExpectType(node, castedType, primaryExecuteCall));
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	823 builder.end();
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	824 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	825 }
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	826 }
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	827
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	828 private CodeTree createExpectType(NodeData node, ExecutableTypeData castedType, CodeTree value) {
7843 4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	829 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	830 return value;
7843 4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	831 } else if (castedType.getType().isVoid()) {
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	832 return value;
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	833 } 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	834 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	835 }
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	836
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	837 CodeTreeBuilder builder = CodeTreeBuilder.createBuilder();
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	838 String targetMethodName;
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	839 if (castedType.hasUnexpectedValue(getContext())) {
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	840 targetMethodName = TypeSystemCodeGenerator.expectTypeMethodName(castedType.getType());
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	841 } else {
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	842 targetMethodName = 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	843 }
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	844 startCallTypeSystemMethod(getContext(), builder, node, targetMethodName);
06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	845
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	846 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	847 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	848 return builder.getRoot();
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	849 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	850
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	851 private void buildFunctionalExecuteMethod(CodeTreeBuilder builder, SpecializationData specialization) {
7843 4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	852 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	853 builder.tree(createDeoptimize(builder));
7843 4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	854 }
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	855
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	856 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	857
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	858 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	859 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	860 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	861
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	862 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	863
91cc98eae8ee Refactor guard creation methods are not flexible enough to handle two if guards. Christian Humer <christian.humer@gmail.com> parents: 7845 diff changeset	864 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	865 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	866 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	867 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	868 }
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	869 builder.tree(createGuardAndCast(builder, null, specialization, specialization, false, executeNode, returnSpecialized));
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	870 }
91cc98eae8ee Refactor guard creation methods are not flexible enough to handle two if guards. Christian Humer <christian.humer@gmail.com> parents: 7845 diff changeset	871
91cc98eae8ee Refactor guard creation methods are not flexible enough to handle two if guards. Christian Humer <christian.humer@gmail.com> parents: 7845 diff changeset	872 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	873 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	874 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	875 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	876 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	877 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	878 }
91cc98eae8ee Refactor guard creation methods are not flexible enough to handle two if guards. Christian Humer <christian.humer@gmail.com> parents: 7845 diff changeset	879
91cc98eae8ee Refactor guard creation methods are not flexible enough to handle two if guards. Christian Humer <christian.humer@gmail.com> parents: 7845 diff changeset	880 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	881 NodeData node = specialization.getNode();
7843 4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	882
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	883 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	884 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	885
91cc98eae8ee Refactor guard creation methods are not flexible enough to handle two if guards. Christian Humer <christian.humer@gmail.com> parents: 7845 diff changeset	886 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	887 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	888 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	889 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	890 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	891 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	892 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	893 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	894 } 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	895 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	896 }
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	897 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	898 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	899 }
7843 4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	900
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	901 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	902 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	903 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	904 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	905 builder.startTryBlock();
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
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	908 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	909 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	910 builder.string("this");
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	911 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	912 builder.end().end();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	913 } else {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	914 builder.startReturn();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	915
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	916 if (specialization.isUninitialized()) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	917 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	918 } else {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	919 startCallOperationMethod(builder, specialization);
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	920 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	921 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	922 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	923 builder.end(); // return
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	924 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	925
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	926 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	927 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	928 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	929 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	930 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	931 builder.end();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	932 }
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	933 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	934 }
91cc98eae8ee Refactor guard creation methods are not flexible enough to handle two if guards. Christian Humer <christian.humer@gmail.com> parents: 7845 diff changeset	935
91cc98eae8ee Refactor guard creation methods are not flexible enough to handle two if guards. Christian Humer <christian.humer@gmail.com> parents: 7845 diff changeset	936 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	937 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	938 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	939 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	940 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	941 }
91cc98eae8ee Refactor guard creation methods are not flexible enough to handle two if guards. Christian Humer <christian.humer@gmail.com> parents: 7845 diff changeset	942
91cc98eae8ee Refactor guard creation methods are not flexible enough to handle two if guards. Christian Humer <christian.humer@gmail.com> parents: 7845 diff changeset	943 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	944
91cc98eae8ee Refactor guard creation methods are not flexible enough to handle two if guards. Christian Humer <christian.humer@gmail.com> parents: 7845 diff changeset	945 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	946 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	947 } 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	948 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	949 }
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	950 }
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	951 return builder.getRoot();
7502 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
7843 4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	954 private void emitSpecializationListeners(CodeTreeBuilder builder, NodeData node) {
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	955 for (TemplateMethod listener : node.getSpecializationListeners()) {
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	956 builder.startStatement();
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	957 startCallOperationMethod(builder, listener);
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	958 addValueParameterNames(builder, listener, null, false);
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	959 builder.end().end();
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	960 builder.end(); // statement
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	961 }
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	962 }
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	963
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	964 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	965 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	966 NodeData node = specialization.getNode();
7530 5e3d1a68664e applied mx eclipseformat to all Java files Doug Simon <doug.simon@oracle.com> parents: 7502 diff changeset	967 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	968
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	969 builder.startStatement();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	970 if (!shortCircuit) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	971 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	972 builder.string(" ");
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
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	975 builder.string(valueName(specParameter));
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	976 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	977 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	978 if (genericExecutableType == null) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	979 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	980 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	981 buildExecute(builder, field, genericExecutableType);
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	982 builder.end();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	983
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	984 endShortCircuit(builder, shortCircuit);
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	985 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	986
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	987 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	988 if (field != null) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	989 Element accessElement = field.getAccessElement();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	990 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	991 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	992 } 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	993 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	994 } else {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	995 throw new AssertionError();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	996 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	997 builder.string(".");
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	998 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	999 builder.startCall(execType.getMethodName());
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1000 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	1001 builder.string("frame");
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1002 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1003 builder.end();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1004 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1005
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1006 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	1007 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	1008 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	1009
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1010 if (!shortCircuit) {
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	1011 builder.startStatement().type(param.getActualType()).string(" ").string(valueName(param)).end();
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1012 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1013
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1014 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	1015
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1016 if (execType.hasUnexpectedValue(getContext())) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1017 builder.startTryBlock();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1018 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1019
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1020 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	1021 buildExecute(builder, field, execType);
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1022 builder.end();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1023
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1024 if (execType.hasUnexpectedValue(getContext())) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1025 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	1026 boolean execute = false;
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1027 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	1028 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	1029 continue;
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1030 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1031 if (execute) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1032 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	1033 } else if (exField == field) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1034 execute = true;
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1035 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1036 }
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	1037 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	1038 builder.end(); // catch block
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 endShortCircuit(builder, shortCircuit);
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1042 builder.newLine();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1043 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1044
7530 5e3d1a68664e applied mx eclipseformat to all Java files Doug Simon <doug.simon@oracle.com> parents: 7502 diff changeset	1045 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	1046 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	1047 return false;
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1048 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1049
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1050 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	1051 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	1052
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1053 int shortCircuitIndex = 0;
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1054 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	1055 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	1056 if (field == forField) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1057 break;
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1058 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1059 shortCircuitIndex++;
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1060 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1061 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1062
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	1063 builder.startStatement().type(shortCircuitParam.getActualType()).string(" ").string(valueName(shortCircuitParam)).string(" = ");
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1064 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	1065
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1066 startCallOperationMethod(builder, shortCircuitData);
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1067 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	1068 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	1069
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1070 builder.end(); // statement
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1071
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	1072 builder.declaration(parameter.getActualType(), valueName(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	1073 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	1074 builder.startBlock();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1075
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1076 return true;
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1077 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1078
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1079 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	1080 if (shortCircuit) {
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1081 builder.end();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1082 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1083 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1084
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	1085 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	1086 CodeTreeBuilder specializeCall = new CodeTreeBuilder(parent);
7843 4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1087 specializeCall.startCall("specializeAndExecute");
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1088 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	1089 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	1090 specializeCall.end().end();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1091
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	1092 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
7843 4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1093 builder.startReturn();
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1094 builder.tree(specializeCall.getRoot());
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1095 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	1096 return builder.getRoot();
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1097 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1098
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1099 private void buildSpecializeStateMethod(CodeTypeElement clazz, SpecializationData specialization) {
7843 4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1100 NodeData node = specialization.getNode();
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1101 TypeData returnType = specialization.getReturnType().getActualTypeData(node.getTypeSystem());
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1102 ExecutableTypeData returnExecutableType = node.findExecutableType(returnType);
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1103 boolean canThrowUnexpected = returnExecutableType == null ? true : returnExecutableType.hasUnexpectedValue(getContext());
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1104
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1105 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	1106 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	1107 if (canThrowUnexpected) {
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1108 method.addThrownType(getUnexpectedValueException());
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1109 }
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1110 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	1111 clazz.add(method);
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1112
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1113 CodeTreeBuilder builder = method.createBuilder();
7843 4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1114
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	1115 builder.tree(createDeoptimize(builder));
7843 4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1116 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	1117
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1118 builder.startStatement();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1119 builder.startCall("replace");
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1120 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	1121 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	1122 builder.end();
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1123 builder.end(); // call replace
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1124 builder.end(); // statement
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1125
7777 ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	1126 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	1127 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	1128
7843 4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1129 CodeTreeBuilder genericExecute = CodeTreeBuilder.createBuilder();
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1130 genericExecute.startCall(factoryClassName(specialization.getNode()), generatedMethodName);
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1131 genericExecute.string("this");
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1132 addValueParameterNames(genericExecute, specialization.getNode().getGenericSpecialization(), null, true);
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1133 genericExecute.end(); // call generated generic
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1134
7847 06a7cd6aaf00 Casting is now done on demand using local variables for explicit guards. Christian Humer <christian.humer@gmail.com> parents: 7846 diff changeset	1135 CodeTree genericInvocation = createExpectType(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	1136
7777 ca51efac4d57 Fixed rewrite in generated generic did not invoke guards. Christian Humer <christian.humer@gmail.com> parents: 7751 diff changeset	1137 if (generatedGeneric != null && Utils.isVoid(generatedGeneric.getReturnType())) {
7843 4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1138 builder.statement(genericInvocation);
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1139
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1140 if (!Utils.isVoid(builder.findMethod().asType())) {
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1141 builder.startReturn().defaultValue(returnType.getPrimitiveType()).end();
4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1142 }
7502 6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1143 } else {
7843 4969921f57b7 Renamed generated specialize to specializeAndExecute. Christian Humer <christian.humer@gmail.com> parents: 7799 diff changeset	1144 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	1145 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1146 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1147
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1148 }
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1149
6343a09b2ec1 Codegen operation generation is inferred from the node type hierarchy. Christian Humer <christian.humer@gmail.com> parents: diff changeset	1150 }

Mercurial > hg > graal-jvmci-8

annotate graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/node/NodeCodeGenerator.java @ 7847:06a7cd6aaf00