[GR-10018] Missing functionality: towards py4j (0.10.7)

PullRequest: graalpython/181

Author: cosminbasca

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 1.0.0 RC7
+
+* Enhance the `java` interop builtin module with introspection utility methods
+
 ## Version 1.0.0 RC6
 
 * Support regular expression patterns built from bytes by using CPython's sre module as a fallback engine to our own

doc/INTEROP.md

@@ -62,6 +62,28 @@ byteArray = myBigInt.toByteArray()
 print(list(byteArray))             # Java arrays can act like Python lists
 ```
 
+In addition to the `type` builtin method, the `java` module, exposes the following 
+methods as well:
+
+Builtin | Specification
+--- | ---
+`instanceof(obj, class)` | returns `True` if `obj` is an instance of `class` (`class` must be a foreign object class)
+`is_function(obj)` | returns `True` if `obj` is a Java host language function wrapped using Truffle interop
+`is_object(obj)` | returns `True` if `obj` if the argument is Java host language object wrapped using Truffle interop
+`is_symbol(obj)` | returns `True` if `obj` if the argument is a Java host symbol, representing the constructor and static members of a Java class, as obtained by `java.type`
+
+```python
+import java
+ArrayList = java.type('java.util.ArrayList')
+my_list = ArrayList()
+print(java.is_symbol(ArrayList))    # prints True
+print(java.is_symbol(my_list))      # prints False, my_list is not a Java host symbol
+print(java.is_object(ArrayList))    # prints True, symbols are also host objects 
+print(java.is_function(my_list.add))# prints True, the add method of ArrayList
+print(java.instanceof(my_list, ArrayList)) # prints True 
+```    
+
+
 #### Python responses to Truffle interop messages
 
 ###### READ

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/Python3Core.java

@@ -64,6 +64,7 @@
 import com.oracle.graal.python.builtins.modules.PosixModuleBuiltins;
 import com.oracle.graal.python.builtins.modules.RandomModuleBuiltins;
 import com.oracle.graal.python.builtins.modules.SREModuleBuiltins;
+import com.oracle.graal.python.builtins.modules.SelectModuleBuiltins;
 import com.oracle.graal.python.builtins.modules.SignalModuleBuiltins;
 import com.oracle.graal.python.builtins.modules.StringModuleBuiltins;
 import com.oracle.graal.python.builtins.modules.SysModuleBuiltins;
@@ -253,6 +254,7 @@ public final class Python3Core implements PythonCore {
                     new JavaModuleBuiltins(),
                     new SREModuleBuiltins(),
                     new AstModuleBuiltins(),
+                    new SelectModuleBuiltins(),
                     new SignalModuleBuiltins(),
                     new TracebackBuiltins(),
                     new GcModuleBuiltins(),

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

@@ -45,13 +45,17 @@
 import com.oracle.graal.python.builtins.Builtin;
 import com.oracle.graal.python.builtins.CoreFunctions;
 import com.oracle.graal.python.builtins.PythonBuiltins;
+import com.oracle.graal.python.builtins.objects.str.PString;
 import com.oracle.graal.python.nodes.function.PythonBuiltinBaseNode;
+import com.oracle.graal.python.nodes.function.builtins.PythonBinaryBuiltinNode;
 import com.oracle.graal.python.nodes.function.builtins.PythonUnaryBuiltinNode;
 import com.oracle.graal.python.runtime.exception.PythonErrorType;
 import com.oracle.truffle.api.TruffleLanguage.Env;
+import com.oracle.truffle.api.dsl.Fallback;
 import com.oracle.truffle.api.dsl.GenerateNodeFactory;
 import com.oracle.truffle.api.dsl.NodeFactory;
 import com.oracle.truffle.api.dsl.Specialization;
+import com.oracle.truffle.api.interop.TruffleObject;
 
 @CoreFunctions(defineModule = "java")
 public class JavaModuleBuiltins extends PythonBuiltins {
@@ -63,8 +67,7 @@ protected List<? extends NodeFactory<? extends PythonBuiltinBaseNode>> getNodeFa
     @Builtin(name = "type", fixedNumOfPositionalArgs = 1)
     @GenerateNodeFactory
     abstract static class TypeNode extends PythonUnaryBuiltinNode {
-        @Specialization
-        Object type(String name) {
+        private Object get(String name) {
             Env env = getContext().getEnv();
             if (!env.isHostLookupAllowed()) {
                 throw raise(PythonErrorType.NotImplementedError, "host lookup is not allowed");
@@ -81,5 +84,75 @@ Object type(String name) {
                 return hostValue;
             }
         }
+
+        @Specialization
+        Object type(String name) {
+            return get(name);
+        }
+
+        @Specialization
+        Object type(PString name) {
+            return get(name.getValue());
+        }
+    }
+
+    @Builtin(name = "is_function", fixedNumOfPositionalArgs = 1)
+    @GenerateNodeFactory
+    abstract static class IsFunctionNode extends PythonUnaryBuiltinNode {
+        @Specialization
+        boolean check(Object object) {
+            Env env = getContext().getEnv();
+            return env.isHostFunction(object);
+        }
+    }
+
+    @Builtin(name = "is_object", fixedNumOfPositionalArgs = 1)
+    @GenerateNodeFactory
+    abstract static class IsObjectNode extends PythonUnaryBuiltinNode {
+        @Specialization
+        boolean check(Object object) {
+            Env env = getContext().getEnv();
+            return env.isHostObject(object);
+        }
+    }
+
+    @Builtin(name = "is_symbol", fixedNumOfPositionalArgs = 1)
+    @GenerateNodeFactory
+    abstract static class IsSymbolNode extends PythonUnaryBuiltinNode {
+        @Specialization
+        boolean check(Object object) {
+            Env env = getContext().getEnv();
+            return env.isHostSymbol(object);
+        }
+    }
+
+    @Builtin(name = "instanceof", fixedNumOfPositionalArgs = 2)
+    @GenerateNodeFactory
+    abstract static class InstanceOfNode extends PythonBinaryBuiltinNode {
+        @Specialization(guards = {"!isForeignObject(object)", "isForeignObject(klass)"})
+        boolean check(Object object, TruffleObject klass) {
+            Env env = getContext().getEnv();
+            Object hostKlass = env.asHostObject(klass);
+            if (hostKlass instanceof Class<?>) {
+                return ((Class<?>) hostKlass).isInstance(object);
+            }
+            return false;
+        }
+
+        @Specialization(guards = {"isForeignObject(object)", "isForeignObject(klass)"})
+        boolean checkForeign(Object object, TruffleObject klass) {
+            Env env = getContext().getEnv();
+            Object hostObject = env.asHostObject(object);
+            Object hostKlass = env.asHostObject(klass);
+            if (hostKlass instanceof Class<?>) {
+                return ((Class<?>) hostKlass).isInstance(hostObject);
+            }
+            return false;
+        }
+
+        @Fallback
+        boolean fallback(Object object, Object klass) {
+            throw raise(PythonErrorType.TypeError, "unsupported instanceof(%p, %p)", object, klass);
+        }
     }
 }

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

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * The Universal Permissive License (UPL), Version 1.0
+ *
+ * Subject to the condition set forth below, permission is hereby granted to any
+ * person obtaining a copy of this software, associated documentation and/or
+ * data (collectively the "Software"), free of charge and under any and all
+ * copyright rights in the Software, and any and all patent rights owned or
+ * freely licensable by each licensor hereunder covering either (i) the
+ * unmodified Software as contributed to or provided by such licensor, or (ii)
+ * the Larger Works (as defined below), to deal in both
+ *
+ * (a) the Software, and
+ *
+ * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+ * one is included with the Software each a "Larger Work" to which the Software
+ * is contributed by such licensors),
+ *
+ * without restriction, including without limitation the rights to copy, create
+ * derivative works of, display, perform, and distribute the Software and make,
+ * use, sell, offer for sale, import, export, have made, and have sold the
+ * Software and the Larger Work(s), and to sublicense the foregoing rights on
+ * either these or other terms.
+ *
+ * This license is subject to the following condition:
+ *
+ * The above copyright notice and either this complete permission notice or at a
+ * minimum a reference to the UPL must be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.oracle.graal.python.builtins.modules;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.oracle.graal.python.builtins.CoreFunctions;
+import com.oracle.graal.python.builtins.PythonBuiltins;
+import com.oracle.graal.python.nodes.function.PythonBuiltinBaseNode;
+import com.oracle.truffle.api.dsl.NodeFactory;
+
+@CoreFunctions(defineModule = "select")
+public class SelectModuleBuiltins extends PythonBuiltins {
+    @Override
+    protected List<? extends NodeFactory<? extends PythonBuiltinBaseNode>> getNodeFactories() {
+        return new ArrayList<>();
+    }
+}

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

@@ -1248,22 +1248,22 @@ abstract static class PyTruffleSlice_GetIndicesEx extends NativeBuiltin {
         @Specialization
         Object doUnpack(int start, int stop, int step, int length) {
             PSlice tmpSlice = factory().createSlice(start, stop, step);
-            SliceInfo actualIndices = tmpSlice.computeActualIndices(length);
+            SliceInfo actualIndices = tmpSlice.computeIndices(length);
             return factory().createTuple(new Object[]{actualIndices.start, actualIndices.stop, actualIndices.step, actualIndices.length});
         }
 
         @Specialization(rewriteOn = ArithmeticException.class)
         Object doUnpackLong(long start, long stop, long step, long length) {
             PSlice tmpSlice = factory().createSlice(PInt.intValueExact(start), PInt.intValueExact(stop), PInt.intValueExact(step));
-            SliceInfo actualIndices = tmpSlice.computeActualIndices(PInt.intValueExact(length));
+            SliceInfo actualIndices = tmpSlice.computeIndices(PInt.intValueExact(length));
             return factory().createTuple(new Object[]{actualIndices.start, actualIndices.stop, actualIndices.step, actualIndices.length});
         }
 
         @Specialization(replaces = {"doUnpackLong", "doUnpack"})
         Object doUnpackLongOvf(long start, long stop, long step, long length) {
             try {
                 PSlice tmpSlice = factory().createSlice(PInt.intValueExact(start), PInt.intValueExact(stop), PInt.intValueExact(step));
-                SliceInfo actualIndices = tmpSlice.computeActualIndices(length > Integer.MAX_VALUE ? Integer.MAX_VALUE : PInt.intValueExact(length));
+                SliceInfo actualIndices = tmpSlice.computeIndices(length > Integer.MAX_VALUE ? Integer.MAX_VALUE : PInt.intValueExact(length));
                 return factory().createTuple(new Object[]{actualIndices.start, actualIndices.stop, actualIndices.step, actualIndices.length});
             } catch (ArithmeticException e) {
                 throw raiseIndexError();

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/common/SequenceStorageNodes.java

@@ -396,7 +396,7 @@ protected Object doScalarGeneric(SequenceStorage storage, Object idx) {
 
         @Specialization
         protected Object doSlice(SequenceStorage storage, PSlice slice) {
-            SliceInfo info = slice.computeActualIndices(storage.length());
+            SliceInfo info = slice.computeIndices(storage.length());
             if (factoryMethod != null) {
                 return factoryMethod.apply(getGetItemSliceNode().execute(storage, info.start, info.stop, info.step, info.length), factory());
             }
@@ -749,7 +749,7 @@ protected SequenceStorage doScalarGeneric(SequenceStorage storage, Object idx, O
 
         @Specialization
         protected SequenceStorage doSlice(SequenceStorage storage, PSlice slice, Object iterable) {
-            SliceInfo info = slice.computeActualIndices(storage.length());
+            SliceInfo info = slice.computeIndices(storage.length());
             try {
                 getSetItemSliceNode().execute(storage, info, iterable);
                 return storage;
@@ -2727,7 +2727,7 @@ protected void doScalarGeneric(SequenceStorage storage, Object idx) {
 
         @Specialization
         protected void doSlice(SequenceStorage storage, PSlice slice) {
-            SliceInfo info = slice.computeActualIndices(storage.length());
+            SliceInfo info = slice.computeIndices(storage.length());
             try {
                 getGetItemSliceNode().execute(storage, info);
             } catch (SequenceStoreException e) {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/foreign/AccessForeignItemNodes.java

@@ -95,27 +95,8 @@ protected int getForeignSize(TruffleObject object, Node getSizeNode, PForeignToP
         }
 
         protected SliceInfo materializeSlice(PSlice idxSlice, TruffleObject object, Node getSizeNode, PForeignToPTypeNode foreign2PTypeNode) throws UnsupportedMessageException {
-
-            // determine start
-            boolean isStartMissing = false;
-            int start = idxSlice.getStart();
-            if (start == PSlice.MISSING_INDEX) {
-                start = 0;
-                isStartMissing = true;
-            }
-
-            // determine stop
-            int end = idxSlice.getStop();
-            int foreignSize = -1;
-            if (end == PSlice.MISSING_INDEX) {
-                foreignSize = getForeignSize(object, getSizeNode, foreign2PTypeNode);
-                end = foreignSize;
-            } else if (isStartMissing) {
-                foreignSize = getForeignSize(object, getSizeNode, foreign2PTypeNode);
-            }
-
-            // determine length (foreignSize is only required if start or stop is missing)
-            return idxSlice.computeActualIndices(foreignSize);
+            int foreignSize = getForeignSize(object, getSizeNode, foreign2PTypeNode);
+            return idxSlice.computeIndices(foreignSize);
         }
     }
 

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/foreign/TruffleObjectBuiltins.java

@@ -32,6 +32,7 @@
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__DELATTR__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__DELITEM__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__DIR__;
+import static com.oracle.graal.python.nodes.SpecialMethodNames.__EQ__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__FLOORDIV__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__GETITEM__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__GE__;
@@ -43,6 +44,7 @@
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__LT__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__MUL__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__NEW__;
+import static com.oracle.graal.python.nodes.SpecialMethodNames.__NE__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__RADD__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__REPR__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__RFLOORDIV__;
@@ -716,6 +718,14 @@ protected GeNode() {
         }
     }
 
+    @Builtin(name = __EQ__, fixedNumOfPositionalArgs = 2)
+    @GenerateNodeFactory
+    public abstract static class EqNode extends ForeignBinaryComparisonNode {
+        protected EqNode() {
+            super(BinaryComparisonNode.create(__EQ__, __NE__, "=="));
+        }
+    }
+
     @Builtin(name = __ITER__, fixedNumOfPositionalArgs = 1)
     @GenerateNodeFactory
     public abstract static class IterNode extends UnboxNode {
@@ -769,7 +779,7 @@ Object doForeignMapping(TruffleObject mapping,
 
         @Fallback
         Object doGeneric(@SuppressWarnings("unused") Object o) {
-            return PNone.NO_VALUE;
+            return PNone.NONE;
         }
 
     }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/range/RangeBuiltins.java

@@ -207,7 +207,7 @@ Object doPRange(PRange primary, PInt idx) {
 
         @Specialization
         Object doPRange(PRange range, PSlice slice) {
-            SliceInfo info = slice.computeActualIndices(range.len());
+            SliceInfo info = slice.computeIndices(range.len());
             int newStep = range.getStep() * info.step;
             int newStart = info.start == PSlice.MISSING_INDEX ? range.getStart() : range.getStart() + info.start * range.getStep();
             int newStop = info.stop == PSlice.MISSING_INDEX ? range.getStop() : Math.min(range.getStop(), newStart + info.length * newStep);