--- a/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/model/ExecutableTypeData.java	Tue Apr 14 22:12:03 2015 +0200
+++ b/graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/model/ExecutableTypeData.java	Tue Apr 14 15:12:48 2015 +0200
@@ -22,67 +22,111 @@
  */
 package com.oracle.truffle.dsl.processor.model;
 
+import java.util.*;
+
 import javax.lang.model.element.*;
+import javax.lang.model.type.*;
 
 import com.oracle.truffle.api.nodes.*;
 import com.oracle.truffle.dsl.processor.*;
 import com.oracle.truffle.dsl.processor.java.*;
 
-public class ExecutableTypeData extends TemplateMethod {
+public class ExecutableTypeData extends MessageContainer implements Comparable<ExecutableTypeData> {
 
-    private final TypeSystemData typeSystem;
-    private final TypeData type;
+    private final ExecutableElement method;
+    private final TypeMirror frameParameter;
+    private final List<TypeMirror> evaluatedParameters;
+
+    public ExecutableTypeData(ExecutableElement method, int signatureSize, List<TypeMirror> frameTypes) {
+        this.method = method;
+        TypeMirror foundFrameParameter = null;
+        List<? extends VariableElement> parameters = method.getParameters();
 
-    public ExecutableTypeData(TemplateMethod method, ExecutableElement executable, TypeSystemData typeSystem, TypeData type) {
-        super(method, executable);
-        this.typeSystem = typeSystem;
-        this.type = type;
-        if (executable.getParameters().size() < method.getMethod().getParameters().size()) {
-            throw new IllegalArgumentException(String.format("Method parameter count mismatch %s != %s.", executable.getParameters(), method.getMethod().getParameters()));
+        int parameterIndex = 0;
+        evaluatedParameters = new ArrayList<>();
+        if (!parameters.isEmpty()) {
+            TypeMirror firstParameter = parameters.get(0).asType();
+            for (TypeMirror frameType : frameTypes) {
+                if (ElementUtils.typeEquals(firstParameter, frameType)) {
+                    foundFrameParameter = firstParameter;
+                    parameterIndex++;
+                    break;
+                }
+            }
         }
+
+        int numberParameters = Math.max(parameters.size() - parameterIndex, signatureSize);
+        for (int i = 0; i < numberParameters; i++) {
+            TypeMirror parameter;
+            if (method.isVarArgs() && parameterIndex >= parameters.size() - 1) {
+                ArrayType varArgsArray = (ArrayType) parameters.get(parameters.size() - 1).asType();
+                parameter = varArgsArray.getComponentType();
+            } else if (parameterIndex < parameters.size()) {
+                parameter = parameters.get(parameterIndex).asType();
+            } else {
+                break;
+            }
+            parameterIndex++;
+            evaluatedParameters.add(parameter);
+        }
+        this.frameParameter = foundFrameParameter;
     }
 
-    public TypeData getType() {
-        return type;
+    public ExecutableElement getMethod() {
+        return method;
+    }
+
+    public String getName() {
+        return method.getSimpleName().toString();
+    }
+
+    @Override
+    public Element getMessageElement() {
+        return method;
+    }
+
+    public List<TypeMirror> getEvaluatedParameters() {
+        return evaluatedParameters;
     }
 
-    public TypeSystemData getTypeSystem() {
-        return typeSystem;
+    public int getVarArgsIndex(int parameterIndex) {
+        if (method.isVarArgs()) {
+            int index = parameterIndex - (method.getParameters().size() - 1);
+            return index;
+        }
+        return -1;
+    }
+
+    public int getParameterIndex(int signatureIndex) {
+        return frameParameter != null ? signatureIndex + 1 : signatureIndex;
+    }
+
+    public TypeMirror getFrameParameter() {
+        return frameParameter;
+    }
+
+    public TypeMirror getReturnType() {
+        return method.getReturnType();
     }
 
     public boolean hasUnexpectedValue(ProcessorContext context) {
-        return ElementUtils.canThrowType(getMethod().getThrownTypes(), context.getType(UnexpectedResultException.class));
+        return ElementUtils.canThrowType(method.getThrownTypes(), context.getType(UnexpectedResultException.class));
     }
 
     public boolean isFinal() {
-        return getMethod().getModifiers().contains(Modifier.FINAL);
+        return method.getModifiers().contains(Modifier.FINAL);
     }
 
     public boolean isAbstract() {
-        return getMethod().getModifiers().contains(Modifier.ABSTRACT);
+        return method.getModifiers().contains(Modifier.ABSTRACT);
     }
 
     public int getEvaluatedCount() {
-        int count = 0;
-        for (Parameter parameter : getParameters()) {
-            if (parameter.getSpecification().isSignature()) {
-                count++;
-            }
-        }
-        return count;
+        return evaluatedParameters.size();
     }
 
-    @Override
-    public int hashCode() {
-        return type.hashCode();
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (obj instanceof ExecutableTypeData) {
-            return type.equals(((ExecutableTypeData) obj).type);
-        }
-        return super.equals(obj);
+    public int compareTo(ExecutableTypeData o) {
+        return ElementUtils.compareMethod(method, o.getMethod());
     }
 
 }