graal-compiler: 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 @ 12395:8e8347ecabbc

Truffle-DSL: implemented new polymorphic more compact generation strategy

author	Christian Humer <christian.humer@gmail.com>
date	Fri, 11 Oct 2013 20:05:55 +0200
parents	4e26955b6da2
children	c78612fb0120

comparison

equal deleted inserted replaced

-:df3af5e007ad
+:8e8347ecabbc
 import com.oracle.truffle.dsl.processor.ast.*;
 import com.oracle.truffle.dsl.processor.node.NodeChildData.Cardinality;
 import com.oracle.truffle.dsl.processor.node.NodeChildData.ExecutionKind;
 import com.oracle.truffle.dsl.processor.node.SpecializationGroup.TypeGuard;
 import com.oracle.truffle.dsl.processor.template.*;
-import com.oracle.truffle.dsl.processor.template.TemplateMethod.Signature;
 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";
+private static final String UPDATE_TYPES_NAME = "updateTypes";
 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 nodeCastClassName(NodeData node, TypeData type) {
-String nodeid = resolveNodeId(node);
-if (type == null) {
-return nodeid + "ImplicitCast";
-} else {
-return Utils.firstLetterUpperCase(Utils.getSimpleName(type.getPrimitiveType())) + "Cast";
-}
 }
 private static String nodeSpecializationClassName(SpecializationData specialization) {
 String nodeid = resolveNodeId(specialization.getNode());
 String name = Utils.firstLetterUpperCase(nodeid);
 private static String valueNameEvaluated(ActualParameter targetParameter) {
 return valueName(targetParameter) + "Evaluated";
 }
-private static String typeName(ActualParameter param) {
+private static String implicitTypeName(ActualParameter param) {
-return param.getLocalName() + "Type";
+return param.getLocalName() + "ImplicitType";
+}
+private static String polymorphicTypeName(ActualParameter param) {
+return param.getLocalName() + "PolymorphicType";
 }
 private static String valueName(ActualParameter param) {
 return param.getLocalName();
 }
 builder.string("this.");
 }
 builder.string(targetParameter.getSpecification().getName());
 builder.end();
 } else if (unexpectedValueName != null && targetParameter.getLocalName().equals(unexpectedValueName)) {
-builder.string("ex.getResult()");
+builder.cast(targetParameter.getType(), CodeTreeBuilder.singleString("ex.getResult()"));
 } else if (!Utils.needsCastTo(getContext(), valueType, targetType)) {
 builder.startGroup();
 builder.string(valueName(targetParameter));
 builder.end();
 } else {
 String name = Utils.firstLetterUpperCase(nodeid);
 name += "BaseNode";
 return name;
 }
-private static CodeTree createCallTypeSystemMethod(ProcessorContext context, CodeTreeBuilder parent, NodeData node, String methodName, CodeTree value) {
+private static CodeTree createCallTypeSystemMethod(ProcessorContext context, CodeTreeBuilder parent, NodeData node, String methodName, CodeTree... args) {
 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
-startCallTypeSystemMethod(context, builder, node, methodName);
+startCallTypeSystemMethod(context, builder, node.getTypeSystem(), methodName);
-builder.tree(value);
+for (CodeTree arg : args) {
+builder.tree(arg);
+}
 builder.end().end();
 return builder.getRoot();
 }
-private static void startCallTypeSystemMethod(ProcessorContext context, CodeTreeBuilder body, NodeData node, String methodName) {
+private static void startCallTypeSystemMethod(ProcessorContext context, CodeTreeBuilder body, TypeSystemData typeSystem, String methodName) {
-VariableElement singleton = TypeSystemCodeGenerator.findSingleton(context, node.getTypeSystem());
+VariableElement singleton = TypeSystemCodeGenerator.findSingleton(context, typeSystem);
 assert singleton != null;
 body.startGroup();
 body.staticReference(singleton.getEnclosingElement().asType(), singleton.getSimpleName().toString());
 body.string(".").startCall(methodName);
 add(factory, node);
 factory.getElement().getEnclosedElements().addAll(casts);
 }
 }
-protected CodeTree createCastType(NodeData node, TypeData sourceType, TypeData targetType, boolean expect, CodeTree value) {
+protected CodeTree createCastType(TypeSystemData typeSystem, TypeData sourceType, TypeData targetType, boolean expect, CodeTree value) {
 if (targetType == null) {
 return value;
 } else if (sourceType != null && !sourceType.needsCastTo(getContext(), targetType)) {
 return value;
 }
 if (expect) {
 targetMethodName = TypeSystemCodeGenerator.expectTypeMethodName(targetType);
 } else {
 targetMethodName = TypeSystemCodeGenerator.asTypeMethodName(targetType);
 }
-startCallTypeSystemMethod(getContext(), builder, node, targetMethodName);
+startCallTypeSystemMethod(getContext(), builder, typeSystem, targetMethodName);
 builder.tree(value);
 builder.end().end();
 return builder.getRoot();
+}
+protected CodeTree createExpectType(TypeSystemData typeSystem, TypeData sourceType, TypeData targetType, CodeTree expression) {
+return createCastType(typeSystem, sourceType, targetType, true, expression);
 }
 private class NodeFactoryFactory extends ClassElementFactory<NodeData> {
 private final Map<NodeData, List<TypeElement>> childTypes;
 protected void createChildren(NodeData node) {
 CodeTypeElement clazz = getElement();
 Modifier createVisibility = Utils.getVisibility(clazz.getModifiers());
+CodeTypeElement polymorphicNode = null;
 if (node.needsFactory()) {
 NodeBaseFactory factory = new NodeBaseFactory(context);
 add(factory, node.getGenericSpecialization() == null ? node.getSpecializations().get(0) : node.getGenericSpecialization());
 generatedNode = factory.getElement();
 }
 createFactoryMethods(node, clazz, createVisibility);
 if (node.isPolymorphic()) {
-PolymorphicNodeFactory generic = new PolymorphicNodeFactory(getContext(), generatedNode, true);
+PolymorphicNodeFactory generic = new PolymorphicNodeFactory(getContext(), generatedNode);
 add(generic, node.getGenericPolymorphicSpecialization());
+polymorphicNode = generic.getElement();
-for (SpecializationData specialization : node.getPolymorphicSpecializations()) {
-if (specialization == node.getGenericPolymorphicSpecialization()) {
-continue;
-}
-add(new PolymorphicNodeFactory(context, generic.getElement(), false), specialization);
-}
 }
 for (SpecializationData specialization : node.getSpecializations()) {
 if (!specialization.isReachable()) {
 continue;
 }
 clazz.add(createGetChildrenSignatureMethod(node));
 clazz.add(createGetInstanceMethod(node, createVisibility));
 clazz.add(createInstanceConstant(node, clazz.asType()));
 }
+if (polymorphicNode != null) {
+patchParameterType(clazz, UPDATE_TYPES_NAME, generatedNode.asType(), polymorphicNode.asType());
+}
 for (NodeData childNode : childTypes.keySet()) {
 if (childNode.getTemplateType().getModifiers().contains(Modifier.PRIVATE)) {
 continue;
 }
 List<NodeData> children = node.getNodeDeclaringChildren();
 if (node.getParent() == null && children.size() > 0) {
 clazz.add(createGetFactories(node));
 }
+}
+private void patchParameterType(CodeTypeElement enclosingClass, String methodName, TypeMirror originalType, TypeMirror newType) {
+for (TypeElement enclosedType : ElementFilter.typesIn(enclosingClass.getEnclosedElements())) {
+CodeTypeElement type = (CodeTypeElement) enclosedType;
+ExecutableElement method = type.getMethod(methodName);
+for (VariableElement v : method.getParameters()) {
+CodeVariableElement var = (CodeVariableElement) v;
+if (Utils.typeEquals(var.getType(), originalType)) {
+var.setType(newType);
+}
+}
+}
 }
 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");
 setter.getParameters().add(new CodeVariableElement(clazz.asType(), "next0"));
 CodeTreeBuilder builder = setter.createBuilder();
 builder.statement("this.next0 = adoptChild(next0)");
 clazz.add(setter);
-createIsCompatible(clazz, null);
+CodeExecutableElement genericCachedExecute = createCachedExecute(node, node.getGenericPolymorphicSpecialization());
-CodeExecutableElement genericCachedExecute = createCachedExecute(node, node.getGenericPolymorphicSpecialization(), null);
 clazz.add(genericCachedExecute);
-for (SpecializationData polymorph : node.getPolymorphicSpecializations()) {
-if (polymorph == node.getGenericPolymorphicSpecialization()) {
+getElement().add(createUpdateTypes(clazz.asType()));
-continue;
-}
-clazz.add(createCachedExecute(node, polymorph, genericCachedExecute));
-}
 }
 for (CodeExecutableElement method : createImplicitChildrenAccessors()) {
 clazz.add(method);
 }
 }
 }
 private List<CodeExecutableElement> createImplicitChildrenAccessors() {
 NodeData node = getModel().getNode();
-List<CodeExecutableElement> methods = new ArrayList<>();
+// Map<NodeChildData, Set<TypeData>> expectTypes = new HashMap<>();
-Map<NodeChildData, Set<TypeData>> expectTypes = new HashMap<>();
+@SuppressWarnings("unchecked")
+List<Set<TypeData>> expectTypes = Arrays.<Set<TypeData>> asList(new Set[node.getGenericSpecialization().getParameters().size()]);
 for (ExecutableTypeData executableType : node.getExecutableTypes()) {
 for (int i = 0; i < executableType.getEvaluatedCount(); i++) {
 ActualParameter parameter = executableType.getSignatureParameter(i);
-NodeChildData child = node.findChild(parameter.getSpecification().getName());
+if (i >= expectTypes.size()) {
-Set<TypeData> types = expectTypes.get(child);
+break;
+}
+Set<TypeData> types = expectTypes.get(i);
 if (types == null) {
 types = new TreeSet<>();
-expectTypes.put(child, types);
+expectTypes.set(i, types);
 }
 types.add(parameter.getTypeSystemType());
 }
 }
-Map<NodeChildData, Set<TypeData>> visitedMap = new HashMap<>();
+List<CodeExecutableElement> methods = new ArrayList<>();
+@SuppressWarnings("unchecked")
+List<Set<TypeData>> visitedList = Arrays.<Set<TypeData>> asList(new Set[node.getGenericSpecialization().getParameters().size()]);
 for (SpecializationData spec : node.getSpecializations()) {
+int signatureIndex = -1;
 for (ActualParameter param : spec.getParameters()) {
 if (!param.getSpecification().isSignature()) {
 continue;
 }
-NodeChildData child = node.findChild(param.getSpecification().getName());
+signatureIndex++;
-Set<TypeData> visitedTypeData = visitedMap.get(child);
+Set<TypeData> visitedTypeData = visitedList.get(signatureIndex);
 if (visitedTypeData == null) {
 visitedTypeData = new TreeSet<>();
-visitedMap.put(child, visitedTypeData);
+visitedList.set(signatureIndex, visitedTypeData);
 }
 if (visitedTypeData.contains(param.getTypeSystemType())) {
 continue;
 }
 visitedTypeData.add(param.getTypeSystemType());
-Set<TypeData> expect = expectTypes.get(child);
+Set<TypeData> expect = expectTypes.get(signatureIndex);
 if (expect == null) {
 expect = Collections.emptySet();
 }
 methods.addAll(createExecuteChilds(param, expect));
 builder.end();
 return method;
 }
-protected void createIsCompatible(CodeTypeElement clazz, SpecializationData specialization) {
+private CodeExecutableElement createCachedExecute(NodeData node, SpecializationData polymorph) {
-CodeExecutableElement isCompatible = new CodeExecutableElement(modifiers(PROTECTED), context.getType(boolean.class), "isCompatible0");
-isCompatible.addParameter(new CodeVariableElement(getContext().getType(Class.class), "type"));
-if (specialization == null) {
-isCompatible.getModifiers().add(ABSTRACT);
-} else if (specialization.isGeneric()) {
-isCompatible.createBuilder().startThrow().startNew(getContext().getType(AssertionError.class)).end().end();
-} else if (specialization.isPolymorphic()) {
-isCompatible.createBuilder().startReturn().string("type != getClass() && next0.isCompatible0(type)").end();
-} else if (specialization.isUninitialized()) {
-isCompatible.createBuilder().returnTrue();
-} else {
-NodeData node = specialization.getNode();
-CodeTreeBuilder builder = isCompatible.createBuilder();
-Signature specializationSignature = specialization.getSignature();
-List<SpecializationData> compatible = new ArrayList<>();
-for (SpecializationData polymorphic : node.getPolymorphicSpecializations()) {
-if (specializationSignature.isCompatibleTo(polymorphic.getSignature())) {
-compatible.add(polymorphic);
-}
-}
-if (compatible.isEmpty()) {
-builder.returnFalse();
-} else {
-builder.startIf();
-String and = "";
-for (SpecializationData polymorphic : compatible) {
-builder.string(and);
-builder.string("type == ").string(nodePolymorphicClassName(node, polymorphic)).string(".class");
-and = " || ";
-}
-builder.end().startBlock();
-builder.startReturn().startCall("next0", "isCompatible0").string("type").end().end();
-builder.end();
-builder.returnFalse();
-}
-}
-clazz.add(isCompatible);
-}
-private CodeExecutableElement createCachedExecute(NodeData node, SpecializationData polymorph, CodeExecutableElement genericPolymorphMethod) {
 String name = executeCachedName(polymorph);
-CodeExecutableElement cachedExecute = new CodeExecutableElement(modifiers(PROTECTED), polymorph.getReturnType().getType(), name);
+CodeExecutableElement cachedExecute = new CodeExecutableElement(modifiers(PROTECTED, ABSTRACT), polymorph.getReturnType().getType(), name);
+addInternalValueParameters(cachedExecute, polymorph, true, true);
 ExecutableTypeData sourceExecutableType = node.findExecutableType(polymorph.getReturnType().getTypeSystemType(), 0);
 boolean sourceThrowsUnexpected = sourceExecutableType != null && sourceExecutableType.hasUnexpectedValue(getContext());
 if (sourceExecutableType.getType().equals(node.getGenericSpecialization().getReturnType().getTypeSystemType())) {
 sourceThrowsUnexpected = false;
 }
 if (sourceThrowsUnexpected) {
 cachedExecute.getThrownTypes().add(getContext().getType(UnexpectedResultException.class));
 }
-addInternalValueParameters(cachedExecute, polymorph, true, true);
-if (polymorph == node.getGenericPolymorphicSpecialization()) {
-cachedExecute.getModifiers().add(ABSTRACT);
-} else {
-SpecializationData genericPolymorph = node.getGenericPolymorphicSpecialization();
-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 void createConstructors(NodeData node, CodeTypeElement clazz) {
 builder.tree(createExecuteTree(builder, node.getGenericSpecialization(), rootGroup, true, new CodeBlock<SpecializationData>() {
 public CodeTree create(CodeTreeBuilder b, SpecializationData current) {
 return createGenericInvokeAndSpecialize(b, node.getGenericSpecialization(), current, currentNodeVar);
 }
-}, null, false, true));
+}, null, false, true, false));
 boolean firstUnreachable = true;
 for (SpecializationData current : node.getSpecializations()) {
 if (current.isUninitialized() || current.isReachable()) {
 continue;
 builder.tree(createExecuteTree(builder, node.getGenericSpecialization(), group, false, new CodeBlock<SpecializationData>() {
 public CodeTree create(CodeTreeBuilder b, SpecializationData current) {
 return createGenericInvoke(builder, current.getNode().getGenericSpecialization(), current);
 }
-}, null, false, true));
+}, null, false, true, false));
 emitUnreachableSpecializations(builder, node);
 return method;
 }
 builder.string("// unreachable ").string(current.getId()).newLine();
 }
 }
 protected CodeTree createExecuteTree(CodeTreeBuilder outerParent, final SpecializationData source, final SpecializationGroup group, final boolean checkMinimumState,
-final CodeBlock<SpecializationData> guardedblock, final CodeTree elseBlock, boolean forceElse, final boolean emitAssumptions) {
+final CodeBlock<SpecializationData> guardedblock, final CodeTree elseBlock, boolean forceElse, final boolean emitAssumptions, final boolean typedCasts) {
 return guard(outerParent, source, group, checkMinimumState, new CodeBlock<Integer>() {
 public CodeTree create(CodeTreeBuilder parent, Integer ifCount) {
 CodeTreeBuilder builder = parent.create();
 assert group.getChildren().isEmpty() : "missed a specialization";
 } else {
 for (SpecializationGroup childGroup : group.getChildren()) {
-builder.tree(createExecuteTree(builder, source, childGroup, checkMinimumState, guardedblock, null, false, emitAssumptions));
+builder.tree(createExecuteTree(builder, source, childGroup, checkMinimumState, guardedblock, null, false, emitAssumptions, typedCasts));
 }
 }
 return builder.getRoot();
 }
-}, elseBlock, forceElse, emitAssumptions);
+}, elseBlock, forceElse, emitAssumptions, typedCasts);
 }
 private CodeTree guard(CodeTreeBuilder parent, SpecializationData source, SpecializationGroup group, boolean checkMinimumState, CodeBlock<Integer> bodyBlock, CodeTree elseBlock,
-boolean forceElse, boolean emitAssumptions) {
+boolean forceElse, boolean emitAssumptions, boolean typedCasts) {
 CodeTreeBuilder builder = parent.create();
-int ifCount = emitGuards(builder, source, group, checkMinimumState, emitAssumptions);
+int ifCount = emitGuards(builder, source, group, checkMinimumState, emitAssumptions, typedCasts);
 if (isReachableGroup(group, ifCount, checkMinimumState)) {
 builder.tree(bodyBlock.create(builder, ifCount));
 }
 }
 return true;
 }
-private int emitGuards(CodeTreeBuilder builder, SpecializationData source, SpecializationGroup group, boolean checkMinimumState, boolean emitAssumptions) {
+private int emitGuards(CodeTreeBuilder builder, SpecializationData source, SpecializationGroup group, boolean checkMinimumState, boolean emitAssumptions, boolean typedCasts) {
 NodeData node = source.getNode();
 CodeTreeBuilder guardsBuilder = builder.create();
 CodeTreeBuilder castBuilder = builder.create();
 CodeTreeBuilder guardsCastBuilder = builder.create();
 NodeChildData child = node.findChild(valueParam.getSpecification().getName());
 if (child == null) {
 throw new IllegalStateException();
 }
-CodeTree implicitGuard = createTypeGuard(guardsBuilder, child, valueParam, typeGuard.getType());
+CodeTree implicitGuard = createTypeGuard(guardsBuilder, child, valueParam, typeGuard.getType(), typedCasts);
 if (implicitGuard != null) {
 guardsBuilder.string(guardsAnd);
 guardsBuilder.tree(implicitGuard);
 guardsAnd = " && ";
 }
-CodeTree cast = createCast(castBuilder, child, valueParam, typeGuard.getType(), checkMinimumState);
+CodeTree cast = createCast(castBuilder, child, valueParam, typeGuard.getType(), checkMinimumState, typedCasts);
 if (cast != null) {
 castBuilder.tree(cast);
 }
 }
 signatureIndex++;
 }
 return false;
 }
-private CodeTree createTypeGuard(CodeTreeBuilder parent, NodeChildData field, ActualParameter source, TypeData targetType) {
+private CodeTree createTypeGuard(CodeTreeBuilder parent, NodeChildData field, ActualParameter source, TypeData targetType, boolean typedCasts) {
 NodeData node = field.getNodeData();
 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
 TypeData sourceType = source.getTypeSystemType();
 builder.string("!").string(valueName(shortCircuit));
 builder.string(" || ");
 }
 String castMethodName;
+String castTypeName = null;
 List<TypeData> types = getModel().getNode().getTypeSystem().lookupSourceTypes(targetType);
 if (types.size() > 1) {
 castMethodName = TypeSystemCodeGenerator.isImplicitTypeMethodName(targetType);
+if (typedCasts) {
+castTypeName = implicitTypeName(source);
+}
 } else {
 castMethodName = TypeSystemCodeGenerator.isTypeMethodName(targetType);
 }
-startCallTypeSystemMethod(getContext(), builder, node, castMethodName);
+startCallTypeSystemMethod(getContext(), builder, node.getTypeSystem(), castMethodName);
 builder.string(valueName(source));
+if (castTypeName != null) {
+builder.string(castTypeName);
+}
 builder.end().end(); // call
 if (field.isShortCircuit()) {
 builder.string(")");
 }
 builder.end(); // group
 return builder.getRoot();
 }
-private CodeTree createCast(CodeTreeBuilder parent, NodeChildData field, ActualParameter source, TypeData targetType, boolean checkMinimumState) {
+// TODO merge redundancies with #createTypeGuard
+private CodeTree createCast(CodeTreeBuilder parent, NodeChildData field, ActualParameter source, TypeData targetType, boolean checkMinimumState, boolean typedCasts) {
 NodeData node = field.getNodeData();
 TypeData sourceType = source.getTypeSystemType();
 if (!sourceType.needsCastTo(getContext(), targetType)) {
 return null;
 assert shortCircuit != null;
 condition = CodeTreeBuilder.singleString(valueName(shortCircuit));
 }
 String castMethodName;
+String castTypeName = null;
 List<TypeData> types = getModel().getNode().getTypeSystem().lookupSourceTypes(targetType);
 if (types.size() > 1) {
 castMethodName = TypeSystemCodeGenerator.asImplicitTypeMethodName(targetType);
+if (typedCasts) {
+castTypeName = implicitTypeName(source);
+}
 } else {
 castMethodName = TypeSystemCodeGenerator.asTypeMethodName(targetType);
 }
-CodeTree value = createCallTypeSystemMethod(context, parent, node, castMethodName, CodeTreeBuilder.singleString(valueName(source)));
+List<CodeTree> args = new ArrayList<>();
+args.add(CodeTreeBuilder.singleString(valueName(source)));
+if (castTypeName != null) {
+args.add(CodeTreeBuilder.singleString(castTypeName));
+}
+CodeTree value = createCallTypeSystemMethod(context, parent, node, castMethodName, args.toArray(new CodeTree[0]));
 CodeTreeBuilder builder = parent.create();
 builder.tree(createLazyAssignment(parent, castValueName(source), targetType.getPrimitiveType(), condition, value));
 if (checkMinimumState && types.size() > 1) {
 CodeTree castType = createCallTypeSystemMethod(context, parent, node, TypeSystemCodeGenerator.getImplicitClass(targetType), CodeTreeBuilder.singleString(valueName(source)));
-builder.tree(createLazyAssignment(builder, typeName(source), getContext().getType(Class.class), condition, castType));
+builder.tree(createLazyAssignment(builder, implicitTypeName(source), getContext().getType(Class.class), condition, castType));
 }
 return builder.getRoot();
 }
 continue;
 }
 NodeChildData child = getModel().getNode().findChild(param.getSpecification().getName());
 List<TypeData> types = child.getNodeData().getTypeSystem().lookupSourceTypes(param.getTypeSystemType());
 if (types.size() > 1) {
-replaceCall.string(typeName(param));
+replaceCall.string(implicitTypeName(param));
 }
 }
 replaceCall.end().end();
 if (message == null) {
 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);
+return createCastType(node.getTypeSystem(), sourceType, castedType.getType(), hasUnexpected, value);
 }
 protected CodeTree createExecuteChildren(CodeTreeBuilder parent, ExecutableTypeData sourceExecutable, SpecializationData specialization, List<ActualParameter> targetParameters,
 ActualParameter unexpectedParameter) {
 CodeTreeBuilder builder = parent.create();
 for (ActualParameter targetParameter : targetParameters) {
 NodeChildData child = node.findChild(targetParameter.getSpecification().getName());
 if (!targetParameter.getSpecification().isSignature()) {
 continue;
 }
-TypeData targetType = targetParameter.getTypeSystemType();
+CodeTree executionExpressions = createExecuteChild(builder, child, sourceExecutable, targetParameter, unexpectedParameter);
-ExecutableTypeData targetExecutable = null;
+CodeTree unexpectedTree = createCatchUnexpectedTree(builder, executionExpressions, specialization, sourceExecutable, targetParameter, isShortCircuit(child), unexpectedParameter);
-if (child != null) {
+CodeTree shortCircuitTree = createShortCircuitTree(builder, unexpectedTree, specialization, targetParameter, unexpectedParameter);
-targetExecutable = child.findExecutableType(getContext(), targetType);
-}
-if (targetExecutable == null) {
-// TODO what to do? assertion?
-continue;
-}
-CodeTree executionExpressions = createExecutionExpresssions(builder, child, sourceExecutable, targetExecutable, targetParameter, unexpectedParameter);
-String targetVarName = valueName(targetParameter);
-CodeTree unexpectedTree = createCatchUnexpectedTree(builder, executionExpressions, targetVarName, specialization, sourceExecutable, targetExecutable, targetParameter,
-isShortCircuit(child));
-CodeTree shortCircuitTree = createShortCircuitTree(builder, unexpectedTree, targetVarName, specialization, targetParameter, unexpectedParameter);
 if (shortCircuitTree == executionExpressions) {
 if (containsNewLine(executionExpressions)) {
-builder.declaration(sourceExecutable.getType().getPrimitiveType(), targetVarName);
+builder.declaration(targetParameter.getType(), valueName(targetParameter));
 builder.tree(shortCircuitTree);
 } else {
 builder.startStatement().type(targetParameter.getType()).string(" ").tree(shortCircuitTree).end();
 }
 } else {
 }
 return builder.getRoot();
 }
-private CodeTree createExecutionExpresssions(CodeTreeBuilder parent, NodeChildData child, ExecutableTypeData sourceExecutable, ExecutableTypeData targetExecutable, ActualParameter param,
+private ExecutableTypeData resolveExecutableType(NodeChildData child, TypeData type) {
-ActualParameter unexpectedParameter) {
+ExecutableTypeData targetExecutable = child.findExecutableType(getContext(), type);
+if (targetExecutable == null) {
+targetExecutable = child.findAnyGenericExecutableType(getContext());
+}
+return targetExecutable;
+}
+private CodeTree createExecuteChild(CodeTreeBuilder parent, NodeChildData child, ExecutableTypeData sourceExecutable, ActualParameter targetParameter, ActualParameter unexpectedParameter) {
+SpecializationData specialization = getModel();
+if (specialization.isPolymorphic() && targetParameter.getTypeSystemType().isGeneric() && unexpectedParameter == null) {
+TreeSet<TypeData> possiblePolymorphicTypes = lookupPolymorphicTargetTypes(targetParameter);
+CodeTreeBuilder builder = parent.create();
+boolean elseIf = false;
+for (TypeData possiblePolymoprhicType : possiblePolymorphicTypes) {
+if (possiblePolymoprhicType.isGeneric()) {
+continue;
+}
+elseIf = builder.startIf(elseIf);
+ActualParameter sourceParameter = sourceExecutable.findParameter(targetParameter.getLocalName());
+TypeData sourceType = sourceParameter != null ? sourceParameter.getTypeSystemType() : null;
+builder.string(polymorphicTypeName(targetParameter)).string(" == ").typeLiteral(possiblePolymoprhicType.getPrimitiveType());
+builder.end().startBlock();
+builder.startStatement();
+builder.tree(createExecuteChildExpression(parent, child, sourceType, new ActualParameter(targetParameter, possiblePolymoprhicType), unexpectedParameter, null));
+builder.end();
+builder.end();
+}
+builder.startElseBlock();
+builder.startStatement().tree(createExecuteChildImplicit(parent, child, sourceExecutable, targetParameter, unexpectedParameter)).end();
+builder.end();
+return builder.getRoot();
+} else {
+return createExecuteChildImplicit(parent, child, sourceExecutable, targetParameter, unexpectedParameter);
+}
+}
+protected final TreeSet<TypeData> lookupPolymorphicTargetTypes(ActualParameter param) {
+SpecializationData specialization = getModel();
+TreeSet<TypeData> possiblePolymorphicTypes = new TreeSet<>();
+for (SpecializationData otherSpecialization : specialization.getNode().getSpecializations()) {
+if (!otherSpecialization.isSpecialized()) {
+continue;
+}
+ActualParameter otherParameter = otherSpecialization.findParameter(param.getLocalName());
+if (otherParameter != null) {
+possiblePolymorphicTypes.add(otherParameter.getTypeSystemType());
+}
+}
+return possiblePolymorphicTypes;
+}
+private CodeTree createExecuteChildImplicit(CodeTreeBuilder parent, NodeChildData child, ExecutableTypeData sourceExecutable, ActualParameter param, ActualParameter unexpectedParameter) {
 CodeTreeBuilder builder = parent.create();
 ActualParameter sourceParameter = sourceExecutable.findParameter(param.getLocalName());
 String childExecuteName = createExecuteChildMethodName(param, sourceParameter != null);
 if (childExecuteName != null) {
 builder.string(valueName(param));
 builder.string(" = ");
 builder.startCall(childExecuteName);
 if (sourceParameter != null) {
 builder.string(valueNameEvaluated(sourceParameter));
 }
-builder.string(typeName(param));
+builder.string(implicitTypeName(param));
 builder.end();
 } else {
 List<TypeData> sourceTypes = child.getNodeData().getTypeSystem().lookupSourceTypes(param.getTypeSystemType());
 TypeData expectType = sourceParameter != null ? sourceParameter.getTypeSystemType() : null;
 if (sourceTypes.size() > 1) {
-builder.tree(createExecuteExpressions(parent, param, expectType));
+builder.tree(createExecuteChildImplicitExpressions(parent, param, expectType));
 } else {
-builder.tree(createExecuteExpression(parent, child, expectType, targetExecutable, param, unexpectedParameter, null));
+builder.tree(createExecuteChildExpression(parent, child, expectType, param, unexpectedParameter, null));
 }
 }
 return builder.getRoot();
 }
 method.getThrownTypes().add(getContext().getTruffleTypes().getUnexpectedValueException());
 method.addParameter(new CodeVariableElement(getContext().getTruffleTypes().getFrame(), "frameValue"));
 if (expectType != null) {
 method.addParameter(new CodeVariableElement(expectType.getPrimitiveType(), valueNameEvaluated(param)));
 }
-method.addParameter(new CodeVariableElement(getContext().getType(Class.class), typeName(param)));
+method.addParameter(new CodeVariableElement(getContext().getType(Class.class), implicitTypeName(param)));
 CodeTreeBuilder builder = method.createBuilder();
 builder.declaration(param.getType(), valueName(param));
-builder.tree(createExecuteExpressions(builder, param, expectType));
+builder.tree(createExecuteChildImplicitExpressions(builder, param, expectType));
 builder.startReturn().string(valueName(param)).end();
 return method;
 }
-private CodeTree createExecuteExpressions(CodeTreeBuilder parent, ActualParameter param, TypeData expectType) {
+private CodeTree createExecuteChildImplicitExpressions(CodeTreeBuilder parent, ActualParameter targetParameter, TypeData expectType) {
 CodeTreeBuilder builder = parent.create();
 NodeData node = getModel().getNode();
-NodeChildData child = node.findChild(param.getSpecification().getName());
+NodeChildData child = node.findChild(targetParameter.getSpecification().getName());
-List<TypeData> sourceTypes = node.getTypeSystem().lookupSourceTypes(param.getTypeSystemType());
+List<TypeData> sourceTypes = node.getTypeSystem().lookupSourceTypes(targetParameter.getTypeSystemType());
 boolean elseIf = false;
 int index = 0;
 for (TypeData sourceType : sourceTypes) {
 if (index < sourceTypes.size() - 1) {
 elseIf = builder.startIf(elseIf);
-builder.string(typeName(param)).string(" == ").typeLiteral(sourceType.getPrimitiveType());
+builder.string(implicitTypeName(targetParameter)).string(" == ").typeLiteral(sourceType.getPrimitiveType());
 builder.end();
 builder.startBlock();
 } else {
 builder.startElseBlock();
 }
-ExecutableTypeData implictExecutableTypeData = child.getNodeData().findExecutableType(sourceType, child.getExecuteWith().size());
+ExecutableTypeData implictExecutableTypeData = child.findExecutableType(getContext(), sourceType);
 if (implictExecutableTypeData == null) {
 /*
 * For children with executeWith.size() > 0 an executable type may not exist so
 * use the generic executable type which is guaranteed to exist. An expect call
 * is inserted automatically by #createExecuteExpression.
 */
 implictExecutableTypeData = child.getNodeData().findExecutableType(node.getTypeSystem().getGenericTypeData(), child.getExecuteWith().size());
 }
-ImplicitCastData cast = child.getNodeData().getTypeSystem().lookupCast(sourceType, param.getTypeSystemType());
+ImplicitCastData cast = child.getNodeData().getTypeSystem().lookupCast(sourceType, targetParameter.getTypeSystemType());
-CodeTree execute = createExecuteExpression(builder, child, expectType, implictExecutableTypeData, param, null, cast);
+CodeTree execute = createExecuteChildExpression(builder, child, expectType, targetParameter, null, cast);
 builder.statement(execute);
 builder.end();
 index++;
 }
 return builder.getRoot();
 }
-private CodeTree createExecuteExpression(CodeTreeBuilder parent, NodeChildData child, TypeData expectType, ExecutableTypeData targetExecutable, ActualParameter targetParameter,
+private CodeTree createExecuteChildExpression(CodeTreeBuilder parent, NodeChildData child, TypeData sourceParameterType, ActualParameter targetParameter, ActualParameter unexpectedParameter,
-ActualParameter unexpectedParameter, ImplicitCastData cast) {
+ImplicitCastData cast) {
+// assignments: targetType <- castTargetType <- castSourceType <- sourceType
+TypeData sourceType = sourceParameterType;
+TypeData targetType = targetParameter.getTypeSystemType();
+TypeData castSourceType = targetType;
+TypeData castTargetType = targetType;
+if (cast != null) {
+castSourceType = cast.getSourceType();
+castTargetType = cast.getTargetType();
+}
+CodeTree expression;
+if (sourceType == null) {
+ExecutableTypeData targetExecutable = resolveExecutableType(child, targetType);
+expression = createExecuteChildExpression(parent, child, targetParameter, targetExecutable, unexpectedParameter);
+sourceType = targetExecutable.getType();
+} else {
+expression = CodeTreeBuilder.singleString(valueNameEvaluated(targetParameter));
+}
+// target = expectTargetType(implicitCast(expectCastSourceType(source)))
+TypeSystemData typeSystem = child.getNodeData().getTypeSystem();
+expression = createExpectType(typeSystem, sourceType, castSourceType, expression);
+expression = createImplicitCast(parent, typeSystem, cast, expression);
+expression = createExpectType(typeSystem, castTargetType, targetType, expression);
 CodeTreeBuilder builder = parent.create();
 builder.string(valueName(targetParameter));
 builder.string(" = ");
-if (cast != null) {
+builder.tree(expression);
-startCallTypeSystemMethod(getContext(), builder, child.getNodeData(), cast.getMethodName());
+return builder.getRoot();
 }
-TypeData expectTarget = targetParameter.getTypeSystemType();
+private CodeTree createImplicitCast(CodeTreeBuilder parent, TypeSystemData typeSystem, ImplicitCastData cast, CodeTree expression) {
-if (cast != null) {
+if (cast == null) {
-expectTarget = cast.getSourceType();
+return expression;
 }
+CodeTreeBuilder builder = parent.create();
-if (targetExecutable.getType().needsCastTo(context, expectTarget)) {
+startCallTypeSystemMethod(getContext(), builder, typeSystem, cast.getMethodName());
-startCallTypeSystemMethod(getContext(), builder, child.getNodeData(), TypeSystemCodeGenerator.expectTypeMethodName(expectTarget));
+builder.tree(expression);
-}
+builder.end().end();
-NodeData node = getModel().getNode();
-if (expectType == null) {
-builder.tree(createExecuteChildExpression(builder, child, targetParameter, targetExecutable, unexpectedParameter));
-} else {
-CodeTree var = CodeTreeBuilder.singleString(valueNameEvaluated(targetParameter));
-builder.tree(createExpectExecutableType(node, expectType, targetExecutable, var));
-}
-if (targetExecutable.getType().needsCastTo(context, targetParameter.getTypeSystemType())) {
-builder.end().end();
-}
-if (cast != null) {
-builder.end().end();
-}
 return builder.getRoot();
 }
 private boolean containsNewLine(CodeTree tree) {
 if (tree.getCodeKind() == CodeTreeKind.NEW_LINE) {
 }
 }
 return false;
 }
-private boolean hasUnexpected(ExecutableTypeData target, ActualParameter sourceParameter, ActualParameter targetParameter) {
+private boolean hasUnexpected(ActualParameter sourceParameter, ActualParameter targetParameter, ActualParameter unexpectedParameter) {
-List<TypeData> types = getModel().getNode().getTypeSystem().lookupSourceTypes(targetParameter.getTypeSystemType());
 NodeChildData child = getModel().getNode().findChild(targetParameter.getSpecification().getName());
-boolean hasUnexpected = false;
-for (TypeData type : types) {
+if (getModel().isPolymorphic() && targetParameter.getTypeSystemType().isGeneric() && unexpectedParameter == null) {
-if (hasUnexpected) {
+// check for other polymorphic types
-continue;
+for (TypeData polymorphicTargetType : lookupPolymorphicTargetTypes(targetParameter)) {
-}
+if (hasUnexpectedType(child, sourceParameter, polymorphicTargetType)) {
-ExecutableTypeData execTarget = target;
+return true;
-if (type != execTarget.getType()) {
+}
-execTarget = child.findExecutableType(getContext(), type);
+}
 }
-hasUnexpected = hasUnexpected || hasUnexpectedType(execTarget, sourceParameter, type);
-}
+if (hasUnexpectedType(child, sourceParameter, targetParameter.getTypeSystemType())) {
-return hasUnexpected;
-}
-private boolean hasUnexpectedType(ExecutableTypeData target, ActualParameter sourceParameter, TypeData type) {
-boolean targetCast = target.getType().needsCastTo(context, type);
-if (targetCast && getModel().getNode().getTypeSystem().lookupCast(target.getType(), type) == null) {
 return true;
 }
-if (sourceParameter == null) {
+return false;
-return target.hasUnexpectedValue(getContext());
+}
-} else {
-if (sourceParameter.getTypeSystemType().needsCastTo(getContext(), type)) {
+private boolean hasUnexpectedType(NodeChildData child, ActualParameter sourceParameter, TypeData targetType) {
-return target.hasUnexpectedValue(getContext());
+List<TypeData> implicitSourceTypes = getModel().getNode().getTypeSystem().lookupSourceTypes(targetType);
-}
-return false;
+for (TypeData implicitSourceType : implicitSourceTypes) {
-}
+TypeData sourceType;
-}
+if (sourceParameter != null) {
+sourceType = sourceParameter.getTypeSystemType();
-private CodeTree createCatchUnexpectedTree(CodeTreeBuilder parent, CodeTree body, String targetVariableName, SpecializationData specialization, ExecutableTypeData currentExecutable,
+} else {
-ExecutableTypeData targetExecutable, ActualParameter param, boolean shortCircuit) {
+ExecutableTypeData targetExecutable = resolveExecutableType(child, implicitSourceType);
+if (targetExecutable.hasUnexpectedValue(getContext())) {
+return true;
+}
+sourceType = targetExecutable.getType();
+}
+ImplicitCastData cast = getModel().getNode().getTypeSystem().lookupCast(implicitSourceType, targetType);
+if (cast != null) {
+if (cast.getSourceType().needsCastTo(getContext(), targetType)) {
+return true;
+}
+}
+if (sourceType.needsCastTo(getContext(), targetType)) {
+return true;
+}
+}
+return false;
+}
+private CodeTree createCatchUnexpectedTree(CodeTreeBuilder parent, CodeTree body, SpecializationData specialization, ExecutableTypeData currentExecutable, ActualParameter param,
+boolean shortCircuit, ActualParameter unexpectedParameter) {
 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
 ActualParameter sourceParameter = currentExecutable.findParameter(param.getLocalName());
-boolean unexpected = hasUnexpected(targetExecutable, sourceParameter, param);
+boolean unexpected = hasUnexpected(sourceParameter, param, unexpectedParameter);
 if (!unexpected) {
 return body;
 }
 if (!shortCircuit) {
-builder.declaration(param.getType(), targetVariableName);
+builder.declaration(param.getType(), valueName(param));
 }
 builder.startTryBlock();
 if (containsNewLine(body)) {
 builder.tree(body);
 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));
 if (specialization.isPolymorphic()) {
 builder.tree(createReturnOptimizeTypes(builder, currentExecutable, specialization, param));
 } else {
 builder.tree(createReturnExecuteAndSpecialize(builder, currentExecutable, specialization, param,
 NodeData node = specialization.getNode();
 assert !node.getPolymorphicSpecializations().isEmpty();
 SpecializationData generic = node.getGenericPolymorphicSpecialization();
 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+builder.startStatement().string(polymorphicTypeName(param)).string(" = ").typeLiteral(getContext().getType(Object.class)).end();
 builder.startReturn();
 CodeTreeBuilder execute = new CodeTreeBuilder(builder);
 execute.startCall("next0", executeCachedName(generic));
 addInternalValueParameterNames(execute, specialization, generic, param.getLocalName(), true, true, null);
 builder.string("[" + targetParameter.getIndex() + "]");
 }
 return builder.getRoot();
 }
-private CodeTree createShortCircuitTree(CodeTreeBuilder parent, CodeTree body, String targetVariableName, SpecializationData specialization, ActualParameter parameter,
+private CodeTree createShortCircuitTree(CodeTreeBuilder parent, CodeTree body, SpecializationData specialization, ActualParameter parameter, ActualParameter exceptionParam) {
-ActualParameter exceptionParam) {
 NodeChildData forField = specialization.getNode().findChild(parameter.getSpecification().getName());
 if (!isShortCircuit(forField)) {
 return body;
 }
 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
 ActualParameter shortCircuitParam = specialization.getPreviousParam(parameter);
 builder.tree(createShortCircuitValue(builder, specialization, forField, shortCircuitParam, exceptionParam));
-builder.declaration(parameter.getType(), targetVariableName, CodeTreeBuilder.createBuilder().defaultValue(parameter.getType()));
+builder.declaration(parameter.getType(), valueName(parameter), CodeTreeBuilder.createBuilder().defaultValue(parameter.getType()));
 builder.startIf().string(shortCircuitParam.getLocalName()).end();
 builder.startBlock();
 if (containsNewLine(body)) {
 builder.tree(body);
 builder.tree(createExpectExecutableType(node, generic.getReturnType().getTypeSystemType(), executable, specializeCall.getRoot()));
 builder.end();
 return builder.getRoot();
 }
+protected final CodeExecutableElement createUpdateTypes(TypeMirror polymorphicType) {
+CodeExecutableElement method = new CodeExecutableElement(modifiers(PROTECTED), getContext().getType(void.class), UPDATE_TYPES_NAME);
+method.getParameters().add(new CodeVariableElement(polymorphicType, "polymorphic"));
+CodeTreeBuilder builder = method.createBuilder();
+if (getModel().isPolymorphic()) {
+builder.startStatement();
+builder.startCall("next0", "updateTypes").string("polymorphic").end();
+builder.end();
+} else if (getModel().isSpecialized()) {
+for (ActualParameter parameter : getModel().getParameters()) {
+if (!parameter.getSpecification().isSignature()) {
+continue;
+}
+if (lookupPolymorphicTargetTypes(parameter).size() <= 1) {
+continue;
+}
+builder.startStatement();
+builder.startCall("polymorphic", createUpdateTypeName(parameter));
+builder.typeLiteral(parameter.getType());
+builder.end().end();
+}
+builder.startStatement().startCall("super", UPDATE_TYPES_NAME).string("polymorphic").end().end();
+}
+return method;
+}
+protected String createUpdateTypeName(ActualParameter parameter) {
+return "update" + Utils.firstLetterUpperCase(parameter.getLocalName()) + "Type";
+}
 }
 private class PolymorphicNodeFactory extends SpecializedNodeFactory {
-private final boolean generic;
+public PolymorphicNodeFactory(ProcessorContext context, CodeTypeElement nodeGen) {
-public PolymorphicNodeFactory(ProcessorContext context, CodeTypeElement nodeGen, boolean generic) {
 super(context, nodeGen);
-this.generic = generic;
+}
+@Override
+public CodeTypeElement create(SpecializationData polymorph) {
+NodeData node = polymorph.getNode();
+TypeMirror baseType = node.getNodeType();
+if (nodeGen != null) {
+baseType = nodeGen.asType();
+}
+CodeTypeElement clazz = createClass(node, modifiers(PRIVATE, STATIC, FINAL), nodePolymorphicClassName(node, polymorph), baseType, false);
+clazz.getAnnotationMirrors().add(createNodeInfo(node, Kind.POLYMORPHIC));
+for (ActualParameter polymorphParameter : polymorph.getParameters()) {
+if (!polymorphParameter.getSpecification().isSignature()) {
+continue;
+}
+if (!polymorphParameter.getTypeSystemType().isGeneric()) {
+continue;
+}
+Set<TypeData> types = new HashSet<>();
+for (SpecializationData specialization : node.getSpecializations()) {
+if (!specialization.isSpecialized()) {
+continue;
+}
+ActualParameter parameter = specialization.findParameter(polymorphParameter.getLocalName());
+assert parameter != null;
+types.add(parameter.getTypeSystemType());
+}
+CodeVariableElement var = new CodeVariableElement(modifiers(PRIVATE), getContext().getType(Class.class), polymorphicTypeName(polymorphParameter));
+var.getAnnotationMirrors().add(new CodeAnnotationMirror(getContext().getTruffleTypes().getCompilationFinal()));
+clazz.add(var);
+}
+return clazz;
+}
+@Override
+protected void createChildren(SpecializationData specialization) {
+CodeTypeElement clazz = getElement();
+createConstructors(clazz);
+createExecuteMethods(specialization);
+getElement().add(createUpdateTypes(nodeGen.asType()));
+for (ActualParameter parameter : specialization.getParameters()) {
+if (!parameter.getSpecification().isSignature()) {
+continue;
+}
+if (lookupPolymorphicTargetTypes(parameter).size() <= 1) {
+continue;
+}
+getElement().add(createUpdateType(parameter));
+}
+createCachedExecuteMethods(specialization);
+}
+private ExecutableElement createUpdateType(ActualParameter parameter) {
+CodeExecutableElement method = new CodeExecutableElement(modifiers(PROTECTED), getContext().getType(void.class), createUpdateTypeName(parameter));
+method.getParameters().add(new CodeVariableElement(getContext().getType(Class.class), "type"));
+CodeTreeBuilder builder = method.createBuilder();
+String fieldName = polymorphicTypeName(parameter);
+builder.startIf().string(fieldName).isNull().end().startBlock();
+builder.startStatement().string(fieldName).string(" = ").string("type").end();
+builder.end();
+builder.startElseIf().string(fieldName).string(" != ").string("type").end();
+builder.startBlock();
+builder.startStatement().string(fieldName).string(" = ").typeLiteral(getContext().getType(Object.class)).end();
+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), 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) {
-CodeTypeElement clazz = getElement();
-createConstructors(clazz);
-createExecuteMethods(specialization);
-if (generic) {
-getElement().add(createOptimizeTypes());
-createCachedExecuteMethods(specialization);
-createIsCompatible(clazz, specialization);
-}
-}
-private CodeExecutableElement createOptimizeTypes() {
-NodeData node = getModel().getNode();
-CodeExecutableElement method = new CodeExecutableElement(modifiers(PROTECTED, FINAL), getContext().getType(void.class), "optimizeTypes");
-CodeTreeBuilder builder = method.createBuilder();
-boolean elseIf = false;
-for (SpecializationData polymorphic : node.getPolymorphicSpecializations()) {
-String className = nodePolymorphicClassName(node, polymorphic);
-String sep = "";
-StringBuilder reason = new StringBuilder("Optimized polymorphic types for (");
-for (ActualParameter parameter : polymorphic.getReturnTypeAndParameters()) {
-if (!parameter.getSpecification().isSignature()) {
-continue;
-}
-reason.append(sep).append(Utils.getSimpleName(parameter.getType()));
-sep = ", ";
-}
-reason.append(")");
-elseIf = builder.startIf(elseIf);
-builder.startCall("isCompatible0");
-builder.startGroup().string(className).string(".class").end();
-builder.end().end().startBlock();
-builder.startStatement().startCall("super", "replace");
-builder.startNew(className).string("this").end();
-builder.doubleQuote(reason.toString());
-builder.end().end(); // call
-builder.end();
-}
-return method;
-}
-}
-private class BaseCastNodeFactory extends ClassElementFactory<NodeData> {
-protected final Set<TypeData> usedTargetTypes;
-public BaseCastNodeFactory(ProcessorContext context, Set<TypeData> usedTargetTypes) {
-super(context);
-this.usedTargetTypes = usedTargetTypes;
-}
-@Override
-protected CodeTypeElement create(NodeData m) {
-CodeTypeElement type = createClass(m, modifiers(STATIC), nodeCastClassName(m, null), context.getTruffleTypes().getNode(), false);
-CodeVariableElement delegate = new CodeVariableElement(m.getNodeType(), "delegate");
-delegate.getModifiers().add(PROTECTED);
-delegate.getAnnotationMirrors().add(new CodeAnnotationMirror(getContext().getTruffleTypes().getChildAnnotation()));
-type.add(delegate);
-type.add(createConstructorUsingFields(modifiers(), type));
-return type;
-}
-@Override
-protected void createChildren(NodeData m) {
-CodeTypeElement type = getElement();
-type.add(createExecute(EXECUTE_SPECIALIZE_NAME, true));
-type.add(createExecute(EXECUTE_GENERIC_NAME, false));
-for (ExecutableTypeData targetExecutable : m.getExecutableTypes()) {
-if (!usedTargetTypes.contains(targetExecutable.getType()) && targetExecutable.hasUnexpectedValue(getContext())) {
-continue;
-}
-CodeExecutableElement execute = createCastExecute(targetExecutable, targetExecutable, false);
-CodeExecutableElement expect = createCastExecute(targetExecutable, targetExecutable, true);
-if (execute != null) {
-getElement().add(execute);
-}
-if (expect != null) {
-getElement().add(expect);
-}
-}
-Set<TypeData> sourceTypes = new TreeSet<>();
-List<ImplicitCastData> casts = getModel().getTypeSystem().getImplicitCasts();
-for (ImplicitCastData cast : casts) {
-sourceTypes.add(cast.getSourceType());
-}
-CodeTypeElement baseType = getElement();
-for (TypeData sourceType : sourceTypes) {
-add(new SpecializedCastNodeFactory(context, baseType, sourceType, usedTargetTypes), getModel());
-}
-}
-private CodeExecutableElement createExecute(String name, boolean specialize) {
-NodeData node = getModel();
-TypeMirror objectType = node.getTypeSystem().getGenericType();
-CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC), objectType, name, new CodeVariableElement(objectType, "value"));
-if (specialize) {
-method.getModifiers().add(FINAL);
-}
-CodeTreeBuilder builder = method.createBuilder();
-List<ImplicitCastData> casts = node.getTypeSystem().getImplicitCasts();
-boolean elseIf = false;
-for (ImplicitCastData cast : casts) {
-elseIf = builder.startIf(elseIf);
-startCallTypeSystemMethod(context, builder, getModel(), TypeSystemCodeGenerator.isTypeMethodName(cast.getSourceType()));
-builder.string("value");
-builder.end().end();
-builder.end();
-builder.startBlock();
-if (specialize) {
-builder.startStatement().startCall("replace").startNew(nodeCastClassName(getModel(), cast.getSourceType())).string("delegate").end().doubleQuote("Added cast").end().end();
-}
-builder.startReturn();
-startCallTypeSystemMethod(context, builder, getModel(), cast.getMethodName());
-startCallTypeSystemMethod(context, builder, getModel(), TypeSystemCodeGenerator.asTypeMethodName(cast.getSourceType()));
-builder.string("value");
-builder.end().end();
-builder.end().end();
-builder.end();
-builder.end();
-}
-builder.startReturn().string("value").end();
-return method;
-}
-protected CodeExecutableElement createCastExecute(ExecutableTypeData sourceExecutable, ExecutableTypeData targetExecutable, boolean expect) {
-ImplicitCastData cast = null;
-if (!sourceExecutable.getType().equals(targetExecutable.getType())) {
-cast = getModel().getTypeSystem().lookupCast(sourceExecutable.getType(), targetExecutable.getType());
-if (cast == null) {
-return null;
-}
-}
-if (expect) {
-if (targetExecutable.getEvaluatedCount() > 0) {
-return null;
-} else if (Utils.isObject(targetExecutable.getType().getPrimitiveType())) {
-return null;
-}
-}
-boolean hasTargetUnexpected = targetExecutable.hasUnexpectedValue(getContext());
-boolean hasSourceUnexpected = sourceExecutable.hasUnexpectedValue(getContext());
-CodeExecutableElement method = copyTemplateMethod(targetExecutable);
-method.getModifiers().add(PUBLIC);
-CodeTreeBuilder builder = method.createBuilder();
-if (hasSourceUnexpected && cast != null) {
-builder.startTryBlock();
-}
-if (expect) {
-method.getParameters().clear();
-String expectMethodName;
-if (hasTargetUnexpected) {
-expectMethodName = TypeSystemCodeGenerator.expectTypeMethodName(targetExecutable.getType());
-} else {
-expectMethodName = TypeSystemCodeGenerator.asTypeMethodName(targetExecutable.getType());
-}
-method.setSimpleName(CodeNames.of(expectMethodName));
-method.addParameter(new CodeVariableElement(getModel().getTypeSystem().getGenericType(), "value"));
-}
-builder.startReturn();
-CodeTree executeCall;
-if (expect) {
-executeCall = createCastType(getModel(), getModel().getTypeSystem().getGenericTypeData(), sourceExecutable.getType(), hasSourceUnexpected, CodeTreeBuilder.singleString("value"));
-} else {
-executeCall = createTemplateMethodCall(builder, CodeTreeBuilder.singleString("delegate."), targetExecutable, sourceExecutable, null);
-}
-if (cast != null) {
-startCallTypeSystemMethod(context, builder, getModel(), cast.getMethodName());
-builder.tree(executeCall);
-builder.end().end();
-} else {
-builder.tree(executeCall);
-}
-builder.end();
-if (hasSourceUnexpected && cast != null) {
-builder.end();
-builder.startCatchBlock(getContext().getTruffleTypes().getUnexpectedValueException(), "ex");
-builder.startStatement().startCall("replace").startNew(nodeCastClassName(getModel(), null)).string("delegate").end().doubleQuote("Removed cast").end().end();
-if (hasTargetUnexpected) {
-builder.startThrow().string("ex").end();
-} else {
-builder.startThrow().startNew(getContext().getType(AssertionError.class)).end().end();
-}
-builder.end();
-}
-return method;
-}
-private CodeExecutableElement copyTemplateMethod(TemplateMethod targetExecutable) {
-CodeExecutableElement method = CodeExecutableElement.clone(getContext().getEnvironment(), targetExecutable.getMethod());
-method.getModifiers().remove(ABSTRACT);
-method.getAnnotationMirrors().clear();
-Modifier visibility = Utils.getVisibility(method.getModifiers());
-if (visibility != null) {
-method.getModifiers().remove(visibility);
-}
-int index = 0;
-for (ActualParameter parameter : targetExecutable.getParameters()) {
-((CodeVariableElement) method.getParameters().get(index)).setName(parameter.getLocalName());
-index++;
-}
-return method;
-}
-}
-private class SpecializedCastNodeFactory extends BaseCastNodeFactory {
-private final CodeTypeElement baseType;
-private final TypeData sourceType;
-public SpecializedCastNodeFactory(ProcessorContext context, CodeTypeElement baseType, TypeData type, Set<TypeData> usedTargetTypes) {
-super(context, usedTargetTypes);
-this.baseType = baseType;
-this.sourceType = type;
-}
-@Override
-protected CodeTypeElement create(NodeData m) {
-CodeTypeElement type = createClass(m, modifiers(PRIVATE, STATIC, FINAL), nodeCastClassName(m, sourceType), baseType.asType(), false);
-type.add(createConstructorUsingFields(modifiers(), type));
-return type;
-}
-@Override
-protected void createChildren(NodeData node) {
-for (TypeData targetType : usedTargetTypes) {
-for (ExecutableTypeData targetExecutable : node.getExecutableTypes()) {
-if (targetExecutable.getType().equals(targetType)) {
-ExecutableTypeData sourceExecutable = node.findExecutableType(sourceType, targetExecutable.getEvaluatedCount());
-if (sourceExecutable == null) {
-// TODO what if there is no evaluated version?
-continue;
-}
-CodeExecutableElement execute = createCastExecute(sourceExecutable, targetExecutable, false);
-CodeExecutableElement expect = createCastExecute(sourceExecutable, targetExecutable, true);
-if (execute != null) {
-getElement().add(execute);
-}
-if (expect != null) {
-getElement().add(expect);
-}
-}
-}
-}
-}
-}
-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;
 @Override
 protected void createChildren(SpecializationData specialization) {
 CodeTypeElement clazz = getElement();
 createConstructors(clazz);
-NodeData node = specialization.getNode();
-if (node.needsRewrites(getContext()) && node.isPolymorphic()) {
-createIsCompatible(clazz, specialization);
-}
 createExecuteMethods(specialization);
 createCachedExecuteMethods(specialization);
+if (specialization.getNode().isPolymorphic()) {
+getElement().add(createUpdateTypes(nodeGen.asType()));
+}
 }
 protected void createConstructors(CodeTypeElement clazz) {
 TypeElement superTypeElement = Utils.fromTypeMirror(clazz.getSuperclass());
 SpecializationData specialization = getModel();
 continue;
 }
 NodeChildData child = getModel().getNode().findChild(param.getSpecification().getName());
 List<TypeData> types = child.getNodeData().getTypeSystem().lookupSourceTypes(param.getTypeSystemType());
 if (types.size() > 1) {
-clazz.add(new CodeVariableElement(modifiers(PRIVATE, FINAL), getContext().getType(Class.class), typeName(param)));
+clazz.add(new CodeVariableElement(modifiers(PRIVATE, FINAL), getContext().getType(Class.class), implicitTypeName(param)));
-superConstructor.getParameters().add(new CodeVariableElement(getContext().getType(Class.class), typeName(param)));
+superConstructor.getParameters().add(new CodeVariableElement(getContext().getType(Class.class), implicitTypeName(param)));
 builder.startStatement();
-builder.string("this.").string(typeName(param)).string(" = ").string(typeName(param));
+builder.string("this.").string(implicitTypeName(param)).string(" = ").string(implicitTypeName(param));
 builder.end();
 }
 }
 clazz.add(superConstructor);
 }
 }
 protected void createCachedExecuteMethods(SpecializationData specialization) {
 NodeData node = specialization.getNode();
+if (!node.isPolymorphic()) {
+return;
+}
 CodeTypeElement clazz = getElement();
-for (final SpecializationData polymorphic : node.getPolymorphicSpecializations()) {
-if (!specialization.getSignature().isCompatibleTo(polymorphic.getSignature())) {
+final SpecializationData polymorphic = node.getGenericPolymorphicSpecialization();
-continue;
-}
+ExecutableElement executeCached = nodeGen.getMethod(executeCachedName(polymorphic));
-ExecutableElement executeCached = nodeGen.getMethod(executeCachedName(polymorphic));
+// ExecutableTypeData execType = new ExecutableTypeData(polymorphic, executeCached,
-ExecutableTypeData execType = new ExecutableTypeData(polymorphic, executeCached, node.getTypeSystem(), polymorphic.getReturnType().getTypeSystemType());
+// node.getTypeSystem(), polymorphic.getReturnType().getTypeSystemType());
-CodeExecutableElement executeMethod = createExecutableTypeOverride(execType, false);
+ExecutableTypeMethodParser parser = new ExecutableTypeMethodParser(getContext(), node);
-CodeTreeBuilder builder = executeMethod.createBuilder();
+ExecutableTypeData execType = parser.parse(Arrays.asList(executeCached)).get(0);
-if (specialization.isGeneric() || specialization.isPolymorphic()) {
+CodeExecutableElement executeMethod = createExecutableTypeOverride(execType, false);
-builder.startThrow().startNew(getContext().getType(AssertionError.class));
+CodeTreeBuilder builder = executeMethod.createBuilder();
-builder.doubleQuote("Should not be reached.");
-builder.end().end();
+if (specialization.isGeneric() || specialization.isPolymorphic()) {
-} else if (specialization.isUninitialized()) {
+builder.startThrow().startNew(getContext().getType(AssertionError.class));
-builder.tree(createAppendPolymorphic(builder, specialization));
+builder.doubleQuote("Should not be reached.");
-} else {
+builder.end().end();
-CodeTreeBuilder elseBuilder = new CodeTreeBuilder(builder);
+} else if (specialization.isUninitialized()) {
-elseBuilder.startReturn().startCall("this.next0", executeCachedName(polymorphic));
+builder.tree(createAppendPolymorphic(builder, specialization));
-addInternalValueParameterNames(elseBuilder, polymorphic, polymorphic, null, true, true, null);
+} else {
-elseBuilder.end().end();
+CodeTreeBuilder elseBuilder = new CodeTreeBuilder(builder);
+elseBuilder.startReturn().startCall("this.next0", executeCachedName(polymorphic));
-boolean forceElse = specialization.getExceptions().size() > 0;
+addInternalValueParameterNames(elseBuilder, polymorphic, polymorphic, null, true, true, null);
-builder.tree(createExecuteTree(builder, polymorphic, SpecializationGroup.create(specialization), false, new CodeBlock<SpecializationData>() {
+elseBuilder.end().end();
-public CodeTree create(CodeTreeBuilder b, SpecializationData current) {
+boolean forceElse = specialization.getExceptions().size() > 0;
-return createGenericInvoke(b, polymorphic, current);
+builder.tree(createExecuteTree(builder, polymorphic, SpecializationGroup.create(specialization), false, new CodeBlock<SpecializationData>() {
-}
-}, elseBuilder.getRoot(), forceElse, true));
+public CodeTree create(CodeTreeBuilder b, SpecializationData current) {
-}
+return createGenericInvoke(b, polymorphic, current);
-clazz.add(executeMethod);
+}
-}
+}, elseBuilder.getRoot(), forceElse, true, true));
+}
+clazz.add(executeMethod);
 }
 private CodeTree createAppendPolymorphic(CodeTreeBuilder parent, SpecializationData specialization) {
 NodeData node = specialization.getNode();
 specializeCall.startGroup().doubleQuote("Uninitialized polymorphic (").string(" + depth + ").doubleQuote("/" + node.getPolymorphicDepth() + ")").end();
 specializeCall.end().end();
 builder.declaration(node.getGenericSpecialization().getReturnType().getType(), "result", specializeCall.getRoot());
+CodeTree root = builder.create().cast(nodePolymorphicClassName(node, node.getGenericPolymorphicSpecialization())).string("root").getRoot();
 builder.startIf().string("this.next0 != null").end().startBlock();
-builder.startStatement().string("(").cast(nodePolymorphicClassName(node, node.getGenericPolymorphicSpecialization())).string("root).optimizeTypes()").end();
+builder.startStatement().string("(").tree(root).string(").").startCall(UPDATE_TYPES_NAME).tree(root).end().end();
 builder.end();
 if (Utils.isVoid(builder.findMethod().getReturnType())) {
 builder.returnStatement();
 } else {
 builder.tree(createExecuteTree(builder, specialization, SpecializationGroup.create(specialization), false, new CodeBlock<SpecializationData>() {
 public CodeTree create(CodeTreeBuilder b, SpecializationData current) {
 return createExecute(b, executable, specialization);
 }
-}, returnSpecialized, false, false));
+}, returnSpecialized, false, false, false));
 return builder.getRoot();
 }
 private CodeTree createExecute(CodeTreeBuilder parent, ExecutableTypeData executable, SpecializationData specialization) {

Mercurial > hg > graal-compiler

comparison graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/node/NodeCodeGenerator.java @ 12395:8e8347ecabbc