[GR-16805] [GR-16806] type.__base__ and GraalPythonVM env support

PullRequest: graalpython/572

Author: cosminbasca

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

@@ -0,0 +1,72 @@
+# Copyright (c) 2019, 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_base():
+    A = type('A', (), {})
+    assert A.__base__ == object
+
+    # class B:
+    #     def ham(self):
+    #         return 'ham%d' % self
+    #
+    # class A(object):
+    #     pass
+    #
+    # class B(dict):
+    #     pass
+    #
+    # class C(A, B):
+    #     pass
+    #
+    # assert C.__base__ == B
+    #
+    # class A(object):
+    #     pass
+    #
+    # class B(object):
+    #     pass
+    #
+    # class C(A, B):
+    #     pass
+    #
+    # assert C.__base__ == A
+    #
+    # C = type('C', (B, int), {'spam': lambda self: 'spam%s' % self})
+    # assert C.__base__ == int

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

@@ -27,6 +27,7 @@
 package com.oracle.graal.python.builtins.objects.type;
 
 import static com.oracle.graal.python.nodes.SpecialAttributeNames.__BASES__;
+import static com.oracle.graal.python.nodes.SpecialAttributeNames.__BASE__;
 import static com.oracle.graal.python.nodes.SpecialAttributeNames.__BASICSIZE__;
 import static com.oracle.graal.python.nodes.SpecialAttributeNames.__CLASS__;
 import static com.oracle.graal.python.nodes.SpecialAttributeNames.__DICTOFFSET__;
@@ -464,6 +465,16 @@ Object bases(LazyPythonClass self,
         }
     }
 
+    @Builtin(name = __BASE__, minNumOfPositionalArgs = 1, isGetter = true)
+    @GenerateNodeFactory
+    abstract static class BaseNode extends PythonBuiltinNode {
+        @Specialization
+        Object base(LazyPythonClass self,
+                        @Cached("create()") TypeNodes.GetBaseClassNode getBaseClassNode) {
+            return getBaseClassNode.execute(self);
+        }
+    }
+
     @Builtin(name = __DICT__, minNumOfPositionalArgs = 1, isGetter = true)
     @GenerateNodeFactory
     @ImportStatic(NativeMemberNames.class)

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

@@ -42,6 +42,7 @@
 
 import static com.oracle.graal.python.builtins.PythonBuiltinClassType.AttributeError;
 import static com.oracle.graal.python.builtins.PythonBuiltinClassType.SystemError;
+import static com.oracle.graal.python.runtime.exception.PythonErrorType.NotImplementedError;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -66,6 +67,7 @@
 import com.oracle.graal.python.builtins.objects.dict.PDict;
 import com.oracle.graal.python.builtins.objects.tuple.PTuple;
 import com.oracle.graal.python.builtins.objects.type.PythonManagedClass.FlagsContainer;
+import com.oracle.graal.python.builtins.objects.type.TypeNodesFactory.GetBaseClassNodeGen;
 import com.oracle.graal.python.builtins.objects.type.TypeNodesFactory.GetBaseClassesNodeGen;
 import com.oracle.graal.python.builtins.objects.type.TypeNodesFactory.GetInstanceShapeNodeGen;
 import com.oracle.graal.python.builtins.objects.type.TypeNodesFactory.GetMroStorageNodeGen;
@@ -574,6 +576,49 @@ private static PythonAbstractClass[] cast(Object[] arr) {
 
     }
 
+    @ImportStatic(NativeMemberNames.class)
+    public abstract static class GetBaseClassNode extends PNodeWithContext {
+
+        public abstract PythonAbstractClass execute(Object obj);
+
+        @Specialization
+        PythonAbstractClass doPythonClass(PythonManagedClass obj,
+                        @Cached PRaiseNode raise) {
+            PythonAbstractClass[] baseClasses = obj.getBaseClasses();
+            if (baseClasses.length == 1) {
+                return baseClasses[0];
+            }
+            throw raise.raise(NotImplementedError, "get bestBase case not yet implemented");
+        }
+
+        @Specialization
+        PythonAbstractClass doPythonClass(PythonBuiltinClassType obj,
+                        @Cached PRaiseNode raise,
+                        @CachedContext(PythonLanguage.class) PythonContext context) {
+            PythonAbstractClass[] baseClasses = context.getCore().lookupType(obj).getBaseClasses();
+            if (baseClasses.length == 1) {
+                return baseClasses[0];
+            }
+            throw raise.raise(NotImplementedError, "get bestBase case not yet implemented");
+        }
+
+        @Specialization
+        PythonAbstractClass doNative(PythonNativeClass obj,
+                        @Cached PRaiseNode raise,
+                        @Cached GetTypeMemberNode getTpBaseNode,
+                        @Cached("createClassProfile()") ValueProfile resultTypeProfile) {
+            Object result = resultTypeProfile.profile(getTpBaseNode.execute(obj, NativeMemberNames.TP_BASE));
+            if (result instanceof PythonAbstractClass) {
+                return (PythonAbstractClass) result;
+            }
+            throw raise.raise(PythonBuiltinClassType.SystemError, "type does not provide __base__");
+        }
+
+        public static GetBaseClassNode create() {
+            return GetBaseClassNodeGen.create();
+        }
+    }
+
     @ImportStatic(SpecialMethodNames.class)
     public abstract static class IsSameTypeNode extends PNodeWithContext {
 

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

@@ -53,6 +53,7 @@ public abstract class SpecialAttributeNames {
     public static final String __MODULE__ = "__module__";
     public static final String __DICT__ = "__dict__";
     public static final String __CLASS__ = "__class__";
+    public static final String __BASE__ = "__base__";
     public static final String __BASES__ = "__bases__";
     public static final String __NAME__ = "__name__";
     public static final String __QUALNAME__ = "__qualname__";

graalpython/lib-graalpython/type.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2019, 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

mx.graalpython/mx_graalpython_benchmark.py

@@ -33,6 +33,7 @@
 import mx_benchmark
 from mx_benchmark import StdOutRule, java_vm_registry, Vm, GuestVm, VmBenchmarkSuite, AveragingBenchmarkMixin
 from mx_graalpython_bench_param import HARNESS_PATH
+from contextlib import contextmanager
 
 # ----------------------------------------------------------------------------------------------------------------------
 #
@@ -75,6 +76,27 @@ def _check_vm_args(name, args):
                  "got {} instead".format(args))
 
 
+@contextmanager
+def environ(env):
+    def _handle_var((k, v)):
+        if v is None:
+            del os.environ[k]
+        else:
+            os.environ[k] = str(v)
+
+    if env:
+        prev_env = {v: os.getenv(v) for v in env}
+        map(_handle_var, env.items())
+    else:
+        prev_env = None
+
+    try:
+        yield
+    finally:
+        if prev_env:
+            map(_handle_var, prev_env.items())
+
+
 # ----------------------------------------------------------------------------------------------------------------------
 #
 # the vm definitions
@@ -194,14 +216,15 @@ def name(self):
 
 class GraalPythonVm(GuestVm):
     def __init__(self, config_name=CONFIGURATION_DEFAULT, distributions=None, cp_suffix=None, cp_prefix=None,
-                 host_vm=None, extra_vm_args=None, extra_polyglot_args=None):
+                 host_vm=None, extra_vm_args=None, extra_polyglot_args=None, env=None):
         super(GraalPythonVm, self).__init__(host_vm=host_vm)
         self._config_name = config_name
         self._distributions = distributions
         self._cp_suffix = cp_suffix
         self._cp_prefix = cp_prefix
         self._extra_vm_args = extra_vm_args
         self._extra_polyglot_args = extra_polyglot_args
+        self._env = env
 
     def hosting_registry(self):
         return java_vm_registry
@@ -240,10 +263,11 @@ def run(self, cwd, args):
         cmd = truffle_options + vm_args + extra_polyglot_args + args
 
         host_vm = self.host_vm()
-        if hasattr(host_vm, 'run_lang'):
-            return host_vm.run_lang('graalpython', extra_polyglot_args + args, cwd)
-        else:
-            return host_vm.run(cwd, cmd)
+        with environ(self._env):
+            if hasattr(host_vm, 'run_lang'):
+                return host_vm.run_lang('graalpython', extra_polyglot_args + args, cwd)
+            else:
+                return host_vm.run(cwd, cmd)
 
     def name(self):
         return VM_NAME_GRAALPYTHON
@@ -254,7 +278,8 @@ def config_name(self):
     def with_host_vm(self, host_vm):
         return self.__class__(config_name=self._config_name, distributions=self._distributions,
                               cp_suffix=self._cp_suffix, cp_prefix=self._cp_prefix, host_vm=host_vm,
-                              extra_vm_args=self._extra_vm_args, extra_polyglot_args=self._extra_polyglot_args)
+                              extra_vm_args=self._extra_vm_args, extra_polyglot_args=self._extra_polyglot_args,
+                              env=self._env)
 
 
 # ----------------------------------------------------------------------------------------------------------------------