better handling of __module__ property for types and methods, added tests

Author: lukasstadler

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

@@ -0,0 +1,68 @@
+# 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.
+
+
+def test_builtins():
+    import array
+    assert array.array.__module__ == "array" # builtin class
+    assert int.__module__ == "builtins" # builtin class
+    import sys
+    assert sys.getrecursionlimit.__module__ == "sys" # builtin module method
+
+def test_imported():
+    import code
+    assert code.InteractiveInterpreter.__module__ == "code" # class
+    assert code.InteractiveInterpreter.runsource.__module__ == "code" # function
+    assert code.InteractiveInterpreter().runsource.__module__ == "code" # method
+
+class TestClass():
+    def foo(self):
+        pass
+
+def test_user_class():
+    assert TestClass.__module__ == __name__
+    assert TestClass().__module__ == __name__
+    assert TestClass.foo.__module__ == __name__
+    assert TestClass().foo.__module__ == __name__
+    # test redefine:
+    TestClass.__module__ = "bar"
+    assert TestClass.__module__ == "bar"
+    t = TestClass()
+    t.__module__ = "baz"
+    assert t.__module__ == "baz"

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

@@ -491,11 +491,9 @@ private void initializeTypes() {
         // publish builtin types in the corresponding modules
         for (PythonBuiltinClassType builtinClass : PythonBuiltinClassType.VALUES) {
             String module = builtinClass.getPublicInModule();
-            PythonBuiltinClass clazz = lookupType(builtinClass);
             if (module != null) {
-                lookupBuiltinModule(module).setAttribute(builtinClass.getName(), clazz);
+                lookupBuiltinModule(module).setAttribute(builtinClass.getName(), lookupType(builtinClass));
             }
-            clazz.setAttribute("__module__", module == null ? "builtins" : module);
         }
         // now initialize well-known objects
         pyTrue = new PInt(lookupType(PythonBuiltinClassType.Boolean), BigInteger.ONE);

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/method/AbstractMethodBuiltins.java

@@ -28,6 +28,7 @@
 
 import static com.oracle.graal.python.nodes.SpecialAttributeNames.__CODE__;
 import static com.oracle.graal.python.nodes.SpecialAttributeNames.__FUNC__;
+import static com.oracle.graal.python.nodes.SpecialAttributeNames.__MODULE__;
 import static com.oracle.graal.python.nodes.SpecialAttributeNames.__NAME__;
 import static com.oracle.graal.python.nodes.SpecialAttributeNames.__SELF__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__CALL__;
@@ -39,14 +40,21 @@
 import com.oracle.graal.python.builtins.CoreFunctions;
 import com.oracle.graal.python.builtins.PythonBuiltinClassType;
 import com.oracle.graal.python.builtins.PythonBuiltins;
+import com.oracle.graal.python.builtins.modules.BuiltinFunctions.GetAttrNode;
+import com.oracle.graal.python.builtins.objects.PNone;
 import com.oracle.graal.python.builtins.objects.function.PKeyword;
+import com.oracle.graal.python.builtins.objects.module.PythonModule;
+import com.oracle.graal.python.builtins.objects.object.PythonObject;
 import com.oracle.graal.python.nodes.argument.CreateArgumentsNode;
+import com.oracle.graal.python.nodes.attributes.ReadAttributeFromObjectNode;
+import com.oracle.graal.python.nodes.attributes.WriteAttributeToObjectNode;
 import com.oracle.graal.python.nodes.call.CallDispatchNode;
 import com.oracle.graal.python.nodes.call.special.LookupAndCallBinaryNode;
 import com.oracle.graal.python.nodes.function.PythonBuiltinBaseNode;
 import com.oracle.graal.python.nodes.function.PythonBuiltinNode;
 import com.oracle.graal.python.nodes.function.builtins.PythonBinaryBuiltinNode;
 import com.oracle.graal.python.nodes.function.builtins.PythonVarargsBuiltinNode;
+import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.Fallback;
 import com.oracle.truffle.api.dsl.GenerateNodeFactory;
@@ -149,4 +157,34 @@ boolean eq(@SuppressWarnings("unused") Object self, @SuppressWarnings("unused")
             return false;
         }
     }
+
+    @Builtin(name = __MODULE__, minNumOfPositionalArgs = 1, maxNumOfPositionalArgs = 2, isGetter = true, isSetter = true)
+    @GenerateNodeFactory
+    abstract static class GetModuleNode extends PythonBuiltinNode {
+        @Specialization(guards = "isNoValue(none)")
+        Object getModule(PythonObject self, @SuppressWarnings("unused") PNone none,
+                        @Cached("create()") ReadAttributeFromObjectNode readObject,
+                        @Cached("create()") GetAttrNode getAttr,
+                        @Cached("create()") WriteAttributeToObjectNode writeObject) {
+            Object module = readObject.execute(self, __MODULE__);
+            if (module == PNone.NO_VALUE) {
+                CompilerDirectives.transferToInterpreter();
+                Object globals = self instanceof PMethod ? ((PMethod) self).getSelf() : ((PBuiltinMethod) self).getSelf();
+                if (globals instanceof PythonModule) {
+                    module = ((PythonModule) globals).getAttribute(__NAME__);
+                } else {
+                    module = getAttr.execute(globals, __MODULE__, PNone.NONE);
+                }
+                writeObject.execute(self, __MODULE__, module);
+            }
+            return module;
+        }
+
+        @Specialization(guards = "!isNoValue(value)")
+        Object getModule(PythonObject self, Object value,
+                        @Cached("create()") WriteAttributeToObjectNode writeObject) {
+            writeObject.execute(self, __MODULE__, value);
+            return PNone.NONE;
+        }
+    }
 }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/type/TypeBuiltins.java

@@ -461,7 +461,6 @@ boolean instanceCheck(PythonClass cls, Object derived) {
     @Builtin(name = __SUBCLASSES__, fixedNumOfPositionalArgs = 1)
     @GenerateNodeFactory
     static abstract class SubclassesNode extends PythonUnaryBuiltinNode {
-        @Child private IsSubtypeNode isSubtypeNode = IsSubtypeNode.create();
 
         @Specialization
         @TruffleBoundary
@@ -496,4 +495,30 @@ Object setName(PythonClass cls, Object value,
             return setName.execute(cls, __NAME__, value);
         }
     }
+
+    @Builtin(name = __MODULE__, minNumOfPositionalArgs = 1, maxNumOfPositionalArgs = 2, isGetter = true, isSetter = true)
+    @GenerateNodeFactory
+    static abstract class ModuleNode extends PythonBinaryBuiltinNode {
+
+        @Specialization(guards = "isNoValue(value)")
+        @TruffleBoundary
+        Object getModule(PythonClass cls, @SuppressWarnings("unused") PNone value) {
+            if (cls instanceof PythonBuiltinClass) {
+                String module = ((PythonBuiltinClass) cls).getType().getPublicInModule();
+                return module == null ? "builtins" : module;
+            }
+            Object module = cls.getAttribute(__MODULE__);
+            if (module == PNone.NO_VALUE) {
+                throw raise(AttributeError, "");
+            }
+            return module;
+        }
+
+        @Specialization(guards = "!isNoValue(value)")
+        @TruffleBoundary
+        Object setModule(PythonClass cls, Object value) {
+            cls.setAttribute(__MODULE__, value);
+            return PNone.NONE;
+        }
+    }
 }