truffle: graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/node/NodeCodeGenerator.java comparison

comparison graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/node/NodeCodeGenerator.java @ 10597:79041ab43660

Truffle-DSL: API-change: Renamed truffle.api.codegen to truffle.api.dsl for all projects and packages.

author	Christian Humer <christian.humer@gmail.com>
date	Mon, 01 Jul 2013 20:58:32 +0200
parents
children	e93efe3ba5f4

comparison

equal deleted inserted replaced

-:f43eb2f1bbbc
+:79041ab43660
+/*
+* Copyright (c) 2012, 2012, Oracle and/or its affiliates. All rights reserved.
+* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+*
+* This code is free software; you can redistribute it and/or modify it
+* under the terms of the GNU General Public License version 2 only, as
+* published by the Free Software Foundation.
+*
+* This code is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+* version 2 for more details (a copy is included in the LICENSE file that
+* accompanied this code).
+*
+* You should have received a copy of the GNU General Public License version
+* 2 along with this work; if not, write to the Free Software Foundation,
+* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+*
+* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+* or visit www.oracle.com if you need additional information or have any
+* questions.
+*/
+package com.oracle.truffle.dsl.processor.node;
+import static com.oracle.truffle.dsl.processor.Utils.*;
+import static javax.lang.model.element.Modifier.*;
+import java.util.*;
+import javax.lang.model.element.*;
+import javax.lang.model.type.*;
+import javax.lang.model.util.*;
+import com.oracle.truffle.api.dsl.*;
+import com.oracle.truffle.api.nodes.NodeInfo.Kind;
+import com.oracle.truffle.dsl.processor.*;
+import com.oracle.truffle.dsl.processor.ast.*;
+import com.oracle.truffle.dsl.processor.node.NodeChildData.*;
+import com.oracle.truffle.dsl.processor.template.*;
+import com.oracle.truffle.dsl.processor.typesystem.*;
+public class NodeCodeGenerator extends CompilationUnitFactory<NodeData> {
+private static final String THIS_NODE_LOCAL_VAR_NAME = "thisNode";
+private static final String EXECUTE_GENERIC_NAME = "executeGeneric0";
+private static final String EXECUTE_SPECIALIZE_NAME = "executeAndSpecialize0";
+public NodeCodeGenerator(ProcessorContext context) {
+super(context);
+}
+private TypeMirror getUnexpectedValueException() {
+return getContext().getTruffleTypes().getUnexpectedValueException();
+}
+private static String factoryClassName(NodeData node) {
+return node.getNodeId() + "Factory";
+}
+private static String nodeSpecializationClassName(SpecializationData specialization) {
+String nodeid = specialization.getNode().getNodeId();
+if (nodeid.endsWith("Node") && !nodeid.equals("Node")) {
+nodeid = nodeid.substring(0, nodeid.length() - 4);
+}
+String name = Utils.firstLetterUpperCase(nodeid);
+name += Utils.firstLetterUpperCase(specialization.getId());
+name += "Node";
+return name;
+}
+private static String nodePolymorphicClassName(NodeData node, SpecializationData specialization) {
+String nodeid = node.getNodeId();
+if (nodeid.endsWith("Node") && !nodeid.equals("Node")) {
+nodeid = nodeid.substring(0, nodeid.length() - 4);
+}
+String name = Utils.firstLetterUpperCase(nodeid);
+int index = specialization == null ? 0 : node.getPolymorphicSpecializations().indexOf(specialization);
+if (index == 0) {
+name += "PolymorphicNode";
+} else {
+name += "Polymorphic" + index + "Node";
+}
+return name;
+}
+private static String valueNameEvaluated(ActualParameter targetParameter) {
+return valueName(targetParameter) + "Evaluated";
+}
+private static String valueName(ActualParameter param) {
+return param.getLocalName();
+}
+private static String castValueName(ActualParameter parameter) {
+return valueName(parameter) + "Cast";
+}
+private void addInternalValueParameters(CodeExecutableElement method, TemplateMethod specialization, boolean forceFrame, boolean evaluated) {
+if (forceFrame && specialization.getSpecification().findParameterSpec("frame") != null) {
+method.addParameter(new CodeVariableElement(getContext().getTruffleTypes().getFrame(), "frameValue"));
+}
+for (ActualParameter parameter : specialization.getParameters()) {
+ParameterSpec spec = parameter.getSpecification();
+if (forceFrame && spec.getName().equals("frame")) {
+continue;
+}
+if (spec.isLocal()) {
+continue;
+}
+String name = valueName(parameter);
+if (evaluated && spec.isSignature()) {
+name = valueNameEvaluated(parameter);
+}
+method.addParameter(new CodeVariableElement(parameter.getType(), name));
+}
+}
+private void addInternalValueParameterNames(CodeTreeBuilder builder, TemplateMethod source, TemplateMethod specialization, String unexpectedValueName, boolean forceFrame, boolean includeImplicit) {
+if (forceFrame && specialization.getSpecification().findParameterSpec("frame") != null) {
+builder.string("frameValue");
+}
+for (ActualParameter parameter : specialization.getParameters()) {
+ParameterSpec spec = parameter.getSpecification();
+if (forceFrame && spec.getName().equals("frame")) {
+continue;
+}
+if (!includeImplicit && (parameter.isImplicit())) {
+continue;
+}
+if (parameter.getSpecification().isLocal()) {
+continue;
+}
+ActualParameter sourceParameter = source.findParameter(parameter.getLocalName());
+if (unexpectedValueName != null && parameter.getLocalName().equals(unexpectedValueName)) {
+builder.cast(parameter.getType(), CodeTreeBuilder.singleString("ex.getResult()"));
+} else if (sourceParameter != null) {
+builder.string(valueName(sourceParameter, parameter));
+} else {
+builder.string(valueName(parameter));
+}
+}
+}
+private String valueName(ActualParameter sourceParameter, ActualParameter targetParameter) {
+if (sourceParameter != null) {
+if (!sourceParameter.getSpecification().isSignature()) {
+return valueName(targetParameter);
+} else if (sourceParameter.getTypeSystemType() != null && targetParameter.getTypeSystemType() != null) {
+if (sourceParameter.getTypeSystemType().needsCastTo(getContext(), targetParameter.getTypeSystemType())) {
+return castValueName(targetParameter);
+}
+}
+return valueName(targetParameter);
+} else {
+return valueName(targetParameter);
+}
+}
+private CodeTree createTemplateMethodCall(CodeTreeBuilder parent, CodeTree target, TemplateMethod sourceMethod, TemplateMethod targetMethod, String unexpectedValueName,
+String... customSignatureValueNames) {
+CodeTreeBuilder builder = parent.create();
+boolean castedValues = sourceMethod != targetMethod;
+builder.startGroup();
+ExecutableElement method = targetMethod.getMethod();
+if (method == null) {
+throw new UnsupportedOperationException();
+}
+TypeElement targetClass = Utils.findNearestEnclosingType(method.getEnclosingElement());
+NodeData node = (NodeData) targetMethod.getTemplate();
+if (target == null) {
+boolean accessible = targetMethod.canBeAccessedByInstanceOf(getContext(), node.getNodeType());
+if (accessible) {
+if (builder.findMethod().getModifiers().contains(STATIC)) {
+if (method.getModifiers().contains(STATIC)) {
+builder.type(targetClass.asType());
+} else {
+builder.string(THIS_NODE_LOCAL_VAR_NAME);
+}
+} else {
+if (targetMethod instanceof ExecutableTypeData) {
+builder.string("this");
+} else {
+builder.string("super");
+}
+}
+} else {
+if (method.getModifiers().contains(STATIC)) {
+builder.type(targetClass.asType());
+} else {
+ActualParameter parameter = null;
+for (ActualParameter searchParameter : targetMethod.getParameters()) {
+if (searchParameter.getSpecification().isSignature()) {
+parameter = searchParameter;
+break;
+}
+}
+ActualParameter sourceParameter = sourceMethod.findParameter(parameter.getLocalName());
+assert parameter != null;
+if (castedValues && sourceParameter != null) {
+builder.string(valueName(sourceParameter, parameter));
+} else {
+builder.string(valueName(parameter));
+}
+}
+}
+builder.string(".");
+} else {
+builder.tree(target);
+}
+builder.startCall(method.getSimpleName().toString());
+int signatureIndex = 0;
+for (ActualParameter targetParameter : targetMethod.getParameters()) {
+ActualParameter valueParameter = null;
+if (sourceMethod != null) {
+valueParameter = sourceMethod.findParameter(targetParameter.getLocalName());
+}
+if (valueParameter == null) {
+valueParameter = targetParameter;
+}
+TypeData targetType = targetParameter.getTypeSystemType();
+if (targetParameter.isImplicit() || valueParameter.isImplicit()) {
+continue;
+}
+TypeData valueType = null;
+if (valueParameter != null) {
+valueType = valueParameter.getTypeSystemType();
+}
+if (signatureIndex < customSignatureValueNames.length && targetParameter.getSpecification().isSignature()) {
+builder.string(customSignatureValueNames[signatureIndex]);
+signatureIndex++;
+} else if (targetParameter.getSpecification().isLocal()) {
+builder.startGroup();
+if (builder.findMethod().getModifiers().contains(Modifier.STATIC)) {
+builder.string(THIS_NODE_LOCAL_VAR_NAME).string(".");
+} else {
+builder.string("this.");
+}
+builder.string(targetParameter.getSpecification().getName());
+builder.end();
+} else if (unexpectedValueName != null && targetParameter.getLocalName().equals(unexpectedValueName)) {
+builder.string("ex.getResult()");
+} else if (targetType == null || targetType.isGeneric() || (valueType != null && valueType.equalsType(targetType))) {
+builder.startGroup();
+if (valueType != null && sourceMethod.getMethodName().equals(targetMethod.getMethodName()) && !valueType.isGeneric() && targetType.isGeneric()) {
+builder.string("(");
+builder.type(targetType.getPrimitiveType());
+builder.string(") ");
+}
+builder.string(valueName(targetParameter));
+builder.end();
+} else {
+builder.string(castValueName(targetParameter));
+}
+}
+builder.end().end();
+return builder.getRoot();
+}
+private static String baseClassName(NodeData node) {
+String nodeid = node.getNodeId();
+if (nodeid.endsWith("Node") && !nodeid.equals("Node")) {
+nodeid = nodeid.substring(0, nodeid.length() - 4);
+}
+String name = Utils.firstLetterUpperCase(nodeid);
+name += "BaseNode";
+return name;
+}
+private static CodeTree createCallTypeSystemMethod(ProcessorContext context, CodeTreeBuilder parent, NodeData node, String methodName, CodeTree value) {
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+startCallTypeSystemMethod(context, builder, node, methodName);
+builder.tree(value);
+builder.end().end();
+return builder.getRoot();
+}
+private static void startCallTypeSystemMethod(ProcessorContext context, CodeTreeBuilder body, NodeData node, String methodName) {
+VariableElement singleton = TypeSystemCodeGenerator.findSingleton(context, node.getTypeSystem());
+assert singleton != null;
+body.startGroup();
+body.staticReference(singleton.getEnclosingElement().asType(), singleton.getSimpleName().toString());
+body.string(".").startCall(methodName);
+}
+private CodeTree createGuardAndCast(CodeTreeBuilder parent, String conditionPrefix, SpecializationData sourceSpecialization, SpecializationData targetSpecialization, boolean castValues,
+CodeTree guardedStatements, CodeTree elseStatements, boolean emitAssumptions, boolean forceElse) {
+NodeData node = targetSpecialization.getNode();
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+CodeTree implicitGuards = createImplicitGuards(parent, conditionPrefix, sourceSpecialization, targetSpecialization, emitAssumptions);
+CodeTree explicitGuards = createExplicitGuards(parent, implicitGuards == null ? conditionPrefix : null, sourceSpecialization, targetSpecialization);
+Set<String> valuesNeedsCast;
+if (castValues) {
+// cast all
+valuesNeedsCast = null;
+} else {
+// find out which values needs a cast
+valuesNeedsCast = new HashSet<>();
+for (GuardData guard : targetSpecialization.getGuards()) {
+for (ActualParameter targetParameter : guard.getParameters()) {
+NodeChildData field = node.findChild(targetParameter.getSpecification().getName());
+if (field == null) {
+continue;
+}
+TypeData targetType = targetParameter.getTypeSystemType();
+ActualParameter sourceParameter = sourceSpecialization.findParameter(targetParameter.getLocalName());
+if (sourceParameter == null) {
+sourceParameter = targetParameter;
+}
+TypeData sourceType = sourceParameter.getTypeSystemType();
+if (sourceType.needsCastTo(getContext(), targetType)) {
+valuesNeedsCast.add(targetParameter.getLocalName());
+}
+}
+}
+}
+int ifCount = 0;
+if (implicitGuards != null) {
+builder.startIf();
+builder.tree(implicitGuards);
+builder.end();
+builder.startBlock();
+ifCount++;
+}
+builder.tree(createCasts(parent, valuesNeedsCast, sourceSpecialization, targetSpecialization));
+if (explicitGuards != null) {
+builder.startIf();
+builder.tree(explicitGuards);
+builder.end();
+builder.startBlock();
+ifCount++;
+}
+if (implicitGuards == null && explicitGuards == null && conditionPrefix != null && !conditionPrefix.isEmpty()) {
+builder.startIf();
+builder.string(conditionPrefix);
+builder.end().startBlock();
+ifCount++;
+}
+builder.tree(guardedStatements);
+builder.end(ifCount);
+if (elseStatements != null && (forceElse || ifCount > 0)) {
+builder.tree(elseStatements);
+}
+return builder.getRoot();
+}
+private CodeTree createExplicitGuards(CodeTreeBuilder parent, String conditionPrefix, TemplateMethod valueSpecialization, SpecializationData guardedSpecialization) {
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+String andOperator = conditionPrefix != null ? conditionPrefix + " && " : "";
+if (guardedSpecialization.getGuards().size() > 0) {
+// Explicitly specified guards
+for (GuardData guard : guardedSpecialization.getGuards()) {
+builder.string(andOperator);
+builder.tree(createTemplateMethodCall(parent, null, valueSpecialization, guard, null));
+andOperator = " && ";
+}
+}
+return builder.isEmpty() ? null : builder.getRoot();
+}
+private CodeTree createCasts(CodeTreeBuilder parent, Set<String> castWhiteList, TemplateMethod valueSpecialization, SpecializationData guardedSpecialization) {
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+// Implict guards based on method signature
+for (ActualParameter guardedParam : guardedSpecialization.getParameters()) {
+NodeChildData field = guardedSpecialization.getNode().findChild(guardedParam.getSpecification().getName());
+if (field == null) {
+continue;
+}
+ActualParameter valueParam = valueSpecialization.findParameter(guardedParam.getLocalName());
+if (valueParam == null) {
+/*
+* If used inside a function execute method. The value param may not exist. In that
+* case it assumes that the value is already converted.
+*/
+valueParam = guardedParam;
+}
+if (castWhiteList != null && !castWhiteList.contains(guardedParam.getLocalName())) {
+continue;
+}
+CodeTree cast = createCast(parent, field, valueParam, guardedParam);
+if (cast == null) {
+continue;
+}
+builder.tree(cast);
+}
+return builder.getRoot();
+}
+private CodeTree createImplicitGuards(CodeTreeBuilder parent, String conditionPrefix, SpecializationData valueSpecialization, SpecializationData guardedSpecialization, boolean emitAssumptions) {
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+// Implict guards based on method signature
+String andOperator = conditionPrefix != null ? conditionPrefix + " && " : "";
+if (emitAssumptions) {
+for (String assumption : guardedSpecialization.getAssumptions()) {
+builder.string(andOperator);
+builder.string("this");
+builder.string(".").string(assumption).string(".isValid()");
+andOperator = " && ";
+}
+}
+for (ActualParameter guardedParam : guardedSpecialization.getParameters()) {
+NodeChildData field = guardedSpecialization.getNode().findChild(guardedParam.getSpecification().getName());
+if (field == null) {
+continue;
+}
+ActualParameter valueParam = valueSpecialization.findParameter(guardedParam.getLocalName());
+if (valueParam == null) {
+/*
+* If used inside a function execute method. The value param may not exist. In that
+* case it assumes that the value is already converted.
+*/
+valueParam = guardedParam;
+}
+CodeTree implicitGuard = createImplicitGuard(builder, field, valueParam, guardedParam);
+if (implicitGuard == null) {
+continue;
+}
+builder.string(andOperator);
+builder.tree(implicitGuard);
+andOperator = " && ";
+}
+return builder.isEmpty() ? null : builder.getRoot();
+}
+private CodeTree createImplicitGuard(CodeTreeBuilder parent, NodeChildData field, ActualParameter source, ActualParameter target) {
+NodeData node = field.getNodeData();
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+TypeData targetType = target.getTypeSystemType();
+TypeData sourceType = source.getTypeSystemType();
+if (!sourceType.needsCastTo(getContext(), targetType)) {
+return null;
+}
+builder.startGroup();
+if (field.isShortCircuit()) {
+ActualParameter shortCircuit = target.getPreviousParameter();
+assert shortCircuit != null;
+builder.string("(");
+builder.string("!").string(valueName(shortCircuit));
+builder.string(" || ");
+}
+startCallTypeSystemMethod(getContext(), builder, node, TypeSystemCodeGenerator.isTypeMethodName(target.getTypeSystemType()));
+builder.string(valueName(source));
+builder.end().end(); // call
+if (field.isShortCircuit()) {
+builder.string(")");
+}
+builder.end(); // group
+return builder.getRoot();
+}
+private CodeTree createCast(CodeTreeBuilder parent, NodeChildData field, ActualParameter source, ActualParameter target) {
+NodeData node = field.getNodeData();
+TypeData sourceType = source.getTypeSystemType();
+TypeData targetType = target.getTypeSystemType();
+if (!sourceType.needsCastTo(getContext(), targetType)) {
+return null;
+}
+CodeTree condition = null;
+if (field.isShortCircuit()) {
+ActualParameter shortCircuit = target.getPreviousParameter();
+assert shortCircuit != null;
+condition = CodeTreeBuilder.singleString(valueName(shortCircuit));
+}
+CodeTree value = createCallTypeSystemMethod(context, parent, node, TypeSystemCodeGenerator.asTypeMethodName(targetType), CodeTreeBuilder.singleString(valueName(target)));
+return createLazyAssignment(parent, castValueName(target), target.getType(), condition, value);
+}
+/**
+* <pre>
+* variant1 $condition != null
+*
+* $type $name = defaultValue($type);
+* if ($condition) {
+*     $name = $value;
+* }
+*
+* variant2 $condition != null
+* $type $name = $value;
+* </pre>
+*
+* .
+*/
+private static CodeTree createLazyAssignment(CodeTreeBuilder parent, String name, TypeMirror type, CodeTree condition, CodeTree value) {
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+if (condition == null) {
+builder.declaration(type, name, value);
+} else {
+builder.declaration(type, name, new CodeTreeBuilder(parent).defaultValue(type).getRoot());
+builder.startIf().tree(condition).end();
+builder.startBlock();
+builder.startStatement();
+builder.string(name);
+builder.string(" = ");
+builder.tree(value);
+builder.end(); // statement
+builder.end(); // block
+}
+return builder.getRoot();
+}
+protected void emitEncounteredSynthetic(CodeTreeBuilder builder, TemplateMethod current) {
+builder.startThrow().startNew(getContext().getType(UnsupportedOperationException.class));
+builder.startCall("createInfo0");
+builder.doubleQuote("Unsupported values");
+addInternalValueParameterNames(builder, current, current, null, false, true);
+builder.end().end().end();
+}
+private static List<ExecutableElement> findUserConstructors(TypeMirror nodeType) {
+List<ExecutableElement> constructors = new ArrayList<>();
+for (ExecutableElement constructor : ElementFilter.constructorsIn(Utils.fromTypeMirror(nodeType).getEnclosedElements())) {
+if (constructor.getModifiers().contains(PRIVATE)) {
+continue;
+}
+if (isCopyConstructor(constructor)) {
+continue;
+}
+constructors.add(constructor);
+}
+if (constructors.isEmpty()) {
+constructors.add(new CodeExecutableElement(null, Utils.getSimpleName(nodeType)));
+}
+return constructors;
+}
+private static ExecutableElement findCopyConstructor(TypeMirror type) {
+for (ExecutableElement constructor : ElementFilter.constructorsIn(Utils.fromTypeMirror(type).getEnclosedElements())) {
+if (constructor.getModifiers().contains(PRIVATE)) {
+continue;
+}
+if (isCopyConstructor(constructor)) {
+return constructor;
+}
+}
+return null;
+}
+private static boolean isCopyConstructor(ExecutableElement element) {
+if (element.getParameters().size() != 1) {
+return false;
+}
+VariableElement var = element.getParameters().get(0);
+TypeElement type = Utils.findNearestEnclosingType(var);
+if (!Utils.typeEquals(var.asType(), type.asType())) {
+return false;
+}
+return true;
+}
+@Override
+protected void createChildren(NodeData node) {
+Map<NodeData, List<TypeElement>> childTypes = new LinkedHashMap<>();
+if (node.getDeclaredNodes() != null && !node.getDeclaredNodes().isEmpty()) {
+for (NodeData nodeChild : node.getDeclaredNodes()) {
+NodeCodeGenerator generator = new NodeCodeGenerator(getContext());
+childTypes.put(nodeChild, generator.process(null, nodeChild).getEnclosedElements());
+}
+}
+if (node.needsFactory() || node.getNodeDeclaringChildren().size() > 0) {
+add(new NodeFactoryFactory(context, childTypes), node);
+}
+}
+private class NodeFactoryFactory extends ClassElementFactory<NodeData> {
+private final Map<NodeData, List<TypeElement>> childTypes;
+private CodeTypeElement generatedNode;
+public NodeFactoryFactory(ProcessorContext context, Map<NodeData, List<TypeElement>> childElements) {
+super(context);
+this.childTypes = childElements;
+}
+@Override
+protected CodeTypeElement create(NodeData node) {
+Modifier visibility = Utils.getVisibility(node.getTemplateType().getModifiers());
+CodeTypeElement clazz = createClass(node, modifiers(), factoryClassName(node), null, false);
+if (visibility != null) {
+clazz.getModifiers().add(visibility);
+}
+clazz.getModifiers().add(Modifier.FINAL);
+clazz.add(createConstructorUsingFields(modifiers(PRIVATE), clazz));
+return clazz;
+}
+@Override
+protected void createChildren(NodeData node) {
+CodeTypeElement clazz = getElement();
+Modifier createVisibility = Utils.getVisibility(clazz.getModifiers());
+if (node.needsFactory()) {
+NodeBaseFactory factory = new NodeBaseFactory(context);
+add(factory, node.getGenericSpecialization() == null ? node.getSpecializations().get(0) : node.getGenericSpecialization());
+generatedNode = factory.getElement();
+if (node.needsRewrites(context)) {
+clazz.add(createCreateGenericMethod(node, createVisibility));
+}
+createFactoryMethods(node, clazz, createVisibility);
+PolymorphicNodeFactory generic = null;
+for (SpecializationData specialization : node.getPolymorphicSpecializations()) {
+PolymorphicNodeFactory polymorphicFactory = new PolymorphicNodeFactory(context, generic == null ? generatedNode : generic.getElement(), generic == null);
+add(polymorphicFactory, specialization);
+if (generic == null) {
+generic = polymorphicFactory;
+}
+}
+for (SpecializationData specialization : node.getSpecializations()) {
+if (!specialization.isReachable()) {
+continue;
+}
+add(new SpecializedNodeFactory(context, generatedNode), specialization);
+}
+TypeMirror nodeFactory = Utils.getDeclaredType(Utils.fromTypeMirror(getContext().getType(NodeFactory.class)), node.getNodeType());
+clazz.getImplements().add(nodeFactory);
+clazz.add(createCreateNodeMethod(node));
+clazz.add(createCreateNodeGenericMethod(node));
+clazz.add(createGetNodeClassMethod(node));
+clazz.add(createGetNodeSignaturesMethod());
+clazz.add(createGetChildrenSignatureMethod(node));
+clazz.add(createGetInstanceMethod(node, createVisibility));
+clazz.add(createInstanceConstant(node, clazz.asType()));
+}
+for (NodeData childNode : childTypes.keySet()) {
+if (childNode.getTemplateType().getModifiers().contains(Modifier.PRIVATE)) {
+continue;
+}
+for (TypeElement type : childTypes.get(childNode)) {
+Set<Modifier> typeModifiers = ((CodeTypeElement) type).getModifiers();
+Modifier visibility = Utils.getVisibility(type.getModifiers());
+typeModifiers.clear();
+if (visibility != null) {
+typeModifiers.add(visibility);
+}
+typeModifiers.add(Modifier.STATIC);
+typeModifiers.add(Modifier.FINAL);
+clazz.add(type);
+}
+}
+List<NodeData> children = node.getNodeDeclaringChildren();
+if (node.getParent() == null && children.size() > 0) {
+clazz.add(createGetFactories(node));
+}
+}
+private CodeExecutableElement createGetNodeClassMethod(NodeData node) {
+TypeMirror returnType = Utils.getDeclaredType(Utils.fromTypeMirror(getContext().getType(Class.class)), node.getNodeType());
+CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC), returnType, "getNodeClass");
+CodeTreeBuilder builder = method.createBuilder();
+builder.startReturn().typeLiteral(node.getNodeType()).end();
+return method;
+}
+private CodeExecutableElement createGetNodeSignaturesMethod() {
+TypeElement listType = Utils.fromTypeMirror(getContext().getType(List.class));
+TypeMirror classType = getContext().getType(Class.class);
+TypeMirror returnType = Utils.getDeclaredType(listType, Utils.getDeclaredType(listType, classType));
+CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC), returnType, "getNodeSignatures");
+CodeTreeBuilder builder = method.createBuilder();
+builder.startReturn();
+builder.startStaticCall(getContext().getType(Arrays.class), "asList");
+List<ExecutableElement> constructors = findUserConstructors(generatedNode.asType());
+for (ExecutableElement constructor : constructors) {
+builder.tree(createAsList(builder, Utils.asTypeMirrors(constructor.getParameters()), classType));
+}
+builder.end();
+builder.end();
+return method;
+}
+private CodeExecutableElement createGetChildrenSignatureMethod(NodeData node) {
+Types types = getContext().getEnvironment().getTypeUtils();
+TypeElement listType = Utils.fromTypeMirror(getContext().getType(List.class));
+TypeMirror classType = getContext().getType(Class.class);
+TypeMirror nodeType = getContext().getTruffleTypes().getNode();
+TypeMirror wildcardNodeType = types.getWildcardType(nodeType, null);
+classType = Utils.getDeclaredType(Utils.fromTypeMirror(classType), wildcardNodeType);
+TypeMirror returnType = Utils.getDeclaredType(listType, classType);
+CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC), returnType, "getExecutionSignature");
+CodeTreeBuilder builder = method.createBuilder();
+List<TypeMirror> signatureTypes = new ArrayList<>();
+assert !node.getSpecializations().isEmpty();
+SpecializationData data = node.getSpecializations().get(0);
+for (ActualParameter parameter : data.getParameters()) {
+ParameterSpec spec = parameter.getSpecification();
+NodeChildData field = node.findChild(spec.getName());
+if (field == null) {
+continue;
+}
+TypeMirror type;
+if (field.getCardinality() == Cardinality.MANY && field.getNodeType().getKind() == TypeKind.ARRAY) {
+type = ((ArrayType) field.getNodeType()).getComponentType();
+} else {
+type = field.getNodeType();
+}
+signatureTypes.add(type);
+}
+builder.startReturn().tree(createAsList(builder, signatureTypes, classType)).end();
+return method;
+}
+private CodeTree createAsList(CodeTreeBuilder parent, List<TypeMirror> types, TypeMirror elementClass) {
+CodeTreeBuilder builder = parent.create();
+builder.startGroup();
+builder.type(getContext().getType(Arrays.class));
+builder.string(".<").type(elementClass).string(">");
+builder.startCall("asList");
+for (TypeMirror typeMirror : types) {
+builder.typeLiteral(typeMirror);
+}
+builder.end().end();
+return builder.getRoot();
+}
+private CodeExecutableElement createCreateNodeMethod(NodeData node) {
+CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC), node.getNodeType(), "createNode");
+CodeVariableElement arguments = new CodeVariableElement(getContext().getType(Object.class), "arguments");
+method.setVarArgs(true);
+method.addParameter(arguments);
+CodeTreeBuilder builder = method.createBuilder();
+List<ExecutableElement> signatures = findUserConstructors(generatedNode.asType());
+boolean ifStarted = false;
+for (ExecutableElement element : signatures) {
+ifStarted = builder.startIf(ifStarted);
+builder.string("arguments.length == " + element.getParameters().size());
+int index = 0;
+for (VariableElement param : element.getParameters()) {
+builder.string(" && ");
+if (!param.asType().getKind().isPrimitive()) {
+builder.string("(arguments[" + index + "] == null || ");
+}
+builder.string("arguments[" + index + "] instanceof ");
+builder.type(Utils.boxType(getContext(), param.asType()));
+if (!param.asType().getKind().isPrimitive()) {
+builder.string(")");
+}
+index++;
+}
+builder.end();
+builder.startBlock();
+builder.startReturn().startCall("create");
+index = 0;
+for (VariableElement param : element.getParameters()) {
+builder.startGroup();
+builder.string("(").type(param.asType()).string(") ");
+builder.string("arguments[").string(String.valueOf(index)).string("]");
+builder.end();
+index++;
+}
+builder.end().end();
+builder.end(); // block
+}
+builder.startElseBlock();
+builder.startThrow().startNew(getContext().getType(IllegalArgumentException.class));
+builder.doubleQuote("Invalid create signature.");
+builder.end().end();
+builder.end(); // else block
+return method;
+}
+private CodeExecutableElement createCreateNodeGenericMethod(NodeData node) {
+CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC), node.getNodeType(), "createNodeGeneric");
+CodeVariableElement nodeParam = new CodeVariableElement(node.getNodeType(), THIS_NODE_LOCAL_VAR_NAME);
+method.addParameter(nodeParam);
+CodeTreeBuilder builder = method.createBuilder();
+if (!node.needsRewrites(getContext())) {
+builder.startThrow().startNew(getContext().getType(UnsupportedOperationException.class)).doubleQuote("No specialized version.").end().end();
+} else {
+builder.startReturn().startCall("createGeneric");
+builder.string(THIS_NODE_LOCAL_VAR_NAME);
+builder.end().end();
+}
+return method;
+}
+private ExecutableElement createGetInstanceMethod(NodeData node, Modifier visibility) {
+TypeElement nodeFactoryType = Utils.fromTypeMirror(getContext().getType(NodeFactory.class));
+TypeMirror returnType = Utils.getDeclaredType(nodeFactoryType, node.getNodeType());
+CodeExecutableElement method = new CodeExecutableElement(modifiers(), returnType, "getInstance");
+if (visibility != null) {
+method.getModifiers().add(visibility);
+}
+method.getModifiers().add(Modifier.STATIC);
+String varName = instanceVarName(node);
+CodeTreeBuilder builder = method.createBuilder();
+builder.startIf();
+builder.string(varName).string(" == null");
+builder.end().startBlock();
+builder.startStatement();
+builder.string(varName);
+builder.string(" = ");
+builder.startNew(factoryClassName(node)).end();
+builder.end();
+builder.end();
+builder.startReturn().string(varName).end();
+return method;
+}
+private String instanceVarName(NodeData node) {
+if (node.getParent() != null) {
+return Utils.firstLetterLowerCase(factoryClassName(node)) + "Instance";
+} else {
+return "instance";
+}
+}
+private CodeVariableElement createInstanceConstant(NodeData node, TypeMirror factoryType) {
+String varName = instanceVarName(node);
+CodeVariableElement var = new CodeVariableElement(modifiers(), factoryType, varName);
+var.getModifiers().add(Modifier.PRIVATE);
+var.getModifiers().add(Modifier.STATIC);
+return var;
+}
+private ExecutableElement createGetFactories(NodeData node) {
+List<NodeData> children = node.getNodeDeclaringChildren();
+if (node.needsFactory()) {
+children.add(node);
+}
+List<TypeMirror> nodeTypesList = new ArrayList<>();
+TypeMirror prev = null;
+boolean allSame = true;
+for (NodeData child : children) {
+nodeTypesList.add(child.getNodeType());
+if (prev != null && !Utils.typeEquals(child.getNodeType(), prev)) {
+allSame = false;
+}
+prev = child.getNodeType();
+}
+TypeMirror commonNodeSuperType = Utils.getCommonSuperType(getContext(), nodeTypesList.toArray(new TypeMirror[nodeTypesList.size()]));
+Types types = getContext().getEnvironment().getTypeUtils();
+TypeMirror factoryType = getContext().getType(NodeFactory.class);
+TypeMirror baseType;
+if (allSame) {
+baseType = Utils.getDeclaredType(Utils.fromTypeMirror(factoryType), commonNodeSuperType);
+} else {
+baseType = Utils.getDeclaredType(Utils.fromTypeMirror(factoryType), types.getWildcardType(commonNodeSuperType, null));
+}
+TypeMirror listType = Utils.getDeclaredType(Utils.fromTypeMirror(getContext().getType(List.class)), baseType);
+CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC, STATIC), listType, "getFactories");
+CodeTreeBuilder builder = method.createBuilder();
+builder.startReturn();
+builder.startStaticCall(getContext().getType(Arrays.class), "asList");
+for (NodeData child : children) {
+builder.startGroup();
+NodeData childNode = child;
+List<NodeData> factories = new ArrayList<>();
+while (childNode.getParent() != null) {
+factories.add(childNode);
+childNode = childNode.getParent();
+}
+Collections.reverse(factories);
+for (NodeData nodeData : factories) {
+builder.string(factoryClassName(nodeData)).string(".");
+}
+builder.string("getInstance()");
+builder.end();
+}
+builder.end();
+builder.end();
+return method;
+}
+private void createFactoryMethods(NodeData node, CodeTypeElement clazz, Modifier createVisibility) {
+List<ExecutableElement> constructors = findUserConstructors(generatedNode.asType());
+for (ExecutableElement constructor : constructors) {
+clazz.add(createCreateMethod(node, createVisibility, constructor));
+}
+}
+private CodeExecutableElement createCreateMethod(NodeData node, Modifier visibility, ExecutableElement constructor) {
+CodeExecutableElement method = CodeExecutableElement.clone(getContext().getEnvironment(), constructor);
+method.setSimpleName(CodeNames.of("create"));
+method.getModifiers().clear();
+if (visibility != null) {
+method.getModifiers().add(visibility);
+}
+method.getModifiers().add(Modifier.STATIC);
+method.setReturnType(node.getNodeType());
+CodeTreeBuilder body = method.createBuilder();
+body.startReturn();
+if (node.getSpecializations().isEmpty()) {
+body.nullLiteral();
+} else {
+body.startNew(nodeSpecializationClassName(node.getSpecializations().get(0)));
+for (VariableElement var : method.getParameters()) {
+body.string(var.getSimpleName().toString());
+}
+body.end();
+}
+body.end();
+return method;
+}
+private CodeExecutableElement createCreateGenericMethod(NodeData node, Modifier visibility) {
+CodeExecutableElement method = new CodeExecutableElement(modifiers(), node.getNodeType(), "createGeneric");
+if (visibility != null) {
+method.getModifiers().add(visibility);
+}
+method.getModifiers().add(Modifier.STATIC);
+method.addParameter(new CodeVariableElement(node.getNodeType(), THIS_NODE_LOCAL_VAR_NAME));
+CodeTreeBuilder body = method.createBuilder();
+SpecializationData found = null;
+List<SpecializationData> specializations = node.getSpecializations();
+for (int i = 0; i < specializations.size(); i++) {
+if (specializations.get(i).isReachable()) {
+found = specializations.get(i);
+}
+}
+if (found == null) {
+body.startThrow().startNew(getContext().getType(UnsupportedOperationException.class)).end().end();
+} else {
+body.startReturn().startNew(nodeSpecializationClassName(found)).startGroup().cast(baseClassName(node)).string(THIS_NODE_LOCAL_VAR_NAME).end().end().end();
+}
+return method;
+}
+}
+private class NodeBaseFactory extends ClassElementFactory<SpecializationData> {
+public NodeBaseFactory(ProcessorContext context) {
+super(context);
+}
+@Override
+protected CodeTypeElement create(SpecializationData specialization) {
+NodeData node = specialization.getNode();
+CodeTypeElement clazz = createClass(node, modifiers(PRIVATE, ABSTRACT, STATIC), baseClassName(node), node.getNodeType(), false);
+for (NodeChildData child : node.getChildren()) {
+clazz.add(createChildField(child));
+if (child.getAccessElement() != null && child.getAccessElement().getModifiers().contains(Modifier.ABSTRACT)) {
+ExecutableElement getter = (ExecutableElement) child.getAccessElement();
+CodeExecutableElement method = CodeExecutableElement.clone(getContext().getEnvironment(), getter);
+method.getModifiers().remove(Modifier.ABSTRACT);
+method.createBuilder().startReturn().string("this.").string(child.getName()).end();
+clazz.add(method);
+}
+}
+for (String assumption : node.getAssumptions()) {
+clazz.add(createAssumptionField(assumption));
+}
+createConstructors(node, clazz);
+return clazz;
+}
+protected String typeGetterName(ActualParameter parameter) {
+return "get" + Utils.firstLetterUpperCase(parameter.getLocalName()) + "Type";
+}
+@Override
+protected void createChildren(SpecializationData specialization) {
+NodeData node = specialization.getNode();
+CodeTypeElement clazz = getElement();
+if (node.needsRewrites(context)) {
+if (node.getPolymorphicDepth() > 1) {
+CodeVariableElement var = new CodeVariableElement(modifiers(PROTECTED), clazz.asType(), "next0");
+var.getAnnotationMirrors().add(new CodeAnnotationMirror(getContext().getTruffleTypes().getChildAnnotation()));
+clazz.add(var);
+CodeExecutableElement setter = new CodeExecutableElement(modifiers(PROTECTED), context.getType(void.class), "setNext0");
+setter.getParameters().add(new CodeVariableElement(clazz.asType(), "next0"));
+CodeTreeBuilder builder = setter.createBuilder();
+builder.statement("this.next0 = adoptChild(next0)");
+clazz.add(setter);
+createTypeGetters(clazz, node.getGenericSpecialization());
+clazz.add(createCreateSpecialization(node));
+CodeExecutableElement genericCachedExecute = null;
+for (SpecializationData polymorph : node.getPolymorphicSpecializations()) {
+CodeExecutableElement cachedExecute = createCachedExecute(node, polymorph, genericCachedExecute);
+clazz.add(cachedExecute);
+if (genericCachedExecute == null) {
+genericCachedExecute = cachedExecute;
+}
+}
+}
+clazz.add(createGenericExecuteAndSpecialize(node));
+clazz.add(createInfoMessage(node));
+}
+if (node.getGenericSpecialization() != null && node.getGenericSpecialization().isReachable()) {
+clazz.add(createGenericExecute(node));
+}
+}
+private Element createInfoMessage(NodeData node) {
+CodeExecutableElement method = new CodeExecutableElement(modifiers(PROTECTED, STATIC), getContext().getType(String.class), "createInfo0");
+method.addParameter(new CodeVariableElement(getContext().getType(String.class), "message"));
+addInternalValueParameters(method, node.getGenericSpecialization(), false, false);
+CodeTreeBuilder builder = method.createBuilder();
+builder.startStatement().string("StringBuilder builder = new StringBuilder(message)").end();
+builder.startStatement().startCall("builder", "append").doubleQuote(" (").end().end();
+String sep = null;
+for (ActualParameter parameter : node.getGenericSpecialization().getParameters()) {
+if (!parameter.getSpecification().isSignature()) {
+continue;
+}
+builder.startStatement();
+builder.string("builder");
+if (sep != null) {
+builder.startCall(".append").doubleQuote(sep).end();
+}
+builder.startCall(".append").doubleQuote(parameter.getLocalName()).end();
+builder.startCall(".append").doubleQuote(" = ").end();
+builder.startCall(".append").string(parameter.getLocalName()).end();
+builder.end();
+if (!Utils.isPrimitive(parameter.getType())) {
+builder.startIf().string(parameter.getLocalName() + " != null").end();
+builder.startBlock();
+}
+builder.startStatement();
+if (Utils.isPrimitive(parameter.getType())) {
+builder.startCall("builder.append").doubleQuote(" (" + Utils.getSimpleName(parameter.getType()) + ")").end();
+} else {
+builder.startCall("builder.append").doubleQuote(" (").end();
+builder.startCall(".append").string(parameter.getLocalName() + ".getClass().getSimpleName()").end();
+builder.startCall(".append").doubleQuote(")").end();
+}
+builder.end();
+if (!Utils.isPrimitive(parameter.getType())) {
+builder.end();
+}
+sep = ", ";
+}
+builder.startStatement().startCall("builder", "append").doubleQuote(")").end().end();
+builder.startReturn().string("builder.toString()").end();
+return method;
+}
+protected void createTypeGetters(CodeTypeElement clazz, SpecializationData specialization) {
+for (ActualParameter parameter : specialization.getReturnTypeAndParameters()) {
+if (!parameter.getSpecification().isSignature()) {
+continue;
+}
+CodeExecutableElement typeGetter = new CodeExecutableElement(modifiers(PROTECTED), context.getType(Class.class), typeGetterName(parameter));
+CodeTreeBuilder builder = typeGetter.createBuilder();
+builder.startReturn().typeLiteral(parameter.getType()).end();
+clazz.add(typeGetter);
+}
+}
+private CodeExecutableElement createCachedExecute(NodeData node, SpecializationData polymorph, CodeExecutableElement genericPolymorphMethod) {
+int index = node.getPolymorphicSpecializations().indexOf(polymorph);
+assert index != -1;
+boolean generic = index == 0;
+String name = "executeCached" + index;
+CodeExecutableElement cachedExecute = new CodeExecutableElement(modifiers(PROTECTED), polymorph.getReturnType().getType(), name);
+addInternalValueParameters(cachedExecute, polymorph, true, true);
+if (generic) {
+cachedExecute.getModifiers().add(ABSTRACT);
+} else {
+SpecializationData genericPolymorph = node.getPolymorphicSpecializations().get(0);
+CodeTreeBuilder builder = cachedExecute.createBuilder();
+ExecutableTypeData genericExecutable = new ExecutableTypeData(genericPolymorph, genericPolymorphMethod, node.getTypeSystem(), genericPolymorph.getReturnType().getTypeSystemType());
+ExecutableTypeData specificExecutable = new ExecutableTypeData(polymorph, cachedExecute, node.getTypeSystem(), polymorph.getReturnType().getTypeSystemType());
+builder.tree(createCastingExecute(builder, polymorph, specificExecutable, genericExecutable));
+}
+return cachedExecute;
+}
+private CodeExecutableElement createCreateSpecialization(NodeData node) {
+CodeExecutableElement method = new CodeExecutableElement(modifiers(PRIVATE), getElement().asType(), "createSpezialization0");
+method.getParameters().add(new CodeVariableElement(context.getType(Class.class), "clazz"));
+CodeTreeBuilder builder = method.createBuilder();
+builder.startStatement().type(getElement().asType()).string(" node").end();
+boolean elseIf = false;
+for (SpecializationData specialization : node.getSpecializations()) {
+if (specialization.isGeneric() || specialization.isUninitialized()) {
+continue;
+}
+elseIf = builder.startIf(elseIf);
+builder.startGroup().string("clazz == ").string(nodeSpecializationClassName(specialization)).string(".class").end();
+builder.end();
+builder.startBlock();
+builder.startStatement();
+builder.string("node = ");
+builder.startNew(nodeSpecializationClassName(specialization)).string("this").end();
+builder.end();
+builder.end();
+}
+builder.startElseBlock();
+builder.startThrow().startNew(context.getType(AssertionError.class)).end().end();
+builder.end();
+builder.startStatement().startCall("node", "setNext0");
+builder.startNew(nodeSpecializationClassName(node.getUninitializedSpecialization())).string("this").end();
+builder.end().end();
+builder.startReturn().string("node").end();
+return method;
+}
+private void createConstructors(NodeData node, CodeTypeElement clazz) {
+List<ExecutableElement> constructors = findUserConstructors(node.getNodeType());
+if (constructors.isEmpty()) {
+clazz.add(createUserConstructor(clazz, null));
+} else {
+for (ExecutableElement constructor : constructors) {
+clazz.add(createUserConstructor(clazz, constructor));
+}
+}
+if (node.needsRewrites(getContext())) {
+clazz.add(createCopyConstructor(clazz, findCopyConstructor(node.getNodeType())));
+}
+}
+private CodeExecutableElement createUserConstructor(CodeTypeElement type, ExecutableElement superConstructor) {
+CodeExecutableElement method = new CodeExecutableElement(null, type.getSimpleName().toString());
+CodeTreeBuilder builder = method.createBuilder();
+NodeData node = getModel().getNode();
+if (superConstructor != null) {
+for (VariableElement param : superConstructor.getParameters()) {
+method.getParameters().add(CodeVariableElement.clone(param));
+}
+}
+for (VariableElement var : type.getFields()) {
+NodeChildData child = node.findChild(var.getSimpleName().toString());
+if (child != null) {
+method.getParameters().add(new CodeVariableElement(child.getOriginalType(), child.getName()));
+} else {
+method.getParameters().add(new CodeVariableElement(var.asType(), var.getSimpleName().toString()));
+}
+}
+if (superConstructor != null) {
+builder.startStatement().startSuperCall();
+for (VariableElement param : superConstructor.getParameters()) {
+builder.string(param.getSimpleName().toString());
+}
+builder.end().end();
+}
+for (VariableElement var : type.getFields()) {
+builder.startStatement();
+String fieldName = var.getSimpleName().toString();
+CodeTree fieldInit = CodeTreeBuilder.singleString(var.getSimpleName().toString());
+builder.string("this.").string(var.getSimpleName().toString());
+NodeChildData child = node.findChild(fieldName);
+if (child != null) {
+CreateCastData createCast = node.findCast(child.getName());
+if (createCast != null) {
+fieldInit = createTemplateMethodCall(builder, null, node.getGenericSpecialization(), createCast, null, child.getName());
+}
+}
+if (Utils.isAssignable(getContext(), var.asType(), getContext().getTruffleTypes().getNode())) {
+builder.string(" = adoptChild(").tree(fieldInit).string(")");
+} else if (Utils.isAssignable(getContext(), var.asType(), getContext().getTruffleTypes().getNodeArray())) {
+builder.string(" = adoptChildren(").tree(fieldInit).string(")");
+} else {
+builder.string(" = ").tree(fieldInit);
+}
+builder.end();
+}
+return method;
+}
+private CodeExecutableElement createCopyConstructor(CodeTypeElement type, ExecutableElement superConstructor) {
+CodeExecutableElement method = new CodeExecutableElement(null, type.getSimpleName().toString());
+CodeTreeBuilder builder = method.createBuilder();
+if (!(superConstructor == null && type.getFields().isEmpty())) {
+method.getParameters().add(new CodeVariableElement(type.asType(), "copy"));
+}
+if (superConstructor != null) {
+builder.startStatement().startSuperCall().string("copy").end().end();
+}
+for (VariableElement var : type.getFields()) {
+builder.startStatement();
+String varName = var.getSimpleName().toString();
+builder.string("this.").string(varName);
+if (Utils.isAssignable(getContext(), var.asType(), getContext().getTruffleTypes().getNode())) {
+builder.string(" = adoptChild(copy.").string(varName).string(")");
+} else if (Utils.isAssignable(getContext(), var.asType(), getContext().getTruffleTypes().getNodeArray())) {
+builder.string(" = adoptChildren(copy.").string(varName).string(")");
+} else {
+builder.string(" = copy.").string(varName);
+}
+builder.end();
+}
+if (getModel().getNode().getPolymorphicDepth() > 1) {
+builder.statement("this.next0 = adoptChild(copy.next0)");
+}
+return method;
+}
+private CodeVariableElement createAssumptionField(String assumption) {
+CodeVariableElement var = new CodeVariableElement(getContext().getTruffleTypes().getAssumption(), assumption);
+var.getModifiers().add(Modifier.FINAL);
+return var;
+}
+private CodeVariableElement createChildField(NodeChildData child) {
+CodeVariableElement var = new CodeVariableElement(child.getNodeType(), child.getName());
+var.getModifiers().add(Modifier.PROTECTED);
+DeclaredType annotationType;
+if (child.getCardinality() == Cardinality.MANY) {
+annotationType = getContext().getTruffleTypes().getChildrenAnnotation();
+} else {
+annotationType = getContext().getTruffleTypes().getChildAnnotation();
+}
+var.getAnnotationMirrors().add(new CodeAnnotationMirror(annotationType));
+return var;
+}
+private CodeExecutableElement createGenericExecuteAndSpecialize(NodeData node) {
+TypeMirror genericReturnType = node.getGenericSpecialization().getReturnType().getType();
+CodeExecutableElement method = new CodeExecutableElement(modifiers(PROTECTED), genericReturnType, EXECUTE_SPECIALIZE_NAME);
+method.addParameter(new CodeVariableElement(getContext().getType(Class.class), "minimumState"));
+addInternalValueParameters(method, node.getGenericSpecialization(), true, false);
+method.addParameter(new CodeVariableElement(getContext().getType(String.class), "reason"));
+CodeTreeBuilder builder = method.createBuilder();
+builder.startStatement();
+builder.startStaticCall(getContext().getTruffleTypes().getCompilerAsserts(), "neverPartOfCompilation").end();
+builder.end();
+emitSpecializationListeners(builder, node);
+builder.defaultDeclaration(node.getGenericSpecialization().getReturnType().getTypeSystemType().getPrimitiveType(), "result");
+builder.defaultDeclaration(getContext().getType(Class.class), "resultClass");
+builder.startStatement().string("boolean allowed = (minimumState == ").string(nodeSpecializationClassName(node.getSpecializations().get(0))).string(".class)").end();
+builder.startStatement().string("String message = ").startCall("createInfo0").string("reason");
+addInternalValueParameterNames(builder, node.getGenericSpecialization(), node.getGenericSpecialization(), null, false, true);
+builder.end().end();
+String prefix = null;
+List<SpecializationData> specializations = node.getSpecializations();
+for (SpecializationData current : specializations) {
+if (current.isUninitialized() || !current.isReachable()) {
+continue;
+}
+CodeTreeBuilder execute = new CodeTreeBuilder(builder);
+execute.tree(createGenericInvokeAndSpecialize(builder, node.getGenericSpecialization(), current));
+if (!current.isGeneric()) {
+builder.startStatement().string("allowed = allowed || (minimumState == ").string(nodeSpecializationClassName(current)).string(".class)").end();
+}
+builder.tree(createGuardAndCast(builder, prefix, current.getNode().getGenericSpecialization(), current, true, execute.getRoot(), null, true, false));
+}
+for (SpecializationData current : specializations) {
+if (current.isUninitialized() || current.isReachable()) {
+continue;
+}
+builder.string("// unreachable ").string(current.getId()).newLine();
+}
+return method;
+}
+private CodeExecutableElement createGenericExecute(NodeData node) {
+TypeMirror genericReturnType = node.getGenericSpecialization().getReturnType().getType();
+CodeExecutableElement method = new CodeExecutableElement(modifiers(PROTECTED), genericReturnType, EXECUTE_GENERIC_NAME);
+addInternalValueParameters(method, node.getGenericSpecialization(), true, false);
+CodeTreeBuilder builder = method.createBuilder();
+String prefix = null;
+List<SpecializationData> specializations = node.getSpecializations();
+for (SpecializationData current : specializations) {
+if (current.isUninitialized() || !current.isReachable()) {
+continue;
+}
+CodeTreeBuilder execute = new CodeTreeBuilder(builder);
+execute.tree(createGenericInvoke(builder, node.getGenericSpecialization(), current));
+builder.tree(createGuardAndCast(builder, prefix, current.getNode().getGenericSpecialization(), current, true, execute.getRoot(), null, true, false));
+}
+for (SpecializationData current : specializations) {
+if (current.isUninitialized() || current.isReachable()) {
+continue;
+}
+builder.string("// unreachable ").string(current.getId()).newLine();
+}
+return method;
+}
+protected CodeTree createGenericInvoke(CodeTreeBuilder parent, SpecializationData source, SpecializationData current) {
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+if (current.getMethod() == null) {
+emitEncounteredSynthetic(builder, current);
+} else {
+builder.startReturn().tree(createTemplateMethodCall(builder, null, source, current, null)).end();
+}
+return encloseThrowsWithFallThrough(current, builder.getRoot());
+}
+protected CodeTree createGenericInvokeAndSpecialize(CodeTreeBuilder parent, SpecializationData source, SpecializationData current) {
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+NodeData node = current.getNode();
+builder.startIf().string("resultClass == null").end().startBlock();
+if (current.getMethod() != null) {
+CodeTree executeCall = createTemplateMethodCall(builder, null, source, current, null);
+if (current.getReturnType().getTypeSystemType().isVoid()) {
+builder.statement(executeCall);
+} else {
+builder.startStatement().string("result = ").tree(executeCall).end();
+}
+builder.startStatement();
+builder.string("resultClass = ").string(nodeSpecializationClassName(current)).string(".class");
+builder.end();
+} else {
+emitEncounteredSynthetic(builder, current);
+}
+builder.end();
+boolean ifAllowed = current.hasRewrite(getContext());
+if (ifAllowed) {
+builder.startIf().string("allowed").end().startBlock();
+}
+if (!current.isGeneric() || node.getPolymorphicDepth() <= 1) {
+// generic rewrite
+builder.tree(createRewriteGeneric(builder, current));
+} else {
+boolean rewriteableToGeneric = node.getGenericSpecialization().getMethod() != null && node.getGenericSpecialization().isReachable();
+if (rewriteableToGeneric) {
+builder.startIf().string("resultClass == ").string(nodeSpecializationClassName(node.getGenericSpecialization())).string(".class").end();
+builder.startBlock();
+boolean maybePolymorphic = node.getPolymorphicDepth() > 1;
+if (maybePolymorphic) {
+builder.startIf().string("next0 == null").end();
+builder.startBlock();
+}
+builder.tree(createRewriteGeneric(builder, current));
+if (maybePolymorphic) {
+builder.end().startElseBlock();
+builder.statement("Node searchNode = super.getParent()");
+builder.startWhile().string("searchNode != null").end();
+builder.startBlock();
+builder.statement("searchNode = searchNode.getParent()");
+builder.startIf().instanceOf("searchNode", nodePolymorphicClassName(node, node.getPolymorphicSpecializations().get(0))).end();
+builder.startBlock().breakStatement().end();
+builder.end();
+builder.startStatement().startCall("searchNode", "replace");
+builder.startGroup().startNew(nodeSpecializationClassName(current)).startGroup().cast(baseClassName(node)).string("searchNode").end().end().end();
+builder.string("message");
+builder.end().end().end();
+}
+builder.end().startElseBlock();
+}
+// polymorphic rewrite
+builder.tree(createRewritePolymorphic(builder, node));
+if (rewriteableToGeneric) {
+builder.end();
+}
+}
+if (current.getReturnType().getTypeSystemType().isVoid()) {
+builder.returnStatement();
+} else {
+builder.startReturn().string("result").end();
+}
+if (ifAllowed) {
+builder.end();
+}
+return encloseThrowsWithFallThrough(current, builder.getRoot());
+}
+private CodeTree encloseThrowsWithFallThrough(SpecializationData current, CodeTree tree) {
+if (current.getExceptions().isEmpty()) {
+return tree;
+}
+CodeTreeBuilder builder = new CodeTreeBuilder(null);
+builder.startTryBlock();
+builder.tree(tree);
+for (SpecializationThrowsData exception : current.getExceptions()) {
+builder.end().startCatchBlock(exception.getJavaClass(), "rewriteEx");
+builder.string("// fall through").newLine();
+}
+builder.end();
+return builder.getRoot();
+}
+private CodeTree createRewriteGeneric(CodeTreeBuilder parent, SpecializationData current) {
+CodeTreeBuilder builder = parent.create();
+builder.startStatement().startCall("super", "replace");
+builder.startGroup().startNew(nodeSpecializationClassName(current)).string("this").end().end();
+builder.string("message");
+builder.end().end();
+return builder.getRoot();
+}
+private CodeTree createRewritePolymorphic(CodeTreeBuilder parent, NodeData node) {
+CodeTreeBuilder builder = parent.create();
+builder.startStatement();
+builder.string(nodePolymorphicClassName(node, null));
+builder.string(" polymorphic = ");
+builder.startNew(nodePolymorphicClassName(node, null)).string("this").end();
+builder.end();
+for (NodeChildData child : node.getChildren()) {
+builder.startStatement().string("this.").string(child.getName()).string(" = null").end();
+}
+builder.startStatement().startCall("super", "replace");
+builder.string("polymorphic");
+builder.string("message");
+builder.end().end();
+builder.statement("polymorphic.setNext0(this)");
+builder.statement("setNext0(createSpezialization0(resultClass))");
+builder.statement("polymorphic.optimizeTypes()");
+return builder.getRoot();
+}
+private void emitSpecializationListeners(CodeTreeBuilder builder, NodeData node) {
+for (TemplateMethod listener : node.getSpecializationListeners()) {
+builder.startStatement();
+builder.tree(createTemplateMethodCall(builder, null, listener, listener, null));
+builder.end(); // statement
+}
+}
+protected CodeTree createCastingExecute(CodeTreeBuilder parent, SpecializationData specialization, ExecutableTypeData executable, ExecutableTypeData castExecutable) {
+TypeData type = executable.getType();
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+NodeData node = specialization.getNode();
+ExecutableTypeData castedType = node.findExecutableType(type, 0);
+TypeData primaryType = castExecutable.getType();
+boolean needsTry = castExecutable.hasUnexpectedValue(getContext());
+boolean returnVoid = type.isVoid();
+List<ActualParameter> executeParameters = new ArrayList<>();
+for (ActualParameter sourceParameter : executable.getParameters()) {
+if (!sourceParameter.getSpecification().isSignature()) {
+continue;
+}
+ActualParameter targetParameter = castExecutable.findParameter(sourceParameter.getLocalName());
+if (targetParameter != null) {
+executeParameters.add(targetParameter);
+}
+}
+builder.tree(createExecuteChildren(builder, executable, specialization, executeParameters, null, true));
+CodeTree primaryExecuteCall = createTemplateMethodCall(builder, null, executable, castExecutable, null);
+if (needsTry) {
+if (!returnVoid) {
+builder.declaration(primaryType.getPrimitiveType(), "value");
+}
+builder.startTryBlock();
+if (returnVoid) {
+builder.statement(primaryExecuteCall);
+} else {
+builder.startStatement();
+builder.string("value = ");
+builder.tree(primaryExecuteCall);
+builder.end();
+}
+builder.end().startCatchBlock(getUnexpectedValueException(), "ex");
+if (returnVoid) {
+builder.string("// ignore").newLine();
+} else {
+builder.startReturn();
+builder.tree(createExpectExecutableType(node, specialization.getNode().getTypeSystem().getGenericTypeData(), castedType, CodeTreeBuilder.singleString("ex.getResult()")));
+builder.end();
+}
+builder.end();
+if (!returnVoid) {
+builder.startReturn();
+builder.tree(createExpectExecutableType(node, castExecutable.getReturnType().getTypeSystemType(), executable, CodeTreeBuilder.singleString("value")));
+builder.end();
+}
+} else {
+if (returnVoid) {
+builder.statement(primaryExecuteCall);
+} else {
+builder.startReturn();
+builder.tree(createExpectExecutableType(node, castExecutable.getReturnType().getTypeSystemType(), executable, primaryExecuteCall));
+builder.end();
+}
+}
+return builder.getRoot();
+}
+protected CodeTree createExpectExecutableType(NodeData node, TypeData sourceType, ExecutableTypeData castedType, CodeTree value) {
+boolean hasUnexpected = castedType.hasUnexpectedValue(getContext());
+return createCastType(node, sourceType, castedType.getType(), hasUnexpected, value);
+}
+protected CodeTree createCastType(NodeData node, TypeData sourceType, TypeData targetType, boolean expect, CodeTree value) {
+if (targetType == null) {
+return value;
+} else if (!sourceType.needsCastTo(getContext(), targetType)) {
+return value;
+}
+CodeTreeBuilder builder = CodeTreeBuilder.createBuilder();
+String targetMethodName;
+if (expect) {
+targetMethodName = TypeSystemCodeGenerator.expectTypeMethodName(targetType);
+} else {
+targetMethodName = TypeSystemCodeGenerator.asTypeMethodName(targetType);
+}
+startCallTypeSystemMethod(getContext(), builder, node, targetMethodName);
+builder.tree(value);
+builder.end().end();
+return builder.getRoot();
+}
+protected CodeTree createExecuteChildren(CodeTreeBuilder parent, ExecutableTypeData sourceExecutable, SpecializationData specialization, List<ActualParameter> targetParameters,
+ActualParameter unexpectedParameter, boolean cast) {
+NodeData sourceNode = specialization.getNode();
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+for (ActualParameter targetParameter : targetParameters) {
+NodeChildData field = sourceNode.findChild(targetParameter.getSpecification().getName());
+if (!targetParameter.getSpecification().isSignature()) {
+continue;
+}
+TypeData targetType = targetParameter.getTypeSystemType();
+ExecutableTypeData targetExecutable = null;
+if (field != null) {
+targetExecutable = field.findExecutableType(getContext(), targetType);
+}
+ActualParameter sourceParameter = sourceExecutable.findParameter(targetParameter.getLocalName());
+String targetVariableName = valueName(targetParameter);
+CodeTree executionExpression = null;
+if ((sourceParameter != null && cast) || sourceParameter != null) {
+TypeData sourceType = sourceParameter.getTypeSystemType();
+if (targetExecutable == null || !sourceType.needsCastTo(getContext(), targetType)) {
+if (field != null && field.isShortCircuit() && sourceParameter != null) {
+builder.tree(createShortCircuitValue(builder, specialization, field, targetParameter.getPreviousParameter(), unexpectedParameter));
+}
+builder.startStatement();
+builder.type(targetParameter.getType()).string(" ");
+builder.string(valueName(targetParameter)).string(" = ");
+builder.tree(CodeTreeBuilder.singleString(valueNameEvaluated(targetParameter)));
+builder.end();
+continue;
+} else {
+CodeTree valueTree = CodeTreeBuilder.singleString(valueNameEvaluated(targetParameter));
+executionExpression = createExpectExecutableType(sourceNode, sourceType, targetExecutable, valueTree);
+}
+} else if (sourceParameter == null) {
+executionExpression = createExecuteChildExpression(builder, field, targetParameter, unexpectedParameter);
+}
+if (executionExpression != null) {
+CodeTreeVariable executionVar = new CodeTreeVariable();
+CodeTree shortCircuitTree = createShortCircuitTree(builder, executionVar, targetVariableName, specialization, targetParameter, unexpectedParameter);
+CodeTree unexpectedTree = createCatchUnexpectedTree(builder, executionExpression, targetVariableName, specialization, sourceExecutable, targetExecutable, targetParameter,
+shortCircuitTree != executionVar);
+executionVar.set(unexpectedTree);
+builder.tree(shortCircuitTree);
+}
+}
+return builder.getRoot();
+}
+private CodeTree createCatchUnexpectedTree(CodeTreeBuilder parent, CodeTree body, String targetVariableName, SpecializationData specialization, ExecutableTypeData currentExecutable,
+ExecutableTypeData targetExecutable, ActualParameter param, boolean shortCircuit) {
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+boolean unexpected = targetExecutable.hasUnexpectedValue(getContext());
+boolean cast = false;
+if (targetExecutable.getType().needsCastTo(getContext(), param.getTypeSystemType())) {
+unexpected = true;
+cast = true;
+}
+if (specialization.isGeneric() && unexpected) {
+throw new AssertionError("Generic has unexpected parameters. " + specialization.toString());
+}
+builder.startStatement();
+if (!shortCircuit) {
+builder.type(param.getType()).string(" ").string(targetVariableName);
+}
+if (unexpected) {
+if (!shortCircuit) {
+builder.end();
+}
+builder.startTryBlock();
+builder.startStatement();
+builder.string(targetVariableName);
+} else if (shortCircuit) {
+builder.startStatement();
+builder.string(targetVariableName);
+}
+builder.string(" = ");
+if (cast) {
+builder.tree(createCastType(specialization.getNode(), targetExecutable.getType(), param.getTypeSystemType(), true, body));
+} else {
+builder.tree(body);
+}
+builder.end();
+if (unexpected) {
+builder.end().startCatchBlock(getUnexpectedValueException(), "ex");
+SpecializationData generic = specialization.getNode().getGenericSpecialization();
+ActualParameter genericParameter = generic.findParameter(param.getLocalName());
+List<ActualParameter> genericParameters = generic.getParametersAfter(genericParameter);
+builder.tree(createDeoptimize(builder));
+builder.tree(createExecuteChildren(parent, currentExecutable, generic, genericParameters, genericParameter, false));
+if (specialization.isPolymorphic()) {
+builder.tree(createReturnOptimizeTypes(builder, specialization, param));
+} else {
+builder.tree(createReturnExecuteAndSpecialize(builder, currentExecutable, specialization.findNextSpecialization(), param, "Expected " + param.getLocalName() + " instanceof " +
+Utils.getSimpleName(param.getType())));
+}
+builder.end(); // catch block
+}
+return builder.getRoot();
+}
+private CodeTree createReturnOptimizeTypes(CodeTreeBuilder parent, SpecializationData specialization, ActualParameter param) {
+NodeData node = specialization.getNode();
+assert !node.getPolymorphicSpecializations().isEmpty();
+SpecializationData generic = node.getPolymorphicSpecializations().get(0);
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+builder.startReturn();
+CodeTreeBuilder execute = new CodeTreeBuilder(builder);
+execute.startCall("next0", "executeCached0");
+addInternalValueParameterNames(execute, specialization, generic, param.getLocalName(), true, true);
+execute.end();
+TypeData sourceType = generic.getReturnType().getTypeSystemType();
+TypeData targetType = specialization.getReturnType().getTypeSystemType();
+builder.tree(createCastType(node, sourceType, targetType, true, execute.getRoot()));
+builder.end();
+return builder.getRoot();
+}
+private CodeTree createExecuteChildExpression(CodeTreeBuilder parent, NodeChildData targetField, ActualParameter sourceParameter, ActualParameter unexpectedParameter) {
+TypeData type = sourceParameter.getTypeSystemType();
+ExecutableTypeData execType = targetField.findExecutableType(getContext(), type);
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+if (targetField != null) {
+Element accessElement = targetField.getAccessElement();
+if (accessElement == null || accessElement.getKind() == ElementKind.METHOD) {
+builder.string("this.").string(targetField.getName());
+} else if (accessElement.getKind() == ElementKind.FIELD) {
+builder.string("this.").string(accessElement.getSimpleName().toString());
+} else {
+throw new AssertionError();
+}
+if (sourceParameter.getSpecification().isIndexed()) {
+builder.string("[" + sourceParameter.getIndex() + "]");
+}
+builder.string(".");
+}
+builder.startCall(execType.getMethodName());
+int index = 0;
+for (ActualParameter parameter : execType.getParameters()) {
+if (!parameter.getSpecification().isSignature()) {
+builder.string(parameter.getLocalName());
+} else {
+if (index < targetField.getExecuteWith().size()) {
+NodeChildData child = targetField.getExecuteWith().get(index);
+ParameterSpec spec = getModel().getSpecification().findParameterSpec(child.getName());
+List<ActualParameter> specializationParams = getModel().findParameters(spec);
+if (specializationParams.isEmpty()) {
+builder.defaultValue(parameter.getType());
+continue;
+}
+ActualParameter specializationParam = specializationParams.get(0);
+TypeData targetType = parameter.getTypeSystemType();
+TypeData sourceType = specializationParam.getTypeSystemType();
+String localName = specializationParam.getLocalName();
+if (unexpectedParameter != null && unexpectedParameter.getLocalName().equals(specializationParam.getLocalName())) {
+localName = "ex.getResult()";
+sourceType = getModel().getNode().getTypeSystem().getGenericTypeData();
+}
+CodeTree value = CodeTreeBuilder.singleString(localName);
+if (sourceType.needsCastTo(getContext(), targetType)) {
+value = createCallTypeSystemMethod(getContext(), builder, getModel().getNode(), TypeSystemCodeGenerator.asTypeMethodName(targetType), value);
+}
+builder.tree(value);
+} else {
+builder.defaultValue(parameter.getType());
+}
+index++;
+}
+}
+builder.end();
+return builder.getRoot();
+}
+private CodeTree createShortCircuitTree(CodeTreeBuilder parent, CodeTree body, String targetVariableName, SpecializationData specialization, ActualParameter parameter,
+ActualParameter exceptionParam) {
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+NodeChildData forField = specialization.getNode().findChild(parameter.getSpecification().getName());
+if (forField == null) {
+return body;
+}
+if (forField.getExecutionKind() != ExecutionKind.SHORT_CIRCUIT) {
+return body;
+}
+ActualParameter shortCircuitParam = specialization.getPreviousParam(parameter);
+builder.tree(createShortCircuitValue(builder, specialization, forField, shortCircuitParam, exceptionParam));
+builder.declaration(parameter.getType(), targetVariableName, CodeTreeBuilder.createBuilder().defaultValue(parameter.getType()));
+builder.startIf().string(shortCircuitParam.getLocalName()).end();
+builder.startBlock();
+builder.tree(body);
+builder.end();
+return builder.getRoot();
+}
+private CodeTree createShortCircuitValue(CodeTreeBuilder parent, SpecializationData specialization, NodeChildData forField, ActualParameter shortCircuitParam, ActualParameter exceptionParam) {
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+int shortCircuitIndex = 0;
+for (NodeChildData field : specialization.getNode().getChildren()) {
+if (field.getExecutionKind() == ExecutionKind.SHORT_CIRCUIT) {
+if (field == forField) {
+break;
+}
+shortCircuitIndex++;
+}
+}
+builder.startStatement().type(shortCircuitParam.getType()).string(" ").string(valueName(shortCircuitParam)).string(" = ");
+ShortCircuitData shortCircuitData = specialization.getShortCircuits().get(shortCircuitIndex);
+builder.tree(createTemplateMethodCall(builder, null, specialization, shortCircuitData, exceptionParam != null ? exceptionParam.getLocalName() : null));
+builder.end(); // statement
+return builder.getRoot();
+}
+protected CodeTree createDeoptimize(CodeTreeBuilder parent) {
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+builder.startStatement();
+builder.startStaticCall(getContext().getTruffleTypes().getCompilerDirectives(), "transferToInterpreter").end();
+builder.end();
+return builder.getRoot();
+}
+protected CodeTree createReturnExecuteAndSpecialize(CodeTreeBuilder parent, ExecutableTypeData executable, SpecializationData nextSpecialization, ActualParameter exceptionParam, String reason) {
+SpecializationData generic = getModel().getNode().getGenericSpecialization();
+CodeTreeBuilder specializeCall = new CodeTreeBuilder(parent);
+specializeCall.startCall(EXECUTE_SPECIALIZE_NAME);
+specializeCall.string(nodeSpecializationClassName(nextSpecialization) + ".class");
+addInternalValueParameterNames(specializeCall, generic, nextSpecialization.getNode().getGenericSpecialization(), exceptionParam != null ? exceptionParam.getLocalName() : null, true, true);
+specializeCall.doubleQuote(reason);
+specializeCall.end().end();
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+builder.startReturn();
+builder.tree(createExpectExecutableType(nextSpecialization.getNode(), generic.getReturnType().getTypeSystemType(), executable, specializeCall.getRoot()));
+builder.end();
+return builder.getRoot();
+}
+}
+private class PolymorphicNodeFactory extends SpecializedNodeFactory {
+private final boolean generic;
+public PolymorphicNodeFactory(ProcessorContext context, CodeTypeElement nodeGen, boolean generic) {
+super(context, nodeGen);
+this.generic = generic;
+}
+@Override
+public CodeTypeElement create(SpecializationData specialization) {
+NodeData node = specialization.getNode();
+TypeMirror baseType = node.getNodeType();
+if (nodeGen != null) {
+baseType = nodeGen.asType();
+}
+CodeTypeElement clazz = createClass(node, modifiers(PRIVATE, STATIC), nodePolymorphicClassName(node, specialization), baseType, false);
+if (!generic) {
+clazz.getModifiers().add(Modifier.FINAL);
+}
+clazz.getAnnotationMirrors().add(createNodeInfo(node, Kind.POLYMORPHIC));
+return clazz;
+}
+@Override
+protected void createChildren(SpecializationData specialization) {
+// super.createChildren(specialization);
+CodeTypeElement clazz = getElement();
+createConstructors(clazz);
+createExecuteMethods(specialization);
+if (generic) {
+getElement().add(createOptimizeTypes());
+createCachedExecuteMethods(specialization);
+}
+}
+private CodeExecutableElement createOptimizeTypes() {
+NodeData node = getModel().getNode();
+CodeExecutableElement method = new CodeExecutableElement(modifiers(PROTECTED, FINAL), getContext().getType(void.class), "optimizeTypes");
+CodeTreeBuilder builder = method.createBuilder();
+builder.startStatement().string(baseClassName(node)).string(" node = this.next0").end();
+TypeMirror classType = getContext().getType(Class.class);
+SpecializationData genericSpecialization = node.getGenericSpecialization();
+CodeTreeBuilder whileBodyBuilder = builder.create();
+for (ActualParameter parameter : node.getGenericSpecialization().getReturnTypeAndParameters()) {
+if (!parameter.getSpecification().isSignature()) {
+continue;
+}
+ActualParameter genericParameter = genericSpecialization.findParameter(parameter.getLocalName());
+String name = parameter.getLocalName() + "Type";
+builder.declaration(classType, name, builder.create().startCall("node", typeGetterName(parameter)).end().getRoot());
+whileBodyBuilder.startIf().string(name).string(" != ").startCall("node", typeGetterName(parameter)).end().end();
+whileBodyBuilder.startBlock();
+whileBodyBuilder.startStatement().string(name).string(" = ").typeLiteral(genericParameter.getType()).end();
+whileBodyBuilder.end();
+}
+builder.startWhile().string("node != null && !(").instanceOf("node", nodeSpecializationClassName(node.getUninitializedSpecialization())).string(")").end();
+builder.startBlock();
+builder.tree(whileBodyBuilder.getRoot());
+builder.statement("node = node.next0");
+builder.end();
+boolean elseIf = false;
+for (SpecializationData polymorph : node.getPolymorphicSpecializations()) {
+elseIf = builder.startIf(elseIf);
+String and = "";
+StringBuilder reason = new StringBuilder("Optimized polymorphic types for (");
+for (ActualParameter parameter : polymorph.getReturnTypeAndParameters()) {
+if (!parameter.getSpecification().isSignature()) {
+continue;
+}
+String name = parameter.getLocalName() + "Type";
+builder.string(and).string(name).string(" == ").typeLiteral(parameter.getType());
+if (!and.isEmpty()) {
+reason.append(", ");
+}
+reason.append(Utils.getSimpleName(parameter.getType()));
+and = " && ";
+}
+reason.append(")");
+builder.end();
+builder.startBlock();
+String className = nodePolymorphicClassName(node, polymorph);
+builder.startIf().string("getClass() != ").string(className).string(".class").end();
+builder.startBlock();
+builder.startStatement().startCall("super", "replace");
+builder.startNew(className).string("this").end();
+builder.doubleQuote(reason.toString());
+builder.end().end(); // call
+builder.end(); // block
+builder.end();
+}
+return method;
+}
+}
+private class SpecializedNodeFactory extends NodeBaseFactory {
+protected final CodeTypeElement nodeGen;
+public SpecializedNodeFactory(ProcessorContext context, CodeTypeElement nodeGen) {
+super(context);
+this.nodeGen = nodeGen;
+}
+@Override
+public CodeTypeElement create(SpecializationData specialization) {
+NodeData node = specialization.getNode();
+TypeMirror baseType = node.getNodeType();
+if (nodeGen != null) {
+baseType = nodeGen.asType();
+}
+CodeTypeElement clazz = createClass(node, modifiers(PRIVATE, STATIC, FINAL), nodeSpecializationClassName(specialization), baseType, false);
+Kind kind;
+if (specialization.isGeneric()) {
+kind = Kind.GENERIC;
+} else if (specialization.isUninitialized()) {
+kind = Kind.UNINITIALIZED;
+} else {
+kind = Kind.SPECIALIZED;
+}
+clazz.getAnnotationMirrors().add(createNodeInfo(node, kind));
+return clazz;
+}
+protected CodeAnnotationMirror createNodeInfo(NodeData node, Kind kind) {
+String shortName = node.getShortName();
+CodeAnnotationMirror nodeInfoMirror = new CodeAnnotationMirror(getContext().getTruffleTypes().getNodeInfoAnnotation());
+if (shortName != null) {
+nodeInfoMirror.setElementValue(nodeInfoMirror.findExecutableElement("shortName"), new CodeAnnotationValue(shortName));
+}
+DeclaredType nodeinfoKind = getContext().getTruffleTypes().getNodeInfoKind();
+VariableElement varKind = Utils.findVariableElement(nodeinfoKind, kind.name());
+nodeInfoMirror.setElementValue(nodeInfoMirror.findExecutableElement("kind"), new CodeAnnotationValue(varKind));
+return nodeInfoMirror;
+}
+@Override
+protected void createChildren(SpecializationData specialization) {
+CodeTypeElement clazz = getElement();
+createConstructors(clazz);
+NodeData node = specialization.getNode();
+if (!specialization.isGeneric() && !specialization.isUninitialized() && !specialization.isPolymorphic() && node.needsRewrites(getContext()) && node.getPolymorphicDepth() > 1) {
+createTypeGetters(clazz, specialization);
+}
+createExecuteMethods(specialization);
+createCachedExecuteMethods(specialization);
+}
+protected void createConstructors(CodeTypeElement clazz) {
+TypeElement superTypeElement = Utils.fromTypeMirror(clazz.getSuperclass());
+for (ExecutableElement constructor : ElementFilter.constructorsIn(superTypeElement.getEnclosedElements())) {
+if (getModel().getNode().getUninitializedSpecialization() != null && !getModel().isUninitialized() &&
+(constructor.getParameters().size() != 1 || constructor.getParameters().get(0).getSimpleName().toString().equals(baseClassName(getModel().getNode())))) {
+continue;
+}
+CodeExecutableElement superConstructor = createSuperConstructor(clazz, constructor);
+if (superConstructor != null) {
+if (getModel().isGeneric() && getModel().getNode().getPolymorphicDepth() > 1) {
+CodeTree body = superConstructor.getBodyTree();
+CodeTreeBuilder builder = superConstructor.createBuilder();
+builder.tree(body);
+builder.statement("this.next0 = null");
+}
+clazz.add(superConstructor);
+}
+}
+}
+protected void createExecuteMethods(SpecializationData specialization) {
+NodeData node = specialization.getNode();
+CodeTypeElement clazz = getElement();
+for (ExecutableTypeData execType : node.getExecutableTypes()) {
+if (execType.isFinal()) {
+continue;
+}
+CodeExecutableElement executeMethod = createExecutableTypeOverride(execType, true);
+clazz.add(executeMethod);
+CodeTreeBuilder builder = executeMethod.createBuilder();
+CodeTree result = createExecuteBody(builder, specialization, execType);
+if (result != null) {
+builder.tree(result);
+} else {
+clazz.remove(executeMethod);
+}
+}
+}
+protected void createCachedExecuteMethods(SpecializationData specialization) {
+NodeData node = specialization.getNode();
+CodeTypeElement clazz = getElement();
+int index = 0;
+for (SpecializationData polymorphic : node.getPolymorphicSpecializations()) {
+boolean matchFound = false;
+if (!specialization.isGeneric() && !specialization.isUninitialized() && !specialization.isPolymorphic()) {
+matchFound = polymorphic.getSignature().hasAnyParameterMatch(specialization.getSignature());
+}
+if (matchFound || index == 0) {
+ExecutableElement executeCached = nodeGen.getMethod("executeCached" + index);
+ExecutableTypeData execType = new ExecutableTypeData(polymorphic, executeCached, node.getTypeSystem(), polymorphic.getReturnType().getTypeSystemType());
+CodeExecutableElement executeMethod = createExecutableTypeOverride(execType, false);
+CodeTreeBuilder builder = executeMethod.createBuilder();
+if (specialization.isGeneric() || specialization.isPolymorphic()) {
+builder.startThrow().startNew(getContext().getType(AssertionError.class));
+builder.doubleQuote("Should not be reached.");
+builder.end().end();
+} else if (specialization.isUninitialized()) {
+builder.tree(createAppendPolymorphic(builder, specialization));
+} else {
+CodeTreeBuilder elseBuilder = new CodeTreeBuilder(builder);
+elseBuilder.startReturn().startCall("this.next0", "executeCached" + index);
+addInternalValueParameterNames(elseBuilder, polymorphic, polymorphic, null, true, true);
+elseBuilder.end().end();
+CodeTreeBuilder execute = new CodeTreeBuilder(builder);
+execute.tree(createGenericInvoke(builder, polymorphic, specialization));
+boolean forceElse = !specialization.getExceptions().isEmpty();
+builder.tree(createGuardAndCast(builder, null, polymorphic, specialization, true, execute.getRoot(), elseBuilder.getRoot(), true, forceElse));
+}
+clazz.add(executeMethod);
+}
+index++;
+}
+}
+private CodeTree createAppendPolymorphic(CodeTreeBuilder parent, SpecializationData specialization) {
+NodeData node = specialization.getNode();
+String genericClassName = nodePolymorphicClassName(node, null);
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+builder.startStatement().startStaticCall(getContext().getTruffleTypes().getCompilerDirectives(), "transferToInterpreter").end().end();
+builder.declaration(getContext().getTruffleTypes().getNode(), "searchNode", "super.getParent()");
+builder.declaration(getContext().getType(int.class), "depth", "0");
+builder.startWhile().string("searchNode != null").end();
+builder.startBlock();
+builder.statement("depth++");
+builder.statement("searchNode = searchNode.getParent()");
+builder.startIf().instanceOf("searchNode", genericClassName).end();
+builder.startBlock().breakStatement().end();
+builder.end(); // if
+builder.end(); // while
+builder.startAssert().instanceOf("searchNode", genericClassName).end();
+builder.startStatement();
+builder.string(genericClassName).string(" ").string("polymorphic = ").string("(").string(genericClassName).string(") searchNode");
+builder.end();
+builder.startIf().string("depth >= ").string(String.valueOf(node.getPolymorphicDepth())).end();
+builder.startBlock();
+builder.startStatement();
+builder.startCall("searchNode", "replace");
+builder.startNew(nodeSpecializationClassName(node.getGenericSpecialization())).string("this").end();
+builder.doubleQuote("Polymorphic limit reached (" + node.getPolymorphicDepth() + ")");
+builder.end();
+builder.end();
+builder.startReturn().startCall("super", EXECUTE_GENERIC_NAME);
+addInternalValueParameterNames(builder, specialization, node.getGenericSpecialization(), null, true, true);
+builder.end().end();
+builder.end().startElseBlock();
+builder.startStatement().startCall("super", "setNext0");
+builder.startNew(nodeSpecializationClassName(node.getUninitializedSpecialization())).string("this").end();
+builder.end().end();
+CodeTreeBuilder specializeCall = new CodeTreeBuilder(builder);
+specializeCall.startCall(EXECUTE_SPECIALIZE_NAME);
+specializeCall.string(nodeSpecializationClassName(node.getUninitializedSpecialization()) + ".class");
+addInternalValueParameterNames(specializeCall, specialization, node.getGenericSpecialization(), null, true, true);
+specializeCall.startGroup().doubleQuote("Uninitialized polymorphic (").string(" + depth + ").doubleQuote("/" + node.getPolymorphicDepth() + ")").end();
+specializeCall.end().end();
+builder.declaration(node.getGenericSpecialization().getReturnType().getType(), "result", specializeCall.getRoot());
+builder.statement("polymorphic.optimizeTypes()");
+if (Utils.isVoid(builder.findMethod().getReturnType())) {
+builder.returnStatement();
+} else {
+builder.startReturn().string("result").end();
+}
+builder.end();
+return builder.getRoot();
+}
+private CodeTree createExecuteBody(CodeTreeBuilder parent, SpecializationData specialization, ExecutableTypeData execType) {
+TypeData primaryType = specialization.getReturnType().getTypeSystemType();
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+List<ExecutableTypeData> primaryExecutes = findFunctionalExecutableType(specialization, execType.getEvaluatedCount());
+if (primaryExecutes.contains(execType) || primaryExecutes.isEmpty()) {
+builder.tree(createFunctionalExecute(builder, specialization, execType));
+} else if (needsCastingExecuteMethod(execType, primaryType)) {
+assert !primaryExecutes.isEmpty();
+builder.tree(createCastingExecute(builder, specialization, execType, primaryExecutes.get(0)));
+} else {
+return null;
+}
+return builder.getRoot();
+}
+private CodeExecutableElement createExecutableTypeOverride(ExecutableTypeData execType, boolean evaluated) {
+CodeExecutableElement method = CodeExecutableElement.clone(getContext().getEnvironment(), execType.getMethod());
+int i = 0;
+for (VariableElement param : method.getParameters()) {
+CodeVariableElement var = CodeVariableElement.clone(param);
+ActualParameter actualParameter = execType.getParameters().get(i);
+if (evaluated && actualParameter.getSpecification().isSignature()) {
+var.setName(valueNameEvaluated(actualParameter));
+} else {
+var.setName(valueName(actualParameter));
+}
+method.getParameters().set(i, var);
+i++;
+}
+method.getAnnotationMirrors().clear();
+method.getModifiers().remove(Modifier.ABSTRACT);
+return method;
+}
+private boolean needsCastingExecuteMethod(ExecutableTypeData execType, TypeData primaryType) {
+if (execType.isAbstract()) {
+return true;
+}
+if (Utils.isPrimitiveOrVoid(primaryType.getPrimitiveType()) && Utils.isPrimitiveOrVoid(execType.getType().getPrimitiveType())) {
+return true;
+}
+if (execType.getType().isGeneric()) {
+return true;
+}
+return false;
+}
+private List<ExecutableTypeData> findFunctionalExecutableType(SpecializationData specialization, int evaluatedCount) {
+TypeData primaryType = specialization.getReturnType().getTypeSystemType();
+List<ExecutableTypeData> otherTypes = specialization.getNode().getExecutableTypes(evaluatedCount);
+List<ExecutableTypeData> filteredTypes = new ArrayList<>();
+for (ExecutableTypeData compareType : otherTypes) {
+if (!Utils.typeEquals(compareType.getType().getPrimitiveType(), primaryType.getPrimitiveType())) {
+continue;
+}
+filteredTypes.add(compareType);
+}
+// no direct matches found use generic where the type is Object
+if (filteredTypes.isEmpty()) {
+for (ExecutableTypeData compareType : otherTypes) {
+if (compareType.getType().isGeneric() && !compareType.hasUnexpectedValue(getContext())) {
+filteredTypes.add(compareType);
+}
+}
+}
+if (filteredTypes.isEmpty()) {
+for (ExecutableTypeData compareType : otherTypes) {
+if (compareType.getType().isGeneric()) {
+filteredTypes.add(compareType);
+}
+}
+}
+return filteredTypes;
+}
+private CodeTree createFunctionalExecute(CodeTreeBuilder parent, SpecializationData specialization, ExecutableTypeData executable) {
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+if (specialization.isUninitialized()) {
+builder.tree(createDeoptimize(builder));
+}
+builder.tree(createExecuteChildren(builder, executable, specialization, specialization.getParameters(), null, false));
+CodeTree executeNode = createExecute(builder, executable, specialization);
+SpecializationData next = specialization.findNextSpecialization();
+CodeTree returnSpecialized = null;
+if (next != null) {
+CodeTreeBuilder returnBuilder = new CodeTreeBuilder(builder);
+returnBuilder.tree(createDeoptimize(builder));
+returnBuilder.tree(createReturnExecuteAndSpecialize(builder, executable, next, null, "One of guards " + specialization.getGuards() + " failed"));
+returnSpecialized = returnBuilder.getRoot();
+}
+builder.tree(createGuardAndCast(builder, null, specialization, specialization, true, executeNode, returnSpecialized, false, false));
+return builder.getRoot();
+}
+private CodeTree createExecute(CodeTreeBuilder parent, ExecutableTypeData executable, SpecializationData specialization) {
+NodeData node = specialization.getNode();
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+if (!specialization.getExceptions().isEmpty() || !specialization.getAssumptions().isEmpty()) {
+builder.startTryBlock();
+}
+for (String assumption : specialization.getAssumptions()) {
+builder.startStatement();
+builder.string("this.").string(assumption).string(".check()");
+builder.end();
+}
+CodeTreeBuilder returnBuilder = new CodeTreeBuilder(parent);
+if (specialization.isPolymorphic()) {
+int index = 0;
+if (executable.hasUnexpectedValue(getContext())) {
+index = specialization.getNode().getPolymorphicSpecializations().indexOf(specialization);
+}
+returnBuilder.startCall("next0", "executeCached" + index);
+addInternalValueParameterNames(returnBuilder, specialization, specialization, null, true, true);
+returnBuilder.end();
+} else if (specialization.isUninitialized()) {
+returnBuilder.startCall("super", EXECUTE_SPECIALIZE_NAME);
+returnBuilder.startGroup().string(nodeSpecializationClassName(specialization)).string(".class").end();
+addInternalValueParameterNames(returnBuilder, specialization, specialization, null, true, true);
+returnBuilder.doubleQuote("Uninitialized monomorphic");
+returnBuilder.end();
+} else if (specialization.getMethod() == null && !node.needsRewrites(context)) {
+emitEncounteredSynthetic(builder, specialization);
+} else if (specialization.isGeneric()) {
+returnBuilder.startCall("super", EXECUTE_GENERIC_NAME);
+addInternalValueParameterNames(returnBuilder, specialization, specialization, null, true, true);
+returnBuilder.end();
+} else {
+returnBuilder.tree(createTemplateMethodCall(returnBuilder, null, specialization, specialization, null));
+}
+if (!returnBuilder.isEmpty()) {
+builder.startReturn();
+TypeData targetType = node.getTypeSystem().findTypeData(builder.findMethod().getReturnType());
+TypeData sourceType = specialization.getReturnType().getTypeSystemType();
+if (targetType == null || sourceType == null) {
+builder.tree(returnBuilder.getRoot());
+} else if (sourceType.needsCastTo(getContext(), targetType)) {
+builder.tree(createCallTypeSystemMethod(context, parent, node, TypeSystemCodeGenerator.expectTypeMethodName(targetType), returnBuilder.getRoot()));
+} else {
+builder.tree(returnBuilder.getRoot());
+}
+builder.end();
+}
+if (!specialization.getExceptions().isEmpty()) {
+for (SpecializationThrowsData exception : specialization.getExceptions()) {
+builder.end().startCatchBlock(exception.getJavaClass(), "ex");
+builder.tree(createDeoptimize(builder));
+builder.tree(createReturnExecuteAndSpecialize(parent, executable, exception.getTransitionTo(), null, "Thrown " + Utils.getSimpleName(exception.getJavaClass())));
+}
+builder.end();
+}
+if (!specialization.getAssumptions().isEmpty()) {
+builder.end().startCatchBlock(getContext().getTruffleTypes().getInvalidAssumption(), "ex");
+builder.tree(createReturnExecuteAndSpecialize(parent, executable, specialization.findNextSpecialization(), null, "Assumption failed"));
+builder.end();
+}
+return builder.getRoot();
+}
+}
+}

Mercurial > hg > truffle

comparison graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/node/NodeCodeGenerator.java @ 10597:79041ab43660