Exception handling generated code is now entirely python-object free.

Author: braxtonmckee

typed_python/_runtime.cpp

@@ -1021,16 +1021,14 @@ extern "C" {
         return PythonObjectOfType::createLayout(p);
     }
 
-    void np_initialize_exception(PythonObjectOfType::layout_type* layout) {
+    // set the python exception state and return (without throwing)
+    void setExceptionState(PyObject* exception, PyObject* cause) {
         PyEnsureGilAcquired getTheGil;
 
-        PyObject* prevType;
-        PyObject* prevValue;
-        PyObject* prevTraceback;
-        PyErr_GetExcInfo(&prevType, &prevValue, &prevTraceback);
-
-        if (layout) {
-            PyTypeObject* tp = layout->pyObj->ob_type;
+        // check if the exception is actually an exception. If not,
+        // we can't even raise it.
+        if (exception) {
+            PyTypeObject* tp = exception->ob_type;
             bool hasBaseE = false;
 
             while (tp) {
@@ -1044,81 +1042,64 @@ extern "C" {
                 PyErr_Format(
                     PyExc_TypeError,
                     "exceptions must derive from BaseException, not %S",
-                    (PyObject*)layout->pyObj->ob_type
+                    (PyObject*)exception->ob_type
                 );
 
                 return;
             }
+        }
+
+        if (exception && cause) {
+            // if we have an exception and a cause, just raise directly
+            PyException_SetCause(exception, incref(cause));
+            PyErr_Restore((PyObject*)incref(exception->ob_type), incref(exception), nullptr);
+        }
+        else if (exception) {
+            PyObject* prevType;
+            PyObject* prevValue;
+            PyObject* prevTraceback;
+            PyErr_GetExcInfo(&prevType, &prevValue, &prevTraceback);
 
             if (prevValue) {
-                PyException_SetContext(layout->pyObj, prevValue);
+                PyException_SetContext(exception, prevValue);
             }
             decref(prevType);
             decref(prevTraceback);
 
-            PyErr_SetObject(
-                (PyObject*)layout->pyObj->ob_type,
-                layout->pyObj
-            );
+            PyErr_SetObject((PyObject*)exception->ob_type, exception);
         }
         else {
+            PyObject* prevType;
+            PyObject* prevValue;
+            PyObject* prevTraceback;
+            PyErr_GetExcInfo(&prevType, &prevValue, &prevTraceback);
+
             if (!prevValue) {
                 decref(prevType);
                 decref(prevValue);
                 decref(prevTraceback);
                 PyErr_SetString(PyExc_RuntimeError, "No active exception to reraise");
                 throw PythonExceptionSet();
             }
+            if (cause) {
+                PyException_SetCause(prevValue, incref(cause));
+            }
             PyErr_Restore(prevType, prevValue, prevTraceback);
         }
     }
 
+    void np_initialize_exception(PythonObjectOfType::layout_type* layout) {
+        setExceptionState(layout ? layout->pyObj : nullptr, nullptr);
+    }
+
     void np_initialize_exception_w_cause(
             PythonObjectOfType::layout_type* layoutExc,
             PythonObjectOfType::layout_type* layoutCause
             ) {
-        PyEnsureGilAcquired getTheGil;
-
-        if (layoutExc) {
-            PyTypeObject* tp = layoutExc->pyObj->ob_type;
-            bool hasBaseE = false;
-
-            while (tp) {
-                if (tp == (PyTypeObject*)PyExc_BaseException) {
-                    hasBaseE = true;
-                }
-                tp = tp->tp_base;
-            }
-
-            if (!hasBaseE) {
-                PyErr_Format(
-                    PyExc_TypeError,
-                    "exceptions must derive from BaseException, not %S",
-                    (PyObject*)layoutExc->pyObj->ob_type
-                );
-
-                return;
-            }
-
-            PyException_SetCause(layoutExc->pyObj, layoutCause ? incref(layoutCause->pyObj) : NULL);
-            PyErr_Restore((PyObject*)incref(layoutExc->pyObj->ob_type), incref(layoutExc->pyObj), nullptr);
-        }
-        else {
-            PyObject* prevType;
-            PyObject* prevValue;
-            PyObject* prevTraceback;
-            PyErr_GetExcInfo(&prevType, &prevValue, &prevTraceback);
-
-            if (!prevValue) {
-                decref(prevType);
-                decref(prevValue);
-                decref(prevTraceback);
-                PyErr_SetString(PyExc_RuntimeError, "No active exception to reraise");
-                throw PythonExceptionSet();
-            }
-            PyException_SetCause(prevValue, layoutCause ? incref(layoutCause->pyObj) : NULL);
-            PyErr_Restore(prevType, prevValue, prevTraceback);
-        }
+        setExceptionState(
+            layoutExc ? layoutExc->pyObj : nullptr,
+            layoutCause ? layoutCause->pyObj : nullptr
+        );
     }
 
     void np_clear_exception() {
@@ -1353,6 +1334,58 @@ extern "C" {
         return PythonObjectOfType::stealToCreateLayout(res);
     }
 
+    void nativepython_runtime_call_pyobj_and_raise(
+        int argCount,
+        int kwargCount,
+        ...
+    ) {
+        PyEnsureGilAcquired getTheGil;
+
+        // each of 'argCount' arguments is a PyObject* followed by a const char*
+        va_list va_args;
+        va_start(va_args, kwargCount);
+
+        PyObjectHolder toCall;
+
+        PyObjectStealer args(PyTuple_New(argCount - 1));
+        PyObjectStealer kwargs(PyDict_New());
+
+        for (int i = 0; i < argCount; ++i) {
+            instance_ptr data = va_arg(va_args, instance_ptr);
+            Type* typ = va_arg(va_args, Type*);
+
+            if (i == 0) {
+                toCall.steal(
+                    PyInstance::extractPythonObject(data, typ)
+                );
+            } else {
+                PyTuple_SetItem((PyObject*)args, i - 1, PyInstance::extractPythonObject(data, typ));
+            }
+        }
+
+        for (int i = 0; i < kwargCount; ++i) {
+            instance_ptr data = va_arg(va_args, instance_ptr);
+            Type* typ = va_arg(va_args, Type*);
+            const char* kwargName = va_arg(va_args, const char*);
+
+            PyObjectStealer kwargVal(PyInstance::extractPythonObject(data, typ));
+
+            PyDict_SetItemString((PyObject*)kwargs, kwargName, (PyObject*)kwargVal);
+        }
+
+        va_end(va_args);
+
+        PyObjectStealer res(PyObject_Call((PyObject*)toCall, args, kwargs));
+
+        if (!res) {
+            throw PythonExceptionSet();
+        }
+
+        setExceptionState((PyObject*)res, nullptr);
+
+        throw PythonExceptionSet();
+    }
+
     PythonObjectOfType::layout_type* nativepython_runtime_call_pyobj(
         PythonObjectOfType::layout_type* toCall,
         int argCount,

typed_python/compiler/expression_conversion_context.py

@@ -1286,53 +1286,44 @@ def pushException(self, excType, *args, **kwargs):
         Returns:
             None
         """
-        if len(args) == 0 and isinstance(excType, type):
-            self.pushEffect(
-                runtime_functions.np_raise_exception_str.call(
-                    self.constantPyObject(excType).nonref_expr.cast(native_ast.VoidPtr),
-                    native_ast.UInt8.pointer().zero(),
-                )
-            )
-            return None
-
-        if len(args) == 1 and isinstance(args[0], str) and isinstance(excType, type):
-            # this is the most common pathway
-            self.pushEffect(
-                runtime_functions.np_raise_exception_str.call(
-                    self.constantPyObject(excType).nonref_expr.cast(native_ast.VoidPtr),
-                    native_ast.const_utf8_cstr(args[0]),
-                )
-            )
-            return None
-
         def toTyped(x):
             if isinstance(x, TypedExpression):
                 return x
             return self.constant(x)
 
-        origExcType = excType
-        excType = toTyped(excType)
-        args = [toTyped(x) for x in args]
+        args = [toTyped(excType)] + [toTyped(x) for x in args]
         kwargs = {k: toTyped(v) for k, v in kwargs.items()}
 
-        if len(args) == 1 and isinstance(args[0].constantValue, str) and isinstance(origExcType, type):
-            self.pushEffect(
-                runtime_functions.np_raise_exception_str.call(
-                    self.constantPyObject(origExcType).nonref_expr.cast(native_ast.VoidPtr),
-                    native_ast.const_utf8_cstr(args[0].constantValue),
-                )
-            )
-            return None
+        args = [a.demasquerade() for a in args]
+        kwargs = {k: v.demasquerade() for k, v in kwargs.items()}
 
-        if excType is None:
-            return None
+        # we converted everything to python objects. We need to pass this
+        # ensemble to the interpreter. We use c-style variadic arguments here
+        # since everything is a pointer.
+        arguments = []
+        kwarguments = []
 
-        exceptionVal = excType.convert_call(args, kwargs)
+        for a in args:
+            a = a.ensureIsReference()
 
-        if exceptionVal is None:
-            return None
+            arguments.append(a.expr.cast(native_ast.VoidPtr))
+            arguments.append(self.getTypePointer(a.expr_type.typeRepresentation))
 
-        return self.pushExceptionObject(exceptionVal)
+        for kwargName, kwargVal in kwargs.items():
+            kwargVal = kwargVal.ensureIsReference()
+
+            kwarguments.append(kwargVal.expr.cast(native_ast.VoidPtr))
+            kwarguments.append(self.getTypePointer(kwargVal.expr_type.typeRepresentation))
+            kwarguments.append(native_ast.const_utf8_cstr(kwargName))
+
+        return self.pushEffect(
+            runtime_functions.call_pyobj_and_raise.call(
+                native_ast.const_int_expr(len(args)),
+                native_ast.const_int_expr(len(kwargs)),
+                *arguments,
+                *kwarguments,
+            )
+        )
 
     def pushExceptionClear(self):
         nativeExpr = (
@@ -1368,8 +1359,7 @@ def pushExceptionObjectWithCause(self, exceptionObject, causeObject, deferred=Fa
         if exceptionObject is None:
             exceptionObject = self.zero(object)
 
-        if causeObject.expr_type.typeRepresentation is type(None):  # noqa
-            causeObject = self.zero(object)
+        causeObject = causeObject.toPyObj()
 
         nativeExpr = (
             runtime_functions.initialize_exception_w_cause.call(

typed_python/compiler/function_conversion_context.py

@@ -1950,6 +1950,32 @@ def _convert_statement_ast(self, ast, variableStates: FunctionStackState, contro
             if ast.exc is None:
                 toThrow = None  # means reraise
             else:
+                if (
+                    ast.exc.matches.Call
+                    and len(ast.exc.args) == 1
+                    and not ast.exc.keywords
+                    and not ast.exc.args[0].matches.Starred
+                    and ast.cause is None
+                ):
+                    exceptionT = expr_context.convert_expression_ast(ast.exc.func)
+                    if exceptionT is None:
+                        return (
+                            expr_context.finalize(None, exceptionsTakeFrom=None if ast.exc is None else ast), False
+                        )
+
+                    exceptionArg = expr_context.convert_expression_ast(ast.exc.args[0])
+                    if exceptionArg is None:
+                        return (
+                            expr_context.finalize(None, exceptionsTakeFrom=None if ast.exc is None else ast), False
+                        )
+
+                    expr_context.pushException(
+                        exceptionT,
+                        exceptionArg
+                    )
+
+                    return expr_context.finalize(None, exceptionsTakeFrom=None if ast.exc is None else ast), False
+
                 toThrow = expr_context.convert_expression_ast(ast.exc)
 
                 if toThrow is None:

typed_python/compiler/python_to_native_converter.py

@@ -916,20 +916,19 @@ def _installInflightFunctions(self, name):
                     self._currentlyConverting = None
 
         for identifier, functionConverter in self._inflight_function_conversions.items():
+            outboundTargets = []
+            for outboundFuncId in self._dependencies.getNamesDependedOn(identifier):
+                name = self._link_name_for_identity[outboundFuncId]
+                outboundTargets.append(self._targets[name])
+
+            nativeFunction, actual_output_type = self._inflight_definitions.get(identifier)
+
             if identifier in self._identifier_to_pyfunc:
                 for v in self._visitors:
-
                     funcName, funcCode, funcGlobals, closureVars, input_types, output_type, conversionType = (
                         self._identifier_to_pyfunc[identifier]
                     )
 
-                    nativeFunction, actual_output_type = self._inflight_definitions.get(identifier)
-
-                    outboundTargets = []
-                    for outboundFuncId in self._dependencies.getNamesDependedOn(identifier):
-                        name = self._link_name_for_identity[outboundFuncId]
-                        outboundTargets.append(self._targets[name])
-
                     try:
                         v.onNewFunction(
                             identifier,
@@ -948,6 +947,17 @@ def _installInflightFunctions(self, name):
                         )
                     except Exception:
                         logging.exception("event handler %s threw an unexpected exception", v.onNewFunction)
+            else:
+                for v in self._visitors:
+                    v.onNewNonpythonFunction(
+                        identifier,
+                        self._link_name_for_identity[identifier],
+                        functionConverter,
+                        nativeFunction,
+                        outboundTargets
+                    )
+
+
 
             if identifier not in self._inflight_definitions:
                 raise Exception(