[GR-46818][GR-46811] Implement native exception subclasses

PullRequest: graalpython/2853

Author: msimacek

graalpython/com.oracle.graal.python.cext/src/capi.c

@@ -424,10 +424,19 @@ PyAPI_FUNC(PyTypeObject*) get_##NAME(RECEIVER obj) {  \
 PyAPI_FUNC(PyObject*) get_##NAME(RECEIVER obj) {        \
     return (PyObject*) obj->NAME;           \
 }
+#define OBJECT_FIELD_SETTER(RECEIVER, NAME) \
+PyAPI_FUNC(void) set_##NAME(RECEIVER obj, PyObject* value) {        \
+    Py_XINCREF(value);                      \
+    Py_XSETREF(obj->NAME, value);           \
+}
 #define PRIMITIVE_FIELD_GETTER(RECEIVER, RESULT, NAME) \
 PyAPI_FUNC(RESULT) get_##NAME(RECEIVER obj) {                      \
     return obj->NAME;                                  \
 }
+#define PRIMITIVE_FIELD_SETTER(RECEIVER, TYPE, NAME) \
+PyAPI_FUNC(void) set_##NAME(RECEIVER obj, TYPE value) {                      \
+    obj->NAME = value;                                  \
+}
 #define PRIMITIVE_SUBFIELD_GETTER(RECEIVER, FIELD, RESULT, NAME) \
 PyAPI_FUNC(RESULT) get_##NAME(RECEIVER obj) {                    \
     return obj->FIELD? obj->FIELD->NAME : NULL;                   \
@@ -522,6 +531,20 @@ PRIMITIVE_FIELD_GETTER(PyModuleDef*, Py_ssize_t, m_size)
 PRIMITIVE_FIELD_GETTER(PyModuleDef*, const char*, m_doc)
 PRIMITIVE_EMBEDDED_FIELD_GETTER(PyComplexObject*, cval, double, real)
 PRIMITIVE_EMBEDDED_FIELD_GETTER(PyComplexObject*, cval, double, imag)
+OBJECT_FIELD_GETTER(PyBaseExceptionObject*, args);
+OBJECT_FIELD_GETTER(PyBaseExceptionObject*, context);
+OBJECT_FIELD_GETTER(PyBaseExceptionObject*, cause);
+OBJECT_FIELD_GETTER(PyBaseExceptionObject*, traceback);
+PRIMITIVE_FIELD_GETTER(PyBaseExceptionObject*, char, suppress_context);
+OBJECT_FIELD_SETTER(PyBaseExceptionObject*, args);
+OBJECT_FIELD_SETTER(PyBaseExceptionObject*, context);
+PyAPI_FUNC(void) set_cause(PyBaseExceptionObject* obj, PyObject* value) {
+    Py_XSETREF(obj->cause, value);
+    obj->suppress_context = 1;
+}
+OBJECT_FIELD_SETTER(PyBaseExceptionObject*, traceback);
+PRIMITIVE_FIELD_SETTER(PyBaseExceptionObject*, char, suppress_context);
+
 
 char* get_ob_sval(PyObject* op) {
 	return ((PyBytesObject *)(op))->ob_sval;
@@ -1529,6 +1552,14 @@ PyAPI_FUNC(PyCodeObject*) PyCode_NewEmpty(const char* a, const char* b, int c) {
 PyAPI_FUNC(PyCodeObject*) PyCode_NewWithPosOnlyArgs(int a, int b, int c, int d, int e, int f, PyObject* g, PyObject* h, PyObject* i, PyObject* j, PyObject* k, PyObject* l, PyObject* m, PyObject* n, int o, PyObject* p) {
     return GraalPyCode_NewWithPosOnlyArgs(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p);
 }
+#undef PyCodec_Decoder
+PyAPI_FUNC(PyObject*) PyCodec_Decoder(const char* a) {
+    return GraalPyCodec_Decoder(truffleString(a));
+}
+#undef PyCodec_Encoder
+PyAPI_FUNC(PyObject*) PyCodec_Encoder(const char* a) {
+    return GraalPyCodec_Encoder(truffleString(a));
+}
 #undef PyComplex_FromDoubles
 PyAPI_FUNC(PyObject*) PyComplex_FromDoubles(double a, double b) {
     return GraalPyComplex_FromDoubles(a, b);

graalpython/com.oracle.graal.python.cext/src/capi.h

@@ -120,6 +120,8 @@ typedef struct {
     BUILTIN(PyCode_New, PyCodeObject*, int, int, int, int, int, PyObject*, PyObject*, PyObject*, PyObject*, PyObject*, PyObject*, PyObject*, PyObject*, int, PyObject*) \
     BUILTIN(PyCode_NewEmpty, PyCodeObject*, const char*, const char*, int) \
     BUILTIN(PyCode_NewWithPosOnlyArgs, PyCodeObject*, int, int, int, int, int, int, PyObject*, PyObject*, PyObject*, PyObject*, PyObject*, PyObject*, PyObject*, PyObject*, int, PyObject*) \
+    BUILTIN(PyCodec_Decoder, PyObject*, const char*) \
+    BUILTIN(PyCodec_Encoder, PyObject*, const char*) \
     BUILTIN(PyComplex_FromDoubles, PyObject*, double, double) \
     BUILTIN(PyComplex_ImagAsDouble, double, PyObject*) \
     BUILTIN(PyComplex_RealAsDouble, double, PyObject*) \

graalpython/com.oracle.graal.python.cext/src/exceptions.c

@@ -187,3 +187,17 @@ void initialize_exceptions() {
     PyExc_ResourceWarning = PY_EXCEPTION("ResourceWarning");
 }
 
+PyObject* exception_subtype_new(PyTypeObject *type, PyObject *args) {
+    PyBaseExceptionObject *self;
+
+    self = (PyBaseExceptionObject *)type->tp_alloc(type, 0);
+    if (!self)
+        return NULL;
+    /* the dict is created on the fly in PyObject_GenericSetAttr */
+    self->dict = NULL;
+    self->traceback = self->cause = self->context = NULL;
+    self->suppress_context = 0;
+    self->args = args;
+    Py_INCREF(args);
+    return (PyObject *)self;
+}

graalpython/com.oracle.graal.python.cext/src/tupleobject.c

@@ -61,6 +61,8 @@ PyObject* PyTuple_Pack(Py_ssize_t n, ...) {
     return result;
 }
 
+PyObject* PyTruffle_Tuple_Alloc(PyTypeObject* cls, Py_ssize_t nitems);
+
 POLYGLOT_DECLARE_TYPE(PyTupleObject);
 PyObject * tuple_subtype_new(PyTypeObject *type, PyObject *iterable) {
 	PyTupleObject* newobj;
@@ -75,7 +77,10 @@ PyObject * tuple_subtype_new(PyTypeObject *type, PyObject *iterable) {
     assert(PyTuple_Check(tmp));
     n = PyTuple_GET_SIZE(tmp);
 
-    newobj = (PyTupleObject*) type->tp_alloc(type, n);
+    /* GraalPy note: we cannot call type->tp_alloc here because managed subtypes don't inherit tp_alloc but get a generic one.
+     * In CPython tuple uses the generic one to begin with, so they don't have this problem
+     */
+    newobj = (PyTupleObject*) PyTruffle_Tuple_Alloc(type, n);
     if (newobj == NULL) {
         return NULL;
     }

graalpython/com.oracle.graal.python.jni/src/capi_forwards.h

@@ -1937,14 +1937,18 @@ PyAPI_FUNC(PyObject*) PyCodec_BackslashReplaceErrors(PyObject* a) {
 PyAPI_FUNC(PyObject*) PyCodec_Decode(PyObject* a, const char* b, const char* c) {
     unimplemented("PyCodec_Decode"); exit(-1);
 }
+PyObject* (*__target__PyCodec_Decoder)(const char*) = NULL;
 PyAPI_FUNC(PyObject*) PyCodec_Decoder(const char* a) {
-    unimplemented("PyCodec_Decoder"); exit(-1);
+    PyObject* result = (PyObject*) __target__PyCodec_Decoder(a);
+    return result;
 }
 PyAPI_FUNC(PyObject*) PyCodec_Encode(PyObject* a, const char* b, const char* c) {
     unimplemented("PyCodec_Encode"); exit(-1);
 }
+PyObject* (*__target__PyCodec_Encoder)(const char*) = NULL;
 PyAPI_FUNC(PyObject*) PyCodec_Encoder(const char* a) {
-    unimplemented("PyCodec_Encoder"); exit(-1);
+    PyObject* result = (PyObject*) __target__PyCodec_Encoder(a);
+    return result;
 }
 PyAPI_FUNC(PyObject*) PyCodec_IgnoreErrors(PyObject* a) {
     unimplemented("PyCodec_IgnoreErrors"); exit(-1);
@@ -6260,6 +6264,8 @@ void initializeCAPIForwards(void* (*getAPI)(const char*)) {
     __target__PyCapsule_New = getAPI("PyCapsule_New");
     __target__PyCapsule_SetName = getAPI("PyCapsule_SetName");
     __target__PyCode_NewEmpty = getAPI("PyCode_NewEmpty");
+    __target__PyCodec_Decoder = getAPI("PyCodec_Decoder");
+    __target__PyCodec_Encoder = getAPI("PyCodec_Encoder");
     __target__PyContextVar_Get = getAPI("PyContextVar_Get");
     __target__PyContextVar_New = getAPI("PyContextVar_New");
     __target__PyDescrObject_GetName = getAPI("PyDescrObject_GetName");

graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/builtins/modules/ConversionNodeTests.java

@@ -46,6 +46,7 @@
 import org.junit.rules.ExpectedException;
 
 import com.oracle.graal.python.PythonLanguage;
+import com.oracle.graal.python.builtins.objects.exception.PBaseException;
 import com.oracle.graal.python.builtins.objects.function.PArguments;
 import com.oracle.graal.python.builtins.objects.function.Signature;
 import com.oracle.graal.python.nodes.PRootNode;
@@ -109,7 +110,9 @@ public boolean isPythonInternal() {
             }
         } catch (PException e) {
             // materialize PException's error message since we are leaving Python
-            e.setMessage(e.getUnreifiedException().getFormattedMessage());
+            if (e.getUnreifiedException() instanceof PBaseException managedException) {
+                e.setMessage(managedException.getFormattedMessage());
+            }
             throw e;
         }
     }

graalpython/com.oracle.graal.python.test/src/tests/cpyext/__init__.py

@@ -58,6 +58,15 @@ def assert_raises(err, fn, *args, **kwargs):
     assert raised
 
 
+if sys.implementation.name == 'graalpy':
+    is_native_object = getattr(__graalpython__, 'is_native_object', None)
+    if not is_native_object:
+        raise RuntimeError("Needs to be run with --python.EnableDebuggingBuiltins")
+else:
+    def is_native_object(obj):
+        return True
+
+
 def unhandled_error_compare(x, y):
     if (isinstance(x, BaseException) and isinstance(y, BaseException)):
         return type(x) == type(y)
@@ -591,7 +600,7 @@ def CPyExtType(name, code, **kwargs):
         {tp_getattro},
         {tp_setattro},
         {tp_as_buffer},
-        Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+        {tp_flags},
         "",
         {tp_traverse},              /* tp_traverse */
         {tp_clear},                 /* tp_clear */
@@ -648,6 +657,7 @@ def CPyExtType(name, code, **kwargs):
     kwargs.setdefault("tp_new", "PyType_GenericNew")
     kwargs.setdefault("tp_alloc", "PyType_GenericAlloc")
     kwargs.setdefault("tp_free", "PyObject_Del")
+    kwargs.setdefault("tp_flags", "Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE")
     kwargs.setdefault("cmembers", "")
     kwargs.setdefault("includes", "")
     kwargs.setdefault("struct_base", "PyObject_HEAD")

graalpython/com.oracle.graal.python.test/src/tests/cpyext/test_bytes.py

@@ -38,7 +38,8 @@
 # SOFTWARE.
 import unittest
 
-from . import CPyExtTestCase, CPyExtFunction, CPyExtFunctionOutVars, unhandled_error_compare, CPyExtType
+from . import CPyExtTestCase, CPyExtFunction, CPyExtFunctionOutVars, unhandled_error_compare, CPyExtType, \
+    is_native_object
 
 __dir__ = __file__.rpartition("/")[0]
 
@@ -589,6 +590,7 @@ def test_create_from_buffer_exception(self):
 class TestNativeSubclass(unittest.TestCase):
     def test_builtins(self):
         b = BytesSubclass(b"hello")
+        assert is_native_object(b)
         assert type(b) == BytesSubclass
         assert b
         assert not BytesSubclass(b'')
@@ -617,3 +619,9 @@ def test_builtins(self):
         assert b.replace(b'e', b'a') == b'hallo'
         assert b.upper() == b'HELLO'
         assert BytesSubclass(b'a,b').split(BytesSubclass(b',')) == [b'a', b'b']
+
+    def test_managed_subclass(self):
+        class ManagedSubclass(BytesSubclass):
+            pass
+
+        assert is_native_object(ManagedSubclass(b"hello"))

graalpython/com.oracle.graal.python.test/src/tests/cpyext/test_codec.py

@@ -0,0 +1,75 @@
+# Copyright (c) 2023, 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.
+
+import codecs
+
+from tests.cpyext import CPyExtTestCase, CPyExtFunction, unhandled_error_compare
+
+
+class TestPyCodec(CPyExtTestCase):
+
+    def compile_module(self, name):
+        type(self).mro()[1].__dict__["test_%s" % name].create_module(name)
+        super().compile_module(name)
+
+    test_PyCodec_Encoder = CPyExtFunction(
+        lambda args: codecs.lookup(args[0])[0],
+        lambda: (
+            ("utf-8",),
+            ("ascii",),
+            ("this-doesn't-exist",),
+        ),
+        resultspec="O",
+        argspec='s',
+        arguments=["char* encoding"],
+        cmpfunc=unhandled_error_compare,
+    )
+
+    test_PyCodec_Decoder = CPyExtFunction(
+        lambda args: codecs.lookup(args[0])[1],
+        lambda: (
+            ("utf-8",),
+            ("ascii",),
+            ("this-doesn't-exist",),
+        ),
+        resultspec="O",
+        argspec='s',
+        arguments=["char* encoding"],
+        cmpfunc=unhandled_error_compare,
+    )