Issue1681

[submitted on behalf of Christian Blichmann]

Calling methods from an embedded Jython script does nothing when
using JSR-223 and Jython 2.5.2rc2, while Jython 2.2.1 just works fine.

- ------------- myscript/ScriptingTest.java -------------
package myscript;

import java.io.InputStream;
import java.io.InputStreamReader;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;

public class ScriptingTest {
   public static void main(String[] args) {
       try {
           final ScriptEngineManager manager =
               new ScriptEngineManager();
           final ScriptEngine engine =
               manager.getEngineByName("python");

           final InputStream is =
               ScriptingTest.class.getResourceAsStream(
                       "/myscript/myscript.py");
           engine.eval(new InputStreamReader(is));
       } catch (final Exception e) {
           e.printStackTrace();
       }
   }
}
- ------------- myscript/PythonCallable.java -------------
package myscript;

public interface PythonCallable {
   String getAString();
   void callAVoid();
}
- ------------- myscript/myscript.py -------------
from myscript import PythonCallable as PythonCallable

class MyPythonCallable(PythonCallable):
   def getAString(self):
       return 'A string'

   def callAVoid(self):
       print 'Called a void method'

print 'getAString() returns: %s' % \
   MyPythonCallable().getAString()
print 'callAVoid():'
MyPythonCallable().callAVoid()
- ------------------------------------------------

Using Jython 2.2.1, I get:
 $ java -cp .:jython.jar:jython-engine.jar myscript.ScriptingTest
 getAString() returns: A string
 callAVoid():
 Called a void method

The problem here lies in PyScriptEngineScope.__setitem__. All values that pass through it are first converted via value.__tojava__(Object.class)

In this case, the __tojava__ call is made on the user defined MyPythonCallable class. Its __tojava__ returns its Proxy object here, which is the cause of the havoc we're seeing

I'm not sure who's at fault -- Nick, what's the point of the __tojava__(Object.class) call here? Is it necessary in all cases?

We either need to add special cases to the scope__setitem__, or fix the __tojava__ result for user defined classes that have an underlying proxy. Might the latter break anything else?

I never really understood the full implications of __tojava__ so I think I was probably just copying something else (perhaps the previous JSR 223 implementation).  Please feel free to change it as you wish.

It seems the original jsr223 impl had a similar issue to this one:

https://scripting.dev.java.net/issues/show_bug.cgi?id=5

Its fix (which was really for Jython 2.2) basically added this line to __setitem__

            if (!(obj instanceof PyClass)) {
                obj = JythonScriptEngine.py2java(value);
            }

This isn't the most efficient fix in the world (adding an instanceof check for any kind of assignment). But whatever -- I propose the attached patch with a similar fix

Their JythonScope class with their fix is here:

https://scripting.dev.java.net/source/browse/scripting/engines/jython/src/com/sun/script/jython/JythonScope.java?rev=1.2&view=markup

I mean, we're already doing a __tojava__(Object.class) for every assignment so an additional instanceof check shouldn't matter

fix+test applied in r7175