Cleanup: Python, Clang-Tidy else-after-return fixes

This addresses warnings from Clang-Tidy's `readability-else-after-return`
rule in the `source/blender/python` module.

No functional changes.

8 files changed, 434 insertions, 508 deletions

diff --git a/source/blender/python/mathutils/mathutils.c b/source/blender/python/mathutils/mathutils.c
index 5764db4e70c..308d2ef9618 100644
--- a/source/blender/python/mathutils/mathutils.c
+++ b/source/blender/python/mathutils/mathutils.c
@@ -249,42 +249,41 @@ int mathutils_array_parse_alloc(float **array,
     memcpy(*array, ((BaseMathObject *)value)->data, size * sizeof(float));
     return size;
   }
-  else
-#endif
-  {
-    PyObject *value_fast = NULL;
-    // *array = NULL;
-    int ret;
 
-    /* non list/tuple cases */
-    if (!(value_fast = PySequence_Fast(value, error_prefix))) {
-      /* PySequence_Fast sets the error */
-      return -1;
-    }
+#endif
 
-    size = PySequence_Fast_GET_SIZE(value_fast);
+  PyObject *value_fast = NULL;
+  // *array = NULL;
+  int ret;
 
-    if (size < array_min) {
-      Py_DECREF(value_fast);
-      PyErr_Format(PyExc_ValueError,
-                   "%.200s: sequence size is %d, expected > %d",
-                   error_prefix,
-                   size,
-                   array_min);
-      return -1;
-    }
+  /* non list/tuple cases */
+  if (!(value_fast = PySequence_Fast(value, error_prefix))) {
+    /* PySequence_Fast sets the error */
+    return -1;
+  }
 
-    *array = PyMem_Malloc(size * sizeof(float));
+  size = PySequence_Fast_GET_SIZE(value_fast);
 
-    ret = mathutils_array_parse_fast(*array, size, value_fast, error_prefix);
+  if (size < array_min) {
     Py_DECREF(value_fast);
+    PyErr_Format(PyExc_ValueError,
+                 "%.200s: sequence size is %d, expected > %d",
+                 error_prefix,
+                 size,
+                 array_min);
+    return -1;
+  }
 
-    if (ret == -1) {
-      PyMem_Free(*array);
-    }
+  *array = PyMem_Malloc(size * sizeof(float));
+
+  ret = mathutils_array_parse_fast(*array, size, value_fast, error_prefix);
+  Py_DECREF(value_fast);
 
-    return ret;
+  if (ret == -1) {
+    PyMem_Free(*array);
   }
+
+  return ret;
 }
 
 /* parse an array of vectors */
@@ -482,45 +481,41 @@ int mathutils_any_to_rotmat(float rmat[3][3], PyObject *value, const char *error
     if (BaseMath_ReadCallback((BaseMathObject *)value) == -1) {
       return -1;
     }
-    else {
-      eulO_to_mat3(rmat, ((EulerObject *)value)->eul, ((EulerObject *)value)->order);
-      return 0;
-    }
+
+    eulO_to_mat3(rmat, ((EulerObject *)value)->eul, ((EulerObject *)value)->order);
+    return 0;
   }
-  else if (QuaternionObject_Check(value)) {
+  if (QuaternionObject_Check(value)) {
     if (BaseMath_ReadCallback((BaseMathObject *)value) == -1) {
       return -1;
     }
-    else {
-      float tquat[4];
-      normalize_qt_qt(tquat, ((QuaternionObject *)value)->quat);
-      quat_to_mat3(rmat, tquat);
-      return 0;
-    }
+
+    float tquat[4];
+    normalize_qt_qt(tquat, ((QuaternionObject *)value)->quat);
+    quat_to_mat3(rmat, tquat);
+    return 0;
   }
-  else if (MatrixObject_Check(value)) {
+  if (MatrixObject_Check(value)) {
     if (BaseMath_ReadCallback((BaseMathObject *)value) == -1) {
       return -1;
     }
-    else if (((MatrixObject *)value)->num_row < 3 || ((MatrixObject *)value)->num_col < 3) {
+    if (((MatrixObject *)value)->num_row < 3 || ((MatrixObject *)value)->num_col < 3) {
       PyErr_Format(
           PyExc_ValueError, "%.200s: matrix must have minimum 3x3 dimensions", error_prefix);
       return -1;
     }
-    else {
-      matrix_as_3x3(rmat, (MatrixObject *)value);
-      normalize_m3(rmat);
-      return 0;
-    }
-  }
-  else {
-    PyErr_Format(PyExc_TypeError,
-                 "%.200s: expected a Euler, Quaternion or Matrix type, "
-                 "found %.200s",
-                 error_prefix,
-                 Py_TYPE(value)->tp_name);
-    return -1;
+
+    matrix_as_3x3(rmat, (MatrixObject *)value);
+    normalize_m3(rmat);
+    return 0;
   }
+
+  PyErr_Format(PyExc_TypeError,
+               "%.200s: expected a Euler, Quaternion or Matrix type, "
+               "found %.200s",
+               error_prefix,
+               Py_TYPE(value)->tp_name);
+  return -1;
 }
 
 /* ----------------------------------MATRIX FUNCTIONS-------------------- */
diff --git a/source/blender/python/mathutils/mathutils_Color.c b/source/blender/python/mathutils/mathutils_Color.c
index 08dede8ff78..6bffff467cd 100644
--- a/source/blender/python/mathutils/mathutils_Color.c
+++ b/source/blender/python/mathutils/mathutils_Color.c
@@ -347,7 +347,7 @@ static PyObject *Color_subscript(ColorObject *self, PyObject *item)
     }
     return Color_item(self, i);
   }
-  else if (PySlice_Check(item)) {
+  if (PySlice_Check(item)) {
     Py_ssize_t start, stop, step, slicelength;
 
     if (PySlice_GetIndicesEx(item, COLOR_SIZE, &start, &stop, &step, &slicelength) < 0) {
@@ -357,19 +357,17 @@ static PyObject *Color_subscript(ColorObject *self, PyObject *item)
     if (slicelength <= 0) {
       return PyTuple_New(0);
     }
-    else if (step == 1) {
+    if (step == 1) {
       return Color_slice(self, start, stop);
     }
-    else {
-      PyErr_SetString(PyExc_IndexError, "slice steps not supported with color");
-      return NULL;
-    }
-  }
-  else {
-    PyErr_Format(
-        PyExc_TypeError, "color indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+
+    PyErr_SetString(PyExc_IndexError, "slice steps not supported with color");
     return NULL;
   }
+
+  PyErr_Format(
+      PyExc_TypeError, "color indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+  return NULL;
 }
 
 static int Color_ass_subscript(ColorObject *self, PyObject *item, PyObject *value)
@@ -384,7 +382,7 @@ static int Color_ass_subscript(ColorObject *self, PyObject *item, PyObject *valu
     }
     return Color_ass_item(self, i, value);
   }
-  else if (PySlice_Check(item)) {
+  if (PySlice_Check(item)) {
     Py_ssize_t start, stop, step, slicelength;
 
     if (PySlice_GetIndicesEx(item, COLOR_SIZE, &start, &stop, &step, &slicelength) < 0) {
@@ -394,16 +392,14 @@ static int Color_ass_subscript(ColorObject *self, PyObject *item, PyObject *valu
     if (step == 1) {
       return Color_ass_slice(self, start, stop, value);
     }
-    else {
-      PyErr_SetString(PyExc_IndexError, "slice steps not supported with color");
-      return -1;
-    }
-  }
-  else {
-    PyErr_Format(
-        PyExc_TypeError, "color indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+
+    PyErr_SetString(PyExc_IndexError, "slice steps not supported with color");
     return -1;
   }
+
+  PyErr_Format(
+      PyExc_TypeError, "color indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+  return -1;
 }
 
 /* -----------------PROTCOL DECLARATIONS-------------------------- */
diff --git a/source/blender/python/mathutils/mathutils_Euler.c b/source/blender/python/mathutils/mathutils_Euler.c
index 7ece587e38f..ebc71706bef 100644
--- a/source/blender/python/mathutils/mathutils_Euler.c
+++ b/source/blender/python/mathutils/mathutils_Euler.c
@@ -558,7 +558,7 @@ static PyObject *Euler_subscript(EulerObject *self, PyObject *item)
     }
     return Euler_item(self, i);
   }
-  else if (PySlice_Check(item)) {
+  if (PySlice_Check(item)) {
     Py_ssize_t start, stop, step, slicelength;
 
     if (PySlice_GetIndicesEx(item, EULER_SIZE, &start, &stop, &step, &slicelength) < 0) {
@@ -568,19 +568,17 @@ static PyObject *Euler_subscript(EulerObject *self, PyObject *item)
     if (slicelength <= 0) {
       return PyTuple_New(0);
     }
-    else if (step == 1) {
+    if (step == 1) {
       return Euler_slice(self, start, stop);
     }
-    else {
-      PyErr_SetString(PyExc_IndexError, "slice steps not supported with eulers");
-      return NULL;
-    }
-  }
-  else {
-    PyErr_Format(
-        PyExc_TypeError, "euler indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+
+    PyErr_SetString(PyExc_IndexError, "slice steps not supported with eulers");
     return NULL;
   }
+
+  PyErr_Format(
+      PyExc_TypeError, "euler indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+  return NULL;
 }
 
 static int Euler_ass_subscript(EulerObject *self, PyObject *item, PyObject *value)
@@ -595,7 +593,7 @@ static int Euler_ass_subscript(EulerObject *self, PyObject *item, PyObject *valu
     }
     return Euler_ass_item(self, i, value);
   }
-  else if (PySlice_Check(item)) {
+  if (PySlice_Check(item)) {
     Py_ssize_t start, stop, step, slicelength;
 
     if (PySlice_GetIndicesEx(item, EULER_SIZE, &start, &stop, &step, &slicelength) < 0) {
@@ -605,16 +603,14 @@ static int Euler_ass_subscript(EulerObject *self, PyObject *item, PyObject *valu
     if (step == 1) {
       return Euler_ass_slice(self, start, stop, value);
     }
-    else {
-      PyErr_SetString(PyExc_IndexError, "slice steps not supported with euler");
-      return -1;
-    }
-  }
-  else {
-    PyErr_Format(
-        PyExc_TypeError, "euler indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+
+    PyErr_SetString(PyExc_IndexError, "slice steps not supported with euler");
     return -1;
   }
+
+  PyErr_Format(
+      PyExc_TypeError, "euler indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+  return -1;
 }
 
 /* -----------------PROTCOL DECLARATIONS-------------------------- */
diff --git a/source/blender/python/mathutils/mathutils_Matrix.c b/source/blender/python/mathutils/mathutils_Matrix.c
index 3e30c81c8c6..236bb1de29d 100644
--- a/source/blender/python/mathutils/mathutils_Matrix.c
+++ b/source/blender/python/mathutils/mathutils_Matrix.c
@@ -54,9 +54,8 @@ static int matrix_row_vector_check(MatrixObject *mat, VectorObject *vec, int row
                     "owner matrix has been resized since this row vector was created");
     return 0;
   }
-  else {
-    return 1;
-  }
+
+  return 1;
 }
 
 static int matrix_col_vector_check(MatrixObject *mat, VectorObject *vec, int col)
@@ -67,9 +66,8 @@ static int matrix_col_vector_check(MatrixObject *mat, VectorObject *vec, int col
                     "owner matrix has been resized since this column vector was created");
     return 0;
   }
-  else {
-    return 1;
-  }
+
+  return 1;
 }
 
 /* ----------------------------------------------------------------------------
@@ -380,9 +378,8 @@ static PyObject *Matrix_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
           if (Matrix_ass_slice((MatrixObject *)matrix, 0, INT_MAX, arg) == 0) {
             return matrix;
           }
-          else { /* matrix ok, slice assignment not */
-            Py_DECREF(matrix);
-          }
+          /* matrix ok, slice assignment not */
+          Py_DECREF(matrix);
         }
       }
       break;
@@ -406,15 +403,13 @@ static PyObject *matrix__apply_to_copy(PyObject *(*matrix_func)(MatrixObject *),
       Py_DECREF(ret_dummy);
       return ret;
     }
-    else { /* error */
-      Py_DECREF(ret);
-      return NULL;
-    }
-  }
-  else {
-    /* copy may fail if the read callback errors out */
+    /* error */
+    Py_DECREF(ret);
     return NULL;
   }
+
+  /* copy may fail if the read callback errors out */
+  return NULL;
 }
 
 /* when a matrix is 4x4 size but initialized as a 3x3, re-assign values for 4x4 */
@@ -512,10 +507,9 @@ static PyObject *C_Matrix_Rotation(PyObject *cls, PyObject *args)
                       "or a string in 'X', 'Y', 'Z'");
       return NULL;
     }
-    else {
-      /* use the string */
-      vec = NULL;
-    }
+
+    /* use the string */
+    vec = NULL;
   }
 
   angle = angle_wrap_rad(angle);
@@ -1023,7 +1017,7 @@ static float matrix_determinant_internal(const MatrixObject *self)
                           MATRIX_ITEM(self, 1, 0),
                           MATRIX_ITEM(self, 1, 1));
   }
-  else if (self->num_col == 3) {
+  if (self->num_col == 3) {
     return determinant_m3(MATRIX_ITEM(self, 0, 0),
                           MATRIX_ITEM(self, 0, 1),
                           MATRIX_ITEM(self, 0, 2),
@@ -1034,9 +1028,8 @@ static float matrix_determinant_internal(const MatrixObject *self)
                           MATRIX_ITEM(self, 2, 1),
                           MATRIX_ITEM(self, 2, 2));
   }
-  else {
-    return determinant_m4((float(*)[4])self->matrix);
-  }
+
+  return determinant_m4((float(*)[4])self->matrix);
 }
 
 static void adjoint_matrix_n(float *mat_dst, const float *mat_src, const ushort dim)
@@ -1094,9 +1087,8 @@ static bool matrix_invert_internal(const MatrixObject *self, float *r_mat)
     matrix_invert_with_det_n_internal(r_mat, self->matrix, det, self->num_col);
     return true;
   }
-  else {
-    return false;
-  }
+
+  return false;
 }
 
 /**
@@ -1475,9 +1467,8 @@ static bool matrix_invert_is_compat(const MatrixObject *self)
                     "only square matrices are supported");
     return false;
   }
-  else {
-    return true;
-  }
+
+  return true;
 }
 
 static bool matrix_invert_args_check(const MatrixObject *self, PyObject *args, bool check_type)
@@ -1605,10 +1596,9 @@ static PyObject *Matrix_inverted(MatrixObject *self, PyObject *args)
       Py_INCREF(fallback);
       return fallback;
     }
-    else {
-      matrix_invert_raise_degenerate();
-      return NULL;
-    }
+
+    matrix_invert_raise_degenerate();
+    return NULL;
   }
 
   return Matrix_copy_notest(self, mat);
@@ -2386,48 +2376,47 @@ static int Matrix_ass_slice(MatrixObject *self, int begin, int end, PyObject *va
     /* PySequence_Fast sets the error */
     return -1;
   }
-  else {
-    PyObject **value_fast_items = PySequence_Fast_ITEMS(value_fast);
-    const int size = end - begin;
-    int row, col;
-    float mat[MATRIX_MAX_DIM * MATRIX_MAX_DIM];
-    float vec[4];
 
-    if (PySequence_Fast_GET_SIZE(value_fast) != size) {
-      Py_DECREF(value_fast);
-      PyErr_SetString(PyExc_ValueError,
-                      "matrix[begin:end] = []: "
-                      "size mismatch in slice assignment");
-      return -1;
-    }
+  PyObject **value_fast_items = PySequence_Fast_ITEMS(value_fast);
+  const int size = end - begin;
+  int row, col;
+  float mat[MATRIX_MAX_DIM * MATRIX_MAX_DIM];
+  float vec[4];
+
+  if (PySequence_Fast_GET_SIZE(value_fast) != size) {
+    Py_DECREF(value_fast);
+    PyErr_SetString(PyExc_ValueError,
+                    "matrix[begin:end] = []: "
+                    "size mismatch in slice assignment");
+    return -1;
+  }
 
-    memcpy(mat, self->matrix, self->num_col * self->num_row * sizeof(float));
+  memcpy(mat, self->matrix, self->num_col * self->num_row * sizeof(float));
 
-    /* parse sub items */
-    for (row = begin; row < end; row++) {
-      /* parse each sub sequence */
-      PyObject *item = value_fast_items[row - begin];
+  /* parse sub items */
+  for (row = begin; row < end; row++) {
+    /* parse each sub sequence */
+    PyObject *item = value_fast_items[row - begin];
 
-      if (mathutils_array_parse(
-              vec, self->num_col, self->num_col, item, "matrix[begin:end] = value assignment") ==
-          -1) {
-        Py_DECREF(value_fast);
-        return -1;
-      }
+    if (mathutils_array_parse(
+            vec, self->num_col, self->num_col, item, "matrix[begin:end] = value assignment") ==
+        -1) {
+      Py_DECREF(value_fast);
+      return -1;
+    }
 
-      for (col = 0; col < self->num_col; col++) {
-        mat[col * self->num_row + row] = vec[col];
-      }
+    for (col = 0; col < self->num_col; col++) {
+      mat[col * self->num_row + row] = vec[col];
     }
+  }
 
-    Py_DECREF(value_fast);
+  Py_DECREF(value_fast);
 
-    /*parsed well - now set in matrix*/
-    memcpy(self->matrix, mat, self->num_col * self->num_row * sizeof(float));
+  /*parsed well - now set in matrix*/
+  memcpy(self->matrix, mat, self->num_col * self->num_row * sizeof(float));
 
-    (void)BaseMath_WriteCallback(self);
-    return 0;
-  }
+  (void)BaseMath_WriteCallback(self);
+  return 0;
 }
 /*------------------------NUMERIC PROTOCOLS----------------------
  *------------------------obj + obj------------------------------*/
@@ -2540,7 +2529,7 @@ static PyObject *Matrix_mul(PyObject *m1, PyObject *m2)
 
     return Matrix_CreatePyObject(mat, mat2->num_col, mat1->num_row, Py_TYPE(mat1));
   }
-  else if (mat2) {
+  if (mat2) {
     /*FLOAT/INT * MATRIX */
     if (((scalar = PyFloat_AsDouble(m1)) == -1.0f && PyErr_Occurred()) == 0) {
       return matrix_mul_float(mat2, scalar);
@@ -2655,7 +2644,7 @@ static PyObject *Matrix_matmul(PyObject *m1, PyObject *m2)
 
     return Matrix_CreatePyObject(mat, mat2->num_col, mat1->num_row, Py_TYPE(mat1));
   }
-  else if (mat1) {
+  if (mat1) {
     /* MATRIX @ VECTOR */
     if (VectorObject_Check(m2)) {
       VectorObject *vec2 = (VectorObject *)m2;
@@ -2772,7 +2761,7 @@ static PyObject *Matrix_subscript(MatrixObject *self, PyObject *item)
     }
     return Matrix_item_row(self, i);
   }
-  else if (PySlice_Check(item)) {
+  if (PySlice_Check(item)) {
     Py_ssize_t start, stop, step, slicelength;
 
     if (PySlice_GetIndicesEx(item, self->num_row, &start, &stop, &step, &slicelength) < 0) {
@@ -2782,19 +2771,17 @@ static PyObject *Matrix_subscript(MatrixObject *self, PyObject *item)
     if (slicelength <= 0) {
       return PyTuple_New(0);
     }
-    else if (step == 1) {
+    if (step == 1) {
       return Matrix_slice(self, start, stop);
     }
-    else {
-      PyErr_SetString(PyExc_IndexError, "slice steps not supported with matrices");
-      return NULL;
-    }
-  }
-  else {
-    PyErr_Format(
-        PyExc_TypeError, "matrix indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+
+    PyErr_SetString(PyExc_IndexError, "slice steps not supported with matrices");
     return NULL;
   }
+
+  PyErr_Format(
+      PyExc_TypeError, "matrix indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+  return NULL;
 }
 
 static int Matrix_ass_subscript(MatrixObject *self, PyObject *item, PyObject *value)
@@ -2809,7 +2796,7 @@ static int Matrix_ass_subscript(MatrixObject *self, PyObject *item, PyObject *va
     }
     return Matrix_ass_item_row(self, i, value);
   }
-  else if (PySlice_Check(item)) {
+  if (PySlice_Check(item)) {
     Py_ssize_t start, stop, step, slicelength;
 
     if (PySlice_GetIndicesEx(item, self->num_row, &start, &stop, &step, &slicelength) < 0) {
@@ -2819,16 +2806,14 @@ static int Matrix_ass_subscript(MatrixObject *self, PyObject *item, PyObject *va
     if (step == 1) {
       return Matrix_ass_slice(self, start, stop, value);
     }
-    else {
-      PyErr_SetString(PyExc_IndexError, "slice steps not supported with matrices");
-      return -1;
-    }
-  }
-  else {
-    PyErr_Format(
-        PyExc_TypeError, "matrix indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+
+    PyErr_SetString(PyExc_IndexError, "slice steps not supported with matrices");
     return -1;
   }
+
+  PyErr_Format(
+      PyExc_TypeError, "matrix indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+  return -1;
 }
 
 static PyMappingMethods Matrix_AsMapping = {
@@ -2977,15 +2962,14 @@ static PyObject *Matrix_is_negative_get(MatrixObject *self, void *UNUSED(closure
   if (self->num_row == 4 && self->num_col == 4) {
     return PyBool_FromLong(is_negative_m4((float(*)[4])self->matrix));
   }
-  else if (self->num_row == 3 && self->num_col == 3) {
+  if (self->num_row == 3 && self->num_col == 3) {
     return PyBool_FromLong(is_negative_m3((float(*)[3])self->matrix));
   }
-  else {
-    PyErr_SetString(PyExc_AttributeError,
-                    "Matrix.is_negative: "
-                    "inappropriate matrix size - expects 3x3 or 4x4 matrix");
-    return NULL;
-  }
+
+  PyErr_SetString(PyExc_AttributeError,
+                  "Matrix.is_negative: "
+                  "inappropriate matrix size - expects 3x3 or 4x4 matrix");
+  return NULL;
 }
 
 PyDoc_STRVAR(Matrix_is_orthogonal_doc,
@@ -3000,15 +2984,14 @@ static PyObject *Matrix_is_orthogonal_get(MatrixObject *self, void *UNUSED(closu
   if (self->num_row == 4 && self->num_col == 4) {
     return PyBool_FromLong(is_orthonormal_m4((float(*)[4])self->matrix));
   }
-  else if (self->num_row == 3 && self->num_col == 3) {
+  if (self->num_row == 3 && self->num_col == 3) {
     return PyBool_FromLong(is_orthonormal_m3((float(*)[3])self->matrix));
   }
-  else {
-    PyErr_SetString(PyExc_AttributeError,
-                    "Matrix.is_orthogonal: "
-                    "inappropriate matrix size - expects 3x3 or 4x4 matrix");
-    return NULL;
-  }
+
+  PyErr_SetString(PyExc_AttributeError,
+                  "Matrix.is_orthogonal: "
+                  "inappropriate matrix size - expects 3x3 or 4x4 matrix");
+  return NULL;
 }
 
 PyDoc_STRVAR(Matrix_is_orthogonal_axis_vectors_doc,
@@ -3024,15 +3007,14 @@ static PyObject *Matrix_is_orthogonal_axis_vectors_get(MatrixObject *self, void
   if (self->num_row == 4 && self->num_col == 4) {
     return PyBool_FromLong(is_orthogonal_m4((float(*)[4])self->matrix));
   }
-  else if (self->num_row == 3 && self->num_col == 3) {
+  if (self->num_row == 3 && self->num_col == 3) {
     return PyBool_FromLong(is_orthogonal_m3((float(*)[3])self->matrix));
   }
-  else {
-    PyErr_SetString(PyExc_AttributeError,
-                    "Matrix.is_orthogonal_axis_vectors: "
-                    "inappropriate matrix size - expects 3x3 or 4x4 matrix");
-    return NULL;
-  }
+
+  PyErr_SetString(PyExc_AttributeError,
+                  "Matrix.is_orthogonal_axis_vectors: "
+                  "inappropriate matrix size - expects 3x3 or 4x4 matrix");
+  return NULL;
 }
 
 /*****************************************************************************/
@@ -3478,14 +3460,13 @@ static PyObject *MatrixAccess_subscript(MatrixAccessObject *self, PyObject *item
       }
       return Matrix_item_row(matrix_user, i);
     }
-    else { /* MAT_ACCESS_ROW */
-      if (i < 0) {
-        i += matrix_user->num_col;
-      }
-      return Matrix_item_col(matrix_user, i);
+    /* MAT_ACCESS_ROW */
+    if (i < 0) {
+      i += matrix_user->num_col;
     }
+    return Matrix_item_col(matrix_user, i);
   }
-  else if (PySlice_Check(item)) {
+  if (PySlice_Check(item)) {
     Py_ssize_t start, stop, step, slicelength;
 
     if (PySlice_GetIndicesEx(item, MatrixAccess_len(self), &start, &stop, &step, &slicelength) <
@@ -3496,19 +3477,17 @@ static PyObject *MatrixAccess_subscript(MatrixAccessObject *self, PyObject *item
     if (slicelength <= 0) {
       return PyTuple_New(0);
     }
-    else if (step == 1) {
+    if (step == 1) {
       return MatrixAccess_slice(self, start, stop);
     }
-    else {
-      PyErr_SetString(PyExc_IndexError, "slice steps not supported with matrix accessors");
-      return NULL;
-    }
-  }
-  else {
-    PyErr_Format(
-        PyExc_TypeError, "matrix indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+
+    PyErr_SetString(PyExc_IndexError, "slice steps not supported with matrix accessors");
     return NULL;
   }
+
+  PyErr_Format(
+      PyExc_TypeError, "matrix indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+  return NULL;
 }
 
 static int MatrixAccess_ass_subscript(MatrixAccessObject *self, PyObject *item, PyObject *value)
@@ -3527,19 +3506,17 @@ static int MatrixAccess_ass_subscript(MatrixAccessObject *self, PyObject *item,
       }
       return Matrix_ass_item_row(matrix_user, i, value);
     }
-    else { /* MAT_ACCESS_ROW */
-      if (i < 0) {
-        i += matrix_user->num_col;
-      }
-      return Matrix_ass_item_col(matrix_user, i, value);
+    /* MAT_ACCESS_ROW */
+    if (i < 0) {
+      i += matrix_user->num_col;
     }
+    return Matrix_ass_item_col(matrix_user, i, value);
   }
   /* TODO, slice */
-  else {
-    PyErr_Format(
-        PyExc_TypeError, "matrix indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
-    return -1;
-  }
+
+  PyErr_Format(
+      PyExc_TypeError, "matrix indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+  return -1;
 }
 
 static PyObject *MatrixAccess_iter(MatrixAccessObject *self)
diff --git a/source/blender/python/mathutils/mathutils_Quaternion.c b/source/blender/python/mathutils/mathutils_Quaternion.c
index 2b7761b7678..b0e6b330968 100644
--- a/source/blender/python/mathutils/mathutils_Quaternion.c
+++ b/source/blender/python/mathutils/mathutils_Quaternion.c
@@ -815,7 +815,7 @@ static PyObject *Quaternion_subscript(QuaternionObject *self, PyObject *item)
     }
     return Quaternion_item(self, i);
   }
-  else if (PySlice_Check(item)) {
+  if (PySlice_Check(item)) {
     Py_ssize_t start, stop, step, slicelength;
 
     if (PySlice_GetIndicesEx(item, QUAT_SIZE, &start, &stop, &step, &slicelength) < 0) {
@@ -825,20 +825,17 @@ static PyObject *Quaternion_subscript(QuaternionObject *self, PyObject *item)
     if (slicelength <= 0) {
       return PyTuple_New(0);
     }
-    else if (step == 1) {
+    if (step == 1) {
       return Quaternion_slice(self, start, stop);
     }
-    else {
-      PyErr_SetString(PyExc_IndexError, "slice steps not supported with quaternions");
-      return NULL;
-    }
-  }
-  else {
-    PyErr_Format(PyExc_TypeError,
-                 "quaternion indices must be integers, not %.200s",
-                 Py_TYPE(item)->tp_name);
+
+    PyErr_SetString(PyExc_IndexError, "slice steps not supported with quaternions");
     return NULL;
   }
+
+  PyErr_Format(
+      PyExc_TypeError, "quaternion indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+  return NULL;
 }
 
 static int Quaternion_ass_subscript(QuaternionObject *self, PyObject *item, PyObject *value)
@@ -853,7 +850,7 @@ static int Quaternion_ass_subscript(QuaternionObject *self, PyObject *item, PyOb
     }
     return Quaternion_ass_item(self, i, value);
   }
-  else if (PySlice_Check(item)) {
+  if (PySlice_Check(item)) {
     Py_ssize_t start, stop, step, slicelength;
 
     if (PySlice_GetIndicesEx(item, QUAT_SIZE, &start, &stop, &step, &slicelength) < 0) {
@@ -863,17 +860,14 @@ static int Quaternion_ass_subscript(QuaternionObject *self, PyObject *item, PyOb
     if (step == 1) {
       return Quaternion_ass_slice(self, start, stop, value);
     }
-    else {
-      PyErr_SetString(PyExc_IndexError, "slice steps not supported with quaternion");
-      return -1;
-    }
-  }
-  else {
-    PyErr_Format(PyExc_TypeError,
-                 "quaternion indices must be integers, not %.200s",
-                 Py_TYPE(item)->tp_name);
+
+    PyErr_SetString(PyExc_IndexError, "slice steps not supported with quaternion");
     return -1;
   }
+
+  PyErr_Format(
+      PyExc_TypeError, "quaternion indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+  return -1;
 }
 
 /* ------------------------NUMERIC PROTOCOLS---------------------- */
@@ -967,7 +961,7 @@ static PyObject *Quaternion_mul(PyObject *q1, PyObject *q2)
     return Quaternion_CreatePyObject(quat, Py_TYPE(q1));
   }
   /* the only case this can happen (for a supported type is "FLOAT * QUAT") */
-  else if (quat2) { /* FLOAT * QUAT */
+  if (quat2) { /* FLOAT * QUAT */
     if (((scalar = PyFloat_AsDouble(q1)) == -1.0f && PyErr_Occurred()) == 0) {
       return quat_mul_float(quat2, scalar);
     }
@@ -1049,7 +1043,7 @@ static PyObject *Quaternion_matmul(PyObject *q1, PyObject *q2)
     mul_qt_qtqt(quat, quat1->quat, quat2->quat);
     return Quaternion_CreatePyObject(quat, Py_TYPE(q1));
   }
-  else if (quat1) {
+  if (quat1) {
     /* QUAT @ VEC */
     if (VectorObject_Check(q2)) {
       VectorObject *vec2 = (VectorObject *)q2;
@@ -1384,10 +1378,9 @@ static PyObject *quat__apply_to_copy(PyObject *(*quat_func)(QuaternionObject *),
     Py_DECREF(ret_dummy);
     return ret;
   }
-  else { /* error */
-    Py_DECREF(ret);
-    return NULL;
-  }
+  /* error */
+  Py_DECREF(ret);
+  return NULL;
 }
 
 /* axis vector suffers from precision errors, use this function to ensure */
diff --git a/source/blender/python/mathutils/mathutils_Vector.c b/source/blender/python/mathutils/mathutils_Vector.c
index 4b47440a530..b30aafbf875 100644
--- a/source/blender/python/mathutils/mathutils_Vector.c
+++ b/source/blender/python/mathutils/mathutils_Vector.c
@@ -104,10 +104,9 @@ static PyObject *vec__apply_to_copy(PyObject *(*vec_func)(VectorObject *), Vecto
     Py_DECREF(ret_dummy);
     return (PyObject *)ret;
   }
-  else { /* error */
-    Py_DECREF(ret);
-    return NULL;
-  }
+  /* error */
+  Py_DECREF(ret);
+  return NULL;
 }
 
 /*-----------------------CLASS-METHODS----------------------------*/
@@ -1004,12 +1003,11 @@ static PyObject *Vector_angle(VectorObject *self, PyObject *args)
       Py_INCREF(fallback);
       return fallback;
     }
-    else {
-      PyErr_SetString(PyExc_ValueError,
-                      "Vector.angle(other): "
-                      "zero length vectors have no valid angle");
-      return NULL;
-    }
+
+    PyErr_SetString(PyExc_ValueError,
+                    "Vector.angle(other): "
+                    "zero length vectors have no valid angle");
+    return NULL;
   }
 
   return PyFloat_FromDouble(saacos(dot / (sqrt(dot_self) * sqrt(dot_other))));
@@ -1059,12 +1057,11 @@ static PyObject *Vector_angle_signed(VectorObject *self, PyObject *args)
       Py_INCREF(fallback);
       return fallback;
     }
-    else {
-      PyErr_SetString(PyExc_ValueError,
-                      "Vector.angle_signed(other): "
-                      "zero length vectors have no valid angle");
-      return NULL;
-    }
+
+    PyErr_SetString(PyExc_ValueError,
+                    "Vector.angle_signed(other): "
+                    "zero length vectors have no valid angle");
+    return NULL;
   }
 
   return PyFloat_FromDouble(angle_signed_v2v2(self->vec, tvec));
@@ -1238,12 +1235,11 @@ static PyObject *Vector_slerp(VectorObject *self, PyObject *args)
       Py_INCREF(fallback);
       return fallback;
     }
-    else {
-      PyErr_SetString(PyExc_ValueError,
-                      "Vector.slerp(): "
-                      "zero length vectors unsupported");
-      return NULL;
-    }
+
+    PyErr_SetString(PyExc_ValueError,
+                    "Vector.slerp(): "
+                    "zero length vectors unsupported");
+    return NULL;
   }
 
   /* We have sane state, execute slerp */
@@ -1256,12 +1252,11 @@ static PyObject *Vector_slerp(VectorObject *self, PyObject *args)
       Py_INCREF(fallback);
       return fallback;
     }
-    else {
-      PyErr_SetString(PyExc_ValueError,
-                      "Vector.slerp(): "
-                      "opposite vectors unsupported");
-      return NULL;
-    }
+
+    PyErr_SetString(PyExc_ValueError,
+                    "Vector.slerp(): "
+                    "opposite vectors unsupported");
+    return NULL;
   }
 
   interp_dot_slerp(fac, cosom, w);
@@ -1785,7 +1780,7 @@ static PyObject *Vector_mul(PyObject *v1, PyObject *v2)
     /* element-wise product */
     return vector_mul_vec(vec1, vec2);
   }
-  else if (vec1) {
+  if (vec1) {
     if (((scalar = PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) == 0) { /* VEC * FLOAT */
       return vector_mul_float(vec1, scalar);
     }
@@ -1890,7 +1885,7 @@ static PyObject *Vector_matmul(PyObject *v1, PyObject *v2)
     /*dot product*/
     return PyFloat_FromDouble(dot_vn_vn(vec1->vec, vec2->vec, vec1->size));
   }
-  else if (vec1) {
+  if (vec1) {
     if (MatrixObject_Check(v2)) {
       /* VEC @ MATRIX */
       float tvec[MAX_DIMENSIONS];
@@ -2039,9 +2034,8 @@ static PyObject *Vector_richcmpr(PyObject *objectA, PyObject *objectB, int compa
     if (comparison_type == Py_NE) {
       Py_RETURN_TRUE;
     }
-    else {
-      Py_RETURN_FALSE;
-    }
+
+    Py_RETURN_FALSE;
   }
   vecA = (VectorObject *)objectA;
   vecB = (VectorObject *)objectB;
@@ -2054,9 +2048,8 @@ static PyObject *Vector_richcmpr(PyObject *objectA, PyObject *objectB, int compa
     if (comparison_type == Py_NE) {
       Py_RETURN_TRUE;
     }
-    else {
-      Py_RETURN_FALSE;
-    }
+
+    Py_RETURN_FALSE;
   }
 
   switch (comparison_type) {
@@ -2107,9 +2100,8 @@ static PyObject *Vector_richcmpr(PyObject *objectA, PyObject *objectB, int compa
   if (result == 1) {
     Py_RETURN_TRUE;
   }
-  else {
-    Py_RETURN_FALSE;
-  }
+
+  Py_RETURN_FALSE;
 }
 
 static Py_hash_t Vector_hash(VectorObject *self)
@@ -2152,7 +2144,7 @@ static PyObject *Vector_subscript(VectorObject *self, PyObject *item)
     }
     return Vector_item(self, i);
   }
-  else if (PySlice_Check(item)) {
+  if (PySlice_Check(item)) {
     Py_ssize_t start, stop, step, slicelength;
 
     if (PySlice_GetIndicesEx(item, self->size, &start, &stop, &step, &slicelength) < 0) {
@@ -2162,19 +2154,17 @@ static PyObject *Vector_subscript(VectorObject *self, PyObject *item)
     if (slicelength <= 0) {
       return PyTuple_New(0);
     }
-    else if (step == 1) {
+    if (step == 1) {
       return Vector_slice(self, start, stop);
     }
-    else {
-      PyErr_SetString(PyExc_IndexError, "slice steps not supported with vectors");
-      return NULL;
-    }
-  }
-  else {
-    PyErr_Format(
-        PyExc_TypeError, "vector indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+
+    PyErr_SetString(PyExc_IndexError, "slice steps not supported with vectors");
     return NULL;
   }
+
+  PyErr_Format(
+      PyExc_TypeError, "vector indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+  return NULL;
 }
 
 static int Vector_ass_subscript(VectorObject *self, PyObject *item, PyObject *value)
@@ -2189,7 +2179,7 @@ static int Vector_ass_subscript(VectorObject *self, PyObject *item, PyObject *va
     }
     return Vector_ass_item(self, i, value);
   }
-  else if (PySlice_Check(item)) {
+  if (PySlice_Check(item)) {
     Py_ssize_t start, stop, step, slicelength;
 
     if (PySlice_GetIndicesEx(item, self->size, &start, &stop, &step, &slicelength) < 0) {
@@ -2199,16 +2189,14 @@ static int Vector_ass_subscript(VectorObject *self, PyObject *item, PyObject *va
     if (step == 1) {
       return Vector_ass_slice(self, start, stop, value);
     }
-    else {
-      PyErr_SetString(PyExc_IndexError, "slice steps not supported with vectors");
-      return -1;
-    }
-  }
-  else {
-    PyErr_Format(
-        PyExc_TypeError, "vector indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+
+    PyErr_SetString(PyExc_IndexError, "slice steps not supported with vectors");
     return -1;
   }
+
+  PyErr_Format(
+      PyExc_TypeError, "vector indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+  return -1;
 }
 
 static PyMappingMethods Vector_AsMapping = {
@@ -2523,9 +2511,8 @@ static int Vector_swizzle_set(VectorObject *self, PyObject *value, void *closure
   if (BaseMath_WriteCallback(self) == -1) {
     return -1;
   }
-  else {
-    return 0;
-  }
+
+  return 0;
 }
 
 #define _SWIZZLE1(a) ((a) | SWIZZLE_VALID_AXIS)
diff --git a/source/blender/python/mathutils/mathutils_bvhtree.c b/source/blender/python/mathutils/mathutils_bvhtree.c
index 5a0dc7d6a5e..80a72696d77 100644
--- a/source/blender/python/mathutils/mathutils_bvhtree.c
+++ b/source/blender/python/mathutils/mathutils_bvhtree.c
@@ -914,16 +914,15 @@ static PyObject *C_BVHTree_FromPolygons(PyObject *UNUSED(cls), PyObject *args, P
     return bvhtree_CreatePyObject(
         tree, epsilon, coords, coords_len, tris, tris_len, orig_index, orig_normal);
   }
-  else {
-    if (coords) {
-      MEM_freeN(coords);
-    }
-    if (tris) {
-      MEM_freeN(tris);
-    }
 
-    return NULL;
+  if (coords) {
+    MEM_freeN(coords);
+  }
+  if (tris) {
+    MEM_freeN(tris);
   }
+
+  return NULL;
 }
 
 #ifndef MATH_STANDALONE
@@ -1053,55 +1052,48 @@ static Mesh *bvh_get_mesh(const char *funcname,
             funcname);
         return NULL;
       }
-      else {
-        *r_free_mesh = true;
-        return mesh_create_eval_final_render(depsgraph, scene, ob, &data_masks);
-      }
+
+      *r_free_mesh = true;
+      return mesh_create_eval_final_render(depsgraph, scene, ob, &data_masks);
     }
-    else if (ob_eval != NULL) {
+    if (ob_eval != NULL) {
       if (use_cage) {
         return mesh_get_eval_deform(depsgraph, scene, ob_eval, &data_masks);
       }
-      else {
-        return mesh_get_eval_final(depsgraph, scene, ob_eval, &data_masks);
-      }
+
+      return mesh_get_eval_final(depsgraph, scene, ob_eval, &data_masks);
     }
-    else {
-      PyErr_Format(PyExc_ValueError,
-                   "%s(...): Cannot get evaluated data from given dependency graph / object pair",
-                   funcname);
+
+    PyErr_Format(PyExc_ValueError,
+                 "%s(...): Cannot get evaluated data from given dependency graph / object pair",
+                 funcname);
+    return NULL;
+  }
+
+  /* !use_deform */
+  if (use_render) {
+    if (use_cage) {
+      PyErr_Format(
+          PyExc_ValueError,
+          "%s(...): cage arg is unsupported when dependency graph evaluation mode is RENDER",
+          funcname);
       return NULL;
     }
+
+    *r_free_mesh = true;
+    return mesh_create_eval_no_deform_render(depsgraph, scene, ob, &data_masks);
   }
-  else {
-    /* !use_deform */
-    if (use_render) {
-      if (use_cage) {
-        PyErr_Format(
-            PyExc_ValueError,
-            "%s(...): cage arg is unsupported when dependency graph evaluation mode is RENDER",
-            funcname);
-        return NULL;
-      }
-      else {
-        *r_free_mesh = true;
-        return mesh_create_eval_no_deform_render(depsgraph, scene, ob, &data_masks);
-      }
-    }
-    else {
-      if (use_cage) {
-        PyErr_Format(PyExc_ValueError,
-                     "%s(...): cage arg is unsupported when deform=False and dependency graph "
-                     "evaluation mode is not RENDER",
-                     funcname);
-        return NULL;
-      }
-      else {
-        *r_free_mesh = true;
-        return mesh_create_eval_no_deform(depsgraph, scene, ob, &data_masks);
-      }
-    }
+
+  if (use_cage) {
+    PyErr_Format(PyExc_ValueError,
+                 "%s(...): cage arg is unsupported when deform=False and dependency graph "
+                 "evaluation mode is not RENDER",
+                 funcname);
+    return NULL;
   }
+
+  *r_free_mesh = true;
+  return mesh_create_eval_no_deform(depsgraph, scene, ob, &data_masks);
 }
 
 PyDoc_STRVAR(C_BVHTree_FromObject_doc,
diff --git a/source/blender/python/mathutils/mathutils_geometry.c b/source/blender/python/mathutils/mathutils_geometry.c
index 93dbac32c19..37997e9f912 100644
--- a/source/blender/python/mathutils/mathutils_geometry.c
+++ b/source/blender/python/mathutils/mathutils_geometry.c
@@ -204,12 +204,11 @@ static PyObject *M_Geometry_intersect_line_line(PyObject *UNUSED(self), PyObject
     /* collinear */
     Py_RETURN_NONE;
   }
-  else {
-    tuple = PyTuple_New(2);
-    PyTuple_SET_ITEMS(
-        tuple, Vector_CreatePyObject(i1, len, NULL), Vector_CreatePyObject(i2, len, NULL));
-    return tuple;
-  }
+
+  tuple = PyTuple_New(2);
+  PyTuple_SET_ITEMS(
+      tuple, Vector_CreatePyObject(i1, len, NULL), Vector_CreatePyObject(i2, len, NULL));
+  return tuple;
 }
 
 /* Line-Line intersection using algorithm from mathworld.wolfram.com */
@@ -466,9 +465,8 @@ static PyObject *M_Geometry_intersect_line_line_2d(PyObject *UNUSED(self), PyObj
   if (isect_seg_seg_v2_point(UNPACK4(lines), vi) == 1) {
     return Vector_CreatePyObject(vi, 2, NULL);
   }
-  else {
-    Py_RETURN_NONE;
-  }
+
+  Py_RETURN_NONE;
 }
 
 PyDoc_STRVAR(
@@ -519,9 +517,8 @@ static PyObject *M_Geometry_intersect_line_plane(PyObject *UNUSED(self), PyObjec
   if (isect_line_plane_v3(isect, line_a, line_b, plane_co, plane_no) == 1) {
     return Vector_CreatePyObject(isect, 3, NULL);
   }
-  else {
-    Py_RETURN_NONE;
-  }
+
+  Py_RETURN_NONE;
 }
 
 PyDoc_STRVAR(
@@ -637,43 +634,42 @@ static PyObject *M_Geometry_intersect_line_sphere(PyObject *UNUSED(self), PyObje
         -1)) == 0) {
     return NULL;
   }
-  else {
-    bool use_a = true;
-    bool use_b = true;
-    float lambda;
 
-    PyObject *ret = PyTuple_New(2);
+  bool use_a = true;
+  bool use_b = true;
+  float lambda;
 
-    switch (isect_line_sphere_v3(line_a, line_b, sphere_co, sphere_radius, isect_a, isect_b)) {
-      case 1:
-        if (!(!clip || (((lambda = line_point_factor_v3(isect_a, line_a, line_b)) >= 0.0f) &&
-                        (lambda <= 1.0f)))) {
-          use_a = false;
-        }
-        use_b = false;
-        break;
-      case 2:
-        if (!(!clip || (((lambda = line_point_factor_v3(isect_a, line_a, line_b)) >= 0.0f) &&
-                        (lambda <= 1.0f)))) {
-          use_a = false;
-        }
-        if (!(!clip || (((lambda = line_point_factor_v3(isect_b, line_a, line_b)) >= 0.0f) &&
-                        (lambda <= 1.0f)))) {
-          use_b = false;
-        }
-        break;
-      default:
+  PyObject *ret = PyTuple_New(2);
+
+  switch (isect_line_sphere_v3(line_a, line_b, sphere_co, sphere_radius, isect_a, isect_b)) {
+    case 1:
+      if (!(!clip || (((lambda = line_point_factor_v3(isect_a, line_a, line_b)) >= 0.0f) &&
+                      (lambda <= 1.0f)))) {
+        use_a = false;
+      }
+      use_b = false;
+      break;
+    case 2:
+      if (!(!clip || (((lambda = line_point_factor_v3(isect_a, line_a, line_b)) >= 0.0f) &&
+                      (lambda <= 1.0f)))) {
         use_a = false;
+      }
+      if (!(!clip || (((lambda = line_point_factor_v3(isect_b, line_a, line_b)) >= 0.0f) &&
+                      (lambda <= 1.0f)))) {
         use_b = false;
-        break;
-    }
+      }
+      break;
+    default:
+      use_a = false;
+      use_b = false;
+      break;
+  }
 
-    PyTuple_SET_ITEMS(ret,
-                      use_a ? Vector_CreatePyObject(isect_a, 3, NULL) : Py_INCREF_RET(Py_None),
-                      use_b ? Vector_CreatePyObject(isect_b, 3, NULL) : Py_INCREF_RET(Py_None));
+  PyTuple_SET_ITEMS(ret,
+                    use_a ? Vector_CreatePyObject(isect_a, 3, NULL) : Py_INCREF_RET(Py_None),
+                    use_b ? Vector_CreatePyObject(isect_b, 3, NULL) : Py_INCREF_RET(Py_None));
 
-    return ret;
-  }
+  return ret;
 }
 
 /* keep in sync with M_Geometry_intersect_line_sphere */
@@ -723,43 +719,42 @@ static PyObject *M_Geometry_intersect_line_sphere_2d(PyObject *UNUSED(self), PyO
         -1)) == 0) {
     return NULL;
   }
-  else {
-    bool use_a = true;
-    bool use_b = true;
-    float lambda;
 
-    PyObject *ret = PyTuple_New(2);
+  bool use_a = true;
+  bool use_b = true;
+  float lambda;
 
-    switch (isect_line_sphere_v2(line_a, line_b, sphere_co, sphere_radius, isect_a, isect_b)) {
-      case 1:
-        if (!(!clip || (((lambda = line_point_factor_v2(isect_a, line_a, line_b)) >= 0.0f) &&
-                        (lambda <= 1.0f)))) {
-          use_a = false;
-        }
-        use_b = false;
-        break;
-      case 2:
-        if (!(!clip || (((lambda = line_point_factor_v2(isect_a, line_a, line_b)) >= 0.0f) &&
-                        (lambda <= 1.0f)))) {
-          use_a = false;
-        }
-        if (!(!clip || (((lambda = line_point_factor_v2(isect_b, line_a, line_b)) >= 0.0f) &&
-                        (lambda <= 1.0f)))) {
-          use_b = false;
-        }
-        break;
-      default:
+  PyObject *ret = PyTuple_New(2);
+
+  switch (isect_line_sphere_v2(line_a, line_b, sphere_co, sphere_radius, isect_a, isect_b)) {
+    case 1:
+      if (!(!clip || (((lambda = line_point_factor_v2(isect_a, line_a, line_b)) >= 0.0f) &&
+                      (lambda <= 1.0f)))) {
+        use_a = false;
+      }
+      use_b = false;
+      break;
+    case 2:
+      if (!(!clip || (((lambda = line_point_factor_v2(isect_a, line_a, line_b)) >= 0.0f) &&
+                      (lambda <= 1.0f)))) {
         use_a = false;
+      }
+      if (!(!clip || (((lambda = line_point_factor_v2(isect_b, line_a, line_b)) >= 0.0f) &&
+                      (lambda <= 1.0f)))) {
         use_b = false;
-        break;
-    }
+      }
+      break;
+    default:
+      use_a = false;
+      use_b = false;
+      break;
+  }
 
-    PyTuple_SET_ITEMS(ret,
-                      use_a ? Vector_CreatePyObject(isect_a, 2, NULL) : Py_INCREF_RET(Py_None),
-                      use_b ? Vector_CreatePyObject(isect_b, 2, NULL) : Py_INCREF_RET(Py_None));
+  PyTuple_SET_ITEMS(ret,
+                    use_a ? Vector_CreatePyObject(isect_a, 2, NULL) : Py_INCREF_RET(Py_None),
+                    use_b ? Vector_CreatePyObject(isect_b, 2, NULL) : Py_INCREF_RET(Py_None));
 
-    return ret;
-  }
+  return ret;
 }
 
 PyDoc_STRVAR(
@@ -849,9 +844,8 @@ static PyObject *M_Geometry_intersect_point_tri(PyObject *UNUSED(self), PyObject
   if (isect_point_tri_v3(pt, UNPACK3(tri), vi)) {
     return Vector_CreatePyObject(vi, 3, NULL);
   }
-  else {
-    Py_RETURN_NONE;
-  }
+
+  Py_RETURN_NONE;
 }
 
 PyDoc_STRVAR(M_Geometry_closest_point_on_tri_doc,
@@ -1094,88 +1088,84 @@ static PyObject *M_Geometry_points_in_planes(PyObject *UNUSED(self), PyObject *a
            (float **)&planes, 4, py_planes, "points_in_planes")) == -1) {
     return NULL;
   }
-  else {
-    /* note, this could be refactored into plain C easy - py bits are noted */
-    const float eps = 0.0001f;
-    const uint len = (uint)planes_len;
-    uint i, j, k, l;
-
-    float n1n2[3], n2n3[3], n3n1[3];
-    float potentialVertex[3];
-    char *planes_used = PyMem_Malloc(sizeof(char) * len);
-
-    /* python */
-    PyObject *py_verts = PyList_New(0);
-    PyObject *py_plane_index = PyList_New(0);
-
-    memset(planes_used, 0, sizeof(char) * len);
-
-    for (i = 0; i < len; i++) {
-      const float *N1 = planes[i];
-      for (j = i + 1; j < len; j++) {
-        const float *N2 = planes[j];
-        cross_v3_v3v3(n1n2, N1, N2);
-        if (len_squared_v3(n1n2) > eps) {
-          for (k = j + 1; k < len; k++) {
-            const float *N3 = planes[k];
-            cross_v3_v3v3(n2n3, N2, N3);
-            if (len_squared_v3(n2n3) > eps) {
-              cross_v3_v3v3(n3n1, N3, N1);
-              if (len_squared_v3(n3n1) > eps) {
-                const float quotient = dot_v3v3(N1, n2n3);
-                if (fabsf(quotient) > eps) {
-                  /**
-                   * <pre>
-                   * potentialVertex = (
-                   *     (n2n3 * N1[3] + n3n1 * N2[3] + n1n2 * N3[3]) *
-                   *     (-1.0 / quotient));
-                   * </pre>
-                   */
-                  const float quotient_ninv = -1.0f / quotient;
-                  potentialVertex[0] = ((n2n3[0] * N1[3]) + (n3n1[0] * N2[3]) +
-                                        (n1n2[0] * N3[3])) *
-                                       quotient_ninv;
-                  potentialVertex[1] = ((n2n3[1] * N1[3]) + (n3n1[1] * N2[3]) +
-                                        (n1n2[1] * N3[3])) *
-                                       quotient_ninv;
-                  potentialVertex[2] = ((n2n3[2] * N1[3]) + (n3n1[2] * N2[3]) +
-                                        (n1n2[2] * N3[3])) *
-                                       quotient_ninv;
-                  for (l = 0; l < len; l++) {
-                    const float *NP = planes[l];
-                    if ((dot_v3v3(NP, potentialVertex) + NP[3]) > 0.000001f) {
-                      break;
-                    }
-                  }
 
-                  if (l == len) { /* ok */
-                    /* python */
-                    PyList_APPEND(py_verts, Vector_CreatePyObject(potentialVertex, 3, NULL));
-                    planes_used[i] = planes_used[j] = planes_used[k] = true;
+  /* note, this could be refactored into plain C easy - py bits are noted */
+  const float eps = 0.0001f;
+  const uint len = (uint)planes_len;
+  uint i, j, k, l;
+
+  float n1n2[3], n2n3[3], n3n1[3];
+  float potentialVertex[3];
+  char *planes_used = PyMem_Malloc(sizeof(char) * len);
+
+  /* python */
+  PyObject *py_verts = PyList_New(0);
+  PyObject *py_plane_index = PyList_New(0);
+
+  memset(planes_used, 0, sizeof(char) * len);
+
+  for (i = 0; i < len; i++) {
+    const float *N1 = planes[i];
+    for (j = i + 1; j < len; j++) {
+      const float *N2 = planes[j];
+      cross_v3_v3v3(n1n2, N1, N2);
+      if (len_squared_v3(n1n2) > eps) {
+        for (k = j + 1; k < len; k++) {
+          const float *N3 = planes[k];
+          cross_v3_v3v3(n2n3, N2, N3);
+          if (len_squared_v3(n2n3) > eps) {
+            cross_v3_v3v3(n3n1, N3, N1);
+            if (len_squared_v3(n3n1) > eps) {
+              const float quotient = dot_v3v3(N1, n2n3);
+              if (fabsf(quotient) > eps) {
+                /**
+                 * <pre>
+                 * potentialVertex = (
+                 *     (n2n3 * N1[3] + n3n1 * N2[3] + n1n2 * N3[3]) *
+                 *     (-1.0 / quotient));
+                 * </pre>
+                 */
+                const float quotient_ninv = -1.0f / quotient;
+                potentialVertex[0] = ((n2n3[0] * N1[3]) + (n3n1[0] * N2[3]) + (n1n2[0] * N3[3])) *
+                                     quotient_ninv;
+                potentialVertex[1] = ((n2n3[1] * N1[3]) + (n3n1[1] * N2[3]) + (n1n2[1] * N3[3])) *
+                                     quotient_ninv;
+                potentialVertex[2] = ((n2n3[2] * N1[3]) + (n3n1[2] * N2[3]) + (n1n2[2] * N3[3])) *
+                                     quotient_ninv;
+                for (l = 0; l < len; l++) {
+                  const float *NP = planes[l];
+                  if ((dot_v3v3(NP, potentialVertex) + NP[3]) > 0.000001f) {
+                    break;
                   }
                 }
+
+                if (l == len) { /* ok */
+                  /* python */
+                  PyList_APPEND(py_verts, Vector_CreatePyObject(potentialVertex, 3, NULL));
+                  planes_used[i] = planes_used[j] = planes_used[k] = true;
+                }
               }
             }
           }
         }
       }
     }
+  }
 
-    PyMem_Free(planes);
+  PyMem_Free(planes);
 
-    /* now make a list of used planes */
-    for (i = 0; i < len; i++) {
-      if (planes_used[i]) {
-        PyList_APPEND(py_plane_index, PyLong_FromLong(i));
-      }
+  /* now make a list of used planes */
+  for (i = 0; i < len; i++) {
+    if (planes_used[i]) {
+      PyList_APPEND(py_plane_index, PyLong_FromLong(i));
     }
-    PyMem_Free(planes_used);
+  }
+  PyMem_Free(planes_used);
 
-    {
-      PyObject *ret = PyTuple_New(2);
-      PyTuple_SET_ITEMS(ret, py_verts, py_plane_index);
-      return ret;
-    }
+  {
+    PyObject *ret = PyTuple_New(2);
+    PyTuple_SET_ITEMS(ret, py_verts, py_plane_index);
+    return ret;
   }
 }
 
@@ -1321,7 +1311,7 @@ static PyObject *M_Geometry_tessellate_polygon(PyObject *UNUSED(self), PyObject
     BKE_displist_free(&dispbase); /* possible some dl was allocated */
     return NULL;
   }
-  else if (totpoints) {
+  if (totpoints) {
     /* now make the list to return */
     BKE_displist_fill(&dispbase, &dispbase, is_2d ? ((const float[3]){0, 0, -1}) : NULL, false);