[GR-47145][GR-45804] Various fixes for MCD

PullRequest: graalpython/2866

Author: msimacek

graalpython/com.oracle.graal.python.cext/include/listobject.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, 2022, Oracle and/or its affiliates.
+/* Copyright (c) 2018, 2023, Oracle and/or its affiliates.
  * Copyright (C) 1996-2017 Python Software Foundation
  *
  * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
@@ -45,6 +45,11 @@ PyAPI_FUNC(int) PyList_Sort(PyObject *);
 PyAPI_FUNC(int) PyList_Reverse(PyObject *);
 PyAPI_FUNC(PyObject *) PyList_AsTuple(PyObject *);
 
+/*
+ * GraalPy-specific, used to implement cython's array.resize_smart
+ */
+PyAPI_FUNC(int) _PyArray_Resize(PyObject* array, Py_ssize_t new_size);
+
 #ifndef Py_LIMITED_API
 #  define Py_CPYTHON_LISTOBJECT_H
 #  include  "cpython/listobject.h"

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

@@ -2420,6 +2420,10 @@ PyAPI_FUNC(PyObject*) Py_GenericAlias(PyObject* a, PyObject* b) {
 PyAPI_FUNC(void) Py_LeaveRecursiveCall() {
     GraalPy_LeaveRecursiveCall();
 }
+#undef _PyArray_Resize
+PyAPI_FUNC(int) _PyArray_Resize(PyObject* a, Py_ssize_t b) {
+    return Graal_PyArray_Resize(a, b);
+}
 #undef _PyBytes_Join
 PyAPI_FUNC(PyObject*) _PyBytes_Join(PyObject* a, PyObject* b) {
     return Graal_PyBytes_Join(a, b);

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

@@ -607,6 +607,7 @@ typedef struct {
     BUILTIN(Py_set_PyTypeObject_tp_vectorcall_offset, void, PyTypeObject*, Py_ssize_t) \
     BUILTIN(Py_set_PyTypeObject_tp_weaklistoffset, void, PyTypeObject*, Py_ssize_t) \
     BUILTIN(Py_set_PyVarObject_ob_size, void, PyVarObject*, Py_ssize_t) \
+    BUILTIN(_PyArray_Resize, int, PyObject*, Py_ssize_t) \
     BUILTIN(_PyBytes_Join, PyObject*, PyObject*, PyObject*) \
     BUILTIN(_PyDict_Pop, PyObject*, PyObject*, PyObject*, PyObject*) \
     BUILTIN(_PyDict_SetItem_KnownHash, int, PyObject*, PyObject*, PyObject*, Py_hash_t) \

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

@@ -1236,6 +1236,7 @@ void unimplemented(const char* name) {
 #undef _PyArg_VaParseTupleAndKeywordsFast_SizeT
 #undef _PyArg_VaParseTupleAndKeywords_SizeT
 #undef _PyArg_VaParse_SizeT
+#undef _PyArray_Resize
 #undef _PyAsyncGenValueWrapperNew
 #undef _PyByteArray_Start
 #undef _PyBytesWriter_Alloc
@@ -4797,6 +4798,10 @@ PyAPI_FUNC(int) _PyArg_VaParse_SizeT(PyObject* a, const char* b, va_list c) {
     int result = (int) __target___PyArg_VaParse_SizeT(a, b, c);
     return result;
 }
+PyAPI_FUNC(int) _PyArray_Resize(PyObject* a, Py_ssize_t b) {
+    int result = (int) Graal_PyArray_Resize(a, b);
+    return result;
+}
 PyAPI_FUNC(PyObject*) _PyAsyncGenValueWrapperNew(PyObject* a) {
     unimplemented("_PyAsyncGenValueWrapperNew"); exit(-1);
 }

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

@@ -426,6 +426,7 @@ def __get__(self, instance, typ=None):
             return self
         else:
             CPyExtFunction.test.__name__ = self.name
+            CPyExtFunction.test.__qualname__ = f'{CPyExtFunction.__name__}.test_{self.name}'
             return self.test
 
 

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

@@ -0,0 +1,80 @@
+# 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 sys
+from array import array
+
+from tests.cpyext import CPyExtTestCase, CPyExtFunction, unhandled_error_compare
+
+
+def reference_array_resize(args):
+    a, n = args
+    if n < len(a):
+        del a[n:]
+    else:
+        a.extend([0 for i in range(n - len(a))])
+    return a
+
+
+class TestPyArray(CPyExtTestCase):
+
+    def compile_module(self, name):
+        type(self).mro()[1].__dict__["test_%s" % name].create_module(name)
+        super().compile_module(name)
+
+    if sys.implementation.name == 'graalpy':
+        test__PyArray_Resize = CPyExtFunction(
+            reference_array_resize,
+            lambda: (
+                (array('i', [1, 2, 3]), 1),
+                (array('i'), 3),
+            ),
+            code="""
+                PyObject* wrap__PyArray_Resize(PyObject* array, Py_ssize_t new_size) {
+                    if (_PyArray_Resize(array, new_size) < 0)
+                        return NULL;
+                    Py_INCREF(array);
+                    return array;
+                }
+            """,
+            callfunction="wrap__PyArray_Resize",
+            resultspec="O",
+            argspec='On',
+            arguments=["PyObject* array", "Py_ssize_t new_size"],
+            cmpfunc=unhandled_error_compare,
+        )

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

@@ -36,14 +36,15 @@
 # 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 math
+
+from . import CPyExtType, CPyExtTestCase, CPyExtFunction, CPyExtFunctionOutVars, unhandled_error_compare, \
+    is_native_object
 
-import sys
-from . import CPyExtType, CPyExtTestCase, CPyExtFunction, CPyExtFunctionOutVars, unhandled_error_compare, GRAALPYTHON
 __dir__ = __file__.rpartition("/")[0]
 
 
 def _float_compare(x, y):
-
     def isNan(x):
         return isinstance(x, float) and x != x
 
@@ -77,6 +78,17 @@ def __float__(self):
         return 2.71828
 
 
+NativeFloatSubclass = CPyExtType(
+    'TestFloatNativeFloatSubclass',
+    '',
+    struct_base='PyFloatObject base',
+    tp_base="&PyFloat_Type",
+    tp_new='0',
+    tp_alloc='0',
+    tp_free='0',
+)
+
+
 class TestPyFloat(CPyExtTestCase):
 
     def compile_module(self, name):
@@ -185,39 +197,107 @@ def compile_module(self, name):
         cmpfunc=unhandled_error_compare
     )
 
+
 class TestPyOSDouble:
     def test_PyOS_double_to_string(self):
-        TestPyOS_Double_To_String = CPyExtType("TestPyOS_Double_To_String",
-                                '''
-                                static PyObject* testPyOS_D_to_Str(PyObject* self, PyObject *pyval) {
-                                    double val = PyFloat_AsDouble(pyval);
-                                    char *str = PyOS_double_to_string(val, 'f', 6, 0x2, NULL);
-                                    return PyUnicode_FromString(str);
-                                }
-                                ''',
-                                tp_methods='{"PyOS_double_to_string_test", (PyCFunction)testPyOS_D_to_Str, METH_O, ""}',
-                                )
+        TestPyOS_Double_To_String = CPyExtType(
+            "TestPyOS_Double_To_String",
+            '''
+            static PyObject* testPyOS_D_to_Str(PyObject* self, PyObject *pyval) {
+                double val = PyFloat_AsDouble(pyval);
+                char *str = PyOS_double_to_string(val, 'f', 6, 0x2, NULL);
+                return PyUnicode_FromString(str);
+            }
+            ''',
+            tp_methods='{"PyOS_double_to_string_test", (PyCFunction)testPyOS_D_to_Str, METH_O, ""}',
+        )
         tester = TestPyOS_Double_To_String()
         assert tester.PyOS_double_to_string_test(150.604459) == '150.604459'
         assert tester.PyOS_double_to_string_test(174.426353) == '174.426353'
         assert tester.PyOS_double_to_string_test(151.074362) == '151.074362'
         assert tester.PyOS_double_to_string_test(190.08) == '190.080000'
 
     def test_PyOS_string_to_double(self):
-        TestPyOS_String_To_Double = CPyExtType("TestPyOS_String_To_Double",
-                                '''
-                                static PyObject* testPyOS_Str_to_D(PyObject* self, PyObject *str) {
-                                    char *endptr;
-                                    const char *s = (char *) PyUnicode_AsUTF8(str);
-                                    double ret = PyOS_string_to_double(s, &endptr, NULL);
-                                    if (PyErr_Occurred()) {
-                                        return NULL;
-                                    }
-                                    return PyFloat_FromDouble(ret);
-                                }
-                                ''',
-                                tp_methods='{"PyOS_string_to_double_test", (PyCFunction)testPyOS_Str_to_D, METH_O, ""}',
-                                )
+        TestPyOS_String_To_Double = CPyExtType(
+            "TestPyOS_String_To_Double",
+            '''
+            static PyObject* testPyOS_Str_to_D(PyObject* self, PyObject *str) {
+                char *endptr;
+                const char *s = (char *) PyUnicode_AsUTF8(str);
+                double ret = PyOS_string_to_double(s, &endptr, NULL);
+                if (PyErr_Occurred()) {
+                    return NULL;
+                }
+                return PyFloat_FromDouble(ret);
+            }
+            ''',
+            tp_methods='{"PyOS_string_to_double_test", (PyCFunction)testPyOS_Str_to_D, METH_O, ""}',
+        )
         tester = TestPyOS_String_To_Double()
         assert tester.PyOS_string_to_double_test('5') == float(5)
         assert tester.PyOS_string_to_double_test('150.604459') == float(150.604459)
+
+
+class TestNativeFloatSubclass:
+    def test_create(self):
+        f = NativeFloatSubclass(1.0)
+        assert is_native_object(f)
+
+        class ManagedSubclass(NativeFloatSubclass):
+            pass
+
+        f = ManagedSubclass(1.0)
+        assert is_native_object(f)
+
+    def test_methods(self):
+        f = NativeFloatSubclass(1.1)
+        zero = NativeFloatSubclass(0.0)
+        nan = NativeFloatSubclass('nan')
+
+        assert bool(f)
+        assert not bool(zero)
+
+        assert f == 1.1
+        assert nan != nan
+        assert f != zero
+        assert +f == 1.1
+        assert -f == -1.1
+        assert f > 0
+        assert f < 2
+        assert f >= 1.1
+        assert f <= 1.1
+        assert str(f) == '1.1'
+        assert repr(f) == '1.1'
+        assert int(f) == 1
+        assert format(f, 'f') == '1.100000'
+        assert abs(NativeFloatSubclass(-2.1)) == 2.1
+        assert round(f) == 1.0
+        assert f + 1.0 == 2.1
+        assert 1.0 + f == 2.1
+        assert f * 2 == 2.2
+        assert f - 1.6 == -0.5
+        assert f // 2 == 0.0
+        assert f % 2 == 1.1
+        assert f / 2.0 == 0.55
+        assert f ** 0 == 1.0
+        assert divmod(f, 2) == (0.0, 1.1)
+        assert hash(f) == hash(1.1)
+        assert f.hex() == (1.1).hex()
+        assert f.real == 1.1
+        assert f.imag == 0.0
+        assert f.conjugate() == 1.1
+        assert not f.is_integer()
+        assert f.as_integer_ratio() == (1.1).as_integer_ratio()
+        assert f.__getnewargs__() == (1.1,)
+
+    def test_math(self):
+        assert math.isnan(NativeFloatSubclass('nan'))
+        assert math.isinf(NativeFloatSubclass('inf'))
+        assert not math.isfinite(NativeFloatSubclass('inf'))
+        f = NativeFloatSubclass(0.9)
+        for fn in [math.ceil, math.floor, math.sqrt, math.exp, math.expm1, math.frexp, math.modf, math.sin, math.asin,
+                   math.cos, math.acos, math.tan, math.atan, math.log2, math.log10, math.log1p, math.fabs, math.trunc,
+                   math.degrees, math.radians, math.gamma, math.lgamma, math.sqrt]:
+            assert fn(f) == fn(0.9)
+
+        assert math.log(f, 10) == math.log(0.9, 10)