Implement primitive overload selection if argument types are exact.

Author: chumer

truffle/src/com.oracle.truffle.api.dsl.test/src/com/oracle/truffle/api/dsl/test/MethodGuardIdempotentTest.java

@@ -329,4 +329,33 @@ public String s1(TestObject arg) {
 
     }
 
+    @SuppressWarnings("unused")
+    abstract static class MethodOverloadIdempotentNode extends SlowPathListenerNode {
+
+        static final TestObject VALUE = null;
+
+        abstract String execute(TestObject arg);
+
+        // no warning here: guard(TestObject arg) should get selected by overload.
+        @Specialization(guards = {"guard(VALUE)"})
+        public String s0(TestObject arg) {
+            return "s0";
+        }
+
+        public static boolean guard(Object arg) {
+            return arg == null;
+        }
+
+        @NonIdempotent
+        public static boolean guard(TestObject arg) {
+            return arg == null;
+        }
+
+        @Specialization
+        public String s1(TestObject arg) {
+            return "s1";
+        }
+
+    }
+
 }

truffle/src/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/expression/DSLExpressionResolver.java

@@ -188,13 +188,28 @@ public ExecutableElement lookupMethod(String searchName, List<TypeMirror> search
         lazyProcess();
         List<ExecutableElement> methodsWithName = this.methods.get(searchName);
         ExecutableElement foundWithName = null;
+        ExecutableElement found = null;
+        List<ExecutableElement> overloads = null;
         if (methodsWithName != null) {
             for (ExecutableElement method : methodsWithName) {
                 if (matchExecutable(searchName, searchParameters, method) && ElementUtils.isVisible(accessType, method)) {
-                    return method;
+                    if (found == null) {
+                        found = method;
+                    } else {
+                        if (overloads == null) {
+                            overloads = new ArrayList<>();
+                            overloads.add(found);
+                        }
+                        overloads.add(method);
+                    }
                 }
                 foundWithName = method;
             }
+            if (overloads != null) {
+                return selectOverload(overloads, searchParameters);
+            } else if (found != null) {
+                return found;
+            }
         }
         if (parent != null) {
             ExecutableElement parentResult = parent.lookupMethod(searchName, searchParameters);
@@ -238,6 +253,20 @@ public static boolean matchExecutable(String name, List<TypeMirror> searchParame
         return true;
     }
 
+    private static ExecutableElement selectOverload(List<ExecutableElement> overloads, List<TypeMirror> searchParameters) {
+        method: for (ExecutableElement method : overloads) {
+            for (int i = 0; i < searchParameters.size(); i++) {
+                TypeMirror searchParameter = searchParameters.get(i);
+                TypeMirror actualParameter = method.getParameters().get(i).asType();
+                if (!ElementUtils.typeEquals(searchParameter, actualParameter)) {
+                    continue method;
+                }
+            }
+            return method;
+        }
+        return overloads.get(0);
+    }
+
     private VariableElement resolveVariable(Variable variable) {
         final String name = variable.getName();