Mercurial > hg > truffle

changeset 16823:96059fd563d4

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge.
author Doug Simon <doug.simon@oracle.com>
date Wed, 13 Aug 2014 18:36:52 +0200
parents 5d468add216f (current diff) 84f1c44b5e9b (diff)
children 28e29a4b0b97
files
diffstat 20 files changed, 134 insertions(+), 97 deletions(-) [+]
line wrap: on
line diff
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/generator/AbstractClassElementFactory.java	Wed Aug 13 18:25:45 2014 +0200
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/generator/AbstractClassElementFactory.java	Wed Aug 13 18:36:52 2014 +0200
@@ -128,7 +128,6 @@
         }
 
         clazz.addAnnotationMirror(generatedByAnnotation);
-
         return clazz;
     }
 }
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/generator/NodeCodeGenerator.java	Wed Aug 13 18:25:45 2014 +0200
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/generator/NodeCodeGenerator.java	Wed Aug 13 18:36:52 2014 +0200
@@ -322,12 +322,12 @@
     /**
      * <pre>
      * variant1 $condition != null
-     *
+     * 
      * $type $name = defaultValue($type);
      * if ($condition) {
      *     $name = $value;
      * }
-     *
+     * 
      * variant2 $condition != null
      * $type $name = $value;
      * </pre>
@@ -2617,14 +2617,22 @@
             NodeData node = specialization.getNode();
             CodeTypeElement clazz = getElement();
 
+            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(specialization, lastEvaluatedCount);
+                }
+
                 CodeExecutableElement executeMethod = createExecutableTypeOverride(execType, true);
                 clazz.add(executeMethod);
                 CodeTreeBuilder builder = executeMethod.getBuilder();
-                CodeTree result = createExecuteBody(builder, specialization, execType);
+                CodeTree result = createExecuteBody(builder, specialization, execType, primaryExecutes);
                 if (result != null) {
                     builder.tree(result);
                 } else {
@@ -2684,11 +2692,9 @@
             return builder.getRoot();
         }
 
-        private CodeTree createExecuteBody(CodeTreeBuilder parent, SpecializationData specialization, ExecutableTypeData execType) {
+        private CodeTree createExecuteBody(CodeTreeBuilder parent, SpecializationData specialization, ExecutableTypeData execType, List<ExecutableTypeData> primaryExecutes) {
             CodeTreeBuilder builder = new CodeTreeBuilder(parent);
 
-            List<ExecutableTypeData> primaryExecutes = findFunctionalExecutableType(specialization, execType.getEvaluatedCount());
-
             if (primaryExecutes.contains(execType) || primaryExecutes.isEmpty()) {
                 builder.tree(createFunctionalExecute(builder, specialization, execType));
             } else if (needsCastingExecuteMethod(execType)) {
@@ -2778,10 +2784,9 @@
 
             List<ExecutableTypeData> filteredTypes = new ArrayList<>();
             for (ExecutableTypeData compareType : otherTypes) {
-                if (!ElementUtils.typeEquals(compareType.getType().getPrimitiveType(), primaryType.getPrimitiveType())) {
-                    continue;
+                if (ElementUtils.typeEquals(compareType.getType().getPrimitiveType(), primaryType.getPrimitiveType())) {
+                    filteredTypes.add(compareType);
                 }
-                filteredTypes.add(compareType);
             }
 
             // no direct matches found use generic where the type is Object
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/generator/TypeSystemCodeGenerator.java	Wed Aug 13 18:25:45 2014 +0200
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/generator/TypeSystemCodeGenerator.java	Wed Aug 13 18:36:52 2014 +0200
@@ -87,20 +87,21 @@
             clazz.add(singleton);
 
             for (TypeData type : typeSystem.getTypes()) {
-                if (!type.isGeneric()) {
-                    clazz.addOptional(createIsTypeMethod(type));
-                    clazz.addOptional(createAsTypeMethod(type));
+                if (type.isGeneric() || type.isVoid()) {
+                    continue;
+                }
+                clazz.addOptional(createIsTypeMethod(type));
+                clazz.addOptional(createAsTypeMethod(type));
 
-                    for (TypeData sourceType : collectExpectSourceTypes(type)) {
-                        clazz.addOptional(createExpectTypeMethod(type, sourceType));
-                    }
+                for (TypeData sourceType : collectExpectSourceTypes(type)) {
+                    clazz.addOptional(createExpectTypeMethod(type, sourceType));
+                }
 
-                    clazz.addOptional(createAsImplicitTypeMethod(type, true));
-                    clazz.addOptional(createAsImplicitTypeMethod(type, false));
-                    clazz.addOptional(createIsImplicitTypeMethod(type, true));
-                    clazz.addOptional(createIsImplicitTypeMethod(type, false));
-                    clazz.addOptional(createGetTypeIndex(type));
-                }
+                clazz.addOptional(createAsImplicitTypeMethod(type, true));
+                clazz.addOptional(createAsImplicitTypeMethod(type, false));
+                clazz.addOptional(createIsImplicitTypeMethod(type, true));
+                clazz.addOptional(createIsImplicitTypeMethod(type, false));
+                clazz.addOptional(createGetTypeIndex(type));
             }
 
             return clazz;
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/java/ElementUtils.java	Wed Aug 13 18:25:45 2014 +0200
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/java/ElementUtils.java	Wed Aug 13 18:36:52 2014 +0200
@@ -41,7 +41,6 @@
 public class ElementUtils {
 
     public static TypeMirror getType(ProcessingEnvironment processingEnv, Class<?> element) {
-        TypeMirror mirror;
         if (element.isPrimitive()) {
             if (element == void.class) {
                 return processingEnv.getTypeUtils().getNoType(TypeKind.VOID);
@@ -67,11 +66,14 @@
                 assert false;
                 return null;
             }
-            mirror = processingEnv.getTypeUtils().getPrimitiveType(typeKind);
+            return processingEnv.getTypeUtils().getPrimitiveType(typeKind);
         } else {
-            mirror = processingEnv.getElementUtils().getTypeElement(element.getCanonicalName()).asType();
+            TypeElement typeElement = processingEnv.getElementUtils().getTypeElement(element.getCanonicalName());
+            if (typeElement == null) {
+                return null;
+            }
+            return typeElement.asType();
         }
-        return mirror;
     }
 
     public static ExecutableElement findExecutableElement(DeclaredType type, String name) {
@@ -898,24 +900,25 @@
     }
 
     public static boolean typeEquals(TypeMirror type1, TypeMirror type2) {
-        if (type1 == null && type2 == null) {
+        if (type1 == type2) {
             return true;
         } else if (type1 == null || type2 == null) {
             return false;
-        } else if (type1 == type2) {
-            return true;
-        }
-        String qualified1 = getQualifiedName(type1);
-        String qualified2 = getQualifiedName(type2);
-
-        if (type1.getKind() == TypeKind.ARRAY || type2.getKind() == TypeKind.ARRAY) {
-            if (type1.getKind() == TypeKind.ARRAY && type2.getKind() == TypeKind.ARRAY) {
-                return typeEquals(((ArrayType) type1).getComponentType(), ((ArrayType) type2).getComponentType());
+        } else {
+            if (type1.getKind() == type2.getKind()) {
+                return getUniqueIdentifier(type1).equals(getUniqueIdentifier(type2));
             } else {
                 return false;
             }
         }
-        return qualified1.equals(qualified2);
+    }
+
+    public static String getUniqueIdentifier(TypeMirror typeMirror) {
+        if (typeMirror.getKind() == TypeKind.ARRAY) {
+            return getUniqueIdentifier(((ArrayType) typeMirror).getComponentType()) + "[]";
+        } else {
+            return getQualifiedName(typeMirror);
+        }
     }
 
     public static int compareByTypeHierarchy(TypeMirror t1, TypeMirror t2) {
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/java/model/CodeElement.java	Wed Aug 13 18:25:45 2014 +0200
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/java/model/CodeElement.java	Wed Aug 13 18:36:52 2014 +0200
@@ -140,7 +140,7 @@
         getAnnotationMirrors().add(annotationMirror);
     }
 
-    protected void setEnclosingElement(Element parent) {
+    public void setEnclosingElement(Element parent) {
         this.enclosingElement = parent;
     }
 
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/java/model/CodeTypeElement.java	Wed Aug 13 18:25:45 2014 +0200
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/java/model/CodeTypeElement.java	Wed Aug 13 18:36:52 2014 +0200
@@ -121,7 +121,7 @@
     }
 
     @Override
-    protected void setEnclosingElement(Element element) {
+    public void setEnclosingElement(Element element) {
         super.setEnclosingElement(element);
 
         // update qualified name on container change
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/java/transform/OrganizedImports.java	Wed Aug 13 18:25:45 2014 +0200
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/java/transform/OrganizedImports.java	Wed Aug 13 18:36:52 2014 +0200
@@ -43,6 +43,7 @@
     private final Set<String> declaredStaticFields = new HashSet<>();
     private final Set<String> ambiguousStaticMethods = new HashSet<>();
     private final Set<String> ambiguousStaticFields = new HashSet<>();
+    private final Map<String, Set<String>> autoImportCache = new HashMap<>();
 
     private final CodeTypeElement topLevelClass;
 
@@ -223,8 +224,9 @@
         return allAmbiguous;
     }
 
-    private boolean needsImport(Element enclosedElement, TypeMirror importType) {
+    private boolean needsImport(Element enclosed, TypeMirror importType) {
         String importPackagName = getPackageName(importType);
+        TypeElement enclosedElement = findNearestEnclosingType(enclosed);
         if (importPackagName == null) {
             return false;
         } else if (importPackagName.equals("java.lang")) {
@@ -233,14 +235,18 @@
             return false; // same package name -> no import
         }
 
-        List<Element> elements = ElementUtils.getElementHierarchy(enclosedElement);
+        Set<String> autoImportedTypes = autoImportCache.get(enclosedElement.toString());
+        if (autoImportedTypes == null) {
+            List<Element> elements = ElementUtils.getElementHierarchy(enclosedElement);
+            autoImportedTypes = new HashSet<>();
+            for (Element element : elements) {
 
-        Set<String> autoImportedTypes = new HashSet<>();
-        for (Element element : elements) {
-            if (element.getKind().isClass()) {
-                collectSuperTypeImports((TypeElement) element, autoImportedTypes);
-                collectInnerTypeImports((TypeElement) element, autoImportedTypes);
+                if (element.getKind().isClass()) {
+                    collectSuperTypeImports((TypeElement) element, autoImportedTypes);
+                    collectInnerTypeImports((TypeElement) element, autoImportedTypes);
+                }
             }
+            autoImportCache.put(enclosedElement.toString(), autoImportedTypes);
         }
 
         String qualifiedName = getQualifiedName(importType);
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/model/ParameterSpec.java	Wed Aug 13 18:25:45 2014 +0200
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/model/ParameterSpec.java	Wed Aug 13 18:36:52 2014 +0200
@@ -34,6 +34,7 @@
 
     private final String name;
     private final List<TypeMirror> allowedTypes;
+    private final Set<String> allowedTypesIdentifier;
 
     /** Type is bound to local final variable. */
     private boolean local;
@@ -43,22 +44,24 @@
     private NodeExecutionData execution;
     private TypeDef typeDefinition;
 
-    public ParameterSpec(String name, List<TypeMirror> allowedTypes) {
+    public ParameterSpec(String name, List<TypeMirror> allowedTypes, Set<String> typeIdentifiers) {
         this.name = name;
         this.allowedTypes = allowedTypes;
+        this.allowedTypesIdentifier = typeIdentifiers;
     }
 
     public ParameterSpec(String name, TypeMirror type) {
-        this(name, Arrays.asList(type));
+        this(name, Arrays.asList(type), new HashSet<>(Arrays.asList(ElementUtils.getUniqueIdentifier(type))));
     }
 
-    public ParameterSpec(ParameterSpec o, List<TypeMirror> allowedTypes) {
+    public ParameterSpec(ParameterSpec o, List<TypeMirror> allowedTypes, Set<String> typeIdentifiers) {
         this.name = o.name;
         this.local = o.local;
         this.typeDefinition = o.typeDefinition;
         this.execution = o.execution;
         this.signature = o.signature;
         this.allowedTypes = allowedTypes;
+        this.allowedTypesIdentifier = typeIdentifiers;
     }
 
     public NodeExecutionData getExecution() {
@@ -103,12 +106,7 @@
     }
 
     public boolean matches(TypeMirror actualType) {
-        for (TypeMirror mirror : allowedTypes) {
-            if (ElementUtils.typeEquals(actualType, mirror)) {
-                return true;
-            }
-        }
-        return false;
+        return allowedTypesIdentifier.contains(ElementUtils.getUniqueIdentifier(actualType));
     }
 
     @Override
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/model/TypeData.java	Wed Aug 13 18:25:45 2014 +0200
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/model/TypeData.java	Wed Aug 13 18:36:52 2014 +0200
@@ -48,6 +48,10 @@
         this.boxedType = boxedType;
     }
 
+    public int getIndex() {
+        return index;
+    }
+
     @Override
     public Element getMessageElement() {
         return typeSystem.getMessageElement();
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/model/TypeSystemData.java	Wed Aug 13 18:25:45 2014 +0200
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/model/TypeSystemData.java	Wed Aug 13 18:36:52 2014 +0200
@@ -35,6 +35,7 @@
     private List<TypeData> types;
     private List<TypeMirror> primitiveTypeMirrors = new ArrayList<>();
     private List<TypeMirror> boxedTypeMirrors = new ArrayList<>();
+    private Map<String, TypeData> cachedTypes = new HashMap<>();
 
     private List<ImplicitCastData> implicitCasts;
     private List<TypeCastData> casts;
@@ -58,6 +59,8 @@
             for (TypeData typeData : types) {
                 primitiveTypeMirrors.add(typeData.getPrimitiveType());
                 boxedTypeMirrors.add(typeData.getBoxedType());
+                cachedTypes.put(ElementUtils.getUniqueIdentifier(typeData.getPrimitiveType()), typeData);
+                cachedTypes.put(ElementUtils.getUniqueIdentifier(typeData.getBoxedType()), typeData);
             }
         }
     }
@@ -116,6 +119,10 @@
         return primitiveTypeMirrors;
     }
 
+    public Set<String> getTypeIdentifiers() {
+        return cachedTypes.keySet();
+    }
+
     public List<TypeData> getTypes() {
         return types;
     }
@@ -125,7 +132,7 @@
     }
 
     public TypeData getGenericTypeData() {
-        TypeData result = types.get(types.size() - 1);
+        TypeData result = types.get(types.size() - 2);
         assert result.getBoxedType() == genericType;
         return result;
     }
@@ -152,10 +159,9 @@
     }
 
     public int findType(TypeMirror type) {
-        for (int i = 0; i < types.size(); i++) {
-            if (ElementUtils.typeEquals(types.get(i).getPrimitiveType(), type)) {
-                return i;
-            }
+        TypeData data = cachedTypes.get(ElementUtils.getUniqueIdentifier(type));
+        if (data != null) {
+            return data.getIndex();
         }
         return -1;
     }
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/parser/CreateCastParser.java	Wed Aug 13 18:25:45 2014 +0200
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/parser/CreateCastParser.java	Wed Aug 13 18:36:52 2014 +0200
@@ -99,7 +99,7 @@
     private static class InheritsParameterSpec extends ParameterSpec {
 
         public InheritsParameterSpec(String name, TypeMirror... allowedTypes) {
-            super(name, Arrays.asList(allowedTypes));
+            super(name, Arrays.asList(allowedTypes), null);
         }
 
         @Override
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/parser/ExecutableTypeMethodParser.java	Wed Aug 13 18:25:45 2014 +0200
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/parser/ExecutableTypeMethodParser.java	Wed Aug 13 18:36:52 2014 +0200
@@ -47,20 +47,31 @@
         spec.getRequired().clear();
 
         List<TypeMirror> allowedTypes = getNode().getTypeSystem().getPrimitiveTypeMirrors();
+        Set<String> allowedIdentifiers = getNode().getTypeSystem().getTypeIdentifiers();
         for (ParameterSpec originalSpec : requiredSpecs) {
-            spec.addRequired(new ParameterSpec(originalSpec, allowedTypes));
+            spec.addRequired(new ParameterSpec(originalSpec, allowedTypes, allowedIdentifiers));
         }
         spec.setIgnoreAdditionalSpecifications(true);
         spec.setIgnoreAdditionalParameters(true);
         spec.setVariableRequiredParameters(true);
         // varargs
-        ParameterSpec otherParameters = new ParameterSpec("other", allowedTypes);
+        ParameterSpec otherParameters = new ParameterSpec("other", allowedTypes, allowedIdentifiers);
         otherParameters.setSignature(true);
         spec.addRequired(otherParameters);
         return spec;
     }
 
     @Override
+    protected List<TypeMirror> nodeTypeMirrors(NodeData nodeData) {
+        return getNode().getTypeSystem().getPrimitiveTypeMirrors();
+    }
+
+    @Override
+    protected Set<String> nodeTypeIdentifiers(NodeData nodeData) {
+        return getNode().getTypeSystem().getTypeIdentifiers();
+    }
+
+    @Override
     public final boolean isParsable(ExecutableElement method) {
         if (method.getModifiers().contains(Modifier.STATIC)) {
             return false;
@@ -71,13 +82,6 @@
     }
 
     @Override
-    protected List<TypeMirror> nodeTypeMirrors(NodeData nodeData) {
-        List<TypeMirror> types = new ArrayList<>(getNode().getTypeSystem().getPrimitiveTypeMirrors());
-        types.add(getNode().getTypeSystem().getVoidType().getPrimitiveType());
-        return types;
-    }
-
-    @Override
     public ExecutableTypeData create(TemplateMethod method, boolean invalid) {
         TypeData resolvedType = method.getReturnType().getTypeSystemType();
         return new ExecutableTypeData(method, method.getMethod(), getNode().getTypeSystem(), resolvedType);
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/parser/GenericParser.java	Wed Aug 13 18:25:45 2014 +0200
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/parser/GenericParser.java	Wed Aug 13 18:36:52 2014 +0200
@@ -30,6 +30,7 @@
 
 import com.oracle.truffle.api.dsl.*;
 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.SpecializationData.SpecializationKind;
 
@@ -48,10 +49,13 @@
     protected ParameterSpec createValueParameterSpec(NodeExecutionData execution) {
         List<ExecutableTypeData> execTypes = execution.getChild().findGenericExecutableTypes(getContext());
         List<TypeMirror> types = new ArrayList<>();
+        Set<String> typeIds = new HashSet<>();
         for (ExecutableTypeData type : execTypes) {
-            types.add(type.getType().getPrimitiveType());
+            TypeMirror typeMirror = type.getType().getPrimitiveType();
+            types.add(typeMirror);
+            typeIds.add(ElementUtils.getUniqueIdentifier(typeMirror));
         }
-        ParameterSpec spec = new ParameterSpec(execution.getName(), types);
+        ParameterSpec spec = new ParameterSpec(execution.getName(), types, typeIds);
         spec.setExecution(execution);
         return spec;
     }
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/parser/GuardParser.java	Wed Aug 13 18:25:45 2014 +0200
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/parser/GuardParser.java	Wed Aug 13 18:36:52 2014 +0200
@@ -58,7 +58,13 @@
         if (compatibleSource != null) {
             spec.getRequired().clear();
             for (Parameter parameter : compatibleSource.getRequiredParameters()) {
-                spec.addRequired(new ParameterSpec(parameter.getSpecification(), ElementUtils.getAssignableTypes(getContext(), parameter.getType())));
+                List<TypeMirror> typeMirrors = ElementUtils.getAssignableTypes(getContext(), parameter.getType());
+                Set<String> typeIds = new HashSet<>();
+                for (TypeMirror typeMirror : typeMirrors) {
+                    typeIds.add(ElementUtils.getUniqueIdentifier(typeMirror));
+                }
+
+                spec.addRequired(new ParameterSpec(parameter.getSpecification(), typeMirrors, typeIds));
             }
         }
         return spec;
@@ -73,6 +79,11 @@
     }
 
     @Override
+    protected Set<String> nodeTypeIdentifiers(NodeData nodeData) {
+        return nodeData.getTypeSystem().getTypeIdentifiers();
+    }
+
+    @Override
     protected ParameterSpec createReturnParameterSpec() {
         return new ParameterSpec("returnType", getContext().getType(boolean.class));
     }
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/parser/ImplicitCastParser.java	Wed Aug 13 18:25:45 2014 +0200
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/parser/ImplicitCastParser.java	Wed Aug 13 18:36:52 2014 +0200
@@ -45,12 +45,10 @@
 
     @Override
     public MethodSpec createSpecification(ExecutableElement method, AnnotationMirror mirror) {
-        List<TypeMirror> types = new ArrayList<>();
-        for (TypeData typeData : getTypeSystem().getTypes()) {
-            types.add(typeData.getPrimitiveType());
-        }
-        MethodSpec spec = new MethodSpec(new ParameterSpec("target", types));
-        spec.addRequired(new ParameterSpec("source", types));
+        List<TypeMirror> types = getTypeSystem().getPrimitiveTypeMirrors();
+        Set<String> identifiers = getTypeSystem().getTypeIdentifiers();
+        MethodSpec spec = new MethodSpec(new ParameterSpec("target", types, identifiers));
+        spec.addRequired(new ParameterSpec("source", types, identifiers));
         return spec;
     }
 
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/parser/NodeMethodParser.java	Wed Aug 13 18:25:45 2014 +0200
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/parser/NodeMethodParser.java	Wed Aug 13 18:36:52 2014 +0200
@@ -42,25 +42,21 @@
     }
 
     protected ParameterSpec createValueParameterSpec(NodeExecutionData execution) {
-        ParameterSpec spec = new ParameterSpec(execution.getName(), nodeTypeMirrors(execution.getChild().getNodeData()));
+        ParameterSpec spec = new ParameterSpec(execution.getName(), nodeTypeMirrors(execution.getChild().getNodeData()), nodeTypeIdentifiers(execution.getChild().getNodeData()));
         spec.setExecution(execution);
         return spec;
     }
 
     protected List<TypeMirror> nodeTypeMirrors(NodeData nodeData) {
-        Set<TypeMirror> typeMirrors = new LinkedHashSet<>();
+        return nodeData.getTypeSystem().getPrimitiveTypeMirrors();
+    }
 
-        for (ExecutableTypeData typeData : nodeData.getExecutableTypes()) {
-            typeMirrors.add(typeData.getType().getPrimitiveType());
-        }
-
-        typeMirrors.add(nodeData.getTypeSystem().getGenericType());
-
-        return new ArrayList<>(typeMirrors);
+    protected Set<String> nodeTypeIdentifiers(NodeData nodeData) {
+        return nodeData.getTypeSystem().getTypeIdentifiers();
     }
 
     protected ParameterSpec createReturnParameterSpec() {
-        ParameterSpec returnValue = new ParameterSpec("returnValue", nodeTypeMirrors(getNode()));
+        ParameterSpec returnValue = new ParameterSpec("returnValue", nodeTypeMirrors(getNode()), nodeTypeIdentifiers(getNode()));
         returnValue.setExecution(getNode().getThisExecution());
         return returnValue;
     }
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/parser/NodeParser.java	Wed Aug 13 18:25:45 2014 +0200
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/parser/NodeParser.java	Wed Aug 13 18:36:52 2014 +0200
@@ -145,6 +145,7 @@
             return node; // error sync point
         }
 
+        node.setExecutableTypes(groupExecutableTypes(new ExecutableTypeMethodParser(context, node).parse(elements)));
         initializeChildren(node);
 
         node.getSpecializations().addAll(new SpecializationMethodParser(context, node).parse(elements));
@@ -209,7 +210,6 @@
         List<NodeExecutionData> executions = parseExecutions(children, elements);
 
         NodeData nodeData = new NodeData(context, templateType, shortName, typeSystem, children, executions, fields, assumptionsList);
-        nodeData.setExecutableTypes(groupExecutableTypes(new ExecutableTypeMethodParser(context, nodeData).parse(elements)));
 
         parsedNodes.put(ElementUtils.getQualifiedName(templateType), nodeData);
 
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/parser/TypeCastParser.java	Wed Aug 13 18:25:45 2014 +0200
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/parser/TypeCastParser.java	Wed Aug 13 18:36:52 2014 +0200
@@ -44,7 +44,7 @@
             return null;
         }
         MethodSpec spec = new MethodSpec(new ParameterSpec("returnType", targetType.getPrimitiveType()));
-        spec.addRequired(new ParameterSpec("value", getTypeSystem().getPrimitiveTypeMirrors()));
+        spec.addRequired(new ParameterSpec("value", getTypeSystem().getPrimitiveTypeMirrors(), getTypeSystem().getTypeIdentifiers()));
         return spec;
     }
 
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/parser/TypeCheckParser.java	Wed Aug 13 18:25:45 2014 +0200
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/parser/TypeCheckParser.java	Wed Aug 13 18:36:52 2014 +0200
@@ -43,7 +43,7 @@
             return null;
         }
         MethodSpec spec = new MethodSpec(new ParameterSpec("returnType", getContext().getType(boolean.class)));
-        spec.addRequired(new ParameterSpec("value", getTypeSystem().getPrimitiveTypeMirrors()));
+        spec.addRequired(new ParameterSpec("value", getTypeSystem().getPrimitiveTypeMirrors(), getTypeSystem().getTypeIdentifiers()));
         return spec;
     }
 
--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/parser/TypeSystemParser.java	Wed Aug 13 18:25:45 2014 +0200
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/parser/TypeSystemParser.java	Wed Aug 13 18:36:52 2014 +0200
@@ -67,14 +67,17 @@
             return typeSystem;
         }
 
-        typeSystem.setTypes(parseTypes(typeSystem));
+        List<TypeData> types = parseTypes(typeSystem);
+
+        TypeMirror genericType = context.getType(Object.class);
+        TypeData voidType = new TypeData(typeSystem, types.size(), null, context.getType(void.class), context.getType(Void.class));
+        types.add(voidType);
+
+        typeSystem.setTypes(types);
         if (typeSystem.hasErrors()) {
             return typeSystem;
         }
 
-        TypeMirror genericType = context.getType(Object.class);
-        TypeData voidType = new TypeData(typeSystem, typeSystem.getTypes().size(), null, context.getType(void.class), context.getType(Void.class));
-
         typeSystem.setGenericType(genericType);
         typeSystem.setVoidType(voidType);
 
@@ -198,7 +201,6 @@
         verifyTypeOrder(types);
 
         types.add(new TypeData(typeSystem, index, annotationValue, objectType, objectType));
-
         return types;
     }