CLJ-2454 When reflectively finding a matching method, also check whether the method is module accessible to call, and if not use an accessible super method

Signed-off-by: Stuart Halloway <[email protected]>

Author: puredanger

src/jvm/clojure/lang/Reflector.java

@@ -153,11 +153,11 @@ else if(methods.size() == 1)
 	if(m == null)
 		throw new IllegalArgumentException(noMethodReport(methodName,target,args));
 
-	if(!Modifier.isPublic(m.getDeclaringClass().getModifiers()))
+	if(!Modifier.isPublic(m.getDeclaringClass().getModifiers()) || !canAccess(m, target))
 		{
 		//public method of non-public class, try to find it in hierarchy
 		Method oldm = m;
-		m = getAsMethodOfPublicBase(target.getClass(), m);
+		m = getAsMethodOfAccessibleBase(target.getClass(), m, target);
 		if(m == null)
 			throw new IllegalArgumentException("Can't call public method of non-public class: " +
 			                                    oldm.toString());
@@ -173,6 +173,7 @@ else if(methods.size() == 1)
 
 }
 
+// DEPRECATED - replaced by getAsMethodOfAccessibleBase()
 public static Method getAsMethodOfPublicBase(Class c, Method m){
 	for(Class iface : c.getInterfaces())
 		{
@@ -197,6 +198,7 @@ public static Method getAsMethodOfPublicBase(Class c, Method m){
 	return getAsMethodOfPublicBase(sc, m);
 }
 
+// DEPRECATED - replaced by isAccessibleMatch()
 public static boolean isMatch(Method lhs, Method rhs) {
 	if(!lhs.getName().equals(rhs.getName())
 			|| !Modifier.isPublic(lhs.getDeclaringClass().getModifiers()))
@@ -221,6 +223,55 @@ public static boolean isMatch(Method lhs, Method rhs) {
 		return match;
 }
 
+public static Method getAsMethodOfAccessibleBase(Class c, Method m, Object target){
+	for(Class iface : c.getInterfaces())
+	{
+		for(Method im : iface.getMethods())
+		{
+			if(isAccessibleMatch(im, m, target))
+			{
+				return im;
+			}
+		}
+	}
+	Class sc = c.getSuperclass();
+	if(sc == null)
+		return null;
+	for(Method scm : sc.getMethods())
+	{
+		if(isAccessibleMatch(scm, m, target))
+		{
+			return scm;
+		}
+	}
+	return getAsMethodOfAccessibleBase(sc, m, target);
+}
+
+public static boolean isAccessibleMatch(Method lhs, Method rhs, Object target) {
+	if(!lhs.getName().equals(rhs.getName())
+			|| !Modifier.isPublic(lhs.getDeclaringClass().getModifiers())
+			|| !canAccess(lhs, target))
+	{
+		return false;
+	}
+
+	Class[] types1 = lhs.getParameterTypes();
+	Class[] types2 = rhs.getParameterTypes();
+	if(types1.length != types2.length)
+		return false;
+
+	boolean match = true;
+	for (int i=0; i<types1.length; ++i)
+	{
+		if(!types1[i].isAssignableFrom(types2[i]))
+		{
+			match = false;
+			break;
+		}
+	}
+	return match;
+}
+
 public static Object invokeConstructor(Class c, Object[] args) {
 	try
 		{