Cleanup: Use const arguments in definition, add helper variable

1 files changed, 189 insertions, 155 deletions

diff --git a/source/blender/blenkernel/intern/customdata.cc b/source/blender/blenkernel/intern/customdata.cc
index b12eafa9cef..f686f5cca64 100644
--- a/source/blender/blenkernel/intern/customdata.cc
+++ b/source/blender/blenkernel/intern/customdata.cc
@@ -165,7 +165,7 @@ struct LayerTypeInfo {
   void (*initminmax)(void *min, void *max);
   void (*add)(void *data1, const void *data2);
   void (*dominmax)(const void *data1, void *min, void *max);
-  void (*copyvalue)(const void *source, void *dest, const int mixmode, const float mixfactor);
+  void (*copyvalue)(const void *source, void *dest, int mixmode, const float mixfactor);
 
   /** a function to read data from a cdf file */
   bool (*read)(CDataFile *cdf, void *data, int count);
@@ -187,7 +187,7 @@ struct LayerTypeInfo {
 /** \name Callbacks for (#MDeformVert, #CD_MDEFORMVERT)
  * \{ */
 
-static void layerCopy_mdeformvert(const void *source, void *dest, int count)
+static void layerCopy_mdeformvert(const void *source, void *dest, const int count)
 {
   int i, size = sizeof(MDeformVert);
 
@@ -209,7 +209,7 @@ static void layerCopy_mdeformvert(const void *source, void *dest, int count)
   }
 }
 
-static void layerFree_mdeformvert(void *data, int count, int size)
+static void layerFree_mdeformvert(void *data, const int count, const int size)
 {
   for (int i = 0; i < count; i++) {
     MDeformVert *dvert = static_cast<MDeformVert *>(POINTER_OFFSET(data, i * size));
@@ -223,7 +223,7 @@ static void layerFree_mdeformvert(void *data, int count, int size)
 }
 
 /* copy just zeros in this case */
-static void layerCopy_bmesh_elem_py_ptr(const void *UNUSED(source), void *dest, int count)
+static void layerCopy_bmesh_elem_py_ptr(const void *UNUSED(source), void *dest, const int count)
 {
   const int size = sizeof(void *);
 
@@ -240,7 +240,7 @@ void bpy_bm_generic_invalidate(struct BPy_BMGeneric *UNUSED(self))
 }
 #endif
 
-static void layerFree_bmesh_elem_py_ptr(void *data, int count, int size)
+static void layerFree_bmesh_elem_py_ptr(void *data, const int count, const int size)
 {
   for (int i = 0; i < count; i++) {
     void **ptr = (void **)POINTER_OFFSET(data, i * size);
@@ -253,7 +253,7 @@ static void layerFree_bmesh_elem_py_ptr(void *data, int count, int size)
 static void layerInterp_mdeformvert(const void **sources,
                                     const float *weights,
                                     const float *UNUSED(sub_weights),
-                                    int count,
+                                    const int count,
                                     void *dest)
 {
   /* a single linked list of MDeformWeight's
@@ -347,7 +347,7 @@ static void layerInterp_mdeformvert(const void **sources,
 static void layerInterp_normal(const void **sources,
                                const float *weights,
                                const float *UNUSED(sub_weights),
-                               int count,
+                               const int count,
                                void *dest)
 {
   /* NOTE: This is linear interpolation, which is not optimal for vectors.
@@ -355,8 +355,8 @@ static void layerInterp_normal(const void **sources,
    * so for now it will do... */
   float no[3] = {0.0f};
 
-  while (count--) {
-    madd_v3_v3fl(no, (const float *)sources[count], weights[count]);
+  for (const int i : IndexRange(count)) {
+    madd_v3_v3fl(no, (const float *)sources[i], weights[i]);
   }
 
   /* Weighted sum of normalized vectors will **not** be normalized, even if weights are. */
@@ -406,7 +406,7 @@ static void layerCopyValue_normal(const void *source,
 /** \name Callbacks for (#MTFace, #CD_MTFACE)
  * \{ */
 
-static void layerCopy_tface(const void *source, void *dest, int count)
+static void layerCopy_tface(const void *source, void *dest, const int count)
 {
   const MTFace *source_tf = (const MTFace *)source;
   MTFace *dest_tf = (MTFace *)dest;
@@ -415,8 +415,11 @@ static void layerCopy_tface(const void *source, void *dest, int count)
   }
 }
 
-static void layerInterp_tface(
-    const void **sources, const float *weights, const float *sub_weights, int count, void *dest)
+static void layerInterp_tface(const void **sources,
+                              const float *weights,
+                              const float *sub_weights,
+                              const int count,
+                              void *dest)
 {
   MTFace *tf = static_cast<MTFace *>(dest);
   float uv[4][2] = {{0.0f}};
@@ -456,7 +459,7 @@ static void layerSwap_tface(void *data, const int *corner_indices)
   memcpy(tf->uv, uv, sizeof(tf->uv));
 }
 
-static void layerDefault_tface(void *data, int count)
+static void layerDefault_tface(void *data, const int count)
 {
   static MTFace default_tf = {{{0, 0}, {1, 0}, {1, 1}, {0, 1}}};
   MTFace *tf = (MTFace *)data;
@@ -477,7 +480,7 @@ static int layerMaxNum_tface()
 /** \name Callbacks for (#MFloatProperty, #CD_PROP_FLOAT)
  * \{ */
 
-static void layerCopy_propFloat(const void *source, void *dest, int count)
+static void layerCopy_propFloat(const void *source, void *dest, const int count)
 {
   memcpy(dest, source, sizeof(MFloatProperty) * count);
 }
@@ -485,7 +488,7 @@ static void layerCopy_propFloat(const void *source, void *dest, int count)
 static void layerInterp_propFloat(const void **sources,
                                   const float *weights,
                                   const float *UNUSED(sub_weights),
-                                  int count,
+                                  const int count,
                                   void *dest)
 {
   float result = 0.0f;
@@ -520,7 +523,7 @@ static bool layerValidate_propFloat(void *data, const uint totitems, const bool
 /** \name Callbacks for (#MIntProperty, #CD_PROP_INT32)
  * \{ */
 
-static void layerCopy_propInt(const void *source, void *dest, int count)
+static void layerCopy_propInt(const void *source, void *dest, const int count)
 {
   memcpy(dest, source, sizeof(MIntProperty) * count);
 }
@@ -528,7 +531,7 @@ static void layerCopy_propInt(const void *source, void *dest, int count)
 static void layerInterp_propInt(const void **sources,
                                 const float *weights,
                                 const float *UNUSED(sub_weights),
-                                int count,
+                                const int count,
                                 void *dest)
 {
   float result = 0.0f;
@@ -547,7 +550,7 @@ static void layerInterp_propInt(const void **sources,
 /** \name Callbacks for (#MStringProperty, #CD_PROP_STRING)
  * \{ */
 
-static void layerCopy_propString(const void *source, void *dest, int count)
+static void layerCopy_propString(const void *source, void *dest, const int count)
 {
   memcpy(dest, source, sizeof(MStringProperty) * count);
 }
@@ -558,7 +561,7 @@ static void layerCopy_propString(const void *source, void *dest, int count)
 /** \name Callbacks for (#OrigSpaceFace, #CD_ORIGSPACE)
  * \{ */
 
-static void layerCopy_origspace_face(const void *source, void *dest, int count)
+static void layerCopy_origspace_face(const void *source, void *dest, const int count)
 {
   const OrigSpaceFace *source_tf = (const OrigSpaceFace *)source;
   OrigSpaceFace *dest_tf = (OrigSpaceFace *)dest;
@@ -568,8 +571,11 @@ static void layerCopy_origspace_face(const void *source, void *dest, int count)
   }
 }
 
-static void layerInterp_origspace_face(
-    const void **sources, const float *weights, const float *sub_weights, int count, void *dest)
+static void layerInterp_origspace_face(const void **sources,
+                                       const float *weights,
+                                       const float *sub_weights,
+                                       const int count,
+                                       void *dest)
 {
   OrigSpaceFace *osf = static_cast<OrigSpaceFace *>(dest);
   float uv[4][2] = {{0.0f}};
@@ -606,7 +612,7 @@ static void layerSwap_origspace_face(void *data, const int *corner_indices)
   memcpy(osf->uv, uv, sizeof(osf->uv));
 }
 
-static void layerDefault_origspace_face(void *data, int count)
+static void layerDefault_origspace_face(void *data, const int count)
 {
   static OrigSpaceFace default_osf = {{{0, 0}, {1, 0}, {1, 1}, {0, 1}}};
   OrigSpaceFace *osf = (OrigSpaceFace *)data;
@@ -652,7 +658,7 @@ static void layerSwap_mdisps(void *data, const int *ci)
   }
 }
 
-static void layerCopy_mdisps(const void *source, void *dest, int count)
+static void layerCopy_mdisps(const void *source, void *dest, const int count)
 {
   const MDisps *s = static_cast<const MDisps *>(source);
   MDisps *d = static_cast<MDisps *>(dest);
@@ -673,7 +679,7 @@ static void layerCopy_mdisps(const void *source, void *dest, int count)
   }
 }
 
-static void layerFree_mdisps(void *data, int count, int UNUSED(size))
+static void layerFree_mdisps(void *data, const int count, const int UNUSED(size))
 {
   MDisps *d = static_cast<MDisps *>(data);
 
@@ -691,7 +697,7 @@ static void layerFree_mdisps(void *data, int count, int UNUSED(size))
   }
 }
 
-static bool layerRead_mdisps(CDataFile *cdf, void *data, int count)
+static bool layerRead_mdisps(CDataFile *cdf, void *data, const int count)
 {
   MDisps *d = static_cast<MDisps *>(data);
 
@@ -709,7 +715,7 @@ static bool layerRead_mdisps(CDataFile *cdf, void *data, int count)
   return true;
 }
 
-static bool layerWrite_mdisps(CDataFile *cdf, const void *data, int count)
+static bool layerWrite_mdisps(CDataFile *cdf, const void *data, const int count)
 {
   const MDisps *d = static_cast<const MDisps *>(data);
 
@@ -723,7 +729,7 @@ static bool layerWrite_mdisps(CDataFile *cdf, const void *data, int count)
   return true;
 }
 
-static size_t layerFilesize_mdisps(CDataFile *UNUSED(cdf), const void *data, int count)
+static size_t layerFilesize_mdisps(CDataFile *UNUSED(cdf), const void *data, const int count)
 {
   const MDisps *d = static_cast<const MDisps *>(data);
   size_t size = 0;
@@ -762,7 +768,7 @@ static void layerInterp_paint_mask(const void **sources,
 /** \name Callbacks for (#GridPaintMask, #CD_GRID_PAINT_MASK)
  * \{ */
 
-static void layerCopy_grid_paint_mask(const void *source, void *dest, int count)
+static void layerCopy_grid_paint_mask(const void *source, void *dest, const int count)
 {
   const GridPaintMask *s = static_cast<const GridPaintMask *>(source);
   GridPaintMask *d = static_cast<GridPaintMask *>(dest);
@@ -779,7 +785,7 @@ static void layerCopy_grid_paint_mask(const void *source, void *dest, int count)
   }
 }
 
-static void layerFree_grid_paint_mask(void *data, int count, int UNUSED(size))
+static void layerFree_grid_paint_mask(void *data, const int count, const int UNUSED(size))
 {
   GridPaintMask *gpm = static_cast<GridPaintMask *>(data);
 
@@ -867,7 +873,7 @@ static bool layerEqual_mloopcol(const void *data1, const void *data2)
   return r * r + g * g + b * b + a * a < 0.001f;
 }
 
-static void layerMultiply_mloopcol(void *data, float fac)
+static void layerMultiply_mloopcol(void *data, const float fac)
 {
   MLoopCol *m = static_cast<MLoopCol *>(data);
 
@@ -936,7 +942,7 @@ static void layerInitMinMax_mloopcol(void *vmin, void *vmax)
   max->a = 0;
 }
 
-static void layerDefault_mloopcol(void *data, int count)
+static void layerDefault_mloopcol(void *data, const int count)
 {
   MLoopCol default_mloopcol = {255, 255, 255, 255};
   MLoopCol *mlcol = (MLoopCol *)data;
@@ -1016,7 +1022,7 @@ static bool layerEqual_mloopuv(const void *data1, const void *data2)
   return len_squared_v2v2(luv1->uv, luv2->uv) < 0.00001f;
 }
 
-static void layerMultiply_mloopuv(void *data, float fac)
+static void layerMultiply_mloopuv(void *data, const float fac)
 {
   MLoopUV *luv = static_cast<MLoopUV *>(data);
 
@@ -1110,7 +1116,7 @@ static bool layerEqual_mloop_origspace(const void *data1, const void *data2)
   return len_squared_v2v2(luv1->uv, luv2->uv) < 0.00001f;
 }
 
-static void layerMultiply_mloop_origspace(void *data, float fac)
+static void layerMultiply_mloop_origspace(void *data, const float fac)
 {
   OrigSpaceLoop *luv = static_cast<OrigSpaceLoop *>(data);
 
@@ -1162,8 +1168,11 @@ static void layerInterp_mloop_origspace(const void **sources,
 }
 /* --- end copy */
 
-static void layerInterp_mcol(
-    const void **sources, const float *weights, const float *sub_weights, int count, void *dest)
+static void layerInterp_mcol(const void **sources,
+                             const float *weights,
+                             const float *sub_weights,
+                             const int count,
+                             void *dest)
 {
   MCol *mc = static_cast<MCol *>(dest);
   struct {
@@ -1222,7 +1231,7 @@ static void layerSwap_mcol(void *data, const int *corner_indices)
   memcpy(mcol, col, sizeof(col));
 }
 
-static void layerDefault_mcol(void *data, int count)
+static void layerDefault_mcol(void *data, const int count)
 {
   static MCol default_mcol = {255, 255, 255, 255};
   MCol *mcol = (MCol *)data;
@@ -1232,7 +1241,7 @@ static void layerDefault_mcol(void *data, int count)
   }
 }
 
-static void layerDefault_origindex(void *data, int count)
+static void layerDefault_origindex(void *data, const int count)
 {
   copy_vn_i((int *)data, count, ORIGINDEX_NONE);
 }
@@ -1290,7 +1299,7 @@ static void layerInterp_shapekey(const void **sources,
 /** \name Callbacks for (#MVertSkin, #CD_MVERT_SKIN)
  * \{ */
 
-static void layerDefault_mvert_skin(void *data, int count)
+static void layerDefault_mvert_skin(void *data, const int count)
 {
   MVertSkin *vs = static_cast<MVertSkin *>(data);
 
@@ -1300,7 +1309,7 @@ static void layerDefault_mvert_skin(void *data, int count)
   }
 }
 
-static void layerCopy_mvert_skin(const void *source, void *dest, int count)
+static void layerCopy_mvert_skin(const void *source, void *dest, const int count)
 {
   memcpy(dest, source, sizeof(MVertSkin) * count);
 }
@@ -1352,7 +1361,7 @@ static void layerSwap_flnor(void *data, const int *corner_indices)
 /** \name Callbacks for (`int`, #CD_FACEMAP)
  * \{ */
 
-static void layerDefault_fmap(void *data, int count)
+static void layerDefault_fmap(void *data, const int count)
 {
   int *fmap_num = (int *)data;
   for (int i = 0; i < count; i++) {
@@ -1428,7 +1437,7 @@ static bool layerEqual_propcol(const void *data1, const void *data2)
   return tot < 0.001f;
 }
 
-static void layerMultiply_propcol(void *data, float fac)
+static void layerMultiply_propcol(void *data, const float fac)
 {
   MPropCol *m = static_cast<MPropCol *>(data);
   mul_v4_fl(m->color, fac);
@@ -1458,7 +1467,7 @@ static void layerInitMinMax_propcol(void *vmin, void *vmax)
   copy_v4_fl(max->color, FLT_MIN);
 }
 
-static void layerDefault_propcol(void *data, int count)
+static void layerDefault_propcol(void *data, const int count)
 {
   /* Default to white, full alpha. */
   MPropCol default_propcol = {{1.0f, 1.0f, 1.0f, 1.0f}};
@@ -1510,7 +1519,7 @@ static void layerInterp_propfloat3(const void **sources,
   copy_v3_v3((float *)dest, &result.x);
 }
 
-static void layerMultiply_propfloat3(void *data, float fac)
+static void layerMultiply_propfloat3(void *data, const float fac)
 {
   vec3f *vec = static_cast<vec3f *>(data);
   vec->x *= fac;
@@ -1563,7 +1572,7 @@ static void layerInterp_propfloat2(const void **sources,
   copy_v2_v2((float *)dest, &result.x);
 }
 
-static void layerMultiply_propfloat2(void *data, float fac)
+static void layerMultiply_propfloat2(void *data, const float fac)
 {
   vec2f *vec = static_cast<vec2f *>(data);
   vec->x *= fac;
@@ -2327,7 +2336,7 @@ bool CustomData_merge(const CustomData *source,
   return changed;
 }
 
-void CustomData_realloc(CustomData *data, int totelem)
+void CustomData_realloc(CustomData *data, const int totelem)
 {
   BLI_assert(totelem >= 0);
   for (int i = 0; i < data->totlayer; i++) {
@@ -2358,7 +2367,7 @@ void CustomData_copy(const CustomData *source,
   CustomData_merge(source, dest, mask, alloctype, totelem);
 }
 
-static void customData_free_layer__internal(CustomDataLayer *layer, int totelem)
+static void customData_free_layer__internal(CustomDataLayer *layer, const int totelem)
 {
   const LayerTypeInfo *typeInfo;
 
@@ -2393,7 +2402,7 @@ void CustomData_reset(CustomData *data)
   copy_vn_i(data->typemap, CD_NUMTYPES, -1);
 }
 
-void CustomData_free(CustomData *data, int totelem)
+void CustomData_free(CustomData *data, const int totelem)
 {
   for (int i = 0; i < data->totlayer; i++) {
     customData_free_layer__internal(&data->layers[i], totelem);
@@ -2407,7 +2416,7 @@ void CustomData_free(CustomData *data, int totelem)
   CustomData_reset(data);
 }
 
-void CustomData_free_typemask(CustomData *data, int totelem, eCustomDataMask mask)
+void CustomData_free_typemask(CustomData *data, const int totelem, eCustomDataMask mask)
 {
   for (int i = 0; i < data->totlayer; i++) {
     CustomDataLayer *layer = &data->layers[i];
@@ -2442,7 +2451,7 @@ static void customData_update_offsets(CustomData *data)
 }
 
 /* to use when we're in the middle of modifying layers */
-static int CustomData_get_layer_index__notypemap(const CustomData *data, int type)
+static int CustomData_get_layer_index__notypemap(const CustomData *data, const int type)
 {
   for (int i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
@@ -2456,13 +2465,13 @@ static int CustomData_get_layer_index__notypemap(const CustomData *data, int typ
 /* -------------------------------------------------------------------- */
 /* index values to access the layers (offset from the layer start) */
 
-int CustomData_get_layer_index(const CustomData *data, int type)
+int CustomData_get_layer_index(const CustomData *data, const int type)
 {
   BLI_assert(customdata_typemap_is_valid(data));
   return data->typemap[type];
 }
 
-int CustomData_get_layer_index_n(const CustomData *data, int type, int n)
+int CustomData_get_layer_index_n(const CustomData *data, const int type, const int n)
 {
   BLI_assert(n >= 0);
   int i = CustomData_get_layer_index(data, type);
@@ -2475,7 +2484,7 @@ int CustomData_get_layer_index_n(const CustomData *data, int type, int n)
   return i;
 }
 
-int CustomData_get_named_layer_index(const CustomData *data, int type, const char *name)
+int CustomData_get_named_layer_index(const CustomData *data, const int type, const char *name)
 {
   for (int i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
@@ -2488,28 +2497,28 @@ int CustomData_get_named_layer_index(const CustomData *data, int type, const cha
   return -1;
 }
 
-int CustomData_get_active_layer_index(const CustomData *data, int type)
+int CustomData_get_active_layer_index(const CustomData *data, const int type)
 {
   const int layer_index = data->typemap[type];
   BLI_assert(customdata_typemap_is_valid(data));
   return (layer_index != -1) ? layer_index + data->layers[layer_index].active : -1;
 }
 
-int CustomData_get_render_layer_index(const CustomData *data, int type)
+int CustomData_get_render_layer_index(const CustomData *data, const int type)
 {
   const int layer_index = data->typemap[type];
   BLI_assert(customdata_typemap_is_valid(data));
   return (layer_index != -1) ? layer_index + data->layers[layer_index].active_rnd : -1;
 }
 
-int CustomData_get_clone_layer_index(const CustomData *data, int type)
+int CustomData_get_clone_layer_index(const CustomData *data, const int type)
 {
   const int layer_index = data->typemap[type];
   BLI_assert(customdata_typemap_is_valid(data));
   return (layer_index != -1) ? layer_index + data->layers[layer_index].active_clone : -1;
 }
 
-int CustomData_get_stencil_layer_index(const CustomData *data, int type)
+int CustomData_get_stencil_layer_index(const CustomData *data, const int type)
 {
   const int layer_index = data->typemap[type];
   BLI_assert(customdata_typemap_is_valid(data));
@@ -2519,7 +2528,7 @@ int CustomData_get_stencil_layer_index(const CustomData *data, int type)
 /* -------------------------------------------------------------------- */
 /* index values per layer type */
 
-int CustomData_get_named_layer(const CustomData *data, int type, const char *name)
+int CustomData_get_named_layer(const CustomData *data, const int type, const char *name)
 {
   const int named_index = CustomData_get_named_layer_index(data, type, name);
   const int layer_index = data->typemap[type];
@@ -2527,28 +2536,28 @@ int CustomData_get_named_layer(const CustomData *data, int type, const char *nam
   return (named_index != -1) ? named_index - layer_index : -1;
 }
 
-int CustomData_get_active_layer(const CustomData *data, int type)
+int CustomData_get_active_layer(const CustomData *data, const int type)
 {
   const int layer_index = data->typemap[type];
   BLI_assert(customdata_typemap_is_valid(data));
   return (layer_index != -1) ? data->layers[layer_index].active : -1;
 }
 
-int CustomData_get_render_layer(const CustomData *data, int type)
+int CustomData_get_render_layer(const CustomData *data, const int type)
 {
   const int layer_index = data->typemap[type];
   BLI_assert(customdata_typemap_is_valid(data));
   return (layer_index != -1) ? data->layers[layer_index].active_rnd : -1;
 }
 
-int CustomData_get_clone_layer(const CustomData *data, int type)
+int CustomData_get_clone_layer(const CustomData *data, const int type)
 {
   const int layer_index = data->typemap[type];
   BLI_assert(customdata_typemap_is_valid(data));
   return (layer_index != -1) ? data->layers[layer_index].active_clone : -1;
 }
 
-int CustomData_get_stencil_layer(const CustomData *data, int type)
+int CustomData_get_stencil_layer(const CustomData *data, const int type)
 {
   const int layer_index = data->typemap[type];
   BLI_assert(customdata_typemap_is_valid(data));
@@ -2562,7 +2571,7 @@ const char *CustomData_get_active_layer_name(const CustomData *data, const int t
   return layer_index < 0 ? nullptr : data->layers[layer_index].name;
 }
 
-void CustomData_set_layer_active(CustomData *data, int type, int n)
+void CustomData_set_layer_active(CustomData *data, const int type, const int n)
 {
   for (int i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
@@ -2571,7 +2580,7 @@ void CustomData_set_layer_active(CustomData *data, int type, int n)
   }
 }
 
-void CustomData_set_layer_render(CustomData *data, int type, int n)
+void CustomData_set_layer_render(CustomData *data, const int type, const int n)
 {
   for (int i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
@@ -2580,7 +2589,7 @@ void CustomData_set_layer_render(CustomData *data, int type, int n)
   }
 }
 
-void CustomData_set_layer_clone(CustomData *data, int type, int n)
+void CustomData_set_layer_clone(CustomData *data, const int type, const int n)
 {
   for (int i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
@@ -2589,7 +2598,7 @@ void CustomData_set_layer_clone(CustomData *data, int type, int n)
   }
 }
 
-void CustomData_set_layer_stencil(CustomData *data, int type, int n)
+void CustomData_set_layer_stencil(CustomData *data, const int type, const int n)
 {
   for (int i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
@@ -2598,7 +2607,7 @@ void CustomData_set_layer_stencil(CustomData *data, int type, int n)
   }
 }
 
-void CustomData_set_layer_active_index(CustomData *data, int type, int n)
+void CustomData_set_layer_active_index(CustomData *data, const int type, const int n)
 {
   const int layer_index = data->typemap[type];
   BLI_assert(customdata_typemap_is_valid(data));
@@ -2610,7 +2619,7 @@ void CustomData_set_layer_active_index(CustomData *data, int type, int n)
   }
 }
 
-void CustomData_set_layer_render_index(CustomData *data, int type, int n)
+void CustomData_set_layer_render_index(CustomData *data, const int type, const int n)
 {
   const int layer_index = data->typemap[type];
   BLI_assert(customdata_typemap_is_valid(data));
@@ -2622,7 +2631,7 @@ void CustomData_set_layer_render_index(CustomData *data, int type, int n)
   }
 }
 
-void CustomData_set_layer_clone_index(CustomData *data, int type, int n)
+void CustomData_set_layer_clone_index(CustomData *data, const int type, const int n)
 {
   const int layer_index = data->typemap[type];
   BLI_assert(customdata_typemap_is_valid(data));
@@ -2634,7 +2643,7 @@ void CustomData_set_layer_clone_index(CustomData *data, int type, int n)
   }
 }
 
-void CustomData_set_layer_stencil_index(CustomData *data, int type, int n)
+void CustomData_set_layer_stencil_index(CustomData *data, const int type, const int n)
 {
   const int layer_index = data->typemap[type];
   BLI_assert(customdata_typemap_is_valid(data));
@@ -2646,7 +2655,7 @@ void CustomData_set_layer_stencil_index(CustomData *data, int type, int n)
   }
 }
 
-void CustomData_set_layer_flag(CustomData *data, int type, int flag)
+void CustomData_set_layer_flag(CustomData *data, const int type, const int flag)
 {
   for (int i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
@@ -2655,7 +2664,7 @@ void CustomData_set_layer_flag(CustomData *data, int type, int flag)
   }
 }
 
-void CustomData_clear_layer_flag(CustomData *data, int type, int flag)
+void CustomData_clear_layer_flag(CustomData *data, const int type, const int flag)
 {
   const int nflag = ~flag;
 
@@ -2666,7 +2675,7 @@ void CustomData_clear_layer_flag(CustomData *data, int type, int flag)
   }
 }
 
-static bool customData_resize(CustomData *data, int amount)
+static bool customData_resize(CustomData *data, const int amount)
 {
   CustomDataLayer *tmp = static_cast<CustomDataLayer *>(
       MEM_calloc_arrayN((data->maxlayer + amount), sizeof(*tmp), __func__));
@@ -2685,15 +2694,14 @@ static bool customData_resize(CustomData *data, int amount)
 }
 
 static CustomDataLayer *customData_add_layer__internal(CustomData *data,
-                                                       int type,
-                                                       eCDAllocType alloctype,
+                                                       const int type,
+                                                       const eCDAllocType alloctype,
                                                        void *layerdata,
-                                                       int totelem,
+                                                       const int totelem,
                                                        const char *name)
 {
   const LayerTypeInfo *typeInfo = layerType_getInfo(type);
-  int flag = 0, index = data->totlayer;
-  void *newlayerdata = nullptr;
+  int flag = 0;
 
   /* Passing a layer-data to copy from with an alloctype that won't copy is
    * most likely a bug */
@@ -2703,6 +2711,7 @@ static CustomDataLayer *customData_add_layer__internal(CustomData *data,
     return &data->layers[CustomData_get_layer_index(data, type)];
   }
 
+  void *newlayerdata = nullptr;
   if (ELEM(alloctype, CD_ASSIGN, CD_REFERENCE)) {
     newlayerdata = layerdata;
   }
@@ -2738,6 +2747,7 @@ static CustomDataLayer *customData_add_layer__internal(CustomData *data,
     flag |= CD_FLAG_NOFREE;
   }
 
+  int index = data->totlayer;
   if (index >= data->maxlayer) {
     if (!customData_resize(data, CUSTOMDATA_GROW)) {
       if (newlayerdata != layerdata) {
@@ -2754,14 +2764,16 @@ static CustomDataLayer *customData_add_layer__internal(CustomData *data,
     data->layers[index] = data->layers[index - 1];
   }
 
+  CustomDataLayer &new_layer = data->layers[index];
+
   /* Clear remaining data on the layer. The original data on the layer has been moved to another
    * index. Without this, it can happen that information from the previous layer at that index
    * leaks into the new layer. */
-  memset(data->layers + index, 0, sizeof(CustomDataLayer));
+  memset(&new_layer, 0, sizeof(CustomDataLayer));
 
-  data->layers[index].type = type;
-  data->layers[index].flag = flag;
-  data->layers[index].data = newlayerdata;
+  new_layer.type = type;
+  new_layer.flag = flag;
+  new_layer.data = newlayerdata;
 
   /* Set default name if none exists. Note we only call DATA_()  once
    * we know there is a default name, to avoid overhead of locale lookups
@@ -2771,24 +2783,24 @@ static CustomDataLayer *customData_add_layer__internal(CustomData *data,
   }
 
   if (name) {
-    BLI_strncpy(data->layers[index].name, name, sizeof(data->layers[index].name));
+    BLI_strncpy(new_layer.name, name, sizeof(new_layer.name));
     CustomData_set_layer_unique_name(data, index);
   }
   else {
-    data->layers[index].name[0] = '\0';
+    new_layer.name[0] = '\0';
   }
 
   if (index > 0 && data->layers[index - 1].type == type) {
-    data->layers[index].active = data->layers[index - 1].active;
-    data->layers[index].active_rnd = data->layers[index - 1].active_rnd;
-    data->layers[index].active_clone = data->layers[index - 1].active_clone;
-    data->layers[index].active_mask = data->layers[index - 1].active_mask;
+    new_layer.active = data->layers[index - 1].active;
+    new_layer.active_rnd = data->layers[index - 1].active_rnd;
+    new_layer.active_clone = data->layers[index - 1].active_clone;
+    new_layer.active_mask = data->layers[index - 1].active_mask;
   }
   else {
-    data->layers[index].active = 0;
-    data->layers[index].active_rnd = 0;
-    data->layers[index].active_clone = 0;
-    data->layers[index].active_mask = 0;
+    new_layer.active = 0;
+    new_layer.active_rnd = 0;
+    new_layer.active_clone = 0;
+    new_layer.active_mask = 0;
   }
 
   customData_update_offsets(data);
@@ -2797,7 +2809,7 @@ static CustomDataLayer *customData_add_layer__internal(CustomData *data,
 }
 
 void *CustomData_add_layer(
-    CustomData *data, int type, eCDAllocType alloctype, void *layerdata, int totelem)
+    CustomData *data, const int type, eCDAllocType alloctype, void *layerdata, const int totelem)
 {
   const LayerTypeInfo *typeInfo = layerType_getInfo(type);
 
@@ -2813,10 +2825,10 @@ void *CustomData_add_layer(
 }
 
 void *CustomData_add_layer_named(CustomData *data,
-                                 int type,
-                                 eCDAllocType alloctype,
+                                 const int type,
+                                 const eCDAllocType alloctype,
                                  void *layerdata,
-                                 int totelem,
+                                 const int totelem,
                                  const char *name)
 {
   CustomDataLayer *layer = customData_add_layer__internal(
@@ -2831,10 +2843,10 @@ void *CustomData_add_layer_named(CustomData *data,
 }
 
 void *CustomData_add_layer_anonymous(CustomData *data,
-                                     int type,
-                                     eCDAllocType alloctype,
+                                     const int type,
+                                     const eCDAllocType alloctype,
                                      void *layerdata,
-                                     int totelem,
+                                     const int totelem,
                                      const AnonymousAttributeID *anonymous_id)
 {
   const char *name = BKE_anonymous_attribute_id_internal_name(anonymous_id);
@@ -2851,7 +2863,7 @@ void *CustomData_add_layer_anonymous(CustomData *data,
   return layer->data;
 }
 
-bool CustomData_free_layer(CustomData *data, int type, int totelem, int index)
+bool CustomData_free_layer(CustomData *data, const int type, const int totelem, const int index)
 {
   const int index_first = CustomData_get_layer_index(data, type);
   const int n = index - index_first;
@@ -2915,7 +2927,7 @@ bool CustomData_free_layer_named(CustomData *data, const char *name, const int t
   return false;
 }
 
-bool CustomData_free_layer_active(CustomData *data, int type, int totelem)
+bool CustomData_free_layer_active(CustomData *data, const int type, const int totelem)
 {
   const int index = CustomData_get_active_layer_index(data, type);
   if (index == -1) {
@@ -2924,7 +2936,7 @@ bool CustomData_free_layer_active(CustomData *data, int type, int totelem)
   return CustomData_free_layer(data, type, totelem, index);
 }
 
-void CustomData_free_layers(CustomData *data, int type, int totelem)
+void CustomData_free_layers(CustomData *data, const int type, const int totelem)
 {
   const int index = CustomData_get_layer_index(data, type);
   while (CustomData_free_layer(data, type, totelem, index)) {
@@ -2932,12 +2944,12 @@ void CustomData_free_layers(CustomData *data, int type, int totelem)
   }
 }
 
-bool CustomData_has_layer(const CustomData *data, int type)
+bool CustomData_has_layer(const CustomData *data, const int type)
 {
   return (CustomData_get_layer_index(data, type) != -1);
 }
 
-int CustomData_number_of_layers(const CustomData *data, int type)
+int CustomData_number_of_layers(const CustomData *data, const int type)
 {
   int number = 0;
 
@@ -2950,7 +2962,7 @@ int CustomData_number_of_layers(const CustomData *data, int type)
   return number;
 }
 
-int CustomData_number_of_layers_typemask(const CustomData *data, eCustomDataMask mask)
+int CustomData_number_of_layers_typemask(const CustomData *data, const eCustomDataMask mask)
 {
   int number = 0;
 
@@ -3040,7 +3052,7 @@ void *CustomData_duplicate_referenced_layer_anonymous(CustomData *data,
   return nullptr;
 }
 
-void CustomData_duplicate_referenced_layers(CustomData *data, int totelem)
+void CustomData_duplicate_referenced_layers(CustomData *data, const int totelem)
 {
   for (int i = 0; i < data->totlayer; i++) {
     CustomDataLayer *layer = &data->layers[i];
@@ -3048,7 +3060,7 @@ void CustomData_duplicate_referenced_layers(CustomData *data, int totelem)
   }
 }
 
-bool CustomData_is_referenced_layer(CustomData *data, int type)
+bool CustomData_is_referenced_layer(CustomData *data, const int type)
 {
   /* get the layer index of the first layer of type */
   int layer_index = CustomData_get_active_layer_index(data, type);
@@ -3061,7 +3073,7 @@ bool CustomData_is_referenced_layer(CustomData *data, int type)
   return (layer->flag & CD_FLAG_NOFREE) != 0;
 }
 
-void CustomData_free_temporary(CustomData *data, int totelem)
+void CustomData_free_temporary(CustomData *data, const int totelem)
 {
   int i, j;
   bool changed = false;
@@ -3093,7 +3105,7 @@ void CustomData_free_temporary(CustomData *data, int totelem)
   }
 }
 
-void CustomData_set_only_copy(const CustomData *data, eCustomDataMask mask)
+void CustomData_set_only_copy(const CustomData *data, const eCustomDataMask mask)
 {
   for (int i = 0; i < data->totlayer; i++) {
     if (!(mask & CD_TYPE_AS_MASK(data->layers[i].type))) {
@@ -3102,7 +3114,10 @@ void CustomData_set_only_copy(const CustomData *data, eCustomDataMask mask)
   }
 }
 
-void CustomData_copy_elements(int type, void *src_data_ofs, void *dst_data_ofs, int count)
+void CustomData_copy_elements(const int type,
+                              void *src_data_ofs,
+                              void *dst_data_ofs,
+                              const int count)
 {
   const LayerTypeInfo *typeInfo = layerType_getInfo(type);
 
@@ -3116,11 +3131,11 @@ void CustomData_copy_elements(int type, void *src_data_ofs, void *dst_data_ofs,
 
 void CustomData_copy_data_layer(const CustomData *source,
                                 CustomData *dest,
-                                int src_layer_index,
-                                int dst_layer_index,
-                                int src_index,
-                                int dst_index,
-                                int count)
+                                const int src_layer_index,
+                                const int dst_layer_index,
+                                const int src_index,
+                                const int dst_index,
+                                const int count)
 {
   const LayerTypeInfo *typeInfo;
 
@@ -3154,8 +3169,11 @@ void CustomData_copy_data_layer(const CustomData *source,
   }
 }
 
-void CustomData_copy_data_named(
-    const CustomData *source, CustomData *dest, int source_index, int dest_index, int count)
+void CustomData_copy_data_named(const CustomData *source,
+                                CustomData *dest,
+                                const int source_index,
+                                const int dest_index,
+                                const int count)
 {
   /* copies a layer at a time */
   for (int src_i = 0; src_i < source->totlayer; src_i++) {
@@ -3170,8 +3188,11 @@ void CustomData_copy_data_named(
   }
 }
 
-void CustomData_copy_data(
-    const CustomData *source, CustomData *dest, int source_index, int dest_index, int count)
+void CustomData_copy_data(const CustomData *source,
+                          CustomData *dest,
+                          const int source_index,
+                          const int dest_index,
+                          const int count)
 {
   /* copies a layer at a time */
   int dest_i = 0;
@@ -3226,7 +3247,7 @@ void CustomData_copy_layer_type_data(const CustomData *source,
                              count);
 }
 
-void CustomData_free_elem(CustomData *data, int index, int count)
+void CustomData_free_elem(CustomData *data, const int index, const int count)
 {
   for (int i = 0; i < data->totlayer; i++) {
     if (!(data->layers[i].flag & CD_FLAG_NOFREE)) {
@@ -3326,7 +3347,7 @@ void CustomData_interp(const CustomData *source,
   }
 }
 
-void CustomData_swap_corners(CustomData *data, int index, const int *corner_indices)
+void CustomData_swap_corners(CustomData *data, const int index, const int *corner_indices)
 {
   for (int i = 0; i < data->totlayer; i++) {
     const LayerTypeInfo *typeInfo = layerType_getInfo(data->layers[i].type);
@@ -3366,7 +3387,7 @@ void CustomData_swap(CustomData *data, const int index_a, const int index_b)
   }
 }
 
-void *CustomData_get(const CustomData *data, int index, int type)
+void *CustomData_get(const CustomData *data, const int index, const int type)
 {
   BLI_assert(index >= 0);
 
@@ -3382,7 +3403,7 @@ void *CustomData_get(const CustomData *data, int index, int type)
   return POINTER_OFFSET(data->layers[layer_index].data, offset);
 }
 
-void *CustomData_get_n(const CustomData *data, int type, int index, int n)
+void *CustomData_get_n(const CustomData *data, const int type, const int index, const int n)
 {
   BLI_assert(index >= 0 && n >= 0);
 
@@ -3396,7 +3417,7 @@ void *CustomData_get_n(const CustomData *data, int type, int index, int n)
   return POINTER_OFFSET(data->layers[layer_index + n].data, offset);
 }
 
-void *CustomData_get_layer(const CustomData *data, int type)
+void *CustomData_get_layer(const CustomData *data, const int type)
 {
   /* get the layer index of the active layer of type */
   int layer_index = CustomData_get_active_layer_index(data, type);
@@ -3407,7 +3428,7 @@ void *CustomData_get_layer(const CustomData *data, int type)
   return data->layers[layer_index].data;
 }
 
-void *CustomData_get_layer_n(const CustomData *data, int type, int n)
+void *CustomData_get_layer_n(const CustomData *data, const int type, const int n)
 {
   /* get the layer index of the active layer of type */
   int layer_index = CustomData_get_layer_index_n(data, type, n);
@@ -3418,7 +3439,7 @@ void *CustomData_get_layer_n(const CustomData *data, int type, int n)
   return data->layers[layer_index].data;
 }
 
-void *CustomData_get_layer_named(const CustomData *data, int type, const char *name)
+void *CustomData_get_layer_named(const CustomData *data, const int type, const char *name)
 {
   int layer_index = CustomData_get_named_layer_index(data, type, name);
   if (layer_index == -1) {
@@ -3428,7 +3449,7 @@ void *CustomData_get_layer_named(const CustomData *data, int type, const char *n
   return data->layers[layer_index].data;
 }
 
-int CustomData_get_offset(const CustomData *data, int type)
+int CustomData_get_offset(const CustomData *data, const int type)
 {
   /* get the layer index of the active layer of type */
   int layer_index = CustomData_get_active_layer_index(data, type);
@@ -3439,7 +3460,7 @@ int CustomData_get_offset(const CustomData *data, int type)
   return data->layers[layer_index].offset;
 }
 
-int CustomData_get_n_offset(const CustomData *data, int type, int n)
+int CustomData_get_n_offset(const CustomData *data, const int type, const int n)
 {
   /* get the layer index of the active layer of type */
   int layer_index = CustomData_get_layer_index_n(data, type, n);
@@ -3450,7 +3471,10 @@ int CustomData_get_n_offset(const CustomData *data, int type, int n)
   return data->layers[layer_index].offset;
 }
 
-bool CustomData_set_layer_name(const CustomData *data, int type, int n, const char *name)
+bool CustomData_set_layer_name(const CustomData *data,
+                               const int type,
+                               const int n,
+                               const char *name)
 {
   /* get the layer index of the first layer of type */
   const int layer_index = CustomData_get_layer_index_n(data, type, n);
@@ -3464,14 +3488,14 @@ bool CustomData_set_layer_name(const CustomData *data, int type, int n, const ch
   return true;
 }
 
-const char *CustomData_get_layer_name(const CustomData *data, int type, int n)
+const char *CustomData_get_layer_name(const CustomData *data, const int type, const int n)
 {
   const int layer_index = CustomData_get_layer_index_n(data, type, n);
 
   return (layer_index == -1) ? nullptr : data->layers[layer_index].name;
 }
 
-void *CustomData_set_layer(const CustomData *data, int type, void *ptr)
+void *CustomData_set_layer(const CustomData *data, const int type, void *ptr)
 {
   /* get the layer index of the first layer of type */
   int layer_index = CustomData_get_active_layer_index(data, type);
@@ -3485,7 +3509,7 @@ void *CustomData_set_layer(const CustomData *data, int type, void *ptr)
   return ptr;
 }
 
-void *CustomData_set_layer_n(const CustomData *data, int type, int n, void *ptr)
+void *CustomData_set_layer_n(const CustomData *data, const int type, const int n, void *ptr)
 {
   /* get the layer index of the first layer of type */
   int layer_index = CustomData_get_layer_index_n(data, type, n);
@@ -3498,7 +3522,7 @@ void *CustomData_set_layer_n(const CustomData *data, int type, int n, void *ptr)
   return ptr;
 }
 
-void CustomData_set(const CustomData *data, int index, int type, const void *source)
+void CustomData_set(const CustomData *data, const int index, const int type, const void *source)
 {
   void *dest = CustomData_get(data, index, type);
   const LayerTypeInfo *typeInfo = layerType_getInfo(type);
@@ -3550,7 +3574,7 @@ void CustomData_bmesh_update_active_layers(CustomData *fdata, CustomData *ldata)
   }
 }
 
-void CustomData_bmesh_init_pool(CustomData *data, int totelem, const char htype)
+void CustomData_bmesh_init_pool(CustomData *data, const int totelem, const char htype)
 {
   int chunksize;
 
@@ -3752,7 +3776,7 @@ void CustomData_bmesh_free_block_data_exclude_by_type(CustomData *data,
   }
 }
 
-static void CustomData_bmesh_set_default_n(CustomData *data, void **block, int n)
+static void CustomData_bmesh_set_default_n(CustomData *data, void **block, const int n)
 {
   int offset = data->layers[n].offset;
   const LayerTypeInfo *typeInfo = layerType_getInfo(data->layers[n].type);
@@ -3847,7 +3871,7 @@ void CustomData_bmesh_copy_data(const CustomData *source,
   CustomData_bmesh_copy_data_exclude_by_type(source, dest, src_block, dest_block, 0);
 }
 
-void *CustomData_bmesh_get(const CustomData *data, void *block, int type)
+void *CustomData_bmesh_get(const CustomData *data, void *block, const int type)
 {
   /* get the layer index of the first layer of type */
   int layer_index = CustomData_get_active_layer_index(data, type);
@@ -3858,7 +3882,7 @@ void *CustomData_bmesh_get(const CustomData *data, void *block, int type)
   return POINTER_OFFSET(block, data->layers[layer_index].offset);
 }
 
-void *CustomData_bmesh_get_n(const CustomData *data, void *block, int type, int n)
+void *CustomData_bmesh_get_n(const CustomData *data, void *block, const int type, const int n)
 {
   /* get the layer index of the first layer of type */
   int layer_index = CustomData_get_layer_index(data, type);
@@ -3869,7 +3893,7 @@ void *CustomData_bmesh_get_n(const CustomData *data, void *block, int type, int
   return POINTER_OFFSET(block, data->layers[layer_index + n].offset);
 }
 
-void *CustomData_bmesh_get_layer_n(const CustomData *data, void *block, int n)
+void *CustomData_bmesh_get_layer_n(const CustomData *data, void *block, const int n)
 {
   if (n < 0 || n >= data->totlayer) {
     return nullptr;
@@ -3878,7 +3902,7 @@ void *CustomData_bmesh_get_layer_n(const CustomData *data, void *block, int n)
   return POINTER_OFFSET(block, data->layers[n].offset);
 }
 
-bool CustomData_layer_has_math(const CustomData *data, int layer_n)
+bool CustomData_layer_has_math(const CustomData *data, const int layer_n)
 {
   const LayerTypeInfo *typeInfo = layerType_getInfo(data->layers[layer_n].type);
 
@@ -3890,7 +3914,7 @@ bool CustomData_layer_has_math(const CustomData *data, int layer_n)
   return false;
 }
 
-bool CustomData_layer_has_interp(const CustomData *data, int layer_n)
+bool CustomData_layer_has_interp(const CustomData *data, const int layer_n)
 {
   const LayerTypeInfo *typeInfo = layerType_getInfo(data->layers[layer_n].type);
 
@@ -4011,7 +4035,7 @@ void CustomData_data_dominmax(int type, const void *data, void *min, void *max)
   }
 }
 
-void CustomData_data_multiply(int type, void *data, float fac)
+void CustomData_data_multiply(int type, void *data, const float fac)
 {
   const LayerTypeInfo *typeInfo = layerType_getInfo(type);
 
@@ -4029,7 +4053,7 @@ void CustomData_data_add(int type, void *data1, const void *data2)
   }
 }
 
-void CustomData_bmesh_set(const CustomData *data, void *block, int type, const void *source)
+void CustomData_bmesh_set(const CustomData *data, void *block, const int type, const void *source)
 {
   void *dest = CustomData_bmesh_get(data, block, type);
   const LayerTypeInfo *typeInfo = layerType_getInfo(type);
@@ -4046,7 +4070,8 @@ void CustomData_bmesh_set(const CustomData *data, void *block, int type, const v
   }
 }
 
-void CustomData_bmesh_set_n(CustomData *data, void *block, int type, int n, const void *source)
+void CustomData_bmesh_set_n(
+    CustomData *data, void *block, const int type, const int n, const void *source)
 {
   void *dest = CustomData_bmesh_get_n(data, block, type, n);
   const LayerTypeInfo *typeInfo = layerType_getInfo(type);
@@ -4063,7 +4088,7 @@ void CustomData_bmesh_set_n(CustomData *data, void *block, int type, int n, cons
   }
 }
 
-void CustomData_bmesh_set_layer_n(CustomData *data, void *block, int n, const void *source)
+void CustomData_bmesh_set_layer_n(CustomData *data, void *block, const int n, const void *source)
 {
   void *dest = CustomData_bmesh_get_layer_n(data, block, n);
   const LayerTypeInfo *typeInfo = layerType_getInfo(data->layers[n].type);
@@ -4317,7 +4342,7 @@ int CustomData_layertype_layers_max(const int type)
   return typeInfo->layers_max();
 }
 
-static bool cd_layer_find_dupe(CustomData *data, const char *name, int type, int index)
+static bool cd_layer_find_dupe(CustomData *data, const char *name, const int type, const int index)
 {
   /* see if there is a duplicate */
   for (int i = 0; i < data->totlayer; i++) {
@@ -4352,7 +4377,7 @@ static bool customdata_unique_check(void *arg, const char *name)
   return cd_layer_find_dupe(data_arg->data, name, data_arg->type, data_arg->index);
 }
 
-void CustomData_set_layer_unique_name(CustomData *data, int index)
+void CustomData_set_layer_unique_name(CustomData *data, const int index)
 {
   CustomDataLayer *nlayer = &data->layers[index];
   const LayerTypeInfo *typeInfo = layerType_getInfo(nlayer->type);
@@ -4397,7 +4422,7 @@ void CustomData_validate_layer_name(const CustomData *data,
   }
 }
 
-bool CustomData_verify_versions(CustomData *data, int index)
+bool CustomData_verify_versions(CustomData *data, const int index)
 {
   const LayerTypeInfo *typeInfo;
   CustomDataLayer *layer = &data->layers[index];
@@ -4556,7 +4581,7 @@ void CustomData_external_reload(CustomData *data,
   }
 }
 
-void CustomData_external_read(CustomData *data, ID *id, eCustomDataMask mask, int totelem)
+void CustomData_external_read(CustomData *data, ID *id, eCustomDataMask mask, const int totelem)
 {
   CustomDataExternal *external = data->external;
   CustomDataLayer *layer;
@@ -4630,7 +4655,7 @@ void CustomData_external_read(CustomData *data, ID *id, eCustomDataMask mask, in
 }
 
 void CustomData_external_write(
-    CustomData *data, ID *id, eCustomDataMask mask, int totelem, int free)
+    CustomData *data, ID *id, eCustomDataMask mask, const int totelem, const int free)
 {
   CustomDataExternal *external = data->external;
   int update = 0;
@@ -4732,8 +4757,11 @@ void CustomData_external_write(
   cdf_free(cdf);
 }
 
-void CustomData_external_add(
-    CustomData *data, ID *UNUSED(id), int type, int UNUSED(totelem), const char *filepath)
+void CustomData_external_add(CustomData *data,
+                             ID *UNUSED(id),
+                             const int type,
+                             const int UNUSED(totelem),
+                             const char *filepath)
 {
   CustomDataExternal *external = data->external;
 
@@ -4757,7 +4785,7 @@ void CustomData_external_add(
   layer->flag |= CD_FLAG_EXTERNAL | CD_FLAG_IN_MEMORY;
 }
 
-void CustomData_external_remove(CustomData *data, ID *id, int type, int totelem)
+void CustomData_external_remove(CustomData *data, ID *id, const int type, const int totelem)
 {
   CustomDataExternal *external = data->external;
 
@@ -4781,7 +4809,7 @@ void CustomData_external_remove(CustomData *data, ID *id, int type, int totelem)
   }
 }
 
-bool CustomData_external_test(CustomData *data, int type)
+bool CustomData_external_test(CustomData *data, const int type)
 {
   int layer_index = CustomData_get_active_layer_index(data, type);
   if (layer_index == -1) {
@@ -5082,7 +5110,10 @@ void CustomData_data_transfer(const MeshPairRemap *me_remap,
 /** \name Custom Data IO
  * \{ */
 
-static void write_mdisps(BlendWriter *writer, int count, const MDisps *mdlist, int external)
+static void write_mdisps(BlendWriter *writer,
+                         const int count,
+                         const MDisps *mdlist,
+                         const int external)
 {
   if (mdlist) {
     BLO_write_struct_array(writer, MDisps, count, mdlist);
@@ -5182,7 +5213,10 @@ void CustomData_blend_write(BlendWriter *writer,
   }
 }
 
-static void blend_read_mdisps(BlendDataReader *reader, int count, MDisps *mdisps, int external)
+static void blend_read_mdisps(BlendDataReader *reader,
+                              const int count,
+                              MDisps *mdisps,
+                              const int external)
 {
   if (mdisps) {
     for (int i = 0; i < count; i++) {
@@ -5224,7 +5258,7 @@ static void blend_read_paint_mask(BlendDataReader *reader,
   }
 }
 
-void CustomData_blend_read(BlendDataReader *reader, CustomData *data, int count)
+void CustomData_blend_read(BlendDataReader *reader, CustomData *data, const int count)
 {
   BLO_read_data_address(reader, &data->layers);