[lldb] Use SWIG_fail in python-typemaps.swig (NFC)

[kastiglione]

Summary

When attempting to use SWIG's -builtin flag, there were a few compile
failures caused by a mismatch between return type and return value. In those
cases, the return type was int but many of the type maps assume returning
NULL/nullptr (only the latter caused compile failures).

This fix abstracts failure paths to use the SWIG_fail macro, which performs
goto fail;. Each of the generated functions contain a fail label, which
performs any resource cleanup and returns the appropriate failure value.

This change isn't strictly necessary at this point, but seems like the right
thing to do, and for anyone who tries -builtin later, it resolves those
issues.

[JDevlieghere]

LGTM

lldb/bindings/python/python-typemaps.swig

if (PythonList::Check($input)) {
     int size = list.GetSize();
     int i = 0;
     $1 = (char **)malloc((size + 1) * sizeof(char *));
     for (i = 0; i < size; i++) {
       PythonString py_str = list.GetItemAtIndex(i).AsType<PythonString>();
       if (!py_str.IsAllocated()) {
         PyErr_SetString(PyExc_TypeError, "list must contain strings");
         free($1);
-        return nullptr;
+        SWIG_fail;
       }
 
       $1[i] = const_cast<char *>(py_str.GetString().data());
     }
     $1[i] = 0;
   } else if ($input == Py_None) {
     $1 = NULL;
   } else {
     PyErr_SetString(PyExc_TypeError, "not a list");
-    return NULL;
+    SWIG_fail;
   }
 }
 
 %typemap(typecheck) char ** {
   /* Check if is a list  */
   $1 = 1;
   if (PythonList::Check($input)) {
     PythonList list(PyRefType::Borrowed, $input);
for (i = 0; i < len; i++)
     list.SetItemAtIndex(i, PythonString($1[i]));
   $result = list.release();
 }
 
 %typemap(in) lldb::tid_t {
   PythonObject obj = Retain<PythonObject>($input);
   lldb::tid_t value = unwrapOrSetPythonException(As<unsigned long long>(obj));
   if (PyErr_Occurred())
-    return nullptr;
+    SWIG_fail;
   $1 = value;
 }
 
 %typemap(in) lldb::StateType {
   PythonObject obj = Retain<PythonObject>($input);
   unsigned long long state_type_value =
       unwrapOrSetPythonException(As<unsigned long long>(obj));
   if (PyErr_Occurred())
-    return nullptr;
+    SWIG_fail;
   if (state_type_value > lldb::StateType::kLastStateType) {
     PyErr_SetString(PyExc_ValueError, "Not a valid StateType value");
-    return nullptr;
+    SWIG_fail;
   }
   $1 = static_cast<lldb::StateType>(state_type_value);
 }
 
 /* Typemap definitions to allow SWIG to properly handle char buffer. */
 
 // typemap for a char buffer
 %typemap(in) (char *dst, size_t dst_len) {
   if (!PyInt_Check($input)) {
     PyErr_SetString(PyExc_ValueError, "Expecting an integer");
-    return NULL;
+    SWIG_fail;
   }
   $2 = PyInt_AsLong($input);
   if ($2 <= 0) {
     PyErr_SetString(PyExc_ValueError, "Positive integer expected");
-    return NULL;
+    SWIG_fail;
   }
   $1 = (char *)malloc($2);
 }
 // SBProcess::ReadCStringFromMemory() uses a void*, but needs to be treated
 // as char data instead of byte data.
 %typemap(in) (void *char_buf, size_t size) = (char *dst, size_t dst_len);
 
 // Return the char buffer.  Discarding any previous return result

 // as char data instead of byte data.
 %typemap(argout) (void *char_buf, size_t size) = (char *dst, size_t dst_len);
 
 
 // typemap for handling an snprintf-like API like SBThread::GetStopDescription.
 %typemap(in) (char *dst_or_null, size_t dst_len) {
   if (!PyInt_Check($input)) {
     PyErr_SetString(PyExc_ValueError, "Expecting an integer");
-    return NULL;
+    SWIG_fail;
   }
   $2 = PyInt_AsLong($input);
   if ($2 <= 0) {
     PyErr_SetString(PyExc_ValueError, "Positive integer expected");
-    return NULL;
+    SWIG_fail;
   }
   $1 = (char *)malloc($2);
 }
 %typemap(argout) (char *dst_or_null, size_t dst_len) {
   Py_XDECREF($result); /* Blow away any previous result */
   llvm::StringRef ref($1);
   PythonString string(ref);
   $result = string.release();
if (PythonString::Check($input)) {
     $1 = (char *)bytearray.GetBytes().data();
     $2 = bytearray.GetSize();
   } else if (PythonBytes::Check($input)) {
     PythonBytes bytes(PyRefType::Borrowed, $input);
     $1 = (char *)bytes.GetBytes().data();
     $2 = bytes.GetSize();
   } else {
     PyErr_SetString(PyExc_ValueError, "Expecting a string");
-    return NULL;
+    SWIG_fail;
   }
 }
 // For SBProcess::WriteMemory, SBTarget::GetInstructions and SBDebugger::DispatchInput.
 %typemap(in) (const void *buf, size_t size),
              (const void *data, size_t data_len) {
   if (PythonString::Check($input)) {
     PythonString str(PyRefType::Borrowed, $input);
     $1 = (void *)str.GetString().data();
     $2 = str.GetSize();
   } else if (PythonByteArray::Check($input)) {
     PythonByteArray bytearray(PyRefType::Borrowed, $input);
     $1 = (void *)bytearray.GetBytes().data();
     $2 = bytearray.GetSize();
   } else if (PythonBytes::Check($input)) {
     PythonBytes bytes(PyRefType::Borrowed, $input);
     $1 = (void *)bytes.GetBytes().data();
     $2 = bytes.GetSize();
   } else {
     PyErr_SetString(PyExc_ValueError, "Expecting a buffer");
-    return NULL;
+    SWIG_fail;
   }
 }
 
 // typemap for an incoming buffer
 // See also SBProcess::ReadMemory.
 %typemap(in) (void *buf, size_t size) {
   if (PyInt_Check($input)) {
     $2 = PyInt_AsLong($input);
   } else if (PyLong_Check($input)) {
     $2 = PyLong_AsLong($input);
   } else {
     PyErr_SetString(PyExc_ValueError, "Expecting an integer or long object");
-    return NULL;
+    SWIG_fail;
   }
   if ($2 <= 0) {
     PyErr_SetString(PyExc_ValueError, "Positive integer expected");
-    return NULL;
+    SWIG_fail;
   }
   $1 = (void *)malloc($2);
 }
 
 // Return the buffer.  Discarding any previous return result
 // See also SBProcess::ReadMemory.
 %typemap(argout) (void *buf, size_t size) {
   Py_XDECREF($result); /* Blow away any previous result */
if (PyList_Check($input)) {
     int i = 0;
     $2 = size;
     $1 = ($1_type)malloc(size * sizeof($*1_type));
     for (i = 0; i < size; i++) {
       PyObject *o = PyList_GetItem($input, i);
       if (!SetNumberFromPyObject($1[i], o)) {
         PyErr_SetString(PyExc_TypeError, "list must contain numbers");
         free($1);
-        return NULL;
+        SWIG_fail;
       }
 
       if (PyErr_Occurred()) {
         free($1);
-        return NULL;
+        SWIG_fail;
       }
     }
   } else if ($input == Py_None) {
     $1 = NULL;
     $2 = 0;
   } else {
     PyErr_SetString(PyExc_TypeError, "not a list");
-    return NULL;
+    SWIG_fail;
   }
 }
 
 %typemap(freearg) (uint64_t* array, size_t array_len),
                   (uint32_t* array, size_t array_len),
                   (int64_t* array, size_t array_len),
                   (int32_t* array, size_t array_len),
                   (double* array, size_t array_len) {

 }
 
 
 // For Log::LogOutputCallback
 %typemap(in) (lldb::LogOutputCallback log_callback, void *baton) {
   if (!($input == Py_None ||
         PyCallable_Check(reinterpret_cast<PyObject *>($input)))) {
     PyErr_SetString(PyExc_TypeError, "Need a callable object or None!");
-    return NULL;
+    SWIG_fail;
   }
 
   // FIXME (filcab): We can't currently check if our callback is already
   // LLDBSwigPythonCallPythonLogOutputCallback (to DECREF the previous
   // baton) nor can we just remove all traces of a callback, if we want to
   // revert to a file logging mechanism.
 
   // Don't lose the callback reference
   Py_INCREF($input);
   $1 = LLDBSwigPythonCallPythonLogOutputCallback;
   $2 = $input;
 }
 
 %typemap(typecheck) (lldb::LogOutputCallback log_callback, void *baton) {
   $1 = $input == Py_None;
   $1 = $1 || PyCallable_Check(reinterpret_cast<PyObject *>($input));
 }
 
 
 %typemap(in) lldb::FileSP {
   PythonFile py_file(PyRefType::Borrowed, $input);
   if (!py_file) {
     PyErr_SetString(PyExc_TypeError, "not a file");
-    return nullptr;
+    SWIG_fail;
   }
   auto sp = unwrapOrSetPythonException(py_file.ConvertToFile());
   if (!sp)
-    return nullptr;
+    SWIG_fail;
   $1 = sp;
 }
 
 %typemap(in) lldb::FileSP FORCE_IO_METHODS {
   PythonFile py_file(PyRefType::Borrowed, $input);
   if (!py_file) {
     PyErr_SetString(PyExc_TypeError, "not a file");
-    return nullptr;
+    SWIG_fail;
   }
   auto sp = unwrapOrSetPythonException(
       py_file.ConvertToFileForcingUseOfScriptingIOMethods());
   if (!sp)
-    return nullptr;
+    SWIG_fail;
   $1 = sp;
 }
 
 %typemap(in) lldb::FileSP BORROWED {
   PythonFile py_file(PyRefType::Borrowed, $input);
   if (!py_file) {
     PyErr_SetString(PyExc_TypeError, "not a file");
-    return nullptr;
+    SWIG_fail;
   }
   auto sp =
       unwrapOrSetPythonException(py_file.ConvertToFile(/*borrowed=*/true));
   if (!sp)
-    return nullptr;
+    SWIG_fail;
   $1 = sp;
 }
 
 %typemap(in) lldb::FileSP BORROWED_FORCE_IO_METHODS {
   PythonFile py_file(PyRefType::Borrowed, $input);
   if (!py_file) {
     PyErr_SetString(PyExc_TypeError, "not a file");
-    return nullptr;
+    SWIG_fail;
   }
   auto sp = unwrapOrSetPythonException(
       py_file.ConvertToFileForcingUseOfScriptingIOMethods(/*borrowed=*/true));
   if (!sp)
-    return nullptr;
+    SWIG_fail;
   $1 = sp;
 }
 
 %typecheck(SWIG_TYPECHECK_POINTER) lldb::FileSP {
   if (PythonFile::Check($input)) {
     $1 = 1;
   } else {
     PyErr_Clear();
     $1 = 0;
   }
 }
 
 %typemap(out) lldb::FileSP {
   $result = nullptr;
   lldb::FileSP &sp = $1;
   if (sp) {
     PythonFile pyfile = unwrapOrSetPythonException(PythonFile::FromFile(*sp));
     if (!pyfile.IsValid())
-      return nullptr;
+      SWIG_fail;
     $result = pyfile.release();
   }
   if (!$result) {
     $result = Py_None;
     Py_INCREF(Py_None);
   }
 }
 
if ($input == Py_None) {
     // if it goes out of scope, the data will be deleted.  The
     // only way to avoid this is to leak the Python object in
     // that case.  Note that if there was no conversion, then
     // releasing the string will not leak anything, since we
     // created this as a borrowed reference.
     py_str.release();
   } else {
     PyErr_SetString(PyExc_TypeError, "not a string-like object");
-    return NULL;
+    SWIG_fail;
   }
 }
 
 // These two pybuffer macros are copied out of swig/Lib/python/pybuffer.i,
 // and fixed so they will not crash if PyObject_GetBuffer fails.
 // https://github.com/swig/swig/issues/1640
 //
 // I've also moved the call to PyBuffer_Release to the end of the SWIG wrapper,