Mercurial > hg > truffle

--- a/graal/com.oracle.truffle.api.dsl/src/com/oracle/truffle/api/dsl/internal/DSLOptions.java	Thu Jan 22 20:42:48 2015 +0100
+++ b/graal/com.oracle.truffle.api.dsl/src/com/oracle/truffle/api/dsl/internal/DSLOptions.java	Thu Jan 22 20:44:24 2015 +0100
@@ -34,8 +34,9 @@
 @Target({ElementType.TYPE})
 public @interface DSLOptions {

-    /** Enable the new DSL generation layout. */
-    boolean useNewLayout() default false;
+    /** Flag has no effect anymore. Is going to be removed soon. */
+    @Deprecated
+    boolean useNewLayout() default true;

     /**
      * Lazy class loading ensures that all generated specialization classes are loaded lazily.
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/TruffleTypes.java	Thu Jan 22 20:42:48 2015 +0100
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/TruffleTypes.java	Thu Jan 22 20:44:24 2015 +0100
@@ -44,8 +44,6 @@
  */
 public final class TruffleTypes {

-    public static final String OPTION_DETAILED_REWRITE_REASONS = "DetailedRewriteReasons";
-
     private final DeclaredType node;
     private final ArrayType nodeArray;
     private final TypeMirror unexpectedValueException;
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/generator/GeneratorUtils.java	Thu Jan 22 20:42:48 2015 +0100
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/generator/GeneratorUtils.java	Thu Jan 22 20:44:24 2015 +0100
@@ -35,6 +35,7 @@
 import com.oracle.truffle.api.dsl.*;
 import com.oracle.truffle.api.dsl.internal.DSLOptions.*;
 import com.oracle.truffle.dsl.processor.*;
+import com.oracle.truffle.dsl.processor.java.*;
 import com.oracle.truffle.dsl.processor.java.model.*;
 import com.oracle.truffle.dsl.processor.model.*;

@@ -148,4 +149,46 @@
         return clazz;
     }

+    public static List<ExecutableElement> findUserConstructors(TypeMirror nodeType) {
+        List<ExecutableElement> constructors = new ArrayList<>();
+        for (ExecutableElement constructor : ElementFilter.constructorsIn(ElementUtils.fromTypeMirror(nodeType).getEnclosedElements())) {
+            if (constructor.getModifiers().contains(PRIVATE)) {
+                continue;
+            }
+            if (isCopyConstructor(constructor)) {
+                continue;
+            }
+            constructors.add(constructor);
+        }
+
+        if (constructors.isEmpty()) {
+            constructors.add(new CodeExecutableElement(null, ElementUtils.getSimpleName(nodeType)));
+        }
+
+        return constructors;
+    }
+
+    public static boolean isCopyConstructor(ExecutableElement element) {
+        if (element.getParameters().size() != 1) {
+            return false;
+        }
+        VariableElement var = element.getParameters().get(0);
+        TypeElement enclosingType = ElementUtils.findNearestEnclosingType(var);
+        if (ElementUtils.typeEquals(var.asType(), enclosingType.asType())) {
+            return true;
+        }
+        List<TypeElement> types = ElementUtils.getDirectSuperTypes(enclosingType);
+        for (TypeElement type : types) {
+            if (!(type instanceof CodeTypeElement)) {
+                // no copy constructors which are not generated types
+                return false;
+            }
+
+            if (ElementUtils.typeEquals(var.asType(), type.asType())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
 }
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/generator/NodeBaseFactory.java	Thu Jan 22 20:42:48 2015 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1976 +0,0 @@
-/*
- * Copyright (c) 2014, 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.generator;
-
-import static com.oracle.truffle.dsl.processor.java.ElementUtils.*;
-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.*;
-import com.oracle.truffle.dsl.processor.*;
-import com.oracle.truffle.dsl.processor.java.*;
-import com.oracle.truffle.dsl.processor.java.model.*;
-import com.oracle.truffle.dsl.processor.java.model.CodeTypeMirror.ArrayCodeTypeMirror;
-import com.oracle.truffle.dsl.processor.model.*;
-import com.oracle.truffle.dsl.processor.model.NodeChildData.Cardinality;
-import com.oracle.truffle.dsl.processor.parser.*;
-import com.oracle.truffle.dsl.processor.parser.SpecializationGroup.TypeGuard;
-
-class NodeBaseFactory {
-
-    private static final String THIS_NODE_LOCAL_VAR_NAME = "thisNode";
-
-    static final String EXECUTE_CHAINED = "executeChained0";
-    private static final String SPECIALIZE = "specialize0";
-    private static final String DSLSHARE_REWRITE = "rewrite";
-    private static final String DSLSHARE_FIND_ROOT = "findRoot";
-    private static final String DSLSHARE_REWRITE_TO_POLYMORHPIC = "rewriteToPolymorphic";
-    static final String EXECUTE_UNINITIALIZED = "executeUninitialized0";
-    private static final String REWRITE = "rewrite0";
-    private static final String CREATE_INFO = "createInfo0";
-    static final String CONTAINS_FALLBACK = "containsFallback";
-
-    static final String EMPTY_CLASS_ARRAY = "EMPTY_CLASS_ARRAY";
-
-    static final String METADATA_FIELD_NAME = "METADATA";
-
-    protected final ProcessorContext context;
-    protected final NodeData node;
-    protected final SpecializationData specialization;
-
-    public NodeBaseFactory(ProcessorContext context, NodeData node, SpecializationData specialization) {
-        this.context = context;
-        this.node = node;
-        this.specialization = specialization;
-    }
-
-    public CodeTypeElement create() {
-        CodeTypeElement clazz = GeneratorUtils.createClass(node, null, modifiers(PRIVATE, ABSTRACT), baseClassName(node), node.getNodeType());
-        clazz.getImplements().add(context.getTruffleTypes().getDslNode());
-
-        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(context.getEnvironment(), getter);
-                method.getModifiers().remove(Modifier.ABSTRACT);
-                CodeTreeBuilder builder = method.createBuilder();
-                builder.startReturn().string("this.").string(child.getName()).end();
-                clazz.add(method);
-            }
-        }
-
-        for (NodeFieldData field : node.getFields()) {
-            if (!field.isGenerated()) {
-                continue;
-            }
-
-            clazz.add(new CodeVariableElement(modifiers(PROTECTED, FINAL), field.getType(), field.getName()));
-            if (field.getGetter() != null && field.getGetter().getModifiers().contains(Modifier.ABSTRACT)) {
-                CodeExecutableElement method = CodeExecutableElement.clone(context.getEnvironment(), field.getGetter());
-                method.getModifiers().remove(Modifier.ABSTRACT);
-                method.createBuilder().startReturn().string("this.").string(field.getName()).end();
-                clazz.add(method);
-            }
-        }
-
-        for (String assumption : node.getAssumptions()) {
-            clazz.add(createAssumptionField(assumption));
-        }
-
-        createConstructors(clazz);
-
-        SpecializationGroup rootGroup = createSpecializationGroups(node);
-
-        if (node.needsRewrites(context)) {
-            if (node.isPolymorphic(context)) {
-
-                CodeVariableElement var = new CodeVariableElement(modifiers(PROTECTED), clazz.asType(), "next0");
-                var.getAnnotationMirrors().add(new CodeAnnotationMirror(context.getTruffleTypes().getChildAnnotation()));
-                clazz.add(var);
-
-                CodeExecutableElement genericCachedExecute = createCachedExecute(node.getPolymorphicSpecialization());
-                clazz.add(genericCachedExecute);
-
-            }
-
-            for (CodeExecutableElement method : createImplicitChildrenAccessors()) {
-                clazz.add(method);
-            }
-            clazz.add(createInfoMessage());
-            clazz.add(createMonomorphicRewrite());
-            clazz.add(createCreateSpecializationMethod(rootGroup));
-        }
-
-        clazz.add(createAdoptChildren0());
-        clazz.add(createGetMetadata0(true));
-        clazz.add(createUpdateTypes0());
-        clazz.add(createGetNext());
-
-        return clazz;
-    }
-
-    public static List<ExecutableElement> findUserConstructors(TypeMirror nodeType) {
-        TypeElement type = ElementUtils.fromTypeMirror(nodeType);
-        List<ExecutableElement> constructors = new ArrayList<>();
-        for (ExecutableElement constructor : ElementFilter.constructorsIn(type.getEnclosedElements())) {
-            if (constructor.getModifiers().contains(PRIVATE)) {
-                continue;
-            }
-            if (isCopyConstructor(constructor)) {
-                continue;
-            }
-            constructors.add(constructor);
-        }
-
-        if (constructors.isEmpty()) {
-            CodeExecutableElement executable = new CodeExecutableElement(null, ElementUtils.getSimpleName(nodeType));
-            ElementUtils.setVisibility(executable.getModifiers(), ElementUtils.getVisibility(type.getModifiers()));
-            constructors.add(executable);
-        }
-
-        return constructors;
-    }
-
-    public static boolean isCopyConstructor(ExecutableElement element) {
-        if (element.getParameters().size() != 1) {
-            return false;
-        }
-        VariableElement var = element.getParameters().get(0);
-        TypeElement enclosingType = ElementUtils.findNearestEnclosingType(var);
-        if (ElementUtils.typeEquals(var.asType(), enclosingType.asType())) {
-            return true;
-        }
-        List<TypeElement> types = ElementUtils.getDirectSuperTypes(enclosingType);
-        for (TypeElement type : types) {
-            if (!(type instanceof CodeTypeElement)) {
-                // no copy constructors which are not generated types
-                return false;
-            }
-
-            if (ElementUtils.typeEquals(var.asType(), type.asType())) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    public SpecializationData getSpecialization() {
-        return specialization;
-    }
-
-    private Element createGetNext() {
-        CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC, FINAL), context.getType(Node.class), "getNext0");
-        CodeTreeBuilder builder = method.createBuilder();
-
-        if (node.isPolymorphic(context)) {
-            builder.startReturn().string("next0").end();
-        } else {
-            builder.returnNull();
-        }
-
-        return method;
-    }
-
-    protected final CodeExecutableElement createUpdateTypes0() {
-        ArrayType classArray = new ArrayCodeTypeMirror(context.getType(Class.class));
-        CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC), context.getType(void.class), "updateTypes0");
-        method.getParameters().add(new CodeVariableElement(classArray, "types"));
-
-        if (getSpecialization().isPolymorphic()) {
-            CodeTreeBuilder builder = method.createBuilder();
-
-            int index = 0;
-            for (NodeExecutionData execution : getSpecialization().getNode().getChildExecutions()) {
-                String fieldName = polymorphicTypeName(execution);
-
-                builder.startStatement();
-                builder.string(fieldName).string(" = ").string("types[").string(String.valueOf(index)).string("]");
-                builder.end();
-                index++;
-            }
-        }
-
-        return method;
-    }
-
-    protected final CodeExecutableElement createGetMetadata0(boolean empty) {
-        CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC), context.getTruffleTypes().getDslMetadata(), "getMetadata0");
-        if (empty) {
-            method.createBuilder().startReturn().staticReference(context.getTruffleTypes().getDslMetadata(), "NONE").end();
-        } else {
-            method.createBuilder().startReturn().string(METADATA_FIELD_NAME).end();
-        }
-        return method;
-    }
-
-    private CodeExecutableElement createAdoptChildren0() {
-        CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC, FINAL), context.getType(void.class), "adoptChildren0");
-        method.getParameters().add(new CodeVariableElement(context.getTruffleTypes().getNode(), "other"));
-        method.getParameters().add(new CodeVariableElement(context.getTruffleTypes().getNode(), "newNext"));
-        CodeTreeBuilder builder = method.createBuilder();
-        List<NodeExecutionData> executions = node.getChildExecutions();
-
-        if (executions.size() > 0) {
-            builder.startIf().string("other == null").end().startBlock();
-            for (NodeExecutionData execution : executions) {
-                builder.startStatement().tree(createAccessChild(execution, "this")).string(" = null").end();
-            }
-            builder.end().startElseBlock();
-
-            String access;
-            if (executions.size() > 1) {
-                builder.declaration(baseClassName(node), "otherCast", builder.create().cast(baseClassName(node)).string("other"));
-                access = "otherCast";
-            } else {
-                assert executions.size() == 1;
-                access = "((" + baseClassName(node) + ") other)";
-            }
-            for (NodeExecutionData execution : executions) {
-                builder.startStatement().tree(createAccessChild(execution, "this")).string(" = ").tree(createAccessChild(execution, access)).end();
-            }
-
-            builder.end();
-        }
-
-        if (getSpecialization().getNode().isPolymorphic(context)) {
-            builder.startIf().string("newNext == null").end().startBlock();
-            builder.statement("this.next0 = null");
-            builder.end().startElseBlock();
-            builder.statement("this.next0 = (" + baseClassName(getSpecialization().getNode()) + ") newNext");
-            builder.end();
-        }
-
-        return method;
-    }
-
-    private List<CodeExecutableElement> createImplicitChildrenAccessors() {
-        List<Set<TypeData>> prototype = Collections.nCopies(node.getGenericSpecialization().getParameters().size(), null);
-        List<Set<TypeData>> expectTypes = new ArrayList<>(prototype);
-
-        for (ExecutableTypeData executableType : node.getExecutableTypes()) {
-            for (int i = 0; i < executableType.getEvaluatedCount(); i++) {
-                Parameter parameter = executableType.getSignatureParameter(i);
-                if (i >= expectTypes.size()) {
-                    break;
-                }
-                Set<TypeData> types = expectTypes.get(i);
-                if (types == null) {
-                    types = new TreeSet<>();
-                    expectTypes.set(i, types);
-                }
-                types.add(parameter.getTypeSystemType());
-            }
-        }
-
-        List<CodeExecutableElement> methods = new ArrayList<>();
-        List<Set<TypeData>> visitedList = new ArrayList<>(prototype);
-        for (SpecializationData spec : node.getSpecializations()) {
-            int signatureIndex = -1;
-            for (Parameter param : spec.getParameters()) {
-                if (!param.getSpecification().isSignature()) {
-                    continue;
-                }
-                signatureIndex++;
-                Set<TypeData> visitedTypeData = visitedList.get(signatureIndex);
-                if (visitedTypeData == null) {
-                    visitedTypeData = new TreeSet<>();
-                    visitedList.set(signatureIndex, visitedTypeData);
-                }
-
-                if (visitedTypeData.contains(param.getTypeSystemType())) {
-                    continue;
-                }
-                visitedTypeData.add(param.getTypeSystemType());
-
-                Set<TypeData> expect = expectTypes.get(signatureIndex);
-                if (expect == null) {
-                    expect = Collections.emptySet();
-                }
-
-                methods.addAll(createExecuteChilds(param, expect));
-            }
-        }
-        return methods;
-    }
-
-    private CodeTree truffleBooleanOption(CodeTreeBuilder parent, String name) {
-        CodeTreeBuilder builder = parent.create();
-        builder.staticReference(context.getTruffleTypes().getTruffleOptions(), name);
-        return builder.build();
-    }
-
-    private void addInternalValueParameters(CodeExecutableElement executableMethod, TemplateMethod method, boolean forceFrame, boolean disableFrame, boolean evaluated) {
-        if (forceFrame && !disableFrame && method.getSpecification().findParameterSpec("frame") != null) {
-            executableMethod.addParameter(new CodeVariableElement(context.getTruffleTypes().getFrame(), "frameValue"));
-        }
-        for (Parameter parameter : method.getParameters()) {
-            ParameterSpec spec = parameter.getSpecification();
-            if ((disableFrame || forceFrame) && spec.getName().equals("frame")) {
-                continue;
-            }
-            if (spec.isLocal()) {
-                continue;
-            }
-
-            String name = valueName(parameter);
-            if (evaluated && spec.isSignature()) {
-                name = valueNameEvaluated(parameter);
-            }
-
-            executableMethod.addParameter(new CodeVariableElement(parameter.getType(), name));
-        }
-    }
-
-    private Element createInfoMessage() {
-        CodeExecutableElement method = new CodeExecutableElement(modifiers(PROTECTED, STATIC), context.getType(String.class), CREATE_INFO);
-        method.addParameter(new CodeVariableElement(context.getType(String.class), "message"));
-        addInternalValueParameters(method, node.getGenericSpecialization(), false, false, false);
-
-        CodeTreeBuilder builder = method.createBuilder();
-
-        builder.startIf().tree(truffleBooleanOption(builder, TruffleTypes.OPTION_DETAILED_REWRITE_REASONS)).end();
-        builder.startBlock();
-
-        builder.startStatement().string("StringBuilder builder = new StringBuilder(message)").end();
-        builder.startStatement().startCall("builder", "append").doubleQuote(" (").end().end();
-
-        String sep = null;
-        for (Parameter parameter : node.getGenericSpecialization().getSignatureParameters()) {
-            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 (!ElementUtils.isPrimitive(parameter.getType())) {
-                builder.startIf().string(parameter.getLocalName() + " != null").end();
-                builder.startBlock();
-            }
-            builder.startStatement();
-            if (ElementUtils.isPrimitive(parameter.getType())) {
-                builder.startCall("builder.append").doubleQuote(" (" + ElementUtils.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 (!ElementUtils.isPrimitive(parameter.getType())) {
-                builder.end();
-            }
-
-            sep = ", ";
-        }
-
-        builder.startStatement().startCall("builder", "append").doubleQuote(")").end().end();
-        builder.startReturn().string("builder.toString()").end();
-
-        builder.end();
-        builder.startElseBlock();
-        builder.startReturn().string("message").end();
-        builder.end();
-
-        return method;
-    }
-
-    private CodeExecutableElement createCachedExecute(SpecializationData polymorph) {
-        CodeExecutableElement cachedExecute = new CodeExecutableElement(modifiers(PROTECTED, ABSTRACT), polymorph.getReturnType().getType(), EXECUTE_CHAINED);
-        addInternalValueParameters(cachedExecute, polymorph, true, false, false);
-
-        ExecutableTypeData sourceExecutableType = node.findExecutableType(polymorph.getReturnType().getTypeSystemType(), 0);
-        boolean sourceThrowsUnexpected = sourceExecutableType != null && sourceExecutableType.hasUnexpectedValue(context);
-        if (sourceThrowsUnexpected && sourceExecutableType.getType().equals(node.getGenericSpecialization().getReturnType().getTypeSystemType())) {
-            sourceThrowsUnexpected = false;
-        }
-        if (sourceThrowsUnexpected) {
-            cachedExecute.getThrownTypes().add(context.getType(UnexpectedResultException.class));
-        }
-        return cachedExecute;
-
-    }
-
-    private void createConstructors(CodeTypeElement clazz) {
-        List<ExecutableElement> constructors = findUserConstructors(node.getNodeType());
-        ExecutableElement sourceSectionConstructor = null;
-        if (constructors.isEmpty()) {
-            clazz.add(createUserConstructor(clazz, null));
-        } else {
-            for (ExecutableElement constructor : constructors) {
-                clazz.add(createUserConstructor(clazz, constructor));
-                if (NodeParser.isSourceSectionConstructor(context, constructor)) {
-                    sourceSectionConstructor = constructor;
-                }
-            }
-        }
-        if (node.needsRewrites(context)) {
-            ExecutableElement copyConstructor = findCopyConstructor(node.getNodeType());
-            clazz.add(createCopyConstructor(clazz, copyConstructor, sourceSectionConstructor));
-        }
-    }
-
-    private CodeExecutableElement createUserConstructor(CodeTypeElement type, ExecutableElement superConstructor) {
-        CodeExecutableElement method = new CodeExecutableElement(null, type.getSimpleName().toString());
-        CodeTreeBuilder builder = method.createBuilder();
-
-        if (superConstructor != null) {
-            ElementUtils.setVisibility(method.getModifiers(), ElementUtils.getVisibility(superConstructor.getModifiers()));
-            for (VariableElement param : superConstructor.getParameters()) {
-                method.getParameters().add(CodeVariableElement.clone(param));
-            }
-            builder.startStatement().startSuperCall();
-            for (VariableElement param : superConstructor.getParameters()) {
-                builder.string(param.getSimpleName().toString());
-            }
-            builder.end().end();
-        }
-
-        for (VariableElement var : type.getFields()) {
-            if (var.getModifiers().contains(STATIC)) {
-                continue;
-            }
-            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()));
-            }
-
-            builder.startStatement();
-            String fieldName = var.getSimpleName().toString();
-
-            CodeTree init = createStaticCast(builder, child, fieldName);
-
-            builder.string("this.").string(fieldName).string(" = ").tree(init);
-            builder.end();
-        }
-        return method;
-    }
-
-    private CodeTree createStaticCast(CodeTreeBuilder parent, NodeChildData child, String fieldName) {
-        NodeData parentNode = getSpecialization().getNode();
-        if (child != null) {
-            CreateCastData createCast = parentNode.findCast(child.getName());
-            if (createCast != null) {
-                return createTemplateMethodCall(parent, null, parentNode.getGenericSpecialization(), createCast, null, fieldName);
-            }
-        }
-        return CodeTreeBuilder.singleString(fieldName);
-    }
-
-    private CodeExecutableElement createCopyConstructor(CodeTypeElement type, ExecutableElement superConstructor, ExecutableElement sourceSectionConstructor) {
-        CodeExecutableElement method = new CodeExecutableElement(null, type.getSimpleName().toString());
-        CodeTreeBuilder builder = method.createBuilder();
-        method.getParameters().add(new CodeVariableElement(type.asType(), "copy"));
-
-        if (superConstructor != null) {
-            builder.startStatement().startSuperCall().string("copy").end().end();
-        } else if (sourceSectionConstructor != null) {
-            builder.startStatement().startSuperCall().string("copy.getSourceSection()").end().end();
-        }
-
-        for (VariableElement var : type.getFields()) {
-            if (var.getModifiers().contains(STATIC) || !var.getModifiers().contains(FINAL)) {
-                continue;
-            }
-            final String varName = var.getSimpleName().toString();
-            final TypeMirror varType = var.asType();
-            if (ElementUtils.isAssignable(varType, context.getTruffleTypes().getNodeArray())) {
-                CodeTree size = builder.create().string("copy.", varName, ".length").build();
-                builder.startStatement().string("this.").string(varName).string(" = ").startNewArray((ArrayType) varType, size).end().end();
-            } else {
-                builder.startStatement().string("this.", varName, " = copy.", varName).end();
-            }
-        }
-
-        return method;
-    }
-
-    private CodeVariableElement createAssumptionField(String assumption) {
-        CodeVariableElement var = new CodeVariableElement(context.getTruffleTypes().getAssumption(), assumption);
-        var.getModifiers().add(Modifier.FINAL);
-        return var;
-    }
-
-    private CodeVariableElement createChildField(NodeChildData child) {
-        TypeMirror type = child.getNodeType();
-        CodeVariableElement var = new CodeVariableElement(type, child.getName());
-        var.getModifiers().add(Modifier.PROTECTED);
-
-        DeclaredType annotationType;
-        if (child.getCardinality() == Cardinality.MANY) {
-            var.getModifiers().add(Modifier.FINAL);
-            annotationType = context.getTruffleTypes().getChildrenAnnotation();
-        } else {
-            annotationType = context.getTruffleTypes().getChildAnnotation();
-        }
-
-        var.getAnnotationMirrors().add(new CodeAnnotationMirror(annotationType));
-        return var;
-    }
-
-    private static SpecializationGroup createSpecializationGroups(final NodeData node) {
-        List<SpecializationData> specializations = node.getSpecializations();
-        List<SpecializationData> filteredSpecializations = new ArrayList<>();
-        for (SpecializationData current : specializations) {
-            if (current.isUninitialized() || current.isPolymorphic() || !current.isReachable()) {
-                continue;
-            }
-            filteredSpecializations.add(current);
-        }
-
-        return SpecializationGroup.create(filteredSpecializations);
-    }
-
-    protected final CodeExecutableElement createExecuteUninitialized() {
-        SpecializationData generic = node.getGenericSpecialization();
-        CodeExecutableElement method = new CodeExecutableElement(modifiers(PROTECTED), generic.getReturnType().getType(), EXECUTE_UNINITIALIZED);
-        addInternalValueParameters(method, generic, true, false, false);
-        CodeTreeBuilder builder = method.createBuilder();
-
-        boolean needsFrame = node.isFrameUsedByAnyGuard();
-        CodeTreeBuilder createSpecializationCall = builder.create();
-        createSpecializationCall.startCall(SPECIALIZE);
-        addInternalValueParameterNames(createSpecializationCall, generic, generic, null, needsFrame, !needsFrame, null);
-        createSpecializationCall.end();
-        builder.declaration(baseClassName(node), "newNode", createSpecializationCall);
-
-        if (generic.isReachable()) {
-            builder.startIf().string("newNode == null").end().startBlock();
-
-            builder.startIf().startStaticCall(context.getTruffleTypes().getCompilerDirectives(), "inInterpreter").end().end().startBlock();
-            builder.statement("containsFallback = true");
-            builder.end();
-            builder.tree(createGenericInvoke(builder, generic, generic));
-            builder.end();
-            builder.startElseBlock();
-            builder.tree(createDeoptimize(builder));
-            builder.end();
-        }
-
-        builder.startReturn();
-        builder.startStaticCall(context.getTruffleTypes().getDslShare(), "rewriteUninitialized").string("this").string("newNode").end();
-        builder.string(".").startCall(EXECUTE_CHAINED);
-        addInternalValueParameterNames(builder, generic, generic, null, true, false, null);
-        builder.end();
-        builder.end();
-
-        if (generic.isReachable()) {
-            builder.end();
-        }
-
-        return method;
-    }
-
-    private static CodeTree createInfoCall(CodeTreeBuilder parent, SpecializationData specialization, String reason) {
-        CodeTreeBuilder builder = parent.create();
-        builder.startCall(CREATE_INFO).string(reason);
-        addInternalValueParameterNames(builder, specialization, specialization, null, false, false, null);
-        builder.end();
-        return builder.build();
-    }
-
-    private CodeExecutableElement createMonomorphicRewrite() {
-        SpecializationData generic = node.getGenericSpecialization();
-        CodeExecutableElement method = new CodeExecutableElement(modifiers(PROTECTED, FINAL), generic.getReturnType().getType(), REWRITE);
-        addInternalValueParameters(method, generic, true, false, false);
-        method.addParameter(new CodeVariableElement(context.getType(String.class), "reason"));
-
-        boolean needsFrame = node.isFrameUsedByAnyGuard();
-        CodeTreeBuilder builder = method.createBuilder();
-
-        builder.startStatement().startStaticCall(context.getTruffleTypes().getCompilerAsserts(), "neverPartOfCompilation").end().end();
-        String baseClassName = baseClassName(getSpecialization().getNode());
-        CodeTreeBuilder createSpecializationCall = builder.create();
-        createSpecializationCall.startCall(SPECIALIZE);
-        addInternalValueParameterNames(createSpecializationCall, generic, generic, null, needsFrame, !needsFrame, null);
-        createSpecializationCall.end();
-        builder.declaration(baseClassName, "newNode", createSpecializationCall);
-
-        builder.startIf().string("newNode == null").end().startBlock();
-        builder.startStatement();
-        String uninitializedName = nodeSpecializationClassName(node.getUninitializedSpecialization());
-        builder.string("newNode = ").startNew(uninitializedName).string("this").end();
-        builder.end();
-        if (node.isFallbackReachable()) {
-            builder.startStatement().string("((", uninitializedName, ") newNode).containsFallback = true").end();
-        }
-        builder.end();
-
-        builder.startStatement();
-        builder.type(context.getType(String.class)).string(" message = ").tree(createInfoCall(builder, generic, "reason"));
-        builder.end();
-
-        builder.declaration(baseClassName, "returnNode",
-                        builder.create().startStaticCall(context.getTruffleTypes().getDslShare(), DSLSHARE_REWRITE).string("this").string("newNode").string("message").end().build());
-        builder.startIf().string("returnNode == null").end().startBlock();
-        builder.tree(createRewritePolymorphic(builder, "this"));
-        builder.end();
-
-        builder.startReturn();
-        builder.startCall("returnNode", EXECUTE_CHAINED);
-        addInternalValueParameterNames(builder, node.getGenericSpecialization(), node.getGenericSpecialization(), null, true, false, null);
-        builder.end();
-        builder.end();
-
-        return method;
-    }
-
-    private CodeTree createRewritePolymorphic(CodeTreeBuilder parent, String currentNode) {
-        String polyClassName = nodePolymorphicClassName(node);
-        CodeTreeBuilder builder = parent.create();
-
-        builder.startStatement().string("returnNode = ");
-        builder.startStaticCall(context.getTruffleTypes().getDslShare(), DSLSHARE_REWRITE_TO_POLYMORHPIC);
-        builder.string("this");
-        builder.tree(builder.create().startNew(nodeSpecializationClassName(node.getUninitializedSpecialization())).string(currentNode).end().build());
-        builder.tree(builder.create().startNew(polyClassName).string(currentNode).end().build());
-        builder.startGroup().cast(baseClassName(node)).startCall("copy").end().end();
-        builder.string("newNode");
-        builder.string("message");
-        builder.end();
-        builder.end();
-
-        return builder.build();
-    }
-
-    private CodeExecutableElement createCreateSpecializationMethod(SpecializationGroup group) {
-        CodeExecutableElement method = new CodeExecutableElement(modifiers(PROTECTED, FINAL), new GeneratedTypeMirror(ElementUtils.getPackageName(node.getTemplateType()), baseClassName(node)),
-                        SPECIALIZE);
-
-        final boolean needsFrame = node.isFrameUsedByAnyGuard();
-
-        if (!needsFrame) {
-            method.getAnnotationMirrors().add(new CodeAnnotationMirror(context.getTruffleTypes().getTruffleBoundary()));
-        }
-
-        addInternalValueParameters(method, node.getGenericSpecialization(), needsFrame, !needsFrame, false);
-        final CodeTreeBuilder builder = method.createBuilder();
-        builder.tree(createExecuteTree(builder, node.getGenericSpecialization(), group, new CodeBlock<SpecializationData>() {
-
-            public CodeTree create(CodeTreeBuilder b, SpecializationData current) {
-                return createCreateSpecializationMethodBody0(builder, current, needsFrame);
-            }
-        }, null, false, true, false, true));
-
-        emitUnreachableSpecializations(builder, node);
-
-        return method;
-    }
-
-    private CodeTree createCreateSpecializationMethodBody0(CodeTreeBuilder parent, SpecializationData current, boolean useDeoptimize) {
-        CodeTreeBuilder builder = new CodeTreeBuilder(parent);
-        if (current.isFallback()) {
-            builder.startReturn().nullLiteral().end();
-        } else {
-            String className = nodeSpecializationClassName(current);
-            if (!current.getExcludedBy().isEmpty()) {
-                builder.startIf().string("!").startStaticCall(context.getTruffleTypes().getDslShare(), "isExcluded");
-                builder.string("this").string(nodeSpecializationClassName(current), ".", METADATA_FIELD_NAME).end().end();
-                builder.startBlock();
-            }
-
-            if (current.getNode().getGenericSpecialization().isReachable() && useDeoptimize) {
-                builder.tree(createDeoptimize(builder));
-            }
-            builder.startReturn();
-            builder.cast(baseClassName(getSpecialization().getNode()));
-            builder.startGroup().startCall(className, NodeFactoryFactory.FACTORY_METHOD_NAME).string("this");
-            for (Parameter param : current.getSignatureParameters()) {
-                NodeChildData child = param.getSpecification().getExecution().getChild();
-                List<TypeData> types = child.getNodeData().getTypeSystem().lookupSourceTypes(param.getTypeSystemType());
-                if (types.size() > 1) {
-                    builder.string(implicitTypeName(param));
-                }
-            }
-            builder.end().end();
-            builder.end();
-
-            if (!current.getExcludedBy().isEmpty()) {
-                builder.end();
-            }
-        }
-        return builder.build();
-
-    }
-
-    private static void emitUnreachableSpecializations(final CodeTreeBuilder builder, NodeData node) {
-        for (SpecializationData current : node.getSpecializations()) {
-            if (current.isReachable()) {
-                continue;
-            }
-            builder.string("// unreachable ").string(current.getId()).newLine();
-        }
-    }
-
-    protected CodeTree createExecuteTree(CodeTreeBuilder outerParent, final SpecializationData source, final SpecializationGroup group, final CodeBlock<SpecializationData> guardedblock,
-                    final CodeTree elseBlock, boolean forceElse, final boolean emitAssumptions, final boolean typedCasts, final boolean castForGuardsOnly) {
-        return guard(outerParent, source, group, new CodeBlock<Integer>() {
-
-            public CodeTree create(CodeTreeBuilder parent, Integer ifCount) {
-                CodeTreeBuilder builder = parent.create();
-
-                if (group.getSpecialization() != null) {
-                    builder.tree(guardedblock.create(builder, group.getSpecialization()));
-
-                    assert group.getChildren().isEmpty() : "missed a specialization";
-
-                } else {
-                    for (SpecializationGroup childGroup : group.getChildren()) {
-                        builder.tree(createExecuteTree(builder, source, childGroup, guardedblock, null, false, emitAssumptions, typedCasts, castForGuardsOnly));
-                    }
-                }
-
-                return builder.build();
-            }
-        }, elseBlock, forceElse, emitAssumptions, typedCasts, castForGuardsOnly);
-    }
-
-    private CodeTree guard(CodeTreeBuilder parent, SpecializationData source, SpecializationGroup group, CodeBlock<Integer> bodyBlock, CodeTree elseBlock, boolean forceElse, boolean emitAssumptions,
-                    boolean typedCasts, boolean castForGuardsOnly) {
-        CodeTreeBuilder builder = parent.create();
-
-        int ifCount = emitGuards(builder, source, group, emitAssumptions, typedCasts, castForGuardsOnly);
-
-        if (isReachableGroup(group, ifCount)) {
-            builder.tree(bodyBlock.create(builder, ifCount));
-        }
-
-        builder.end(ifCount);
-
-        if (elseBlock != null) {
-            if (ifCount > 0 || forceElse) {
-                builder.tree(elseBlock);
-            }
-        }
-
-        return builder.build();
-    }
-
-    private static boolean isReachableGroup(SpecializationGroup group, int ifCount) {
-        if (ifCount != 0) {
-            return true;
-        }
-        SpecializationGroup previous = group.getPreviousGroup();
-        if (previous == null || previous.findElseConnectableGuards().isEmpty()) {
-            return true;
-        }
-
-        /*
-         * Hacky else case. In this case the specialization is not reachable due to previous else
-         * branch. This is only true if the minimum state is not checked.
-         */
-        if (previous.getGuards().size() == 1 && previous.getTypeGuards().isEmpty() && previous.getAssumptions().isEmpty() &&
-                        (previous.getParent() == null || previous.getMaxSpecializationIndex() != previous.getParent().getMaxSpecializationIndex())) {
-            return false;
-        }
-
-        return true;
-    }
-
-    private int emitGuards(CodeTreeBuilder builder, SpecializationData source, SpecializationGroup group, boolean emitAssumptions, boolean typedCasts, boolean castForGuardsOnly) {
-        CodeTreeBuilder guardsBuilder = builder.create();
-        CodeTreeBuilder castBuilder = builder.create();
-        CodeTreeBuilder guardsCastBuilder = builder.create();
-
-        String guardsAnd = "";
-        String guardsCastAnd = "";
-
-        if (emitAssumptions) {
-            for (String assumption : group.getAssumptions()) {
-                guardsBuilder.string(guardsAnd);
-                guardsBuilder.string("this");
-                guardsBuilder.string(".").string(assumption).string(".isValid()");
-                guardsAnd = " && ";
-            }
-        }
-
-        for (TypeGuard typeGuard : group.getTypeGuards()) {
-            Parameter valueParam = source.getSignatureParameter(typeGuard.getSignatureIndex());
-
-            if (valueParam == null) {
-                /*
-                 * If used inside a execute evaluated method then the value param may not exist. In
-                 * that case we assume that the value is executed generic or of the current
-                 * specialization.
-                 */
-                if (group.getSpecialization() != null) {
-                    valueParam = group.getSpecialization().getSignatureParameter(typeGuard.getSignatureIndex());
-                } else {
-                    valueParam = node.getGenericSpecialization().getSignatureParameter(typeGuard.getSignatureIndex());
-                }
-            }
-
-            NodeExecutionData execution = valueParam.getSpecification().getExecution();
-            CodeTree implicitGuard = createTypeGuard(guardsBuilder, execution, valueParam, typeGuard.getType(), typedCasts);
-            if (implicitGuard != null) {
-                guardsBuilder.string(guardsAnd);
-                guardsBuilder.tree(implicitGuard);
-                guardsAnd = " && ";
-            }
-
-            CodeTree implicitGetType = null;
-            if (castForGuardsOnly) {
-                implicitGetType = createGetImplicitType(builder, execution, valueParam, typeGuard.getType());
-            }
-
-            boolean performCast = true;
-            if (castForGuardsOnly) {
-                // if cast for guards we just cast if the type guard is used inside a guard.
-                performCast = group.isTypeGuardUsedInAnyGuardBelow(context, source, typeGuard);
-            }
-
-            if (performCast) {
-                CodeTree cast = createCast(castBuilder, execution, valueParam, typeGuard.getType(), typedCasts);
-                if (cast != null) {
-                    castBuilder.tree(cast);
-                }
-            }
-            if (implicitGetType != null) {
-                castBuilder.tree(implicitGetType);
-            }
-        }
-        List<GuardExpression> elseGuards = group.findElseConnectableGuards();
-
-        for (GuardExpression guard : group.getGuards()) {
-            if (elseGuards.contains(guard)) {
-                continue;
-            }
-
-            if (needsTypeGuard(source, group, guard)) {
-                guardsCastBuilder.tree(createMethodGuard(builder, guardsCastAnd, source, guard));
-                guardsCastAnd = " && ";
-            } else {
-                guardsBuilder.tree(createMethodGuard(builder, guardsAnd, source, guard));
-                guardsAnd = " && ";
-            }
-        }
-
-        int ifCount = startGuardIf(builder, guardsBuilder.build(), 0, elseGuards);
-        builder.tree(castBuilder.build());
-        ifCount = startGuardIf(builder, guardsCastBuilder.build(), ifCount, elseGuards);
-        return ifCount;
-    }
-
-    private static int startGuardIf(CodeTreeBuilder builder, CodeTree condition, int ifCount, List<GuardExpression> elseGuard) {
-        int newIfCount = ifCount;
-
-        if (!condition.isEmpty()) {
-            if (ifCount == 0 && !elseGuard.isEmpty()) {
-                builder.startElseIf();
-            } else {
-                builder.startIf();
-            }
-            builder.tree(condition);
-            builder.end().startBlock();
-            newIfCount++;
-        } else if (ifCount == 0 && !elseGuard.isEmpty()) {
-            builder.startElseBlock();
-            newIfCount++;
-        }
-        return newIfCount;
-    }
-
-    private static boolean needsTypeGuard(SpecializationData source, SpecializationGroup group, GuardExpression guard) {
-        for (Parameter parameter : guard.getResolvedGuard().getParameters()) {
-            if (!parameter.getSpecification().isSignature()) {
-                continue;
-            }
-
-            int signatureIndex = source.getNode().getChildExecutions().indexOf(parameter.getSpecification().getExecution());
-            if (signatureIndex == -1) {
-                continue;
-            }
-
-            TypeGuard typeGuard = group.findTypeGuard(signatureIndex);
-            if (typeGuard != null) {
-                TypeData requiredType = typeGuard.getType();
-
-                Parameter sourceParameter = source.findParameter(parameter.getLocalName());
-                if (sourceParameter == null) {
-                    sourceParameter = source.getNode().getGenericSpecialization().findParameter(parameter.getLocalName());
-                }
-
-                if (ElementUtils.needsCastTo(sourceParameter.getType(), requiredType.getPrimitiveType())) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    private CodeTree createTypeGuard(CodeTreeBuilder parent, NodeExecutionData execution, Parameter source, TypeData targetType, boolean typedCasts) {
-        CodeTreeBuilder builder = new CodeTreeBuilder(parent);
-
-        TypeData sourceType = source.getTypeSystemType();
-
-        if (!sourceType.needsCastTo(targetType)) {
-            return null;
-        }
-
-        builder.startGroup();
-
-        if (execution.isShortCircuit()) {
-            Parameter shortCircuit = source.getPreviousParameter();
-            assert shortCircuit != null;
-            builder.string("(");
-            builder.string("!").string(valueName(shortCircuit));
-            builder.string(" || ");
-        }
-
-        List<TypeData> types = getSpecialization().getNode().getTypeSystem().lookupSourceTypes(targetType);
-        if (types.size() > 1) {
-            String castTypeName = null;
-            if (typedCasts) {
-                castTypeName = implicitTypeName(source);
-            }
-            CodeTree check;
-            if (castTypeName == null) {
-                check = TypeSystemCodeGenerator.implicitCheck(targetType, CodeTreeBuilder.singleString(valueName(source)), null);
-            } else {
-                check = TypeSystemCodeGenerator.implicitCheck(targetType, CodeTreeBuilder.singleString(valueName(source)), castTypeName);
-            }
-            builder.tree(check);
-        } else {
-            builder.tree(TypeSystemCodeGenerator.check(targetType, CodeTreeBuilder.singleString(valueName(source))));
-        }
-
-        if (execution.isShortCircuit()) {
-            builder.string(")");
-        }
-
-        builder.end(); // group
-
-        return builder.build();
-    }
-
-    // TODO merge redundancies with #createTypeGuard
-    private CodeTree createCast(CodeTreeBuilder parent, NodeExecutionData execution, Parameter source, TypeData targetType, boolean typedCasts) {
-        TypeData sourceType = source.getTypeSystemType();
-
-        if (!sourceType.needsCastTo(targetType)) {
-            return null;
-        }
-
-        CodeTree condition = null;
-        if (execution.isShortCircuit()) {
-            Parameter shortCircuit = source.getPreviousParameter();
-            assert shortCircuit != null;
-            condition = CodeTreeBuilder.singleString(valueName(shortCircuit));
-        }
-
-        CodeTree cast;
-        List<TypeData> types = getSpecialization().getNode().getTypeSystem().lookupSourceTypes(targetType);
-        if (types.size() > 1) {
-            String castTypeName = null;
-            if (typedCasts) {
-                castTypeName = implicitTypeName(source);
-            }
-            cast = TypeSystemCodeGenerator.implicitCast(targetType, CodeTreeBuilder.singleString(valueName(source)), castTypeName);
-        } else {
-            cast = TypeSystemCodeGenerator.cast(targetType, valueName(source));
-        }
-
-        CodeTreeBuilder builder = parent.create();
-        builder.tree(createLazyAssignment(parent, castValueName(source), targetType.getPrimitiveType(), condition, cast));
-
-        return builder.build();
-    }
-
-    private CodeTree createGetImplicitType(CodeTreeBuilder parent, NodeExecutionData execution, Parameter source, TypeData targetType) {
-        CodeTree condition = null;
-        if (execution.isShortCircuit()) {
-            Parameter shortCircuit = source.getPreviousParameter();
-            assert shortCircuit != null;
-            condition = CodeTreeBuilder.singleString(valueName(shortCircuit));
-        }
-
-        CodeTreeBuilder builder = parent.create();
-        List<TypeData> types = getSpecialization().getNode().getTypeSystem().lookupSourceTypes(targetType);
-        if (types.size() > 1) {
-            CodeTree castType = TypeSystemCodeGenerator.implicitType(targetType, CodeTreeBuilder.singleString(valueName(source)));
-            builder.tree(createLazyAssignment(builder, implicitTypeName(source), context.getType(Class.class), condition, castType));
-        }
-        return builder.build();
-    }
-
-    private static CodeTree createMethodGuard(CodeTreeBuilder parent, String prefix, SpecializationData source, GuardExpression guard) {
-        CodeTreeBuilder builder = parent.create();
-        builder.string(prefix);
-        if (guard.isNegated()) {
-            builder.string("!");
-        }
-        builder.tree(createTemplateMethodCall(builder, null, source, guard.getResolvedGuard(), null));
-        return builder.build();
-    }
-
-    protected CodeTree createGenericInvoke(CodeTreeBuilder parent, SpecializationData source, SpecializationData current) {
-        CodeTreeBuilder builder = new CodeTreeBuilder(parent);
-
-        if (current.getMethod() == null) {
-            emitEncounteredSynthetic(builder, getSpecialization().getNode(), current);
-        } else {
-            builder.startReturn().tree(createTemplateMethodCall(builder, null, source, current, null)).end();
-        }
-
-        return encloseThrowsWithFallThrough(parent, current, builder.build());
-    }
-
-    private CodeTree encloseThrowsWithFallThrough(CodeTreeBuilder parent, SpecializationData current, CodeTree tree) {
-        if (current.getExceptions().isEmpty()) {
-            return tree;
-        }
-        CodeTreeBuilder builder = new CodeTreeBuilder(parent);
-
-        builder.startTryBlock();
-        builder.tree(tree);
-        for (SpecializationThrowsData exception : current.getExceptions()) {
-            builder.end().startCatchBlock(exception.getJavaClass(), "rewriteEx");
-            builder.tree(createDeoptimize(builder));
-            builder.tree(createCallRewriteMonomorphic(builder, false, current.getNode().getGenericSpecialization().getReturnType().getTypeSystemType(), null,
-                            "Thrown " + ElementUtils.getSimpleName(exception.getJavaClass())));
-        }
-        builder.end();
-
-        return builder.build();
-    }
-
-    protected CodeTree createCastingExecute(CodeTreeBuilder parent, ExecutableTypeData executable, ExecutableTypeData castExecutable) {
-        TypeData type = executable.getType();
-        CodeTreeBuilder builder = new CodeTreeBuilder(parent);
-
-        TypeData primaryType = castExecutable.getType();
-
-        boolean needsTry = castExecutable.hasUnexpectedValue(context);
-        boolean returnVoid = type.isVoid();
-
-        List<Parameter> executeParameters = new ArrayList<>();
-        for (Parameter sourceParameter : executable.getSignatureParameters()) {
-            Parameter targetParameter = castExecutable.findParameter(sourceParameter.getLocalName());
-            if (targetParameter != null) {
-                executeParameters.add(targetParameter);
-            }
-        }
-
-        // execute names are enforced no cast
-        String[] executeParameterNames = new String[executeParameters.size()];
-        for (int i = 0; i < executeParameterNames.length; i++) {
-            executeParameterNames[i] = valueName(executeParameters.get(i));
-        }
-
-        builder.tree(createExecuteChildren(builder, executable, specialization, executeParameters, null));
-        boolean hasUnexpected = executable.hasUnexpectedValue(context);
-
-        CodeTree primaryExecuteCall = createTemplateMethodCall(builder, null, executable, castExecutable, null, executeParameterNames);
-        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(specialization.getNode().getTypeSystem().getGenericTypeData(), hasUnexpected, executable.getType(),
-                                CodeTreeBuilder.singleString("ex.getResult()")));
-                builder.end();
-            }
-            builder.end();
-
-            if (!returnVoid) {
-                builder.startReturn();
-                builder.tree(createExpectExecutableType(castExecutable.getReturnType().getTypeSystemType(), hasUnexpected, executable.getType(), CodeTreeBuilder.singleString("value")));
-                builder.end();
-            }
-        } else {
-            if (returnVoid) {
-                builder.statement(primaryExecuteCall);
-            } else {
-                builder.startReturn();
-                builder.tree(createExpectExecutableType(castExecutable.getReturnType().getTypeSystemType(), hasUnexpected, executable.getType(), primaryExecuteCall));
-                builder.end();
-            }
-        }
-
-        return builder.build();
-    }
-
-    private static CodeTree createExpectExecutableType(TypeData sourceType, boolean hasUnexpected, TypeData exepctedType, CodeTree value) {
-        return createCastType(sourceType, exepctedType, hasUnexpected, value);
-    }
-
-    protected CodeTree createExecuteChildren(CodeTreeBuilder parent, ExecutableTypeData sourceExecutable, SpecializationData currentSpecialization, List<Parameter> targetParameters,
-                    Parameter unexpectedParameter) {
-        CodeTreeBuilder builder = parent.create();
-        for (Parameter targetParameter : targetParameters) {
-            if (!targetParameter.getSpecification().isSignature()) {
-                continue;
-            }
-            NodeExecutionData execution = targetParameter.getSpecification().getExecution();
-            CodeTree executionExpressions = createExecuteChild(builder, execution, sourceExecutable, targetParameter, unexpectedParameter);
-            CodeTree unexpectedTree = createCatchUnexpectedTree(builder, executionExpressions, currentSpecialization, sourceExecutable, targetParameter, execution.isShortCircuit(),
-                            unexpectedParameter);
-            CodeTree shortCircuitTree = createShortCircuitTree(builder, unexpectedTree, currentSpecialization, targetParameter, unexpectedParameter);
-
-            if (shortCircuitTree == executionExpressions) {
-                if (containsNewLine(executionExpressions)) {
-                    builder.declaration(targetParameter.getType(), valueName(targetParameter));
-                    builder.tree(shortCircuitTree);
-                } else {
-                    builder.startStatement().type(targetParameter.getType()).string(" ").tree(shortCircuitTree).end();
-                }
-            } else {
-                builder.tree(shortCircuitTree);
-            }
-
-        }
-        return builder.build();
-    }
-
-    private ExecutableTypeData resolveExecutableType(NodeExecutionData execution, TypeData type) {
-        ExecutableTypeData targetExecutable = execution.getChild().findExecutableType(type);
-        if (targetExecutable == null) {
-            targetExecutable = execution.getChild().findAnyGenericExecutableType(context);
-        }
-        return targetExecutable;
-    }
-
-    private CodeTree createExecuteChild(CodeTreeBuilder parent, NodeExecutionData execution, ExecutableTypeData sourceExecutable, Parameter targetParameter, Parameter unexpectedParameter) {
-        if (specialization.isPolymorphic() && targetParameter.getTypeSystemType().isGeneric() && unexpectedParameter == null) {
-            List<TypeData> possiblePolymorphicTypes = lookupPolymorphicTargetTypes(targetParameter);
-            if (possiblePolymorphicTypes.size() > 1) {
-                CodeTreeBuilder builder = parent.create();
-
-                boolean elseIf = false;
-                for (TypeData possiblePolymoprhicType : possiblePolymorphicTypes) {
-                    if (possiblePolymoprhicType.isGeneric()) {
-                        continue;
-                    }
-                    elseIf = builder.startIf(elseIf);
-
-                    Parameter sourceParameter = sourceExecutable.findParameter(targetParameter.getLocalName());
-                    TypeData sourceType = sourceParameter != null ? sourceParameter.getTypeSystemType() : null;
-                    builder.string(polymorphicTypeName(targetParameter.getSpecification().getExecution())).string(" == ").typeLiteral(possiblePolymoprhicType.getPrimitiveType());
-                    builder.end().startBlock();
-                    builder.startStatement();
-                    builder.tree(createExecuteChildExpression(parent, execution, sourceType, new Parameter(targetParameter, possiblePolymoprhicType), unexpectedParameter, null));
-                    builder.end();
-                    builder.end();
-                }
-
-                builder.startElseBlock();
-                builder.startStatement().tree(createExecuteChildImplicit(parent, execution, sourceExecutable, targetParameter, unexpectedParameter)).end();
-                builder.end();
-
-                return builder.build();
-            }
-        }
-        return createExecuteChildImplicit(parent, execution, sourceExecutable, targetParameter, unexpectedParameter);
-    }
-
-    protected static final List<Parameter> getImplicitTypeParameters(SpecializationData model) {
-        List<Parameter> parameter = new ArrayList<>();
-        for (Parameter param : model.getSignatureParameters()) {
-            NodeChildData child = param.getSpecification().getExecution().getChild();
-            List<TypeData> types = child.getNodeData().getTypeSystem().lookupSourceTypes(param.getTypeSystemType());
-            if (types.size() > 1) {
-                parameter.add(param);
-            }
-        }
-        return parameter;
-    }
-
-    private List<TypeData> lookupPolymorphicTargetTypes(Parameter param) {
-        Set<TypeData> possiblePolymorphicTypes = new HashSet<>();
-        for (SpecializationData otherSpecialization : specialization.getNode().getSpecializations()) {
-            if (!otherSpecialization.isSpecialized()) {
-                continue;
-            }
-            Parameter otherParameter = otherSpecialization.findParameter(param.getLocalName());
-            if (otherParameter != null) {
-                possiblePolymorphicTypes.add(otherParameter.getTypeSystemType());
-            }
-        }
-        List<TypeData> types = new ArrayList<>(possiblePolymorphicTypes);
-        Collections.sort(types);
-        return types;
-    }
-
-    private CodeTree createExecuteChildImplicit(CodeTreeBuilder parent, NodeExecutionData execution, ExecutableTypeData sourceExecutable, Parameter param, Parameter unexpectedParameter) {
-        CodeTreeBuilder builder = parent.create();
-        Parameter sourceParameter = sourceExecutable.findParameter(param.getLocalName());
-        String childExecuteName = createExecuteChildMethodName(param, sourceParameter != null);
-        if (childExecuteName != null) {
-            builder.string(valueName(param));
-            builder.string(" = ");
-            builder.startCall(childExecuteName);
-
-            for (Parameter parameters : sourceExecutable.getParameters()) {
-                if (parameters.getSpecification().isSignature()) {
-                    continue;
-                }
-                builder.string(parameters.getLocalName());
-            }
-
-            if (sourceParameter != null) {
-                builder.string(valueNameEvaluated(sourceParameter));
-            }
-
-            builder.string(implicitTypeName(param));
-
-            builder.end();
-        } else {
-            List<TypeData> sourceTypes = execution.getChild().getNodeData().getTypeSystem().lookupSourceTypes(param.getTypeSystemType());
-            TypeData expectType = sourceParameter != null ? sourceParameter.getTypeSystemType() : null;
-            if (sourceTypes.size() > 1) {
-                builder.tree(createExecuteChildImplicitExpressions(parent, param, expectType));
-            } else {
-                builder.tree(createExecuteChildExpression(parent, execution, expectType, param, unexpectedParameter, null));
-            }
-        }
-        return builder.build();
-    }
-
-    private static String createExecuteChildMethodName(Parameter param, boolean expect) {
-        NodeExecutionData execution = param.getSpecification().getExecution();
-        NodeChildData child = execution.getChild();
-        if (child.getExecuteWith().size() > 0) {
-            return null;
-        }
-        List<TypeData> sourceTypes = child.getNodeData().getTypeSystem().lookupSourceTypes(param.getTypeSystemType());
-        if (sourceTypes.size() <= 1) {
-            return null;
-        }
-        String prefix = expect ? "expect" : "execute";
-        String suffix = execution.getIndex() > -1 ? String.valueOf(execution.getIndex()) : "";
-        return prefix + ElementUtils.firstLetterUpperCase(child.getName()) + ElementUtils.firstLetterUpperCase(ElementUtils.getTypeId(param.getType())) + suffix;
-    }
-
-    private List<CodeExecutableElement> createExecuteChilds(Parameter param, Set<TypeData> expectTypes) {
-        CodeExecutableElement executeMethod = createExecuteChild(param, null);
-        if (executeMethod == null) {
-            return Collections.emptyList();
-        }
-        List<CodeExecutableElement> childs = new ArrayList<>();
-        childs.add(executeMethod);
-
-        for (TypeData expectType : expectTypes) {
-            CodeExecutableElement method = createExecuteChild(param, expectType);
-            if (method != null) {
-                childs.add(method);
-            }
-        }
-        return childs;
-    }
-
-    private CodeExecutableElement createExecuteChild(Parameter param, TypeData expectType) {
-        String childExecuteName = createExecuteChildMethodName(param, expectType != null);
-        if (childExecuteName == null) {
-            return null;
-        }
-
-        CodeExecutableElement method = new CodeExecutableElement(modifiers(PROTECTED, expectType != null ? STATIC : FINAL), param.getType(), childExecuteName);
-        method.getThrownTypes().add(context.getTruffleTypes().getUnexpectedValueException());
-        method.addParameter(new CodeVariableElement(context.getTruffleTypes().getFrame(), "frameValue"));
-        if (expectType != null) {
-            method.addParameter(new CodeVariableElement(expectType.getPrimitiveType(), valueNameEvaluated(param)));
-        }
-        method.addParameter(new CodeVariableElement(context.getType(Class.class), implicitTypeName(param)));
-
-        CodeTreeBuilder builder = method.createBuilder();
-        builder.declaration(param.getType(), valueName(param));
-        builder.tree(createExecuteChildImplicitExpressions(builder, param, expectType));
-        builder.startReturn().string(valueName(param)).end();
-
-        return method;
-    }
-
-    private CodeTree createExecuteChildImplicitExpressions(CodeTreeBuilder parent, Parameter targetParameter, TypeData expectType) {
-        CodeTreeBuilder builder = parent.create();
-        NodeExecutionData execution = targetParameter.getSpecification().getExecution();
-        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(implicitTypeName(targetParameter)).string(" == ").typeLiteral(sourceType.getPrimitiveType());
-                builder.end();
-                builder.startBlock();
-            } else {
-                builder.startElseBlock();
-            }
-
-            ExecutableTypeData implictExecutableTypeData = execution.getChild().findExecutableType(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 = execution.getChild().getNodeData().findAnyGenericExecutableType(context, execution.getChild().getExecuteWith().size());
-            }
-
-            ImplicitCastData cast = execution.getChild().getNodeData().getTypeSystem().lookupCast(sourceType, targetParameter.getTypeSystemType());
-            CodeTree execute = createExecuteChildExpression(builder, execution, expectType, targetParameter, null, cast);
-            builder.statement(execute);
-            builder.end();
-            index++;
-        }
-        return builder.build();
-    }
-
-    private CodeTree createExecuteChildExpression(CodeTreeBuilder parent, NodeExecutionData execution, TypeData sourceParameterType, Parameter targetParameter, Parameter unexpectedParameter,
-                    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(execution, castSourceType);
-            expression = createExecuteChildExpression(parent, execution, targetExecutable, unexpectedParameter);
-            sourceType = targetExecutable.getType();
-        } else {
-            expression = CodeTreeBuilder.singleString(valueNameEvaluated(targetParameter));
-        }
-
-        // target = expectTargetType(implicitCast(expectCastSourceType(source)))
-        expression = createExpectType(sourceType, castSourceType, expression);
-        expression = createImplicitCast(cast, expression);
-        expression = createExpectType(castTargetType, targetType, expression);
-
-        CodeTreeBuilder builder = parent.create();
-        builder.string(valueName(targetParameter));
-        builder.string(" = ");
-        builder.tree(expression);
-        return builder.build();
-    }
-
-    private static CodeTree createImplicitCast(ImplicitCastData cast, CodeTree expression) {
-        if (cast == null) {
-            return expression;
-        }
-        return TypeSystemCodeGenerator.invokeImplicitCast(cast, expression);
-    }
-
-    private boolean containsNewLine(CodeTree tree) {
-        if (tree.getCodeKind() == CodeTreeKind.NEW_LINE) {
-            return true;
-        }
-
-        List<CodeTree> enclosing = tree.getEnclosedElements();
-        if (enclosing != null) {
-            for (CodeTree codeTree : enclosing) {
-                if (containsNewLine(codeTree)) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    private boolean hasUnexpected(Parameter sourceParameter, Parameter targetParameter, Parameter unexpectedParameter) {
-        NodeExecutionData execution = targetParameter.getSpecification().getExecution();
-
-        if (getSpecialization().isPolymorphic() && targetParameter.getTypeSystemType().isGeneric() && unexpectedParameter == null) {
-            // check for other polymorphic types
-            List<TypeData> polymorphicTargetTypes = lookupPolymorphicTargetTypes(targetParameter);
-            if (polymorphicTargetTypes.size() > 1) {
-                for (TypeData polymorphicTargetType : polymorphicTargetTypes) {
-                    if (hasUnexpectedType(execution, sourceParameter, polymorphicTargetType)) {
-                        return true;
-                    }
-                }
-            }
-        }
-
-        if (hasUnexpectedType(execution, sourceParameter, targetParameter.getTypeSystemType())) {
-            return true;
-        }
-        return false;
-    }
-
-    private boolean hasUnexpectedType(NodeExecutionData execution, Parameter sourceParameter, TypeData targetType) {
-        List<TypeData> implicitSourceTypes = getSpecialization().getNode().getTypeSystem().lookupSourceTypes(targetType);
-
-        for (TypeData implicitSourceType : implicitSourceTypes) {
-            TypeData sourceType;
-            ExecutableTypeData targetExecutable = resolveExecutableType(execution, implicitSourceType);
-            if (sourceParameter != null) {
-                sourceType = sourceParameter.getTypeSystemType();
-            } else {
-                if (targetExecutable.hasUnexpectedValue(context)) {
-                    return true;
-                }
-                sourceType = targetExecutable.getType();
-            }
-
-            ImplicitCastData cast = getSpecialization().getNode().getTypeSystem().lookupCast(implicitSourceType, targetType);
-            if (cast != null) {
-                if (cast.getSourceType().needsCastTo(targetType)) {
-                    return true;
-                }
-            }
-
-            if (sourceType.needsCastTo(targetType)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    private CodeTree createCatchUnexpectedTree(CodeTreeBuilder parent, CodeTree body, SpecializationData currentSpecialization, ExecutableTypeData currentExecutable, Parameter param,
-                    boolean shortCircuit, Parameter unexpectedParameter) {
-        CodeTreeBuilder builder = new CodeTreeBuilder(parent);
-        Parameter sourceParameter = currentExecutable.findParameter(param.getLocalName());
-        boolean unexpected = hasUnexpected(sourceParameter, param, unexpectedParameter);
-        if (!unexpected) {
-            return body;
-        }
-
-        if (!shortCircuit) {
-            builder.declaration(param.getType(), valueName(param));
-        }
-        builder.startTryBlock();
-
-        if (containsNewLine(body)) {
-            builder.tree(body);
-        } else {
-            builder.statement(body);
-        }
-
-        builder.end().startCatchBlock(getUnexpectedValueException(), "ex");
-        SpecializationData generic = currentSpecialization.getNode().getGenericSpecialization();
-        Parameter genericParameter = generic.findParameter(param.getLocalName());
-
-        List<Parameter> genericParameters = generic.getParametersAfter(genericParameter);
-        builder.tree(createExecuteChildren(parent, currentExecutable, generic, genericParameters, genericParameter));
-        if (currentSpecialization.isPolymorphic()) {
-            builder.tree(createReturnOptimizeTypes(builder, currentExecutable, currentSpecialization, param));
-        } else {
-            builder.tree(createCallRewriteMonomorphic(builder, currentExecutable.hasUnexpectedValue(context), currentExecutable.getType(), param, "Expected " + param.getLocalName() + " instanceof " +
-                            ElementUtils.getSimpleName(param.getType())));
-        }
-        builder.end(); // catch block
-
-        return builder.build();
-    }
-
-    private CodeTree createReturnOptimizeTypes(CodeTreeBuilder parent, ExecutableTypeData currentExecutable, SpecializationData currentSpecialization, Parameter param) {
-        SpecializationData polymorphic = node.getPolymorphicSpecialization();
-
-        CodeTreeBuilder builder = new CodeTreeBuilder(parent);
-        builder.startStatement().string(polymorphicTypeName(param.getSpecification().getExecution())).string(" = ").typeLiteral(context.getType(Object.class)).end();
-
-        builder.startReturn();
-
-        CodeTreeBuilder execute = new CodeTreeBuilder(builder);
-        execute.startCall("next0", EXECUTE_CHAINED);
-        addInternalValueParameterNames(execute, currentSpecialization, polymorphic, param.getLocalName(), true, false, null);
-        execute.end();
-
-        TypeData sourceType = polymorphic.getReturnType().getTypeSystemType();
-
-        builder.tree(createExpectExecutableType(sourceType, currentExecutable.hasUnexpectedValue(context), currentExecutable.getType(), execute.build()));
-
-        builder.end();
-        return builder.build();
-    }
-
-    private CodeTree createExecuteChildExpression(CodeTreeBuilder parent, NodeExecutionData targetExecution, ExecutableTypeData targetExecutable, Parameter unexpectedParameter) {
-        CodeTreeBuilder builder = new CodeTreeBuilder(parent);
-        if (targetExecution != null) {
-            builder.tree(createAccessChild(targetExecution, null));
-            builder.string(".");
-        }
-
-        builder.startCall(targetExecutable.getMethodName());
-
-        // TODO this should be merged with #createTemplateMethodCall
-        int index = 0;
-        for (Parameter parameter : targetExecutable.getParameters()) {
-
-            if (!parameter.getSpecification().isSignature()) {
-                builder.string(parameter.getLocalName());
-            } else {
-
-                if (index < targetExecution.getChild().getExecuteWith().size()) {
-                    NodeChildData child = targetExecution.getChild().getExecuteWith().get(index);
-
-                    ParameterSpec spec = getSpecialization().getSpecification().findParameterSpec(child.getName());
-                    List<Parameter> specializationParams = getSpecialization().findParameters(spec);
-
-                    if (specializationParams.isEmpty()) {
-                        builder.defaultValue(parameter.getType());
-                        continue;
-                    }
-
-                    Parameter 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 = getSpecialization().getNode().getTypeSystem().getGenericTypeData();
-                    }
-
-                    CodeTree value = CodeTreeBuilder.singleString(localName);
-
-                    if (sourceType.needsCastTo(targetType)) {
-                        value = TypeSystemCodeGenerator.cast(targetType, value);
-                    }
-                    builder.tree(value);
-                } else {
-                    builder.defaultValue(parameter.getType());
-                }
-                index++;
-            }
-        }
-
-        builder.end();
-
-        return builder.build();
-    }
-
-    private CodeTree createShortCircuitTree(CodeTreeBuilder parent, CodeTree body, SpecializationData currentSpecialization, Parameter parameter, Parameter exceptionParam) {
-        NodeExecutionData execution = parameter.getSpecification().getExecution();
-        if (execution == null || !execution.isShortCircuit()) {
-            return body;
-        }
-
-        CodeTreeBuilder builder = new CodeTreeBuilder(parent);
-        Parameter shortCircuitParam = currentSpecialization.getPreviousParam(parameter);
-        builder.tree(createShortCircuitValue(builder, currentSpecialization, execution, shortCircuitParam, exceptionParam));
-        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);
-        } else {
-            builder.statement(body);
-        }
-        builder.end();
-
-        return builder.build();
-    }
-
-    private static CodeTree createShortCircuitValue(CodeTreeBuilder parent, SpecializationData specialization, NodeExecutionData execution, Parameter shortCircuitParam, Parameter exceptionParam) {
-        CodeTreeBuilder builder = new CodeTreeBuilder(parent);
-        int shortCircuitIndex = 0;
-        for (NodeExecutionData otherExectuion : specialization.getNode().getChildExecutions()) {
-            if (otherExectuion.isShortCircuit()) {
-                if (otherExectuion == execution) {
-                    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.build();
-    }
-
-    protected CodeTree createCallRewriteMonomorphic(CodeTreeBuilder parent, boolean hasUnexpected, TypeData returnType, Parameter exceptionParam, String reason) {
-        SpecializationData generic = node.getGenericSpecialization();
-        CodeTreeBuilder specializeCall = new CodeTreeBuilder(parent);
-        specializeCall.startCall(REWRITE);
-        addInternalValueParameterNames(specializeCall, generic, node.getGenericSpecialization(), exceptionParam != null ? exceptionParam.getLocalName() : null, true, false, null);
-        specializeCall.doubleQuote(reason);
-        specializeCall.end().end();
-
-        CodeTreeBuilder builder = new CodeTreeBuilder(parent);
-
-        builder.startReturn();
-        builder.tree(createExpectExecutableType(generic.getReturnType().getTypeSystemType(), hasUnexpected, returnType, specializeCall.build()));
-        builder.end();
-
-        return builder.build();
-    }
-
-    static String valueNameEvaluated(Parameter targetParameter) {
-        return valueName(targetParameter) + "Evaluated";
-    }
-
-    static String implicitTypeName(Parameter param) {
-        return param.getLocalName() + "ImplicitType";
-    }
-
-    static String polymorphicTypeName(NodeExecutionData param) {
-        return param.getName() + "PolymorphicType";
-    }
-
-    static String valueName(Parameter param) {
-        return param.getLocalName();
-    }
-
-    private static CodeTree createAccessChild(NodeExecutionData targetExecution, String thisReference) {
-        String reference = thisReference;
-        if (reference == null) {
-            reference = "this";
-        }
-        CodeTreeBuilder builder = CodeTreeBuilder.createBuilder();
-        Element accessElement = targetExecution.getChild().getAccessElement();
-        if (accessElement == null || accessElement.getKind() == ElementKind.METHOD) {
-            builder.string(reference).string(".").string(targetExecution.getChild().getName());
-        } else if (accessElement.getKind() == ElementKind.FIELD) {
-            builder.string(reference).string(".").string(accessElement.getSimpleName().toString());
-        } else {
-            throw new AssertionError();
-        }
-        if (targetExecution.isIndexed()) {
-            builder.string("[" + targetExecution.getIndex() + "]");
-        }
-        return builder.build();
-    }
-
-    private static String castValueName(Parameter parameter) {
-        return valueName(parameter) + "Cast";
-    }
-
-    static void addInternalValueParameterNames(CodeTreeBuilder builder, TemplateMethod source, TemplateMethod specialization, String unexpectedValueName, boolean forceFrame, boolean disableFrame,
-                    Map<String, String> customNames) {
-        if (forceFrame && !disableFrame && specialization.getSpecification().findParameterSpec("frame") != null) {
-            builder.string("frameValue");
-        }
-        for (Parameter parameter : specialization.getParameters()) {
-            ParameterSpec spec = parameter.getSpecification();
-            if ((disableFrame || forceFrame) && spec.getName().equals("frame")) {
-                continue;
-            }
-
-            if (parameter.getSpecification().isLocal()) {
-                continue;
-            }
-
-            Parameter sourceParameter = source.findParameter(parameter.getLocalName());
-
-            if (customNames != null && customNames.containsKey(parameter.getLocalName())) {
-                builder.string(customNames.get(parameter.getLocalName()));
-            } else 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 static String valueName(Parameter sourceParameter, Parameter targetParameter) {
-        if (!sourceParameter.getSpecification().isSignature()) {
-            return valueName(targetParameter);
-        } else if (sourceParameter.getTypeSystemType() != null && targetParameter.getTypeSystemType() != null) {
-            if (sourceParameter.getTypeSystemType().needsCastTo(targetParameter.getTypeSystemType())) {
-                return castValueName(targetParameter);
-            }
-        }
-        return valueName(targetParameter);
-    }
-
-    static 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 = ElementUtils.findNearestEnclosingType(method.getEnclosingElement());
-        NodeData node = (NodeData) targetMethod.getTemplate();
-
-        if (target == null) {
-            boolean accessible = targetMethod.canBeAccessedByInstanceOf(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 {
-                    Parameter firstParameter = null;
-                    for (Parameter searchParameter : targetMethod.getParameters()) {
-                        if (searchParameter.getSpecification().isSignature()) {
-                            firstParameter = searchParameter;
-                            break;
-                        }
-                    }
-                    if (firstParameter == null) {
-                        throw new AssertionError();
-                    }
-
-                    Parameter sourceParameter = sourceMethod.findParameter(firstParameter.getLocalName());
-
-                    if (castedValues && sourceParameter != null) {
-                        builder.string(valueName(sourceParameter, firstParameter));
-                    } else {
-                        builder.string(valueName(firstParameter));
-                    }
-                }
-            }
-            builder.string(".");
-        } else {
-            builder.tree(target);
-        }
-        builder.startCall(method.getSimpleName().toString());
-
-        int signatureIndex = 0;
-
-        for (Parameter targetParameter : targetMethod.getParameters()) {
-            Parameter valueParameter = null;
-            if (sourceMethod != null) {
-                valueParameter = sourceMethod.findParameter(targetParameter.getLocalName());
-            }
-            if (valueParameter == null) {
-                valueParameter = targetParameter;
-            }
-            TypeMirror targetType = targetParameter.getType();
-            TypeMirror valueType = null;
-            if (valueParameter != null) {
-                valueType = valueParameter.getType();
-            }
-
-            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.cast(targetParameter.getType(), CodeTreeBuilder.singleString("ex.getResult()"));
-            } else if (!ElementUtils.needsCastTo(valueType, targetType)) {
-                builder.startGroup();
-                builder.string(valueName(targetParameter));
-                builder.end();
-            } else {
-                builder.string(castValueName(targetParameter));
-            }
-        }
-
-        builder.end().end();
-
-        return builder.build();
-    }
-
-    public static String baseClassName(NodeData node) {
-        String nodeid = resolveNodeId(node);
-        String name = ElementUtils.firstLetterUpperCase(nodeid);
-        name += "NodeGen";
-        return name;
-    }
-
-    /**
-     * <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).build());
-
-            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.build();
-    }
-
-    void emitEncounteredSynthetic(CodeTreeBuilder builder, NodeData model, TemplateMethod current) {
-        CodeTreeBuilder nodes = builder.create();
-        CodeTreeBuilder arguments = builder.create();
-        nodes.startCommaGroup();
-        arguments.startCommaGroup();
-        boolean empty = true;
-        for (Parameter parameter : current.getParameters()) {
-            NodeExecutionData executionData = parameter.getSpecification().getExecution();
-            if (executionData != null) {
-                if (executionData.isShortCircuit()) {
-                    nodes.nullLiteral();
-                    arguments.string(valueName(parameter.getPreviousParameter()));
-                }
-                nodes.tree(createAccessChild(executionData, "rootNode"));
-                arguments.string(valueName(parameter));
-                empty = false;
-            }
-        }
-        nodes.end();
-        arguments.end();
-        builder.startStatement().startStaticCall(context.getTruffleTypes().getCompilerDirectives(), "transferToInterpreter").end().end();
-
-        builder.declaration(baseClassName(model), "rootNode", builder.create().startStaticCall(context.getTruffleTypes().getDslShare(), DSLSHARE_FIND_ROOT).string("this").end());
-        builder.startThrow().startNew(context.getType(UnsupportedSpecializationException.class));
-        builder.string("rootNode");
-        builder.startNewArray(context.getTruffleTypes().getNodeArray(), null);
-        builder.tree(nodes.build());
-        builder.end();
-        if (!empty) {
-            builder.tree(arguments.build());
-        }
-        builder.end().end();
-    }
-
-    private static ExecutableElement findCopyConstructor(TypeMirror type) {
-        for (ExecutableElement constructor : ElementFilter.constructorsIn(ElementUtils.fromTypeMirror(type).getEnclosedElements())) {
-            if (constructor.getModifiers().contains(PRIVATE)) {
-                continue;
-            }
-            if (isCopyConstructor(constructor)) {
-                return constructor;
-            }
-        }
-
-        return null;
-    }
-
-    static String nodeSpecializationClassName(SpecializationData specialization) {
-        String nodeid = resolveNodeId(specialization.getNode());
-        String name = ElementUtils.firstLetterUpperCase(nodeid);
-        name += ElementUtils.firstLetterUpperCase(specialization.getId());
-        name += "Node";
-        return name;
-    }
-
-    static String nodePolymorphicClassName(NodeData node) {
-        return ElementUtils.firstLetterUpperCase(resolveNodeId(node)) + "PolymorphicNode";
-    }
-
-    private static String resolveNodeId(NodeData node) {
-        String nodeid = node.getNodeId();
-        if (nodeid.endsWith("Node") && !nodeid.equals("Node")) {
-            nodeid = nodeid.substring(0, nodeid.length() - 4);
-        }
-        return nodeid;
-    }
-
-    private static CodeTree createCastType(TypeData sourceType, TypeData targetType, boolean expect, CodeTree value) {
-        if (targetType == null) {
-            return value;
-        } else if (sourceType != null && !sourceType.needsCastTo(targetType)) {
-            return value;
-        }
-
-        if (expect) {
-            return TypeSystemCodeGenerator.expect(targetType, value);
-        } else {
-            return TypeSystemCodeGenerator.cast(targetType, value);
-        }
-    }
-
-    private static CodeTree createExpectType(TypeData sourceType, TypeData targetType, CodeTree expression) {
-        return createCastType(sourceType, targetType, true, expression);
-    }
-
-    static CodeTree createDeoptimize(CodeTreeBuilder parent) {
-        CodeTreeBuilder builder = new CodeTreeBuilder(parent);
-        builder.startStatement();
-        builder.startStaticCall(ProcessorContext.getInstance().getTruffleTypes().getCompilerDirectives(), "transferToInterpreterAndInvalidate").end();
-        builder.end();
-        return builder.build();
-    }
-
-    private TypeMirror getUnexpectedValueException() {
-        return context.getTruffleTypes().getUnexpectedValueException();
-    }
-
-    interface CodeBlock<T> {
-
-        CodeTree create(CodeTreeBuilder parent, T value);
-
-    }
-
-}
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/generator/NodeCodeGenerator.java	Thu Jan 22 20:42:48 2015 +0100
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/generator/NodeCodeGenerator.java	Thu Jan 22 20:44:24 2015 +0100
@@ -122,38 +122,14 @@
     }

     private static String getAccessorClassName(NodeData node) {
-        return node.isGenerateFactory() ? NodeFactoryFactory.factoryClassName(node) : NodeBaseFactory.baseClassName(node);
+        return node.isGenerateFactory() ? NodeFactoryFactory.factoryClassName(node) : NodeGenFactory.nodeTypeName(node);
     }

     private static List<CodeTypeElement> generateNodes(ProcessorContext context, NodeData node) {
         if (!node.needsFactory()) {
             return Collections.emptyList();
         }
-        if (node.getTypeSystem().getOptions().useNewLayout()) {
-            return Arrays.asList(new NodeGenFactory(context, node).create());
-        } else {
-            return generateNodesOld(context, node);
-        }
-    }
-
-    private static List<CodeTypeElement> generateNodesOld(ProcessorContext context, NodeData node) {
-        List<CodeTypeElement> nodeTypes = new ArrayList<>();
-        SpecializationData generic = node.getGenericSpecialization() == null ? node.getSpecializations().get(0) : node.getGenericSpecialization();
-        CodeTypeElement baseNode = new NodeBaseFactory(context, node, generic).create();
-        nodeTypes.add(baseNode);
-
-        for (SpecializationData specialization : node.getSpecializations()) {
-            if (!specialization.isReachable() || specialization.isFallback()) {
-                continue;
-            }
-            if (specialization.isPolymorphic() && node.isPolymorphic(context)) {
-                nodeTypes.add(new PolymorphicNodeFactory(context, node, specialization, baseNode).create());
-                continue;
-            }
-
-            nodeTypes.add(new SpecializedNodeFactory(context, node, specialization, baseNode).create());
-        }
-        return nodeTypes;
+        return Arrays.asList(new NodeGenFactory(context, node).create());
     }

     private static ExecutableElement createGetFactories(ProcessorContext context, NodeData node) {
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/generator/NodeFactoryFactory.java	Thu Jan 22 20:42:48 2015 +0100
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/generator/NodeFactoryFactory.java	Thu Jan 22 20:44:24 2015 +0100
@@ -31,7 +31,6 @@
 import javax.lang.model.type.*;

 import com.oracle.truffle.api.dsl.*;
-import com.oracle.truffle.api.dsl.internal.*;
 import com.oracle.truffle.dsl.processor.*;
 import com.oracle.truffle.dsl.processor.java.*;
 import com.oracle.truffle.dsl.processor.java.model.*;
@@ -40,20 +39,16 @@

 class NodeFactoryFactory {

-    static final String FACTORY_METHOD_NAME = "create0";
+    static final String EMPTY_CLASS_ARRAY = "EMPTY_CLASS_ARRAY";

     private final ProcessorContext context;
     private final NodeData node;
-    private final TypeSystemData typeSystem;
-    private final DSLOptions options;
     private final CodeTypeElement createdFactoryElement;

     public NodeFactoryFactory(ProcessorContext context, NodeData node, CodeTypeElement createdClass) {
         this.context = context;
         this.node = node;
         this.createdFactoryElement = createdClass;
-        this.typeSystem = node.getTypeSystem();
-        this.options = typeSystem.getOptions();
     }

     public static String factoryClassName(NodeData node) {
@@ -94,7 +89,7 @@
         // execution signature
         builder.startGroup();
         if (node.getChildExecutions().isEmpty()) {
-            builder.staticReference(context.getTruffleTypes().getDslMetadata(), NodeBaseFactory.EMPTY_CLASS_ARRAY);
+            builder.staticReference(context.getTruffleTypes().getDslMetadata(), EMPTY_CLASS_ARRAY);
         } else {
             builder.startNewArray(new ArrayCodeTypeMirror(context.getType(Class.class)), null);
             for (NodeExecutionData execution : node.getChildExecutions()) {
@@ -107,11 +102,11 @@
         // node signatures
         builder.startGroup();
         builder.startNewArray(new ArrayCodeTypeMirror(new ArrayCodeTypeMirror(context.getType(Class.class))), null);
-        List<ExecutableElement> constructors = NodeBaseFactory.findUserConstructors(createdFactoryElement.asType());
+        List<ExecutableElement> constructors = GeneratorUtils.findUserConstructors(createdFactoryElement.asType());
         for (ExecutableElement constructor : constructors) {
             builder.startGroup();
             if (constructor.getParameters().isEmpty()) {
-                builder.staticReference(context.getTruffleTypes().getDslMetadata(), NodeBaseFactory.EMPTY_CLASS_ARRAY);
+                builder.staticReference(context.getTruffleTypes().getDslMetadata(), EMPTY_CLASS_ARRAY);
             } else {
                 builder.startNewArray(new ArrayCodeTypeMirror(context.getType(Class.class)), null);
                 for (VariableElement var : constructor.getParameters()) {
@@ -135,7 +130,7 @@
         method.addParameter(arguments);

         CodeTreeBuilder builder = method.createBuilder();
-        List<ExecutableElement> signatures = NodeBaseFactory.findUserConstructors(createdFactoryElement.asType());
+        List<ExecutableElement> signatures = GeneratorUtils.findUserConstructors(createdFactoryElement.asType());
         boolean ifStarted = false;

         for (ExecutableElement element : signatures) {
@@ -230,7 +225,7 @@
     }

     public void createFactoryMethods(CodeTypeElement clazz) {
-        List<ExecutableElement> constructors = NodeBaseFactory.findUserConstructors(createdFactoryElement.asType());
+        List<ExecutableElement> constructors = GeneratorUtils.findUserConstructors(createdFactoryElement.asType());
         for (ExecutableElement constructor : constructors) {
             clazz.add(createCreateMethod(constructor));
             if (constructor instanceof CodeExecutableElement) {
@@ -252,11 +247,7 @@
         if (node.getSpecializations().isEmpty()) {
             body.nullLiteral();
         } else {
-            if (options.useNewLayout()) {
-                body.startNew(NodeGenFactory.nodeType(node));
-            } else {
-                body.startCall(NodeBaseFactory.nodeSpecializationClassName(node.getSpecializations().get(0)), FACTORY_METHOD_NAME);
-            }
+            body.startNew(NodeGenFactory.nodeType(node));
             for (VariableElement var : method.getParameters()) {
                 body.string(var.getSimpleName().toString());
             }
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/generator/NodeGenFactory.java	Thu Jan 22 20:42:48 2015 +0100
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/generator/NodeGenFactory.java	Thu Jan 22 20:44:24 2015 +0100
@@ -183,7 +183,7 @@
             }
         }

-        for (ExecutableElement superConstructor : NodeBaseFactory.findUserConstructors(node.getTemplateType().asType())) {
+        for (ExecutableElement superConstructor : GeneratorUtils.findUserConstructors(node.getTemplateType().asType())) {
             clazz.add(createNodeConstructor(clazz, superConstructor));
         }
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/generator/PolymorphicNodeFactory.java	Thu Jan 22 20:42:48 2015 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,85 +0,0 @@
-/*
- * Copyright (c) 2014, 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.generator;
-
-import static com.oracle.truffle.dsl.processor.java.ElementUtils.*;
-import static javax.lang.model.element.Modifier.*;
-
-import java.util.*;
-
-import javax.lang.model.type.*;
-
-import com.oracle.truffle.api.nodes.*;
-import com.oracle.truffle.dsl.processor.*;
-import com.oracle.truffle.dsl.processor.java.model.*;
-import com.oracle.truffle.dsl.processor.model.*;
-
-class PolymorphicNodeFactory extends SpecializedNodeFactory {
-
-    public PolymorphicNodeFactory(ProcessorContext context, NodeData node, SpecializationData specialization, CodeTypeElement nodeGen) {
-        super(context, node, specialization, nodeGen);
-    }
-
-    @Override
-    public CodeTypeElement create() {
-        TypeMirror baseType = node.getNodeType();
-        if (nodeGen != null) {
-            baseType = nodeGen.asType();
-        }
-        CodeTypeElement clazz = GeneratorUtils.createClass(node, null, modifiers(PRIVATE, FINAL), nodePolymorphicClassName(node), baseType);
-
-        clazz.getAnnotationMirrors().add(createNodeInfo(NodeCost.POLYMORPHIC));
-
-        for (Parameter polymorphParameter : specialization.getSignatureParameters()) {
-            if (!polymorphParameter.getTypeSystemType().isGeneric()) {
-                continue;
-            }
-            Set<TypeData> types = new HashSet<>();
-            for (SpecializationData otherSpecialization : node.getSpecializations()) {
-                if (!otherSpecialization.isSpecialized()) {
-                    continue;
-                }
-                Parameter parameter = otherSpecialization.findParameter(polymorphParameter.getLocalName());
-                assert parameter != null;
-                types.add(parameter.getTypeSystemType());
-            }
-
-        }
-
-        for (NodeExecutionData execution : node.getChildExecutions()) {
-            String fieldName = polymorphicTypeName(execution);
-            CodeVariableElement var = new CodeVariableElement(modifiers(PRIVATE), context.getType(Class.class), fieldName);
-            var.getAnnotationMirrors().add(new CodeAnnotationMirror(context.getTruffleTypes().getCompilationFinal()));
-            clazz.add(var);
-        }
-
-        createConstructors(clazz);
-        createExecuteMethods(clazz);
-
-        clazz.add(createUpdateTypes0());
-        createCachedExecuteMethods(clazz);
-
-        return clazz;
-    }
-
-}
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/generator/SpecializedNodeFactory.java	Thu Jan 22 20:42:48 2015 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,557 +0,0 @@
-/*
- * Copyright (c) 2014, 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.generator;
-
-import static com.oracle.truffle.dsl.processor.java.ElementUtils.*;
-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.nodes.*;
-import com.oracle.truffle.dsl.processor.*;
-import com.oracle.truffle.dsl.processor.java.*;
-import com.oracle.truffle.dsl.processor.java.model.*;
-import com.oracle.truffle.dsl.processor.java.model.CodeTypeMirror.ArrayCodeTypeMirror;
-import com.oracle.truffle.dsl.processor.model.*;
-import com.oracle.truffle.dsl.processor.parser.*;
-
-class SpecializedNodeFactory extends NodeBaseFactory {
-
-    protected final CodeTypeElement nodeGen;
-
-    public SpecializedNodeFactory(ProcessorContext context, NodeData node, SpecializationData specialization, CodeTypeElement nodeGen) {
-        super(context, node, specialization);
-        this.nodeGen = nodeGen;
-    }
-
-    @Override
-    public CodeTypeElement create() {
-        TypeMirror baseType = node.getNodeType();
-        if (nodeGen != null) {
-            baseType = nodeGen.asType();
-        }
-        CodeTypeElement clazz = GeneratorUtils.createClass(node, null, modifiers(PRIVATE, FINAL), nodeSpecializationClassName(specialization), baseType);
-
-        if (specialization.isSpecialized() || specialization.isUninitialized()) {
-            clazz.add(createGetMetadata0(false));
-            clazz.add(createMetadataLiteral());
-        }
-
-        NodeCost cost;
-        if (specialization.isFallback()) {
-            cost = NodeCost.MEGAMORPHIC;
-        } else if (specialization.isUninitialized()) {
-            cost = NodeCost.UNINITIALIZED;
-        } else if (specialization.isPolymorphic()) {
-            cost = NodeCost.POLYMORPHIC;
-        } else if (specialization.isSpecialized()) {
-            cost = NodeCost.MONOMORPHIC;
-        } else {
-            throw new AssertionError();
-        }
-        clazz.getAnnotationMirrors().add(createNodeInfo(cost));
-
-        if (specialization.isUninitialized() && node.getGenericSpecialization().isReachable()) {
-            clazz.add(createUninitializedGetCostOverride());
-        }
-
-        createConstructors(clazz);
-
-        createExecuteMethods(clazz);
-        createCachedExecuteMethods(clazz);
-
-        if (specialization.isUninitialized()) {
-            if (specialization.getNode().isFallbackReachable()) {
-                CodeVariableElement var = new CodeVariableElement(modifiers(Modifier.PRIVATE), context.getType(boolean.class), CONTAINS_FALLBACK);
-                var.addAnnotationMirror(new CodeAnnotationMirror(context.getTruffleTypes().getCompilationFinal()));
-                clazz.add(var);
-            }
-            clazz.add(createExecuteUninitialized());
-        }
-
-        if (!specialization.isUninitialized() && specialization.getNode().needsRewrites(context)) {
-            clazz.add(createCopyConstructorFactoryMethod(clazz, nodeGen.asType()));
-        } else {
-            for (ExecutableElement constructor : ElementFilter.constructorsIn(clazz.getEnclosedElements())) {
-                if (constructor.getParameters().size() == 1 && ((CodeVariableElement) constructor.getParameters().get(0)).getType().equals(nodeGen.asType())) {
-                    // skip copy constructor - not used
-                    continue;
-                }
-                clazz.add(createConstructorFactoryMethod(clazz, constructor));
-            }
-        }
-
-        return clazz;
-    }
-
-    private Element createUninitializedGetCostOverride() {
-        TypeMirror returnType = context.getTruffleTypes().getNodeCost();
-        CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC), returnType, "getCost");
-        CodeTreeBuilder builder = method.createBuilder();
-        builder.startIf().string(CONTAINS_FALLBACK).end().startBlock();
-        builder.startReturn().staticReference(returnType, "MONOMORPHIC").end();
-        builder.end();
-        builder.startReturn().string("super.getCost()").end();
-        return method;
-    }
-
-    private CodeVariableElement createMetadataLiteral() {
-        CodeVariableElement includes = new CodeVariableElement(modifiers(PRIVATE, STATIC, FINAL), context.getTruffleTypes().getDslMetadata(), METADATA_FIELD_NAME);
-
-        CodeTreeBuilder builder = includes.createInitBuilder();
-
-        Set<SpecializationData> contains = specialization.getContains();
-        if (specialization.isUninitialized()) {
-            contains = new HashSet<>();
-
-            SpecializationData polymorphic = node.getPolymorphicSpecialization();
-            if (polymorphic != null) {
-                contains.addAll(polymorphic.getContains());
-            }
-            SpecializationData generic = node.getGenericSpecialization();
-            if (generic != null) {
-                contains.addAll(generic.getContains());
-            }
-        }
-
-        builder.startNew(context.getTruffleTypes().getDslMetadata());
-        builder.startGroup().string(nodeSpecializationClassName(getSpecialization()), ".class").end();
-        builder.tree(createSpecializationListLiteral(builder, contains));
-        builder.tree(createSpecializationListLiteral(builder, getSpecialization().getExcludedBy()));
-        builder.tree(createSpecializationTypeLiteral(builder, SpecializationData.getSignatureTypes(getSpecialization())));
-        builder.string("0").string("0");
-        builder.end();
-        return includes;
-    }
-
-    private CodeTree createSpecializationTypeLiteral(CodeTreeBuilder parent, List<TypeMirror> list) {
-        ArrayType classArray = new ArrayCodeTypeMirror(context.getType(Class.class));
-        CodeTreeBuilder builder = parent.create();
-
-        if (list.isEmpty()) {
-            builder.staticReference(context.getTruffleTypes().getDslMetadata(), EMPTY_CLASS_ARRAY);
-        } else {
-            builder.startNewArray(classArray, null);
-            for (TypeMirror type : list) {
-                builder.typeLiteral(type);
-            }
-            builder.end();
-        }
-
-        return builder.build();
-    }
-
-    private CodeTree createSpecializationListLiteral(CodeTreeBuilder parent, Set<SpecializationData> list) {
-        ArrayType classArray = new ArrayCodeTypeMirror(context.getType(Class.class));
-        CodeTreeBuilder builder = parent.create();
-
-        if (list.isEmpty()) {
-            builder.staticReference(context.getTruffleTypes().getDslMetadata(), EMPTY_CLASS_ARRAY);
-        } else {
-            builder.startNewArray(classArray, null);
-            for (SpecializationData current : list) {
-                SpecializationData s = current;
-                if (s.isFallback() || s.isPolymorphic()) {
-                    s = getSpecialization().getNode().getUninitializedSpecialization();
-                }
-                builder.startGroup().string(nodeSpecializationClassName(s)).string(".class").end();
-            }
-            builder.end();
-        }
-
-        return builder.build();
-    }
-
-    protected CodeAnnotationMirror createNodeInfo(NodeCost cost) {
-        String shortName = node.getShortName();
-        CodeAnnotationMirror nodeInfoMirror = new CodeAnnotationMirror(context.getTruffleTypes().getNodeInfoAnnotation());
-        if (shortName != null) {
-            nodeInfoMirror.setElementValue(nodeInfoMirror.findExecutableElement("shortName"), new CodeAnnotationValue(shortName));
-        }
-
-        DeclaredType nodeinfoCost = context.getTruffleTypes().getNodeCost();
-        VariableElement varKind = ElementUtils.findVariableElement(nodeinfoCost, cost.name());
-
-        nodeInfoMirror.setElementValue(nodeInfoMirror.findExecutableElement("cost"), new CodeAnnotationValue(varKind));
-        return nodeInfoMirror;
-    }
-
-    protected void createConstructors(CodeTypeElement clazz) {
-        TypeElement superTypeElement = ElementUtils.fromTypeMirror(clazz.getSuperclass());
-        for (ExecutableElement constructor : ElementFilter.constructorsIn(superTypeElement.getEnclosedElements())) {
-            if (specialization.isUninitialized()) {
-                // ignore copy constructors for uninitialized if not polymorphic
-                if (isCopyConstructor(constructor) && !node.isPolymorphic(context)) {
-                    continue;
-                }
-            } else if (node.getUninitializedSpecialization() != null) {
-                // ignore others than copy constructors for specialized nodes
-                if (!isCopyConstructor(constructor)) {
-                    continue;
-                }
-            }
-
-            CodeExecutableElement superConstructor = GeneratorUtils.createSuperConstructor(context, clazz, constructor);
-            if (superConstructor == null) {
-                continue;
-            }
-            CodeTree body = superConstructor.getBodyTree();
-            CodeTreeBuilder builder = superConstructor.createBuilder();
-            builder.tree(body);
-
-            if (superConstructor != null) {
-                for (Parameter param : getImplicitTypeParameters(getSpecialization())) {
-                    clazz.add(new CodeVariableElement(modifiers(PRIVATE, FINAL), context.getType(Class.class), implicitTypeName(param)));
-                    superConstructor.getParameters().add(new CodeVariableElement(context.getType(Class.class), implicitTypeName(param)));
-
-                    builder.startStatement();
-                    builder.string("this.").string(implicitTypeName(param)).string(" = ").string(implicitTypeName(param));
-                    builder.end();
-                }
-
-                clazz.add(superConstructor);
-            }
-        }
-    }
-
-    protected void createExecuteMethods(CodeTypeElement clazz) {
-
-        List<ExecutableTypeData> primaryExecutes = null;
-        int lastEvaluatedCount = -1;
-
-        for (ExecutableTypeData execType : node.getExecutableTypes()) {
-            if (execType.isFinal()) {
-                continue;
-            }
-            if (execType.getEvaluatedCount() != lastEvaluatedCount) {
-                lastEvaluatedCount = execType.getEvaluatedCount();
-                primaryExecutes = findFunctionalExecutableType(lastEvaluatedCount);
-            }
-
-            CodeExecutableElement executeMethod = createExecutableTypeOverride(execType, true);
-            clazz.add(executeMethod);
-            CodeTreeBuilder builder = executeMethod.getBuilder();
-            CodeTree result = createExecuteBody(builder, execType, primaryExecutes);
-            if (result != null) {
-                builder.tree(result);
-            } else {
-                clazz.remove(executeMethod);
-            }
-        }
-    }
-
-    protected void createCachedExecuteMethods(CodeTypeElement clazz) {
-        if (!node.isPolymorphic(context)) {
-            return;
-        }
-
-        final SpecializationData polymorphic = node.getPolymorphicSpecialization();
-        ExecutableElement executeCached = nodeGen.getMethod(EXECUTE_CHAINED);
-        CodeExecutableElement executeMethod = CodeExecutableElement.clone(context.getEnvironment(), executeCached);
-        executeMethod.getModifiers().remove(Modifier.ABSTRACT);
-        CodeTreeBuilder builder = executeMethod.createBuilder();
-
-        if (specialization.isPolymorphic()) {
-            builder.startReturn().startCall("this.next0", EXECUTE_CHAINED);
-            addInternalValueParameterNames(builder, polymorphic, polymorphic, null, true, false, null);
-            builder.end().end();
-        } else if (specialization.isUninitialized()) {
-            builder.tree(createDeoptimizeUninitialized(node, builder));
-            builder.startReturn().startCall("this", EXECUTE_UNINITIALIZED);
-            addInternalValueParameterNames(builder, polymorphic, polymorphic, null, true, false, null);
-            builder.end().end();
-        } else {
-            CodeTreeBuilder elseBuilder = new CodeTreeBuilder(builder);
-            elseBuilder.startReturn().startCall("this.next0", EXECUTE_CHAINED);
-            addInternalValueParameterNames(elseBuilder, polymorphic, polymorphic, null, true, false, null);
-            elseBuilder.end().end();
-
-            builder.tree(createExecuteTree(builder, polymorphic, SpecializationGroup.create(specialization), new CodeBlock<SpecializationData>() {
-
-                public CodeTree create(CodeTreeBuilder b, SpecializationData current) {
-                    return createGenericInvoke(b, polymorphic, current);
-                }
-            }, elseBuilder.build(), false, true, true, false));
-        }
-        clazz.add(executeMethod);
-    }
-
-    private static CodeTree createDeoptimizeUninitialized(NodeData node, CodeTreeBuilder parent) {
-        CodeTreeBuilder builder = parent.create();
-        if (node.getGenericSpecialization().isReachable()) {
-            builder.startIf().string("!containsFallback").end().startBlock();
-            builder.tree(createDeoptimize(builder));
-            builder.end();
-        } else {
-            builder.tree(createDeoptimize(builder));
-        }
-        return builder.build();
-    }
-
-    private CodeTree createExecuteBody(CodeTreeBuilder parent, ExecutableTypeData execType, List<ExecutableTypeData> primaryExecutes) {
-        CodeTreeBuilder builder = new CodeTreeBuilder(parent);
-
-        if (primaryExecutes.contains(execType) || primaryExecutes.isEmpty()) {
-            builder.tree(createFunctionalExecute(builder, execType));
-        } else if (needsCastingExecuteMethod(execType)) {
-            assert !primaryExecutes.isEmpty();
-            builder.tree(createCastingExecute(builder, execType, primaryExecutes.get(0)));
-        } else {
-            return null;
-        }
-
-        return builder.build();
-    }
-
-    private CodeExecutableElement createExecutableTypeOverride(ExecutableTypeData execType, boolean evaluated) {
-        CodeExecutableElement method = CodeExecutableElement.clone(context.getEnvironment(), execType.getMethod());
-
-        method.getAnnotationMirrors().clear();
-        for (VariableElement variable : method.getParameters()) {
-            variable.getAnnotationMirrors().clear();
-        }
-
-        CodeTreeBuilder builder = method.createBuilder();
-        int i = 0;
-        int signatureIndex = -1;
-        for (VariableElement param : method.getParameters()) {
-            CodeVariableElement var = CodeVariableElement.clone(param);
-            Parameter actualParameter = i < execType.getParameters().size() ? execType.getParameters().get(i) : null;
-            String name;
-            if (actualParameter != null) {
-                if (actualParameter.getSpecification().isSignature()) {
-                    signatureIndex++;
-                }
-
-                if (evaluated && actualParameter.getSpecification().isSignature()) {
-                    name = valueNameEvaluated(actualParameter);
-                } else {
-                    name = valueName(actualParameter);
-                }
-
-                int varArgCount = getSpecialization().getSignatureSize() - signatureIndex;
-                if (evaluated && actualParameter.isTypeVarArgs()) {
-                    Parameter baseVarArgs = actualParameter;
-                    name = valueName(baseVarArgs) + "Args";
-
-                    builder.startAssert().string(name).string(" != null").end();
-                    builder.startAssert().string(name).string(".length == ").string(String.valueOf(varArgCount)).end();
-                    if (varArgCount > 0) {
-                        List<Parameter> varArgsParameter = execType.getParameters().subList(i, execType.getParameters().size());
-                        for (Parameter varArg : varArgsParameter) {
-                            if (varArgCount <= 0) {
-                                break;
-                            }
-                            TypeMirror type = baseVarArgs.getType();
-                            if (type.getKind() == TypeKind.ARRAY) {
-                                type = ((ArrayType) type).getComponentType();
-                            }
-                            builder.declaration(type, valueNameEvaluated(varArg), name + "[" + varArg.getTypeVarArgsIndex() + "]");
-                            varArgCount--;
-                        }
-                    }
-                }
-            } else {
-                name = "arg" + i;
-            }
-            var.setName(name);
-            method.getParameters().set(i, var);
-            i++;
-        }
-
-        method.getAnnotationMirrors().clear();
-        method.getModifiers().remove(Modifier.ABSTRACT);
-        return method;
-    }
-
-    private static boolean needsCastingExecuteMethod(ExecutableTypeData execType) {
-        if (execType.isAbstract()) {
-            return true;
-        }
-        if (execType.getType().isGeneric()) {
-            return true;
-        }
-        return false;
-    }
-
-    private List<ExecutableTypeData> findFunctionalExecutableType(int evaluatedCount) {
-        TypeData primaryType = specialization.getReturnType().getTypeSystemType();
-        List<ExecutableTypeData> otherTypes = specialization.getNode().getExecutableTypes(evaluatedCount);
-
-        List<ExecutableTypeData> filteredTypes = new ArrayList<>();
-        for (ExecutableTypeData compareType : otherTypes) {
-            if (ElementUtils.typeEquals(compareType.getType().getPrimitiveType(), primaryType.getPrimitiveType())) {
-                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(context)) {
-                    filteredTypes.add(compareType);
-                }
-            }
-        }
-
-        if (filteredTypes.isEmpty()) {
-            for (ExecutableTypeData compareType : otherTypes) {
-                if (compareType.getType().isGeneric()) {
-                    filteredTypes.add(compareType);
-                }
-            }
-        }
-
-        return filteredTypes;
-    }
-
-    private CodeTree createFunctionalExecute(CodeTreeBuilder parent, final ExecutableTypeData executable) {
-        CodeTreeBuilder builder = new CodeTreeBuilder(parent);
-
-        if (specialization.isUninitialized()) {
-            builder.tree(createDeoptimizeUninitialized(specialization.getNode(), builder));
-        }
-
-        builder.tree(createExecuteChildren(builder, executable, specialization, specialization.getParameters(), null));
-
-        CodeTree returnSpecialized = null;
-
-        if (specialization.findNextSpecialization() != null) {
-            CodeTreeBuilder returnBuilder = new CodeTreeBuilder(builder);
-            returnBuilder.tree(createDeoptimize(builder));
-            returnBuilder.tree(createCallRewriteMonomorphic(builder, executable.hasUnexpectedValue(context), executable.getType(), null, "One of guards " + specialization.getGuards() + " failed"));
-            returnSpecialized = returnBuilder.build();
-        }
-
-        builder.tree(createExecuteTree(builder, specialization, SpecializationGroup.create(specialization), new CodeBlock<SpecializationData>() {
-
-            public CodeTree create(CodeTreeBuilder b, SpecializationData current) {
-                return createExecute(b, executable);
-            }
-        }, returnSpecialized, false, false, false, false));
-
-        return builder.build();
-    }
-
-    private CodeTree createExecute(CodeTreeBuilder parent, ExecutableTypeData executable) {
-        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()) {
-            returnBuilder.startCall("next0", EXECUTE_CHAINED);
-            addInternalValueParameterNames(returnBuilder, specialization, specialization, null, true, false, null);
-            returnBuilder.end();
-        } else if (specialization.isUninitialized()) {
-            returnBuilder.startCall(EXECUTE_UNINITIALIZED);
-            addInternalValueParameterNames(returnBuilder, specialization, specialization, null, true, false, null);
-            returnBuilder.end();
-        } else if (specialization.getMethod() == null && !node.needsRewrites(context)) {
-            emitEncounteredSynthetic(builder, getSpecialization().getNode(), specialization);
-        } else {
-            returnBuilder.tree(createTemplateMethodCall(returnBuilder, null, specialization, specialization, null));
-        }
-
-        if (!returnBuilder.isEmpty()) {
-            TypeData targetType = node.getTypeSystem().findTypeData(builder.findMethod().getReturnType());
-            TypeData sourceType = specialization.getReturnType().getTypeSystemType();
-
-            builder.startReturn();
-            if (targetType == null || sourceType == null) {
-                builder.tree(returnBuilder.build());
-            } else if (sourceType.needsCastTo(targetType)) {
-                CodeTree cast;
-                if (executable.hasUnexpectedValue(context)) {
-                    cast = TypeSystemCodeGenerator.expect(targetType, returnBuilder.build());
-                } else {
-                    cast = TypeSystemCodeGenerator.cast(targetType, returnBuilder.build());
-                }
-                builder.tree(cast);
-            } else {
-                builder.tree(returnBuilder.build());
-            }
-            builder.end();
-        }
-
-        if (!specialization.getExceptions().isEmpty()) {
-            for (SpecializationThrowsData exception : specialization.getExceptions()) {
-                builder.end().startCatchBlock(exception.getJavaClass(), "ex");
-                builder.tree(createDeoptimize(builder));
-                builder.tree(createCallRewriteMonomorphic(parent, executable.hasUnexpectedValue(context), executable.getType(), null, "Thrown " + ElementUtils.getSimpleName(exception.getJavaClass())));
-            }
-            builder.end();
-        }
-        if (!specialization.getAssumptions().isEmpty()) {
-            builder.end().startCatchBlock(context.getTruffleTypes().getInvalidAssumption(), "ex");
-            builder.tree(createCallRewriteMonomorphic(parent, executable.hasUnexpectedValue(context), executable.getType(), null, "Assumption failed"));
-            builder.end();
-        }
-
-        return builder.build();
-    }
-
-    private CodeExecutableElement createCopyConstructorFactoryMethod(CodeTypeElement clazz, TypeMirror baseType) {
-        List<Parameter> implicitTypeParams = getImplicitTypeParameters(specialization);
-        String baseName = "current";
-        CodeExecutableElement method = new CodeExecutableElement(modifiers(STATIC), specialization.getNode().getNodeType(), NodeFactoryFactory.FACTORY_METHOD_NAME);
-        method.addParameter(new CodeVariableElement(specialization.getNode().getNodeType(), baseName));
-        for (Parameter implicitTypeParam : implicitTypeParams) {
-            method.addParameter(new CodeVariableElement(context.getType(Class.class), implicitTypeName(implicitTypeParam)));
-        }
-        CodeTreeBuilder builder = method.createBuilder();
-        builder.startReturn();
-        builder.startNew(clazz.asType());
-        builder.startGroup().cast(baseType, CodeTreeBuilder.singleString(baseName)).end();
-        for (Parameter param : implicitTypeParams) {
-            builder.string(implicitTypeName(param));
-        }
-        builder.end().end();
-        return method;
-    }
-
-    private CodeExecutableElement createConstructorFactoryMethod(CodeTypeElement clazz, ExecutableElement constructor) {
-        List<? extends VariableElement> parameters = constructor.getParameters();
-        CodeExecutableElement method = new CodeExecutableElement(modifiers(STATIC), specialization.getNode().getNodeType(), NodeFactoryFactory.FACTORY_METHOD_NAME,
-                        parameters.toArray(new CodeVariableElement[parameters.size()]));
-        CodeTreeBuilder builder = method.createBuilder();
-        builder.startReturn();
-        builder.startNew(clazz.asType());
-        for (VariableElement param : parameters) {
-            builder.string(((CodeVariableElement) param).getName());
-        }
-        builder.end().end();
-        return method;
-    }
-}
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/generator/TypeSystemCodeGenerator.java	Thu Jan 22 20:42:48 2015 +0100
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/generator/TypeSystemCodeGenerator.java	Thu Jan 22 20:44:24 2015 +0100
@@ -118,14 +118,6 @@
         return builder.build();
     }

-    public static CodeTree cast(TypeData sourceType, TypeData targetType, CodeTree content) {
-        if (sourceType != null && !sourceType.needsCastTo(targetType)) {
-            return content;
-        } else {
-            return cast(targetType, content);
-        }
-    }
-
     public static CodeTree expect(TypeData type, CodeTree content) {
         if (type.isGeneric() || type.isVoid()) {
             return content;
@@ -208,15 +200,13 @@
     public CodeTypeElement create(ProcessorContext context, TypeSystemData typeSystem) {
         CodeTypeElement clazz = new TypeClassFactory(context, typeSystem).create();

-        if (typeSystem.getOptions().useNewLayout()) {
-            clazz.add(new TypeSystemNodeFactory(context, typeSystem).create());
+        clazz.add(new TypeSystemNodeFactory(context, typeSystem).create());

-            if (typeSystem.getOptions().implicitCastOptimization().isMergeCasts()) {
-                for (TypeData type : typeSystem.getTypes()) {
-                    List<TypeData> sourceTypes = typeSystem.lookupSourceTypes(type);
-                    if (sourceTypes.size() > 1) {
-                        clazz.add(new ImplicitCastNodeFactory(context, type).create());
-                    }
+        if (typeSystem.getOptions().implicitCastOptimization().isMergeCasts()) {
+            for (TypeData type : typeSystem.getTypes()) {
+                List<TypeData> sourceTypes = typeSystem.lookupSourceTypes(type);
+                if (sourceTypes.size() > 1) {
+                    clazz.add(new ImplicitCastNodeFactory(context, type).create());
                 }
             }
         }
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/java/ElementUtils.java	Thu Jan 22 20:42:48 2015 +0100
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/java/ElementUtils.java	Thu Jan 22 20:44:24 2015 +0100
@@ -119,16 +119,6 @@
         return b.toString();
     }

-    public static VariableElement findVariableElement(DeclaredType type, String name) {
-        List<? extends VariableElement> elements = ElementFilter.fieldsIn(type.asElement().getEnclosedElements());
-        for (VariableElement variableElement : elements) {
-            if (variableElement.getSimpleName().toString().equals(name)) {
-                return variableElement;
-            }
-        }
-        return null;
-    }
-
     public static TypeMirror boxType(ProcessorContext context, TypeMirror primitiveType) {
         TypeMirror boxedType = primitiveType;
         if (boxedType.getKind().isPrimitive()) {
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/java/model/CodeTreeBuilder.java	Thu Jan 22 20:42:48 2015 +0100
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/java/model/CodeTreeBuilder.java	Thu Jan 22 20:44:24 2015 +0100
@@ -324,10 +324,6 @@
         return end();
     }

-    public CodeTreeBuilder dot() {
-        return string(".");
-    }
-
     public CodeTreeBuilder newLine() {
         return push(NEW_LINE);
     }
@@ -576,17 +572,6 @@
         return declaration(type, name, init.getTree());
     }

-    public CodeTreeBuilder declaration(String type, String name, CodeTreeBuilder init) {
-        if (init == this) {
-            throw new IllegalArgumentException("Recursive builder usage.");
-        }
-        return declaration(type, name, init.getTree());
-    }
-
-    public CodeTreeBuilder declaration(TypeMirror type, String name) {
-        return declaration(type, name, (CodeTree) null);
-    }
-
     public CodeTreeBuilder create() {
         return new CodeTreeBuilder(this);
     }
@@ -622,11 +607,6 @@
         return root;
     }

-    public CodeTreeBuilder cast(String baseClassName) {
-        string("(").string(baseClassName).string(") ");
-        return this;
-    }
-
     public CodeTreeBuilder cast(TypeMirror type) {
         string("(").type(type).string(") ");
         return this;
@@ -671,22 +651,10 @@
         return startReturn().string("true").end();
     }

-    public CodeTreeBuilder instanceOf(CodeTree var, CodeTree type) {
-        return tree(var).string(" instanceof ").tree(type);
-    }
-
     public CodeTreeBuilder instanceOf(CodeTree var, TypeMirror type) {
         return tree(var).string(" instanceof ").type(type);
     }

-    public CodeTreeBuilder instanceOf(String var, String type) {
-        return instanceOf(singleString(var), singleString(type));
-    }
-
-    public CodeTreeBuilder instanceOf(String var, TypeMirror type) {
-        return instanceOf(singleString(var), singleType(type));
-    }
-
     public CodeTreeBuilder defaultValue(TypeMirror mirror) {
         switch (mirror.getKind()) {
             case VOID:
@@ -717,26 +685,6 @@
         }
     }

-    public CodeTreeBuilder assertFalse() {
-        return startAssert().string("false").end();
-    }
-
-    public CodeTreeBuilder breakStatement() {
-        return statement("break");
-    }
-
-    public CodeTreeBuilder isNull() {
-        return string(" == null");
-    }
-
-    public CodeTreeBuilder isNotNull() {
-        return string(" != null");
-    }
-
-    public CodeTreeBuilder is(CodeTree tree) {
-        return string(" == ").tree(tree);
-    }
-
     public CodeTreeBuilder startTryBlock() {
         return string("try ").startBlock();
     }
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/java/model/CodeTypeElement.java	Thu Jan 22 20:42:48 2015 +0100
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/java/model/CodeTypeElement.java	Thu Jan 22 20:44:24 2015 +0100
@@ -173,15 +173,6 @@
         return ElementFilter.fieldsIn(getEnclosedElements());
     }

-    public ExecutableElement getMethod(String name) {
-        for (Element element : getEnclosedElements()) {
-            if (element.getKind() == ElementKind.METHOD && element.getSimpleName().toString().equals(name)) {
-                return (ExecutableElement) element;
-            }
-        }
-        return null;
-    }
-
     public List<ExecutableElement> getMethods() {
         return ElementFilter.methodsIn(getEnclosedElements());
     }
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/model/ExecutableTypeData.java	Thu Jan 22 20:42:48 2015 +0100
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/model/ExecutableTypeData.java	Thu Jan 22 20:44:24 2015 +0100
@@ -85,10 +85,6 @@
         return super.equals(obj);
     }

-    public boolean hasFrame() {
-        return getFrame() != null;
-    }
-
     public Parameter getFrame() {
         return findParameter("frameValue");
     }
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/model/MethodSpec.java	Thu Jan 22 20:42:48 2015 +0100
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/model/MethodSpec.java	Thu Jan 22 20:44:24 2015 +0100
@@ -89,15 +89,6 @@
         return specs;
     }

-    public ParameterSpec findParameterSpec(String name) {
-        for (ParameterSpec spec : getAll()) {
-            if (spec.getName().equals(name)) {
-                return spec;
-            }
-        }
-        return null;
-    }
-
     public void applyTypeDefinitions(String prefix) {
         this.typeDefinitions = createTypeDefinitions(prefix);
     }
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/model/NodeData.java	Thu Jan 22 20:42:48 2015 +0100
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/model/NodeData.java	Thu Jan 22 20:44:24 2015 +0100
@@ -155,10 +155,6 @@
         return false;
     }

-    public boolean isPolymorphic(ProcessorContext context) {
-        return needsRewrites(context);
-    }
-
     public List<CreateCastData> getCasts() {
         return casts;
     }
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/model/TemplateMethod.java	Thu Jan 22 20:42:48 2015 +0100
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/model/TemplateMethod.java	Thu Jan 22 20:44:24 2015 +0100
@@ -157,16 +157,6 @@
         return parameters;
     }

-    public List<Parameter> findParameters(ParameterSpec spec) {
-        List<Parameter> foundParameters = new ArrayList<>();
-        for (Parameter param : getReturnTypeAndParameters()) {
-            if (param.getSpecification().getName().equals(spec.getName())) {
-                foundParameters.add(param);
-            }
-        }
-        return foundParameters;
-    }
-
     public Parameter findParameterOrDie(NodeExecutionData execution) {
         for (Parameter parameter : parameters) {
             if (parameter.getSpecification().isSignature() && parameter.getSpecification().getExecution() == execution) {
@@ -200,11 +190,6 @@
         return Collections.unmodifiableList(allParameters);
     }

-    public boolean canBeAccessedByInstanceOf(TypeMirror type) {
-        TypeMirror methodType = ElementUtils.findNearestEnclosingType(getMethod()).asType();
-        return ElementUtils.isAssignable(type, methodType) || ElementUtils.isAssignable(methodType, type);
-    }
-
     public ExecutableElement getMethod() {
         return method;
     }
@@ -258,20 +243,6 @@
         return signature;
     }

-    public Parameter getSignatureParameter(int searchIndex) {
-        int index = 0;
-        for (Parameter parameter : getParameters()) {
-            if (!parameter.getSpecification().isSignature()) {
-                continue;
-            }
-            if (index == searchIndex) {
-                return parameter;
-            }
-            index++;
-        }
-        return null;
-    }
-
     public void updateSignature(TypeSignature signature) {
         // TODO(CH): fails in normal usage - output ok though
         // assert signature.size() >= 1;
@@ -311,19 +282,6 @@
         return compare;
     }

-    public List<Parameter> getParametersAfter(Parameter genericParameter) {
-        boolean found = false;
-        List<Parameter> foundParameters = new ArrayList<>();
-        for (Parameter param : getParameters()) {
-            if (param.getLocalName().equals(genericParameter.getLocalName())) {
-                found = true;
-            } else if (found) {
-                foundParameters.add(param);
-            }
-        }
-        return foundParameters;
-    }
-
     public int compareBySignature(TemplateMethod compareMethod) {
         final TypeSystemData typeSystem = getTemplate().getTypeSystem();
         if (typeSystem != compareMethod.getTemplate().getTypeSystem()) {
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/model/TypeSystemData.java	Thu Jan 22 20:42:48 2015 +0100
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/model/TypeSystemData.java	Thu Jan 22 20:44:24 2015 +0100
@@ -146,15 +146,6 @@
         return result;
     }

-    public TypeData findType(String simpleName) {
-        for (TypeData type : types) {
-            if (ElementUtils.getTypeId(type.getBoxedType()).equals(simpleName)) {
-                return type;
-            }
-        }
-        return null;
-    }
-
     public TypeData findTypeData(TypeMirror type) {
         if (ElementUtils.typeEquals(voidType.getPrimitiveType(), type)) {
             return voidType;
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/parser/NodeParser.java	Thu Jan 22 20:42:48 2015 +0100
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/parser/NodeParser.java	Thu Jan 22 20:44:24 2015 +0100
@@ -695,18 +695,13 @@
         initializeReachability(node);
         initializeContains(node);

-        if (!node.hasErrors() && !node.getTypeSystem().getOptions().useNewLayout()) {
-            initializeExceptions(node);
-        }
         resolveContains(node);

-        if (node.getTypeSystem().getOptions().useNewLayout()) {
-            List<SpecializationData> specializations = node.getSpecializations();
-            for (SpecializationData cur : specializations) {
-                for (SpecializationData child : specializations) {
-                    if (child != null && child != cur && child.getContains().contains(cur)) {
-                        cur.getExcludedBy().add(child);
-                    }
+        List<SpecializationData> specializations = node.getSpecializations();
+        for (SpecializationData cur : specializations) {
+            for (SpecializationData child : specializations) {
+                if (child != null && child != cur && child.getContains().contains(cur)) {
+                    cur.getExcludedBy().add(child);
                 }
             }
         }
@@ -763,40 +758,6 @@
         }
     }

-    private static void initializeExceptions(NodeData node) {
-        List<SpecializationData> specializations = node.getSpecializations();
-
-        for (int i = 0; i < specializations.size(); i++) {
-            SpecializationData cur = specializations.get(i);
-            if (cur.getExceptions().isEmpty()) {
-                continue;
-            }
-            SpecializationData next = i + 1 < specializations.size() ? specializations.get(i + 1) : null;
-
-            if (!cur.isContainedBy(next)) {
-                next.addError("This specialiation is not a valid exceptional rewrite target for %s. To fix this make %s compatible to %s or remove the exceptional rewrite.",
-                                cur.createReferenceName(), next != null ? next.createReferenceName() : "-", cur.createReferenceName());
-                continue;
-            }
-            Set<SpecializationData> nextContains = next != null ? next.getContains() : Collections.<SpecializationData> emptySet();
-            if (!nextContains.contains(cur)) {
-                nextContains.add(cur);
-            }
-        }
-
-        for (SpecializationData cur : specializations) {
-            if (cur.getExceptions().isEmpty()) {
-                continue;
-            }
-            for (SpecializationData child : specializations) {
-                if (child != null && child != cur && child.getContains().contains(cur)) {
-                    cur.getExcludedBy().add(child);
-                }
-            }
-        }
-
-    }
-
     private static void initializeContains(NodeData node) {
         for (SpecializationData specialization : node.getSpecializations()) {
             Set<SpecializationData> resolvedSpecializations = specialization.getContains();
@@ -1392,62 +1353,22 @@
         }
     }

-    private void verifyConstructors(NodeData nodeData) {
-        if (nodeData.getTypeSystem().getOptions().useNewLayout()) {
-            List<ExecutableElement> constructors = ElementFilter.constructorsIn(nodeData.getTemplateType().getEnclosedElements());
-            if (constructors.isEmpty()) {
-                return;
-            }
-
-            boolean oneNonPrivate = false;
-            for (ExecutableElement constructor : constructors) {
-                if (ElementUtils.getVisibility(constructor.getModifiers()) != Modifier.PRIVATE) {
-                    oneNonPrivate = true;
-                    break;
-                }
-            }
-            if (!oneNonPrivate && !nodeData.getTemplateType().getModifiers().contains(Modifier.PRIVATE)) {
-                nodeData.addError("At least one constructor must be non-private.");
-            }
-            return;
-        }
-        if (!nodeData.needsRewrites(context)) {
-            // no specialization constructor is needed if the node never rewrites.
+    private static void verifyConstructors(NodeData nodeData) {
+        List<ExecutableElement> constructors = ElementFilter.constructorsIn(nodeData.getTemplateType().getEnclosedElements());
+        if (constructors.isEmpty()) {
             return;
         }

-        TypeElement type = ElementUtils.fromTypeMirror(nodeData.getNodeType());
-        List<ExecutableElement> constructors = ElementFilter.constructorsIn(type.getEnclosedElements());
-
-        boolean parametersFound = false;
+        boolean oneNonPrivate = false;
         for (ExecutableElement constructor : constructors) {
-            if (!constructor.getParameters().isEmpty() && !isSourceSectionConstructor(context, constructor)) {
-                parametersFound = true;
+            if (ElementUtils.getVisibility(constructor.getModifiers()) != Modifier.PRIVATE) {
+                oneNonPrivate = true;
+                break;
             }
         }
-        if (!parametersFound) {
-            return;
+        if (!oneNonPrivate && !nodeData.getTemplateType().getModifiers().contains(Modifier.PRIVATE)) {
+            nodeData.addError("At least one constructor must be non-private.");
         }
-        for (ExecutableElement e : constructors) {
-            if (e.getParameters().size() == 1) {
-                TypeMirror firstArg = e.getParameters().get(0).asType();
-                if (ElementUtils.typeEquals(firstArg, nodeData.getNodeType())) {
-                    if (e.getModifiers().contains(Modifier.PRIVATE)) {
-                        nodeData.addError("The specialization constructor must not be private.");
-                    } else if (constructors.size() <= 1) {
-                        nodeData.addError("The specialization constructor must not be the only constructor. The definition of an alternative constructor is required.");
-                    }
-                    return;
-                }
-            }
-        }
-
-        // not found
-        nodeData.addError("Specialization constructor '%s(%s previousNode) { this(...); }' is required.", ElementUtils.getSimpleName(type), ElementUtils.getSimpleName(type));
-    }
-
-    public static boolean isSourceSectionConstructor(ProcessorContext context, ExecutableElement constructor) {
-        return constructor.getParameters().size() == 1 && ElementUtils.typeEquals(constructor.getParameters().get(0).asType(), context.getTruffleTypes().getSourceSection());
     }

     private AnnotationMirror findFirstAnnotation(List<? extends Element> elements, Class<? extends Annotation> annotation) {
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/parser/SpecializationGroup.java	Thu Jan 22 20:42:48 2015 +0100
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/parser/SpecializationGroup.java	Thu Jan 22 20:44:24 2015 +0100
@@ -26,7 +26,6 @@

 import javax.lang.model.type.*;

-import com.oracle.truffle.dsl.processor.*;
 import com.oracle.truffle.dsl.processor.java.*;
 import com.oracle.truffle.dsl.processor.model.*;
 import com.oracle.truffle.dsl.processor.model.TemplateMethod.TypeSignature;
@@ -81,15 +80,6 @@
         return collectedGuards;
     }

-    public TypeGuard findTypeGuard(int signatureIndex) {
-        for (TypeGuard guard : typeGuards) {
-            if (guard.getSignatureIndex() == signatureIndex) {
-                return guard;
-            }
-        }
-        return null;
-    }
-
     public List<GuardExpression> findElseConnectableGuards() {
         if (!getTypeGuards().isEmpty() || !getAssumptions().isEmpty()) {
             return Collections.emptyList();
@@ -423,26 +413,4 @@
         }
     }

-    public boolean isTypeGuardUsedInAnyGuardBelow(ProcessorContext context, SpecializationData source, TypeGuard typeGuard) {
-        NodeExecutionData execution = source.getNode().getChildExecutions().get(typeGuard.getSignatureIndex());
-
-        for (GuardExpression guard : guards) {
-            List<Parameter> guardParameters = guard.getResolvedGuard().findByExecutionData(execution);
-            Parameter sourceParameter = source.getSignatureParameter(typeGuard.getSignatureIndex());
-            for (Parameter guardParameter : guardParameters) {
-                if (sourceParameter.getTypeSystemType().needsCastTo(guardParameter.getType())) {
-                    return true;
-                }
-            }
-        }
-
-        for (SpecializationGroup group : getChildren()) {
-            if (group.isTypeGuardUsedInAnyGuardBelow(context, source, typeGuard)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
 }