[GR-26694] Allow subclassing of Java classes

PullRequest: graalpython/1656

Author: ppisl

CHANGELOG.md

@@ -3,6 +3,10 @@
 This changelog summarizes major changes between GraalVM versions of the Python
 language runtime. The main focus is on user-observable behavior of the engine.
 
+## Version 21.1.0
+
+* Added subclassing of Java classes in JVM mode
+
 ## Version 21.0.0
 
 * Implement name mangling for private attributes

graalpython/com.oracle.graal.python.test/src/tests/test_interop.py

@@ -522,6 +522,99 @@ def test_isinstance02():
             assert isinstance(h, HashMap)
             assert isinstance(h, Map)
 
+    def test_is_type():
+        import java
+        from java.util.logging import Handler
+        from java.util import Set
+        from java.util.logging import LogRecord
+        from java.util.logging import Level
+        
+        assert java.is_type(Handler)
+        assert java.is_type(LogRecord)
+        assert java.is_type(Set)
+        assert java.is_type(Level)
+        
+        lr = LogRecord(Level.ALL, "message")
+        assert not java.is_type(lr)
+        assert not java.is_type(Level.ALL)
+        assert not java.is_type("ahoj")
+                
+    def test_extend_java_class_01():
+        from java.util.logging import Handler
+        from java.util.logging import LogRecord
+        from java.util.logging import Level
+
+        lr = LogRecord(Level.ALL, "The first message")
+
+        # extender object
+        class MyHandler (Handler):
+            "This is MyHandler doc"
+            counter = 0;
+            def isLoggable(self, logrecord):
+                self.counter = self.counter + 1
+                return self.__super__.isLoggable(logrecord)
+            def sayHello(self):
+                return 'Hello'  
+
+        h = MyHandler()
+        
+        # accessing extender object via this property
+        assert hasattr(h, 'this')
+        assert hasattr(h.this, 'sayHello')
+        assert hasattr(h.this, 'counter')
+        assert hasattr(h.this, 'isLoggable')
+        
+        #accessing java methods or methods from extender object directly
+        assert hasattr(h, 'close')
+        assert hasattr(h, 'flush')
+        assert hasattr(h, 'getEncoding')
+        assert hasattr(h, 'setEncoding')
+        
+        
+        assert h.this.counter == 0
+        assert h.isLoggable(lr)
+        assert h.this.counter == 1
+        assert h.isLoggable(lr)
+        assert h.isLoggable(lr)
+        assert h.this.counter == 3
+        
+        assert 'Hello' == h.this.sayHello()
+
+        h2 = MyHandler()
+        assert h2.this.counter == 0
+        assert h2.isLoggable(lr)
+        assert h2.this.counter == 1
+        assert h.this.counter == 3
+        
+    def test_extend_java_class_02():
+        from java.math import BigDecimal
+        try:
+            class MyDecimal(BigDecimal):
+                pass
+        except TypeError:
+            assert True
+        else:
+            assert False
+        
+    def test_extend_java_class_03():
+        #test of java constructor
+        from java.util.logging import LogRecord
+        from java.util.logging import Level
+        
+        class MyLogRecord(LogRecord):
+            def getLevel(self):
+                if self.__super__.getLevel() == Level.FINEST:
+                    self.__super__.setLevel(Level.WARNING)
+                return self.__super__.getLevel()
+        
+        message = "log message"
+        my_lr1 = MyLogRecord(Level.WARNING, message)
+        assert my_lr1.getLevel() == Level.WARNING
+        assert my_lr1.getMessage() == message
+        
+        my_lr2 = MyLogRecord(Level.FINEST, message)
+        assert my_lr2.getLevel() == Level.WARNING
+        
     def test_foreign_slice_setting():
         import java
         il = java.type("int[]")(20)

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/GraalPythonModuleBuiltins.java

@@ -95,6 +95,8 @@
 import com.oracle.graal.python.runtime.PythonContext;
 import com.oracle.graal.python.runtime.PythonCore;
 import com.oracle.graal.python.runtime.PythonOptions;
+import static com.oracle.graal.python.runtime.exception.PythonErrorType.SystemError;
+import static com.oracle.graal.python.runtime.exception.PythonErrorType.TypeError;
 import com.oracle.graal.python.runtime.object.PythonObjectFactory;
 import com.oracle.graal.python.runtime.sequence.storage.SequenceStorage;
 import com.oracle.graal.python.util.PythonUtils;
@@ -103,6 +105,7 @@
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.RootCallTarget;
 import com.oracle.truffle.api.TruffleFile;
+import com.oracle.truffle.api.TruffleLanguage;
 import com.oracle.truffle.api.TruffleLanguage.Env;
 import com.oracle.truffle.api.TruffleLogger;
 import com.oracle.truffle.api.TruffleOptions;
@@ -116,6 +119,9 @@
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.dsl.TypeSystemReference;
 import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.interop.InteropLibrary;
+import com.oracle.truffle.api.interop.UnknownIdentifierException;
+import com.oracle.truffle.api.interop.UnsupportedMessageException;
 import com.oracle.truffle.api.library.CachedLibrary;
 import com.oracle.truffle.api.nodes.LanguageInfo;
 import com.oracle.truffle.api.nodes.Node;
@@ -624,4 +630,53 @@ private void validate(HashingStorage dictStorage) {
             }
         }
     }
+
+    @Builtin(name = "extend", minNumOfPositionalArgs = 1, doc = "Extends Java class and return HostAdapterCLass")
+    @GenerateNodeFactory
+    public abstract static class JavaExtendNode extends PythonUnaryBuiltinNode {
+        @Specialization
+        Object doIt(Object value) {
+            if (ImageInfo.inImageBuildtimeCode()) {
+                CompilerDirectives.transferToInterpreterAndInvalidate();
+                throw new UnsupportedOperationException(ErrorMessages.CANT_EXTEND_JAVA_CLASS_NOT_JVM);
+            }
+            if (ImageInfo.inImageRuntimeCode()) {
+                CompilerDirectives.transferToInterpreterAndInvalidate();
+                throw raise(SystemError, ErrorMessages.CANT_EXTEND_JAVA_CLASS_NOT_JVM);
+            }
+
+            Env env = getContext().getEnv();
+            if (!isType(value, env)) {
+                throw raise(TypeError, ErrorMessages.CANT_EXTEND_JAVA_CLASS_NOT_TYPE, value);
+            }
+
+            final Class<?>[] types = new Class<?>[1];
+            types[0] = (Class<?>) env.asHostObject(value);
+            try {
+                return env.createHostAdapterClass(types);
+            } catch (Exception ex) {
+                throw raise(TypeError, ex.getMessage(), ex);
+            }
+        }
+
+        protected static boolean isType(Object obj, TruffleLanguage.Env env) {
+            return env.isHostObject(obj) && env.asHostObject(obj) instanceof Class<?>;
+        }
+
+    }
+
+    @Builtin(name = "super", minNumOfPositionalArgs = 1, doc = "Returns HostAdapter instance of the object or None")
+    @GenerateNodeFactory
+    public abstract static class JavaSuperNode extends PythonUnaryBuiltinNode {
+        @Specialization
+        @TruffleBoundary
+        Object doIt(Object value) {
+            try {
+                return InteropLibrary.getUncached().readMember(value, "super");
+            } catch (UnsupportedMessageException | UnknownIdentifierException e) {
+                return PNone.NONE;
+            }
+        }
+    }
+
 }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/JavaModuleBuiltins.java

@@ -199,6 +199,16 @@ boolean check(Object object) {
         }
     }
 
+    @Builtin(name = "is_type", minNumOfPositionalArgs = 1)
+    @GenerateNodeFactory
+    abstract static class IsTypeNode extends PythonUnaryBuiltinNode {
+        @Specialization
+        boolean isType(Object object) {
+            Env env = getContext().getEnv();
+            return env.isHostObject(object) && env.asHostObject(object) instanceof Class<?>;
+        }
+    }
+
     @Builtin(name = "instanceof", minNumOfPositionalArgs = 2)
     @GenerateNodeFactory
     abstract static class InstanceOfNode extends PythonBinaryBuiltinNode {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/ErrorMessages.java

@@ -166,6 +166,8 @@ public abstract class ErrorMessages {
     public static final String CANT_CONVERT_TO_STR_EXPLICITELY = "Can't convert '%p' object to str implicitly";
     public static final String CANT_COMPARE = "Can't compare %p and %p";
     public static final String CANT_DELETE = "can't delete '%s'";
+    public static final String CANT_EXTEND_JAVA_CLASS_NOT_JVM = "Java Class can be extended only in JVM mode.";
+    public static final String CANT_EXTEND_JAVA_CLASS_NOT_TYPE = "Function extend needs a Java type as its argument not %p";
     public static final String CANT_FIND_MODULE = "can't find module '%s'";
     public static final String CANT_MULTIPLY_SEQ_BY_NON_INT = "can't multiply sequence by non-int of type '%p'";
     public static final String CANT_PICKLE_FUNC_OBJS = "can't pickle function objects";

graalpython/lib-graalpython/classes.py

@@ -142,6 +142,27 @@ def __build_class__(func, name, *bases, **kwargs):
         raise TypeError("__build_class__: func must be a function")
     if not isinstance(name, str):
         raise TypeError("__build_class__: name is not a string, got '%s'" % type(name))
+    if len(bases) == 1:
+        import java
+        if java.is_type(bases[0]): 
+            ns = {}
+            func(ns)  # fill up namespace with the methods and fields of the class
+            ns['__super__'] = None  # place where store the original java class when instance is created
+            ExtenderClass = type("PythonJavaExtenderClass", (object, ), ns)
+            HostAdapter = __graalpython__.extend(bases[0])
+            resultClass = type(name, (object, ), {})
+
+            def factory (cls, *args):
+                # creates extender object and store the super java class
+                extenderInstance = ExtenderClass()
+                args = args[1:] + (extenderInstance, ) # remove the class and add the extender instance object
+                hostObject = HostAdapter(*args)   # create new adapter
+                extenderInstance.__super__ = __graalpython__.super(hostObject)   #set the super java object
+                return hostObject
+
+            resultClass.__new__ = classmethod(factory)
+            return resultClass
+        
     return new_class(name, bases=bases, kwds=kwargs, exec_body=func)