Issue1795

First, note that threading.py contains these two classes:

class JavaThread(object):
class Thread(JavaThread):

That is, "JavaThread" extends only python objects (although it contains a native java thread). Therefore, it should be possible to extend both Thread and a java interface, and then pass an instance of the resulting class to a java function accepting the interface.  However, if you try something like that after defining a single-method interface and a function that accepts an instance of that interface:

# BEGIN
from com.invitemedia.jython import JythonTestMethods
from com.invitemedia.jython import StringInterface
from threading import Thread

class Foo(Thread, StringInterface):
  def stringMethod(self):
    return "yo yo yo"

a = JythonTestMethods()

print a.doStringInterfaceThing(Foo())
# END

You end up with this error:

$ CLASSPATH=bin /opt/jython*/bin/jython ~/testThreadtojava.py 
Traceback (most recent call last):
  File "/home/dtm/testThreadtojava.py", line 11, in <module>
    print a.doStringInterfaceThing(Foo())
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:616)

java.lang.IllegalArgumentException: java.lang.IllegalArgumentException: argument type mismatch

The issue is a combination of how threading.JavaThread overrides __tojava__ and how PyObjectDerived implements __tojava__.

JavaThread says:
    def __tojava__(self, c):
        if isinstance(self._thread, c):
            return self._thread
        if isinstance(self, c):
            return self
        return Py.NoConversion

PyObjectDerived says (in part, but this is the relevant part):
        PyType self_type=getType();
        PyObject impl=self_type.lookup("__tojava__");
        if (impl!=null)
            return impl.__get__(this,self_type).__call__(Py.java2py(c)).__tojava__(Object.class);
        return super.__tojava__(c);

What happens is that JavaThread's __tojava__ method is first called with StringInterface; this hits the "return self" line, which then results in JavaThread's __tojava__ method being called with Java.lang.Object and hitting the "return self._thread" line. The end result is that PyObjectDerived's __tojava__ called with StringInterface.class returns an org.python.core.FunctionThread object.

I think that the best solution to this is to modify PyObjectDerived so that if  __call__ to the __tojava__ method returns *this*, we delegate to super.__tojava__(c). Patch attached.

With the patch applied, the script above works as it should.

Hey Jim - I put you on this one since you have the most experience with our threading story. What do you think? If you think it looks good but don't have time to apply it I can double check it and apply. To me it looks like it might break backwards compatibility and so would be more of a 2.6/trunk thing. On the other hand it does fix a demonstrable bug.

Ah I see now that this is not really a threading thing but an inheritance thing.

Target beta 4, we got what appears to be a minimal and simple patch, we only need to add a test

Fixed as of https://hg.python.org/jython/rev/c8d3b553d93d