diff --git a/source/blender/blenkernel/BKE_mesh.h b/source/blender/blenkernel/BKE_mesh.h
index a32c3cd462e..ba162782251 100644
--- a/source/blender/blenkernel/BKE_mesh.h
+++ b/source/blender/blenkernel/BKE_mesh.h
@@ -314,7 +314,7 @@ void BKE_mesh_vert_coords_apply(struct Mesh *mesh, const float (*vert_coords)[3]
  * Calculate tessellation into #MLoopTri which exist only for this purpose.
  */
 void BKE_mesh_recalc_looptri(const struct MLoop *mloop,
-                             const struct MPoly *mpoly,
+                             const struct MPoly *polys,
                              const float (*vert_positions)[3],
                              int totloop,
                              int totpoly,
@@ -328,7 +328,7 @@ void BKE_mesh_recalc_looptri(const struct MLoop *mloop,
  * to be calculated which aren't needed for tessellation.
  */
 void BKE_mesh_recalc_looptri_with_normals(const struct MLoop *mloop,
-                                          const struct MPoly *mpoly,
+                                          const struct MPoly *polys,
                                           const float (*vert_positions)[3],
                                           int totloop,
                                           int totpoly,
@@ -409,7 +409,7 @@ bool BKE_mesh_vert_normals_are_dirty(const struct Mesh *mesh);
  */
 bool BKE_mesh_poly_normals_are_dirty(const struct Mesh *mesh);
 
-void BKE_mesh_calc_poly_normal(const struct MPoly *mpoly,
+void BKE_mesh_calc_poly_normal(const struct MPoly *polys,
                                const struct MLoop *loopstart,
                                const float (*vert_positions)[3],
                                float r_no[3]);
@@ -424,8 +424,8 @@ void BKE_mesh_calc_normals_poly(const float (*vert_positions)[3],
                                 int mvert_len,
                                 const struct MLoop *mloop,
                                 int mloop_len,
-                                const struct MPoly *mpoly,
-                                int mpoly_len,
+                                const struct MPoly *polys,
+                                int polys_len,
                                 float (*r_poly_normals)[3]);
 
 /**
@@ -438,8 +438,8 @@ void BKE_mesh_calc_normals_poly_and_vertex(const float (*vert_positions)[3],
                                            int mvert_len,
                                            const struct MLoop *mloop,
                                            int mloop_len,
-                                           const struct MPoly *mpoly,
-                                           int mpoly_len,
+                                           const struct MPoly *polys,
+                                           int polys_len,
                                            float (*r_poly_normals)[3],
                                            float (*r_vert_normals)[3]);
 
@@ -466,7 +466,7 @@ void BKE_mesh_ensure_normals_for_display(struct Mesh *mesh);
 void BKE_edges_sharp_from_angle_set(int numEdges,
                                     const struct MLoop *mloops,
                                     int numLoops,
-                                    const struct MPoly *mpolys,
+                                    const struct MPoly *polys,
                                     const float (*poly_normals)[3],
                                     int numPolys,
                                     float split_angle,
@@ -589,12 +589,12 @@ void BKE_lnor_space_custom_normal_to_data(const MLoopNorSpace *lnor_space,
 void BKE_mesh_normals_loop_split(const float (*vert_positions)[3],
                                  const float (*vert_normals)[3],
                                  int numVerts,
-                                 const struct MEdge *medges,
+                                 const struct MEdge *edges,
                                  int numEdges,
                                  const struct MLoop *mloops,
                                  float (*r_loop_normals)[3],
                                  int numLoops,
-                                 const struct MPoly *mpolys,
+                                 const struct MPoly *polys,
                                  const float (*poly_normals)[3],
                                  int numPolys,
                                  bool use_split_normals,
@@ -607,12 +607,12 @@ void BKE_mesh_normals_loop_split(const float (*vert_positions)[3],
 void BKE_mesh_normals_loop_custom_set(const float (*vert_positions)[3],
                                       const float (*vert_normals)[3],
                                       int numVerts,
-                                      const struct MEdge *medges,
+                                      const struct MEdge *edges,
                                       int numEdges,
                                       const struct MLoop *mloops,
                                       float (*r_custom_loop_normals)[3],
                                       int numLoops,
-                                      const struct MPoly *mpolys,
+                                      const struct MPoly *polys,
                                       const float (*poly_normals)[3],
                                       int numPolys,
                                       bool *sharp_edges,
@@ -621,11 +621,11 @@ void BKE_mesh_normals_loop_custom_from_verts_set(const float (*vert_positions)[3
                                                  const float (*vert_normals)[3],
                                                  float (*r_custom_vert_normals)[3],
                                                  int numVerts,
-                                                 const struct MEdge *medges,
+                                                 const struct MEdge *edges,
                                                  int numEdges,
                                                  const struct MLoop *mloops,
                                                  int numLoops,
-                                                 const struct MPoly *mpolys,
+                                                 const struct MPoly *polys,
                                                  const float (*poly_normals)[3],
                                                  int numPolys,
                                                  bool *sharp_edges,
@@ -679,16 +679,16 @@ void BKE_mesh_set_custom_normals_from_verts(struct Mesh *mesh, float (*r_custom_
 
 /* *** mesh_evaluate.cc *** */
 
-void BKE_mesh_calc_poly_center(const struct MPoly *mpoly,
+void BKE_mesh_calc_poly_center(const struct MPoly *poly,
                                const struct MLoop *loopstart,
                                const float (*vert_positions)[3],
                                float r_cent[3]);
 /* NOTE: passing poly-normal is only a speedup so we can skip calculating it. */
-float BKE_mesh_calc_poly_area(const struct MPoly *mpoly,
+float BKE_mesh_calc_poly_area(const struct MPoly *poly,
                               const struct MLoop *loopstart,
                               const float (*vert_positions)[3]);
 float BKE_mesh_calc_area(const struct Mesh *me);
-void BKE_mesh_calc_poly_angles(const struct MPoly *mpoly,
+void BKE_mesh_calc_poly_angles(const struct MPoly *poly,
                                const struct MLoop *loopstart,
                                const float (*vert_positions)[3],
                                float angles[]);
@@ -735,20 +735,20 @@ void BKE_mesh_calc_volume(const float (*vert_positions)[3],
 void BKE_mesh_mdisp_flip(struct MDisps *md, bool use_loop_mdisp_flip);
 
 /**
- * Flip (invert winding of) the given \a mpoly, i.e. reverse order of its loops
+ * Flip (invert winding of) the given \a poly, i.e. reverse order of its loops
  * (keeping the same vertex as 'start point').
  *
- * \param mpoly: the polygon to flip.
+ * \param poly: the polygon to flip.
  * \param mloop: the full loops array.
  * \param ldata: the loops custom data.
  */
-void BKE_mesh_polygon_flip_ex(const struct MPoly *mpoly,
+void BKE_mesh_polygon_flip_ex(const struct MPoly *poly,
                               struct MLoop *mloop,
                               struct CustomData *ldata,
                               float (*lnors)[3],
                               struct MDisps *mdisp,
                               bool use_loop_mdisp_flip);
-void BKE_mesh_polygon_flip(const struct MPoly *mpoly,
+void BKE_mesh_polygon_flip(const struct MPoly *poly,
                            struct MLoop *mloop,
                            struct CustomData *ldata,
                            int totloop);
@@ -757,7 +757,7 @@ void BKE_mesh_polygon_flip(const struct MPoly *mpoly,
  *
  * \note Invalidates tessellation, caller must handle that.
  */
-void BKE_mesh_polys_flip(const struct MPoly *mpoly,
+void BKE_mesh_polys_flip(const struct MPoly *polys,
                          struct MLoop *mloop,
                          struct CustomData *ldata,
                          int totpoly);
@@ -793,7 +793,7 @@ void BKE_mesh_flush_select_from_verts(struct Mesh *me);
  * \param vert_cos_org: reference for the output location.
  * \param vert_cos_new: resulting coords.
  */
-void BKE_mesh_calc_relative_deform(const struct MPoly *mpoly,
+void BKE_mesh_calc_relative_deform(const struct MPoly *polys,
                                    int totpoly,
                                    const struct MLoop *mloop,
                                    int totvert,
@@ -841,13 +841,13 @@ bool BKE_mesh_validate_material_indices(struct Mesh *me);
 bool BKE_mesh_validate_arrays(struct Mesh *me,
                               float (*vert_positions)[3],
                               unsigned int totvert,
-                              struct MEdge *medges,
+                              struct MEdge *edges,
                               unsigned int totedge,
                               struct MFace *mfaces,
                               unsigned int totface,
                               struct MLoop *mloops,
                               unsigned int totloop,
-                              struct MPoly *mpolys,
+                              struct MPoly *polys,
                               unsigned int totpoly,
                               struct MDeformVert *dverts, /* assume totvert length */
                               bool do_verbose,
diff --git a/source/blender/blenkernel/BKE_mesh_mapping.h b/source/blender/blenkernel/BKE_mesh_mapping.h
index 98ceb6a49d1..3835e3f78e2 100644
--- a/source/blender/blenkernel/BKE_mesh_mapping.h
+++ b/source/blender/blenkernel/BKE_mesh_mapping.h
@@ -101,7 +101,7 @@ typedef struct MeshElemMap {
 
 /* mapping */
 
-UvVertMap *BKE_mesh_uv_vert_map_create(const struct MPoly *mpoly,
+UvVertMap *BKE_mesh_uv_vert_map_create(const struct MPoly *polys,
                                        const bool *hide_poly,
                                        const bool *select_poly,
                                        const struct MLoop *mloop,
@@ -121,7 +121,7 @@ void BKE_mesh_uv_vert_map_free(UvVertMap *vmap);
  */
 void BKE_mesh_vert_poly_map_create(MeshElemMap **r_map,
                                    int **r_mem,
-                                   const struct MPoly *mpoly,
+                                   const struct MPoly *polys,
                                    const struct MLoop *mloop,
                                    int totvert,
                                    int totpoly,
@@ -133,7 +133,7 @@ void BKE_mesh_vert_poly_map_create(MeshElemMap **r_map,
  */
 void BKE_mesh_vert_loop_map_create(MeshElemMap **r_map,
                                    int **r_mem,
-                                   const struct MPoly *mpoly,
+                                   const struct MPoly *polys,
                                    const struct MLoop *mloop,
                                    int totvert,
                                    int totpoly,
@@ -156,13 +156,13 @@ void BKE_mesh_vert_looptri_map_create(MeshElemMap **r_map,
  * The lists are allocated from one memory pool.
  */
 void BKE_mesh_vert_edge_map_create(
-    MeshElemMap **r_map, int **r_mem, const struct MEdge *medge, int totvert, int totedge);
+    MeshElemMap **r_map, int **r_mem, const struct MEdge *edges, int totvert, int totedge);
 /**
  * A version of #BKE_mesh_vert_edge_map_create that references connected vertices directly
  * (not their edges).
  */
 void BKE_mesh_vert_edge_vert_map_create(
-    MeshElemMap **r_map, int **r_mem, const struct MEdge *medge, int totvert, int totedge);
+    MeshElemMap **r_map, int **r_mem, const struct MEdge *edges, int totvert, int totedge);
 /**
  * Generates a map where the key is the edge and the value is a list of loops that use that edge.
  * Loops indices of a same poly are contiguous and in winding order.
@@ -171,7 +171,7 @@ void BKE_mesh_vert_edge_vert_map_create(
 void BKE_mesh_edge_loop_map_create(MeshElemMap **r_map,
                                    int **r_mem,
                                    int totedge,
-                                   const struct MPoly *mpoly,
+                                   const struct MPoly *polys,
                                    int totpoly,
                                    const struct MLoop *mloop,
                                    int totloop);
@@ -183,7 +183,7 @@ void BKE_mesh_edge_loop_map_create(MeshElemMap **r_map,
 void BKE_mesh_edge_poly_map_create(MeshElemMap **r_map,
                                    int **r_mem,
                                    int totedge,
-                                   const struct MPoly *mpoly,
+                                   const struct MPoly *polys,
                                    int totpoly,
                                    const struct MLoop *mloop,
                                    int totloop);
@@ -209,8 +209,8 @@ void BKE_mesh_origindex_map_create(
  */
 void BKE_mesh_origindex_map_create_looptri(MeshElemMap **r_map,
                                            int **r_mem,
-                                           const struct MPoly *mpoly,
-                                           int mpoly_num,
+                                           const struct MPoly *polys,
+                                           int polys_num,
                                            const struct MLoopTri *looptri,
                                            int looptri_num);
 
@@ -319,7 +319,7 @@ bool BKE_mesh_calc_islands_loop_poly_uvmap(float (*vert_positions)[3],
  * Note it's callers's responsibility to MEM_freeN returned array.
  */
 int *BKE_mesh_calc_smoothgroups(int totedge,
-                                const struct MPoly *mpoly,
+                                const struct MPoly *polys,
                                 int totpoly,
                                 const struct MLoop *mloop,
                                 int totloop,
diff --git a/source/blender/blenkernel/BKE_mesh_tangent.h b/source/blender/blenkernel/BKE_mesh_tangent.h
index b30ce13da8d..0a4201eadff 100644
--- a/source/blender/blenkernel/BKE_mesh_tangent.h
+++ b/source/blender/blenkernel/BKE_mesh_tangent.h
@@ -24,7 +24,7 @@ void BKE_mesh_calc_loop_tangent_single_ex(const float (*vert_positions)[3],
                                           const float (*loop_normals)[3],
                                           const float (*loopuv)[2],
                                           int numLoops,
-                                          const struct MPoly *mpolys,
+                                          const struct MPoly *polys,
                                           int numPolys,
                                           struct ReportList *reports);
 /**
@@ -42,8 +42,8 @@ void BKE_mesh_calc_loop_tangent_single(struct Mesh *mesh,
  * See: #BKE_editmesh_loop_tangent_calc (matching logic).
  */
 void BKE_mesh_calc_loop_tangent_ex(const float (*vert_positions)[3],
-                                   const struct MPoly *mpoly,
-                                   uint mpoly_len,
+                                   const struct MPoly *polys,
+                                   uint polys_len,
                                    const struct MLoop *mloop,
                                    const struct MLoopTri *looptri,
                                    uint looptri_len,
diff --git a/source/blender/blenkernel/BKE_multires.h b/source/blender/blenkernel/BKE_multires.h
index 5faafbe957c..3a90a8edfc2 100644
--- a/source/blender/blenkernel/BKE_multires.h
+++ b/source/blender/blenkernel/BKE_multires.h
@@ -154,7 +154,7 @@ void old_mdisps_bilinear(float out[3], float (*disps)[3], int st, float u, float
  * Find per-corner coordinate with given per-face UV coord.
  */
 int mdisp_rot_face_to_crn(
-    struct MPoly *mpoly, int face_side, float u, float v, float *x, float *y);
+    struct MPoly *poly, int face_side, float u, float v, float *x, float *y);
 
 /* Reshaping, define in multires_reshape.cc */
 
diff --git a/source/blender/blenkernel/BKE_paint.h b/source/blender/blenkernel/BKE_paint.h
index 0247bfcf673..a9ac01c9f73 100644
--- a/source/blender/blenkernel/BKE_paint.h
+++ b/source/blender/blenkernel/BKE_paint.h
@@ -577,7 +577,7 @@ typedef struct SculptSession {
 
   /* These are always assigned to base mesh data when using PBVH_FACES and PBVH_GRIDS. */
   float (*vert_positions)[3];
-  const struct MPoly *mpoly;
+  const struct MPoly *polys;
   const struct MLoop *mloop;
 
   /* These contain the vertex and poly counts of the final mesh. */
diff --git a/source/blender/blenkernel/BKE_pbvh.h b/source/blender/blenkernel/BKE_pbvh.h
index 12a55151c9b..2a7aca450ba 100644
--- a/source/blender/blenkernel/BKE_pbvh.h
+++ b/source/blender/blenkernel/BKE_pbvh.h
@@ -288,7 +288,7 @@ PBVH *BKE_pbvh_new(PBVHType type);
  */
 void BKE_pbvh_build_mesh(PBVH *pbvh,
                          struct Mesh *mesh,
-                         const struct MPoly *mpoly,
+                         const struct MPoly *polys,
                          const struct MLoop *mloop,
                          float (*vert_positions)[3],
                          int totvert,
@@ -735,7 +735,7 @@ typedef struct PBVHFaceIter {
   int cd_hide_poly_, cd_face_set_;
   bool *hide_poly_;
   int *face_sets_;
-  const struct MPoly *mpoly_;
+  const struct MPoly *polys_;
   const struct MLoopTri *looptri_;
   const struct MLoop *mloop_;
   int prim_index_;
diff --git a/source/blender/blenkernel/BKE_subdiv_ccg.h b/source/blender/blenkernel/BKE_subdiv_ccg.h
index ced7ff2aa71..582e0774a58 100644
--- a/source/blender/blenkernel/BKE_subdiv_ccg.h
+++ b/source/blender/blenkernel/BKE_subdiv_ccg.h
@@ -311,7 +311,7 @@ typedef enum SubdivCCGAdjacencyType {
 SubdivCCGAdjacencyType BKE_subdiv_ccg_coarse_mesh_adjacency_info_get(const SubdivCCG *subdiv_ccg,
                                                                      const SubdivCCGCoord *coord,
                                                                      const struct MLoop *mloop,
-                                                                     const struct MPoly *mpoly,
+                                                                     const struct MPoly *polys,
                                                                      int *r_v1,
                                                                      int *r_v2);
 
diff --git a/source/blender/blenkernel/intern/DerivedMesh.cc b/source/blender/blenkernel/intern/DerivedMesh.cc
index 4cdf8b215c1..9b2d98d5af9 100644
--- a/source/blender/blenkernel/intern/DerivedMesh.cc
+++ b/source/blender/blenkernel/intern/DerivedMesh.cc
@@ -109,17 +109,17 @@ static float *dm_getVertArray(DerivedMesh *dm)
 
 static MEdge *dm_getEdgeArray(DerivedMesh *dm)
 {
-  MEdge *medge = (MEdge *)CustomData_get_layer_for_write(
+  MEdge *edge = (MEdge *)CustomData_get_layer_for_write(
       &dm->edgeData, CD_MEDGE, dm->getNumEdges(dm));
 
-  if (!medge) {
-    medge = (MEdge *)CustomData_add_layer(
+  if (!edge) {
+    edge = (MEdge *)CustomData_add_layer(
         &dm->edgeData, CD_MEDGE, CD_SET_DEFAULT, nullptr, dm->getNumEdges(dm));
     CustomData_set_layer_flag(&dm->edgeData, CD_MEDGE, CD_FLAG_TEMPORARY);
-    dm->copyEdgeArray(dm, medge);
+    dm->copyEdgeArray(dm, edge);
   }
 
-  return medge;
+  return edge;
 }
 
 static MLoop *dm_getLoopArray(DerivedMesh *dm)
@@ -1901,21 +1901,21 @@ static void mesh_init_origspace(Mesh *mesh)
   const Span<MPoly> polys = mesh->polys();
   const Span<MLoop> loops = mesh->loops();
 
-  const MPoly *mp = polys.data();
+  const MPoly *poly = polys.data();
   int i, j, k;
 
   blender::Vector<blender::float2, 64> vcos_2d;
 
-  for (i = 0; i < numpoly; i++, mp++) {
-    OrigSpaceLoop *lof = lof_array + mp->loopstart;
+  for (i = 0; i < numpoly; i++, poly++) {
+    OrigSpaceLoop *lof = lof_array + poly->loopstart;
 
-    if (ELEM(mp->totloop, 3, 4)) {
-      for (j = 0; j < mp->totloop; j++, lof++) {
+    if (ELEM(poly->totloop, 3, 4)) {
+      for (j = 0; j < poly->totloop; j++, lof++) {
         copy_v2_v2(lof->uv, default_osf[j]);
       }
     }
     else {
-      const MLoop *l = &loops[mp->loopstart];
+      const MLoop *l = &loops[poly->loopstart];
       float p_nor[3], co[3];
       float mat[3][3];
 
@@ -1923,11 +1923,11 @@ static void mesh_init_origspace(Mesh *mesh)
       float translate[2], scale[2];
 
       BKE_mesh_calc_poly_normal(
-          mp, l, reinterpret_cast<const float(*)[3]>(positions.data()), p_nor);
+          poly, l, reinterpret_cast<const float(*)[3]>(positions.data()), p_nor);
       axis_dominant_v3_to_m3(mat, p_nor);
 
-      vcos_2d.resize(mp->totloop);
-      for (j = 0; j < mp->totloop; j++, l++) {
+      vcos_2d.resize(poly->totloop);
+      for (j = 0; j < poly->totloop; j++, l++) {
         mul_v3_m3v3(co, mat, positions[l->v]);
         copy_v2_v2(vcos_2d[j], co);
 
@@ -1956,7 +1956,7 @@ static void mesh_init_origspace(Mesh *mesh)
 
       /* Finally, transform all vcos_2d into ((0, 0), (1, 1))
        * square and assign them as origspace. */
-      for (j = 0; j < mp->totloop; j++, lof++) {
+      for (j = 0; j < poly->totloop; j++, lof++) {
         add_v2_v2v2(lof->uv, vcos_2d[j], translate);
         mul_v2_v2(lof->uv, scale);
       }
diff --git a/source/blender/blenkernel/intern/deform.cc b/source/blender/blenkernel/intern/deform.cc
index dda4d098126..90e5c9b8041 100644
--- a/source/blender/blenkernel/intern/deform.cc
+++ b/source/blender/blenkernel/intern/deform.cc
@@ -1059,9 +1059,9 @@ void BKE_defvert_extract_vgroup_to_edgeweights(const MDeformVert *dvert,
         dvert, defgroup, verts_num, invert_vgroup, tmp_weights);
 
     while (i--) {
-      const MEdge *me = &edges[i];
+      const MEdge *edge = &edges[i];
 
-      r_weights[i] = (tmp_weights[me->v1] + tmp_weights[me->v2]) * 0.5f;
+      r_weights[i] = (tmp_weights[edge->v1] + tmp_weights[edge->v2]) * 0.5f;
     }
 
     MEM_freeN(tmp_weights);
@@ -1119,15 +1119,15 @@ void BKE_defvert_extract_vgroup_to_polyweights(const MDeformVert *dvert,
         dvert, defgroup, verts_num, invert_vgroup, tmp_weights);
 
     while (i--) {
-      const MPoly *mp = &polys[i];
-      const MLoop *ml = &loops[mp->loopstart];
-      int j = mp->totloop;
+      const MPoly *poly = &polys[i];
+      const MLoop *ml = &loops[poly->loopstart];
+      int j = poly->totloop;
       float w = 0.0f;
 
       for (; j--; ml++) {
         w += tmp_weights[ml->v];
       }
-      r_weights[i] = w / float(mp->totloop);
+      r_weights[i] = w / float(poly->totloop);
     }
 
     MEM_freeN(tmp_weights);
diff --git a/source/blender/blenkernel/intern/fluid.cc b/source/blender/blenkernel/intern/fluid.cc
index c6f481acc4f..0bc2564a8ba 100644
--- a/source/blender/blenkernel/intern/fluid.cc
+++ b/source/blender/blenkernel/intern/fluid.cc
@@ -3215,11 +3215,9 @@ static Mesh *create_liquid_geometry(FluidDomainSettings *fds,
 
   /* Assign material + flags to new mesh.
    * If there are no faces in original mesh, keep materials and flags unchanged. */
-  MPoly *mpoly;
   MPoly mp_example = {0};
-  mpoly = BKE_mesh_polys_for_write(orgmesh);
-  if (mpoly) {
-    mp_example = *mpoly;
+  if (MPoly *polys = BKE_mesh_polys_for_write(orgmesh)) {
+    mp_example = *polys;
   }
 
   const int *orig_material_indices = BKE_mesh_material_indices(orgmesh);
@@ -3368,7 +3366,7 @@ static Mesh *create_smoke_geometry(FluidDomainSettings *fds, Mesh *orgmesh, Obje
   float min[3];
   float max[3];
   float *co;
-  MPoly *mp;
+  MPoly *poly;
   MLoop *ml;
 
   int num_verts = 8;
@@ -3429,55 +3427,55 @@ static Mesh *create_smoke_geometry(FluidDomainSettings *fds, Mesh *orgmesh, Obje
 
     /* Create faces. */
     /* Top side. */
-    mp = &polys[0];
+    poly = &polys[0];
     ml = &loops[0 * 4];
-    mp->loopstart = 0 * 4;
-    mp->totloop = 4;
+    poly->loopstart = 0 * 4;
+    poly->totloop = 4;
     ml[0].v = 0;
     ml[1].v = 1;
     ml[2].v = 2;
     ml[3].v = 3;
     /* Right side. */
-    mp = &polys[1];
+    poly = &polys[1];
     ml = &loops[1 * 4];
-    mp->loopstart = 1 * 4;
-    mp->totloop = 4;
+    poly->loopstart = 1 * 4;
+    poly->totloop = 4;
     ml[0].v = 2;
     ml[1].v = 1;
     ml[2].v = 5;
     ml[3].v = 6;
     /* Bottom side. */
-    mp = &polys[2];
+    poly = &polys[2];
     ml = &loops[2 * 4];
-    mp->loopstart = 2 * 4;
-    mp->totloop = 4;
+    poly->loopstart = 2 * 4;
+    poly->totloop = 4;
     ml[0].v = 7;
     ml[1].v = 6;
     ml[2].v = 5;
     ml[3].v = 4;
     /* Left side. */
-    mp = &polys[3];
+    poly = &polys[3];
     ml = &loops[3 * 4];
-    mp->loopstart = 3 * 4;
-    mp->totloop = 4;
+    poly->loopstart = 3 * 4;
+    poly->totloop = 4;
     ml[0].v = 0;
     ml[1].v = 3;
     ml[2].v = 7;
     ml[3].v = 4;
     /* Front side. */
-    mp = &polys[4];
+    poly = &polys[4];
     ml = &loops[4 * 4];
-    mp->loopstart = 4 * 4;
-    mp->totloop = 4;
+    poly->loopstart = 4 * 4;
+    poly->totloop = 4;
     ml[0].v = 3;
     ml[1].v = 2;
     ml[2].v = 6;
     ml[3].v = 7;
     /* Back side. */
-    mp = &polys[5];
+    poly = &polys[5];
     ml = &loops[5 * 4];
-    mp->loopstart = 5 * 4;
-    mp->totloop = 4;
+    poly->loopstart = 5 * 4;
+    poly->totloop = 4;
     ml[0].v = 1;
     ml[1].v = 0;
     ml[2].v = 4;
diff --git a/source/blender/blenkernel/intern/geometry_component_mesh.cc b/source/blender/blenkernel/intern/geometry_component_mesh.cc
index 97db3b9565f..a91a615532f 100644
--- a/source/blender/blenkernel/intern/geometry_component_mesh.cc
+++ b/source/blender/blenkernel/intern/geometry_component_mesh.cc
@@ -913,14 +913,14 @@ static void tag_component_positions_changed(void *owner)
   }
 }
 
-static bool get_shade_smooth(const MPoly &mpoly)
+static bool get_shade_smooth(const MPoly &poly)
 {
-  return mpoly.flag & ME_SMOOTH;
+  return poly.flag & ME_SMOOTH;
 }
 
-static void set_shade_smooth(MPoly &mpoly, bool value)
+static void set_shade_smooth(MPoly &poly, bool value)
 {
-  SET_FLAG_FROM_TEST(mpoly.flag, value, ME_SMOOTH);
+  SET_FLAG_FROM_TEST(poly.flag, value, ME_SMOOTH);
 }
 
 static float get_crease(const float &crease)
diff --git a/source/blender/blenkernel/intern/gpencil_geom.cc b/source/blender/blenkernel/intern/gpencil_geom.cc
index b83c4b8f859..012605c21f0 100644
--- a/source/blender/blenkernel/intern/gpencil_geom.cc
+++ b/source/blender/blenkernel/intern/gpencil_geom.cc
@@ -2519,18 +2519,18 @@ static void gpencil_generate_edgeloops(Object *ob,
   GpEdge *gp_edges = (GpEdge *)MEM_callocN(sizeof(GpEdge) * me->totedge, __func__);
   GpEdge *gped = nullptr;
   for (int i = 0; i < me->totedge; i++) {
-    const MEdge *ed = &edges[i];
+    const MEdge *edge = &edges[i];
     gped = &gp_edges[i];
-    copy_v3_v3(gped->n1, vert_normals[ed->v1]);
+    copy_v3_v3(gped->n1, vert_normals[edge->v1]);
 
-    gped->v1 = ed->v1;
-    copy_v3_v3(gped->v1_co, vert_positions[ed->v1]);
+    gped->v1 = edge->v1;
+    copy_v3_v3(gped->v1_co, vert_positions[edge->v1]);
 
-    copy_v3_v3(gped->n2, vert_normals[ed->v2]);
-    gped->v2 = ed->v2;
-    copy_v3_v3(gped->v2_co, vert_positions[ed->v2]);
+    copy_v3_v3(gped->n2, vert_normals[edge->v2]);
+    gped->v2 = edge->v2;
+    copy_v3_v3(gped->v2_co, vert_positions[edge->v2]);
 
-    sub_v3_v3v3(gped->vec, vert_positions[ed->v1], vert_positions[ed->v2]);
+    sub_v3_v3v3(gped->vec, vert_positions[edge->v1], vert_positions[edge->v2]);
 
     /* If use seams, mark as done if not a seam. */
     if ((use_seams) && !uv_seams[i]) {
@@ -2715,7 +2715,7 @@ bool BKE_gpencil_convert_mesh(Main *bmain,
   const Span<float3> positions = me_eval->vert_positions();
   const Span<MPoly> polys = me_eval->polys();
   const Span<MLoop> loops = me_eval->loops();
-  int mpoly_len = me_eval->totpoly;
+  int polys_len = me_eval->totpoly;
   char element_name[200];
 
   /* Need at least an edge. */
@@ -2739,7 +2739,7 @@ bool BKE_gpencil_convert_mesh(Main *bmain,
   }
 
   /* Export faces as filled strokes. */
-  if (use_faces && mpoly_len > 0) {
+  if (use_faces && polys_len > 0) {
     /* Read all polygons and create fill for each. */
     make_element_name(ob_mesh->id.name + 2, "Fills", 128, element_name);
     /* Create Layer and Frame. */
@@ -2753,8 +2753,8 @@ bool BKE_gpencil_convert_mesh(Main *bmain,
 
     const VArray<int> mesh_material_indices = me_eval->attributes().lookup_or_default<int>(
         "material_index", ATTR_DOMAIN_FACE, 0);
-    for (i = 0; i < mpoly_len; i++) {
-      const MPoly *mp = &polys[i];
+    for (i = 0; i < polys_len; i++) {
+      const MPoly *poly = &polys[i];
 
       /* Find material. */
       int mat_idx = 0;
@@ -2774,19 +2774,19 @@ bool BKE_gpencil_convert_mesh(Main *bmain,
         gpencil_add_material(bmain, ob_gp, element_name, color, false, true, &mat_idx);
       }
 
-      bGPDstroke *gps_fill = BKE_gpencil_stroke_add(gpf_fill, mat_idx, mp->totloop, 10, false);
+      bGPDstroke *gps_fill = BKE_gpencil_stroke_add(gpf_fill, mat_idx, poly->totloop, 10, false);
       gps_fill->flag |= GP_STROKE_CYCLIC;
 
       /* Create dvert data. */
       const Span<MDeformVert> dverts = me_eval->deform_verts();
       if (use_vgroups && !dverts.is_empty()) {
-        gps_fill->dvert = (MDeformVert *)MEM_callocN(sizeof(MDeformVert) * mp->totloop,
+        gps_fill->dvert = (MDeformVert *)MEM_callocN(sizeof(MDeformVert) * poly->totloop,
                                                      "gp_fill_dverts");
       }
 
       /* Add points to strokes. */
-      for (int j = 0; j < mp->totloop; j++) {
-        const MLoop *ml = &loops[mp->loopstart + j];
+      for (int j = 0; j < poly->totloop; j++) {
+        const MLoop *ml = &loops[poly->loopstart + j];
 
         bGPDspoint *pt = &gps_fill->points[j];
         copy_v3_v3(&pt->x, positions[ml->v]);
@@ -2808,7 +2808,7 @@ bool BKE_gpencil_convert_mesh(Main *bmain,
         }
       }
       /* If has only 3 points subdivide. */
-      if (mp->totloop == 3) {
+      if (poly->totloop == 3) {
         BKE_gpencil_stroke_subdivide(gpd, gps_fill, 1, GP_SUBDIV_SIMPLE);
       }
 
diff --git a/source/blender/blenkernel/intern/mball_tessellate.cc b/source/blender/blenkernel/intern/mball_tessellate.cc
index d8377882ca7..839834a8326 100644
--- a/source/blender/blenkernel/intern/mball_tessellate.cc
+++ b/source/blender/blenkernel/intern/mball_tessellate.cc
@@ -1468,7 +1468,7 @@ Mesh *BKE_mball_polygonize(Depsgraph *depsgraph, Scene *scene, Object *ob)
   process.co = nullptr;
 
   mesh->totpoly = int(process.curindex);
-  MPoly *mpoly = static_cast<MPoly *>(
+  MPoly *polys = static_cast<MPoly *>(
       CustomData_add_layer(&mesh->pdata, CD_MPOLY, CD_CONSTRUCT, nullptr, mesh->totpoly));
   MLoop *mloop = static_cast<MLoop *>(
       CustomData_add_layer(&mesh->ldata, CD_MLOOP, CD_CONSTRUCT, nullptr, mesh->totpoly * 4));
@@ -1478,9 +1478,9 @@ Mesh *BKE_mball_polygonize(Depsgraph *depsgraph, Scene *scene, Object *ob)
     const int *indices = process.indices[i];
 
     const int count = indices[2] != indices[3] ? 4 : 3;
-    mpoly[i].loopstart = loop_offset;
-    mpoly[i].totloop = count;
-    mpoly[i].flag = ME_SMOOTH;
+    polys[i].loopstart = loop_offset;
+    polys[i].totloop = count;
+    polys[i].flag = ME_SMOOTH;
 
     mloop[loop_offset].v = uint32_t(indices[0]);
     mloop[loop_offset + 1].v = uint32_t(indices[1]);
diff --git a/source/blender/blenkernel/intern/mesh.cc b/source/blender/blenkernel/intern/mesh.cc
index 8a75c24f4f2..0549bee5a5b 100644
--- a/source/blender/blenkernel/intern/mesh.cc
+++ b/source/blender/blenkernel/intern/mesh.cc
@@ -1535,13 +1535,13 @@ int poly_get_adj_loops_from_vert(const MPoly *poly, const MLoop *mloop, int vert
   return corner;
 }
 
-int BKE_mesh_edge_other_vert(const MEdge *e, int v)
+int BKE_mesh_edge_other_vert(const MEdge *edge, int v)
 {
-  if (e->v1 == v) {
-    return e->v2;
+  if (edge->v1 == v) {
+    return edge->v2;
   }
-  if (e->v2 == v) {
-    return e->v1;
+  if (edge->v2 == v) {
+    return edge->v1;
   }
 
   return -1;
@@ -1554,9 +1554,10 @@ void BKE_mesh_looptri_get_real_edges(const MEdge *edges,
 {
   for (int i = 2, i_next = 0; i_next < 3; i = i_next++) {
     const MLoop *l1 = &loops[tri->tri[i]], *l2 = &loops[tri->tri[i_next]];
-    const MEdge *e = &edges[l1->e];
+    const MEdge *edge = &edges[l1->e];
 
-    bool is_real = (l1->v == e->v1 && l2->v == e->v2) || (l1->v == e->v2 && l2->v == e->v1);
+    bool is_real = (l1->v == edge->v1 && l2->v == edge->v2) ||
+                   (l1->v == edge->v2 && l2->v == edge->v1);
 
     r_edges[i] = is_real ? l1->e : -1;
   }
diff --git a/source/blender/blenkernel/intern/mesh_boolean_convert.cc b/source/blender/blenkernel/intern/mesh_boolean_convert.cc
index c4e6eca8ff7..ec23aefe400 100644
--- a/source/blender/blenkernel/intern/mesh_boolean_convert.cc
+++ b/source/blender/blenkernel/intern/mesh_boolean_convert.cc
@@ -164,7 +164,7 @@ const MPoly *MeshesToIMeshInfo::input_mpoly_for_orig_index(int orig_index,
   const Span<MPoly> polys = me->polys();
   int index_in_mesh = orig_index - mesh_poly_offset[orig_mesh_index];
   BLI_assert(0 <= index_in_mesh && index_in_mesh < me->totpoly);
-  const MPoly *mp = &polys[index_in_mesh];
+  const MPoly *poly = &polys[index_in_mesh];
   if (r_orig_mesh) {
     *r_orig_mesh = me;
   }
@@ -174,7 +174,7 @@ const MPoly *MeshesToIMeshInfo::input_mpoly_for_orig_index(int orig_index,
   if (r_index_in_orig_mesh) {
     *r_index_in_orig_mesh = index_in_mesh;
   }
-  return mp;
+  return poly;
 }
 
 /* Given an index of an original vertex in the `IMesh`, find out the input
@@ -391,15 +391,15 @@ static void copy_vert_attributes(Mesh *dest_mesh,
 
 /* Similar to copy_vert_attributes but for poly attributes. */
 static void copy_poly_attributes(Mesh *dest_mesh,
-                                 MPoly *mp,
-                                 const MPoly *orig_mp,
+                                 MPoly *poly,
+                                 const MPoly *orig_poly,
                                  const Mesh *orig_me,
-                                 int mp_index,
+                                 int poly_index,
                                  int index_in_orig_me,
                                  Span<short> material_remap,
                                  MutableSpan<int> dst_material_indices)
 {
-  mp->flag = orig_mp->flag;
+  poly->flag = orig_poly->flag;
   CustomData *target_cd = &dest_mesh->pdata;
   const CustomData *source_cd = &orig_me->pdata;
   for (int source_layer_i = 0; source_layer_i < source_cd->totlayer; ++source_layer_i) {
@@ -411,7 +411,7 @@ static void copy_poly_attributes(Mesh *dest_mesh,
     int target_layer_i = CustomData_get_named_layer_index(target_cd, ty, name);
     if (target_layer_i != -1) {
       CustomData_copy_data_layer(
-          source_cd, target_cd, source_layer_i, target_layer_i, index_in_orig_me, mp_index, 1);
+          source_cd, target_cd, source_layer_i, target_layer_i, index_in_orig_me, poly_index, 1);
     }
   }
 
@@ -421,12 +421,12 @@ static void copy_poly_attributes(Mesh *dest_mesh,
   const int src_index = src_material_indices[index_in_orig_me];
   if (material_remap.index_range().contains(src_index)) {
     const int remapped_index = material_remap[src_index];
-    dst_material_indices[mp_index] = remapped_index >= 0 ? remapped_index : src_index;
+    dst_material_indices[poly_index] = remapped_index >= 0 ? remapped_index : src_index;
   }
   else {
-    dst_material_indices[mp_index] = src_index;
+    dst_material_indices[poly_index] = src_index;
   }
-  BLI_assert(dst_material_indices[mp_index] >= 0);
+  BLI_assert(dst_material_indices[poly_index] >= 0);
 }
 
 /* Similar to copy_vert_attributes but for edge attributes. */
@@ -452,17 +452,17 @@ static void copy_edge_attributes(Mesh *dest_mesh,
 }
 
 /**
- * For #IMesh face `f`, with corresponding output Mesh poly `mp`,
- * where the original Mesh poly is `orig_mp`, coming from the Mesh
+ * For #IMesh face `f`, with corresponding output Mesh poly `poly`,
+ * where the original Mesh poly is `orig_poly`, coming from the Mesh
  * `orig_me`, which has index `orig_me_index` in `mim`:
  * fill in the `orig_loops` Array with corresponding indices of MLoops from `orig_me`
  * where they have the same start and end vertices; for cases where that is
  * not true, put -1 in the `orig_loops` slot.
- * For now, we only try to do this if `mp` and `orig_mp` have the same size.
+ * For now, we only try to do this if `poly` and `orig_poly` have the same size.
  * Return the number of non-null MLoops filled in.
  */
 static int fill_orig_loops(const Face *f,
-                           const MPoly *orig_mp,
+                           const MPoly *orig_poly,
                            const Mesh *orig_me,
                            int orig_me_index,
                            MeshesToIMeshInfo &mim,
@@ -471,7 +471,7 @@ static int fill_orig_loops(const Face *f,
   r_orig_loops.fill(-1);
   const Span<MLoop> orig_loops = orig_me->loops();
 
-  int orig_mplen = orig_mp->totloop;
+  int orig_mplen = orig_poly->totloop;
   if (f->size() != orig_mplen) {
     return 0;
   }
@@ -496,7 +496,7 @@ static int fill_orig_loops(const Face *f,
   /* Assume all vertices in an mpoly are unique. */
   int offset = -1;
   for (int i = 0; i < orig_mplen; ++i) {
-    int loop_i = i + orig_mp->loopstart;
+    int loop_i = i + orig_poly->loopstart;
     if (orig_loops[loop_i].v == first_orig_v_in_orig_me) {
       offset = i;
       break;
@@ -508,7 +508,7 @@ static int fill_orig_loops(const Face *f,
   int num_orig_loops_found = 0;
   for (int mp_loop_index = 0; mp_loop_index < orig_mplen; ++mp_loop_index) {
     int orig_mp_loop_index = (mp_loop_index + offset) % orig_mplen;
-    const MLoop *l = &orig_loops[orig_mp->loopstart + orig_mp_loop_index];
+    const MLoop *l = &orig_loops[orig_poly->loopstart + orig_mp_loop_index];
     int fv_orig = f->vert[mp_loop_index]->orig;
     if (fv_orig != NO_INDEX) {
       fv_orig -= orig_me_vert_offset;
@@ -518,7 +518,7 @@ static int fill_orig_loops(const Face *f,
     }
     if (l->v == fv_orig) {
       const MLoop *lnext =
-          &orig_loops[orig_mp->loopstart + ((orig_mp_loop_index + 1) % orig_mplen)];
+          &orig_loops[orig_poly->loopstart + ((orig_mp_loop_index + 1) % orig_mplen)];
       int fvnext_orig = f->vert[(mp_loop_index + 1) % orig_mplen]->orig;
       if (fvnext_orig != NO_INDEX) {
         fvnext_orig -= orig_me_vert_offset;
@@ -527,7 +527,7 @@ static int fill_orig_loops(const Face *f,
         }
       }
       if (lnext->v == fvnext_orig) {
-        r_orig_loops[mp_loop_index] = orig_mp->loopstart + orig_mp_loop_index;
+        r_orig_loops[mp_loop_index] = orig_poly->loopstart + orig_mp_loop_index;
         ++num_orig_loops_found;
       }
     }
@@ -535,24 +535,24 @@ static int fill_orig_loops(const Face *f,
   return num_orig_loops_found;
 }
 
-/* Fill `cos_2d` with the 2d coordinates found by projection MPoly `mp` along
+/* Fill `cos_2d` with the 2d coordinates found by projection MPoly `poly` along
  * its normal. Also fill in r_axis_mat with the matrix that does that projection.
  * But before projecting, also transform the 3d coordinate by multiplying by trans_mat.
- * `cos_2d` should have room for `mp->totloop` entries. */
+ * `cos_2d` should have room for `poly->totloop` entries. */
 static void get_poly2d_cos(const Mesh *me,
-                           const MPoly *mp,
+                           const MPoly *poly,
                            float (*cos_2d)[2],
                            const float4x4 &trans_mat,
                            float r_axis_mat[3][3])
 {
   const Span<float3> positions = me->vert_positions();
   const Span<MLoop> loops = me->loops();
-  const Span<MLoop> poly_loops = loops.slice(mp->loopstart, mp->totloop);
+  const Span<MLoop> poly_loops = loops.slice(poly->loopstart, poly->totloop);
 
   /* Project coordinates to 2d in cos_2d, using normal as projection axis. */
   float axis_dominant[3];
-  BKE_mesh_calc_poly_normal(mp,
-                            &loops[mp->loopstart],
+  BKE_mesh_calc_poly_normal(poly,
+                            &loops[poly->loopstart],
                             reinterpret_cast<const float(*)[3]>(positions.data()),
                             axis_dominant);
   axis_dominant_v3_to_m3(r_axis_mat, axis_dominant);
@@ -563,41 +563,41 @@ static void get_poly2d_cos(const Mesh *me,
   }
 }
 
-/* For the loops of `mp`, see if the face is unchanged from `orig_mp`, and if so,
+/* For the loops of `poly`, see if the face is unchanged from `orig_poly`, and if so,
  * copy the Loop attributes from corresponding loops to corresponding loops.
- * Otherwise, interpolate the Loop attributes in the face `orig_mp`. */
+ * Otherwise, interpolate the Loop attributes in the face `orig_poly`. */
 static void copy_or_interp_loop_attributes(Mesh *dest_mesh,
                                            const Face *f,
-                                           MPoly *mp,
-                                           const MPoly *orig_mp,
+                                           MPoly *poly,
+                                           const MPoly *orig_poly,
                                            const Mesh *orig_me,
                                            int orig_me_index,
                                            MeshesToIMeshInfo &mim)
 {
-  Array<int> orig_loops(mp->totloop);
-  int norig = fill_orig_loops(f, orig_mp, orig_me, orig_me_index, mim, orig_loops);
+  Array<int> orig_loops(poly->totloop);
+  int norig = fill_orig_loops(f, orig_poly, orig_me, orig_me_index, mim, orig_loops);
   /* We may need these arrays if we have to interpolate Loop attributes rather than just copy.
    * Right now, trying Array<float[2]> complains, so declare cos_2d a different way. */
   float(*cos_2d)[2];
   Array<float> weights;
   Array<const void *> src_blocks_ofs;
   float axis_mat[3][3];
-  if (norig != mp->totloop) {
-    /* We will need to interpolate. Make `cos_2d` hold 2d-projected coordinates of `orig_mp`,
+  if (norig != poly->totloop) {
+    /* We will need to interpolate. Make `cos_2d` hold 2d-projected coordinates of `orig_poly`,
      * which are transformed into object 0's local space before projecting.
      * At this point we cannot yet calculate the interpolation weights, as they depend on
      * the coordinate where interpolation is to happen, but we can allocate the needed arrays,
      * so they don't have to be allocated per-layer. */
-    cos_2d = (float(*)[2])BLI_array_alloca(cos_2d, orig_mp->totloop);
-    weights = Array<float>(orig_mp->totloop);
-    src_blocks_ofs = Array<const void *>(orig_mp->totloop);
-    get_poly2d_cos(orig_me, orig_mp, cos_2d, mim.to_target_transform[orig_me_index], axis_mat);
+    cos_2d = (float(*)[2])BLI_array_alloca(cos_2d, orig_poly->totloop);
+    weights = Array<float>(orig_poly->totloop);
+    src_blocks_ofs = Array<const void *>(orig_poly->totloop);
+    get_poly2d_cos(orig_me, orig_poly, cos_2d, mim.to_target_transform[orig_me_index], axis_mat);
   }
   CustomData *target_cd = &dest_mesh->ldata;
   const Span<float3> dst_positions = dest_mesh->vert_positions();
   const Span<MLoop> dst_loops = dest_mesh->loops();
-  for (int i = 0; i < mp->totloop; ++i) {
-    int loop_index = mp->loopstart + i;
+  for (int i = 0; i < poly->totloop; ++i) {
+    int loop_index = poly->loopstart + i;
     int orig_loop_index = norig > 0 ? orig_loops[i] : -1;
     const CustomData *source_cd = &orig_me->ldata;
     if (orig_loop_index == -1) {
@@ -606,7 +606,7 @@ static void copy_or_interp_loop_attributes(Mesh *dest_mesh,
        * coordinates were. The `dest_mesh` coordinates are already in object 0 local space. */
       float co[2];
       mul_v2_m3v3(co, axis_mat, dst_positions[dst_loops[loop_index].v]);
-      interp_weights_poly_v2(weights.data(), cos_2d, orig_mp->totloop, co);
+      interp_weights_poly_v2(weights.data(), cos_2d, orig_poly->totloop, co);
     }
     for (int source_layer_i = 0; source_layer_i < source_cd->totlayer; ++source_layer_i) {
       int ty = source_cd->layers[source_layer_i].type;
@@ -635,9 +635,9 @@ static void copy_or_interp_loop_attributes(Mesh *dest_mesh,
         int source_layer_type_index = source_layer_i - source_cd->typemap[ty];
         BLI_assert(target_layer_type_index != -1 && source_layer_type_index >= 0);
         const int size = CustomData_sizeof(ty);
-        for (int j = 0; j < orig_mp->totloop; ++j) {
+        for (int j = 0; j < orig_poly->totloop; ++j) {
           const void *layer = CustomData_get_layer_n(source_cd, ty, source_layer_type_index);
-          src_blocks_ofs[j] = POINTER_OFFSET(layer, size * (orig_mp->loopstart + j));
+          src_blocks_ofs[j] = POINTER_OFFSET(layer, size * (orig_poly->loopstart + j));
         }
         void *dst_layer = CustomData_get_layer_n_for_write(
             target_cd, ty, target_layer_type_index, dest_mesh->totloop);
@@ -646,7 +646,7 @@ static void copy_or_interp_loop_attributes(Mesh *dest_mesh,
                                   src_blocks_ofs.data(),
                                   weights.data(),
                                   nullptr,
-                                  orig_mp->totloop,
+                                  orig_poly->totloop,
                                   dst_block_ofs,
                                   target_layer_i);
       }
@@ -737,11 +737,11 @@ static Mesh *imesh_to_mesh(IMesh *im, MeshesToIMeshInfo &mim)
     const Mesh *orig_me;
     int index_in_orig_me;
     int orig_me_index;
-    const MPoly *orig_mp = mim.input_mpoly_for_orig_index(
+    const MPoly *orig_poly = mim.input_mpoly_for_orig_index(
         f->orig, &orig_me, &orig_me_index, &index_in_orig_me);
-    MPoly *mp = &dst_polys[fi];
-    mp->totloop = f->size();
-    mp->loopstart = cur_loop_index;
+    MPoly *poly = &dst_polys[fi];
+    poly->totloop = f->size();
+    poly->loopstart = cur_loop_index;
     for (int j : f->index_range()) {
       const Vert *vf = f->vert[j];
       const int vfi = im->lookup_vert(vf);
@@ -751,8 +751,8 @@ static Mesh *imesh_to_mesh(IMesh *im, MeshesToIMeshInfo &mim)
     }
 
     copy_poly_attributes(result,
-                         mp,
-                         orig_mp,
+                         poly,
+                         orig_poly,
                          orig_me,
                          fi,
                          index_in_orig_me,
@@ -760,7 +760,7 @@ static Mesh *imesh_to_mesh(IMesh *im, MeshesToIMeshInfo &mim)
                              mim.material_remaps[orig_me_index].as_span() :
                              Span<short>(),
                          dst_material_indices.span);
-    copy_or_interp_loop_attributes(result, f, mp, orig_mp, orig_me, orig_me_index, mim);
+    copy_or_interp_loop_attributes(result, f, poly, orig_poly, orig_me, orig_me_index, mim);
   }
   dst_material_indices.finish();
 
@@ -773,13 +773,13 @@ static Mesh *imesh_to_mesh(IMesh *im, MeshesToIMeshInfo &mim)
    */
   for (int fi : im->face_index_range()) {
     const Face *f = im->face(fi);
-    const MPoly *mp = &dst_polys[fi];
+    const MPoly *poly = &dst_polys[fi];
     for (int j : f->index_range()) {
       if (f->edge_orig[j] != NO_INDEX) {
         const Mesh *orig_me;
         int index_in_orig_me;
         mim.input_medge_for_orig_index(f->edge_orig[j], &orig_me, &index_in_orig_me);
-        int e_index = dst_loops[mp->loopstart + j].e;
+        int e_index = dst_loops[poly->loopstart + j].e;
         copy_edge_attributes(result, orig_me, e_index, index_in_orig_me);
       }
     }
diff --git a/source/blender/blenkernel/intern/mesh_convert.cc b/source/blender/blenkernel/intern/mesh_convert.cc
index 79f9dfaecd3..654d4c15a59 100644
--- a/source/blender/blenkernel/intern/mesh_convert.cc
+++ b/source/blender/blenkernel/intern/mesh_convert.cc
@@ -82,7 +82,7 @@ static CLG_LogRef LOG = {"bke.mesh_convert"};
 static void make_edges_mdata_extend(Mesh &mesh)
 {
   int totedge = mesh.totedge;
-  const MPoly *mp;
+  const MPoly *poly;
   int i;
 
   const Span<MPoly> polys = mesh.polys();
@@ -112,22 +112,22 @@ static void make_edges_mdata_extend(Mesh &mesh)
     CustomData_realloc(&mesh.edata, totedge, totedge + totedge_new);
     mesh.totedge += totedge_new;
     MutableSpan<MEdge> edges = mesh.edges_for_write();
-    MEdge *medge = &edges[totedge];
+    MEdge *edge = &edges[totedge];
 
     EdgeHashIterator *ehi;
     uint e_index = totedge;
     for (ehi = BLI_edgehashIterator_new(eh); BLI_edgehashIterator_isDone(ehi) == false;
-         BLI_edgehashIterator_step(ehi), ++medge, e_index++) {
-      BLI_edgehashIterator_getKey(ehi, &medge->v1, &medge->v2);
+         BLI_edgehashIterator_step(ehi), ++edge, e_index++) {
+      BLI_edgehashIterator_getKey(ehi, &edge->v1, &edge->v2);
       BLI_edgehashIterator_setValue(ehi, POINTER_FROM_UINT(e_index));
     }
     BLI_edgehashIterator_free(ehi);
 
-    for (i = 0, mp = polys.data(); i < mesh.totpoly; i++, mp++) {
-      MLoop *l = &loops[mp->loopstart];
-      MLoop *l_prev = (l + (mp->totloop - 1));
+    for (i = 0, poly = polys.data(); i < mesh.totpoly; i++, poly++) {
+      MLoop *l = &loops[poly->loopstart];
+      MLoop *l_prev = (l + (poly->totloop - 1));
       int j;
-      for (j = 0; j < mp->totloop; j++, l++) {
+      for (j = 0; j < poly->totloop; j++, l++) {
         /* lookup hashed edge index */
         l_prev->e = POINTER_AS_UINT(BLI_edgehash_lookup(eh, l_prev->v, l->v));
         l_prev = l;
@@ -457,11 +457,11 @@ void BKE_mesh_to_curve_nurblist(const Mesh *me, ListBase *nurblist, const int ed
   const Span<MPoly> polys = me->polys();
   const Span<MLoop> loops = me->loops();
 
-  const MEdge *med;
-  const MPoly *mp;
+  const MEdge *edge;
+  const MPoly *poly;
 
-  int medge_len = me->totedge;
-  int mpoly_len = me->totpoly;
+  int edges_len = me->totedge;
+  int polys_len = me->totpoly;
   int totedges = 0;
   int i;
 
@@ -471,21 +471,21 @@ void BKE_mesh_to_curve_nurblist(const Mesh *me, ListBase *nurblist, const int ed
   ListBase edges = {nullptr, nullptr};
 
   /* get boundary edges */
-  edge_users = (int *)MEM_calloc_arrayN(medge_len, sizeof(int), __func__);
-  for (i = 0, mp = polys.data(); i < mpoly_len; i++, mp++) {
-    const MLoop *ml = &loops[mp->loopstart];
+  edge_users = (int *)MEM_calloc_arrayN(edges_len, sizeof(int), __func__);
+  for (i = 0, poly = polys.data(); i < polys_len; i++, poly++) {
+    const MLoop *ml = &loops[poly->loopstart];
     int j;
-    for (j = 0; j < mp->totloop; j++, ml++) {
+    for (j = 0; j < poly->totloop; j++, ml++) {
       edge_users[ml->e]++;
     }
   }
 
   /* create edges from all faces (so as to find edges not in any faces) */
-  med = mesh_edges.data();
-  for (i = 0; i < medge_len; i++, med++) {
+  edge = mesh_edges.data();
+  for (i = 0; i < edges_len; i++, edge++) {
     if (edge_users[i] == edge_users_test) {
       EdgeLink *edl = MEM_cnew<EdgeLink>("EdgeLink");
-      edl->edge = med;
+      edl->edge = edge;
 
       BLI_addtail(&edges, edl);
       totedges++;
@@ -500,9 +500,9 @@ void BKE_mesh_to_curve_nurblist(const Mesh *me, ListBase *nurblist, const int ed
       ListBase polyline = {nullptr, nullptr}; /* store a list of VertLink's */
       bool closed = false;
       int totpoly = 0;
-      MEdge *med_current = (MEdge *)((EdgeLink *)edges.last)->edge;
-      uint startVert = med_current->v1;
-      uint endVert = med_current->v2;
+      MEdge *edge_current = (MEdge *)((EdgeLink *)edges.last)->edge;
+      uint startVert = edge_current->v1;
+      uint endVert = edge_current->v2;
       bool ok = true;
 
       appendPolyLineVert(&polyline, startVert);
@@ -518,34 +518,34 @@ void BKE_mesh_to_curve_nurblist(const Mesh *me, ListBase *nurblist, const int ed
         while (edl) {
           EdgeLink *edl_prev = edl->prev;
 
-          med = (MEdge *)edl->edge;
+          edge = (MEdge *)edl->edge;
 
-          if (med->v1 == endVert) {
-            endVert = med->v2;
-            appendPolyLineVert(&polyline, med->v2);
+          if (edge->v1 == endVert) {
+            endVert = edge->v2;
+            appendPolyLineVert(&polyline, edge->v2);
             totpoly++;
             BLI_freelinkN(&edges, edl);
             totedges--;
             ok = true;
           }
-          else if (med->v2 == endVert) {
-            endVert = med->v1;
+          else if (edge->v2 == endVert) {
+            endVert = edge->v1;
             appendPolyLineVert(&polyline, endVert);
             totpoly++;
             BLI_freelinkN(&edges, edl);
             totedges--;
             ok = true;
           }
-          else if (med->v1 == startVert) {
-            startVert = med->v2;
+          else if (edge->v1 == startVert) {
+            startVert = edge->v2;
             prependPolyLineVert(&polyline, startVert);
             totpoly++;
             BLI_freelinkN(&edges, edl);
             totedges--;
             ok = true;
           }
-          else if (med->v2 == startVert) {
-            startVert = med->v1;
+          else if (edge->v2 == startVert) {
+            startVert = edge->v1;
             prependPolyLineVert(&polyline, startVert);
             totpoly++;
             BLI_freelinkN(&edges, edl);
diff --git a/source/blender/blenkernel/intern/mesh_evaluate.cc b/source/blender/blenkernel/intern/mesh_evaluate.cc
index 8cab5a4dd9a..bf3cd17f58e 100644
--- a/source/blender/blenkernel/intern/mesh_evaluate.cc
+++ b/source/blender/blenkernel/intern/mesh_evaluate.cc
@@ -39,32 +39,32 @@ using blender::VArray;
 /** \name Polygon Calculations
  * \{ */
 
-static void mesh_calc_ngon_center(const MPoly *mpoly,
+static void mesh_calc_ngon_center(const MPoly *poly,
                                   const MLoop *loopstart,
                                   const float (*positions)[3],
                                   float cent[3])
 {
-  const float w = 1.0f / float(mpoly->totloop);
+  const float w = 1.0f / float(poly->totloop);
 
   zero_v3(cent);
 
-  for (int i = 0; i < mpoly->totloop; i++) {
+  for (int i = 0; i < poly->totloop; i++) {
     madd_v3_v3fl(cent, positions[(loopstart++)->v], w);
   }
 }
 
-void BKE_mesh_calc_poly_center(const MPoly *mpoly,
+void BKE_mesh_calc_poly_center(const MPoly *poly,
                                const MLoop *loopstart,
                                const float (*vert_positions)[3],
                                float r_cent[3])
 {
-  if (mpoly->totloop == 3) {
+  if (poly->totloop == 3) {
     mid_v3_v3v3v3(r_cent,
                   vert_positions[loopstart[0].v],
                   vert_positions[loopstart[1].v],
                   vert_positions[loopstart[2].v]);
   }
-  else if (mpoly->totloop == 4) {
+  else if (poly->totloop == 4) {
     mid_v3_v3v3v3v3(r_cent,
                     vert_positions[loopstart[0].v],
                     vert_positions[loopstart[1].v],
@@ -72,30 +72,30 @@ void BKE_mesh_calc_poly_center(const MPoly *mpoly,
                     vert_positions[loopstart[3].v]);
   }
   else {
-    mesh_calc_ngon_center(mpoly, loopstart, vert_positions, r_cent);
+    mesh_calc_ngon_center(poly, loopstart, vert_positions, r_cent);
   }
 }
 
-float BKE_mesh_calc_poly_area(const MPoly *mpoly,
+float BKE_mesh_calc_poly_area(const MPoly *poly,
                               const MLoop *loopstart,
                               const float (*vert_positions)[3])
 {
-  if (mpoly->totloop == 3) {
+  if (poly->totloop == 3) {
     return area_tri_v3(vert_positions[loopstart[0].v],
                        vert_positions[loopstart[1].v],
                        vert_positions[loopstart[2].v]);
   }
 
   const MLoop *l_iter = loopstart;
-  float(*vertexcos)[3] = (float(*)[3])BLI_array_alloca(vertexcos, size_t(mpoly->totloop));
+  float(*vertexcos)[3] = (float(*)[3])BLI_array_alloca(vertexcos, size_t(poly->totloop));
 
   /* pack vertex cos into an array for area_poly_v3 */
-  for (int i = 0; i < mpoly->totloop; i++, l_iter++) {
+  for (int i = 0; i < poly->totloop; i++, l_iter++) {
     copy_v3_v3(vertexcos[i], vert_positions[l_iter->v]);
   }
 
   /* finally calculate the area */
-  float area = area_poly_v3((const float(*)[3])vertexcos, uint(mpoly->totloop));
+  float area = area_poly_v3((const float(*)[3])vertexcos, uint(poly->totloop));
 
   return area;
 }
@@ -114,7 +114,7 @@ float BKE_mesh_calc_area(const Mesh *me)
   return total_area;
 }
 
-static float UNUSED_FUNCTION(mesh_calc_poly_volume_centroid)(const MPoly *mpoly,
+static float UNUSED_FUNCTION(mesh_calc_poly_volume_centroid)(const MPoly *poly,
                                                              const MLoop *loopstart,
                                                              const float (*positions)[3],
                                                              float r_cent[3])
@@ -127,7 +127,7 @@ static float UNUSED_FUNCTION(mesh_calc_poly_volume_centroid)(const MPoly *mpoly,
   v_pivot = positions[loopstart[0].v];
   v_step1 = positions[loopstart[1].v];
 
-  for (int i = 2; i < mpoly->totloop; i++) {
+  for (int i = 2; i < poly->totloop; i++) {
     const float *v_step2 = positions[loopstart[i].v];
 
     /* Calculate the 6x volume of the tetrahedron formed by the 3 vertices
@@ -156,7 +156,7 @@ static float UNUSED_FUNCTION(mesh_calc_poly_volume_centroid)(const MPoly *mpoly,
  * use this to increase numeric stability as the quality of the result becomes
  * very low quality as the value moves away from 0.0, see: #65986.
  */
-static float mesh_calc_poly_volume_centroid_with_reference_center(const MPoly *mpoly,
+static float mesh_calc_poly_volume_centroid_with_reference_center(const MPoly *poly,
                                                                   const MLoop *loopstart,
                                                                   const Span<float3> positions,
                                                                   const float reference_center[3],
@@ -168,7 +168,7 @@ static float mesh_calc_poly_volume_centroid_with_reference_center(const MPoly *m
   zero_v3(r_cent);
   sub_v3_v3v3(v_pivot, positions[loopstart[0].v], reference_center);
   sub_v3_v3v3(v_step1, positions[loopstart[1].v], reference_center);
-  for (int i = 2; i < mpoly->totloop; i++) {
+  for (int i = 2; i < poly->totloop; i++) {
     float v_step2[3];
     sub_v3_v3v3(v_step2, positions[loopstart[i].v], reference_center);
     const float tetra_volume = volume_tri_tetrahedron_signed_v3_6x(v_pivot, v_step1, v_step2);
@@ -187,7 +187,7 @@ static float mesh_calc_poly_volume_centroid_with_reference_center(const MPoly *m
  * - This has the advantage over #mesh_calc_poly_volume_centroid
  *   that it doesn't depend on solid geometry, instead it weights the surface by volume.
  */
-static float mesh_calc_poly_area_centroid(const MPoly *mpoly,
+static float mesh_calc_poly_area_centroid(const MPoly *poly,
                                           const MLoop *loopstart,
                                           const float (*positions)[3],
                                           float r_cent[3])
@@ -195,12 +195,12 @@ static float mesh_calc_poly_area_centroid(const MPoly *mpoly,
   float total_area = 0.0f;
   float v1[3], v2[3], v3[3], normal[3], tri_cent[3];
 
-  BKE_mesh_calc_poly_normal(mpoly, loopstart, positions, normal);
+  BKE_mesh_calc_poly_normal(poly, loopstart, positions, normal);
   copy_v3_v3(v1, positions[loopstart[0].v]);
   copy_v3_v3(v2, positions[loopstart[1].v]);
   zero_v3(r_cent);
 
-  for (int i = 2; i < mpoly->totloop; i++) {
+  for (int i = 2; i < poly->totloop; i++) {
     copy_v3_v3(v3, positions[loopstart[i].v]);
 
     float tri_area = area_tri_signed_v3(v1, v2, v3, normal);
@@ -217,7 +217,7 @@ static float mesh_calc_poly_area_centroid(const MPoly *mpoly,
   return total_area;
 }
 
-void BKE_mesh_calc_poly_angles(const MPoly *mpoly,
+void BKE_mesh_calc_poly_angles(const MPoly *poly,
                                const MLoop *loopstart,
                                const float (*vert_positions)[3],
                                float angles[])
@@ -225,14 +225,14 @@ void BKE_mesh_calc_poly_angles(const MPoly *mpoly,
   float nor_prev[3];
   float nor_next[3];
 
-  int i_this = mpoly->totloop - 1;
+  int i_this = poly->totloop - 1;
   int i_next = 0;
 
   sub_v3_v3v3(
       nor_prev, vert_positions[loopstart[i_this - 1].v], vert_positions[loopstart[i_this].v]);
   normalize_v3(nor_prev);
 
-  while (i_next < mpoly->totloop) {
+  while (i_next < poly->totloop) {
     sub_v3_v3v3(
         nor_next, vert_positions[loopstart[i_this].v], vert_positions[loopstart[i_next].v]);
     normalize_v3(nor_next);
@@ -245,10 +245,10 @@ void BKE_mesh_calc_poly_angles(const MPoly *mpoly,
   }
 }
 
-void BKE_mesh_poly_edgehash_insert(EdgeHash *ehash, const MPoly *mp, const MLoop *mloop)
+void BKE_mesh_poly_edgehash_insert(EdgeHash *ehash, const MPoly *poly, const MLoop *mloop)
 {
   const MLoop *ml, *ml_next;
-  int i = mp->totloop;
+  int i = poly->totloop;
 
   ml_next = mloop;      /* first loop */
   ml = &ml_next[i - 1]; /* last loop */
@@ -261,10 +261,10 @@ void BKE_mesh_poly_edgehash_insert(EdgeHash *ehash, const MPoly *mp, const MLoop
   }
 }
 
-void BKE_mesh_poly_edgebitmap_insert(uint *edge_bitmap, const MPoly *mp, const MLoop *mloop)
+void BKE_mesh_poly_edgebitmap_insert(uint *edge_bitmap, const MPoly *poly, const MLoop *mloop)
 {
   const MLoop *ml;
-  int i = mp->totloop;
+  int i = poly->totloop;
 
   ml = mloop;
 
@@ -548,15 +548,15 @@ void BKE_mesh_mdisp_flip(MDisps *md, const bool use_loop_mdisp_flip)
   }
 }
 
-void BKE_mesh_polygon_flip_ex(const MPoly *mpoly,
+void BKE_mesh_polygon_flip_ex(const MPoly *poly,
                               MLoop *mloop,
                               CustomData *ldata,
                               float (*lnors)[3],
                               MDisps *mdisp,
                               const bool use_loop_mdisp_flip)
 {
-  int loopstart = mpoly->loopstart;
-  int loopend = loopstart + mpoly->totloop - 1;
+  int loopstart = poly->loopstart;
+  int loopend = loopstart + poly->totloop - 1;
   const bool loops_in_ldata = (CustomData_get_layer(ldata, CD_MLOOP) == mloop);
 
   if (mdisp) {
@@ -591,20 +591,17 @@ void BKE_mesh_polygon_flip_ex(const MPoly *mpoly,
   }
 }
 
-void BKE_mesh_polygon_flip(const MPoly *mpoly, MLoop *mloop, CustomData *ldata, const int totloop)
+void BKE_mesh_polygon_flip(const MPoly *poly, MLoop *mloop, CustomData *ldata, const int totloop)
 {
   MDisps *mdisp = (MDisps *)CustomData_get_layer_for_write(ldata, CD_MDISPS, totloop);
-  BKE_mesh_polygon_flip_ex(mpoly, mloop, ldata, nullptr, mdisp, true);
+  BKE_mesh_polygon_flip_ex(poly, mloop, ldata, nullptr, mdisp, true);
 }
 
-void BKE_mesh_polys_flip(const MPoly *mpoly, MLoop *mloop, CustomData *ldata, int totpoly)
+void BKE_mesh_polys_flip(const MPoly *polys, MLoop *mloop, CustomData *ldata, int totpoly)
 {
   MDisps *mdisp = (MDisps *)CustomData_get_layer_for_write(ldata, CD_MDISPS, totpoly);
-  const MPoly *mp;
-  int i;
-
-  for (mp = mpoly, i = 0; i < totpoly; mp++, i++) {
-    BKE_mesh_polygon_flip_ex(mp, mloop, ldata, nullptr, mdisp, true);
+  for (const int i : blender::IndexRange(totpoly)) {
+    BKE_mesh_polygon_flip_ex(&polys[i], mloop, ldata, nullptr, mdisp, true);
   }
 }
 
@@ -788,7 +785,7 @@ void BKE_mesh_flush_select_from_verts(Mesh *me)
 /** \name Mesh Spatial Calculation
  * \{ */
 
-void BKE_mesh_calc_relative_deform(const MPoly *mpoly,
+void BKE_mesh_calc_relative_deform(const MPoly *polys,
                                    const int totpoly,
                                    const MLoop *mloop,
                                    const int totvert,
@@ -799,20 +796,20 @@ void BKE_mesh_calc_relative_deform(const MPoly *mpoly,
                                    const float (*vert_cos_org)[3],
                                    float (*vert_cos_new)[3])
 {
-  const MPoly *mp;
+  const MPoly *poly;
   int i;
 
   int *vert_accum = (int *)MEM_calloc_arrayN(size_t(totvert), sizeof(*vert_accum), __func__);
 
   memset(vert_cos_new, '\0', sizeof(*vert_cos_new) * size_t(totvert));
 
-  for (i = 0, mp = mpoly; i < totpoly; i++, mp++) {
-    const MLoop *loopstart = mloop + mp->loopstart;
+  for (i = 0, poly = polys; i < totpoly; i++, poly++) {
+    const MLoop *loopstart = mloop + poly->loopstart;
 
-    for (int j = 0; j < mp->totloop; j++) {
-      uint v_prev = loopstart[(mp->totloop + (j - 1)) % mp->totloop].v;
+    for (int j = 0; j < poly->totloop; j++) {
+      uint v_prev = loopstart[(poly->totloop + (j - 1)) % poly->totloop].v;
       uint v_curr = loopstart[j].v;
-      uint v_next = loopstart[(j + 1) % mp->totloop].v;
+      uint v_next = loopstart[(j + 1) % poly->totloop].v;
 
       float tvec[3];
 
diff --git a/source/blender/blenkernel/intern/mesh_fair.cc b/source/blender/blenkernel/intern/mesh_fair.cc
index ddf6b342236..d9b9e2e2240 100644
--- a/source/blender/blenkernel/intern/mesh_fair.cc
+++ b/source/blender/blenkernel/intern/mesh_fair.cc
@@ -198,12 +198,12 @@ class MeshFairingContext : public FairingContext {
     totloop_ = mesh->totloop;
 
     MutableSpan<float3> positions = mesh->vert_positions_for_write();
-    medge_ = mesh->edges();
-    mpoly_ = mesh->polys();
+    edges_ = mesh->edges();
+    polys = mesh->polys();
     mloop_ = mesh->loops();
     BKE_mesh_vert_loop_map_create(&vlmap_,
                                   &vlmap_mem_,
-                                  mpoly_.data(),
+                                  polys.data(),
                                   mloop_.data(),
                                   mesh->totvert,
                                   mesh->totpoly,
@@ -222,7 +222,7 @@ class MeshFairingContext : public FairingContext {
       }
     }
 
-    loop_to_poly_map_ = blender::bke::mesh_topology::build_loop_to_poly_map(mpoly_, mloop_.size());
+    loop_to_poly_map_ = blender::bke::mesh_topology::build_loop_to_poly_map(polys, mloop_.size());
   }
 
   ~MeshFairingContext() override
@@ -236,26 +236,26 @@ class MeshFairingContext : public FairingContext {
                                   float r_adj_prev[3]) override
   {
     const int vert = mloop_[loop].v;
-    const MPoly *p = &mpoly_[loop_to_poly_map_[loop]];
-    const int corner = poly_find_loop_from_vert(p, &mloop_[p->loopstart], vert);
-    copy_v3_v3(r_adj_next, co_[ME_POLY_LOOP_NEXT(mloop_, p, corner)->v]);
-    copy_v3_v3(r_adj_prev, co_[ME_POLY_LOOP_PREV(mloop_, p, corner)->v]);
+    const MPoly *poly = &polys[loop_to_poly_map_[loop]];
+    const int corner = poly_find_loop_from_vert(poly, &mloop_[poly->loopstart], vert);
+    copy_v3_v3(r_adj_next, co_[ME_POLY_LOOP_NEXT(mloop_, poly, corner)->v]);
+    copy_v3_v3(r_adj_prev, co_[ME_POLY_LOOP_PREV(mloop_, poly, corner)->v]);
   }
 
   int other_vertex_index_from_loop(const int loop, const uint v) override
   {
-    const MEdge *e = &medge_[mloop_[loop].e];
-    if (e->v1 == v) {
-      return e->v2;
+    const MEdge *edge = &edges_[mloop_[loop].e];
+    if (edge->v1 == v) {
+      return edge->v2;
     }
-    return e->v1;
+    return edge->v1;
   }
 
  protected:
   Mesh *mesh_;
   Span<MLoop> mloop_;
-  Span<MPoly> mpoly_;
-  Span<MEdge> medge_;
+  Span<MPoly> polys;
+  Span<MEdge> edges_;
   Array<int> loop_to_poly_map_;
 };
 
diff --git a/source/blender/blenkernel/intern/mesh_legacy_convert.cc b/source/blender/blenkernel/intern/mesh_legacy_convert.cc
index 0e20364f572..46908416325 100644
--- a/source/blender/blenkernel/intern/mesh_legacy_convert.cc
+++ b/source/blender/blenkernel/intern/mesh_legacy_convert.cc
@@ -94,7 +94,7 @@ static void mesh_calc_edges_mdata(const MVert * /*allvert*/,
 {
   const MPoly *mpoly;
   const MFace *mface;
-  MEdge *medge, *med;
+  MEdge *edges, *edge;
   EdgeHash *hash;
   struct EdgeSort *edsort, *ed;
   int a, totedge = 0;
@@ -148,20 +148,20 @@ static void mesh_calc_edges_mdata(const MVert * /*allvert*/,
   }
   totedge_final++;
 
-  medge = (MEdge *)MEM_callocN(sizeof(MEdge) * totedge_final, __func__);
+  edges = (MEdge *)MEM_callocN(sizeof(MEdge) * totedge_final, __func__);
 
-  for (a = totedge, med = medge, ed = edsort; a > 1; a--, ed++) {
+  for (a = totedge, edge = edges, ed = edsort; a > 1; a--, ed++) {
     /* edge is unique when it differs from next edge, or is last */
     if (ed->v1 != (ed + 1)->v1 || ed->v2 != (ed + 1)->v2) {
-      med->v1 = ed->v1;
-      med->v2 = ed->v2;
+      edge->v1 = ed->v1;
+      edge->v2 = ed->v2;
 
       /* order is swapped so extruding this edge as a surface won't flip face normals
        * with cyclic curves */
       if (ed->v1 + 1 != ed->v2) {
-        std::swap(med->v1, med->v2);
+        std::swap(edge->v1, edge->v2);
       }
-      med++;
+      edge++;
     }
     else {
       /* Equal edge, merge the draw-flag. */
@@ -169,15 +169,15 @@ static void mesh_calc_edges_mdata(const MVert * /*allvert*/,
     }
   }
   /* last edge */
-  med->v1 = ed->v1;
-  med->v2 = ed->v2;
+  edge->v1 = ed->v1;
+  edge->v2 = ed->v2;
 
   MEM_freeN(edsort);
 
   /* set edge members of mloops */
   hash = BLI_edgehash_new_ex(__func__, totedge_final);
-  for (edge_index = 0, med = medge; edge_index < totedge_final; edge_index++, med++) {
-    BLI_edgehash_insert(hash, med->v1, med->v2, POINTER_FROM_UINT(edge_index));
+  for (edge_index = 0, edge = edges; edge_index < totedge_final; edge_index++, edge++) {
+    BLI_edgehash_insert(hash, edge->v1, edge->v2, POINTER_FROM_UINT(edge_index));
   }
 
   mpoly = allpoly;
@@ -197,14 +197,14 @@ static void mesh_calc_edges_mdata(const MVert * /*allvert*/,
 
   BLI_edgehash_free(hash, nullptr);
 
-  *r_medge = medge;
+  *r_medge = edges;
   *r_totedge = totedge_final;
 }
 
 void BKE_mesh_calc_edges_legacy(Mesh *me)
 {
   using namespace blender;
-  MEdge *medge;
+  MEdge *edges;
   int totedge = 0;
   const Span<MVert> verts(static_cast<const MVert *>(CustomData_get_layer(&me->vdata, CD_MVERT)),
                           me->totvert);
@@ -219,7 +219,7 @@ void BKE_mesh_calc_edges_legacy(Mesh *me)
                         me->totface,
                         loops.size(),
                         polys.size(),
-                        &medge,
+                        &edges,
                         &totedge);
 
   if (totedge == 0) {
@@ -228,7 +228,7 @@ void BKE_mesh_calc_edges_legacy(Mesh *me)
     return;
   }
 
-  medge = (MEdge *)CustomData_add_layer(&me->edata, CD_MEDGE, CD_ASSIGN, medge, totedge);
+  edges = (MEdge *)CustomData_add_layer(&me->edata, CD_MEDGE, CD_ASSIGN, edges, totedge);
   me->totedge = totedge;
 
   BKE_mesh_tag_topology_changed(me);
@@ -419,15 +419,15 @@ static void convert_mfaces_to_mpolys(ID *id,
                                      int totface_i,
                                      int totloop_i,
                                      int totpoly_i,
-                                     MEdge *medge,
+                                     MEdge *edges,
                                      MFace *mface,
                                      int *r_totloop,
                                      int *r_totpoly)
 {
   MFace *mf;
   MLoop *ml, *mloop;
-  MPoly *mp, *mpoly;
-  MEdge *me;
+  MPoly *poly, *mpoly;
+  MEdge *edge;
   EdgeHash *eh;
   int numTex, numCol;
   int i, j, totloop, totpoly, *polyindex;
@@ -470,13 +470,13 @@ static void convert_mfaces_to_mpolys(ID *id,
   eh = BLI_edgehash_new_ex(__func__, uint(totedge_i));
 
   /* build edge hash */
-  me = medge;
-  for (i = 0; i < totedge_i; i++, me++) {
-    BLI_edgehash_insert(eh, me->v1, me->v2, POINTER_FROM_UINT(i));
+  edge = edges;
+  for (i = 0; i < totedge_i; i++, edge++) {
+    BLI_edgehash_insert(eh, edge->v1, edge->v2, POINTER_FROM_UINT(i));
 
     /* unrelated but avoid having the FGON flag enabled,
      * so we can reuse it later for something else */
-    me->flag_legacy &= ~ME_FGON;
+    edge->flag_legacy &= ~ME_FGON;
   }
 
   polyindex = (int *)CustomData_get_layer(fdata, CD_ORIGINDEX);
@@ -484,14 +484,14 @@ static void convert_mfaces_to_mpolys(ID *id,
   j = 0; /* current loop index */
   ml = mloop;
   mf = mface;
-  mp = mpoly;
-  for (i = 0; i < totface_i; i++, mf++, mp++) {
-    mp->loopstart = j;
+  poly = mpoly;
+  for (i = 0; i < totface_i; i++, mf++, poly++) {
+    poly->loopstart = j;
 
-    mp->totloop = mf->v4 ? 4 : 3;
+    poly->totloop = mf->v4 ? 4 : 3;
 
     material_indices[i] = mf->mat_nr;
-    mp->flag = mf->flag;
+    poly->flag = mf->flag;
 
 #define ML(v1, v2) \
   { \
@@ -515,7 +515,7 @@ static void convert_mfaces_to_mpolys(ID *id,
 #undef ML
 
     bm_corners_to_loops_ex(
-        id, fdata, totface_i, ldata, mface, totloop, i, mp->loopstart, numTex, numCol);
+        id, fdata, totface_i, ldata, mface, totloop, i, poly->loopstart, numTex, numCol);
 
     if (polyindex) {
       *polyindex = i;
@@ -962,7 +962,7 @@ static int mesh_tessface_calc(Mesh &mesh,
 
   const int looptri_num = poly_to_tri_count(totpoly, totloop);
 
-  const MPoly *mp, *mpoly;
+  const MPoly *poly, *mpoly;
   const MLoop *ml, *mloop;
   MFace *mface, *mf;
   MemArena *arena = nullptr;
@@ -985,10 +985,10 @@ static int mesh_tessface_calc(Mesh &mesh,
   lindices = (uint(*)[4])MEM_malloc_arrayN(size_t(looptri_num), sizeof(*lindices), __func__);
 
   mface_index = 0;
-  mp = mpoly;
-  for (poly_index = 0; poly_index < totpoly; poly_index++, mp++) {
-    const uint mp_loopstart = uint(mp->loopstart);
-    const uint mp_totloop = uint(mp->totloop);
+  poly = mpoly;
+  for (poly_index = 0; poly_index < totpoly; poly_index++, poly++) {
+    const uint mp_loopstart = uint(poly->loopstart);
+    const uint mp_totloop = uint(poly->totloop);
     uint l1, l2, l3, l4;
     uint *lidx;
     if (mp_totloop < 3) {
@@ -1014,7 +1014,7 @@ static int mesh_tessface_calc(Mesh &mesh,
     lidx[2] = l3; \
     lidx[3] = 0; \
     mf->mat_nr = material_indices ? material_indices[poly_index] : 0; \
-    mf->flag = mp->flag; \
+    mf->flag = poly->flag; \
     mf->edcode = 0; \
     (void)0
 
@@ -1037,7 +1037,7 @@ static int mesh_tessface_calc(Mesh &mesh,
     lidx[2] = l3; \
     lidx[3] = l4; \
     mf->mat_nr = material_indices ? material_indices[poly_index] : 0; \
-    mf->flag = mp->flag; \
+    mf->flag = poly->flag; \
     mf->edcode = TESSFACE_IS_QUAD; \
     (void)0
 
@@ -1123,7 +1123,7 @@ static int mesh_tessface_calc(Mesh &mesh,
         lidx[3] = 0;
 
         mf->mat_nr = material_indices ? material_indices[poly_index] : 0;
-        mf->flag = mp->flag;
+        mf->flag = poly->flag;
         mf->edcode = 0;
 
         mface_index++;
diff --git a/source/blender/blenkernel/intern/mesh_mapping.cc b/source/blender/blenkernel/intern/mesh_mapping.cc
index b1bd07fea06..60d9f903bcd 100644
--- a/source/blender/blenkernel/intern/mesh_mapping.cc
+++ b/source/blender/blenkernel/intern/mesh_mapping.cc
@@ -30,7 +30,7 @@
 /** \name Mesh Connectivity Mapping
  * \{ */
 
-UvVertMap *BKE_mesh_uv_vert_map_create(const MPoly *mpoly,
+UvVertMap *BKE_mesh_uv_vert_map_create(const MPoly *polys,
                                        const bool *hide_poly,
                                        const bool *select_poly,
                                        const MLoop *mloop,
@@ -45,7 +45,7 @@ UvVertMap *BKE_mesh_uv_vert_map_create(const MPoly *mpoly,
 
   UvVertMap *vmap;
   UvMapVert *buf;
-  const MPoly *mp;
+  const MPoly *poly;
   uint a;
   int i, totuv, nverts;
 
@@ -54,10 +54,10 @@ UvVertMap *BKE_mesh_uv_vert_map_create(const MPoly *mpoly,
   totuv = 0;
 
   /* generate UvMapVert array */
-  mp = mpoly;
-  for (a = 0; a < totpoly; a++, mp++) {
+  poly = polys;
+  for (a = 0; a < totpoly; a++, poly++) {
     if (!selected || (!(hide_poly && hide_poly[a]) && (select_poly && select_poly[a]))) {
-      totuv += mp->totloop;
+      totuv += poly->totloop;
     }
   }
 
@@ -79,26 +79,26 @@ UvVertMap *BKE_mesh_uv_vert_map_create(const MPoly *mpoly,
     winding = static_cast<bool *>(MEM_callocN(sizeof(*winding) * totpoly, "winding"));
   }
 
-  mp = mpoly;
-  for (a = 0; a < totpoly; a++, mp++) {
+  poly = polys;
+  for (a = 0; a < totpoly; a++, poly++) {
     if (!selected || (!(hide_poly && hide_poly[a]) && (select_poly && select_poly[a]))) {
       float(*tf_uv)[2] = nullptr;
 
       if (use_winding) {
-        tf_uv = (float(*)[2])BLI_buffer_reinit_data(&tf_uv_buf, vec2f, size_t(mp->totloop));
+        tf_uv = (float(*)[2])BLI_buffer_reinit_data(&tf_uv_buf, vec2f, size_t(poly->totloop));
       }
 
-      nverts = mp->totloop;
+      nverts = poly->totloop;
 
       for (i = 0; i < nverts; i++) {
         buf->loop_of_poly_index = ushort(i);
         buf->poly_index = a;
         buf->separate = false;
-        buf->next = vmap->vert[mloop[mp->loopstart + i].v];
-        vmap->vert[mloop[mp->loopstart + i].v] = buf;
+        buf->next = vmap->vert[mloop[poly->loopstart + i].v];
+        vmap->vert[mloop[poly->loopstart + i].v] = buf;
 
         if (use_winding) {
-          copy_v2_v2(tf_uv[i], mloopuv[mpoly[a].loopstart + i]);
+          copy_v2_v2(tf_uv[i], mloopuv[polys[a].loopstart + i]);
         }
 
         buf++;
@@ -123,14 +123,14 @@ UvVertMap *BKE_mesh_uv_vert_map_create(const MPoly *mpoly,
       v->next = newvlist;
       newvlist = v;
 
-      uv = mloopuv[mpoly[v->poly_index].loopstart + v->loop_of_poly_index];
+      uv = mloopuv[polys[v->poly_index].loopstart + v->loop_of_poly_index];
       lastv = nullptr;
       iterv = vlist;
 
       while (iterv) {
         next = iterv->next;
 
-        uv2 = mloopuv[mpoly[iterv->poly_index].loopstart + iterv->loop_of_poly_index];
+        uv2 = mloopuv[polys[iterv->poly_index].loopstart + iterv->loop_of_poly_index];
         sub_v2_v2v2(uvdiff, uv2, uv);
 
         if (fabsf(uv[0] - uv2[0]) < limit[0] && fabsf(uv[1] - uv2[1]) < limit[1] &&
@@ -193,7 +193,7 @@ void BKE_mesh_uv_vert_map_free(UvVertMap *vmap)
  */
 static void mesh_vert_poly_or_loop_map_create(MeshElemMap **r_map,
                                               int **r_mem,
-                                              const MPoly *mpoly,
+                                              const MPoly *polys,
                                               const MLoop *mloop,
                                               int totvert,
                                               int totpoly,
@@ -209,10 +209,10 @@ static void mesh_vert_poly_or_loop_map_create(MeshElemMap **r_map,
 
   /* Count number of polys for each vertex */
   for (i = 0; i < totpoly; i++) {
-    const MPoly *p = &mpoly[i];
+    const MPoly *poly = &polys[i];
 
-    for (j = 0; j < p->totloop; j++) {
-      map[mloop[p->loopstart + j].v].count++;
+    for (j = 0; j < poly->totloop; j++) {
+      map[mloop[poly->loopstart + j].v].count++;
     }
   }
 
@@ -227,12 +227,12 @@ static void mesh_vert_poly_or_loop_map_create(MeshElemMap **r_map,
 
   /* Find the users */
   for (i = 0; i < totpoly; i++) {
-    const MPoly *p = &mpoly[i];
+    const MPoly *poly = &polys[i];
 
-    for (j = 0; j < p->totloop; j++) {
-      uint v = mloop[p->loopstart + j].v;
+    for (j = 0; j < poly->totloop; j++) {
+      uint v = mloop[poly->loopstart + j].v;
 
-      map[v].indices[map[v].count] = do_loops ? p->loopstart + j : i;
+      map[v].indices[map[v].count] = do_loops ? poly->loopstart + j : i;
       map[v].count++;
     }
   }
@@ -243,24 +243,24 @@ static void mesh_vert_poly_or_loop_map_create(MeshElemMap **r_map,
 
 void BKE_mesh_vert_poly_map_create(MeshElemMap **r_map,
                                    int **r_mem,
-                                   const MPoly *mpoly,
+                                   const MPoly *polys,
                                    const MLoop *mloop,
                                    int totvert,
                                    int totpoly,
                                    int totloop)
 {
-  mesh_vert_poly_or_loop_map_create(r_map, r_mem, mpoly, mloop, totvert, totpoly, totloop, false);
+  mesh_vert_poly_or_loop_map_create(r_map, r_mem, polys, mloop, totvert, totpoly, totloop, false);
 }
 
 void BKE_mesh_vert_loop_map_create(MeshElemMap **r_map,
                                    int **r_mem,
-                                   const MPoly *mpoly,
+                                   const MPoly *polys,
                                    const MLoop *mloop,
                                    int totvert,
                                    int totpoly,
                                    int totloop)
 {
-  mesh_vert_poly_or_loop_map_create(r_map, r_mem, mpoly, mloop, totvert, totpoly, totloop, true);
+  mesh_vert_poly_or_loop_map_create(r_map, r_mem, polys, mloop, totvert, totpoly, totloop, true);
 }
 
 void BKE_mesh_vert_looptri_map_create(MeshElemMap **r_map,
@@ -307,7 +307,7 @@ void BKE_mesh_vert_looptri_map_create(MeshElemMap **r_map,
 }
 
 void BKE_mesh_vert_edge_map_create(
-    MeshElemMap **r_map, int **r_mem, const MEdge *medge, int totvert, int totedge)
+    MeshElemMap **r_map, int **r_mem, const MEdge *edges, int totvert, int totedge)
 {
   MeshElemMap *map = MEM_cnew_array<MeshElemMap>(size_t(totvert), __func__);
   int *indices = static_cast<int *>(MEM_mallocN(sizeof(int[2]) * size_t(totedge), __func__));
@@ -317,8 +317,8 @@ void BKE_mesh_vert_edge_map_create(
 
   /* Count number of edges for each vertex */
   for (i = 0; i < totedge; i++) {
-    map[medge[i].v1].count++;
-    map[medge[i].v2].count++;
+    map[edges[i].v1].count++;
+    map[edges[i].v2].count++;
   }
 
   /* Assign indices mem */
@@ -332,7 +332,7 @@ void BKE_mesh_vert_edge_map_create(
 
   /* Find the users */
   for (i = 0; i < totedge; i++) {
-    const uint v[2] = {medge[i].v1, medge[i].v2};
+    const uint v[2] = {edges[i].v1, edges[i].v2};
 
     map[v[0]].indices[map[v[0]].count] = i;
     map[v[1]].indices[map[v[1]].count] = i;
@@ -346,7 +346,7 @@ void BKE_mesh_vert_edge_map_create(
 }
 
 void BKE_mesh_vert_edge_vert_map_create(
-    MeshElemMap **r_map, int **r_mem, const MEdge *medge, int totvert, int totedge)
+    MeshElemMap **r_map, int **r_mem, const MEdge *edges, int totvert, int totedge)
 {
   MeshElemMap *map = MEM_cnew_array<MeshElemMap>(size_t(totvert), __func__);
   int *indices = static_cast<int *>(MEM_mallocN(sizeof(int[2]) * size_t(totedge), __func__));
@@ -356,8 +356,8 @@ void BKE_mesh_vert_edge_vert_map_create(
 
   /* Count number of edges for each vertex */
   for (i = 0; i < totedge; i++) {
-    map[medge[i].v1].count++;
-    map[medge[i].v2].count++;
+    map[edges[i].v1].count++;
+    map[edges[i].v2].count++;
   }
 
   /* Assign indices mem */
@@ -371,7 +371,7 @@ void BKE_mesh_vert_edge_vert_map_create(
 
   /* Find the users */
   for (i = 0; i < totedge; i++) {
-    const uint v[2] = {medge[i].v1, medge[i].v2};
+    const uint v[2] = {edges[i].v1, edges[i].v2};
 
     map[v[0]].indices[map[v[0]].count] = int(v[1]);
     map[v[1]].indices[map[v[1]].count] = int(v[0]);
@@ -387,7 +387,7 @@ void BKE_mesh_vert_edge_vert_map_create(
 void BKE_mesh_edge_loop_map_create(MeshElemMap **r_map,
                                    int **r_mem,
                                    const int totedge,
-                                   const MPoly *mpoly,
+                                   const MPoly *polys,
                                    const int totpoly,
                                    const MLoop *mloop,
                                    const int totloop)
@@ -395,14 +395,14 @@ void BKE_mesh_edge_loop_map_create(MeshElemMap **r_map,
   MeshElemMap *map = MEM_cnew_array<MeshElemMap>(size_t(totedge), __func__);
   int *indices = static_cast<int *>(MEM_mallocN(sizeof(int) * size_t(totloop) * 2, __func__));
   int *index_step;
-  const MPoly *mp;
+  const MPoly *poly;
   int i;
 
   /* count face users */
-  for (i = 0, mp = mpoly; i < totpoly; mp++, i++) {
+  for (i = 0, poly = polys; i < totpoly; poly++, i++) {
     const MLoop *ml;
-    int j = mp->totloop;
-    for (ml = &mloop[mp->loopstart]; j--; ml++) {
+    int j = poly->totloop;
+    for (ml = &mloop[poly->loopstart]; j--; ml++) {
       map[ml->e].count += 2;
     }
   }
@@ -418,18 +418,18 @@ void BKE_mesh_edge_loop_map_create(MeshElemMap **r_map,
   }
 
   /* assign loop-edge users */
-  for (i = 0, mp = mpoly; i < totpoly; mp++, i++) {
+  for (i = 0, poly = polys; i < totpoly; poly++, i++) {
     const MLoop *ml;
     MeshElemMap *map_ele;
-    const int max_loop = mp->loopstart + mp->totloop;
-    int j = mp->loopstart;
+    const int max_loop = poly->loopstart + poly->totloop;
+    int j = poly->loopstart;
     for (ml = &mloop[j]; j < max_loop; j++, ml++) {
       map_ele = &map[ml->e];
       map_ele->indices[map_ele->count++] = j;
       map_ele->indices[map_ele->count++] = j + 1;
     }
     /* last edge/loop of poly, must point back to first loop! */
-    map_ele->indices[map_ele->count - 1] = mp->loopstart;
+    map_ele->indices[map_ele->count - 1] = poly->loopstart;
   }
 
   *r_map = map;
@@ -439,7 +439,7 @@ void BKE_mesh_edge_loop_map_create(MeshElemMap **r_map,
 void BKE_mesh_edge_poly_map_create(MeshElemMap **r_map,
                                    int **r_mem,
                                    const int totedge,
-                                   const MPoly *mpoly,
+                                   const MPoly *polys,
                                    const int totpoly,
                                    const MLoop *mloop,
                                    const int totloop)
@@ -447,14 +447,14 @@ void BKE_mesh_edge_poly_map_create(MeshElemMap **r_map,
   MeshElemMap *map = MEM_cnew_array<MeshElemMap>(size_t(totedge), __func__);
   int *indices = static_cast<int *>(MEM_mallocN(sizeof(int) * size_t(totloop), __func__));
   int *index_step;
-  const MPoly *mp;
+  const MPoly *poly;
   int i;
 
   /* count face users */
-  for (i = 0, mp = mpoly; i < totpoly; mp++, i++) {
+  for (i = 0, poly = polys; i < totpoly; poly++, i++) {
     const MLoop *ml;
-    int j = mp->totloop;
-    for (ml = &mloop[mp->loopstart]; j--; ml++) {
+    int j = poly->totloop;
+    for (ml = &mloop[poly->loopstart]; j--; ml++) {
       map[ml->e].count++;
     }
   }
@@ -470,10 +470,10 @@ void BKE_mesh_edge_poly_map_create(MeshElemMap **r_map,
   }
 
   /* assign poly-edge users */
-  for (i = 0, mp = mpoly; i < totpoly; mp++, i++) {
+  for (i = 0, poly = polys; i < totpoly; poly++, i++) {
     const MLoop *ml;
-    int j = mp->totloop;
-    for (ml = &mloop[mp->loopstart]; j--; ml++) {
+    int j = poly->totloop;
+    for (ml = &mloop[poly->loopstart]; j--; ml++) {
       MeshElemMap *map_ele = &map[ml->e];
       map_ele->indices[map_ele->count++] = i;
     }
@@ -526,21 +526,21 @@ void BKE_mesh_origindex_map_create(MeshElemMap **r_map,
 
 void BKE_mesh_origindex_map_create_looptri(MeshElemMap **r_map,
                                            int **r_mem,
-                                           const MPoly *mpoly,
-                                           const int mpoly_num,
+                                           const MPoly *polys,
+                                           const int polys_num,
                                            const MLoopTri *looptri,
                                            const int looptri_num)
 {
-  MeshElemMap *map = MEM_cnew_array<MeshElemMap>(size_t(mpoly_num), __func__);
+  MeshElemMap *map = MEM_cnew_array<MeshElemMap>(size_t(polys_num), __func__);
   int *indices = static_cast<int *>(MEM_mallocN(sizeof(int) * size_t(looptri_num), __func__));
   int *index_step;
   int i;
 
   /* create offsets */
   index_step = indices;
-  for (i = 0; i < mpoly_num; i++) {
+  for (i = 0; i < polys_num; i++) {
     map[i].indices = index_step;
-    index_step += ME_POLY_TRI_TOT(&mpoly[i]);
+    index_step += ME_POLY_TRI_TOT(&polys[i]);
   }
 
   /* assign poly-tessface users */
@@ -842,7 +842,7 @@ static void poly_edge_loop_islands_calc(const int totedge,
 }
 
 int *BKE_mesh_calc_smoothgroups(const int totedge,
-                                const MPoly *mpoly,
+                                const MPoly *polys,
                                 const int totpoly,
                                 const MLoop *mloop,
                                 const int totloop,
@@ -859,19 +859,19 @@ int *BKE_mesh_calc_smoothgroups(const int totedge,
                                             const MeshElemMap &edge_poly_map_elem) {
     /* Edge is sharp if one of its polys is flat, or edge itself is sharp,
      * or edge is not used by exactly two polygons. */
-    if ((mpoly[poly_index].flag & ME_SMOOTH) && !(sharp_edges && sharp_edges[edge_index]) &&
+    if ((polys[poly_index].flag & ME_SMOOTH) && !(sharp_edges && sharp_edges[edge_index]) &&
         (edge_user_count == 2)) {
       /* In that case, edge appears to be smooth, but we need to check its other poly too. */
       const int other_poly_index = (poly_index == edge_poly_map_elem.indices[0]) ?
                                        edge_poly_map_elem.indices[1] :
                                        edge_poly_map_elem.indices[0];
-      return (mpoly[other_poly_index].flag & ME_SMOOTH) == 0;
+      return (polys[other_poly_index].flag & ME_SMOOTH) == 0;
     }
     return true;
   };
 
   poly_edge_loop_islands_calc(totedge,
-                              {mpoly, totpoly},
+                              {polys, totpoly},
                               {mloop, totloop},
                               nullptr,
                               use_bitflags,
@@ -1134,9 +1134,9 @@ static bool mesh_calc_islands_loop_poly_uv(const int totedge,
       if (poly_groups[p_idx] != grp_idx) {
         continue;
       }
-      const MPoly *mp = &polys[p_idx];
+      const MPoly *poly = &polys[p_idx];
       poly_indices[num_pidx++] = p_idx;
-      for (l_idx = mp->loopstart, pl_idx = 0; pl_idx < mp->totloop; l_idx++, pl_idx++) {
+      for (l_idx = poly->loopstart, pl_idx = 0; pl_idx < poly->totloop; l_idx++, pl_idx++) {
         const MLoop *ml = &loops[l_idx];
         loop_indices[num_lidx++] = l_idx;
         if (num_edge_borders && BLI_BITMAP_TEST(edge_borders, ml->e) &&
diff --git a/source/blender/blenkernel/intern/mesh_normals.cc b/source/blender/blenkernel/intern/mesh_normals.cc
index 90533e4f5d5..7de1c130d88 100644
--- a/source/blender/blenkernel/intern/mesh_normals.cc
+++ b/source/blender/blenkernel/intern/mesh_normals.cc
@@ -165,12 +165,12 @@ bool BKE_mesh_poly_normals_are_dirty(const Mesh *mesh)
  * polygon See Graphics Gems for
  * computing newell normal.
  */
-static void mesh_calc_ngon_normal(const MPoly *mpoly,
+static void mesh_calc_ngon_normal(const MPoly *poly,
                                   const MLoop *loopstart,
                                   const float (*positions)[3],
                                   float r_normal[3])
 {
-  const int nverts = mpoly->totloop;
+  const int nverts = poly->totloop;
   const float *v_prev = positions[loopstart[nverts - 1].v];
   const float *v_curr;
 
@@ -188,21 +188,21 @@ static void mesh_calc_ngon_normal(const MPoly *mpoly,
   }
 }
 
-void BKE_mesh_calc_poly_normal(const MPoly *mpoly,
+void BKE_mesh_calc_poly_normal(const MPoly *poly,
                                const MLoop *loopstart,
                                const float (*vert_positions)[3],
                                float r_no[3])
 {
-  if (mpoly->totloop > 4) {
-    mesh_calc_ngon_normal(mpoly, loopstart, vert_positions, r_no);
+  if (poly->totloop > 4) {
+    mesh_calc_ngon_normal(poly, loopstart, vert_positions, r_no);
   }
-  else if (mpoly->totloop == 3) {
+  else if (poly->totloop == 3) {
     normal_tri_v3(r_no,
                   vert_positions[loopstart[0].v],
                   vert_positions[loopstart[1].v],
                   vert_positions[loopstart[2].v]);
   }
-  else if (mpoly->totloop == 4) {
+  else if (poly->totloop == 4) {
     normal_quad_v3(r_no,
                    vert_positions[loopstart[0].v],
                    vert_positions[loopstart[1].v],
@@ -237,14 +237,14 @@ void BKE_mesh_calc_normals_poly(const float (*vert_positions)[3],
                                 const int verts_num,
                                 const MLoop *mloop,
                                 const int mloop_len,
-                                const MPoly *mpoly,
-                                int mpoly_len,
+                                const MPoly *polys,
+                                int polys_len,
                                 float (*r_poly_normals)[3])
 {
   calculate_normals_poly({reinterpret_cast<const float3 *>(vert_positions), verts_num},
-                         {mpoly, mpoly_len},
+                         {polys, polys_len},
                          {mloop, mloop_len},
-                         {reinterpret_cast<float3 *>(r_poly_normals), mpoly_len});
+                         {reinterpret_cast<float3 *>(r_poly_normals), polys_len});
 }
 
 /** \} */
@@ -350,15 +350,15 @@ void BKE_mesh_calc_normals_poly_and_vertex(const float (*vert_positions)[3],
                                            const int mvert_len,
                                            const MLoop *mloop,
                                            const int mloop_len,
-                                           const MPoly *mpoly,
-                                           const int mpoly_len,
+                                           const MPoly *polys,
+                                           const int polys_len,
                                            float (*r_poly_normals)[3],
                                            float (*r_vert_normals)[3])
 {
   calculate_normals_poly_and_vert({reinterpret_cast<const float3 *>(vert_positions), mvert_len},
-                                  {mpoly, mpoly_len},
+                                  {polys, polys_len},
                                   {mloop, mloop_len},
-                                  {reinterpret_cast<float3 *>(r_poly_normals), mpoly_len},
+                                  {reinterpret_cast<float3 *>(r_poly_normals), polys_len},
                                   {reinterpret_cast<float3 *>(r_vert_normals), mvert_len});
 }
 
@@ -761,7 +761,7 @@ struct LoopSplitTaskData {
   int ml_curr_index;
   /** Also used a flag to switch between single or fan process! */
   int ml_prev_index;
-  int mp_index;
+  int poly_index;
 
   Type flag;
 };
@@ -861,7 +861,7 @@ static void mesh_edges_sharp_tag(const Span<MPoly> polys,
 void BKE_edges_sharp_from_angle_set(const int numEdges,
                                     const MLoop *mloops,
                                     const int numLoops,
-                                    const MPoly *mpolys,
+                                    const MPoly *polys,
                                     const float (*poly_normals)[3],
                                     const int numPolys,
                                     const float split_angle,
@@ -878,10 +878,10 @@ void BKE_edges_sharp_from_angle_set(const int numEdges,
   Array<int2> edge_to_loops(numEdges, int2(0));
 
   /* Simple mapping from a loop to its polygon index. */
-  const Array<int> loop_to_poly = mesh_topology::build_loop_to_poly_map({mpolys, numPolys},
+  const Array<int> loop_to_poly = mesh_topology::build_loop_to_poly_map({polys, numPolys},
                                                                         numLoops);
 
-  mesh_edges_sharp_tag({mpolys, numPolys},
+  mesh_edges_sharp_tag({polys, numPolys},
                        {mloops, numLoops},
                        loop_to_poly,
                        {reinterpret_cast<const float3 *>(poly_normals), numPolys},
@@ -950,19 +950,19 @@ static void split_loop_nor_single_do(LoopSplitTaskDataCommon *common_data, LoopS
   MLoopNorSpace *lnor_space = data->lnor_space;
   const int ml_curr_index = data->ml_curr_index;
   const int ml_prev_index = data->ml_prev_index;
-  const int mp_index = data->mp_index;
+  const int poly_index = data->poly_index;
 
   /* Simple case (both edges around that vertex are sharp in current polygon),
    * this loop just takes its poly normal.
    */
-  loop_normals[ml_curr_index] = poly_normals[mp_index];
+  loop_normals[ml_curr_index] = poly_normals[poly_index];
 
 #if 0
   printf("BASIC: handling loop %d / edge %d / vert %d / poly %d\n",
          ml_curr_index,
          loops[ml_curr_index].e,
          loops[ml_curr_index].v,
-         mp_index);
+         poly_index);
 #endif
 
   /* If needed, generate this (simple!) lnor space. */
@@ -1013,7 +1013,7 @@ static void split_loop_nor_fan_do(LoopSplitTaskDataCommon *common_data,
 #endif
   const int ml_curr_index = data->ml_curr_index;
   const int ml_prev_index = data->ml_prev_index;
-  const int mp_index = data->mp_index;
+  const int poly_index = data->poly_index;
 
   /* Sigh! we have to fan around current vertex, until we find the other non-smooth edge,
    * and accumulate face normals into the vertex!
@@ -1044,7 +1044,7 @@ static void split_loop_nor_fan_do(LoopSplitTaskDataCommon *common_data,
    */
   int mlfan_curr_index = ml_prev_index;
   int mlfan_vert_index = ml_curr_index;
-  int mpfan_curr_index = mp_index;
+  int mpfan_curr_index = poly_index;
 
   BLI_assert(mlfan_curr_index >= 0);
   BLI_assert(mlfan_vert_index >= 0);
@@ -1235,7 +1235,7 @@ static void loop_split_worker(TaskPool *__restrict pool, void *taskdata)
  * and yet we need to walk them once, and only once.
  */
 static bool loop_split_generator_check_cyclic_smooth_fan(const Span<MLoop> mloops,
-                                                         const Span<MPoly> mpolys,
+                                                         const Span<MPoly> polys,
                                                          const Span<int2> edge_to_loops,
                                                          const Span<int> loop_to_poly,
                                                          const int *e2l_prev,
@@ -1268,7 +1268,7 @@ static bool loop_split_generator_check_cyclic_smooth_fan(const Span<MLoop> mloop
   while (true) {
     /* Find next loop of the smooth fan. */
     loop_manifold_fan_around_vert_next(mloops,
-                                       mpolys,
+                                       polys,
                                        loop_to_poly,
                                        e2lfan_curr,
                                        mv_pivot_index,
@@ -1331,8 +1331,8 @@ static void loop_split_generator(TaskPool *pool, LoopSplitTaskDataCommon *common
   /* We now know edges that can be smoothed (with their vector, and their two loops),
    * and edges that will be hard! Now, time to generate the normals.
    */
-  for (const int mp_index : polys.index_range()) {
-    const MPoly &poly = polys[mp_index];
+  for (const int poly_index : polys.index_range()) {
+    const MPoly &poly = polys[poly_index];
 
     for (const int ml_curr_index : IndexRange(poly.loopstart, poly.totloop)) {
       const int ml_prev_index = mesh_topology::poly_loop_prev(poly, ml_curr_index);
@@ -1366,7 +1366,7 @@ static void loop_split_generator(TaskPool *pool, LoopSplitTaskDataCommon *common
                                                          skip_loops,
                                                          ml_curr_index,
                                                          ml_prev_index,
-                                                         mp_index))) {
+                                                         poly_index))) {
         // printf("SKIPPING!\n");
       }
       else {
@@ -1391,7 +1391,7 @@ static void loop_split_generator(TaskPool *pool, LoopSplitTaskDataCommon *common
           data->ml_curr_index = ml_curr_index;
           data->ml_prev_index = ml_prev_index;
           data->flag = LoopSplitTaskData::Type::Single;
-          data->mp_index = mp_index;
+          data->poly_index = poly_index;
           if (lnors_spacearr) {
             data->lnor_space = BKE_lnor_space_create(lnors_spacearr);
           }
@@ -1407,7 +1407,7 @@ static void loop_split_generator(TaskPool *pool, LoopSplitTaskDataCommon *common
           data->ml_curr_index = ml_curr_index;
           data->ml_prev_index = ml_prev_index;
           data->flag = LoopSplitTaskData::Type::Fan;
-          data->mp_index = mp_index;
+          data->poly_index = poly_index;
           if (lnors_spacearr) {
             data->lnor_space = BKE_lnor_space_create(lnors_spacearr);
           }
@@ -1439,12 +1439,12 @@ static void loop_split_generator(TaskPool *pool, LoopSplitTaskDataCommon *common
 void BKE_mesh_normals_loop_split(const float (*vert_positions)[3],
                                  const float (*vert_normals)[3],
                                  const int numVerts,
-                                 const MEdge *medges,
+                                 const MEdge *edges,
                                  const int numEdges,
                                  const MLoop *mloops,
                                  float (*r_loop_normals)[3],
                                  const int numLoops,
-                                 const MPoly *mpolys,
+                                 const MPoly *polys,
                                  const float (*poly_normals)[3],
                                  const int numPolys,
                                  const bool use_split_normals,
@@ -1467,17 +1467,17 @@ void BKE_mesh_normals_loop_split(const float (*vert_positions)[3],
      * since we may want to use loop_normals even when mesh's 'autosmooth' is disabled
      * (see e.g. mesh mapping code). As usual, we could handle that on case-by-case basis,
      * but simpler to keep it well confined here. */
-    int mp_index;
+    int poly_index;
 
-    for (mp_index = 0; mp_index < numPolys; mp_index++) {
-      const MPoly *mp = &mpolys[mp_index];
-      int ml_index = mp->loopstart;
-      const int ml_index_end = ml_index + mp->totloop;
-      const bool is_poly_flat = ((mp->flag & ME_SMOOTH) == 0);
+    for (poly_index = 0; poly_index < numPolys; poly_index++) {
+      const MPoly *poly = &polys[poly_index];
+      int ml_index = poly->loopstart;
+      const int ml_index_end = ml_index + poly->totloop;
+      const bool is_poly_flat = ((poly->flag & ME_SMOOTH) == 0);
 
       for (; ml_index < ml_index_end; ml_index++) {
         if (is_poly_flat) {
-          copy_v3_v3(r_loop_normals[ml_index], poly_normals[mp_index]);
+          copy_v3_v3(r_loop_normals[ml_index], poly_normals[poly_index]);
         }
         else {
           copy_v3_v3(r_loop_normals[ml_index], vert_normals[mloops[ml_index].v]);
@@ -1510,7 +1510,7 @@ void BKE_mesh_normals_loop_split(const float (*vert_positions)[3],
     loop_to_poly = {loop_to_poly_map, numLoops};
   }
   else {
-    local_loop_to_poly_map = mesh_topology::build_loop_to_poly_map({mpolys, numPolys}, numLoops);
+    local_loop_to_poly_map = mesh_topology::build_loop_to_poly_map({polys, numPolys}, numLoops);
     loop_to_poly = local_loop_to_poly_map;
   }
 
@@ -1531,7 +1531,6 @@ void BKE_mesh_normals_loop_split(const float (*vert_positions)[3],
     BKE_lnor_spacearr_init(r_lnors_spacearr, numLoops, MLNOR_SPACEARR_LOOP_INDEX);
   }
 
-  const Span<MPoly> polys(mpolys, numPolys);
   const Span<MLoop> loops(mloops, numLoops);
 
   /* Init data common to all tasks. */
@@ -1540,8 +1539,8 @@ void BKE_mesh_normals_loop_split(const float (*vert_positions)[3],
   common_data.loop_normals = {reinterpret_cast<float3 *>(r_loop_normals), numLoops};
   common_data.clnors_data = {reinterpret_cast<short2 *>(clnors_data), clnors_data ? numLoops : 0};
   common_data.positions = {reinterpret_cast<const float3 *>(vert_positions), numVerts};
-  common_data.edges = {medges, numEdges};
-  common_data.polys = polys;
+  common_data.edges = {edges, numEdges};
+  common_data.polys = {polys, numPolys};
   common_data.loops = loops;
   common_data.edge_to_loops = edge_to_loops;
   common_data.loop_to_poly = loop_to_poly;
@@ -1550,7 +1549,7 @@ void BKE_mesh_normals_loop_split(const float (*vert_positions)[3],
 
   /* Pre-populate all loop normals as if their verts were all smooth.
    * This way we don't have to compute those later! */
-  threading::parallel_for(polys.index_range(), 1024, [&](const IndexRange range) {
+  threading::parallel_for(IndexRange(numPolys), 1024, [&](const IndexRange range) {
     for (const int poly_i : range) {
       const MPoly &poly = polys[poly_i];
       for (const int loop_i : IndexRange(poly.loopstart, poly.totloop)) {
@@ -1560,7 +1559,7 @@ void BKE_mesh_normals_loop_split(const float (*vert_positions)[3],
   });
 
   /* This first loop check which edges are actually smooth, and compute edge vectors. */
-  mesh_edges_sharp_tag(polys,
+  mesh_edges_sharp_tag({polys, numPolys},
                        loops,
                        loop_to_poly,
                        {reinterpret_cast<const float3 *>(poly_normals), numPolys},
@@ -1607,12 +1606,12 @@ void BKE_mesh_normals_loop_split(const float (*vert_positions)[3],
 static void mesh_normals_loop_custom_set(const float (*positions)[3],
                                          const float (*vert_normals)[3],
                                          const int numVerts,
-                                         const MEdge *medges,
+                                         const MEdge *edges,
                                          const int numEdges,
                                          const MLoop *mloops,
                                          float (*r_custom_loop_normals)[3],
                                          const int numLoops,
-                                         const MPoly *mpolys,
+                                         const MPoly *polys,
                                          const float (*poly_normals)[3],
                                          const int numPolys,
                                          MutableSpan<bool> sharp_edges,
@@ -1631,7 +1630,7 @@ static void mesh_normals_loop_custom_set(const float (*positions)[3],
   BitVector<> done_loops(numLoops, false);
   float(*loop_normals)[3] = (float(*)[3])MEM_calloc_arrayN(
       size_t(numLoops), sizeof(*loop_normals), __func__);
-  const Array<int> loop_to_poly = mesh_topology::build_loop_to_poly_map({mpolys, numPolys},
+  const Array<int> loop_to_poly = mesh_topology::build_loop_to_poly_map({polys, numPolys},
                                                                         numLoops);
   /* In this case we always consider split nors as ON,
    * and do not want to use angle to define smooth fans! */
@@ -1644,12 +1643,12 @@ static void mesh_normals_loop_custom_set(const float (*positions)[3],
   BKE_mesh_normals_loop_split(positions,
                               vert_normals,
                               numVerts,
-                              medges,
+                              edges,
                               numEdges,
                               mloops,
                               loop_normals,
                               numLoops,
-                              mpolys,
+                              polys,
                               poly_normals,
                               numPolys,
                               use_split_normals,
@@ -1734,9 +1733,9 @@ static void mesh_normals_loop_custom_set(const float (*positions)[3],
            * previous loop's face and current's one as sharp.
            * We know those two loops do not point to the same edge,
            * since we do not allow reversed winding in a same smooth fan. */
-          const MPoly *mp = &mpolys[loop_to_poly[lidx]];
+          const MPoly *poly = &polys[loop_to_poly[lidx]];
           const MLoop *mlp =
-              &mloops[(lidx == mp->loopstart) ? mp->loopstart + mp->totloop - 1 : lidx - 1];
+              &mloops[(lidx == poly->loopstart) ? poly->loopstart + poly->totloop - 1 : lidx - 1];
           sharp_edges[(prev_ml->e == mlp->e) ? prev_ml->e : ml->e] = true;
 
           org_nor = nor;
@@ -1759,9 +1758,9 @@ static void mesh_normals_loop_custom_set(const float (*positions)[3],
         float *nor = r_custom_loop_normals[nidx];
 
         if (dot_v3v3(org_nor, nor) < LNOR_SPACE_TRIGO_THRESHOLD) {
-          const MPoly *mp = &mpolys[loop_to_poly[lidx]];
+          const MPoly *poly = &polys[loop_to_poly[lidx]];
           const MLoop *mlp =
-              &mloops[(lidx == mp->loopstart) ? mp->loopstart + mp->totloop - 1 : lidx - 1];
+              &mloops[(lidx == poly->loopstart) ? poly->loopstart + poly->totloop - 1 : lidx - 1];
           sharp_edges[(prev_ml->e == mlp->e) ? prev_ml->e : ml->e] = true;
         }
       }
@@ -1772,12 +1771,12 @@ static void mesh_normals_loop_custom_set(const float (*positions)[3],
     BKE_mesh_normals_loop_split(positions,
                                 vert_normals,
                                 numVerts,
-                                medges,
+                                edges,
                                 numEdges,
                                 mloops,
                                 loop_normals,
                                 numLoops,
-                                mpolys,
+                                polys,
                                 poly_normals,
                                 numPolys,
                                 use_split_normals,
@@ -1850,12 +1849,12 @@ static void mesh_normals_loop_custom_set(const float (*positions)[3],
 void BKE_mesh_normals_loop_custom_set(const float (*vert_positions)[3],
                                       const float (*vert_normals)[3],
                                       const int numVerts,
-                                      const MEdge *medges,
+                                      const MEdge *edges,
                                       const int numEdges,
                                       const MLoop *mloops,
                                       float (*r_custom_loop_normals)[3],
                                       const int numLoops,
-                                      const MPoly *mpolys,
+                                      const MPoly *polys,
                                       const float (*poly_normals)[3],
                                       const int numPolys,
                                       bool *sharp_edges,
@@ -1864,12 +1863,12 @@ void BKE_mesh_normals_loop_custom_set(const float (*vert_positions)[3],
   mesh_normals_loop_custom_set(vert_positions,
                                vert_normals,
                                numVerts,
-                               medges,
+                               edges,
                                numEdges,
                                mloops,
                                r_custom_loop_normals,
                                numLoops,
-                               mpolys,
+                               polys,
                                poly_normals,
                                numPolys,
                                {sharp_edges, numEdges},
@@ -1881,11 +1880,11 @@ void BKE_mesh_normals_loop_custom_from_verts_set(const float (*vert_positions)[3
                                                  const float (*vert_normals)[3],
                                                  float (*r_custom_vert_normals)[3],
                                                  const int numVerts,
-                                                 const MEdge *medges,
+                                                 const MEdge *edges,
                                                  const int numEdges,
                                                  const MLoop *mloops,
                                                  const int numLoops,
-                                                 const MPoly *mpolys,
+                                                 const MPoly *polys,
                                                  const float (*poly_normals)[3],
                                                  const int numPolys,
                                                  bool *sharp_edges,
@@ -1894,12 +1893,12 @@ void BKE_mesh_normals_loop_custom_from_verts_set(const float (*vert_positions)[3
   mesh_normals_loop_custom_set(vert_positions,
                                vert_normals,
                                numVerts,
-                               medges,
+                               edges,
                                numEdges,
                                mloops,
                                r_custom_vert_normals,
                                numLoops,
-                               mpolys,
+                               polys,
                                poly_normals,
                                numPolys,
                                {sharp_edges, numEdges},
diff --git a/source/blender/blenkernel/intern/mesh_remap.cc b/source/blender/blenkernel/intern/mesh_remap.cc
index f5f9420c6f0..82b4ae5f8e7 100644
--- a/source/blender/blenkernel/intern/mesh_remap.cc
+++ b/source/blender/blenkernel/intern/mesh_remap.cc
@@ -531,22 +531,22 @@ void BKE_mesh_remap_calc_verts_from_mesh(const int mode,
 
         if (mesh_remap_bvhtree_query_nearest(
                 &treedata, &nearest, tmp_co, max_dist_sq, &hit_dist)) {
-          const MEdge *me = &edges_src[nearest.index];
-          const float *v1cos = vcos_src[me->v1];
-          const float *v2cos = vcos_src[me->v2];
+          const MEdge *edge = &edges_src[nearest.index];
+          const float *v1cos = vcos_src[edge->v1];
+          const float *v2cos = vcos_src[edge->v2];
 
           if (mode == MREMAP_MODE_VERT_EDGE_NEAREST) {
             const float dist_v1 = len_squared_v3v3(tmp_co, v1cos);
             const float dist_v2 = len_squared_v3v3(tmp_co, v2cos);
-            const int index = int((dist_v1 > dist_v2) ? me->v2 : me->v1);
+            const int index = int((dist_v1 > dist_v2) ? edge->v2 : edge->v1);
             mesh_remap_item_define(r_map, i, hit_dist, 0, 1, &index, &full_weight);
           }
           else if (mode == MREMAP_MODE_VERT_EDGEINTERP_NEAREST) {
             int indices[2];
             float weights[2];
 
-            indices[0] = int(me->v1);
-            indices[1] = int(me->v2);
+            indices[0] = int(edge->v1);
+            indices[1] = int(edge->v2);
 
             /* Weight is inverse of point factor here... */
             weights[0] = line_point_factor_v3(tmp_co, v2cos, v1cos);
@@ -792,8 +792,8 @@ void BKE_mesh_remap_calc_edges_from_mesh(const int mode,
           k = vert_to_edge_src_map[vidx_src].count;
 
           for (; k--; eidx_src++) {
-            const MEdge *e_src = &edges_src[*eidx_src];
-            const float *other_co_src = vcos_src[BKE_mesh_edge_other_vert(e_src, vidx_src)];
+            const MEdge *edge_src = &edges_src[*eidx_src];
+            const float *other_co_src = vcos_src[BKE_mesh_edge_other_vert(edge_src, vidx_src)];
             const float *other_co_dst =
                 vert_positions_dst[BKE_mesh_edge_other_vert(e_dst, int(vidx_dst))];
             const float totdist = first_dist + len_v3v3(other_co_src, other_co_dst);
@@ -899,9 +899,9 @@ void BKE_mesh_remap_calc_edges_from_mesh(const int mode,
           int best_eidx_src = -1;
 
           for (; nloops--; ml_src++) {
-            const MEdge *med_src = &edges_src[ml_src->e];
-            float *co1_src = vcos_src[med_src->v1];
-            float *co2_src = vcos_src[med_src->v2];
+            const MEdge *edge_src = &edges_src[ml_src->e];
+            float *co1_src = vcos_src[edge_src->v1];
+            float *co2_src = vcos_src[edge_src->v2];
             float co_src[3];
             float dist_sq;
 
@@ -942,7 +942,7 @@ void BKE_mesh_remap_calc_edges_from_mesh(const int mode,
       for (i = 0; i < numedges_dst; i++) {
         /* For each dst edge, we sample some rays from it (interpolated from its vertices)
          * and use their hits to interpolate from source edges. */
-        const MEdge *me = &edges_dst[i];
+        const MEdge *edge = &edges_dst[i];
         float v1_co[3], v2_co[3];
         float v1_no[3], v2_no[3];
 
@@ -955,11 +955,11 @@ void BKE_mesh_remap_calc_edges_from_mesh(const int mode,
         int sources_num = 0;
         int j;
 
-        copy_v3_v3(v1_co, vert_positions_dst[me->v1]);
-        copy_v3_v3(v2_co, vert_positions_dst[me->v2]);
+        copy_v3_v3(v1_co, vert_positions_dst[edge->v1]);
+        copy_v3_v3(v2_co, vert_positions_dst[edge->v2]);
 
-        copy_v3_v3(v1_no, vert_normals_dst[me->v1]);
-        copy_v3_v3(v2_no, vert_normals_dst[me->v2]);
+        copy_v3_v3(v1_no, vert_normals_dst[edge->v1]);
+        copy_v3_v3(v2_no, vert_normals_dst[edge->v2]);
 
         /* We do our transform here, allows to interpolate from normals already in src space. */
         if (space_transform) {
@@ -1059,11 +1059,11 @@ static void mesh_island_to_astar_graph_edge_process(MeshIslandStore *islands,
 
   for (i = 0; i < edge_to_poly_map[edge_idx].count; i++) {
     const int pidx = edge_to_poly_map[edge_idx].indices[i];
-    const MPoly *mp = &polys[pidx];
+    const MPoly *poly = &polys[pidx];
     const int pidx_isld = islands ? poly_island_index_map[pidx] : pidx;
     void *custom_data = is_edge_innercut ? POINTER_FROM_INT(edge_idx) : POINTER_FROM_INT(-1);
 
-    if (UNLIKELY(islands && (islands->items_to_islands[mp->loopstart] != island_index))) {
+    if (UNLIKELY(islands && (islands->items_to_islands[poly->loopstart] != island_index))) {
       /* poly not in current island, happens with border edges... */
       poly_island_indices[i] = -1;
       continue;
@@ -1075,7 +1075,7 @@ static void mesh_island_to_astar_graph_edge_process(MeshIslandStore *islands,
     }
 
     if (poly_status[pidx_isld] == POLY_UNSET) {
-      BKE_mesh_calc_poly_center(mp, &loops[mp->loopstart], positions, poly_centers[pidx_isld]);
+      BKE_mesh_calc_poly_center(poly, &loops[poly->loopstart], positions, poly_centers[pidx_isld]);
       BLI_astar_node_init(as_graph, pidx_isld, poly_centers[pidx_isld]);
       poly_status[pidx_isld] = POLY_CENTER_INIT;
     }
@@ -1156,14 +1156,14 @@ static void mesh_island_to_astar_graph(MeshIslandStore *islands,
 
   for (pidx_isld = node_num; pidx_isld--;) {
     const int pidx = islands ? island_poly_map->indices[pidx_isld] : pidx_isld;
-    const MPoly *mp = &polys[pidx];
+    const MPoly *poly = &polys[pidx];
     int pl_idx, l_idx;
 
     if (poly_status[pidx_isld] == POLY_COMPLETE) {
       continue;
     }
 
-    for (pl_idx = 0, l_idx = mp->loopstart; pl_idx < mp->totloop; pl_idx++, l_idx++) {
+    for (pl_idx = 0, l_idx = poly->loopstart; pl_idx < poly->totloop; pl_idx++, l_idx++) {
       const MLoop *ml = &loops[l_idx];
 
       if (BLI_BITMAP_TEST(done_edges, ml->e)) {
@@ -2195,9 +2195,9 @@ void BKE_mesh_remap_calc_polys_from_mesh(const int mode,
       nearest.index = -1;
 
       for (i = 0; i < numpolys_dst; i++) {
-        const MPoly *mp = &polys_dst[i];
+        const MPoly *poly = &polys_dst[i];
 
-        BKE_mesh_calc_poly_center(mp, &loops_dst[mp->loopstart], vert_positions_dst, tmp_co);
+        BKE_mesh_calc_poly_center(poly, &loops_dst[poly->loopstart], vert_positions_dst, tmp_co);
 
         /* Convert the vertex to tree coordinates, if needed. */
         if (space_transform) {
@@ -2220,9 +2220,9 @@ void BKE_mesh_remap_calc_polys_from_mesh(const int mode,
       BLI_assert(poly_nors_dst);
 
       for (i = 0; i < numpolys_dst; i++) {
-        const MPoly *mp = &polys_dst[i];
+        const MPoly *poly = &polys_dst[i];
 
-        BKE_mesh_calc_poly_center(mp, &loops_dst[mp->loopstart], vert_positions_dst, tmp_co);
+        BKE_mesh_calc_poly_center(poly, &loops_dst[poly->loopstart], vert_positions_dst, tmp_co);
         copy_v3_v3(tmp_no, poly_nors_dst[i]);
 
         /* Convert the vertex to tree coordinates, if needed. */
@@ -2269,7 +2269,7 @@ void BKE_mesh_remap_calc_polys_from_mesh(const int mode,
         /* For each dst poly, we sample some rays from it (2D grid in pnor space)
          * and use their hits to interpolate from source polys. */
         /* NOTE: dst poly is early-converted into src space! */
-        const MPoly *mp = &polys_dst[i];
+        const MPoly *poly = &polys_dst[i];
 
         int tot_rays, done_rays = 0;
         float poly_area_2d_inv, done_area = 0.0f;
@@ -2282,10 +2282,11 @@ void BKE_mesh_remap_calc_polys_from_mesh(const int mode,
         float totweights = 0.0f;
         float hit_dist_accum = 0.0f;
         int sources_num = 0;
-        const int tris_num = mp->totloop - 2;
+        const int tris_num = poly->totloop - 2;
         int j;
 
-        BKE_mesh_calc_poly_center(mp, &loops_dst[mp->loopstart], vert_positions_dst, pcent_dst);
+        BKE_mesh_calc_poly_center(
+            poly, &loops_dst[poly->loopstart], vert_positions_dst, pcent_dst);
         copy_v3_v3(tmp_no, poly_nors_dst[i]);
 
         /* We do our transform here, else it'd be redone by raycast helper for each ray, ugh! */
@@ -2296,8 +2297,8 @@ void BKE_mesh_remap_calc_polys_from_mesh(const int mode,
 
         copy_vn_fl(weights, int(numpolys_src), 0.0f);
 
-        if (UNLIKELY(size_t(mp->totloop) > tmp_poly_size)) {
-          tmp_poly_size = size_t(mp->totloop);
+        if (UNLIKELY(size_t(poly->totloop) > tmp_poly_size)) {
+          tmp_poly_size = size_t(poly->totloop);
           poly_vcos_2d = static_cast<float(*)[2]>(
               MEM_reallocN(poly_vcos_2d, sizeof(*poly_vcos_2d) * tmp_poly_size));
           tri_vidx_2d = static_cast<int(*)[3]>(
@@ -2313,8 +2314,8 @@ void BKE_mesh_remap_calc_polys_from_mesh(const int mode,
         /* Get (2D) bounding square of our poly. */
         INIT_MINMAX2(poly_dst_2d_min, poly_dst_2d_max);
 
-        for (j = 0; j < mp->totloop; j++) {
-          const MLoop *ml = &loops_dst[j + mp->loopstart];
+        for (j = 0; j < poly->totloop; j++) {
+          const MLoop *ml = &loops_dst[j + poly->loopstart];
           copy_v3_v3(tmp_co, vert_positions_dst[ml->v]);
           if (space_transform) {
             BLI_space_transform_apply(space_transform, tmp_co);
@@ -2337,17 +2338,17 @@ void BKE_mesh_remap_calc_polys_from_mesh(const int mode,
         }
         tot_rays *= tot_rays;
 
-        poly_area_2d_inv = area_poly_v2(poly_vcos_2d, uint(mp->totloop));
+        poly_area_2d_inv = area_poly_v2(poly_vcos_2d, uint(poly->totloop));
         /* In case we have a null-area degenerated poly... */
         poly_area_2d_inv = 1.0f / max_ff(poly_area_2d_inv, 1e-9f);
 
         /* Tessellate our poly. */
-        if (mp->totloop == 3) {
+        if (poly->totloop == 3) {
           tri_vidx_2d[0][0] = 0;
           tri_vidx_2d[0][1] = 1;
           tri_vidx_2d[0][2] = 2;
         }
-        if (mp->totloop == 4) {
+        if (poly->totloop == 4) {
           tri_vidx_2d[0][0] = 0;
           tri_vidx_2d[0][1] = 1;
           tri_vidx_2d[0][2] = 2;
@@ -2356,7 +2357,7 @@ void BKE_mesh_remap_calc_polys_from_mesh(const int mode,
           tri_vidx_2d[1][2] = 3;
         }
         else {
-          BLI_polyfill_calc(poly_vcos_2d, uint(mp->totloop), -1, (uint(*)[3])tri_vidx_2d);
+          BLI_polyfill_calc(poly_vcos_2d, uint(poly->totloop), -1, (uint(*)[3])tri_vidx_2d);
         }
 
         for (j = 0; j < tris_num; j++) {
diff --git a/source/blender/blenkernel/intern/mesh_remesh_voxel.cc b/source/blender/blenkernel/intern/mesh_remesh_voxel.cc
index 1ecefce5bf5..aaffe1c158c 100644
--- a/source/blender/blenkernel/intern/mesh_remesh_voxel.cc
+++ b/source/blender/blenkernel/intern/mesh_remesh_voxel.cc
@@ -342,9 +342,9 @@ void BKE_remesh_reproject_sculpt_face_sets(Mesh *target, const Mesh *source)
       BVHTreeNearest nearest;
       nearest.index = -1;
       nearest.dist_sq = FLT_MAX;
-      const MPoly *mpoly = &target_polys[i];
-      BKE_mesh_calc_poly_center(mpoly,
-                                &target_loops[mpoly->loopstart],
+      const MPoly *poly = &target_polys[i];
+      BKE_mesh_calc_poly_center(poly,
+                                &target_loops[poly->loopstart],
                                 reinterpret_cast<const float(*)[3]>(target_positions.data()),
                                 from_co);
       BLI_bvhtree_find_nearest(
diff --git a/source/blender/blenkernel/intern/mesh_tangent.cc b/source/blender/blenkernel/intern/mesh_tangent.cc
index be7aaba94da..31387699557 100644
--- a/source/blender/blenkernel/intern/mesh_tangent.cc
+++ b/source/blender/blenkernel/intern/mesh_tangent.cc
@@ -44,33 +44,33 @@ struct BKEMeshToTangent {
 
   uint GetNumVerticesOfFace(const uint face_num)
   {
-    return uint(mpolys[face_num].totloop);
+    return uint(polys[face_num].totloop);
   }
 
   mikk::float3 GetPosition(const uint face_num, const uint vert_num)
   {
-    const uint loop_idx = uint(mpolys[face_num].loopstart) + vert_num;
+    const uint loop_idx = uint(polys[face_num].loopstart) + vert_num;
     return mikk::float3(positions[mloops[loop_idx].v]);
   }
 
   mikk::float3 GetTexCoord(const uint face_num, const uint vert_num)
   {
-    const float *uv = luvs[uint(mpolys[face_num].loopstart) + vert_num];
+    const float *uv = luvs[uint(polys[face_num].loopstart) + vert_num];
     return mikk::float3(uv[0], uv[1], 1.0f);
   }
 
   mikk::float3 GetNormal(const uint face_num, const uint vert_num)
   {
-    return mikk::float3(loop_normals[uint(mpolys[face_num].loopstart) + vert_num]);
+    return mikk::float3(loop_normals[uint(polys[face_num].loopstart) + vert_num]);
   }
 
   void SetTangentSpace(const uint face_num, const uint vert_num, mikk::float3 T, bool orientation)
   {
-    float *p_res = tangents[uint(mpolys[face_num].loopstart) + vert_num];
+    float *p_res = tangents[uint(polys[face_num].loopstart) + vert_num];
     copy_v4_fl4(p_res, T.x, T.y, T.z, orientation ? 1.0f : -1.0f);
   }
 
-  const MPoly *mpolys;            /* faces */
+  const MPoly *polys;             /* faces */
   const MLoop *mloops;            /* faces vertices */
   const float (*positions)[3];    /* vertices */
   const float (*luvs)[2];         /* texture coordinates */
@@ -86,13 +86,13 @@ void BKE_mesh_calc_loop_tangent_single_ex(const float (*vert_positions)[3],
                                           const float (*loop_normals)[3],
                                           const float (*loop_uvs)[2],
                                           const int /*numLoops*/,
-                                          const MPoly *mpolys,
+                                          const MPoly *polys,
                                           const int numPolys,
                                           ReportList *reports)
 {
   /* Compute Mikktspace's tangent normals. */
   BKEMeshToTangent mesh_to_tangent;
-  mesh_to_tangent.mpolys = mpolys;
+  mesh_to_tangent.polys = polys;
   mesh_to_tangent.mloops = mloops;
   mesh_to_tangent.positions = vert_positions;
   mesh_to_tangent.luvs = loop_uvs;
@@ -104,7 +104,7 @@ void BKE_mesh_calc_loop_tangent_single_ex(const float (*vert_positions)[3],
 
   /* First check we do have a tris/quads only mesh. */
   for (int i = 0; i < numPolys; i++) {
-    if (mpolys[i].totloop > 4) {
+    if (polys[i].totloop > 4) {
       BKE_report(
           reports, RPT_ERROR, "Tangent space can only be computed for tris/quads, aborting");
       return;
@@ -180,8 +180,8 @@ struct SGLSLMeshToTangent {
 #ifdef USE_LOOPTRI_DETECT_QUADS
     if (face_as_quad_map) {
       const MLoopTri *lt = &looptri[face_as_quad_map[face_num]];
-      const MPoly *mp = &mpoly[lt->poly];
-      if (mp->totloop == 4) {
+      const MPoly *poly = &polys[lt->poly];
+      if (poly->totloop == 4) {
         return 4;
       }
     }
@@ -197,9 +197,9 @@ struct SGLSLMeshToTangent {
 #ifdef USE_LOOPTRI_DETECT_QUADS
     if (face_as_quad_map) {
       lt = &looptri[face_as_quad_map[face_num]];
-      const MPoly *mp = &mpoly[lt->poly];
-      if (mp->totloop == 4) {
-        return (uint(mp->loopstart) + vert_num);
+      const MPoly *poly = &polys[lt->poly];
+      if (poly->totloop == 4) {
+        return (uint(poly->loopstart) + vert_num);
       }
       /* fall through to regular triangle */
     }
@@ -240,19 +240,19 @@ struct SGLSLMeshToTangent {
     if (precomputedLoopNormals) {
       return mikk::float3(precomputedLoopNormals[loop_index]);
     }
-    if ((mpoly[lt->poly].flag & ME_SMOOTH) == 0) { /* flat */
+    if ((polys[lt->poly].flag & ME_SMOOTH) == 0) { /* flat */
       if (precomputedFaceNormals) {
         return mikk::float3(precomputedFaceNormals[lt->poly]);
       }
 #ifdef USE_LOOPTRI_DETECT_QUADS
-      const MPoly *mp = &mpoly[lt->poly];
+      const MPoly *poly = &polys[lt->poly];
       float normal[3];
-      if (mp->totloop == 4) {
+      if (poly->totloop == 4) {
         normal_quad_v3(normal,
-                       positions[mloop[mp->loopstart + 0].v],
-                       positions[mloop[mp->loopstart + 1].v],
-                       positions[mloop[mp->loopstart + 2].v],
-                       positions[mloop[mp->loopstart + 3].v]);
+                       positions[mloop[poly->loopstart + 0].v],
+                       positions[mloop[poly->loopstart + 1].v],
+                       positions[mloop[poly->loopstart + 2].v],
+                       positions[mloop[poly->loopstart + 3].v]);
       }
       else
 #endif
@@ -279,7 +279,7 @@ struct SGLSLMeshToTangent {
   const float (*precomputedLoopNormals)[3];
   const MLoopTri *looptri;
   const float2 *mloopuv;       /* texture coordinates */
-  const MPoly *mpoly;          /* indices */
+  const MPoly *polys;          /* indices */
   const MLoop *mloop;          /* indices */
   const float (*positions)[3]; /* vertex coordinates */
   const float (*vert_normals)[3];
@@ -389,8 +389,8 @@ void BKE_mesh_calc_loop_tangent_step_0(const CustomData *loopData,
 }
 
 void BKE_mesh_calc_loop_tangent_ex(const float (*vert_positions)[3],
-                                   const MPoly *mpoly,
-                                   const uint mpoly_len,
+                                   const MPoly *polys,
+                                   const uint polys_len,
                                    const MLoop *mloop,
                                    const MLoopTri *looptri,
                                    const uint looptri_len,
@@ -456,7 +456,7 @@ void BKE_mesh_calc_loop_tangent_ex(const float (*vert_positions)[3],
     int *face_as_quad_map = nullptr;
 
     /* map faces to quads */
-    if (looptri_len != mpoly_len) {
+    if (looptri_len != polys_len) {
       /* Over allocate, since we don't know how many ngon or quads we have. */
 
       /* map fake face index to looptri */
@@ -465,7 +465,7 @@ void BKE_mesh_calc_loop_tangent_ex(const float (*vert_positions)[3],
       for (k = 0, j = 0; j < int(looptri_len); k++, j++) {
         face_as_quad_map[k] = j;
         /* step over all quads */
-        if (mpoly[looptri[j].poly].totloop == 4) {
+        if (polys[looptri[j].poly].totloop == 4) {
           j++; /* skips the nest looptri */
         }
       }
@@ -495,7 +495,7 @@ void BKE_mesh_calc_loop_tangent_ex(const float (*vert_positions)[3],
 #endif
         mesh2tangent->positions = vert_positions;
         mesh2tangent->vert_normals = vert_normals;
-        mesh2tangent->mpoly = mpoly;
+        mesh2tangent->polys = polys;
         mesh2tangent->mloop = mloop;
         mesh2tangent->looptri = looptri;
         /* NOTE: we assume we do have tessellated loop normals at this point
diff --git a/source/blender/blenkernel/intern/mesh_tessellate.cc b/source/blender/blenkernel/intern/mesh_tessellate.cc
index 275163c0007..4d3898b70ac 100644
--- a/source/blender/blenkernel/intern/mesh_tessellate.cc
+++ b/source/blender/blenkernel/intern/mesh_tessellate.cc
@@ -41,7 +41,7 @@
  * \param face_normal: This will be optimized out as a constant.
  */
 BLI_INLINE void mesh_calc_tessellation_for_face_impl(const MLoop *mloop,
-                                                     const MPoly *mpoly,
+                                                     const MPoly *polys,
                                                      const float (*positions)[3],
                                                      uint poly_index,
                                                      MLoopTri *mlt,
@@ -49,8 +49,8 @@ BLI_INLINE void mesh_calc_tessellation_for_face_impl(const MLoop *mloop,
                                                      const bool face_normal,
                                                      const float normal_precalc[3])
 {
-  const uint mp_loopstart = uint(mpoly[poly_index].loopstart);
-  const uint mp_totloop = uint(mpoly[poly_index].totloop);
+  const uint mp_loopstart = uint(polys[poly_index].loopstart);
+  const uint mp_totloop = uint(polys[poly_index].totloop);
 
 #define ML_TO_MLT(i1, i2, i3) \
   { \
@@ -151,18 +151,18 @@ BLI_INLINE void mesh_calc_tessellation_for_face_impl(const MLoop *mloop,
 }
 
 static void mesh_calc_tessellation_for_face(const MLoop *mloop,
-                                            const MPoly *mpoly,
+                                            const MPoly *polys,
                                             const float (*positions)[3],
                                             uint poly_index,
                                             MLoopTri *mlt,
                                             MemArena **pf_arena_p)
 {
   mesh_calc_tessellation_for_face_impl(
-      mloop, mpoly, positions, poly_index, mlt, pf_arena_p, false, nullptr);
+      mloop, polys, positions, poly_index, mlt, pf_arena_p, false, nullptr);
 }
 
 static void mesh_calc_tessellation_for_face_with_normal(const MLoop *mloop,
-                                                        const MPoly *mpoly,
+                                                        const MPoly *polys,
                                                         const float (*positions)[3],
                                                         uint poly_index,
                                                         MLoopTri *mlt,
@@ -170,11 +170,11 @@ static void mesh_calc_tessellation_for_face_with_normal(const MLoop *mloop,
                                                         const float normal_precalc[3])
 {
   mesh_calc_tessellation_for_face_impl(
-      mloop, mpoly, positions, poly_index, mlt, pf_arena_p, true, normal_precalc);
+      mloop, polys, positions, poly_index, mlt, pf_arena_p, true, normal_precalc);
 }
 
 static void mesh_recalc_looptri__single_threaded(const MLoop *mloop,
-                                                 const MPoly *mpoly,
+                                                 const MPoly *polys,
                                                  const float (*positions)[3],
                                                  int totloop,
                                                  int totpoly,
@@ -182,26 +182,26 @@ static void mesh_recalc_looptri__single_threaded(const MLoop *mloop,
                                                  const float (*poly_normals)[3])
 {
   MemArena *pf_arena = nullptr;
-  const MPoly *mp = mpoly;
+  const MPoly *poly = polys;
   uint tri_index = 0;
 
   if (poly_normals != nullptr) {
-    for (uint poly_index = 0; poly_index < uint(totpoly); poly_index++, mp++) {
+    for (uint poly_index = 0; poly_index < uint(totpoly); poly_index++, poly++) {
       mesh_calc_tessellation_for_face_with_normal(mloop,
-                                                  mpoly,
+                                                  polys,
                                                   positions,
                                                   poly_index,
                                                   &mlooptri[tri_index],
                                                   &pf_arena,
                                                   poly_normals[poly_index]);
-      tri_index += uint(mp->totloop - 2);
+      tri_index += uint(poly->totloop - 2);
     }
   }
   else {
-    for (uint poly_index = 0; poly_index < uint(totpoly); poly_index++, mp++) {
+    for (uint poly_index = 0; poly_index < uint(totpoly); poly_index++, poly++) {
       mesh_calc_tessellation_for_face(
-          mloop, mpoly, positions, poly_index, &mlooptri[tri_index], &pf_arena);
-      tri_index += uint(mp->totloop - 2);
+          mloop, polys, positions, poly_index, &mlooptri[tri_index], &pf_arena);
+      tri_index += uint(poly->totloop - 2);
     }
   }
 
@@ -215,7 +215,7 @@ static void mesh_recalc_looptri__single_threaded(const MLoop *mloop,
 
 struct TessellationUserData {
   const MLoop *mloop;
-  const MPoly *mpoly;
+  const MPoly *polys;
   const float (*positions)[3];
 
   /** Output array. */
@@ -235,9 +235,9 @@ static void mesh_calc_tessellation_for_face_fn(void *__restrict userdata,
 {
   const TessellationUserData *data = static_cast<const TessellationUserData *>(userdata);
   TessellationUserTLS *tls_data = static_cast<TessellationUserTLS *>(tls->userdata_chunk);
-  const int tri_index = poly_to_tri_count(index, data->mpoly[index].loopstart);
+  const int tri_index = poly_to_tri_count(index, data->polys[index].loopstart);
   mesh_calc_tessellation_for_face_impl(data->mloop,
-                                       data->mpoly,
+                                       data->polys,
                                        data->positions,
                                        uint(index),
                                        &data->mlooptri[tri_index],
@@ -252,9 +252,9 @@ static void mesh_calc_tessellation_for_face_with_normal_fn(void *__restrict user
 {
   const TessellationUserData *data = static_cast<const TessellationUserData *>(userdata);
   TessellationUserTLS *tls_data = static_cast<TessellationUserTLS *>(tls->userdata_chunk);
-  const int tri_index = poly_to_tri_count(index, data->mpoly[index].loopstart);
+  const int tri_index = poly_to_tri_count(index, data->polys[index].loopstart);
   mesh_calc_tessellation_for_face_impl(data->mloop,
-                                       data->mpoly,
+                                       data->polys,
                                        data->positions,
                                        uint(index),
                                        &data->mlooptri[tri_index],
@@ -273,7 +273,7 @@ static void mesh_calc_tessellation_for_face_free_fn(const void *__restrict /*use
 }
 
 static void mesh_recalc_looptri__multi_threaded(const MLoop *mloop,
-                                                const MPoly *mpoly,
+                                                const MPoly *polys,
                                                 const float (*positions)[3],
                                                 int /*totloop*/,
                                                 int totpoly,
@@ -285,7 +285,7 @@ static void mesh_recalc_looptri__multi_threaded(const MLoop *mloop,
   struct TessellationUserData data {
   };
   data.mloop = mloop;
-  data.mpoly = mpoly;
+  data.polys = polys;
   data.positions = positions;
   data.mlooptri = mlooptri;
   data.poly_normals = poly_normals;
@@ -307,7 +307,7 @@ static void mesh_recalc_looptri__multi_threaded(const MLoop *mloop,
 }
 
 void BKE_mesh_recalc_looptri(const MLoop *mloop,
-                             const MPoly *mpoly,
+                             const MPoly *polys,
                              const float (*vert_positions)[3],
                              int totloop,
                              int totpoly,
@@ -315,16 +315,16 @@ void BKE_mesh_recalc_looptri(const MLoop *mloop,
 {
   if (totloop < MESH_FACE_TESSELLATE_THREADED_LIMIT) {
     mesh_recalc_looptri__single_threaded(
-        mloop, mpoly, vert_positions, totloop, totpoly, mlooptri, nullptr);
+        mloop, polys, vert_positions, totloop, totpoly, mlooptri, nullptr);
   }
   else {
     mesh_recalc_looptri__multi_threaded(
-        mloop, mpoly, vert_positions, totloop, totpoly, mlooptri, nullptr);
+        mloop, polys, vert_positions, totloop, totpoly, mlooptri, nullptr);
   }
 }
 
 void BKE_mesh_recalc_looptri_with_normals(const MLoop *mloop,
-                                          const MPoly *mpoly,
+                                          const MPoly *polys,
                                           const float (*vert_positions)[3],
                                           int totloop,
                                           int totpoly,
@@ -334,11 +334,11 @@ void BKE_mesh_recalc_looptri_with_normals(const MLoop *mloop,
   BLI_assert(poly_normals != nullptr);
   if (totloop < MESH_FACE_TESSELLATE_THREADED_LIMIT) {
     mesh_recalc_looptri__single_threaded(
-        mloop, mpoly, vert_positions, totloop, totpoly, mlooptri, poly_normals);
+        mloop, polys, vert_positions, totloop, totpoly, mlooptri, poly_normals);
   }
   else {
     mesh_recalc_looptri__multi_threaded(
-        mloop, mpoly, vert_positions, totloop, totpoly, mlooptri, poly_normals);
+        mloop, polys, vert_positions, totloop, totpoly, mlooptri, poly_normals);
   }
 }
 
diff --git a/source/blender/blenkernel/intern/mesh_validate.cc b/source/blender/blenkernel/intern/mesh_validate.cc
index d644451d33e..f6adf1247bc 100644
--- a/source/blender/blenkernel/intern/mesh_validate.cc
+++ b/source/blender/blenkernel/intern/mesh_validate.cc
@@ -209,13 +209,13 @@ static int search_polyloop_cmp(const void *v1, const void *v2)
 bool BKE_mesh_validate_arrays(Mesh *mesh,
                               float (*vert_positions)[3],
                               uint totvert,
-                              MEdge *medges,
+                              MEdge *edges,
                               uint totedge,
                               MFace *mfaces,
                               uint totface,
                               MLoop *mloops,
                               uint totloop,
-                              MPoly *mpolys,
+                              MPoly *polys,
                               uint totpoly,
                               MDeformVert *dverts, /* assume totvert length */
                               const bool do_verbose,
@@ -247,9 +247,9 @@ bool BKE_mesh_validate_arrays(Mesh *mesh,
       mesh->attributes_for_write().lookup_for_write<int>("material_index");
   blender::MutableVArraySpan<int> material_indices_span(material_indices.varray);
 
-  MEdge *me;
+  MEdge *edge;
   MLoop *ml;
-  MPoly *mp;
+  MPoly *poly;
   uint i, j;
   int *v;
 
@@ -343,40 +343,40 @@ bool BKE_mesh_validate_arrays(Mesh *mesh,
     }
   }
 
-  for (i = 0, me = medges; i < totedge; i++, me++) {
+  for (i = 0, edge = edges; i < totedge; i++, edge++) {
     bool remove = false;
 
-    if (me->v1 == me->v2) {
-      PRINT_ERR("\tEdge %u: has matching verts, both %u", i, me->v1);
+    if (edge->v1 == edge->v2) {
+      PRINT_ERR("\tEdge %u: has matching verts, both %u", i, edge->v1);
       remove = do_fixes;
     }
-    if (me->v1 >= totvert) {
-      PRINT_ERR("\tEdge %u: v1 index out of range, %u", i, me->v1);
+    if (edge->v1 >= totvert) {
+      PRINT_ERR("\tEdge %u: v1 index out of range, %u", i, edge->v1);
       remove = do_fixes;
     }
-    if (me->v2 >= totvert) {
-      PRINT_ERR("\tEdge %u: v2 index out of range, %u", i, me->v2);
+    if (edge->v2 >= totvert) {
+      PRINT_ERR("\tEdge %u: v2 index out of range, %u", i, edge->v2);
       remove = do_fixes;
     }
 
-    if ((me->v1 != me->v2) && BLI_edgehash_haskey(edge_hash, me->v1, me->v2)) {
+    if ((edge->v1 != edge->v2) && BLI_edgehash_haskey(edge_hash, edge->v1, edge->v2)) {
       PRINT_ERR("\tEdge %u: is a duplicate of %d",
                 i,
-                POINTER_AS_INT(BLI_edgehash_lookup(edge_hash, me->v1, me->v2)));
+                POINTER_AS_INT(BLI_edgehash_lookup(edge_hash, edge->v1, edge->v2)));
       remove = do_fixes;
     }
 
     if (remove == false) {
-      if (me->v1 != me->v2) {
-        BLI_edgehash_insert(edge_hash, me->v1, me->v2, POINTER_FROM_INT(i));
+      if (edge->v1 != edge->v2) {
+        BLI_edgehash_insert(edge_hash, edge->v1, edge->v2, POINTER_FROM_INT(i));
       }
     }
     else {
-      REMOVE_EDGE_TAG(me);
+      REMOVE_EDGE_TAG(edge);
     }
   }
 
-  if (mfaces && !mpolys) {
+  if (mfaces && !polys) {
 #define REMOVE_FACE_TAG(_mf) \
   { \
     _mf->v3 = 0; \
@@ -560,7 +560,7 @@ bool BKE_mesh_validate_arrays(Mesh *mesh,
     SortPoly *prev_sp, *sp = sort_polys;
     int prev_end;
 
-    for (i = 0, mp = mpolys; i < totpoly; i++, mp++, sp++) {
+    for (i = 0, poly = polys; i < totpoly; i++, poly++, sp++) {
       sp->index = i;
 
       /* Material index, isolated from other tests here. While large indices are clamped,
@@ -573,22 +573,22 @@ bool BKE_mesh_validate_arrays(Mesh *mesh,
         }
       }
 
-      if (mp->loopstart < 0 || mp->totloop < 3) {
+      if (poly->loopstart < 0 || poly->totloop < 3) {
         /* Invalid loop data. */
         PRINT_ERR("\tPoly %u is invalid (loopstart: %d, totloop: %d)",
                   sp->index,
-                  mp->loopstart,
-                  mp->totloop);
+                  poly->loopstart,
+                  poly->totloop);
         sp->invalid = true;
       }
-      else if (mp->loopstart + mp->totloop > totloop) {
+      else if (poly->loopstart + poly->totloop > totloop) {
         /* Invalid loop data. */
         PRINT_ERR(
             "\tPoly %u uses loops out of range "
             "(loopstart: %d, loopend: %d, max number of loops: %u)",
             sp->index,
-            mp->loopstart,
-            mp->loopstart + mp->totloop - 1,
+            poly->loopstart,
+            poly->loopstart + poly->totloop - 1,
             totloop - 1);
         sp->invalid = true;
       }
@@ -596,21 +596,21 @@ bool BKE_mesh_validate_arrays(Mesh *mesh,
         /* Poly itself is valid, for now. */
         int v1, v2; /* v1 is prev loop vert idx, v2 is current loop one. */
         sp->invalid = false;
-        sp->verts = v = (int *)MEM_mallocN(sizeof(int) * mp->totloop, "Vert idx of SortPoly");
-        sp->numverts = mp->totloop;
-        sp->loopstart = mp->loopstart;
+        sp->verts = v = (int *)MEM_mallocN(sizeof(int) * poly->totloop, "Vert idx of SortPoly");
+        sp->numverts = poly->totloop;
+        sp->loopstart = poly->loopstart;
 
         /* Ideally we would only have to do that once on all vertices
          * before we start checking each poly, but several polys can use same vert,
          * so we have to ensure here all verts of current poly are cleared. */
-        for (j = 0, ml = &mloops[sp->loopstart]; j < mp->totloop; j++, ml++) {
+        for (j = 0, ml = &mloops[sp->loopstart]; j < poly->totloop; j++, ml++) {
           if (ml->v < totvert) {
             BLI_BITMAP_DISABLE(vert_tag, ml->v);
           }
         }
 
         /* Test all poly's loops' vert idx. */
-        for (j = 0, ml = &mloops[sp->loopstart]; j < mp->totloop; j++, ml++, v++) {
+        for (j = 0, ml = &mloops[sp->loopstart]; j < poly->totloop; j++, ml++, v++) {
           if (ml->v >= totvert) {
             /* Invalid vert idx. */
             PRINT_ERR("\tLoop %u has invalid vert reference (%u)", sp->loopstart + j, ml->v);
@@ -631,9 +631,9 @@ bool BKE_mesh_validate_arrays(Mesh *mesh,
         }
 
         /* Test all poly's loops. */
-        for (j = 0, ml = &mloops[sp->loopstart]; j < mp->totloop; j++, ml++) {
+        for (j = 0, ml = &mloops[sp->loopstart]; j < poly->totloop; j++, ml++) {
           v1 = ml->v;
-          v2 = mloops[sp->loopstart + (j + 1) % mp->totloop].v;
+          v2 = mloops[sp->loopstart + (j + 1) % poly->totloop].v;
           if (!BLI_edgehash_haskey(edge_hash, v1, v2)) {
             /* Edge not existing. */
             PRINT_ERR("\tPoly %u needs missing edge (%d, %d)", sp->index, v1, v2);
@@ -662,9 +662,9 @@ bool BKE_mesh_validate_arrays(Mesh *mesh,
             }
           }
           else {
-            me = &medges[ml->e];
-            if (IS_REMOVED_EDGE(me) ||
-                !((me->v1 == v1 && me->v2 == v2) || (me->v1 == v2 && me->v2 == v1))) {
+            edge = &edges[ml->e];
+            if (IS_REMOVED_EDGE(edge) ||
+                !((edge->v1 == v1 && edge->v2 == v2) || (edge->v1 == v2 && edge->v2 == v1))) {
               /* The pointed edge is invalid (tagged as removed, or vert idx mismatch),
                * and we already know from previous test that a valid one exists,
                * use it (if allowed)! */
@@ -677,7 +677,7 @@ bool BKE_mesh_validate_arrays(Mesh *mesh,
                     "%u",
                     sp->index,
                     prev_e,
-                    IS_REMOVED_EDGE(me),
+                    IS_REMOVED_EDGE(edge),
                     ml->e);
               }
               else {
@@ -747,7 +747,7 @@ bool BKE_mesh_validate_arrays(Mesh *mesh,
        */
       if (sp->invalid) {
         if (do_fixes) {
-          REMOVE_POLY_TAG((&mpolys[sp->index]));
+          REMOVE_POLY_TAG((&polys[sp->index]));
           /* DO NOT REMOVE ITS LOOPS!!!
            * As already invalid polys are at the end of the SortPoly list, the loops they
            * were the only users have already been tagged as "to remove" during previous
@@ -777,7 +777,7 @@ bool BKE_mesh_validate_arrays(Mesh *mesh,
                     prev_end,
                     sp->index);
           if (do_fixes) {
-            REMOVE_POLY_TAG((&mpolys[sp->index]));
+            REMOVE_POLY_TAG((&polys[sp->index]));
             /* DO NOT REMOVE ITS LOOPS!!!
              * They might be used by some next, valid poly!
              * Just not updating prev_end/prev_sp vars is enough to ensure the loops
@@ -1210,18 +1210,18 @@ void BKE_mesh_strip_loose_polysloops(Mesh *me)
   MutableSpan<MPoly> polys = me->polys_for_write();
   MutableSpan<MLoop> loops = me->loops_for_write();
 
-  MPoly *p;
+  MPoly *poly;
   MLoop *l;
   int a, b;
   /* New loops idx! */
   int *new_idx = (int *)MEM_mallocN(sizeof(int) * me->totloop, __func__);
 
-  for (a = b = 0, p = polys.data(); a < me->totpoly; a++, p++) {
+  for (a = b = 0, poly = polys.data(); a < me->totpoly; a++, poly++) {
     bool invalid = false;
-    int i = p->loopstart;
-    int stop = i + p->totloop;
+    int i = poly->loopstart;
+    int stop = i + poly->totloop;
 
-    if (stop > me->totloop || stop < i || p->loopstart < 0) {
+    if (stop > me->totloop || stop < i || poly->loopstart < 0) {
       invalid = true;
     }
     else {
@@ -1236,9 +1236,9 @@ void BKE_mesh_strip_loose_polysloops(Mesh *me)
       }
     }
 
-    if (p->totloop >= 3 && !invalid) {
+    if (poly->totloop >= 3 && !invalid) {
       if (a != b) {
-        memcpy(&polys[b], p, sizeof(polys[b]));
+        memcpy(&polys[b], poly, sizeof(polys[b]));
         CustomData_copy_data(&me->pdata, &me->pdata, a, b, 1);
       }
       b++;
@@ -1349,13 +1349,13 @@ void BKE_mesh_calc_edges_tessface(Mesh *mesh)
   CustomData_add_layer(&edgeData, CD_MEDGE, CD_SET_DEFAULT, nullptr, numEdges);
   CustomData_add_layer(&edgeData, CD_ORIGINDEX, CD_SET_DEFAULT, nullptr, numEdges);
 
-  MEdge *med = (MEdge *)CustomData_get_layer_for_write(&edgeData, CD_MEDGE, mesh->totedge);
+  MEdge *ege = (MEdge *)CustomData_get_layer_for_write(&edgeData, CD_MEDGE, mesh->totedge);
   int *index = (int *)CustomData_get_layer_for_write(&edgeData, CD_ORIGINDEX, mesh->totedge);
 
   EdgeSetIterator *ehi = BLI_edgesetIterator_new(eh);
   for (int i = 0; BLI_edgesetIterator_isDone(ehi) == false;
-       BLI_edgesetIterator_step(ehi), i++, med++, index++) {
-    BLI_edgesetIterator_getKey(ehi, &med->v1, &med->v2);
+       BLI_edgesetIterator_step(ehi), i++, ege++, index++) {
+    BLI_edgesetIterator_getKey(ehi, &ege->v1, &ege->v2);
     *index = ORIGINDEX_NONE;
   }
   BLI_edgesetIterator_free(ehi);
diff --git a/source/blender/blenkernel/intern/multires.cc b/source/blender/blenkernel/intern/multires.cc
index 49084ca12cb..0b9cc2e7e38 100644
--- a/source/blender/blenkernel/intern/multires.cc
+++ b/source/blender/blenkernel/intern/multires.cc
@@ -856,7 +856,7 @@ struct MultiresThreadedData {
   CCGElem **gridData, **subGridData;
   CCGKey *key;
   CCGKey *sub_key;
-  const MPoly *mpoly;
+  const MPoly *polys;
   MDisps *mdisps;
   GridPaintMask *grid_paint_mask;
   int *gridOffset;
@@ -874,7 +874,7 @@ static void multires_disp_run_cb(void *__restrict userdata,
   CCGElem **gridData = tdata->gridData;
   CCGElem **subGridData = tdata->subGridData;
   CCGKey *key = tdata->key;
-  const MPoly *mpoly = tdata->mpoly;
+  const MPoly *polys = tdata->polys;
   MDisps *mdisps = tdata->mdisps;
   GridPaintMask *grid_paint_mask = tdata->grid_paint_mask;
   int *gridOffset = tdata->gridOffset;
@@ -882,12 +882,12 @@ static void multires_disp_run_cb(void *__restrict userdata,
   int dGridSize = tdata->dGridSize;
   int dSkip = tdata->dSkip;
 
-  const int numVerts = mpoly[pidx].totloop;
+  const int numVerts = polys[pidx].totloop;
   int S, x, y, gIndex = gridOffset[pidx];
 
   for (S = 0; S < numVerts; S++, gIndex++) {
     GridPaintMask *gpm = grid_paint_mask ? &grid_paint_mask[gIndex] : nullptr;
-    MDisps *mdisp = &mdisps[mpoly[pidx].loopstart + S];
+    MDisps *mdisp = &mdisps[polys[pidx].loopstart + S];
     CCGElem *grid = gridData[gIndex];
     CCGElem *subgrid = subGridData[gIndex];
     float(*dispgrid)[3] = nullptr;
@@ -968,7 +968,7 @@ static void multiresModifier_disp_run(
   CCGDerivedMesh *ccgdm = (CCGDerivedMesh *)dm;
   CCGElem **gridData, **subGridData;
   CCGKey key;
-  const MPoly *mpoly = me->polys().data();
+  const MPoly *polys = me->polys().data();
   MDisps *mdisps = static_cast<MDisps *>(
       CustomData_get_layer_for_write(&me->ldata, CD_MDISPS, me->totloop));
   GridPaintMask *grid_paint_mask = nullptr;
@@ -978,7 +978,7 @@ static void multiresModifier_disp_run(
 
   /* this happens in the dm made by bmesh_mdisps_space_set */
   if (dm2 && CustomData_has_layer(&dm2->loopData, CD_MDISPS)) {
-    mpoly = static_cast<const MPoly *>(
+    polys = static_cast<const MPoly *>(
         CustomData_get_layer_for_write(&dm2->polyData, CD_MPOLY, dm2->getNumPolys(dm)));
     mdisps = static_cast<MDisps *>(
         CustomData_get_layer_for_write(&dm2->loopData, CD_MDISPS, dm2->getNumLoops(dm)));
@@ -1033,7 +1033,7 @@ static void multiresModifier_disp_run(
   data.gridData = gridData;
   data.subGridData = subGridData;
   data.key = &key;
-  data.mpoly = mpoly;
+  data.polys = polys;
   data.mdisps = mdisps;
   data.grid_paint_mask = grid_paint_mask;
   data.gridOffset = gridOffset;
@@ -1556,12 +1556,12 @@ void multiresModifier_ensure_external_read(struct Mesh *mesh, const MultiresModi
 /***************** Multires interpolation stuff *****************/
 
 int mdisp_rot_face_to_crn(
-    MPoly *mpoly, const int face_side, const float u, const float v, float *x, float *y)
+    MPoly *poly, const int face_side, const float u, const float v, float *x, float *y)
 {
   const float offset = face_side * 0.5f - 0.5f;
   int S = 0;
 
-  if (mpoly->totloop == 4) {
+  if (poly->totloop == 4) {
     if (u <= offset && v <= offset) {
       S = 0;
     }
@@ -1592,7 +1592,7 @@ int mdisp_rot_face_to_crn(
       *y = v - offset;
     }
   }
-  else if (mpoly->totloop == 3) {
+  else if (poly->totloop == 3) {
     int grid_size = offset;
     float w = (face_side - 1) - u - v;
     float W1, W2;
@@ -1628,8 +1628,8 @@ int mdisp_rot_face_to_crn(
     int minS, i;
     float mindist = FLT_MAX;
 
-    for (i = 0; i < mpoly->totloop; i++) {
-      float len = len_v3v3(nullptr, positions[mloop[mpoly->loopstart + i].v]);
+    for (i = 0; i < poly->totloop; i++) {
+      float len = len_v3v3(nullptr, positions[mloop[poly->loopstart + i].v]);
       if (len < mindist) {
         mindist = len;
         minS = i;
diff --git a/source/blender/blenkernel/intern/multires_reshape_apply_base.cc b/source/blender/blenkernel/intern/multires_reshape_apply_base.cc
index 8be2bd28e01..145dde1b923 100644
--- a/source/blender/blenkernel/intern/multires_reshape_apply_base.cc
+++ b/source/blender/blenkernel/intern/multires_reshape_apply_base.cc
@@ -98,11 +98,11 @@ void multires_reshape_apply_base_refit_base_mesh(MultiresReshapeContext *reshape
     /* Find center. */
     int tot = 0;
     for (int j = 0; j < pmap[i].count; j++) {
-      const MPoly *p = &reshape_context->base_polys[pmap[i].indices[j]];
+      const MPoly *poly = &reshape_context->base_polys[pmap[i].indices[j]];
 
       /* This double counts, not sure if that's bad or good. */
-      for (int k = 0; k < p->totloop; k++) {
-        const int vndx = reshape_context->base_loops[p->loopstart + k].v;
+      for (int k = 0; k < poly->totloop; k++) {
+        const int vndx = reshape_context->base_loops[poly->loopstart + k].v;
         if (vndx != i) {
           add_v3_v3(center, origco[vndx]);
           tot++;
@@ -113,20 +113,20 @@ void multires_reshape_apply_base_refit_base_mesh(MultiresReshapeContext *reshape
 
     /* Find normal. */
     for (int j = 0; j < pmap[i].count; j++) {
-      const MPoly *p = &reshape_context->base_polys[pmap[i].indices[j]];
+      const MPoly *poly = &reshape_context->base_polys[pmap[i].indices[j]];
       MPoly fake_poly;
       float no[3];
 
       /* Set up poly, loops, and coords in order to call BKE_mesh_calc_poly_normal(). */
-      fake_poly.totloop = p->totloop;
+      fake_poly.totloop = poly->totloop;
       fake_poly.loopstart = 0;
       MLoop *fake_loops = static_cast<MLoop *>(
-          MEM_malloc_arrayN(p->totloop, sizeof(MLoop), __func__));
+          MEM_malloc_arrayN(poly->totloop, sizeof(MLoop), __func__));
       float(*fake_co)[3] = static_cast<float(*)[3]>(
-          MEM_malloc_arrayN(p->totloop, sizeof(float[3]), __func__));
+          MEM_malloc_arrayN(poly->totloop, sizeof(float[3]), __func__));
 
-      for (int k = 0; k < p->totloop; k++) {
-        const int vndx = reshape_context->base_loops[p->loopstart + k].v;
+      for (int k = 0; k < poly->totloop; k++) {
+        const int vndx = reshape_context->base_loops[poly->loopstart + k].v;
 
         fake_loops[k].v = k;
 
diff --git a/source/blender/blenkernel/intern/multires_unsubdivide.cc b/source/blender/blenkernel/intern/multires_unsubdivide.cc
index aa6bd7f8e5a..e328f9a59aa 100644
--- a/source/blender/blenkernel/intern/multires_unsubdivide.cc
+++ b/source/blender/blenkernel/intern/multires_unsubdivide.cc
@@ -968,19 +968,19 @@ static void multires_unsubdivide_prepare_original_bmesh_for_extract(
  */
 static bool multires_unsubdivide_flip_grid_x_axis(const blender::Span<MPoly> polys,
                                                   const blender::Span<MLoop> loops,
-                                                  int poly,
+                                                  int poly_index,
                                                   int loop,
                                                   int v_x)
 {
-  const MPoly *p = &polys[poly];
+  const MPoly *poly = &polys[poly_index];
 
-  const MLoop *l_first = &loops[p->loopstart];
-  if ((loop == (p->loopstart + (p->totloop - 1))) && l_first->v == v_x) {
+  const MLoop *l_first = &loops[poly->loopstart];
+  if ((loop == (poly->loopstart + (poly->totloop - 1))) && l_first->v == v_x) {
     return true;
   }
 
   int next_l_index = loop + 1;
-  if (next_l_index < p->loopstart + p->totloop) {
+  if (next_l_index < poly->loopstart + poly->totloop) {
     const MLoop *l_next = &loops[next_l_index];
     if (l_next->v == v_x) {
       return true;
diff --git a/source/blender/blenkernel/intern/object_dupli.cc b/source/blender/blenkernel/intern/object_dupli.cc
index c88b8e42d1d..7a75f1bc080 100644
--- a/source/blender/blenkernel/intern/object_dupli.cc
+++ b/source/blender/blenkernel/intern/object_dupli.cc
@@ -1056,7 +1056,7 @@ struct FaceDupliData_Mesh {
   FaceDupliData_Params params;
 
   int totface;
-  const MPoly *mpoly;
+  const MPoly *polys;
   const MLoop *mloop;
   Span<float3> vert_positions;
   const float (*orco)[3];
@@ -1155,11 +1155,11 @@ static DupliObject *face_dupli_from_mesh(const DupliContext *ctx,
                                          const float scale_fac,
 
                                          /* Mesh variables. */
-                                         const MPoly *mpoly,
+                                         const MPoly *polys,
                                          const MLoop *mloopstart,
                                          const Span<float3> vert_positions)
 {
-  const int coords_len = mpoly->totloop;
+  const int coords_len = polys->totloop;
   Array<float3, 64> coords(coords_len);
 
   const MLoop *ml = mloopstart;
@@ -1206,7 +1206,7 @@ static void make_child_duplis_faces_from_mesh(const DupliContext *ctx,
                                               Object *inst_ob)
 {
   FaceDupliData_Mesh *fdd = (FaceDupliData_Mesh *)userdata;
-  const MPoly *mpoly = fdd->mpoly, *mp;
+  const MPoly *polys = fdd->polys, *poly;
   const MLoop *mloop = fdd->mloop;
   const float(*orco)[3] = fdd->orco;
   const float2 *mloopuv = fdd->mloopuv;
@@ -1221,27 +1221,27 @@ static void make_child_duplis_faces_from_mesh(const DupliContext *ctx,
   mul_m4_m4m4(child_imat, inst_ob->world_to_object, ctx->object->object_to_world);
   const float scale_fac = ctx->object->instance_faces_scale;
 
-  for (a = 0, mp = mpoly; a < totface; a++, mp++) {
-    const MLoop *loopstart = mloop + mp->loopstart;
+  for (a = 0, poly = polys; a < totface; a++, poly++) {
+    const MLoop *loopstart = mloop + poly->loopstart;
     DupliObject *dob = face_dupli_from_mesh(fdd->params.ctx,
                                             inst_ob,
                                             child_imat,
                                             a,
                                             use_scale,
                                             scale_fac,
-                                            mp,
+                                            poly,
                                             loopstart,
                                             fdd->vert_positions);
 
-    const float w = 1.0f / float(mp->totloop);
+    const float w = 1.0f / float(poly->totloop);
     if (orco) {
-      for (int j = 0; j < mp->totloop; j++) {
+      for (int j = 0; j < poly->totloop; j++) {
         madd_v3_v3fl(dob->orco, orco[loopstart[j].v], w);
       }
     }
     if (mloopuv) {
-      for (int j = 0; j < mp->totloop; j++) {
-        madd_v2_v2fl(dob->uv, mloopuv[mp->loopstart + j], w);
+      for (int j = 0; j < poly->totloop; j++) {
+        madd_v2_v2fl(dob->uv, mloopuv[poly->loopstart + j], w);
       }
     }
   }
@@ -1319,7 +1319,7 @@ static void make_duplis_faces(const DupliContext *ctx)
     FaceDupliData_Mesh fdd{};
     fdd.params = fdd_params;
     fdd.totface = me_eval->totpoly;
-    fdd.mpoly = me_eval->polys().data();
+    fdd.polys = me_eval->polys().data();
     fdd.mloop = me_eval->loops().data();
     fdd.vert_positions = me_eval->vert_positions();
     fdd.mloopuv = (uv_idx != -1) ? (const float2 *)CustomData_get_layer_n(
diff --git a/source/blender/blenkernel/intern/paint.cc b/source/blender/blenkernel/intern/paint.cc
index 5c5c670deeb..00ebaf2f6a1 100644
--- a/source/blender/blenkernel/intern/paint.cc
+++ b/source/blender/blenkernel/intern/paint.cc
@@ -1696,7 +1696,7 @@ static void sculpt_update_object(
     /* These are assigned to the base mesh in Multires. This is needed because Face Sets operators
      * and tools use the Face Sets data from the base mesh when Multires is active. */
     ss->vert_positions = BKE_mesh_vert_positions_for_write(me);
-    ss->mpoly = me->polys().data();
+    ss->polys = me->polys().data();
     ss->mloop = me->loops().data();
   }
   else {
@@ -1704,7 +1704,7 @@ static void sculpt_update_object(
     ss->totpoly = me->totpoly;
     ss->totfaces = me->totpoly;
     ss->vert_positions = BKE_mesh_vert_positions_for_write(me);
-    ss->mpoly = me->polys().data();
+    ss->polys = me->polys().data();
     ss->mloop = me->loops().data();
     ss->multires.active = false;
     ss->multires.modifier = nullptr;
@@ -2015,22 +2015,22 @@ int BKE_sculpt_mask_layers_ensure(Depsgraph *depsgraph,
     /* if vertices already have mask, copy into multires data */
     if (paint_mask) {
       for (i = 0; i < me->totpoly; i++) {
-        const MPoly *p = &polys[i];
+        const MPoly *poly = &polys[i];
         float avg = 0;
 
         /* mask center */
-        for (j = 0; j < p->totloop; j++) {
-          const MLoop *l = &loops[p->loopstart + j];
+        for (j = 0; j < poly->totloop; j++) {
+          const MLoop *l = &loops[poly->loopstart + j];
           avg += paint_mask[l->v];
         }
-        avg /= float(p->totloop);
+        avg /= float(poly->totloop);
 
         /* fill in multires mask corner */
-        for (j = 0; j < p->totloop; j++) {
-          GridPaintMask *gpm = &gmask[p->loopstart + j];
-          const MLoop *l = &loops[p->loopstart + j];
-          const MLoop *prev = ME_POLY_LOOP_PREV(loops, p, j);
-          const MLoop *next = ME_POLY_LOOP_NEXT(loops, p, j);
+        for (j = 0; j < poly->totloop; j++) {
+          GridPaintMask *gpm = &gmask[poly->loopstart + j];
+          const MLoop *l = &loops[poly->loopstart + j];
+          const MLoop *prev = ME_POLY_LOOP_PREV(loops, poly, j);
+          const MLoop *next = ME_POLY_LOOP_NEXT(loops, poly, j);
 
           gpm->data[0] = avg;
           gpm->data[1] = (paint_mask[l->v] + paint_mask[next->v]) * 0.5f;
diff --git a/source/blender/blenkernel/intern/particle_system.c b/source/blender/blenkernel/intern/particle_system.c
index f04686efb56..a9fc9425ecc 100644
--- a/source/blender/blenkernel/intern/particle_system.c
+++ b/source/blender/blenkernel/intern/particle_system.c
@@ -3309,7 +3309,7 @@ static void hair_create_input_mesh(ParticleSimulationData *sim,
   ParticleSystem *psys = sim->psys;
   ParticleSettings *part = psys->part;
   Mesh *mesh;
-  MEdge *medge;
+  MEdge *edge;
   MDeformVert *dvert;
   HairKey *key;
   PARTICLE_P;
@@ -3323,7 +3323,7 @@ static void hair_create_input_mesh(ParticleSimulationData *sim,
     *r_mesh = mesh = BKE_mesh_new_nomain(totpoint, totedge, 0, 0);
   }
   float(*positions)[3] = BKE_mesh_vert_positions_for_write(mesh);
-  medge = BKE_mesh_edges_for_write(mesh);
+  edge = BKE_mesh_edges_for_write(mesh);
   dvert = BKE_mesh_deform_verts_for_write(mesh);
 
   if (psys->clmd->hairdata == NULL) {
@@ -3390,13 +3390,13 @@ static void hair_create_input_mesh(ParticleSimulationData *sim,
           sub_v3_v3(positions[vert_index], co_next);
           mul_m4_v3(hairmat, positions[vert_index]);
 
-          medge->v1 = pa->hair_index - 1;
-          medge->v2 = pa->hair_index;
+          edge->v1 = pa->hair_index - 1;
+          edge->v2 = pa->hair_index;
 
           dvert = hair_set_pinning(dvert, 1.0f);
 
           vert_index++;
-          medge++;
+          edge++;
         }
 
         /* store root transform in cloth data */
@@ -3411,8 +3411,8 @@ static void hair_create_input_mesh(ParticleSimulationData *sim,
         mul_m4_v3(hairmat, positions[vert_index]);
 
         if (k) {
-          medge->v1 = pa->hair_index + k - 1;
-          medge->v2 = pa->hair_index + k;
+          edge->v1 = pa->hair_index + k - 1;
+          edge->v2 = pa->hair_index + k;
         }
 
         /* roots and disabled hairs should be 1.0, the rest can be anything from 0.0 to 1.0 */
@@ -3425,7 +3425,7 @@ static void hair_create_input_mesh(ParticleSimulationData *sim,
 
         vert_index++;
         if (k) {
-          medge++;
+          edge++;
         }
       }
 
diff --git a/source/blender/blenkernel/intern/pbvh.cc b/source/blender/blenkernel/intern/pbvh.cc
index f0ed27e314c..c6b18a7b71a 100644
--- a/source/blender/blenkernel/intern/pbvh.cc
+++ b/source/blender/blenkernel/intern/pbvh.cc
@@ -158,7 +158,7 @@ static bool face_materials_match(const PBVH *pbvh, const int a, const int b)
       return false;
     }
   }
-  return (pbvh->mpoly[a].flag & ME_SMOOTH) == (pbvh->mpoly[b].flag & ME_SMOOTH);
+  return (pbvh->polys[a].flag & ME_SMOOTH) == (pbvh->polys[b].flag & ME_SMOOTH);
 }
 
 static bool grid_materials_match(const DMFlagMat *f1, const DMFlagMat *f2)
@@ -678,7 +678,7 @@ static void pbvh_draw_args_init(PBVH *pbvh, PBVH_GPU_Args *args, PBVHNode *node)
   args->face_sets_color_seed = pbvh->face_sets_color_seed;
   args->vert_positions = pbvh->vert_positions;
   args->mloop = pbvh->mloop;
-  args->mpoly = pbvh->mpoly;
+  args->polys = pbvh->polys;
   args->mlooptri = pbvh->looptri;
 
   if (ELEM(pbvh->header.type, PBVH_FACES, PBVH_GRIDS)) {
@@ -695,7 +695,7 @@ static void pbvh_draw_args_init(PBVH *pbvh, PBVH_GPU_Args *args, PBVHNode *node)
       args->pdata = pbvh->pdata;
       args->totprim = node->totprim;
       args->me = pbvh->mesh;
-      args->mpoly = pbvh->mpoly;
+      args->polys = pbvh->polys;
       args->vert_normals = pbvh->vert_normals;
 
       args->active_color = pbvh->mesh->active_color_attribute;
@@ -714,7 +714,7 @@ static void pbvh_draw_args_init(PBVH *pbvh, PBVH_GPU_Args *args, PBVHNode *node)
       args->grid_indices = node->prim_indices;
       args->subdiv_ccg = pbvh->subdiv_ccg;
       args->face_sets = pbvh->face_sets;
-      args->mpoly = pbvh->mpoly;
+      args->polys = pbvh->polys;
 
       args->active_color = pbvh->mesh->active_color_attribute;
       args->render_color = pbvh->mesh->default_color_attribute;
@@ -811,7 +811,7 @@ static void pbvh_validate_node_prims(PBVH *pbvh)
 
 void BKE_pbvh_build_mesh(PBVH *pbvh,
                          Mesh *mesh,
-                         const MPoly *mpoly,
+                         const MPoly *polys,
                          const MLoop *mloop,
                          float (*vert_positions)[3],
                          int totvert,
@@ -826,7 +826,7 @@ void BKE_pbvh_build_mesh(PBVH *pbvh,
 
   pbvh->mesh = mesh;
   pbvh->header.type = PBVH_FACES;
-  pbvh->mpoly = mpoly;
+  pbvh->polys = polys;
   pbvh->hide_poly = static_cast<bool *>(CustomData_get_layer_named_for_write(
       &mesh->pdata, CD_PROP_BOOL, ".hide_poly", mesh->totpoly));
   pbvh->material_indices = static_cast<const int *>(
@@ -940,7 +940,7 @@ void BKE_pbvh_build_grids(PBVH *pbvh,
   pbvh->ldata = &me->ldata;
   pbvh->pdata = &me->pdata;
 
-  pbvh->mpoly = me->polys().data();
+  pbvh->polys = me->polys().data();
   pbvh->mloop = me->loops().data();
 
   /* We also need the base mesh for PBVH draw. */
@@ -1410,8 +1410,8 @@ static void pbvh_update_normals_accum_task_cb(void *__restrict userdata,
 
       /* Face normal and mask */
       if (lt->poly != mpoly_prev) {
-        const MPoly *mp = &pbvh->mpoly[lt->poly];
-        BKE_mesh_calc_poly_normal(mp, &pbvh->mloop[mp->loopstart], pbvh->vert_positions, fn);
+        const MPoly *poly = &pbvh->polys[lt->poly];
+        BKE_mesh_calc_poly_normal(poly, &pbvh->mloop[poly->loopstart], pbvh->vert_positions, fn);
         mpoly_prev = lt->poly;
       }
 
@@ -3713,7 +3713,7 @@ static void pbvh_face_iter_step(PBVHFaceIter *fd, bool do_step)
       }
 
       fd->last_face_index_ = face_index;
-      const MPoly *mp = fd->mpoly_ + face_index;
+      const MPoly *poly = fd->polys_ + face_index;
 
       fd->face.i = fd->index = face_index;
 
@@ -3724,15 +3724,15 @@ static void pbvh_face_iter_step(PBVHFaceIter *fd, bool do_step)
         fd->hide = fd->hide_poly_ + face_index;
       }
 
-      pbvh_face_iter_verts_reserve(fd, mp->totloop);
+      pbvh_face_iter_verts_reserve(fd, poly->totloop);
 
-      const MLoop *ml = fd->mloop_ + mp->loopstart;
+      const MLoop *ml = fd->mloop_ + poly->loopstart;
       const int grid_area = fd->subdiv_key_.grid_area;
 
-      for (int i = 0; i < mp->totloop; i++, ml++) {
+      for (int i = 0; i < poly->totloop; i++, ml++) {
         if (fd->pbvh_type_ == PBVH_GRIDS) {
           /* Grid corners. */
-          fd->verts[i].i = (mp->loopstart + i) * grid_area + grid_area - 1;
+          fd->verts[i].i = (poly->loopstart + i) * grid_area + grid_area - 1;
         }
         else {
           fd->verts[i].i = ml->v;
@@ -3763,7 +3763,7 @@ void BKE_pbvh_face_iter_init(PBVH *pbvh, PBVHNode *node, PBVHFaceIter *fd)
       fd->subdiv_key_ = pbvh->gridkey;
       ATTR_FALLTHROUGH;
     case PBVH_FACES:
-      fd->mpoly_ = pbvh->mpoly;
+      fd->polys_ = pbvh->polys;
       fd->mloop_ = pbvh->mloop;
       fd->looptri_ = pbvh->looptri;
       fd->hide_poly_ = pbvh->hide_poly;
diff --git a/source/blender/blenkernel/intern/pbvh_colors.cc b/source/blender/blenkernel/intern/pbvh_colors.cc
index 2ec4139d8c4..6ec7088a835 100644
--- a/source/blender/blenkernel/intern/pbvh_colors.cc
+++ b/source/blender/blenkernel/intern/pbvh_colors.cc
@@ -94,11 +94,11 @@ static void pbvh_vertex_color_get(const PBVH &pbvh, PBVHVertRef vertex, float r_
     int count = 0;
     zero_v4(r_color);
     for (const int i_poly : Span(melem.indices, melem.count)) {
-      const MPoly &mp = pbvh.mpoly[i_poly];
-      Span<T> colors{static_cast<const T *>(pbvh.color_layer->data) + mp.loopstart, mp.totloop};
-      Span<MLoop> loops{pbvh.mloop + mp.loopstart, mp.totloop};
+      const MPoly &poly = pbvh.polys[i_poly];
+      Span<T> colors{static_cast<const T *>(pbvh.color_layer->data) + poly.loopstart, poly.totloop};
+      Span<MLoop> loops{pbvh.mloop + poly.loopstart, poly.totloop};
 
-      for (const int i_loop : IndexRange(mp.totloop)) {
+      for (const int i_loop : IndexRange(poly.totloop)) {
         if (loops[i_loop].v == index) {
           float temp[4];
           to_float(colors[i_loop], temp);
@@ -127,11 +127,11 @@ static void pbvh_vertex_color_set(PBVH &pbvh, PBVHVertRef vertex, const float co
     const MeshElemMap &melem = pbvh.pmap[index];
 
     for (const int i_poly : Span(melem.indices, melem.count)) {
-      const MPoly &mp = pbvh.mpoly[i_poly];
-      MutableSpan<T> colors{static_cast<T *>(pbvh.color_layer->data) + mp.loopstart, mp.totloop};
-      Span<MLoop> loops{pbvh.mloop + mp.loopstart, mp.totloop};
+      const MPoly &poly = pbvh.polys[i_poly];
+      MutableSpan<T> colors{static_cast<T *>(pbvh.color_layer->data) + poly.loopstart, poly.totloop};
+      Span<MLoop> loops{pbvh.mloop + poly.loopstart, poly.totloop};
 
-      for (const int i_loop : IndexRange(mp.totloop)) {
+      for (const int i_loop : IndexRange(poly.totloop)) {
         if (loops[i_loop].v == index) {
           from_float(color, colors[i_loop]);
         }
diff --git a/source/blender/blenkernel/intern/pbvh_intern.hh b/source/blender/blenkernel/intern/pbvh_intern.hh
index d41eeb0b70b..a9282629031 100644
--- a/source/blender/blenkernel/intern/pbvh_intern.hh
+++ b/source/blender/blenkernel/intern/pbvh_intern.hh
@@ -157,7 +157,7 @@ struct PBVH {
   float (*vert_normals)[3];
   bool *hide_vert;
   float (*vert_positions)[3];
-  const MPoly *mpoly;
+  const MPoly *polys;
   bool *hide_poly;
   /** Material indices. Only valid for polygon meshes. */
   const int *material_indices;
diff --git a/source/blender/blenkernel/intern/softbody.c b/source/blender/blenkernel/intern/softbody.c
index 1a19ccade7a..6ebf9fb1a03 100644
--- a/source/blender/blenkernel/intern/softbody.c
+++ b/source/blender/blenkernel/intern/softbody.c
@@ -567,11 +567,11 @@ static void ccd_update_deflector_hash(Depsgraph *depsgraph,
 static int count_mesh_quads(Mesh *me)
 {
   int a, result = 0;
-  const MPoly *mp = BKE_mesh_polys(me);
+  const MPoly *poly = BKE_mesh_polys(me);
 
-  if (mp) {
-    for (a = me->totpoly; a > 0; a--, mp++) {
-      if (mp->totloop == 4) {
+  if (poly) {
+    for (a = me->totpoly; a > 0; a--, poly++) {
+      if (poly->totloop == 4) {
         result++;
       }
     }
@@ -592,7 +592,7 @@ static void add_mesh_quad_diag_springs(Object *ob)
     nofquads = count_mesh_quads(me);
     if (nofquads) {
       const MLoop *mloop = BKE_mesh_loops(me);
-      const MPoly *mp = BKE_mesh_polys(me);
+      const MPoly *poly = BKE_mesh_polys(me);
       BodySpring *bs;
 
       /* resize spring-array to hold additional quad springs */
@@ -603,14 +603,14 @@ static void add_mesh_quad_diag_springs(Object *ob)
       a = 0;
       bs = &ob->soft->bspring[ob->soft->totspring];
       // bp = ob->soft->bpoint; /* UNUSED */
-      for (a = me->totpoly; a > 0; a--, mp++) {
-        if (mp->totloop == 4) {
-          bs->v1 = mloop[mp->loopstart + 0].v;
-          bs->v2 = mloop[mp->loopstart + 2].v;
+      for (a = me->totpoly; a > 0; a--, poly++) {
+        if (poly->totloop == 4) {
+          bs->v1 = mloop[poly->loopstart + 0].v;
+          bs->v2 = mloop[poly->loopstart + 2].v;
           bs->springtype = SB_STIFFQUAD;
           bs++;
-          bs->v1 = mloop[mp->loopstart + 1].v;
-          bs->v2 = mloop[mp->loopstart + 3].v;
+          bs->v1 = mloop[poly->loopstart + 1].v;
+          bs->v2 = mloop[poly->loopstart + 3].v;
           bs->springtype = SB_STIFFQUAD;
           bs++;
         }
@@ -2663,7 +2663,7 @@ static void mesh_to_softbody(Object *ob)
 {
   SoftBody *sb;
   Mesh *me = ob->data;
-  const MEdge *medge = BKE_mesh_edges(me);
+  const MEdge *edge = BKE_mesh_edges(me);
   BodyPoint *bp;
   BodySpring *bs;
   int a, totedge;
@@ -2718,11 +2718,11 @@ static void mesh_to_softbody(Object *ob)
 
   /* but we only optionally add body edge springs */
   if (ob->softflag & OB_SB_EDGES) {
-    if (medge) {
+    if (edge) {
       bs = sb->bspring;
-      for (a = me->totedge; a > 0; a--, medge++, bs++) {
-        bs->v1 = medge->v1;
-        bs->v2 = medge->v2;
+      for (a = me->totedge; a > 0; a--, edge++, bs++) {
+        bs->v1 = edge->v1;
+        bs->v2 = edge->v2;
         bs->springtype = SB_EDGE;
       }
 
diff --git a/source/blender/blenkernel/intern/subdiv_ccg.cc b/source/blender/blenkernel/intern/subdiv_ccg.cc
index e998d9b2555..e87741bfbe1 100644
--- a/source/blender/blenkernel/intern/subdiv_ccg.cc
+++ b/source/blender/blenkernel/intern/subdiv_ccg.cc
@@ -1987,22 +1987,22 @@ const int *BKE_subdiv_ccg_start_face_grid_index_get(const SubdivCCG *subdiv_ccg)
 static void adjacet_vertices_index_from_adjacent_edge(const SubdivCCG *subdiv_ccg,
                                                       const SubdivCCGCoord *coord,
                                                       const MLoop *mloop,
-                                                      const MPoly *mpoly,
+                                                      const MPoly *polys,
                                                       int *r_v1,
                                                       int *r_v2)
 {
   const int grid_size_1 = subdiv_ccg->grid_size - 1;
   const int poly_index = BKE_subdiv_ccg_grid_to_face_index(subdiv_ccg, coord->grid_index);
-  const MPoly *p = &mpoly[poly_index];
+  const MPoly *poly = &polys[poly_index];
   *r_v1 = mloop[coord->grid_index].v;
 
-  const int corner = poly_find_loop_from_vert(p, &mloop[p->loopstart], *r_v1);
+  const int corner = poly_find_loop_from_vert(poly, &mloop[poly->loopstart], *r_v1);
   if (coord->x == grid_size_1) {
-    const MLoop *next = ME_POLY_LOOP_NEXT(mloop, p, corner);
+    const MLoop *next = ME_POLY_LOOP_NEXT(mloop, poly, corner);
     *r_v2 = next->v;
   }
   if (coord->y == grid_size_1) {
-    const MLoop *prev = ME_POLY_LOOP_PREV(mloop, p, corner);
+    const MLoop *prev = ME_POLY_LOOP_PREV(mloop, poly, corner);
     *r_v2 = prev->v;
   }
 }
@@ -2010,7 +2010,7 @@ static void adjacet_vertices_index_from_adjacent_edge(const SubdivCCG *subdiv_cc
 SubdivCCGAdjacencyType BKE_subdiv_ccg_coarse_mesh_adjacency_info_get(const SubdivCCG *subdiv_ccg,
                                                                      const SubdivCCGCoord *coord,
                                                                      const MLoop *mloop,
-                                                                     const MPoly *mpoly,
+                                                                     const MPoly *polys,
                                                                      int *r_v1,
                                                                      int *r_v2)
 {
@@ -2027,14 +2027,14 @@ SubdivCCGAdjacencyType BKE_subdiv_ccg_coarse_mesh_adjacency_info_get(const Subdi
       return SUBDIV_CCG_ADJACENT_VERTEX;
     }
     /* Grid corner adjacent to the middle of a coarse mesh edge. */
-    adjacet_vertices_index_from_adjacent_edge(subdiv_ccg, coord, mloop, mpoly, r_v1, r_v2);
+    adjacet_vertices_index_from_adjacent_edge(subdiv_ccg, coord, mloop, polys, r_v1, r_v2);
     return SUBDIV_CCG_ADJACENT_EDGE;
   }
 
   if (is_boundary_grid_coord(subdiv_ccg, coord)) {
     if (!is_inner_edge_grid_coordinate(subdiv_ccg, coord)) {
       /* Grid boundary adjacent to a coarse mesh edge. */
-      adjacet_vertices_index_from_adjacent_edge(subdiv_ccg, coord, mloop, mpoly, r_v1, r_v2);
+      adjacet_vertices_index_from_adjacent_edge(subdiv_ccg, coord, mloop, polys, r_v1, r_v2);
       return SUBDIV_CCG_ADJACENT_EDGE;
     }
   }
diff --git a/source/blender/blenkernel/intern/subdiv_converter_mesh.cc b/source/blender/blenkernel/intern/subdiv_converter_mesh.cc
index 85cac62660d..a6a60637b27 100644
--- a/source/blender/blenkernel/intern/subdiv_converter_mesh.cc
+++ b/source/blender/blenkernel/intern/subdiv_converter_mesh.cc
@@ -231,8 +231,8 @@ static void precalc_uv_layer(const OpenSubdiv_Converter *converter, const int la
       if (uv_vert->separate) {
         storage->num_uv_coordinates++;
       }
-      const MPoly *mp = &storage->polys[uv_vert->poly_index];
-      const int global_loop_index = mp->loopstart + uv_vert->loop_of_poly_index;
+      const MPoly *poly = &storage->polys[uv_vert->poly_index];
+      const int global_loop_index = poly->loopstart + uv_vert->loop_of_poly_index;
       storage->loop_uv_indices[global_loop_index] = storage->num_uv_coordinates;
       uv_vert = uv_vert->next;
     }
@@ -259,8 +259,8 @@ static int get_face_corner_uv_index(const OpenSubdiv_Converter *converter,
                                     const int corner)
 {
   ConverterStorage *storage = static_cast<ConverterStorage *>(converter->user_data);
-  const MPoly *mp = &storage->polys[face_index];
-  return storage->loop_uv_indices[mp->loopstart + corner];
+  const MPoly *poly = &storage->polys[face_index];
+  return storage->loop_uv_indices[poly->loopstart + corner];
 }
 
 static void free_user_data(const OpenSubdiv_Converter *converter)
diff --git a/source/blender/blenkernel/intern/subdiv_eval.cc b/source/blender/blenkernel/intern/subdiv_eval.cc
index b7d79e88c26..dcb9c2120f6 100644
--- a/source/blender/blenkernel/intern/subdiv_eval.cc
+++ b/source/blender/blenkernel/intern/subdiv_eval.cc
@@ -139,8 +139,8 @@ static void set_face_varying_data_from_uv_task(void *__restrict userdata,
   FaceVaryingDataFromUVContext *ctx = static_cast<FaceVaryingDataFromUVContext *>(userdata);
   OpenSubdiv_TopologyRefiner *topology_refiner = ctx->topology_refiner;
   const int layer_index = ctx->layer_index;
-  const MPoly *mpoly = &ctx->polys[face_index];
-  const float(*mluv)[2] = &ctx->mloopuv[mpoly->loopstart];
+  const MPoly *poly = &ctx->polys[face_index];
+  const float(*mluv)[2] = &ctx->mloopuv[poly->loopstart];
 
   /* TODO(sergey): OpenSubdiv's C-API converter can change winding of
    * loops of a face, need to watch for that, to prevent wrong UVs assigned.
diff --git a/source/blender/blenkernel/intern/subsurf_ccg.cc b/source/blender/blenkernel/intern/subsurf_ccg.cc
index de76e2bbe39..1c7330c4bcf 100644
--- a/source/blender/blenkernel/intern/subsurf_ccg.cc
+++ b/source/blender/blenkernel/intern/subsurf_ccg.cc
@@ -231,10 +231,10 @@ static int getFaceIndex(
 }
 
 static void get_face_uv_map_vert(
-    UvVertMap *vmap, MPoly *mpoly, MLoop *ml, int fi, CCGVertHDL *fverts)
+    UvVertMap *vmap, MPoly *polys, MLoop *ml, int fi, CCGVertHDL *fverts)
 {
   UvMapVert *v, *nv;
-  int j, nverts = mpoly[fi].totloop;
+  int j, nverts = polys[fi].totloop;
 
   for (j = 0; j < nverts; j++) {
     for (nv = v = BKE_mesh_uv_vert_map_get_vert(vmap, ml[j].v); v; v = v->next) {
@@ -246,7 +246,7 @@ static void get_face_uv_map_vert(
       }
     }
 
-    fverts[j] = POINTER_FROM_UINT(mpoly[nv->poly_index].loopstart + nv->loop_of_poly_index);
+    fverts[j] = POINTER_FROM_UINT(polys[nv->poly_index].loopstart + nv->loop_of_poly_index);
   }
 }
 
@@ -255,7 +255,7 @@ static int ss_sync_from_uv(CCGSubSurf *ss,
                            DerivedMesh *dm,
                            const float (*mloopuv)[2])
 {
-  MPoly *mpoly = dm->getPolyArray(dm);
+  MPoly *polys = dm->getPolyArray(dm);
   MLoop *mloop = dm->getLoopArray(dm);
   int totvert = dm->getNumVerts(dm);
   int totface = dm->getNumPolys(dm);
@@ -273,7 +273,7 @@ static int ss_sync_from_uv(CCGSubSurf *ss,
    * Also, initially intention is to treat merged vertices from mirror modifier as seams.
    * This fixes a very old regression (2.49 was correct here) */
   vmap = BKE_mesh_uv_vert_map_create(
-      mpoly, nullptr, nullptr, mloop, mloopuv, totface, totvert, limit, false, true);
+      polys, nullptr, nullptr, mloop, mloopuv, totface, totvert, limit, false, true);
   if (!vmap) {
     return 0;
   }
@@ -297,7 +297,7 @@ static int ss_sync_from_uv(CCGSubSurf *ss,
     for (v = BKE_mesh_uv_vert_map_get_vert(vmap, i); v; v = v->next) {
       if (v->separate) {
         CCGVert *ssv;
-        int loopid = mpoly[v->poly_index].loopstart + v->loop_of_poly_index;
+        int loopid = polys[v->poly_index].loopstart + v->loop_of_poly_index;
         CCGVertHDL vhdl = POINTER_FROM_INT(loopid);
 
         copy_v2_v2(uv, mloopuv[loopid]);
@@ -311,16 +311,16 @@ static int ss_sync_from_uv(CCGSubSurf *ss,
   eset = BLI_edgeset_new_ex(__func__, BLI_EDGEHASH_SIZE_GUESS_FROM_POLYS(totface));
 
   for (i = 0; i < totface; i++) {
-    MPoly *mp = &mpoly[i];
-    int nverts = mp->totloop;
+    MPoly *poly = &polys[i];
+    int nverts = poly->totloop;
     int j, j_next;
     CCGFace *origf = ccgSubSurf_getFace(origss, POINTER_FROM_INT(i));
-    // uint *fv = &mp->v1;
-    MLoop *ml = mloop + mp->loopstart;
+    // uint *fv = &poly->v1;
+    MLoop *ml = mloop + poly->loopstart;
 
     fverts.reinitialize(nverts);
 
-    get_face_uv_map_vert(vmap, mpoly, ml, i, fverts.data());
+    get_face_uv_map_vert(vmap, polys, ml, i, fverts.data());
 
     for (j = 0, j_next = nverts - 1; j < nverts; j_next = j++) {
       uint v0 = POINTER_AS_UINT(fverts[j_next]);
@@ -328,7 +328,7 @@ static int ss_sync_from_uv(CCGSubSurf *ss,
 
       if (BLI_edgeset_add(eset, v0, v1)) {
         CCGEdge *e, *orige = ccgSubSurf_getFaceEdge(origf, j_next);
-        CCGEdgeHDL ehdl = POINTER_FROM_INT(mp->loopstart + j_next);
+        CCGEdgeHDL ehdl = POINTER_FROM_INT(poly->loopstart + j_next);
         float crease = ccgSubSurf_getEdgeCrease(orige);
 
         ccgSubSurf_syncEdge(ss, ehdl, fverts[j_next], fverts[j], crease, &e);
@@ -340,14 +340,14 @@ static int ss_sync_from_uv(CCGSubSurf *ss,
 
   /* create faces */
   for (i = 0; i < totface; i++) {
-    MPoly *mp = &mpoly[i];
-    MLoop *ml = &mloop[mp->loopstart];
-    int nverts = mp->totloop;
+    MPoly *poly = &polys[i];
+    MLoop *ml = &mloop[poly->loopstart];
+    int nverts = poly->totloop;
     CCGFace *f;
 
     fverts.reinitialize(nverts);
 
-    get_face_uv_map_vert(vmap, mpoly, ml, i, fverts.data());
+    get_face_uv_map_vert(vmap, polys, ml, i, fverts.data());
     ccgSubSurf_syncFace(ss, POINTER_FROM_INT(i), nverts, fverts.data(), &f);
   }
 
@@ -540,10 +540,10 @@ static void ss_sync_ccg_from_derivedmesh(CCGSubSurf *ss,
   float creaseFactor = float(ccgSubSurf_getSubdivisionLevels(ss));
   blender::Vector<CCGVertHDL, 16> fverts;
   float(*positions)[3] = (float(*)[3])dm->getVertArray(dm);
-  MEdge *medge = dm->getEdgeArray(dm);
-  MEdge *me;
+  MEdge *edges = dm->getEdgeArray(dm);
+  MEdge *edge;
   MLoop *mloop = dm->getLoopArray(dm), *ml;
-  MPoly *mpoly = dm->getPolyArray(dm), *mp;
+  MPoly *polys = dm->getPolyArray(dm), *poly;
   int totvert = dm->getNumVerts(dm);
   int totedge = dm->getNumEdges(dm);
   int i, j;
@@ -565,30 +565,30 @@ static void ss_sync_ccg_from_derivedmesh(CCGSubSurf *ss,
     ((int *)ccgSubSurf_getVertUserData(ss, v))[1] = (index) ? *index++ : i;
   }
 
-  me = medge;
+  edge = edges;
   index = (int *)dm->getEdgeDataArray(dm, CD_ORIGINDEX);
   const float *creases = (const float *)dm->getEdgeDataArray(dm, CD_CREASE);
-  for (i = 0; i < totedge; i++, me++) {
+  for (i = 0; i < totedge; i++, edge++) {
     CCGEdge *e;
     float crease;
 
     crease = useFlatSubdiv ? creaseFactor : (creases ? creases[i] * creaseFactor : 0.0f);
 
     ccgSubSurf_syncEdge(
-        ss, POINTER_FROM_INT(i), POINTER_FROM_UINT(me->v1), POINTER_FROM_UINT(me->v2), crease, &e);
+        ss, POINTER_FROM_INT(i), POINTER_FROM_UINT(edge->v1), POINTER_FROM_UINT(edge->v2), crease, &e);
 
     ((int *)ccgSubSurf_getEdgeUserData(ss, e))[1] = (index) ? *index++ : i;
   }
 
-  mp = mpoly;
+  poly = polys;
   index = (int *)dm->getPolyDataArray(dm, CD_ORIGINDEX);
-  for (i = 0; i < dm->numPolyData; i++, mp++) {
+  for (i = 0; i < dm->numPolyData; i++, poly++) {
     CCGFace *f;
 
-    fverts.reinitialize(mp->totloop);
+    fverts.reinitialize(poly->totloop);
 
-    ml = mloop + mp->loopstart;
-    for (j = 0; j < mp->totloop; j++, ml++) {
+    ml = mloop + poly->loopstart;
+    for (j = 0; j < poly->totloop; j++, ml++) {
       fverts[j] = POINTER_FROM_UINT(ml->v);
     }
 
@@ -596,7 +596,7 @@ static void ss_sync_ccg_from_derivedmesh(CCGSubSurf *ss,
      * it is not really possible to continue without modifying
      * other parts of code significantly to handle missing faces.
      * since this really shouldn't even be possible we just bail. */
-    if (ccgSubSurf_syncFace(ss, POINTER_FROM_INT(i), mp->totloop, fverts.data(), &f) ==
+    if (ccgSubSurf_syncFace(ss, POINTER_FROM_INT(i), poly->totloop, fverts.data(), &f) ==
         eCCGError_InvalidValue) {
       static int hasGivenError = 0;
 
@@ -911,13 +911,13 @@ static void ccgDM_copyFinalVertArray(DerivedMesh *dm, float (*r_positions)[3])
 }
 
 /* utility function */
-BLI_INLINE void ccgDM_to_MEdge(MEdge *med, const int v1, const int v2)
+BLI_INLINE void ccgDM_to_MEdge(MEdge *edge, const int v1, const int v2)
 {
-  med->v1 = v1;
-  med->v2 = v2;
+  edge->v1 = v1;
+  edge->v2 = v2;
 }
 
-static void ccgDM_copyFinalEdgeArray(DerivedMesh *dm, MEdge *medge)
+static void ccgDM_copyFinalEdgeArray(DerivedMesh *dm, MEdge *edges)
 {
   CCGDerivedMesh *ccgdm = (CCGDerivedMesh *)dm;
   CCGSubSurf *ss = ccgdm->ss;
@@ -934,17 +934,17 @@ static void ccgDM_copyFinalEdgeArray(DerivedMesh *dm, MEdge *medge)
 
     for (S = 0; S < numVerts; S++) {
       for (x = 0; x < gridSize - 1; x++) {
-        ccgDM_to_MEdge(&medge[i++],
+        ccgDM_to_MEdge(&edges[i++],
                        getFaceIndex(ss, f, S, x, 0, edgeSize, gridSize),
                        getFaceIndex(ss, f, S, x + 1, 0, edgeSize, gridSize));
       }
 
       for (x = 1; x < gridSize - 1; x++) {
         for (y = 0; y < gridSize - 1; y++) {
-          ccgDM_to_MEdge(&medge[i++],
+          ccgDM_to_MEdge(&edges[i++],
                          getFaceIndex(ss, f, S, x, y, edgeSize, gridSize),
                          getFaceIndex(ss, f, S, x, y + 1, edgeSize, gridSize));
-          ccgDM_to_MEdge(&medge[i++],
+          ccgDM_to_MEdge(&edges[i++],
                          getFaceIndex(ss, f, S, y, x, edgeSize, gridSize),
                          getFaceIndex(ss, f, S, y + 1, x, edgeSize, gridSize));
         }
@@ -957,7 +957,7 @@ static void ccgDM_copyFinalEdgeArray(DerivedMesh *dm, MEdge *medge)
     CCGEdge *e = ccgdm->edgeMap[index].edge;
     for (int x = 0; x < edgeSize - 1; x++) {
       ccgDM_to_MEdge(
-          &medge[i++], getEdgeIndex(ss, e, x, edgeSize), getEdgeIndex(ss, e, x + 1, edgeSize));
+          &edges[i++], getEdgeIndex(ss, e, x, edgeSize), getEdgeIndex(ss, e, x + 1, edgeSize));
     }
   }
 }
@@ -1022,14 +1022,14 @@ static void ccgDM_copyFinalLoopArray(DerivedMesh *dm, MLoop *mloop)
   if (!ccgdm->ehash) {
     BLI_mutex_lock(&ccgdm->loops_cache_lock);
     if (!ccgdm->ehash) {
-      MEdge *medge;
+      MEdge *edges;
       EdgeHash *ehash;
 
       ehash = BLI_edgehash_new_ex(__func__, ccgdm->dm.numEdgeData);
-      medge = ccgdm->dm.getEdgeArray((DerivedMesh *)ccgdm);
+      edges = ccgdm->dm.getEdgeArray((DerivedMesh *)ccgdm);
 
       for (int i = 0; i < ccgdm->dm.numEdgeData; i++) {
-        BLI_edgehash_insert(ehash, medge[i].v1, medge[i].v2, POINTER_FROM_INT(i));
+        BLI_edgehash_insert(ehash, edges[i].v1, edges[i].v2, POINTER_FROM_INT(i));
       }
 
       atomic_cas_ptr((void **)&ccgdm->ehash, ccgdm->ehash, ehash);
@@ -1058,7 +1058,7 @@ static void ccgDM_copyFinalLoopArray(DerivedMesh *dm, MLoop *mloop)
       0, ccgSubSurf_getNumFaces(ss), &data, copyFinalLoopArray_task_cb, &settings);
 }
 
-static void ccgDM_copyFinalPolyArray(DerivedMesh *dm, MPoly *mpoly)
+static void ccgDM_copyFinalPolyArray(DerivedMesh *dm, MPoly *polys)
 {
   CCGDerivedMesh *ccgdm = (CCGDerivedMesh *)dm;
   CCGSubSurf *ss = ccgdm->ss;
@@ -1078,11 +1078,11 @@ static void ccgDM_copyFinalPolyArray(DerivedMesh *dm, MPoly *mpoly)
     for (S = 0; S < numVerts; S++) {
       for (y = 0; y < gridSize - 1; y++) {
         for (x = 0; x < gridSize - 1; x++) {
-          MPoly *mp = &mpoly[i];
+          MPoly *poly = &polys[i];
 
-          mp->flag = flag;
-          mp->loopstart = k;
-          mp->totloop = 4;
+          poly->flag = flag;
+          poly->loopstart = k;
+          poly->totloop = 4;
 
           k += 4;
           i++;
@@ -1542,7 +1542,7 @@ static void set_ccgdm_all_geometry(CCGDerivedMesh *ccgdm,
   gridSideEdges = gridSize - 1;
   gridInternalEdges = (gridSideEdges - 1) * gridSideEdges * 2;
 
-  const MPoly *mpoly = static_cast<const MPoly *>(CustomData_get_layer(&dm->polyData, CD_MPOLY));
+  const MPoly *polys = static_cast<const MPoly *>(CustomData_get_layer(&dm->polyData, CD_MPOLY));
   const int *material_indices = static_cast<const int *>(
       CustomData_get_layer_named(&dm->polyData, CD_MPOLY, "material_index"));
   const int *base_polyOrigIndex = static_cast<const int *>(
@@ -1570,7 +1570,7 @@ static void set_ccgdm_all_geometry(CCGDerivedMesh *ccgdm,
     ccgdm->faceMap[index].startEdge = edgeNum;
     ccgdm->faceMap[index].startFace = faceNum;
 
-    faceFlags->flag = mpoly ? mpoly[origIndex].flag : 0;
+    faceFlags->flag = polys ? polys[origIndex].flag : 0;
     faceFlags->mat_nr = material_indices ? material_indices[origIndex] : 0;
     faceFlags++;
 
diff --git a/source/blender/blenloader/intern/versioning_280.c b/source/blender/blenloader/intern/versioning_280.c
index 4672491425e..e0b3c813ff6 100644
--- a/source/blender/blenloader/intern/versioning_280.c
+++ b/source/blender/blenloader/intern/versioning_280.c
@@ -1616,7 +1616,7 @@ void do_versions_after_linking_280(FileData *fd, Main *bmain)
      * which exact version fully deprecated tessfaces, so think we can keep that one here, no
      * harm to be expected anyway for being over-conservative. */
     for (Mesh *me = bmain->meshes.first; me != NULL; me = me->id.next) {
-      /* Check if we need to convert mfaces to mpolys. */
+      /* Check if we need to convert mfaces to polys. */
       if (me->totface && !me->totpoly) {
         /* temporarily switch main so that reading from
          * external CustomData works */
diff --git a/source/blender/bmesh/intern/bmesh_mesh_convert.cc b/source/blender/bmesh/intern/bmesh_mesh_convert.cc
index 23a2d8f708a..c2484e30bf2 100644
--- a/source/blender/bmesh/intern/bmesh_mesh_convert.cc
+++ b/source/blender/bmesh/intern/bmesh_mesh_convert.cc
@@ -468,11 +468,11 @@ void BM_mesh_bm_from_me(BMesh *bm, const Mesh *me, const struct BMeshFromMeshPar
     bm->elem_index_dirty &= ~BM_VERT; /* Added in order, clear dirty flag. */
   }
 
-  const Span<MEdge> medge = me->edges();
+  const Span<MEdge> edges = me->edges();
   Array<BMEdge *> etable(me->totedge);
-  for (const int i : medge.index_range()) {
+  for (const int i : edges.index_range()) {
     BMEdge *e = etable[i] = BM_edge_create(
-        bm, vtable[medge[i].v1], vtable[medge[i].v2], nullptr, BM_CREATE_SKIP_CD);
+        bm, vtable[edges[i].v1], vtable[edges[i].v2], nullptr, BM_CREATE_SKIP_CD);
     BM_elem_index_set(e, i); /* set_ok */
 
     e->head.hflag = 0;
@@ -495,7 +495,7 @@ void BM_mesh_bm_from_me(BMesh *bm, const Mesh *me, const struct BMeshFromMeshPar
     bm->elem_index_dirty &= ~BM_EDGE; /* Added in order, clear dirty flag. */
   }
 
-  const Span<MPoly> mpoly = me->polys();
+  const Span<MPoly> polys = me->polys();
   const Span<MLoop> mloop = me->loops();
 
   /* Only needed for selection. */
@@ -506,9 +506,9 @@ void BM_mesh_bm_from_me(BMesh *bm, const Mesh *me, const struct BMeshFromMeshPar
   }
 
   int totloops = 0;
-  for (const int i : mpoly.index_range()) {
+  for (const int i : polys.index_range()) {
     BMFace *f = bm_face_create_from_mpoly(
-        *bm, mloop.slice(mpoly[i].loopstart, mpoly[i].totloop), vtable, etable);
+        *bm, mloop.slice(polys[i].loopstart, polys[i].totloop), vtable, etable);
     if (!ftable.is_empty()) {
       ftable[i] = f;
     }
@@ -527,7 +527,7 @@ void BM_mesh_bm_from_me(BMesh *bm, const Mesh *me, const struct BMeshFromMeshPar
     BM_elem_index_set(f, bm->totface - 1); /* set_ok */
 
     /* Transfer flag. */
-    f->head.hflag = bm_face_flag_from_mflag(mpoly[i].flag);
+    f->head.hflag = bm_face_flag_from_mflag(polys[i].flag);
     if (hide_poly && hide_poly[i]) {
       BM_elem_flag_enable(f, BM_ELEM_HIDDEN);
     }
@@ -540,7 +540,7 @@ void BM_mesh_bm_from_me(BMesh *bm, const Mesh *me, const struct BMeshFromMeshPar
       bm->act_face = f;
     }
 
-    int j = mpoly[i].loopstart;
+    int j = polys[i].loopstart;
     BMLoop *l_first = BM_FACE_FIRST_LOOP(f);
     BMLoop *l_iter = l_first;
     do {
@@ -1241,8 +1241,8 @@ void BM_mesh_bm_to_me(Main *bmain, BMesh *bm, Mesh *me, const struct BMeshToMesh
   CustomData_add_layer(&me->ldata, CD_MLOOP, CD_SET_DEFAULT, nullptr, me->totloop);
   CustomData_add_layer(&me->pdata, CD_MPOLY, CD_SET_DEFAULT, nullptr, me->totpoly);
   MutableSpan<float3> positions = me->vert_positions_for_write();
-  MutableSpan<MEdge> medge = me->edges_for_write();
-  MutableSpan<MPoly> mpoly = me->polys_for_write();
+  MutableSpan<MEdge> edges = me->edges_for_write();
+  MutableSpan<MPoly> polys = me->polys_for_write();
   MutableSpan<MLoop> mloop = me->loops_for_write();
 
   bool need_select_vert = false;
@@ -1278,8 +1278,8 @@ void BM_mesh_bm_to_me(Main *bmain, BMesh *bm, Mesh *me, const struct BMeshToMesh
 
   i = 0;
   BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
-    medge[i].v1 = BM_elem_index_get(e->v1);
-    medge[i].v2 = BM_elem_index_get(e->v2);
+    edges[i].v1 = BM_elem_index_get(e->v1);
+    edges[i].v2 = BM_elem_index_get(e->v2);
 
     if (BM_elem_flag_test(e, BM_ELEM_SEAM)) {
       need_uv_seam = true;
@@ -1307,12 +1307,12 @@ void BM_mesh_bm_to_me(Main *bmain, BMesh *bm, Mesh *me, const struct BMeshToMesh
   j = 0;
   BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
     BMLoop *l_iter, *l_first;
-    mpoly[i].loopstart = j;
-    mpoly[i].totloop = f->len;
+    polys[i].loopstart = j;
+    polys[i].totloop = f->len;
     if (f->mat_nr != 0) {
       need_material_index = true;
     }
-    mpoly[i].flag = bm_face_flag_to_mflag(f);
+    polys[i].flag = bm_face_flag_to_mflag(f);
     if (BM_elem_flag_test(f, BM_ELEM_HIDDEN)) {
       need_hide_poly = true;
     }
diff --git a/source/blender/draw/DRW_pbvh.hh b/source/blender/draw/DRW_pbvh.hh
index 74cf1f93594..22c21fc9c8d 100644
--- a/source/blender/draw/DRW_pbvh.hh
+++ b/source/blender/draw/DRW_pbvh.hh
@@ -35,7 +35,7 @@ struct PBVH_GPU_Args {
   const Mesh *me;
   const float (*vert_positions)[3];
   const MLoop *mloop;
-  const MPoly *mpoly;
+  const MPoly *polys;
   int mesh_verts_num, mesh_faces_num, mesh_grids_num;
   CustomData *vdata, *ldata, *pdata;
   const float (*vert_normals)[3];
diff --git a/source/blender/draw/intern/draw_cache_extract_mesh.cc b/source/blender/draw/intern/draw_cache_extract_mesh.cc
index 1ecd16ea8a9..5d5603eb858 100644
--- a/source/blender/draw/intern/draw_cache_extract_mesh.cc
+++ b/source/blender/draw/intern/draw_cache_extract_mesh.cc
@@ -305,10 +305,10 @@ static void extract_range_iter_poly_mesh(void *__restrict userdata,
 
   const ExtractorIterData *data = static_cast<ExtractorIterData *>(userdata);
   const MeshRenderData *mr = data->mr;
-  const MPoly *mp = &((const MPoly *)data->elems)[iter];
+  const MPoly *poly = &((const MPoly *)data->elems)[iter];
   for (const ExtractorRunData &run_data : data->extractors) {
     run_data.extractor->iter_poly_mesh(
-        mr, mp, iter, POINTER_OFFSET(extract_data, run_data.data_offset));
+        mr, poly, iter, POINTER_OFFSET(extract_data, run_data.data_offset));
   }
 }
 
@@ -337,10 +337,10 @@ static void extract_range_iter_ledge_mesh(void *__restrict userdata,
   const ExtractorIterData *data = static_cast<ExtractorIterData *>(userdata);
   const MeshRenderData *mr = data->mr;
   const int ledge_index = data->loose_elems[iter];
-  const MEdge *med = &((const MEdge *)data->elems)[ledge_index];
+  const MEdge *edge = &((const MEdge *)data->elems)[ledge_index];
   for (const ExtractorRunData &run_data : data->extractors) {
     run_data.extractor->iter_ledge_mesh(
-        mr, med, iter, POINTER_OFFSET(extract_data, run_data.data_offset));
+        mr, edge, iter, POINTER_OFFSET(extract_data, run_data.data_offset));
   }
 }
 
@@ -885,8 +885,8 @@ void mesh_buffer_cache_create_requested_subdiv(MeshBatchCache *cache,
           /* Multiply by 4 to have the start index of the quad's loop, as subdiv_loop_poly_index is
            * based on the subdivision loops. */
           const int poly_origindex = subdiv_loop_poly_index[i * 4];
-          const MPoly *mp = &mr->polys[poly_origindex];
-          extractor->iter_subdiv_mesh(subdiv_cache, mr, data, i, mp);
+          const MPoly *poly = &mr->polys[poly_origindex];
+          extractor->iter_subdiv_mesh(subdiv_cache, mr, data, i, poly);
         }
       }
     }
diff --git a/source/blender/draw/intern/draw_cache_extract_mesh_render_data.cc b/source/blender/draw/intern/draw_cache_extract_mesh_render_data.cc
index 2f66c9ed1e4..e8e011c650c 100644
--- a/source/blender/draw/intern/draw_cache_extract_mesh_render_data.cc
+++ b/source/blender/draw/intern/draw_cache_extract_mesh_render_data.cc
@@ -237,10 +237,10 @@ static void mesh_render_data_polys_sorted_build(MeshRenderData *mr, MeshBufferCa
   else {
     for (int i = 0; i < mr->poly_len; i++) {
       if (!(mr->use_hide && mr->hide_poly && mr->hide_poly[i])) {
-        const MPoly *mp = &mr->polys[i];
+        const MPoly *poly = &mr->polys[i];
         const int mat = min_ii(mr->material_indices ? mr->material_indices[i] : 0, mat_last);
         tri_first_index[i] = mat_tri_offs[mat];
-        mat_tri_offs[mat] += mp->totloop - 2;
+        mat_tri_offs[mat] += poly->totloop - 2;
       }
       else {
         tri_first_index[i] = -1;
@@ -275,10 +275,10 @@ static void mesh_render_data_mat_tri_len_mesh_range_fn(void *__restrict userdata
   MeshRenderData *mr = static_cast<MeshRenderData *>(userdata);
   int *mat_tri_len = static_cast<int *>(tls->userdata_chunk);
 
-  const MPoly *mp = &mr->polys[iter];
+  const MPoly *poly = &mr->polys[iter];
   if (!(mr->use_hide && mr->hide_poly && mr->hide_poly[iter])) {
     int mat = min_ii(mr->material_indices ? mr->material_indices[iter] : 0, mr->mat_len - 1);
-    mat_tri_len[mat] += mp->totloop - 2;
+    mat_tri_len[mat] += poly->totloop - 2;
   }
 }
 
@@ -371,7 +371,7 @@ void mesh_render_data_update_normals(MeshRenderData *mr, const eMRDataType data_
           CustomData_get_layer_named(&mr->me->edata, CD_PROP_BOOL, "sharp_edge"));
       BKE_mesh_normals_loop_split(reinterpret_cast<const float(*)[3]>(mr->vert_positions.data()),
                                   reinterpret_cast<const float(*)[3]>(mr->vert_normals.data()),
-                                  mr->vert_len,
+                                  mr->vert_positions.size(),
                                   mr->edges.data(),
                                   mr->edges.size(),
                                   mr->loops.data(),
diff --git a/source/blender/draw/intern/draw_pbvh.cc b/source/blender/draw/intern/draw_pbvh.cc
index 84dd9e1f46b..d34e85e5694 100644
--- a/source/blender/draw/intern/draw_pbvh.cc
+++ b/source/blender/draw/intern/draw_pbvh.cc
@@ -339,14 +339,14 @@ struct PBVHBatches {
     bool smooth = false;
 
     foreach_faces([&](int /*buffer_i*/, int /*tri_i*/, int vertex_i, const MLoopTri *tri) {
-      const MPoly *mp = args->mpoly + tri->poly;
+      const MPoly *poly = args->polys + tri->poly;
 
       if (tri->poly != last_poly) {
         last_poly = tri->poly;
 
-        if (!(mp->flag & ME_SMOOTH)) {
+        if (!(poly->flag & ME_SMOOTH)) {
           smooth = true;
-          BKE_mesh_calc_poly_normal(mp, args->mloop + mp->loopstart, args->vert_positions, fno);
+          BKE_mesh_calc_poly_normal(poly, args->mloop + poly->loopstart, args->vert_positions, fno);
           normal_float_to_short_v3(no, fno);
         }
         else {
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh.hh b/source/blender/draw/intern/mesh_extractors/extract_mesh.hh
index 2d8b2a98230..727bacadb0c 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh.hh
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh.hh
@@ -254,15 +254,15 @@ using ExtractPolyBMeshFn = void(const MeshRenderData *mr,
                                 int f_index,
                                 void *data);
 using ExtractPolyMeshFn = void(const MeshRenderData *mr,
-                               const MPoly *mp,
-                               int mp_index,
+                               const MPoly *poly,
+                               int poly_index,
                                void *data);
 using ExtractLEdgeBMeshFn = void(const MeshRenderData *mr,
                                  const BMEdge *eed,
                                  int ledge_index,
                                  void *data);
 using ExtractLEdgeMeshFn = void(const MeshRenderData *mr,
-                                const MEdge *med,
+                                const MEdge *edge,
                                 int ledge_index,
                                 void *data);
 using ExtractLVertBMeshFn = void(const MeshRenderData *mr,
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_edituv.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_edituv.cc
index 18600d1c906..c71fc5619ad 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_edituv.cc
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_edituv.cc
@@ -204,30 +204,30 @@ static void extract_edituv_lines_iter_poly_bm(const MeshRenderData * /*mr*/,
 }
 
 static void extract_edituv_lines_iter_poly_mesh(const MeshRenderData *mr,
-                                                const MPoly *mp,
-                                                const int mp_index,
+                                                const MPoly *poly,
+                                                const int poly_index,
                                                 void *_data)
 {
   MeshExtract_EditUvElem_Data *data = static_cast<MeshExtract_EditUvElem_Data *>(_data);
   const MLoop *mloop = mr->loops.data();
-  const int ml_index_end = mp->loopstart + mp->totloop;
+  const int ml_index_end = poly->loopstart + poly->totloop;
 
   bool mp_hidden, mp_select;
   if (mr->bm) {
-    const BMFace *efa = bm_original_face_get(mr, mp_index);
+    const BMFace *efa = bm_original_face_get(mr, poly_index);
     mp_hidden = (efa) ? BM_elem_flag_test_bool(efa, BM_ELEM_HIDDEN) : true;
     mp_select = (efa) ? BM_elem_flag_test_bool(efa, BM_ELEM_SELECT) : false;
   }
   else {
-    mp_hidden = (mr->hide_poly) ? mr->hide_poly[mp_index] : false;
-    mp_select = mr->select_poly && mr->select_poly[mp_index];
+    mp_hidden = (mr->hide_poly) ? mr->hide_poly[poly_index] : false;
+    mp_select = mr->select_poly && mr->select_poly[poly_index];
   }
 
-  for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
+  for (int ml_index = poly->loopstart; ml_index < ml_index_end; ml_index += 1) {
     const MLoop *ml = &mloop[ml_index];
 
-    const int ml_index_last = mp->totloop + mp->loopstart - 1;
-    const int ml_index_next = (ml_index == ml_index_last) ? mp->loopstart : (ml_index + 1);
+    const int ml_index_last = poly->totloop + poly->loopstart - 1;
+    const int ml_index_next = (ml_index == ml_index_last) ? poly->loopstart : (ml_index + 1);
     const bool real_edge = (mr->e_origindex == nullptr ||
                             mr->e_origindex[ml->e] != ORIGINDEX_NONE);
     edituv_edge_add(data, mp_hidden || !real_edge, mp_select, ml_index, ml_index_next);
@@ -390,18 +390,18 @@ static void extract_edituv_points_iter_poly_bm(const MeshRenderData * /*mr*/,
 }
 
 static void extract_edituv_points_iter_poly_mesh(const MeshRenderData *mr,
-                                                 const MPoly *mp,
-                                                 const int mp_index,
+                                                 const MPoly *poly,
+                                                 const int poly_index,
                                                  void *_data)
 {
   MeshExtract_EditUvElem_Data *data = static_cast<MeshExtract_EditUvElem_Data *>(_data);
 
-  const BMFace *efa = bm_original_face_get(mr, mp_index);
+  const BMFace *efa = bm_original_face_get(mr, poly_index);
   const bool mp_hidden = (efa) ? BM_elem_flag_test_bool(efa, BM_ELEM_HIDDEN) : true;
   const bool mp_select = (efa) ? BM_elem_flag_test_bool(efa, BM_ELEM_SELECT) : false;
 
-  const int ml_index_end = mp->loopstart + mp->totloop;
-  for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
+  const int ml_index_end = poly->loopstart + poly->totloop;
+  for (int ml_index = poly->loopstart; ml_index < ml_index_end; ml_index += 1) {
     const MLoop *ml = &mr->loops[ml_index];
 
     const bool real_vert = !mr->v_origindex || mr->v_origindex[ml->v] != ORIGINDEX_NONE;
@@ -545,31 +545,31 @@ static void extract_edituv_fdots_iter_poly_bm(const MeshRenderData * /*mr*/,
 }
 
 static void extract_edituv_fdots_iter_poly_mesh(const MeshRenderData *mr,
-                                                const MPoly *mp,
-                                                const int mp_index,
+                                                const MPoly *poly,
+                                                const int poly_index,
                                                 void *_data)
 {
   MeshExtract_EditUvElem_Data *data = static_cast<MeshExtract_EditUvElem_Data *>(_data);
 
-  const BMFace *efa = bm_original_face_get(mr, mp_index);
+  const BMFace *efa = bm_original_face_get(mr, poly_index);
   const bool mp_hidden = (efa) ? BM_elem_flag_test_bool(efa, BM_ELEM_HIDDEN) : true;
   const bool mp_select = (efa) ? BM_elem_flag_test_bool(efa, BM_ELEM_SELECT) : false;
 
   if (mr->use_subsurf_fdots) {
     const BitSpan facedot_tags = mr->me->runtime->subsurf_face_dot_tags;
 
-    const int ml_index_end = mp->loopstart + mp->totloop;
-    for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
+    const int ml_index_end = poly->loopstart + poly->totloop;
+    for (int ml_index = poly->loopstart; ml_index < ml_index_end; ml_index += 1) {
       const MLoop *ml = &mr->loops[ml_index];
 
-      const bool real_fdot = !mr->p_origindex || (mr->p_origindex[mp_index] != ORIGINDEX_NONE);
+      const bool real_fdot = !mr->p_origindex || (mr->p_origindex[poly_index] != ORIGINDEX_NONE);
       const bool subd_fdot = facedot_tags[ml->v];
-      edituv_facedot_add(data, mp_hidden || !real_fdot || !subd_fdot, mp_select, mp_index);
+      edituv_facedot_add(data, mp_hidden || !real_fdot || !subd_fdot, mp_select, poly_index);
     }
   }
   else {
-    const bool real_fdot = !mr->p_origindex || (mr->p_origindex[mp_index] != ORIGINDEX_NONE);
-    edituv_facedot_add(data, mp_hidden || !real_fdot, mp_select, mp_index);
+    const bool real_fdot = !mr->p_origindex || (mr->p_origindex[poly_index] != ORIGINDEX_NONE);
+    edituv_facedot_add(data, mp_hidden || !real_fdot, mp_select, poly_index);
   }
 }
 
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_fdots.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_fdots.cc
index dfc1242e94a..c27ba8bdf89 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_fdots.cc
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_fdots.cc
@@ -38,32 +38,32 @@ static void extract_fdots_iter_poly_bm(const MeshRenderData * /*mr*/,
 }
 
 static void extract_fdots_iter_poly_mesh(const MeshRenderData *mr,
-                                         const MPoly *mp,
-                                         const int mp_index,
+                                         const MPoly *poly,
+                                         const int poly_index,
                                          void *_userdata)
 {
-  const bool hidden = mr->use_hide && mr->hide_poly && mr->hide_poly[mp_index];
+  const bool hidden = mr->use_hide && mr->hide_poly && mr->hide_poly[poly_index];
 
   GPUIndexBufBuilder *elb = static_cast<GPUIndexBufBuilder *>(_userdata);
   if (mr->use_subsurf_fdots) {
     const BitSpan facedot_tags = mr->me->runtime->subsurf_face_dot_tags;
 
-    const int ml_index_end = mp->loopstart + mp->totloop;
-    for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
+    const int ml_index_end = poly->loopstart + poly->totloop;
+    for (int ml_index = poly->loopstart; ml_index < ml_index_end; ml_index += 1) {
       const MLoop *ml = &mr->loops[ml_index];
       if (facedot_tags[ml->v] && !hidden) {
-        GPU_indexbuf_set_point_vert(elb, mp_index, mp_index);
+        GPU_indexbuf_set_point_vert(elb, poly_index, poly_index);
         return;
       }
     }
-    GPU_indexbuf_set_point_restart(elb, mp_index);
+    GPU_indexbuf_set_point_restart(elb, poly_index);
   }
   else {
     if (!hidden) {
-      GPU_indexbuf_set_point_vert(elb, mp_index, mp_index);
+      GPU_indexbuf_set_point_vert(elb, poly_index, poly_index);
     }
     else {
-      GPU_indexbuf_set_point_restart(elb, mp_index);
+      GPU_indexbuf_set_point_restart(elb, poly_index);
     }
   }
 }
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_lines.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_lines.cc
index 7063aebd8ba..8cae5033020 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_lines.cc
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_lines.cc
@@ -51,16 +51,16 @@ static void extract_lines_iter_poly_bm(const MeshRenderData * /*mr*/,
 }
 
 static void extract_lines_iter_poly_mesh(const MeshRenderData *mr,
-                                         const MPoly *mp,
-                                         const int /*mp_index*/,
+                                         const MPoly *poly,
+                                         const int /*poly_index*/,
                                          void *data)
 {
   GPUIndexBufBuilder *elb = static_cast<GPUIndexBufBuilder *>(data);
   /* Using poly & loop iterator would complicate accessing the adjacent loop. */
   const int *e_origindex = (mr->edit_bmesh) ? mr->e_origindex : nullptr;
   if (mr->use_hide || (e_origindex != nullptr)) {
-    const int ml_index_last = mp->loopstart + (mp->totloop - 1);
-    int ml_index = ml_index_last, ml_index_next = mp->loopstart;
+    const int ml_index_last = poly->loopstart + (poly->totloop - 1);
+    int ml_index = ml_index_last, ml_index_next = poly->loopstart;
     do {
       const MLoop *ml = &mr->loops[ml_index];
       if (!((mr->use_hide && mr->hide_edge && mr->hide_edge[ml->e]) ||
@@ -73,8 +73,8 @@ static void extract_lines_iter_poly_mesh(const MeshRenderData *mr,
     } while ((ml_index = ml_index_next++) != ml_index_last);
   }
   else {
-    const int ml_index_last = mp->loopstart + (mp->totloop - 1);
-    int ml_index = ml_index_last, ml_index_next = mp->loopstart;
+    const int ml_index_last = poly->loopstart + (poly->totloop - 1);
+    int ml_index = ml_index_last, ml_index_next = poly->loopstart;
     do {
       const MLoop *ml = &mr->loops[ml_index];
       GPU_indexbuf_set_line_verts(elb, ml->e, ml_index, ml_index_next);
@@ -101,7 +101,7 @@ static void extract_lines_iter_ledge_bm(const MeshRenderData *mr,
 }
 
 static void extract_lines_iter_ledge_mesh(const MeshRenderData *mr,
-                                          const MEdge *med,
+                                          const MEdge *edge,
                                           const int ledge_index,
                                           void *data)
 {
@@ -109,7 +109,7 @@ static void extract_lines_iter_ledge_mesh(const MeshRenderData *mr,
   const int l_index_offset = mr->edge_len + ledge_index;
   const int e_index = mr->ledges[ledge_index];
   const int *e_origindex = (mr->edit_bmesh) ? mr->e_origindex : nullptr;
-  if (!((mr->use_hide && mr->hide_edge && mr->hide_edge[med - mr->edges.data()]) ||
+  if (!((mr->use_hide && mr->hide_edge && mr->hide_edge[edge - mr->edges.data()]) ||
         ((e_origindex) && (e_origindex[e_index] == ORIGINDEX_NONE)))) {
     const int l_index = mr->loop_len + ledge_index * 2;
     GPU_indexbuf_set_line_verts(elb, l_index_offset, l_index, l_index + 1);
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_lines_paint_mask.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_lines_paint_mask.cc
index 9b2603bac13..082299e82f0 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_lines_paint_mask.cc
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_lines_paint_mask.cc
@@ -36,22 +36,22 @@ static void extract_lines_paint_mask_init(const MeshRenderData *mr,
 }
 
 static void extract_lines_paint_mask_iter_poly_mesh(const MeshRenderData *mr,
-                                                    const MPoly *mp,
-                                                    const int mp_index,
+                                                    const MPoly *poly,
+                                                    const int poly_index,
                                                     void *_data)
 {
   MeshExtract_LinePaintMask_Data *data = static_cast<MeshExtract_LinePaintMask_Data *>(_data);
-  const int ml_index_end = mp->loopstart + mp->totloop;
-  for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
+  const int ml_index_end = poly->loopstart + poly->totloop;
+  for (int ml_index = poly->loopstart; ml_index < ml_index_end; ml_index += 1) {
     const MLoop *ml = &mr->loops[ml_index];
 
     const int e_index = ml->e;
     if (!((mr->use_hide && mr->hide_edge && mr->hide_edge[e_index]) ||
           ((mr->e_origindex) && (mr->e_origindex[e_index] == ORIGINDEX_NONE)))) {
 
-      const int ml_index_last = mp->totloop + mp->loopstart - 1;
-      const int ml_index_other = (ml_index == ml_index_last) ? mp->loopstart : (ml_index + 1);
-      if (mr->select_poly && mr->select_poly[mp_index]) {
+      const int ml_index_last = poly->totloop + poly->loopstart - 1;
+      const int ml_index_other = (ml_index == ml_index_last) ? poly->loopstart : (ml_index + 1);
+      if (mr->select_poly && mr->select_poly[poly_index]) {
         if (BLI_BITMAP_TEST_AND_SET_ATOMIC(data->select_map, e_index)) {
           /* Hide edge as it has more than 2 selected loop. */
           GPU_indexbuf_set_line_restart(&data->elb, e_index);
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_points.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_points.cc
index ef9717c1ff7..f0bf091d6ad 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_points.cc
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_points.cc
@@ -69,13 +69,13 @@ static void extract_points_iter_poly_bm(const MeshRenderData * /*mr*/,
 }
 
 static void extract_points_iter_poly_mesh(const MeshRenderData *mr,
-                                          const MPoly *mp,
-                                          const int /*mp_index*/,
+                                          const MPoly *poly,
+                                          const int /*poly_index*/,
                                           void *_userdata)
 {
   GPUIndexBufBuilder *elb = static_cast<GPUIndexBufBuilder *>(_userdata);
-  const int ml_index_end = mp->loopstart + mp->totloop;
-  for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
+  const int ml_index_end = poly->loopstart + poly->totloop;
+  for (int ml_index = poly->loopstart; ml_index < ml_index_end; ml_index += 1) {
     const MLoop *ml = &mr->loops[ml_index];
     vert_set_mesh(elb, mr, ml->v, ml_index);
   }
@@ -92,13 +92,13 @@ static void extract_points_iter_ledge_bm(const MeshRenderData *mr,
 }
 
 static void extract_points_iter_ledge_mesh(const MeshRenderData *mr,
-                                           const MEdge *med,
+                                           const MEdge *edge,
                                            const int ledge_index,
                                            void *_userdata)
 {
   GPUIndexBufBuilder *elb = static_cast<GPUIndexBufBuilder *>(_userdata);
-  vert_set_mesh(elb, mr, med->v1, mr->loop_len + (ledge_index * 2));
-  vert_set_mesh(elb, mr, med->v2, mr->loop_len + (ledge_index * 2) + 1);
+  vert_set_mesh(elb, mr, edge->v1, mr->loop_len + (ledge_index * 2));
+  vert_set_mesh(elb, mr, edge->v2, mr->loop_len + (ledge_index * 2) + 1);
 }
 
 static void extract_points_iter_lvert_bm(const MeshRenderData *mr,
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_tris.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_tris.cc
index 45ab67f149e..3568b7a2a83 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_tris.cc
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_tris.cc
@@ -60,19 +60,19 @@ static void extract_tris_iter_poly_bm(const MeshRenderData *mr,
 }
 
 static void extract_tris_iter_poly_mesh(const MeshRenderData *mr,
-                                        const MPoly *mp,
-                                        const int mp_index,
+                                        const MPoly *poly,
+                                        const int poly_index,
                                         void *_data)
 {
-  int tri_first_index = mr->poly_sorted.tri_first_index[mp_index];
+  int tri_first_index = mr->poly_sorted.tri_first_index[poly_index];
   if (tri_first_index == -1) {
     return;
   }
 
   GPUIndexBufBuilder *elb = static_cast<GPUIndexBufBuilder *>(_data);
-  int tri_first_index_real = poly_to_tri_count(mp_index, mp->loopstart);
+  int tri_first_index_real = poly_to_tri_count(poly_index, poly->loopstart);
 
-  int tri_len = mp->totloop - 2;
+  int tri_len = poly->totloop - 2;
   for (int offs = 0; offs < tri_len; offs++) {
     const MLoopTri *mlt = &mr->looptris[tri_first_index_real + offs];
     int tri_index = tri_first_index + offs;
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_attributes.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_attributes.cc
index af884b68374..5e7b292a0d3 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_attributes.cc
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_attributes.cc
@@ -209,9 +209,9 @@ static void fill_vertbuf_with_attribute(const MeshRenderData *mr,
       }
       break;
     case ATTR_DOMAIN_FACE:
-      for (int mp_index = 0; mp_index < mr->poly_len; mp_index++) {
-        const MPoly &poly = mr->polys[mp_index];
-        const VBOType value = Converter::convert_value(attr_data[mp_index]);
+      for (int poly_index = 0; poly_index < mr->poly_len; poly_index++) {
+        const MPoly &poly = mr->polys[poly_index];
+        const VBOType value = Converter::convert_value(attr_data[poly_index]);
         for (int l = 0; l < poly.totloop; l++) {
           *vbo_data++ = value;
         }
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edge_fac.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edge_fac.cc
index 3be5de9f373..0348d004c06 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edge_fac.cc
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edge_fac.cc
@@ -97,15 +97,15 @@ static void extract_edge_fac_iter_poly_bm(const MeshRenderData *mr,
 }
 
 static void extract_edge_fac_iter_poly_mesh(const MeshRenderData *mr,
-                                            const MPoly *mp,
-                                            const int mp_index,
+                                            const MPoly *poly,
+                                            const int poly_index,
                                             void *_data)
 {
   MeshExtract_EdgeFac_Data *data = static_cast<MeshExtract_EdgeFac_Data *>(_data);
   const BitSpan optimal_display_edges = mr->me->runtime->subsurf_optimal_display_edges;
 
-  const int ml_index_end = mp->loopstart + mp->totloop;
-  for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
+  const int ml_index_end = poly->loopstart + poly->totloop;
+  for (int ml_index = poly->loopstart; ml_index < ml_index_end; ml_index += 1) {
     const MLoop *ml = &mr->loops[ml_index];
 
     if (data->use_edge_render) {
@@ -119,10 +119,10 @@ static void extract_edge_fac_iter_poly_mesh(const MeshRenderData *mr,
       }
       if (data->edge_loop_count[ml->e] == 2) {
         /* Manifold */
-        const int ml_index_last = mp->totloop + mp->loopstart - 1;
-        const int ml_index_other = (ml_index == ml_index_last) ? mp->loopstart : (ml_index + 1);
+        const int ml_index_last = poly->totloop + poly->loopstart - 1;
+        const int ml_index_other = (ml_index == ml_index_last) ? poly->loopstart : (ml_index + 1);
         const MLoop *ml_next = &mr->loops[ml_index_other];
-        float ratio = loop_edge_factor_get(mr->poly_normals[mp_index],
+        float ratio = loop_edge_factor_get(mr->poly_normals[poly_index],
                                            mr->vert_positions[ml->v],
                                            mr->vert_normals[ml->v],
                                            mr->vert_positions[ml_next->v]);
@@ -147,7 +147,7 @@ static void extract_edge_fac_iter_ledge_bm(const MeshRenderData *mr,
 }
 
 static void extract_edge_fac_iter_ledge_mesh(const MeshRenderData *mr,
-                                             const MEdge * /*med*/,
+                                             const MEdge * /*edge*/,
                                              const int ledge_index,
                                              void *_data)
 {
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edit_data.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edit_data.cc
index ca437d7da46..553ad0cb4c9 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edit_data.cc
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edit_data.cc
@@ -145,18 +145,18 @@ static void extract_edit_data_iter_poly_bm(const MeshRenderData *mr,
 }
 
 static void extract_edit_data_iter_poly_mesh(const MeshRenderData *mr,
-                                             const MPoly *mp,
-                                             const int mp_index,
+                                             const MPoly *poly,
+                                             const int poly_index,
                                              void *_data)
 {
   EditLoopData *vbo_data = *(EditLoopData **)_data;
 
-  const int ml_index_end = mp->loopstart + mp->totloop;
-  for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
+  const int ml_index_end = poly->loopstart + poly->totloop;
+  for (int ml_index = poly->loopstart; ml_index < ml_index_end; ml_index += 1) {
     const MLoop *ml = &mr->loops[ml_index];
     EditLoopData *data = vbo_data + ml_index;
     memset(data, 0x0, sizeof(*data));
-    BMFace *efa = bm_original_face_get(mr, mp_index);
+    BMFace *efa = bm_original_face_get(mr, poly_index);
     BMEdge *eed = bm_original_edge_get(mr, ml->e);
     BMVert *eve = bm_original_vert_get(mr, ml->v);
     if (efa) {
@@ -186,7 +186,7 @@ static void extract_edit_data_iter_ledge_bm(const MeshRenderData *mr,
 }
 
 static void extract_edit_data_iter_ledge_mesh(const MeshRenderData *mr,
-                                              const MEdge *med,
+                                              const MEdge *edge,
                                               const int ledge_index,
                                               void *_data)
 {
@@ -195,8 +195,8 @@ static void extract_edit_data_iter_ledge_mesh(const MeshRenderData *mr,
   memset(data, 0x0, sizeof(*data) * 2);
   const int e_index = mr->ledges[ledge_index];
   BMEdge *eed = bm_original_edge_get(mr, e_index);
-  BMVert *eve1 = bm_original_vert_get(mr, med->v1);
-  BMVert *eve2 = bm_original_vert_get(mr, med->v2);
+  BMVert *eve1 = bm_original_vert_get(mr, edge->v1);
+  BMVert *eve2 = bm_original_vert_get(mr, edge->v2);
   if (eed) {
     mesh_render_data_edge_flag(mr, eed, &data[0]);
     data[1] = data[0];
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edituv_data.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edituv_data.cc
index b69846f0ffd..e93c341f73d 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edituv_data.cc
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edituv_data.cc
@@ -70,18 +70,18 @@ static void extract_edituv_data_iter_poly_bm(const MeshRenderData *mr,
 }
 
 static void extract_edituv_data_iter_poly_mesh(const MeshRenderData *mr,
-                                               const MPoly *mp,
-                                               const int mp_index,
+                                               const MPoly *poly,
+                                               const int poly_index,
                                                void *_data)
 {
   MeshExtract_EditUVData_Data *data = static_cast<MeshExtract_EditUVData_Data *>(_data);
-  const int ml_index_end = mp->loopstart + mp->totloop;
-  for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
+  const int ml_index_end = poly->loopstart + poly->totloop;
+  for (int ml_index = poly->loopstart; ml_index < ml_index_end; ml_index += 1) {
     const MLoop *ml = &mr->loops[ml_index];
 
     EditLoopData *eldata = &data->vbo_data[ml_index];
     memset(eldata, 0x0, sizeof(*eldata));
-    BMFace *efa = bm_original_face_get(mr, mp_index);
+    BMFace *efa = bm_original_face_get(mr, poly_index);
     if (efa) {
       BMEdge *eed = bm_original_edge_get(mr, ml->e);
       BMVert *eve = bm_original_vert_get(mr, ml->v);
@@ -95,8 +95,8 @@ static void extract_edituv_data_iter_poly_mesh(const MeshRenderData *mr,
         if (eed == nullptr) {
           /* Find if the loop's vert is not part of an edit edge.
            * For this, we check if the previous loop was on an edge. */
-          const int ml_index_last = mp->loopstart + mp->totloop - 1;
-          const int l_prev = (ml_index == mp->loopstart) ? ml_index_last : (ml_index - 1);
+          const int ml_index_last = poly->loopstart + poly->totloop - 1;
+          const int l_prev = (ml_index == poly->loopstart) ? ml_index_last : (ml_index - 1);
           const MLoop *ml_prev = &mr->loops[l_prev];
           eed = bm_original_edge_get(mr, ml_prev->e);
         }
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edituv_stretch_angle.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edituv_stretch_angle.cc
index 66d3b46ce20..9e0a149d181 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edituv_stretch_angle.cc
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edituv_stretch_angle.cc
@@ -154,21 +154,21 @@ static void extract_edituv_stretch_angle_iter_poly_bm(const MeshRenderData *mr,
 }
 
 static void extract_edituv_stretch_angle_iter_poly_mesh(const MeshRenderData *mr,
-                                                        const MPoly *mp,
-                                                        const int /*mp_index*/,
+                                                        const MPoly *poly,
+                                                        const int /*poly_index*/,
                                                         void *_data)
 {
   MeshExtract_StretchAngle_Data *data = static_cast<MeshExtract_StretchAngle_Data *>(_data);
 
-  const int ml_index_end = mp->loopstart + mp->totloop;
-  for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
+  const int ml_index_end = poly->loopstart + poly->totloop;
+  for (int ml_index = poly->loopstart; ml_index < ml_index_end; ml_index += 1) {
     float(*auv)[2] = data->auv, *last_auv = data->last_auv;
     float(*av)[3] = data->av, *last_av = data->last_av;
     int l_next = ml_index + 1;
-    if (ml_index == mp->loopstart) {
+    if (ml_index == poly->loopstart) {
       /* First loop in face. */
       const int ml_index_last = ml_index_end - 1;
-      const int l_next_tmp = mp->loopstart;
+      const int l_next_tmp = poly->loopstart;
       compute_normalize_edge_vectors(auv,
                                      av,
                                      data->uv[ml_index_last],
@@ -180,7 +180,7 @@ static void extract_edituv_stretch_angle_iter_poly_mesh(const MeshRenderData *mr
       copy_v3_v3(last_av, av[1]);
     }
     if (l_next == ml_index_end) {
-      l_next = mp->loopstart;
+      l_next = poly->loopstart;
       /* Move previous edge. */
       copy_v2_v2(auv[0], auv[1]);
       copy_v3_v3(av[0], av[1]);
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edituv_stretch_area.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edituv_stretch_area.cc
index 93955934c44..5ef7f207688 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edituv_stretch_area.cc
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edituv_stretch_area.cc
@@ -75,8 +75,8 @@ static void compute_area_ratio(const MeshRenderData *mr,
   else {
     BLI_assert(mr->extract_type == MR_EXTRACT_MESH);
     const float2 *uv_data = (const float2 *)CustomData_get_layer(&mr->me->ldata, CD_PROP_FLOAT2);
-    for (int mp_index = 0; mp_index < mr->poly_len; mp_index++) {
-      const MPoly &poly = mr->polys[mp_index];
+    for (int poly_index = 0; poly_index < mr->poly_len; poly_index++) {
+      const MPoly &poly = mr->polys[poly_index];
       float area = BKE_mesh_calc_poly_area(
           &poly,
           &mr->loops[poly.loopstart],
@@ -85,7 +85,7 @@ static void compute_area_ratio(const MeshRenderData *mr,
                                   poly.totloop);
       tot_area += area;
       tot_uv_area += uvarea;
-      r_area_ratio[mp_index] = area_ratio_get(area, uvarea);
+      r_area_ratio[poly_index] = area_ratio_get(area, uvarea);
     }
   }
 
@@ -117,10 +117,10 @@ static void extract_edituv_stretch_area_finish(const MeshRenderData *mr,
   }
   else {
     BLI_assert(mr->extract_type == MR_EXTRACT_MESH);
-    const MPoly *mp = mr->polys.data();
-    for (int mp_index = 0, l_index = 0; mp_index < mr->poly_len; mp_index++, mp++) {
-      for (int i = 0; i < mp->totloop; i++, l_index++) {
-        loop_stretch[l_index] = area_ratio[mp_index];
+    const MPoly *poly = mr->polys.data();
+    for (int poly_index = 0, l_index = 0; poly_index < mr->poly_len; poly_index++, poly++) {
+      for (int i = 0; i < poly->totloop; i++, l_index++) {
+        loop_stretch[l_index] = area_ratio[poly_index];
       }
     }
   }
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_fdots_edituv_data.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_fdots_edituv_data.cc
index 1ac4512bab0..62db5588115 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_fdots_edituv_data.cc
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_fdots_edituv_data.cc
@@ -51,14 +51,14 @@ static void extract_fdots_edituv_data_iter_poly_bm(const MeshRenderData *mr,
 }
 
 static void extract_fdots_edituv_data_iter_poly_mesh(const MeshRenderData *mr,
-                                                     const MPoly * /*mp*/,
-                                                     const int mp_index,
+                                                     const MPoly * /*poly*/,
+                                                     const int poly_index,
                                                      void *_data)
 {
   MeshExtract_EditUVFdotData_Data *data = static_cast<MeshExtract_EditUVFdotData_Data *>(_data);
-  EditLoopData *eldata = &data->vbo_data[mp_index];
+  EditLoopData *eldata = &data->vbo_data[poly_index];
   memset(eldata, 0x0, sizeof(*eldata));
-  BMFace *efa = bm_original_face_get(mr, mp_index);
+  BMFace *efa = bm_original_face_get(mr, poly_index);
   if (efa) {
     mesh_render_data_face_flag(mr, efa, data->offsets, eldata);
   }
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_fdots_pos.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_fdots_pos.cc
index 6d38b752de5..0ac3bf50bf5 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_fdots_pos.cc
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_fdots_pos.cc
@@ -67,32 +67,32 @@ static void extract_fdots_pos_iter_poly_bm(const MeshRenderData *mr,
 }
 
 static void extract_fdots_pos_iter_poly_mesh(const MeshRenderData *mr,
-                                             const MPoly *mp,
-                                             const int mp_index,
+                                             const MPoly *poly,
+                                             const int poly_index,
                                              void *data)
 {
   float(*center)[3] = *static_cast<float(**)[3]>(data);
-  float *co = center[mp_index];
+  float *co = center[poly_index];
   zero_v3(co);
 
   const BitSpan facedot_tags = mr->me->runtime->subsurf_face_dot_tags;
 
-  const int ml_index_end = mp->loopstart + mp->totloop;
-  for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
+  const int ml_index_end = poly->loopstart + poly->totloop;
+  for (int ml_index = poly->loopstart; ml_index < ml_index_end; ml_index += 1) {
     const MLoop *ml = &mr->loops[ml_index];
     if (mr->use_subsurf_fdots) {
       if (facedot_tags[ml->v]) {
-        copy_v3_v3(center[mp_index], mr->vert_positions[ml->v]);
+        copy_v3_v3(center[poly_index], mr->vert_positions[ml->v]);
         break;
       }
     }
     else {
-      add_v3_v3(center[mp_index], mr->vert_positions[ml->v]);
+      add_v3_v3(center[poly_index], mr->vert_positions[ml->v]);
     }
   }
 
   if (!mr->use_subsurf_fdots) {
-    mul_v3_fl(co, 1.0f / float(mp->totloop));
+    mul_v3_fl(co, 1.0f / float(poly->totloop));
   }
 }
 
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_fdots_uv.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_fdots_uv.cc
index ab0fbf437e3..113d5ddea56 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_fdots_uv.cc
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_fdots_uv.cc
@@ -69,24 +69,24 @@ static void extract_fdots_uv_iter_poly_bm(const MeshRenderData * /*mr*/,
 }
 
 static void extract_fdots_uv_iter_poly_mesh(const MeshRenderData *mr,
-                                            const MPoly *mp,
-                                            const int mp_index,
+                                            const MPoly *poly,
+                                            const int poly_index,
                                             void *_data)
 {
   MeshExtract_FdotUV_Data *data = static_cast<MeshExtract_FdotUV_Data *>(_data);
   const BitSpan facedot_tags = mr->me->runtime->subsurf_face_dot_tags;
 
-  const int ml_index_end = mp->loopstart + mp->totloop;
-  for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
+  const int ml_index_end = poly->loopstart + poly->totloop;
+  for (int ml_index = poly->loopstart; ml_index < ml_index_end; ml_index += 1) {
     const MLoop *ml = &mr->loops[ml_index];
     if (mr->use_subsurf_fdots) {
       if (facedot_tags[ml->v]) {
-        copy_v2_v2(data->vbo_data[mp_index], data->uv_data[ml_index]);
+        copy_v2_v2(data->vbo_data[poly_index], data->uv_data[ml_index]);
       }
     }
     else {
-      float w = 1.0f / float(mp->totloop);
-      madd_v2_v2fl(data->vbo_data[mp_index], data->uv_data[ml_index], w);
+      float w = 1.0f / float(poly->totloop);
+      madd_v2_v2fl(data->vbo_data[poly_index], data->uv_data[ml_index], w);
     }
   }
 }
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_lnor.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_lnor.cc
index 044d1efd14c..4c69a66d152 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_lnor.cc
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_lnor.cc
@@ -58,24 +58,24 @@ static void extract_lnor_iter_poly_bm(const MeshRenderData *mr,
 }
 
 static void extract_lnor_iter_poly_mesh(const MeshRenderData *mr,
-                                        const MPoly *mp,
-                                        const int mp_index,
+                                        const MPoly *poly,
+                                        const int poly_index,
                                         void *data)
 {
-  const bool hidden = mr->hide_poly && mr->hide_poly[mp_index];
+  const bool hidden = mr->hide_poly && mr->hide_poly[poly_index];
 
-  const int ml_index_end = mp->loopstart + mp->totloop;
-  for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
+  const int ml_index_end = poly->loopstart + poly->totloop;
+  for (int ml_index = poly->loopstart; ml_index < ml_index_end; ml_index += 1) {
     const MLoop *ml = &mr->loops[ml_index];
     GPUPackedNormal *lnor_data = &(*(GPUPackedNormal **)data)[ml_index];
     if (mr->loop_normals) {
       *lnor_data = GPU_normal_convert_i10_v3(mr->loop_normals[ml_index]);
     }
-    else if (mp->flag & ME_SMOOTH) {
+    else if (poly->flag & ME_SMOOTH) {
       *lnor_data = GPU_normal_convert_i10_v3(mr->vert_normals[ml->v]);
     }
     else {
-      *lnor_data = GPU_normal_convert_i10_v3(mr->poly_normals[mp_index]);
+      *lnor_data = GPU_normal_convert_i10_v3(mr->poly_normals[poly_index]);
     }
 
     /* Flag for paint mode overlay.
@@ -85,7 +85,7 @@ static void extract_lnor_iter_poly_mesh(const MeshRenderData *mr,
         (mr->edit_bmesh && (mr->v_origindex) && mr->v_origindex[ml->v] == ORIGINDEX_NONE)) {
       lnor_data->w = -1;
     }
-    else if (mr->select_poly && mr->select_poly[mp_index]) {
+    else if (mr->select_poly && mr->select_poly[poly_index]) {
       lnor_data->w = 1;
     }
     else {
@@ -182,24 +182,24 @@ static void extract_lnor_hq_iter_poly_bm(const MeshRenderData *mr,
 }
 
 static void extract_lnor_hq_iter_poly_mesh(const MeshRenderData *mr,
-                                           const MPoly *mp,
-                                           const int mp_index,
+                                           const MPoly *poly,
+                                           const int poly_index,
                                            void *data)
 {
-  const bool hidden = mr->hide_poly && mr->hide_poly[mp_index];
+  const bool hidden = mr->hide_poly && mr->hide_poly[poly_index];
 
-  const int ml_index_end = mp->loopstart + mp->totloop;
-  for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
+  const int ml_index_end = poly->loopstart + poly->totloop;
+  for (int ml_index = poly->loopstart; ml_index < ml_index_end; ml_index += 1) {
     const MLoop *ml = &mr->loops[ml_index];
     gpuHQNor *lnor_data = &(*(gpuHQNor **)data)[ml_index];
     if (mr->loop_normals) {
       normal_float_to_short_v3(&lnor_data->x, mr->loop_normals[ml_index]);
     }
-    else if (mp->flag & ME_SMOOTH) {
+    else if (poly->flag & ME_SMOOTH) {
       normal_float_to_short_v3(&lnor_data->x, mr->vert_normals[ml->v]);
     }
     else {
-      normal_float_to_short_v3(&lnor_data->x, mr->poly_normals[mp_index]);
+      normal_float_to_short_v3(&lnor_data->x, mr->poly_normals[poly_index]);
     }
 
     /* Flag for paint mode overlay.
@@ -209,7 +209,7 @@ static void extract_lnor_hq_iter_poly_mesh(const MeshRenderData *mr,
         (mr->edit_bmesh && (mr->v_origindex) && mr->v_origindex[ml->v] == ORIGINDEX_NONE)) {
       lnor_data->w = -1;
     }
-    else if (mr->select_poly && mr->select_poly[mp_index]) {
+    else if (mr->select_poly && mr->select_poly[poly_index]) {
       lnor_data->w = 1;
     }
     else {
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_mesh_analysis.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_mesh_analysis.cc
index 365e6061475..8603488f026 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_mesh_analysis.cc
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_mesh_analysis.cc
@@ -96,11 +96,11 @@ static void statvis_calc_overhang(const MeshRenderData *mr, float *r_overhang)
     }
   }
   else {
-    const MPoly *mp = mr->polys.data();
-    for (int mp_index = 0, l_index = 0; mp_index < mr->poly_len; mp_index++, mp++) {
-      float fac = angle_normalized_v3v3(mr->poly_normals[mp_index], dir) / float(M_PI);
+    const MPoly *poly = mr->polys.data();
+    for (int poly_index = 0, l_index = 0; poly_index < mr->poly_len; poly_index++, poly++) {
+      float fac = angle_normalized_v3v3(mr->poly_normals[poly_index], dir) / float(M_PI);
       fac = overhang_remap(fac, min, max, minmax_irange);
-      for (int i = 0; i < mp->totloop; i++, l_index++) {
+      for (int i = 0; i < poly->totloop; i++, l_index++) {
         r_overhang[l_index] = fac;
       }
     }
@@ -247,11 +247,11 @@ static void statvis_calc_thickness(const MeshRenderData *mr, float *r_thickness)
       }
     }
 
-    const MPoly *mp = mr->polys.data();
-    for (int mp_index = 0, l_index = 0; mp_index < mr->poly_len; mp_index++, mp++) {
-      float fac = face_dists[mp_index];
+    const MPoly *poly = mr->polys.data();
+    for (int poly_index = 0, l_index = 0; poly_index < mr->poly_len; poly_index++, poly++) {
+      float fac = face_dists[poly_index];
       fac = thickness_remap(fac, min, max, minmax_irange);
-      for (int i = 0; i < mp->totloop; i++, l_index++) {
+      for (int i = 0; i < poly->totloop; i++, l_index++) {
         r_thickness[l_index] = fac;
       }
     }
@@ -440,18 +440,18 @@ static void statvis_calc_distort(const MeshRenderData *mr, float *r_distort)
     }
   }
   else {
-    const MPoly *mp = mr->polys.data();
-    for (int mp_index = 0, l_index = 0; mp_index < mr->poly_len; mp_index++, mp++) {
+    const MPoly *poly = mr->polys.data();
+    for (int poly_index = 0, l_index = 0; poly_index < mr->poly_len; poly_index++, poly++) {
       float fac = -1.0f;
 
-      if (mp->totloop > 3) {
-        const float *f_no = mr->poly_normals[mp_index];
+      if (poly->totloop > 3) {
+        const float *f_no = mr->poly_normals[poly_index];
         fac = 0.0f;
 
-        for (int i = 1; i <= mp->totloop; i++) {
-          const MLoop *l_prev = &mr->loops[mp->loopstart + (i - 1) % mp->totloop];
-          const MLoop *l_curr = &mr->loops[mp->loopstart + (i + 0) % mp->totloop];
-          const MLoop *l_next = &mr->loops[mp->loopstart + (i + 1) % mp->totloop];
+        for (int i = 1; i <= poly->totloop; i++) {
+          const MLoop *l_prev = &mr->loops[poly->loopstart + (i - 1) % poly->totloop];
+          const MLoop *l_curr = &mr->loops[poly->loopstart + (i + 0) % poly->totloop];
+          const MLoop *l_next = &mr->loops[poly->loopstart + (i + 1) % poly->totloop];
           float no_corner[3];
           normal_tri_v3(no_corner,
                         mr->vert_positions[l_prev->v],
@@ -467,7 +467,7 @@ static void statvis_calc_distort(const MeshRenderData *mr, float *r_distort)
       }
 
       fac = distort_remap(fac, min, max, minmax_irange);
-      for (int i = 0; i < mp->totloop; i++, l_index++) {
+      for (int i = 0; i < poly->totloop; i++, l_index++) {
         r_distort[l_index] = fac;
       }
     }
@@ -526,24 +526,24 @@ static void statvis_calc_sharp(const MeshRenderData *mr, float *r_sharp)
   }
   else {
     /* first assign float values to verts */
-    const MPoly *mp = mr->polys.data();
+    const MPoly *poly = mr->polys.data();
 
     EdgeHash *eh = BLI_edgehash_new_ex(__func__, mr->edge_len);
 
-    for (int mp_index = 0; mp_index < mr->poly_len; mp_index++, mp++) {
-      for (int i = 0; i < mp->totloop; i++) {
-        const MLoop *l_curr = &mr->loops[mp->loopstart + (i + 0) % mp->totloop];
-        const MLoop *l_next = &mr->loops[mp->loopstart + (i + 1) % mp->totloop];
+    for (int poly_index = 0; poly_index < mr->poly_len; poly_index++, poly++) {
+      for (int i = 0; i < poly->totloop; i++) {
+        const MLoop *l_curr = &mr->loops[poly->loopstart + (i + 0) % poly->totloop];
+        const MLoop *l_next = &mr->loops[poly->loopstart + (i + 1) % poly->totloop];
         float angle;
         void **pval;
         bool value_is_init = BLI_edgehash_ensure_p(eh, l_curr->v, l_next->v, &pval);
         if (!value_is_init) {
-          *pval = (void *)&mr->poly_normals[mp_index];
+          *pval = (void *)&mr->poly_normals[poly_index];
           /* non-manifold edge, yet... */
           continue;
         }
         if (*pval != nullptr) {
-          const float *f1_no = mr->poly_normals[mp_index];
+          const float *f1_no = mr->poly_normals[poly_index];
           const float *f2_no = static_cast<const float *>(*pval);
           angle = angle_normalized_v3v3(f1_no, f2_no);
           angle = is_edge_convex_v3(
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_orco.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_orco.cc
index a34bef2096a..db0de3761e3 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_orco.cc
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_orco.cc
@@ -62,12 +62,12 @@ static void extract_orco_iter_poly_bm(const MeshRenderData * /*mr*/,
 }
 
 static void extract_orco_iter_poly_mesh(const MeshRenderData *mr,
-                                        const MPoly *mp,
-                                        const int /*mp_index*/,
+                                        const MPoly *poly,
+                                        const int /*poly_index*/,
                                         void *data)
 {
-  const int ml_index_end = mp->loopstart + mp->totloop;
-  for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
+  const int ml_index_end = poly->loopstart + poly->totloop;
+  for (int ml_index = poly->loopstart; ml_index < ml_index_end; ml_index += 1) {
     const MLoop *ml = &mr->loops[ml_index];
     MeshExtract_Orco_Data *orco_data = (MeshExtract_Orco_Data *)data;
     float *loop_orco = orco_data->vbo_data[ml_index];
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_pos_nor.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_pos_nor.cc
index 016021157da..d9fc2b71d15 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_pos_nor.cc
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_pos_nor.cc
@@ -82,15 +82,15 @@ static void extract_pos_nor_iter_poly_bm(const MeshRenderData *mr,
 }
 
 static void extract_pos_nor_iter_poly_mesh(const MeshRenderData *mr,
-                                           const MPoly *mp,
-                                           const int mp_index,
+                                           const MPoly *poly,
+                                           const int poly_index,
                                            void *_data)
 {
   MeshExtract_PosNor_Data *data = static_cast<MeshExtract_PosNor_Data *>(_data);
-  const bool poly_hidden = mr->hide_poly && mr->hide_poly[mp_index];
+  const bool poly_hidden = mr->hide_poly && mr->hide_poly[poly_index];
 
-  const int ml_index_end = mp->loopstart + mp->totloop;
-  for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
+  const int ml_index_end = poly->loopstart + poly->totloop;
+  for (int ml_index = poly->loopstart; ml_index < ml_index_end; ml_index += 1) {
     const MLoop *ml = &mr->loops[ml_index];
 
     PosNorLoop *vert = &data->vbo_data[ml_index];
@@ -127,17 +127,17 @@ static void extract_pos_nor_iter_ledge_bm(const MeshRenderData *mr,
 }
 
 static void extract_pos_nor_iter_ledge_mesh(const MeshRenderData *mr,
-                                            const MEdge *med,
+                                            const MEdge *edge,
                                             const int ledge_index,
                                             void *_data)
 {
   MeshExtract_PosNor_Data *data = static_cast<MeshExtract_PosNor_Data *>(_data);
   const int ml_index = mr->loop_len + ledge_index * 2;
   PosNorLoop *vert = &data->vbo_data[ml_index];
-  copy_v3_v3(vert[0].pos, mr->vert_positions[med->v1]);
-  copy_v3_v3(vert[1].pos, mr->vert_positions[med->v2]);
-  vert[0].nor = data->normals[med->v1].low;
-  vert[1].nor = data->normals[med->v2].low;
+  copy_v3_v3(vert[0].pos, mr->vert_positions[edge->v1]);
+  copy_v3_v3(vert[1].pos, mr->vert_positions[edge->v2]);
+  vert[0].nor = data->normals[edge->v1].low;
+  vert[1].nor = data->normals[edge->v2].low;
 }
 
 static void extract_pos_nor_iter_lvert_bm(const MeshRenderData *mr,
@@ -457,16 +457,16 @@ static void extract_pos_nor_hq_iter_poly_bm(const MeshRenderData *mr,
 }
 
 static void extract_pos_nor_hq_iter_poly_mesh(const MeshRenderData *mr,
-                                              const MPoly *mp,
-                                              const int /*mp_index*/,
+                                              const MPoly *poly,
+                                              const int /*poly_index*/,
                                               void *_data)
 {
   MeshExtract_PosNorHQ_Data *data = static_cast<MeshExtract_PosNorHQ_Data *>(_data);
-  const bool poly_hidden = mr->hide_poly && mr->hide_poly[mp - mr->polys.data()];
+  const bool poly_hidden = mr->hide_poly && mr->hide_poly[poly - mr->polys.data()];
 
   const MLoop *mloop = mr->loops.data();
-  const int ml_index_end = mp->loopstart + mp->totloop;
-  for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
+  const int ml_index_end = poly->loopstart + poly->totloop;
+  for (int ml_index = poly->loopstart; ml_index < ml_index_end; ml_index += 1) {
     const MLoop *ml = &mloop[ml_index];
 
     const bool vert_hidden = mr->hide_vert && mr->hide_vert[ml->v];
@@ -505,18 +505,18 @@ static void extract_pos_nor_hq_iter_ledge_bm(const MeshRenderData *mr,
 }
 
 static void extract_pos_nor_hq_iter_ledge_mesh(const MeshRenderData *mr,
-                                               const MEdge *med,
+                                               const MEdge *edge,
                                                const int ledge_index,
                                                void *_data)
 {
   MeshExtract_PosNorHQ_Data *data = static_cast<MeshExtract_PosNorHQ_Data *>(_data);
   const int ml_index = mr->loop_len + ledge_index * 2;
   PosNorHQLoop *vert = &data->vbo_data[ml_index];
-  copy_v3_v3(vert[0].pos, mr->vert_positions[med->v1]);
-  copy_v3_v3(vert[1].pos, mr->vert_positions[med->v2]);
-  copy_v3_v3_short(vert[0].nor, data->normals[med->v1].high);
+  copy_v3_v3(vert[0].pos, mr->vert_positions[edge->v1]);
+  copy_v3_v3(vert[1].pos, mr->vert_positions[edge->v2]);
+  copy_v3_v3_short(vert[0].nor, data->normals[edge->v1].high);
   vert[0].nor[3] = 0;
-  copy_v3_v3_short(vert[1].nor, data->normals[med->v2].high);
+  copy_v3_v3_short(vert[1].nor, data->normals[edge->v2].high);
   vert[1].nor[3] = 0;
 }
 
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_sculpt_data.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_sculpt_data.cc
index 6858ad3fa53..29ec52e98af 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_sculpt_data.cc
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_sculpt_data.cc
@@ -87,9 +87,9 @@ static void extract_sculpt_data_init(const MeshRenderData *mr,
   }
   else {
     int mp_loop = 0;
-    for (int mp_index = 0; mp_index < mr->poly_len; mp_index++) {
-      const MPoly *p = &mr->polys[mp_index];
-      for (int l = 0; l < p->totloop; l++) {
+    for (int poly_index = 0; poly_index < mr->poly_len; poly_index++) {
+      const MPoly *poly = &mr->polys[poly_index];
+      for (int l = 0; l < poly->totloop; l++) {
         float v_mask = 0.0f;
         if (cd_mask) {
           v_mask = cd_mask[loops[mp_loop].v];
@@ -98,7 +98,7 @@ static void extract_sculpt_data_init(const MeshRenderData *mr,
 
         uchar face_set_color[4] = {UCHAR_MAX, UCHAR_MAX, UCHAR_MAX, UCHAR_MAX};
         if (cd_face_set) {
-          const int face_set_id = cd_face_set[mp_index];
+          const int face_set_id = cd_face_set[poly_index];
           /* Skip for the default color Face Set to render it white. */
           if (face_set_id != mr->me->face_sets_color_default) {
             BKE_paint_face_set_overlay_color_get(
@@ -143,9 +143,9 @@ static void extract_sculpt_data_init_subdiv(const DRWSubdivCache *subdiv_cache,
     float *v_mask = static_cast<float *>(GPU_vertbuf_get_data(mask_vbo));
 
     for (int i = 0; i < coarse_mesh->totpoly; i++) {
-      const MPoly *mpoly = &coarse_polys[i];
+      const MPoly *poly = &coarse_polys[i];
 
-      for (int loop_index = mpoly->loopstart; loop_index < mpoly->loopstart + mpoly->totloop;
+      for (int loop_index = poly->loopstart; loop_index < poly->loopstart + poly->totloop;
            loop_index++) {
         const MLoop *ml = &coarse_loops[loop_index];
         *v_mask++ = cd_mask[ml->v];
@@ -180,11 +180,11 @@ static void extract_sculpt_data_init_subdiv(const DRWSubdivCache *subdiv_cache,
   int *subdiv_loop_poly_index = subdiv_cache->subdiv_loop_poly_index;
 
   for (uint i = 0; i < subdiv_cache->num_subdiv_loops; i++) {
-    const int mp_index = subdiv_loop_poly_index[i];
+    const int poly_index = subdiv_loop_poly_index[i];
 
     uchar face_set_color[4] = {UCHAR_MAX, UCHAR_MAX, UCHAR_MAX, UCHAR_MAX};
     if (cd_face_set) {
-      const int face_set_id = cd_face_set[mp_index];
+      const int face_set_id = cd_face_set[poly_index];
       /* Skip for the default color Face Set to render it white. */
       if (face_set_id != coarse_mesh->face_sets_color_default) {
         BKE_paint_face_set_overlay_color_get(
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_select_idx.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_select_idx.cc
index adaf7b7474c..3c40c481c8f 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_select_idx.cc
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_select_idx.cc
@@ -110,42 +110,42 @@ static void extract_vert_idx_iter_lvert_bm(const MeshRenderData *mr,
 }
 
 static void extract_poly_idx_iter_poly_mesh(const MeshRenderData *mr,
-                                            const MPoly *mp,
-                                            const int mp_index,
+                                            const MPoly *poly,
+                                            const int poly_index,
                                             void *data)
 {
-  const int ml_index_end = mp->loopstart + mp->totloop;
-  for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
-    (*(int32_t **)data)[ml_index] = (mr->p_origindex) ? mr->p_origindex[mp_index] : mp_index;
+  const int ml_index_end = poly->loopstart + poly->totloop;
+  for (int ml_index = poly->loopstart; ml_index < ml_index_end; ml_index += 1) {
+    (*(int32_t **)data)[ml_index] = (mr->p_origindex) ? mr->p_origindex[poly_index] : poly_index;
   }
 }
 
 static void extract_edge_idx_iter_poly_mesh(const MeshRenderData *mr,
-                                            const MPoly *mp,
-                                            const int /*mp_index*/,
+                                            const MPoly *poly,
+                                            const int /*poly_index*/,
                                             void *data)
 {
-  const int ml_index_end = mp->loopstart + mp->totloop;
-  for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
+  const int ml_index_end = poly->loopstart + poly->totloop;
+  for (int ml_index = poly->loopstart; ml_index < ml_index_end; ml_index += 1) {
     const MLoop *ml = &mr->loops[ml_index];
     (*(int32_t **)data)[ml_index] = (mr->e_origindex) ? mr->e_origindex[ml->e] : ml->e;
   }
 }
 
 static void extract_vert_idx_iter_poly_mesh(const MeshRenderData *mr,
-                                            const MPoly *mp,
-                                            const int /*mp_index*/,
+                                            const MPoly *poly,
+                                            const int /*poly_index*/,
                                             void *data)
 {
-  const int ml_index_end = mp->loopstart + mp->totloop;
-  for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
+  const int ml_index_end = poly->loopstart + poly->totloop;
+  for (int ml_index = poly->loopstart; ml_index < ml_index_end; ml_index += 1) {
     const MLoop *ml = &mr->loops[ml_index];
     (*(int32_t **)data)[ml_index] = (mr->v_origindex) ? mr->v_origindex[ml->v] : ml->v;
   }
 }
 
 static void extract_edge_idx_iter_ledge_mesh(const MeshRenderData *mr,
-                                             const MEdge * /*med*/,
+                                             const MEdge * /*edge*/,
                                              const int ledge_index,
                                              void *data)
 {
@@ -156,12 +156,12 @@ static void extract_edge_idx_iter_ledge_mesh(const MeshRenderData *mr,
 }
 
 static void extract_vert_idx_iter_ledge_mesh(const MeshRenderData *mr,
-                                             const MEdge *med,
+                                             const MEdge *edge,
                                              const int ledge_index,
                                              void *data)
 {
-  int v1_orig = (mr->v_origindex) ? mr->v_origindex[med->v1] : med->v1;
-  int v2_orig = (mr->v_origindex) ? mr->v_origindex[med->v2] : med->v2;
+  int v1_orig = (mr->v_origindex) ? mr->v_origindex[edge->v1] : edge->v1;
+  int v2_orig = (mr->v_origindex) ? mr->v_origindex[edge->v2] : edge->v2;
   (*(int32_t **)data)[mr->loop_len + ledge_index * 2 + 0] = v1_orig;
   (*(int32_t **)data)[mr->loop_len + ledge_index * 2 + 1] = v2_orig;
 }
@@ -379,15 +379,15 @@ static void extract_fdot_idx_iter_poly_bm(const MeshRenderData * /*mr*/,
 }
 
 static void extract_fdot_idx_iter_poly_mesh(const MeshRenderData *mr,
-                                            const MPoly * /*mp*/,
-                                            const int mp_index,
+                                            const MPoly * /*poly*/,
+                                            const int poly_index,
                                             void *data)
 {
   if (mr->p_origindex != nullptr) {
-    (*(int32_t **)data)[mp_index] = mr->p_origindex[mp_index];
+    (*(int32_t **)data)[poly_index] = mr->p_origindex[poly_index];
   }
   else {
-    (*(int32_t **)data)[mp_index] = mp_index;
+    (*(int32_t **)data)[poly_index] = poly_index;
   }
 }
 
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_weights.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_weights.cc
index 8db5e4095fc..486208f9790 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_weights.cc
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_weights.cc
@@ -133,13 +133,13 @@ static void extract_weights_iter_poly_bm(const MeshRenderData * /*mr*/,
 }
 
 static void extract_weights_iter_poly_mesh(const MeshRenderData *mr,
-                                           const MPoly *mp,
-                                           const int /*mp_index*/,
+                                           const MPoly *poly,
+                                           const int /*poly_index*/,
                                            void *_data)
 {
   MeshExtract_Weight_Data *data = static_cast<MeshExtract_Weight_Data *>(_data);
-  const int ml_index_end = mp->loopstart + mp->totloop;
-  for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
+  const int ml_index_end = poly->loopstart + poly->totloop;
+  for (int ml_index = poly->loopstart; ml_index < ml_index_end; ml_index += 1) {
     const MLoop *ml = &mr->loops[ml_index];
     if (data->dvert != nullptr) {
       const MDeformVert *dvert = &data->dvert[ml->v];
@@ -173,8 +173,8 @@ static void extract_weights_init_subdiv(const DRWSubdivCache *subdiv_cache,
   if (mr->extract_type != MR_EXTRACT_BMESH) {
     const Span<MPoly> coarse_polys = coarse_mesh->polys();
     for (const int i : coarse_polys.index_range()) {
-      const MPoly *mpoly = &coarse_polys[i];
-      extract_weights_iter_poly_mesh(mr, mpoly, i, _data);
+      const MPoly *poly = &coarse_polys[i];
+      extract_weights_iter_poly_mesh(mr, poly, i, _data);
     }
   }
   else {
diff --git a/source/blender/editors/armature/meshlaplacian.cc b/source/blender/editors/armature/meshlaplacian.cc
index a01046bfdf2..255d0dfc60f 100644
--- a/source/blender/editors/armature/meshlaplacian.cc
+++ b/source/blender/editors/armature/meshlaplacian.cc
@@ -1034,16 +1034,16 @@ static MDefBoundIsect *meshdeform_ray_tree_intersect(MeshDeformBind *mdb,
                               BVH_RAYCAST_WATERTIGHT) != -1) {
     const blender::Span<MLoop> loops = mdb->cagemesh_cache.loops;
     const MLoopTri *lt = &mdb->cagemesh_cache.looptris[hit.index];
-    const MPoly *mp = &mdb->cagemesh_cache.polys[lt->poly];
+    const MPoly *poly = &mdb->cagemesh_cache.polys[lt->poly];
     const float(*cagecos)[3] = mdb->cagecos;
     const float len = isect_mdef.lambda;
     MDefBoundIsect *isect;
 
-    blender::Array<blender::float3, 64> mp_cagecos(mp->totloop);
+    blender::Array<blender::float3, 64> mp_cagecos(poly->totloop);
 
     /* create MDefBoundIsect, and extra for 'poly_weights[]' */
     isect = static_cast<MDefBoundIsect *>(
-        BLI_memarena_alloc(mdb->memarena, sizeof(*isect) + (sizeof(float) * mp->totloop)));
+        BLI_memarena_alloc(mdb->memarena, sizeof(*isect) + (sizeof(float) * poly->totloop)));
 
     /* compute intersection coordinate */
     madd_v3_v3v3fl(isect->co, co1, isect_mdef.vec, len);
@@ -1055,13 +1055,13 @@ static MDefBoundIsect *meshdeform_ray_tree_intersect(MeshDeformBind *mdb,
     isect->len = max_ff(len_v3v3(co1, isect->co), MESHDEFORM_LEN_THRESHOLD);
 
     /* compute mean value coordinates for interpolation */
-    for (int i = 0; i < mp->totloop; i++) {
-      copy_v3_v3(mp_cagecos[i], cagecos[loops[mp->loopstart + i].v]);
+    for (int i = 0; i < poly->totloop; i++) {
+      copy_v3_v3(mp_cagecos[i], cagecos[loops[poly->loopstart + i].v]);
     }
 
     interp_weights_poly_v3(isect->poly_weights,
                            reinterpret_cast<float(*)[3]>(mp_cagecos.data()),
-                           mp->totloop,
+                           poly->totloop,
                            isect->co);
 
     return isect;
@@ -1226,10 +1226,10 @@ static float meshdeform_boundary_phi(const MeshDeformBind *mdb,
                                      int cagevert)
 {
   const blender::Span<MLoop> loops = mdb->cagemesh_cache.loops;
-  const MPoly *mp = &mdb->cagemesh_cache.polys[isect->poly_index];
+  const MPoly *poly = &mdb->cagemesh_cache.polys[isect->poly_index];
 
-  for (int i = 0; i < mp->totloop; i++) {
-    if (loops[mp->loopstart + i].v == cagevert) {
+  for (int i = 0; i < poly->totloop; i++) {
+    if (loops[poly->loopstart + i].v == cagevert) {
       return isect->poly_weights[i];
     }
   }
diff --git a/source/blender/editors/mesh/mesh_data.cc b/source/blender/editors/mesh/mesh_data.cc
index 320906ff4d6..52f67860c90 100644
--- a/source/blender/editors/mesh/mesh_data.cc
+++ b/source/blender/editors/mesh/mesh_data.cc
@@ -169,15 +169,15 @@ static void mesh_uv_reset_bmface(BMFace *f, const int cd_loop_uv_offset)
   mesh_uv_reset_array(fuv.data(), f->len);
 }
 
-static void mesh_uv_reset_mface(const MPoly *mp, float2 *mloopuv)
+static void mesh_uv_reset_mface(const MPoly *poly, float2 *mloopuv)
 {
-  Array<float *, BM_DEFAULT_NGON_STACK_SIZE> fuv(mp->totloop);
+  Array<float *, BM_DEFAULT_NGON_STACK_SIZE> fuv(poly->totloop);
 
-  for (int i = 0; i < mp->totloop; i++) {
-    fuv[i] = mloopuv[mp->loopstart + i];
+  for (int i = 0; i < poly->totloop; i++) {
+    fuv[i] = mloopuv[poly->loopstart + i];
   }
 
-  mesh_uv_reset_array(fuv.data(), mp->totloop);
+  mesh_uv_reset_array(fuv.data(), poly->totloop);
 }
 
 void ED_mesh_uv_loop_reset_ex(Mesh *me, const int layernum)
diff --git a/source/blender/editors/mesh/meshtools.cc b/source/blender/editors/mesh/meshtools.cc
index 1534d2c1464..c5b1d57ca6c 100644
--- a/source/blender/editors/mesh/meshtools.cc
+++ b/source/blender/editors/mesh/meshtools.cc
@@ -98,9 +98,9 @@ static void join_mesh_single(Depsgraph *depsgraph,
 
   Mesh *me = static_cast<Mesh *>(ob_src->data);
   float3 *vert_positions = *vert_positions_pp;
-  MEdge *medge = *medge_pp;
+  MEdge *edge = *medge_pp;
   MLoop *mloop = *mloop_pp;
-  MPoly *mpoly = *mpoly_pp;
+  MPoly *poly = *mpoly_pp;
 
   if (me->totvert) {
     /* standard data */
@@ -207,9 +207,9 @@ static void join_mesh_single(Depsgraph *depsgraph,
     CustomData_merge(&me->edata, edata, CD_MASK_MESH.emask, CD_SET_DEFAULT, totedge);
     CustomData_copy_data_named(&me->edata, edata, 0, *edgeofs, me->totedge);
 
-    for (a = 0; a < me->totedge; a++, medge++) {
-      medge->v1 += *vertofs;
-      medge->v2 += *vertofs;
+    for (a = 0; a < me->totedge; a++, edge++) {
+      edge->v1 += *vertofs;
+      edge->v2 += *vertofs;
     }
   }
 
@@ -266,8 +266,8 @@ static void join_mesh_single(Depsgraph *depsgraph,
       }
     }
 
-    for (a = 0; a < me->totpoly; a++, mpoly++) {
-      mpoly->loopstart += *loopofs;
+    for (a = 0; a < me->totpoly; a++, poly++) {
+      poly->loopstart += *loopofs;
     }
 
     /* Face maps. */
@@ -333,8 +333,8 @@ int ED_mesh_join_objects_exec(bContext *C, wmOperator *op)
   Object *ob = CTX_data_active_object(C);
   Material **matar = nullptr, *ma;
   Mesh *me;
-  MEdge *medge = nullptr;
-  MPoly *mpoly = nullptr;
+  MEdge *edge = nullptr;
+  MPoly *polys = nullptr;
   MLoop *mloop = nullptr;
   Key *key, *nkey = nullptr;
   float imat[4][4];
@@ -585,9 +585,9 @@ int ED_mesh_join_objects_exec(bContext *C, wmOperator *op)
 
   float3 *vert_positions = (float3 *)CustomData_add_layer_named(
       &vdata, CD_PROP_FLOAT3, CD_SET_DEFAULT, nullptr, totvert, "position");
-  medge = (MEdge *)CustomData_add_layer(&edata, CD_MEDGE, CD_SET_DEFAULT, nullptr, totedge);
+  edge = (MEdge *)CustomData_add_layer(&edata, CD_MEDGE, CD_SET_DEFAULT, nullptr, totedge);
   mloop = (MLoop *)CustomData_add_layer(&ldata, CD_MLOOP, CD_SET_DEFAULT, nullptr, totloop);
-  mpoly = (MPoly *)CustomData_add_layer(&pdata, CD_MPOLY, CD_SET_DEFAULT, nullptr, totpoly);
+  polys = (MPoly *)CustomData_add_layer(&pdata, CD_MPOLY, CD_SET_DEFAULT, nullptr, totpoly);
 
   vertofs = 0;
   edgeofs = 0;
@@ -610,9 +610,9 @@ int ED_mesh_join_objects_exec(bContext *C, wmOperator *op)
                    ob,
                    imat,
                    &vert_positions,
-                   &medge,
+                   &edge,
                    &mloop,
-                   &mpoly,
+                   &polys,
                    &vdata,
                    &edata,
                    &ldata,
@@ -644,9 +644,9 @@ int ED_mesh_join_objects_exec(bContext *C, wmOperator *op)
                        ob_iter,
                        imat,
                        &vert_positions,
-                       &medge,
+                       &edge,
                        &mloop,
-                       &mpoly,
+                       &polys,
                        &vdata,
                        &edata,
                        &ldata,
@@ -1224,7 +1224,7 @@ static void ed_mesh_pick_face_vert__mpoly_find(
     ARegion *region,
     const float mval[2],
     /* mesh data (evaluated) */
-    const MPoly *mp,
+    const MPoly *poly,
     const Span<float3> vert_positions,
     const MLoop *mloop,
     /* return values */
@@ -1232,8 +1232,8 @@ static void ed_mesh_pick_face_vert__mpoly_find(
     int *r_v_idx_best)
 {
   const MLoop *ml;
-  int j = mp->totloop;
-  for (ml = &mloop[mp->loopstart]; j--; ml++) {
+  int j = poly->totloop;
+  for (ml = &mloop[poly->loopstart]; j--; ml++) {
     float sco[2];
     const int v_idx = ml->v;
     if (ED_view3d_project_float_object(region, vert_positions[v_idx], sco, V3D_PROJ_TEST_NOP) ==
diff --git a/source/blender/editors/object/object_modifier.cc b/source/blender/editors/object/object_modifier.cc
index c332c8a91fc..0301564f06c 100644
--- a/source/blender/editors/object/object_modifier.cc
+++ b/source/blender/editors/object/object_modifier.cc
@@ -658,7 +658,7 @@ bool ED_object_modifier_convert_psys_to_mesh(ReportList * /*reports*/,
 
   blender::MutableSpan<float3> positions = me->vert_positions_for_write();
   blender::MutableSpan<MEdge> edges = me->edges_for_write();
-  MEdge *medge = edges.data();
+  MEdge *edge = edges.data();
 
   bke::MutableAttributeAccessor attributes = me->attributes_for_write();
   bke::SpanAttributeWriter<bool> select_vert = attributes.lookup_or_add_for_write_span<bool>(
@@ -673,9 +673,9 @@ bool ED_object_modifier_convert_psys_to_mesh(ReportList * /*reports*/,
     for (int k = 0; k <= kmax; k++, key++, cvert++, vert_index++) {
       positions[vert_index] = key->co;
       if (k) {
-        medge->v1 = cvert - 1;
-        medge->v2 = cvert;
-        medge++;
+        edge->v1 = cvert - 1;
+        edge->v2 = cvert;
+        edge++;
       }
       else {
         /* cheap trick to select the roots */
@@ -691,9 +691,9 @@ bool ED_object_modifier_convert_psys_to_mesh(ReportList * /*reports*/,
     for (int k = 0; k <= kmax; k++, key++, cvert++, vert_index++) {
       copy_v3_v3(positions[vert_index], key->co);
       if (k) {
-        medge->v1 = cvert - 1;
-        medge->v2 = cvert;
-        medge++;
+        edge->v1 = cvert - 1;
+        edge->v2 = cvert;
+        edge++;
       }
       else {
         /* cheap trick to select the roots */
@@ -2882,7 +2882,7 @@ void OBJECT_OT_skin_radii_equalize(wmOperatorType *ot)
 
 static void skin_armature_bone_create(Object *skin_ob,
                                       const Span<float3> positions,
-                                      const MEdge *medge,
+                                      const MEdge *edges,
                                       bArmature *arm,
                                       BLI_bitmap *edges_visited,
                                       const MeshElemMap *emap,
@@ -2891,7 +2891,7 @@ static void skin_armature_bone_create(Object *skin_ob,
 {
   for (int i = 0; i < emap[parent_v].count; i++) {
     int endx = emap[parent_v].indices[i];
-    const MEdge *e = &medge[endx];
+    const MEdge *edge = &edges[endx];
 
     /* ignore edge if already visited */
     if (BLI_BITMAP_TEST(edges_visited, endx)) {
@@ -2899,7 +2899,7 @@ static void skin_armature_bone_create(Object *skin_ob,
     }
     BLI_BITMAP_ENABLE(edges_visited, endx);
 
-    int v = (e->v1 == parent_v ? e->v2 : e->v1);
+    int v = (edge->v1 == parent_v ? edge->v2 : edge->v1);
 
     EditBone *bone = ED_armature_ebone_add(arm, "Bone");
 
@@ -2920,7 +2920,7 @@ static void skin_armature_bone_create(Object *skin_ob,
       ED_vgroup_vert_add(skin_ob, dg, v, 1, WEIGHT_REPLACE);
     }
 
-    skin_armature_bone_create(skin_ob, positions, medge, arm, edges_visited, emap, bone, v);
+    skin_armature_bone_create(skin_ob, positions, edges, arm, edges_visited, emap, bone, v);
   }
 }
 
diff --git a/source/blender/editors/object/object_vgroup.cc b/source/blender/editors/object/object_vgroup.cc
index 23140afc701..995577d2eb3 100644
--- a/source/blender/editors/object/object_vgroup.cc
+++ b/source/blender/editors/object/object_vgroup.cc
@@ -1224,16 +1224,16 @@ static bool vgroup_normalize(Object *ob)
  * count is an int passed by reference so it can be assigned the value of the length here. */
 static blender::Vector<int> getSurroundingVerts(Mesh *me, int vert)
 {
-  const MPoly *mp = me->polys().data();
+  const MPoly *poly = me->polys().data();
   const MLoop *loops = me->loops().data();
   int i = me->totpoly;
 
   blender::Vector<int> verts;
 
   while (i--) {
-    int j = mp->totloop;
-    int first_l = mp->totloop - 1;
-    const MLoop *ml = &loops[mp->loopstart];
+    int j = poly->totloop;
+    int first_l = poly->totloop - 1;
+    const MLoop *ml = &loops[poly->loopstart];
     while (j--) {
       /* XXX This assume a vert can only be once in a poly, even though
        *     it seems logical to me, not totally sure of that. */
@@ -1247,7 +1247,7 @@ static blender::Vector<int> getSurroundingVerts(Mesh *me, int vert)
         else if (!j) {
           /* We are on the last corner. */
           a = (ml - 1)->v;
-          b = loops[mp->loopstart].v;
+          b = loops[poly->loopstart].v;
         }
         else {
           a = (ml - 1)->v;
@@ -1277,7 +1277,7 @@ static blender::Vector<int> getSurroundingVerts(Mesh *me, int vert)
       }
       ml++;
     }
-    mp++;
+    poly++;
   }
 
   return verts;
@@ -1992,8 +1992,8 @@ static void vgroup_smooth_subset(Object *ob,
     for (int i = 0; i < dvert_tot; i++) {
       if (IS_ME_VERT_WRITE(i)) {
         for (int j = 0; j < emap[i].count; j++) {
-          const MEdge *e = &edges[emap[i].indices[j]];
-          const int i_other = (e->v1 == i) ? e->v2 : e->v1;
+          const MEdge *edge = &edges[emap[i].indices[j]];
+          const int i_other = (edge->v1 == i) ? edge->v2 : edge->v1;
           if (IS_ME_VERT_READ(i_other)) {
             STACK_PUSH(verts_used, i);
             break;
@@ -2071,8 +2071,8 @@ static void vgroup_smooth_subset(Object *ob,
           BLI_assert(IS_ME_VERT_WRITE(i));
 
           for (j = 0; j < emap[i].count; j++) {
-            const MEdge *e = &edges[emap[i].indices[j]];
-            const int i_other = (e->v1 == i ? e->v2 : e->v1);
+            const MEdge *edge = &edges[emap[i].indices[j]];
+            const int i_other = (edge->v1 == i ? edge->v2 : edge->v1);
             if (IS_ME_VERT_READ(i_other)) {
               WEIGHT_ACCUMULATE;
             }
diff --git a/source/blender/editors/physics/particle_object.c b/source/blender/editors/physics/particle_object.c
index 846e138e958..f8b7d4db46b 100644
--- a/source/blender/editors/physics/particle_object.c
+++ b/source/blender/editors/physics/particle_object.c
@@ -706,7 +706,7 @@ static bool remap_hair_emitter(Depsgraph *depsgraph,
   PTCacheEditKey *ekey;
   BVHTreeFromMesh bvhtree = {NULL};
   const MFace *mface = NULL, *mf;
-  const MEdge *medge = NULL, *me;
+  const MEdge *edges = NULL, *edge;
   Mesh *mesh, *target_mesh;
   int numverts;
   int k;
@@ -763,7 +763,7 @@ static bool remap_hair_emitter(Depsgraph *depsgraph,
     BKE_bvhtree_from_mesh_get(&bvhtree, mesh, BVHTREE_FROM_FACES, 2);
   }
   else if (mesh->totedge != 0) {
-    medge = BKE_mesh_edges(mesh);
+    edges = BKE_mesh_edges(mesh);
     BKE_bvhtree_from_mesh_get(&bvhtree, mesh, BVHTREE_FROM_EDGES, 2);
   }
   else {
@@ -824,9 +824,9 @@ static bool remap_hair_emitter(Depsgraph *depsgraph,
       }
     }
     else {
-      me = &medge[nearest.index];
+      edge = &edges[nearest.index];
 
-      tpa->fuv[1] = line_point_factor_v3(nearest.co, positions[me->v1], positions[me->v2]);
+      tpa->fuv[1] = line_point_factor_v3(nearest.co, positions[edge->v1], positions[edge->v2]);
       tpa->fuv[0] = 1.0f - tpa->fuv[1];
       tpa->fuv[2] = tpa->fuv[3] = 0.0f;
       tpa->foffset = 0.0f;
diff --git a/source/blender/editors/sculpt_paint/paint_image_proj.cc b/source/blender/editors/sculpt_paint/paint_image_proj.cc
index b2580a5f146..cb331f8083e 100644
--- a/source/blender/editors/sculpt_paint/paint_image_proj.cc
+++ b/source/blender/editors/sculpt_paint/paint_image_proj.cc
@@ -1721,10 +1721,10 @@ static float project_paint_uvpixel_mask(const ProjPaintState *ps,
   if (ps->do_mask_normal) {
     const MLoopTri *lt = &ps->looptris_eval[tri_index];
     const int lt_vtri[3] = {PS_LOOPTRI_AS_VERT_INDEX_3(ps, lt)};
-    const MPoly *mp = &ps->polys_eval[lt->poly];
+    const MPoly *poly = &ps->polys_eval[lt->poly];
     float no[3], angle_cos;
 
-    if (mp->flag & ME_SMOOTH) {
+    if (poly->flag & ME_SMOOTH) {
       const float *no1, *no2, *no3;
       no1 = ps->vert_normals[lt_vtri[0]];
       no2 = ps->vert_normals[lt_vtri[1]];
diff --git a/source/blender/editors/sculpt_paint/paint_vertex.cc b/source/blender/editors/sculpt_paint/paint_vertex.cc
index 635331b6d6c..bf124a448a4 100644
--- a/source/blender/editors/sculpt_paint/paint_vertex.cc
+++ b/source/blender/editors/sculpt_paint/paint_vertex.cc
@@ -1981,11 +1981,11 @@ static void do_wpaint_brush_blur_task_cb_ex(void *__restrict userdata,
         float weight_final = 0.0f;
         for (int j = 0; j < gmap->vert_to_poly[v_index].count; j++) {
           const int p_index = gmap->vert_to_poly[v_index].indices[j];
-          const MPoly *mp = &ss->mpoly[p_index];
+          const MPoly *poly = &ss->polys[p_index];
 
-          total_hit_loops += mp->totloop;
-          for (int k = 0; k < mp->totloop; k++) {
-            const int l_index = mp->loopstart + k;
+          total_hit_loops += poly->totloop;
+          for (int k = 0; k < poly->totloop; k++) {
+            const int l_index = poly->loopstart + k;
             const MLoop *ml = &ss->mloop[l_index];
             weight_final += data->wpd->precomputed_weight[ml->v];
           }
@@ -2094,9 +2094,9 @@ static void do_wpaint_brush_smear_task_cb_ex(void *__restrict userdata,
             float weight_final = 0.0;
             for (int j = 0; j < gmap->vert_to_poly[v_index].count; j++) {
               const int p_index = gmap->vert_to_poly[v_index].indices[j];
-              const MPoly *mp = &ss->mpoly[p_index];
-              const MLoop *ml_other = &ss->mloop[mp->loopstart];
-              for (int k = 0; k < mp->totloop; k++, ml_other++) {
+              const MPoly *poly = &ss->polys[p_index];
+              const MLoop *ml_other = &ss->mloop[poly->loopstart];
+              for (int k = 0; k < poly->totloop; k++, ml_other++) {
                 const uint v_other_index = ml_other->v;
                 if (v_other_index != v_index) {
                   const float3 &mv_other = ss->vert_positions[v_other_index];
@@ -3030,11 +3030,11 @@ static void do_vpaint_brush_blur_loops(bContext *C,
 
               for (int j = 0; j < gmap->vert_to_poly[v_index].count; j++) {
                 int p_index = gmap->vert_to_poly[v_index].indices[j];
-                const MPoly *mp = &ss->mpoly[p_index];
+                const MPoly *poly = &ss->polys[p_index];
                 if (!use_face_sel || select_poly[p_index]) {
-                  total_hit_loops += mp->totloop;
-                  for (int k = 0; k < mp->totloop; k++) {
-                    const uint l_index = mp->loopstart + k;
+                  total_hit_loops += poly->totloop;
+                  for (int k = 0; k < poly->totloop; k++) {
+                    const uint l_index = poly->loopstart + k;
                     Color *col = lcol + l_index;
 
                     /* Color is squared to compensate the sqrt color encoding. */
@@ -3175,11 +3175,11 @@ static void do_vpaint_brush_blur_verts(bContext *C,
 
               for (int j = 0; j < gmap->vert_to_poly[v_index].count; j++) {
                 int p_index = gmap->vert_to_poly[v_index].indices[j];
-                const MPoly *mp = &ss->mpoly[p_index];
+                const MPoly *poly = &ss->polys[p_index];
                 if (!use_face_sel || select_poly[p_index]) {
-                  total_hit_loops += mp->totloop;
-                  for (int k = 0; k < mp->totloop; k++) {
-                    const uint l_index = mp->loopstart + k;
+                  total_hit_loops += poly->totloop;
+                  for (int k = 0; k < poly->totloop; k++) {
+                    const uint l_index = poly->loopstart + k;
                     const uint v_index = ss->mloop[l_index].v;
 
                     Color *col = lcol + v_index;
@@ -3338,10 +3338,10 @@ static void do_vpaint_brush_smear(bContext *C,
                   const int l_index = gmap->vert_to_loop[v_index].indices[j];
                   BLI_assert(ss->mloop[l_index].v == v_index);
                   UNUSED_VARS_NDEBUG(l_index);
-                  const MPoly *mp = &ss->mpoly[p_index];
+                  const MPoly *poly = &ss->polys[p_index];
                   if (!use_face_sel || select_poly[p_index]) {
-                    const MLoop *ml_other = &ss->mloop[mp->loopstart];
-                    for (int k = 0; k < mp->totloop; k++, ml_other++) {
+                    const MLoop *ml_other = &ss->mloop[poly->loopstart];
+                    for (int k = 0; k < poly->totloop; k++, ml_other++) {
                       const uint v_other_index = ml_other->v;
                       if (v_other_index != v_index) {
                         const float3 &mv_other = &ss->vert_positions[v_other_index];
@@ -3361,7 +3361,7 @@ static void do_vpaint_brush_smear(bContext *C,
                           elem_index = ml_other->v;
                         }
                         else {
-                          elem_index = mp->loopstart + k;
+                          elem_index = poly->loopstart + k;
                         }
 
                         if (stroke_dot > stroke_dot_max) {
diff --git a/source/blender/editors/sculpt_paint/paint_vertex_weight_ops.cc b/source/blender/editors/sculpt_paint/paint_vertex_weight_ops.cc
index 153a99aa396..dc147f7a90e 100644
--- a/source/blender/editors/sculpt_paint/paint_vertex_weight_ops.cc
+++ b/source/blender/editors/sculpt_paint/paint_vertex_weight_ops.cc
@@ -344,11 +344,11 @@ static const EnumPropertyItem *weight_paint_sample_enum_itemf(bContext *C,
         }
         else {
           if (ED_mesh_pick_face(C, vc.obact, mval, ED_MESH_PICK_DEFAULT_FACE_DIST, &index)) {
-            const MPoly *mp = &polys[index];
-            uint fidx = mp->totloop - 1;
+            const MPoly *poly = &polys[index];
+            uint fidx = poly->totloop - 1;
 
             do {
-              const MDeformVert *dvert = &dverts[loops[mp->loopstart + fidx].v];
+              const MDeformVert *dvert = &dverts[loops[poly->loopstart + fidx].v];
               found |= weight_paint_sample_enum_itemf__helper(dvert, defbase_tot, groups);
             } while (fidx--);
           }
diff --git a/source/blender/editors/sculpt_paint/sculpt.cc b/source/blender/editors/sculpt_paint/sculpt.cc
index 15810573724..d6e3ab7461c 100644
--- a/source/blender/editors/sculpt_paint/sculpt.cc
+++ b/source/blender/editors/sculpt_paint/sculpt.cc
@@ -725,9 +725,9 @@ static bool sculpt_check_unique_face_set_for_edge_in_base_mesh(SculptSession *ss
   const MeshElemMap *vert_map = &ss->pmap[v1];
   int p1 = -1, p2 = -1;
   for (int i = 0; i < vert_map->count; i++) {
-    const MPoly *p = &ss->mpoly[vert_map->indices[i]];
-    for (int l = 0; l < p->totloop; l++) {
-      const MLoop *loop = &ss->mloop[p->loopstart + l];
+    const MPoly *poly = &ss->polys[vert_map->indices[i]];
+    for (int l = 0; l < poly->totloop; l++) {
+      const MLoop *loop = &ss->mloop[poly->loopstart + l];
       if (loop->v == v2) {
         if (p1 == -1) {
           p1 = vert_map->indices[i];
@@ -769,7 +769,7 @@ bool SCULPT_vertex_has_unique_face_set(SculptSession *ss, PBVHVertRef vertex)
       coord.y = vertex_index / key->grid_size;
       int v1, v2;
       const SubdivCCGAdjacencyType adjacency = BKE_subdiv_ccg_coarse_mesh_adjacency_info_get(
-          ss->subdiv_ccg, &coord, ss->mloop, ss->mpoly, &v1, &v2);
+          ss->subdiv_ccg, &coord, ss->mloop, ss->polys, &v1, &v2);
       switch (adjacency) {
         case SUBDIV_CCG_ADJACENT_VERTEX:
           return sculpt_check_unique_face_set_in_base_mesh(ss, v1);
@@ -888,9 +888,9 @@ static void sculpt_vertex_neighbors_get_faces(SculptSession *ss,
       /* Skip connectivity from hidden faces. */
       continue;
     }
-    const MPoly *p = &ss->mpoly[vert_map->indices[i]];
+    const MPoly *poly = &ss->polys[vert_map->indices[i]];
     int f_adj_v[2];
-    if (poly_get_adj_loops_from_vert(p, ss->mloop, vertex.i, f_adj_v) != -1) {
+    if (poly_get_adj_loops_from_vert(poly, ss->mloop, vertex.i, f_adj_v) != -1) {
       for (int j = 0; j < ARRAY_SIZE(f_adj_v); j += 1) {
         if (f_adj_v[j] != vertex.i) {
           sculpt_vertex_neighbor_add(iter, BKE_pbvh_make_vref(f_adj_v[j]), f_adj_v[j]);
@@ -1004,7 +1004,7 @@ bool SCULPT_vertex_is_boundary(const SculptSession *ss, const PBVHVertRef vertex
       coord.y = vertex_index / key->grid_size;
       int v1, v2;
       const SubdivCCGAdjacencyType adjacency = BKE_subdiv_ccg_coarse_mesh_adjacency_info_get(
-          ss->subdiv_ccg, &coord, ss->mloop, ss->mpoly, &v1, &v2);
+          ss->subdiv_ccg, &coord, ss->mloop, ss->polys, &v1, &v2);
       switch (adjacency) {
         case SUBDIV_CCG_ADJACENT_VERTEX:
           return sculpt_check_boundary_vertex_in_base_mesh(ss, v1);
diff --git a/source/blender/editors/sculpt_paint/sculpt_expand.cc b/source/blender/editors/sculpt_paint/sculpt_expand.cc
index e38ad0fcd2d..5e5b1dc3ba4 100644
--- a/source/blender/editors/sculpt_paint/sculpt_expand.cc
+++ b/source/blender/editors/sculpt_paint/sculpt_expand.cc
@@ -148,7 +148,7 @@ static bool sculpt_expand_is_face_in_active_component(SculptSession *ss,
                                                       ExpandCache *expand_cache,
                                                       const int f)
 {
-  const MLoop *loop = &ss->mloop[ss->mpoly[f].loopstart];
+  const MLoop *loop = &ss->mloop[ss->polys[f].loopstart];
   return sculpt_expand_is_vert_in_active_component(ss, expand_cache, BKE_pbvh_make_vref(loop->v));
 }
 
@@ -712,9 +712,9 @@ static float *sculpt_expand_diagonals_falloff_create(Object *ob, const PBVHVertR
     int v_next_i = BKE_pbvh_vertex_to_index(ss->pbvh, v_next);
 
     for (int j = 0; j < ss->pmap[v_next_i].count; j++) {
-      const MPoly *p = &ss->mpoly[ss->pmap[v_next_i].indices[j]];
-      for (int l = 0; l < p->totloop; l++) {
-        const PBVHVertRef neighbor_v = BKE_pbvh_make_vref(ss->mloop[p->loopstart + l].v);
+      const MPoly *poly = &ss->polys[ss->pmap[v_next_i].indices[j]];
+      for (int l = 0; l < poly->totloop; l++) {
+        const PBVHVertRef neighbor_v = BKE_pbvh_make_vref(ss->mloop[poly->loopstart + l].v);
         if (BLI_BITMAP_TEST(visited_verts, neighbor_v.i)) {
           continue;
         }
@@ -1116,7 +1116,7 @@ static void sculpt_expand_snap_initialize_from_enabled(SculptSession *ss,
   }
 
   for (int p = 0; p < totface; p++) {
-    const MPoly *poly = &ss->mpoly[p];
+    const MPoly *poly = &ss->polys[p];
     bool any_disabled = false;
     for (int l = 0; l < poly->totloop; l++) {
       const MLoop *loop = &ss->mloop[l + poly->loopstart];
diff --git a/source/blender/editors/sculpt_paint/sculpt_face_set.cc b/source/blender/editors/sculpt_paint/sculpt_face_set.cc
index 828c17c8706..c75b07630ec 100644
--- a/source/blender/editors/sculpt_paint/sculpt_face_set.cc
+++ b/source/blender/editors/sculpt_paint/sculpt_face_set.cc
@@ -132,10 +132,10 @@ static void do_draw_face_sets_brush_task_cb_ex(void *__restrict userdata,
     if (BKE_pbvh_type(ss->pbvh) == PBVH_FACES) {
       MeshElemMap *vert_map = &ss->pmap[vd.index];
       for (int j = 0; j < ss->pmap[vd.index].count; j++) {
-        const MPoly *p = &ss->mpoly[vert_map->indices[j]];
+        const MPoly *poly = &ss->polys[vert_map->indices[j]];
 
         float poly_center[3];
-        BKE_mesh_calc_poly_center(p, &ss->mloop[p->loopstart], positions, poly_center);
+        BKE_mesh_calc_poly_center(poly, &ss->mloop[poly->loopstart], positions, poly_center);
 
         if (!sculpt_brush_test_sq_fn(&test, poly_center)) {
           continue;
diff --git a/source/blender/editors/sculpt_paint/sculpt_geodesic.cc b/source/blender/editors/sculpt_paint/sculpt_geodesic.cc
index 2b85e09581e..762cb8cabbe 100644
--- a/source/blender/editors/sculpt_paint/sculpt_geodesic.cc
+++ b/source/blender/editors/sculpt_paint/sculpt_geodesic.cc
@@ -181,10 +181,9 @@ static float *SCULPT_geodesic_mesh_create(Object *ob,
           if (ss->hide_poly && ss->hide_poly[poly]) {
             continue;
           }
-          const MPoly *mpoly = &polys[poly];
 
-          for (int loop_index = 0; loop_index < mpoly->totloop; loop_index++) {
-            const MLoop *mloop = &loops[loop_index + mpoly->loopstart];
+          for (int loop_index = 0; loop_index < polys[poly].totloop; loop_index++) {
+            const MLoop *mloop = &loops[loop_index + polys[poly].loopstart];
             const int v_other = mloop->v;
             if (ELEM(v_other, v1, v2)) {
               continue;
diff --git a/source/blender/editors/transform/transform_snap_object.cc b/source/blender/editors/transform/transform_snap_object.cc
index faa946a1393..46d7622b31e 100644
--- a/source/blender/editors/transform/transform_snap_object.cc
+++ b/source/blender/editors/transform/transform_snap_object.cc
@@ -1428,7 +1428,7 @@ struct Nearest2dUserData {
     struct {
       const float (*vert_positions)[3];
       const float (*vert_normals)[3];
-      const MEdge *edge; /* only used for #BVHTreeFromMeshEdges */
+      const MEdge *edges; /* only used for #BVHTreeFromMeshEdges */
       const MLoop *loop;
       const MLoopTri *looptris;
     };
@@ -1463,7 +1463,7 @@ static void cb_bvert_no_copy(const int index, const Nearest2dUserData *data, flo
 
 static void cb_medge_verts_get(const int index, const Nearest2dUserData *data, int r_v_index[2])
 {
-  const MEdge *edge = &data->edge[index];
+  const MEdge *edge = &data->edges[index];
 
   r_v_index[0] = edge->v1;
   r_v_index[1] = edge->v2;
@@ -1479,13 +1479,13 @@ static void cb_bedge_verts_get(const int index, const Nearest2dUserData *data, i
 
 static void cb_mlooptri_edges_get(const int index, const Nearest2dUserData *data, int r_v_index[3])
 {
-  const MEdge *medge = data->edge;
+  const MEdge *edges = data->edges;
   const MLoop *mloop = data->loop;
   const MLoopTri *lt = &data->looptris[index];
   for (int j = 2, j_next = 0; j_next < 3; j = j_next++) {
-    const MEdge *ed = &medge[mloop[lt->tri[j]].e];
+    const MEdge *edge = &edges[mloop[lt->tri[j]].e];
     const uint tri_edge[2] = {mloop[lt->tri[j]].v, mloop[lt->tri[j_next]].v};
-    if (ELEM(ed->v1, tri_edge[0], tri_edge[1]) && ELEM(ed->v2, tri_edge[0], tri_edge[1])) {
+    if (ELEM(edge->v1, tri_edge[0], tri_edge[1]) && ELEM(edge->v2, tri_edge[0], tri_edge[1])) {
       // printf("real edge found\n");
       r_v_index[j] = mloop[lt->tri[j]].e;
     }
@@ -1717,7 +1717,7 @@ static void nearest2d_data_init_mesh(const Mesh *mesh,
 
   r_nearest2d->vert_positions = BKE_mesh_vert_positions(mesh);
   r_nearest2d->vert_normals = BKE_mesh_vert_normals_ensure(mesh);
-  r_nearest2d->edge = mesh->edges().data();
+  r_nearest2d->edges = mesh->edges().data();
   r_nearest2d->loop = mesh->loops().data();
   r_nearest2d->looptris = mesh->looptris().data();
 
@@ -1782,12 +1782,12 @@ static eSnapMode snap_mesh_polygon(SnapObjectContext *sctx,
                              params->use_backface_culling,
                              &nearest2d);
 
-    const MPoly *mp = &mesh->polys()[sctx->ret.index];
-    const MLoop *ml = &nearest2d.loop[mp->loopstart];
+    const MPoly *poly = &mesh->polys()[sctx->ret.index];
+    const MLoop *ml = &nearest2d.loop[poly->loopstart];
     if (sctx->runtime.snap_to_flag & SCE_SNAP_MODE_EDGE) {
       elem = SCE_SNAP_MODE_EDGE;
       BLI_assert(nearest2d.edge != nullptr);
-      for (int i = mp->totloop; i--; ml++) {
+      for (int i = poly->totloop; i--; ml++) {
         cb_snap_edge(&nearest2d,
                      int(ml->e),
                      &neasrest_precalc,
@@ -1798,7 +1798,7 @@ static eSnapMode snap_mesh_polygon(SnapObjectContext *sctx,
     }
     else {
       elem = SCE_SNAP_MODE_VERTEX;
-      for (int i = mp->totloop; i--; ml++) {
+      for (int i = poly->totloop; i--; ml++) {
         cb_snap_vert(&nearest2d,
                      int(ml->v),
                      &neasrest_precalc,
diff --git a/source/blender/editors/uvedit/uvedit_unwrap_ops.cc b/source/blender/editors/uvedit/uvedit_unwrap_ops.cc
index d2fca0e9604..3707016534e 100644
--- a/source/blender/editors/uvedit/uvedit_unwrap_ops.cc
+++ b/source/blender/editors/uvedit/uvedit_unwrap_ops.cc
@@ -666,7 +666,7 @@ static ParamHandle *construct_param_handle_subsurfed(const Scene *scene,
 
   /* Prepare and feed faces to the solver */
   for (const int i : subsurf_polys.index_range()) {
-    const MPoly *mpoly = &subsurf_polys[i];
+    const MPoly *poly = &subsurf_polys[i];
     ParamKey key, vkeys[4];
     bool pin[4], select[4];
     const float *co[4];
@@ -685,10 +685,10 @@ static ParamHandle *construct_param_handle_subsurfed(const Scene *scene,
       }
     }
 
-    const MLoop *mloop = &subsurf_loops[mpoly->loopstart];
+    const MLoop *mloop = &subsurf_loops[poly->loopstart];
 
     /* We will not check for v4 here. Sub-surface faces always have 4 vertices. */
-    BLI_assert(mpoly->totloop == 4);
+    BLI_assert(poly->totloop == 4);
     key = (ParamKey)i;
     vkeys[0] = (ParamKey)mloop[0].v;
     vkeys[1] = (ParamKey)mloop[1].v;
diff --git a/source/blender/freestyle/intern/blender_interface/BlenderFileLoader.cpp b/source/blender/freestyle/intern/blender_interface/BlenderFileLoader.cpp
index dc6e13b3d3a..6526dd68d9c 100644
--- a/source/blender/freestyle/intern/blender_interface/BlenderFileLoader.cpp
+++ b/source/blender/freestyle/intern/blender_interface/BlenderFileLoader.cpp
@@ -388,9 +388,9 @@ static bool testEdgeMark(Mesh *me, const FreestyleEdge *fed, const MLoopTri *lt,
 
   const MLoop *mloop = &loops[lt->tri[i]];
   const MLoop *mloop_next = &loops[lt->tri[(i + 1) % 3]];
-  const MEdge *medge = &edges[mloop->e];
+  const MEdge *edge = &edges[mloop->e];
 
-  if (!ELEM(mloop_next->v, medge->v1, medge->v2)) {
+  if (!ELEM(mloop_next->v, edge->v1, edge->v2)) {
     /* Not an edge in the original mesh before triangulation. */
     return false;
   }
@@ -521,7 +521,7 @@ void BlenderFileLoader::insertShapeNode(Object *ob, Mesh *me, int id)
   // by the near and far view planes.
   for (int a = 0; a < tottri; a++) {
     const MLoopTri *lt = &mlooptri[a];
-    const MPoly *mp = &mesh_polys[lt->poly];
+    const MPoly *poly = &mesh_polys[lt->poly];
     Material *mat = BKE_object_material_get(ob, material_indices[lt->poly] + 1);
 
     copy_v3_v3(v1, vert_positions[mesh_loops[lt->tri[0]].v]);
@@ -536,7 +536,7 @@ void BlenderFileLoader::insertShapeNode(Object *ob, Mesh *me, int id)
     v2[2] += _z_offset;
     v3[2] += _z_offset;
 
-    if (_smooth && (mp->flag & ME_SMOOTH) && lnors) {
+    if (_smooth && (poly->flag & ME_SMOOTH) && lnors) {
       copy_v3_v3(n1, lnors[lt->tri[0]]);
       copy_v3_v3(n2, lnors[lt->tri[1]]);
       copy_v3_v3(n3, lnors[lt->tri[2]]);
diff --git a/source/blender/geometry/intern/mesh_merge_by_distance.cc b/source/blender/geometry/intern/mesh_merge_by_distance.cc
index 092f395417b..46c42ec7c43 100644
--- a/source/blender/geometry/intern/mesh_merge_by_distance.cc
+++ b/source/blender/geometry/intern/mesh_merge_by_distance.cc
@@ -160,14 +160,14 @@ static void weld_assert_edge_kill_len(Span<WeldEdge> wedge, const int supposed_k
 
 static void weld_assert_poly_and_loop_kill_len(WeldMesh *weld_mesh,
                                                Span<MLoop> mloop,
-                                               Span<MPoly> mpoly,
+                                               Span<MPoly> polys,
                                                const int supposed_poly_kill_len,
                                                const int supposed_loop_kill_len)
 {
   int poly_kills = 0;
   int loop_kills = mloop.size();
-  const MPoly *mp = &mpoly[0];
-  for (int i = 0; i < mpoly.size(); i++, mp++) {
+  const MPoly *poly = &polys[0];
+  for (int i = 0; i < polys.size(); i++, poly++) {
     int poly_ctx = weld_mesh->poly_map[i];
     if (poly_ctx != OUT_OF_CONTEXT) {
       const WeldPoly *wp = &weld_mesh->wpoly[poly_ctx];
@@ -206,7 +206,7 @@ static void weld_assert_poly_and_loop_kill_len(WeldMesh *weld_mesh,
       }
     }
     else {
-      loop_kills -= mp->totloop;
+      loop_kills -= poly->totloop;
     }
   }
 
@@ -416,7 +416,7 @@ static void weld_vert_groups_setup(Span<WeldVert> wvert,
  * \return r_edge_dest_map: First step to create map of indices pointing edges that will be merged.
  * \return r_edge_ctx_map: Map of indices pointing original edges to weld context edges.
  */
-static Vector<WeldEdge> weld_edge_ctx_alloc_and_find_collapsed(Span<MEdge> medge,
+static Vector<WeldEdge> weld_edge_ctx_alloc_and_find_collapsed(Span<MEdge> edges,
                                                                Span<int> vert_dest_map,
                                                                MutableSpan<int> r_edge_dest_map,
                                                                MutableSpan<int> r_edge_ctx_map,
@@ -427,11 +427,11 @@ static Vector<WeldEdge> weld_edge_ctx_alloc_and_find_collapsed(Span<MEdge> medge
   int edge_collapsed_len = 0;
 
   Vector<WeldEdge> wedge;
-  wedge.reserve(medge.size());
+  wedge.reserve(edges.size());
 
-  for (const int i : medge.index_range()) {
-    int v1 = medge[i].v1;
-    int v2 = medge[i].v2;
+  for (const int i : edges.index_range()) {
+    int v1 = edges[i].v1;
+    int v2 = edges[i].v2;
     int v_dest_1 = vert_dest_map[v1];
     int v_dest_2 = vert_dest_map[v2];
     if ((v_dest_1 != OUT_OF_CONTEXT) || (v_dest_2 != OUT_OF_CONTEXT)) {
@@ -589,7 +589,7 @@ static void weld_edge_find_doubles(int remain_edge_ctx_len,
  * \return r_edge_groups_buffer: Buffer containing the indices of all edges that merge.
  * \return r_edge_groups_offs: Array that indicates where each edge group starts in the buffer.
  */
-static void weld_edge_groups_setup(const int medge_len,
+static void weld_edge_groups_setup(const int edges_len,
                                    const int edge_kill_len,
                                    MutableSpan<WeldEdge> wedge,
                                    Span<int> wedge_map,
@@ -603,7 +603,7 @@ static void weld_edge_groups_setup(const int medge_len,
   r_edge_groups_verts.reinitialize(wgroups_len);
 
   wgroups_len = 0;
-  for (const int i : IndexRange(medge_len)) {
+  for (const int i : IndexRange(edges_len)) {
     int edge_ctx = wedge_map[i];
     if (edge_ctx != OUT_OF_CONTEXT) {
       WeldEdge *we = &wedge[edge_ctx];
@@ -779,7 +779,7 @@ static bool weld_iter_loop_of_poly_next(WeldLoopOfPolyIter &iter)
  *
  * \return r_weld_mesh: Loop and poly members will be allocated here.
  */
-static void weld_poly_loop_ctx_alloc(Span<MPoly> mpoly,
+static void weld_poly_loop_ctx_alloc(Span<MPoly> polys,
                                      Span<MLoop> mloop,
                                      Span<int> vert_dest_map,
                                      Span<int> edge_dest_map,
@@ -787,7 +787,7 @@ static void weld_poly_loop_ctx_alloc(Span<MPoly> mpoly,
 {
   /* Loop/Poly Context. */
   Array<int> loop_map(mloop.size());
-  Array<int> poly_map(mpoly.size());
+  Array<int> poly_map(polys.size());
   int wloop_len = 0;
   int wpoly_len = 0;
   int max_ctx_poly_len = 4;
@@ -796,14 +796,14 @@ static void weld_poly_loop_ctx_alloc(Span<MPoly> mpoly,
   wloop.reserve(mloop.size());
 
   Vector<WeldPoly> wpoly;
-  wpoly.reserve(mpoly.size());
+  wpoly.reserve(polys.size());
 
   int maybe_new_poly = 0;
 
-  for (const int i : mpoly.index_range()) {
-    const MPoly &mp = mpoly[i];
-    const int loopstart = mp.loopstart;
-    const int totloop = mp.totloop;
+  for (const int i : polys.index_range()) {
+    const MPoly &poly = polys[i];
+    const int loopstart = poly.loopstart;
+    const int totloop = poly.totloop;
 
     int vert_ctx_len = 0;
 
@@ -1022,7 +1022,7 @@ static void weld_poly_split_recursive(Span<int> vert_dest_map,
 static void weld_poly_loop_ctx_setup_collapsed_and_split(
 #ifdef USE_WELD_DEBUG
     Span<MLoop> mloop,
-    Span<MPoly> mpoly,
+    Span<MPoly> polys,
 #endif
     Span<int> vert_dest_map,
     const int remain_edge_ctx_len,
@@ -1102,7 +1102,7 @@ static void weld_poly_loop_ctx_setup_collapsed_and_split(
 
 #ifdef USE_WELD_DEBUG
   weld_assert_poly_and_loop_kill_len(
-      r_weld_mesh, mloop, mpoly, r_weld_mesh->poly_kill_len, r_weld_mesh->loop_kill_len);
+      r_weld_mesh, mloop, polys, r_weld_mesh->poly_kill_len, r_weld_mesh->loop_kill_len);
 #endif
 }
 
@@ -1259,7 +1259,7 @@ static int poly_find_doubles(const OffsetIndices<int> poly_corners_offsets,
 
 static void weld_poly_find_doubles(Span<MLoop> mloop,
 #ifdef USE_WELD_DEBUG
-                                   const Span<MPoly> mpoly,
+                                   const Span<MPoly> polys,
 #endif
                                    const int medge_len,
                                    WeldMesh *r_weld_mesh)
@@ -1329,7 +1329,7 @@ static void weld_poly_find_doubles(Span<MLoop> mloop,
 
 #ifdef USE_WELD_DEBUG
   weld_assert_poly_and_loop_kill_len(
-      r_weld_mesh, mloop, mpoly, r_weld_mesh->poly_kill_len, r_weld_mesh->loop_kill_len);
+      r_weld_mesh, mloop, polys, r_weld_mesh->poly_kill_len, r_weld_mesh->loop_kill_len);
 #endif
 }
 
@@ -1573,11 +1573,11 @@ static Mesh *create_merged_mesh(const Mesh &mesh,
     }
     if (count) {
       CustomData_copy_data(&mesh.edata, &result->edata, source_index, dest_index, count);
-      MEdge *me = &dst_edges[dest_index];
+      MEdge *edge = &dst_edges[dest_index];
       dest_index += count;
-      for (; count--; me++) {
-        me->v1 = vert_final_map[me->v1];
-        me->v2 = vert_final_map[me->v2];
+      for (; count--; edge++) {
+        edge->v1 = vert_final_map[edge->v1];
+        edge->v2 = vert_final_map[edge->v2];
       }
     }
     if (i == totedge) {
@@ -1593,9 +1593,9 @@ static Mesh *create_merged_mesh(const Mesh &mesh,
                       &weld_mesh.edge_groups_buffer[wegrp_offs],
                       wegrp_len,
                       dest_index);
-      MEdge *me = &dst_edges[dest_index];
-      me->v1 = vert_final_map[wegrp_verts[0]];
-      me->v2 = vert_final_map[wegrp_verts[1]];
+      MEdge *edge = &dst_edges[dest_index];
+      edge->v1 = vert_final_map[wegrp_verts[0]];
+      edge->v2 = vert_final_map[wegrp_verts[1]];
 
       edge_final_map[i] = dest_index;
       dest_index++;
@@ -1612,12 +1612,12 @@ static Mesh *create_merged_mesh(const Mesh &mesh,
   int loop_cur = 0;
   Array<int, 64> group_buffer(weld_mesh.max_poly_len);
   for (const int i : src_polys.index_range()) {
-    const MPoly &mp = src_polys[i];
+    const MPoly &poly = src_polys[i];
     const int loop_start = loop_cur;
     const int poly_ctx = weld_mesh.poly_map[i];
     if (poly_ctx == OUT_OF_CONTEXT) {
-      int mp_loop_len = mp.totloop;
-      CustomData_copy_data(&mesh.ldata, &result->ldata, mp.loopstart, loop_cur, mp_loop_len);
+      int mp_loop_len = poly.totloop;
+      CustomData_copy_data(&mesh.ldata, &result->ldata, poly.loopstart, loop_cur, mp_loop_len);
       loop_cur += mp_loop_len;
       for (; mp_loop_len--; r_ml++) {
         r_ml->v = vert_final_map[r_ml->v];
diff --git a/source/blender/gpu/intern/gpu_shader_builder_stubs.cc b/source/blender/gpu/intern/gpu_shader_builder_stubs.cc
index dea62de94f6..bbd71d4e3fe 100644
--- a/source/blender/gpu/intern/gpu_shader_builder_stubs.cc
+++ b/source/blender/gpu/intern/gpu_shader_builder_stubs.cc
@@ -146,7 +146,7 @@ bool paint_is_grid_face_hidden(const uint * /*grid_hidden*/,
 /* -------------------------------------------------------------------- */
 /** \name Stubs of BKE_mesh.h
  * \{ */
-void BKE_mesh_calc_poly_normal(const struct MPoly * /*mpoly*/,
+void BKE_mesh_calc_poly_normal(const struct MPoly * /*polys*/,
                                const struct MLoop * /*loopstart*/,
                                const float (*vert_positions)[3],
                                float[3] /*col*/)
diff --git a/source/blender/io/alembic/exporter/abc_writer_mesh.cc b/source/blender/io/alembic/exporter/abc_writer_mesh.cc
index e7eee7a43be..dfbe46d1038 100644
--- a/source/blender/io/alembic/exporter/abc_writer_mesh.cc
+++ b/source/blender/io/alembic/exporter/abc_writer_mesh.cc
@@ -176,7 +176,7 @@ void ABCGenericMeshWriter::do_write(HierarchyContext &context)
 
   m_custom_data_config.pack_uvs = args_.export_params->packuv;
   m_custom_data_config.mesh = mesh;
-  m_custom_data_config.mpoly = mesh->polys_for_write().data();
+  m_custom_data_config.polys = mesh->polys_for_write().data();
   m_custom_data_config.mloop = mesh->loops_for_write().data();
   m_custom_data_config.totpoly = mesh->totpoly;
   m_custom_data_config.totloop = mesh->totloop;
@@ -548,9 +548,9 @@ static void get_loop_normals(struct Mesh *mesh,
   const Span<MPoly> polys = mesh->polys();
 
   for (const int i : polys.index_range()) {
-    const MPoly *mp = &polys[i];
-    for (int j = mp->totloop - 1; j >= 0; j--, abc_index++) {
-      int blender_index = mp->loopstart + j;
+    const MPoly *poly = &polys[i];
+    for (int j = poly->totloop - 1; j >= 0; j--, abc_index++) {
+      int blender_index = poly->loopstart + j;
       copy_yup_from_zup(normals[abc_index].getValue(), lnors[blender_index]);
     }
   }
diff --git a/source/blender/io/alembic/intern/abc_customdata.cc b/source/blender/io/alembic/intern/abc_customdata.cc
index baa03ca915b..fccbf0651f3 100644
--- a/source/blender/io/alembic/intern/abc_customdata.cc
+++ b/source/blender/io/alembic/intern/abc_customdata.cc
@@ -57,7 +57,7 @@ static void get_uvs(const CDStreamConfig &config,
   }
 
   const int num_poly = config.totpoly;
-  MPoly *mpoly = config.mpoly;
+  MPoly *polys = config.polys;
   MLoop *mloop = config.mloop;
 
   if (!config.pack_uvs) {
@@ -67,7 +67,7 @@ static void get_uvs(const CDStreamConfig &config,
 
     /* Iterate in reverse order to match exported polygons. */
     for (int i = 0; i < num_poly; i++) {
-      MPoly &current_poly = mpoly[i];
+      MPoly &current_poly = polys[i];
       const float2 *loopuv = mloopuv_array + current_poly.loopstart + current_poly.totloop;
 
       for (int j = 0; j < current_poly.totloop; j++, count++) {
@@ -85,7 +85,7 @@ static void get_uvs(const CDStreamConfig &config,
     int idx_count = 0;
 
     for (int i = 0; i < num_poly; i++) {
-      MPoly &current_poly = mpoly[i];
+      MPoly &current_poly = polys[i];
       MLoop *looppoly = mloop + current_poly.loopstart + current_poly.totloop;
       const float2 *loopuv = mloopuv_array + current_poly.loopstart + current_poly.totloop;
 
@@ -172,7 +172,7 @@ static void get_cols(const CDStreamConfig &config,
                      const void *cd_data)
 {
   const float cscale = 1.0f / 255.0f;
-  const MPoly *polys = config.mpoly;
+  const MPoly *polys = config.polys;
   const MCol *cfaces = static_cast<const MCol *>(cd_data);
 
   buffer.reserve(config.totvert);
@@ -181,10 +181,10 @@ static void get_cols(const CDStreamConfig &config,
   Imath::C4f col;
 
   for (int i = 0; i < config.totpoly; i++) {
-    const MPoly *p = &polys[i];
-    const MCol *cface = &cfaces[p->loopstart + p->totloop];
+    const MPoly *poly = &polys[i];
+    const MCol *cface = &cfaces[poly->loopstart + poly->totloop];
 
-    for (int j = 0; j < p->totloop; j++) {
+    for (int j = 0; j < poly->totloop; j++) {
       cface--;
 
       col[0] = cface->a * cscale;
@@ -315,7 +315,7 @@ static void read_uvs(const CDStreamConfig &config,
                      const Alembic::AbcGeom::V2fArraySamplePtr &uvs,
                      const UInt32ArraySamplePtr &indices)
 {
-  MPoly *mpolys = config.mpoly;
+  MPoly *polys = config.polys;
   MLoop *mloops = config.mloop;
   float2 *mloopuvs = static_cast<float2 *>(data);
 
@@ -325,7 +325,7 @@ static void read_uvs(const CDStreamConfig &config,
   const bool do_uvs_per_loop = (uv_scope == ABC_UV_SCOPE_LOOP);
 
   for (int i = 0; i < config.totpoly; i++) {
-    MPoly &poly = mpolys[i];
+    MPoly &poly = polys[i];
     uint rev_loop_offset = poly.loopstart + poly.totloop - 1;
 
     for (int f = 0; f < poly.totloop; f++) {
@@ -411,7 +411,7 @@ static void read_custom_data_mcols(const std::string &iobject_full_name,
   void *cd_data = config.add_customdata_cb(
       config.mesh, prop_header.getName().c_str(), CD_PROP_BYTE_COLOR);
   MCol *cfaces = static_cast<MCol *>(cd_data);
-  MPoly *mpolys = config.mpoly;
+  MPoly *polys = config.polys;
   MLoop *mloops = config.mloop;
 
   size_t face_index = 0;
@@ -425,7 +425,7 @@ static void read_custom_data_mcols(const std::string &iobject_full_name,
   bool use_dual_indexing = is_facevarying && indices->size() > 0;
 
   for (int i = 0; i < config.totpoly; i++) {
-    MPoly *poly = &mpolys[i];
+    MPoly *poly = &polys[i];
     MCol *cface = &cfaces[poly->loopstart + poly->totloop];
     MLoop *mloop = &mloops[poly->loopstart + poly->totloop];
 
diff --git a/source/blender/io/alembic/intern/abc_customdata.h b/source/blender/io/alembic/intern/abc_customdata.h
index a2e257e2285..17ec872b989 100644
--- a/source/blender/io/alembic/intern/abc_customdata.h
+++ b/source/blender/io/alembic/intern/abc_customdata.h
@@ -33,7 +33,7 @@ struct CDStreamConfig {
   MLoop *mloop;
   int totloop;
 
-  MPoly *mpoly;
+  MPoly *polys;
   int totpoly;
 
   float3 *positions;
@@ -75,7 +75,7 @@ struct CDStreamConfig {
   CDStreamConfig()
       : mloop(NULL),
         totloop(0),
-        mpoly(NULL),
+        polys(NULL),
         totpoly(0),
         totvert(0),
         pack_uvs(false),
diff --git a/source/blender/io/alembic/intern/abc_reader_mesh.cc b/source/blender/io/alembic/intern/abc_reader_mesh.cc
index 68d28815f83..10f90071c46 100644
--- a/source/blender/io/alembic/intern/abc_reader_mesh.cc
+++ b/source/blender/io/alembic/intern/abc_reader_mesh.cc
@@ -175,7 +175,7 @@ void read_mverts(Mesh &mesh, const P3fArraySamplePtr positions, const N3fArraySa
 
 static void read_mpolys(CDStreamConfig &config, const AbcMeshData &mesh_data)
 {
-  MPoly *mpolys = config.mpoly;
+  MPoly *polys = config.polys;
   MLoop *mloops = config.mloop;
   float2 *mloopuvs = config.mloopuv;
 
@@ -197,7 +197,7 @@ static void read_mpolys(CDStreamConfig &config, const AbcMeshData &mesh_data)
   for (int i = 0; i < face_counts->size(); i++) {
     const int face_size = (*face_counts)[i];
 
-    MPoly &poly = mpolys[i];
+    MPoly &poly = polys[i];
     poly.loopstart = loop_index;
     poly.totloop = face_size;
 
@@ -270,13 +270,13 @@ static void process_loop_normals(CDStreamConfig &config, const N3fArraySamplePtr
   float(*lnors)[3] = static_cast<float(*)[3]>(
       MEM_malloc_arrayN(loop_count, sizeof(float[3]), "ABC::FaceNormals"));
 
-  MPoly *mpoly = mesh->polys_for_write().data();
+  MPoly *poly = mesh->polys_for_write().data();
   const N3fArraySample &loop_normals = *loop_normals_ptr;
   int abc_index = 0;
-  for (int i = 0, e = mesh->totpoly; i < e; i++, mpoly++) {
+  for (int i = 0, e = mesh->totpoly; i < e; i++, poly++) {
     /* As usual, ABC orders the loops in reverse. */
-    for (int j = mpoly->totloop - 1; j >= 0; j--, abc_index++) {
-      int blender_index = mpoly->loopstart + j;
+    for (int j = poly->totloop - 1; j >= 0; j--, abc_index++) {
+      int blender_index = poly->loopstart + j;
       copy_zup_from_yup(lnors[blender_index], loop_normals[abc_index].getValue());
     }
   }
@@ -519,7 +519,7 @@ CDStreamConfig get_config(Mesh *mesh, const bool use_vertex_interpolation)
   config.mesh = mesh;
   config.positions = mesh->vert_positions_for_write().data();
   config.mloop = mesh->loops_for_write().data();
-  config.mpoly = mesh->polys_for_write().data();
+  config.polys = mesh->polys_for_write().data();
   config.totvert = mesh->totvert;
   config.totloop = mesh->totloop;
   config.totpoly = mesh->totpoly;
diff --git a/source/blender/io/collada/GeometryExporter.cpp b/source/blender/io/collada/GeometryExporter.cpp
index e4217e8641d..c68bac9e627 100644
--- a/source/blender/io/collada/GeometryExporter.cpp
+++ b/source/blender/io/collada/GeometryExporter.cpp
@@ -411,11 +411,11 @@ void GeometryExporter::create_mesh_primitive_list(short material_index,
   /* <p> */
   int texindex = 0;
   for (const int i : polys.index_range()) {
-    const MPoly *p = &polys[i];
-    int loop_count = p->totloop;
+    const MPoly *poly = &polys[i];
+    int loop_count = poly->totloop;
 
     if (material_indices[i] == material_index) {
-      const MLoop *l = &loops[p->loopstart];
+      const MLoop *l = &loops[poly->loopstart];
       BCPolygonNormalsIndices normal_indices = norind[i];
 
       for (int j = 0; j < loop_count; j++) {
@@ -565,9 +565,9 @@ void GeometryExporter::createTexcoordsSource(std::string geom_id, Mesh *me)
       source.prepareToAppendValues();
 
       for (const int i : polys.index_range()) {
-        const MPoly *mpoly = &polys[i];
-        const blender::float2 *mloop = uv_map + mpoly->loopstart;
-        for (int j = 0; j < mpoly->totloop; j++) {
+        const MPoly *poly = &polys[i];
+        const blender::float2 *mloop = uv_map + poly->loopstart;
+        for (int j = 0; j < poly->totloop; j++) {
           source.appendValues(mloop[j][0], mloop[j][1]);
         }
       }
@@ -632,15 +632,15 @@ void GeometryExporter::create_normals(std::vector<Normal> &normals,
   }
 
   for (const int poly_index : polys.index_range()) {
-    const MPoly *mpoly = &polys[poly_index];
-    bool use_vert_normals = use_custom_normals || mpoly->flag & ME_SMOOTH;
+    const MPoly *poly = &polys[poly_index];
+    bool use_vert_normals = use_custom_normals || poly->flag & ME_SMOOTH;
 
     if (!use_vert_normals) {
       /* For flat faces use face normal as vertex normal: */
 
       float vector[3];
-      BKE_mesh_calc_poly_normal(mpoly,
-                                &loops[mpoly->loopstart],
+      BKE_mesh_calc_poly_normal(poly,
+                                &loops[poly->loopstart],
                                 reinterpret_cast<const float(*)[3]>(positions.data()),
                                 vector);
 
@@ -650,8 +650,8 @@ void GeometryExporter::create_normals(std::vector<Normal> &normals,
     }
 
     BCPolygonNormalsIndices poly_indices;
-    for (int loop_index = 0; loop_index < mpoly->totloop; loop_index++) {
-      uint loop_idx = mpoly->loopstart + loop_index;
+    for (int loop_index = 0; loop_index < poly->totloop; loop_index++) {
+      uint loop_idx = poly->loopstart + loop_index;
       if (use_vert_normals) {
         float normalized[3];
 
diff --git a/source/blender/io/collada/MeshImporter.cpp b/source/blender/io/collada/MeshImporter.cpp
index b7379afee65..541475375e4 100644
--- a/source/blender/io/collada/MeshImporter.cpp
+++ b/source/blender/io/collada/MeshImporter.cpp
@@ -210,10 +210,10 @@ MeshImporter::MeshImporter(UnitConverter *unitconv,
 }
 
 bool MeshImporter::set_poly_indices(
-    MPoly *mpoly, MLoop *mloop, int loop_index, const uint *indices, int loop_count)
+    MPoly *poly, MLoop *mloop, int loop_index, const uint *indices, int loop_count)
 {
-  mpoly->loopstart = loop_index;
-  mpoly->totloop = loop_count;
+  poly->loopstart = loop_index;
+  poly->totloop = loop_count;
   bool broken_loop = false;
   for (int index = 0; index < loop_count; index++) {
 
@@ -576,7 +576,7 @@ void MeshImporter::read_lines(COLLADAFW::Mesh *mesh, Mesh *me)
 
     mesh_add_edges(me, loose_edge_count);
     MutableSpan<MEdge> edges = me->edges_for_write();
-    MEdge *med = edges.data() + face_edge_count;
+    MEdge *edge = edges.data() + face_edge_count;
 
     COLLADAFW::MeshPrimitiveArray &prim_arr = mesh->getMeshPrimitives();
 
@@ -588,9 +588,9 @@ void MeshImporter::read_lines(COLLADAFW::Mesh *mesh, Mesh *me)
         uint edge_count = mp->getFaceCount();
         uint *indices = mp->getPositionIndices().getData();
 
-        for (int j = 0; j < edge_count; j++, med++) {
-          med->v1 = indices[2 * j];
-          med->v2 = indices[2 * j + 1];
+        for (int j = 0; j < edge_count; j++, edge++) {
+          edge->v1 = indices[2 * j];
+          edge->v2 = indices[2 * j + 1];
         }
       }
     }
@@ -610,7 +610,7 @@ void MeshImporter::read_polys(COLLADAFW::Mesh *collada_mesh,
 
   MutableSpan<MPoly> polys = me->polys_for_write();
   MutableSpan<MLoop> loops = me->loops_for_write();
-  MPoly *mpoly = polys.data();
+  MPoly *poly = polys.data();
   MLoop *mloop = loops.data();
   int loop_index = 0;
 
@@ -635,8 +635,8 @@ void MeshImporter::read_polys(COLLADAFW::Mesh *collada_mesh,
 
     int collada_meshtype = mp->getPrimitiveType();
 
-    /* since we cannot set mpoly->mat_nr here, we store a portion of me->mpoly in Primitive */
-    Primitive prim = {mpoly, material_indices, 0};
+    /* since we cannot set poly->mat_nr here, we store a portion of me->mpoly in Primitive */
+    Primitive prim = {poly, material_indices, 0};
 
     /* If MeshPrimitive is TRIANGLE_FANS we split it into triangles
      * The first triangle-fan vertex will be the first vertex in every triangle
@@ -654,18 +654,18 @@ void MeshImporter::read_polys(COLLADAFW::Mesh *collada_mesh,
           /* For each triangle store indices of its 3 vertices */
           uint triangle_vertex_indices[3] = {
               first_vertex, position_indices[1], position_indices[2]};
-          set_poly_indices(mpoly, mloop, loop_index, triangle_vertex_indices, 3);
+          set_poly_indices(poly, mloop, loop_index, triangle_vertex_indices, 3);
 
           if (mp_has_normals) { /* vertex normals, same implementation as for the triangles */
             /* The same for vertices normals. */
             uint vertex_normal_indices[3] = {first_normal, normal_indices[1], normal_indices[2]};
             if (!is_flat_face(vertex_normal_indices, nor, 3)) {
-              mpoly->flag |= ME_SMOOTH;
+              poly->flag |= ME_SMOOTH;
             }
             normal_indices++;
           }
 
-          mpoly++;
+          poly++;
           if (material_indices) {
             material_indices++;
           }
@@ -702,7 +702,7 @@ void MeshImporter::read_polys(COLLADAFW::Mesh *collada_mesh,
           continue; /* TODO: add support for holes */
         }
 
-        bool broken_loop = set_poly_indices(mpoly, mloop, loop_index, position_indices, vcount);
+        bool broken_loop = set_poly_indices(poly, mloop, loop_index, position_indices, vcount);
         if (broken_loop) {
           invalid_loop_holes += 1;
         }
@@ -732,7 +732,7 @@ void MeshImporter::read_polys(COLLADAFW::Mesh *collada_mesh,
           /* If it turns out that we have complete custom normals for each MPoly
            * and we want to use custom normals, this will be overridden. */
           if (!is_flat_face(normal_indices, nor, vcount)) {
-            mpoly->flag |= ME_SMOOTH;
+            poly->flag |= ME_SMOOTH;
           }
 
           if (use_custom_normals) {
@@ -768,7 +768,7 @@ void MeshImporter::read_polys(COLLADAFW::Mesh *collada_mesh,
           }
         }
 
-        mpoly++;
+        poly++;
         if (material_indices) {
           material_indices++;
         }
diff --git a/source/blender/io/collada/MeshImporter.h b/source/blender/io/collada/MeshImporter.h
index dbe3cce0ca4..a3b14f03de6 100644
--- a/source/blender/io/collada/MeshImporter.h
+++ b/source/blender/io/collada/MeshImporter.h
@@ -81,7 +81,7 @@ class MeshImporter : public MeshImporterBase {
    * it holds a portion of Mesh faces and corresponds to a DAE primitive list
    * (<triangles>, <polylist>, etc.) */
   struct Primitive {
-    MPoly *mpoly;
+    MPoly *poly;
     int *material_indices;
     unsigned int totpoly;
   };
@@ -93,7 +93,7 @@ class MeshImporter : public MeshImporterBase {
   std::multimap<COLLADAFW::UniqueId, COLLADAFW::UniqueId> materials_mapped_to_geom;
 
   bool set_poly_indices(
-      MPoly *mpoly, MLoop *mloop, int loop_index, const unsigned int *indices, int loop_count);
+      MPoly *poly, MLoop *mloop, int loop_index, const unsigned int *indices, int loop_count);
 
   void set_face_uv(blender::float2 *mloopuv,
                    UVDataWrapper &uvs,
diff --git a/source/blender/io/wavefront_obj/exporter/obj_export_mesh.cc b/source/blender/io/wavefront_obj/exporter/obj_export_mesh.cc
index 3f8a21cc5ab..d915fcc8aa9 100644
--- a/source/blender/io/wavefront_obj/exporter/obj_export_mesh.cc
+++ b/source/blender/io/wavefront_obj/exporter/obj_export_mesh.cc
@@ -277,9 +277,9 @@ float3 OBJMesh::calc_vertex_coords(const int vert_index, const float global_scal
 
 Vector<int> OBJMesh::calc_poly_vertex_indices(const int poly_index) const
 {
-  const MPoly &mpoly = mesh_polys_[poly_index];
-  const MLoop *mloop = &mesh_loops_[mpoly.loopstart];
-  const int totloop = mpoly.totloop;
+  const MPoly &poly = mesh_polys_[poly_index];
+  const MLoop *mloop = &mesh_loops_[poly.loopstart];
+  const int totloop = poly.totloop;
   Vector<int> r_poly_vertex_indices(totloop);
   for (int loop_index = 0; loop_index < totloop; loop_index++) {
     r_poly_vertex_indices[loop_index] = mloop[loop_index].v;
@@ -398,12 +398,12 @@ void OBJMesh::store_normal_coords_and_indices()
   const float(*lnors)[3] = static_cast<const float(*)[3]>(
       CustomData_get_layer(&export_mesh_->ldata, CD_NORMAL));
   for (int poly_index = 0; poly_index < export_mesh_->totpoly; ++poly_index) {
-    const MPoly &mpoly = mesh_polys_[poly_index];
-    bool need_per_loop_normals = lnors != nullptr || (mpoly.flag & ME_SMOOTH);
+    const MPoly &poly = mesh_polys_[poly_index];
+    bool need_per_loop_normals = lnors != nullptr || (poly.flag & ME_SMOOTH);
     if (need_per_loop_normals) {
-      for (int loop_of_poly = 0; loop_of_poly < mpoly.totloop; ++loop_of_poly) {
+      for (int loop_of_poly = 0; loop_of_poly < poly.totloop; ++loop_of_poly) {
         float3 loop_normal;
-        int loop_index = mpoly.loopstart + loop_of_poly;
+        int loop_index = poly.loopstart + loop_of_poly;
         BLI_assert(loop_index < export_mesh_->totloop);
         copy_v3_v3(loop_normal, lnors[loop_index]);
         mul_m3_v3(world_and_axes_normal_transform_, loop_normal);
@@ -427,8 +427,8 @@ void OBJMesh::store_normal_coords_and_indices()
         normal_to_index.add(rounded_poly_normal, poly_norm_index);
         normal_coords_.append(rounded_poly_normal);
       }
-      for (int i = 0; i < mpoly.totloop; ++i) {
-        int loop_index = mpoly.loopstart + i;
+      for (int i = 0; i < poly.totloop; ++i) {
+        int loop_index = poly.loopstart + i;
         BLI_assert(loop_index < export_mesh_->totloop);
         loop_to_normal_index_[loop_index] = poly_norm_index;
       }
@@ -442,11 +442,11 @@ Vector<int> OBJMesh::calc_poly_normal_indices(const int poly_index) const
   if (loop_to_normal_index_.is_empty()) {
     return {};
   }
-  const MPoly &mpoly = mesh_polys_[poly_index];
-  const int totloop = mpoly.totloop;
+  const MPoly &poly = mesh_polys_[poly_index];
+  const int totloop = poly.totloop;
   Vector<int> r_poly_normal_indices(totloop);
   for (int poly_loop_index = 0; poly_loop_index < totloop; poly_loop_index++) {
-    int loop_index = mpoly.loopstart + poly_loop_index;
+    int loop_index = poly.loopstart + poly_loop_index;
     r_poly_normal_indices[poly_loop_index] = loop_to_normal_index_[loop_index];
   }
   return r_poly_normal_indices;
@@ -472,9 +472,9 @@ int16_t OBJMesh::get_poly_deform_group_index(const int poly_index,
 
   group_weights.fill(0);
   bool found_any_group = false;
-  const MPoly &mpoly = mesh_polys_[poly_index];
-  const MLoop *mloop = &mesh_loops_[mpoly.loopstart];
-  for (int loop_i = 0; loop_i < mpoly.totloop; ++loop_i, ++mloop) {
+  const MPoly &poly = mesh_polys_[poly_index];
+  const MLoop *mloop = &mesh_loops_[poly.loopstart];
+  for (int loop_i = 0; loop_i < poly.totloop; ++loop_i, ++mloop) {
     const MDeformVert &dv = dverts[mloop->v];
     for (int weight_i = 0; weight_i < dv.totweight; ++weight_i) {
       const auto group = dv.dw[weight_i].def_nr;
diff --git a/source/blender/io/wavefront_obj/importer/obj_import_mesh.cc b/source/blender/io/wavefront_obj/importer/obj_import_mesh.cc
index d044ff57d4d..e68d4fc54fb 100644
--- a/source/blender/io/wavefront_obj/importer/obj_import_mesh.cc
+++ b/source/blender/io/wavefront_obj/importer/obj_import_mesh.cc
@@ -200,11 +200,11 @@ void MeshFromGeometry::create_polys_loops(Mesh *mesh, bool use_vertex_groups)
       continue;
     }
 
-    MPoly &mpoly = polys[poly_idx];
-    mpoly.totloop = curr_face.corner_count_;
-    mpoly.loopstart = tot_loop_idx;
+    MPoly &poly = polys[poly_idx];
+    poly.totloop = curr_face.corner_count_;
+    poly.loopstart = tot_loop_idx;
     if (curr_face.shaded_smooth) {
-      mpoly.flag |= ME_SMOOTH;
+      poly.flag |= ME_SMOOTH;
     }
     material_indices.span[poly_idx] = curr_face.material_index;
     /* Importing obj files without any materials would result in negative indices, which is not
diff --git a/source/blender/makesdna/DNA_meshdata_types.h b/source/blender/makesdna/DNA_meshdata_types.h
index 79b518b0e48..6385d0fc879 100644
--- a/source/blender/makesdna/DNA_meshdata_types.h
+++ b/source/blender/makesdna/DNA_meshdata_types.h
@@ -173,9 +173,9 @@ enum {
  *
  * \code{.c}
  * // loop over all looptri's for a given polygon: i
- * MPoly *mp = &mpoly[i];
- * MLoopTri *lt = &looptri[poly_to_tri_count(i, mp->loopstart)];
- * int j, lt_tot = ME_POLY_TRI_TOT(mp);
+ * MPoly *poly = &polys[i];
+ * MLoopTri *lt = &looptri[poly_to_tri_count(i, poly->loopstart)];
+ * int j, lt_tot = ME_POLY_TRI_TOT(poly);
  *
  * for (j = 0; j < lt_tot; j++, lt++) {
  *     unsigned int vtri[3] = {
@@ -409,12 +409,12 @@ enum {
 /** \name Utility Macros
  * \{ */
 
-#define ME_POLY_LOOP_PREV(mloop, mp, i) \
-  (&(mloop)[(mp)->loopstart + (((i) + (mp)->totloop - 1) % (mp)->totloop)])
-#define ME_POLY_LOOP_NEXT(mloop, mp, i) (&(mloop)[(mp)->loopstart + (((i) + 1) % (mp)->totloop)])
+#define ME_POLY_LOOP_PREV(mloop, poly, i) \
+  (&(mloop)[(poly)->loopstart + (((i) + (poly)->totloop - 1) % (poly)->totloop)])
+#define ME_POLY_LOOP_NEXT(mloop, poly, i) (&(mloop)[(poly)->loopstart + (((i) + 1) % (poly)->totloop)])
 
 /** Number of tri's that make up this polygon once tessellated. */
-#define ME_POLY_TRI_TOT(mp) ((mp)->totloop - 2)
+#define ME_POLY_TRI_TOT(poly) ((poly)->totloop - 2)
 
 /**
  * Check out-of-bounds material, note that this is nearly always prevented,
diff --git a/source/blender/makesrna/intern/rna_mesh.c b/source/blender/makesrna/intern/rna_mesh.c
index a31730e7a38..47bc0e4e375 100644
--- a/source/blender/makesrna/intern/rna_mesh.c
+++ b/source/blender/makesrna/intern/rna_mesh.c
@@ -385,8 +385,8 @@ static int rna_MeshEdge_index_get(PointerRNA *ptr)
 static int rna_MeshPolygon_index_get(PointerRNA *ptr)
 {
   const Mesh *mesh = rna_mesh(ptr);
-  const MPoly *mpoly = (MPoly *)ptr->data;
-  const int index = (int)(mpoly - BKE_mesh_polys(mesh));
+  const MPoly *poly = (MPoly *)ptr->data;
+  const int index = (int)(poly - BKE_mesh_polys(mesh));
   BLI_assert(index >= 0);
   BLI_assert(index < mesh->totpoly);
   return index;
@@ -627,10 +627,10 @@ static void rna_MeshLoop_bitangent_get(PointerRNA *ptr, float *values)
 static void rna_MeshPolygon_normal_get(PointerRNA *ptr, float *values)
 {
   Mesh *me = rna_mesh(ptr);
-  MPoly *mp = (MPoly *)ptr->data;
+  MPoly *poly = (MPoly *)ptr->data;
   const float(*positions)[3] = BKE_mesh_vert_positions(me);
   const MLoop *loops = BKE_mesh_loops(me);
-  BKE_mesh_calc_poly_normal(mp, loops + mp->loopstart, positions, values);
+  BKE_mesh_calc_poly_normal(poly, loops + poly->loopstart, positions, values);
 }
 
 static bool rna_MeshPolygon_hide_get(PointerRNA *ptr)
@@ -704,26 +704,26 @@ static void rna_MeshPolygon_material_index_set(PointerRNA *ptr, int value)
 static void rna_MeshPolygon_center_get(PointerRNA *ptr, float *values)
 {
   Mesh *me = rna_mesh(ptr);
-  MPoly *mp = (MPoly *)ptr->data;
+  MPoly *poly = (MPoly *)ptr->data;
   const float(*positions)[3] = BKE_mesh_vert_positions(me);
   const MLoop *loops = BKE_mesh_loops(me);
-  BKE_mesh_calc_poly_center(mp, loops + mp->loopstart, positions, values);
+  BKE_mesh_calc_poly_center(poly, loops + poly->loopstart, positions, values);
 }
 
 static float rna_MeshPolygon_area_get(PointerRNA *ptr)
 {
   Mesh *me = (Mesh *)ptr->owner_id;
-  MPoly *mp = (MPoly *)ptr->data;
+  MPoly *poly = (MPoly *)ptr->data;
   const float(*positions)[3] = BKE_mesh_vert_positions(me);
   const MLoop *loops = BKE_mesh_loops(me);
-  return BKE_mesh_calc_poly_area(mp, loops + mp->loopstart, positions);
+  return BKE_mesh_calc_poly_area(poly, loops + poly->loopstart, positions);
 }
 
-static void rna_MeshPolygon_flip(ID *id, MPoly *mp)
+static void rna_MeshPolygon_flip(ID *id, MPoly *poly)
 {
   Mesh *me = (Mesh *)id;
   MLoop *loops = BKE_mesh_loops_for_write(me);
-  BKE_mesh_polygon_flip(mp, loops, &me->ldata, me->totloop);
+  BKE_mesh_polygon_flip(poly, loops, &me->ldata, me->totloop);
   BKE_mesh_tessface_clear(me);
   BKE_mesh_runtime_clear_geometry(me);
 }
@@ -1625,20 +1625,20 @@ static void rna_Mesh_face_map_remove(struct Mesh *me,
 static int rna_MeshPoly_vertices_get_length(const PointerRNA *ptr,
                                             int length[RNA_MAX_ARRAY_DIMENSION])
 {
-  const MPoly *mp = (MPoly *)ptr->data;
+  const MPoly *poly = (MPoly *)ptr->data;
   /* NOTE: raw access uses dummy item, this _could_ crash,
    * watch out for this, #MFace uses it but it can't work here. */
-  return (length[0] = mp->totloop);
+  return (length[0] = poly->totloop);
 }
 
 static void rna_MeshPoly_vertices_get(PointerRNA *ptr, int *values)
 {
   Mesh *me = rna_mesh(ptr);
-  MPoly *mp = (MPoly *)ptr->data;
+  MPoly *poly = (MPoly *)ptr->data;
   const MLoop *loops = BKE_mesh_loops(me);
-  const MLoop *ml = &loops[mp->loopstart];
+  const MLoop *ml = &loops[poly->loopstart];
   uint i;
-  for (i = mp->totloop; i > 0; i--, values++, ml++) {
+  for (i = poly->totloop; i > 0; i--, values++, ml++) {
     *values = ml->v;
   }
 }
@@ -1646,12 +1646,12 @@ static void rna_MeshPoly_vertices_get(PointerRNA *ptr, int *values)
 static void rna_MeshPoly_vertices_set(PointerRNA *ptr, const int *values)
 {
   Mesh *me = rna_mesh(ptr);
-  const MPoly *mp = (const MPoly *)ptr->data;
+  const MPoly *poly = (const MPoly *)ptr->data;
   MLoop *loops = BKE_mesh_loops_for_write(me);
 
-  MLoop *ml = &loops[mp->loopstart];
+  MLoop *ml = &loops[poly->loopstart];
   uint i;
-  for (i = mp->totloop; i > 0; i--, values++, ml++) {
+  for (i = poly->totloop; i > 0; i--, values++, ml++) {
     ml->v = *values;
   }
 }
diff --git a/source/blender/modifiers/intern/MOD_array.cc b/source/blender/modifiers/intern/MOD_array.cc
index 21bac2676ca..b08af002601 100644
--- a/source/blender/modifiers/intern/MOD_array.cc
+++ b/source/blender/modifiers/intern/MOD_array.cc
@@ -283,9 +283,9 @@ static void mesh_merge_transform(Mesh *result,
   using namespace blender;
   int *index_orig;
   int i;
-  MEdge *me;
+  MEdge *edge;
   MLoop *ml;
-  MPoly *mp;
+  MPoly *poly;
   float(*result_positions)[3] = BKE_mesh_vert_positions_for_write(result);
   blender::MutableSpan<MEdge> result_edges = result->edges_for_write();
   blender::MutableSpan<MPoly> result_polys = result->polys_for_write();
@@ -316,16 +316,16 @@ static void mesh_merge_transform(Mesh *result,
   }
 
   /* adjust cap edge vertex indices */
-  me = &result_edges[cap_edges_index];
-  for (i = 0; i < cap_nedges; i++, me++) {
-    me->v1 += cap_verts_index;
-    me->v2 += cap_verts_index;
+  edge = &result_edges[cap_edges_index];
+  for (i = 0; i < cap_nedges; i++, edge++) {
+    edge->v1 += cap_verts_index;
+    edge->v2 += cap_verts_index;
   }
 
   /* adjust cap poly loopstart indices */
-  mp = &result_polys[cap_polys_index];
-  for (i = 0; i < cap_npolys; i++, mp++) {
-    mp->loopstart += cap_loops_index;
+  poly = &result_polys[cap_polys_index];
+  for (i = 0; i < cap_npolys; i++, poly++) {
+    poly->loopstart += cap_loops_index;
   }
 
   /* adjust cap loop vertex and edge indices */
@@ -376,9 +376,9 @@ static Mesh *arrayModifier_doArray(ArrayModifierData *amd,
                                    const ModifierEvalContext *ctx,
                                    const Mesh *mesh)
 {
-  MEdge *me;
+  MEdge *edge;
   MLoop *ml;
-  MPoly *mp;
+  MPoly *poly;
   int i, j, c, count;
   float length = amd->length;
   /* offset matrix */
@@ -609,15 +609,15 @@ static Mesh *arrayModifier_doArray(ArrayModifierData *amd,
     }
 
     /* adjust edge vertex indices */
-    me = &result_edges[c * chunk_nedges];
-    for (i = 0; i < chunk_nedges; i++, me++) {
-      me->v1 += c * chunk_nverts;
-      me->v2 += c * chunk_nverts;
+    edge = &result_edges[c * chunk_nedges];
+    for (i = 0; i < chunk_nedges; i++, edge++) {
+      edge->v1 += c * chunk_nverts;
+      edge->v2 += c * chunk_nverts;
     }
 
-    mp = &result_polys[c * chunk_npolys];
-    for (i = 0; i < chunk_npolys; i++, mp++) {
-      mp->loopstart += c * chunk_nloops;
+    poly = &result_polys[c * chunk_npolys];
+    for (i = 0; i < chunk_npolys; i++, poly++) {
+      poly->loopstart += c * chunk_nloops;
     }
 
     /* adjust loop vertex and edge indices */
diff --git a/source/blender/modifiers/intern/MOD_build.cc b/source/blender/modifiers/intern/MOD_build.cc
index f929823332c..7b77b443d76 100644
--- a/source/blender/modifiers/intern/MOD_build.cc
+++ b/source/blender/modifiers/intern/MOD_build.cc
@@ -96,7 +96,7 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
 
   /* if there's at least one face, build based on faces */
   if (faces_dst_num) {
-    const MPoly *mpoly, *mp;
+    const MPoly *polys, *poly;
     const MLoop *ml, *mloop;
     uintptr_t hash_num, hash_num_alt;
 
@@ -107,14 +107,14 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
     /* get the set of all vert indices that will be in the final mesh,
      * mapped to the new indices
      */
-    mpoly = polys_src.data();
+    polys = polys_src.data();
     mloop = loops_src.data();
     hash_num = 0;
     for (i = 0; i < faces_dst_num; i++) {
-      mp = mpoly + faceMap[i];
-      ml = mloop + mp->loopstart;
+      poly = polys + faceMap[i];
+      ml = mloop + poly->loopstart;
 
-      for (j = 0; j < mp->totloop; j++, ml++) {
+      for (j = 0; j < poly->totloop; j++, ml++) {
         void **val_p;
         if (!BLI_ghash_ensure_p(vertHash, POINTER_FROM_INT(ml->v), &val_p)) {
           *val_p = (void *)hash_num;
@@ -122,7 +122,7 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
         }
       }
 
-      loops_dst_num += mp->totloop;
+      loops_dst_num += poly->totloop;
     }
     BLI_assert(hash_num == BLI_ghash_len(vertHash));
 
@@ -132,10 +132,10 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
     hash_num = 0;
     hash_num_alt = 0;
     for (i = 0; i < edges_src.size(); i++, hash_num_alt++) {
-      const MEdge *me = edges_src.data() + i;
+      const MEdge *edge = edges_src.data() + i;
 
-      if (BLI_ghash_haskey(vertHash, POINTER_FROM_INT(me->v1)) &&
-          BLI_ghash_haskey(vertHash, POINTER_FROM_INT(me->v2))) {
+      if (BLI_ghash_haskey(vertHash, POINTER_FROM_INT(edge->v1)) &&
+          BLI_ghash_haskey(vertHash, POINTER_FROM_INT(edge->v2))) {
         BLI_ghash_insert(edgeHash, (void *)hash_num, (void *)hash_num_alt);
         BLI_ghash_insert(edgeHash2, (void *)hash_num_alt, (void *)hash_num);
         hash_num++;
@@ -144,7 +144,7 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
     BLI_assert(hash_num == BLI_ghash_len(edgeHash));
   }
   else if (edges_dst_num) {
-    const MEdge *medge, *me;
+    const MEdge *edge;
     uintptr_t hash_num;
 
     if (bmd->flag & MOD_BUILD_FLAG_RANDOMIZE) {
@@ -154,18 +154,18 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
     /* get the set of all vert indices that will be in the final mesh,
      * mapped to the new indices
      */
-    medge = edges_src.data();
+    const MEdge *edges = edges_src.data();
     hash_num = 0;
     BLI_assert(hash_num == BLI_ghash_len(vertHash));
     for (i = 0; i < edges_dst_num; i++) {
       void **val_p;
-      me = medge + edgeMap[i];
+      edge = edges + edgeMap[i];
 
-      if (!BLI_ghash_ensure_p(vertHash, POINTER_FROM_INT(me->v1), &val_p)) {
+      if (!BLI_ghash_ensure_p(vertHash, POINTER_FROM_INT(edge->v1), &val_p)) {
         *val_p = (void *)hash_num;
         hash_num++;
       }
-      if (!BLI_ghash_ensure_p(vertHash, POINTER_FROM_INT(me->v2), &val_p)) {
+      if (!BLI_ghash_ensure_p(vertHash, POINTER_FROM_INT(edge->v2), &val_p)) {
         *val_p = (void *)hash_num;
         hash_num++;
       }
diff --git a/source/blender/modifiers/intern/MOD_correctivesmooth.cc b/source/blender/modifiers/intern/MOD_correctivesmooth.cc
index d906c628097..98230a7f97d 100644
--- a/source/blender/modifiers/intern/MOD_correctivesmooth.cc
+++ b/source/blender/modifiers/intern/MOD_correctivesmooth.cc
@@ -442,9 +442,9 @@ static void calc_tangent_spaces(const Mesh *mesh,
   }
 
   for (const int64_t i : polys.index_range()) {
-    const MPoly *mp = &polys[i];
-    const MLoop *l_next = &loops[mp->loopstart];
-    const MLoop *l_term = l_next + mp->totloop;
+    const MPoly *poly = &polys[i];
+    const MLoop *l_next = &loops[poly->loopstart];
+    const MLoop *l_term = l_next + poly->totloop;
     const MLoop *l_prev = l_term - 2;
     const MLoop *l_curr = l_term - 1;
 
diff --git a/source/blender/modifiers/intern/MOD_laplaciansmooth.cc b/source/blender/modifiers/intern/MOD_laplaciansmooth.cc
index ae24c35bf67..6d3ba83cb45 100644
--- a/source/blender/modifiers/intern/MOD_laplaciansmooth.cc
+++ b/source/blender/modifiers/intern/MOD_laplaciansmooth.cc
@@ -118,11 +118,11 @@ static float compute_volume(const float center[3],
   float vol = 0.0f;
 
   for (const int i : polys.index_range()) {
-    const MPoly *mp = &polys[i];
-    const MLoop *l_first = &loops[mp->loopstart];
+    const MPoly *poly = &polys[i];
+    const MLoop *l_first = &loops[poly->loopstart];
     const MLoop *l_prev = l_first + 1;
     const MLoop *l_curr = l_first + 2;
-    const MLoop *l_term = l_first + mp->totloop;
+    const MLoop *l_term = l_first + poly->totloop;
 
     for (; l_curr != l_term; l_prev = l_curr, l_curr++) {
       vol += volume_tetrahedron_signed_v3(
@@ -187,9 +187,9 @@ static void init_laplacian_matrix(LaplacianSystem *sys)
   }
 
   for (const int i : sys->polys.index_range()) {
-    const MPoly *mp = &sys->polys[i];
-    const MLoop *l_next = &sys->loops[mp->loopstart];
-    const MLoop *l_term = l_next + mp->totloop;
+    const MPoly *poly = &sys->polys[i];
+    const MLoop *l_next = &sys->loops[poly->loopstart];
+    const MLoop *l_term = l_next + poly->totloop;
     const MLoop *l_prev = l_term - 2;
     const MLoop *l_curr = l_term - 1;
 
@@ -242,9 +242,9 @@ static void fill_laplacian_matrix(LaplacianSystem *sys)
   uint idv1, idv2;
 
   for (const int i : sys->polys.index_range()) {
-    const MPoly *mp = &sys->polys[i];
-    const MLoop *l_next = &sys->loops[mp->loopstart];
-    const MLoop *l_term = l_next + mp->totloop;
+    const MPoly *poly = &sys->polys[i];
+    const MLoop *l_next = &sys->loops[poly->loopstart];
+    const MLoop *l_term = l_next + poly->totloop;
     const MLoop *l_prev = l_term - 2;
     const MLoop *l_curr = l_term - 1;
 
diff --git a/source/blender/modifiers/intern/MOD_multires.cc b/source/blender/modifiers/intern/MOD_multires.cc
index 6491cc6cb6d..91a5c5bd102 100644
--- a/source/blender/modifiers/intern/MOD_multires.cc
+++ b/source/blender/modifiers/intern/MOD_multires.cc
@@ -245,7 +245,7 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
       sculpt_session->totvert = mesh->totvert;
       sculpt_session->totpoly = mesh->totpoly;
       sculpt_session->vert_positions = nullptr;
-      sculpt_session->mpoly = nullptr;
+      sculpt_session->polys = nullptr;
       sculpt_session->mloop = nullptr;
     }
     // BKE_subdiv_stats_print(&subdiv->stats);
diff --git a/source/blender/modifiers/intern/MOD_ocean.cc b/source/blender/modifiers/intern/MOD_ocean.cc
index 208d888358e..77527460d0d 100644
--- a/source/blender/modifiers/intern/MOD_ocean.cc
+++ b/source/blender/modifiers/intern/MOD_ocean.cc
@@ -191,7 +191,7 @@ static void generate_ocean_geometry_polys(void *__restrict userdata,
   for (x = 0; x < gogd->res_x; x++) {
     const int fi = y * gogd->res_x + x;
     const int vi = y * (gogd->res_x + 1) + x;
-    MPoly *mp = &gogd->polys[fi];
+    MPoly *poly = &gogd->polys[fi];
     MLoop *ml = &gogd->loops[fi * 4];
 
     ml->v = vi;
@@ -203,10 +203,10 @@ static void generate_ocean_geometry_polys(void *__restrict userdata,
     ml->v = vi + gogd->res_x + 1;
     ml++;
 
-    mp->loopstart = fi * 4;
-    mp->totloop = 4;
+    poly->loopstart = fi * 4;
+    poly->totloop = 4;
 
-    mp->flag |= ME_SMOOTH;
+    poly->flag |= ME_SMOOTH;
   }
 }
 
diff --git a/source/blender/modifiers/intern/MOD_particleinstance.cc b/source/blender/modifiers/intern/MOD_particleinstance.cc
index 720f12ca08f..1d3480ff0ad 100644
--- a/source/blender/modifiers/intern/MOD_particleinstance.cc
+++ b/source/blender/modifiers/intern/MOD_particleinstance.cc
@@ -468,28 +468,28 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
 
     /* Create edges and adjust edge vertex indices. */
     CustomData_copy_data(&mesh->edata, &result->edata, 0, p_skip * totedge, totedge);
-    MEdge *me = &edges[p_skip * totedge];
-    for (k = 0; k < totedge; k++, me++) {
-      me->v1 += p_skip * totvert;
-      me->v2 += p_skip * totvert;
+    MEdge *edge = &edges[p_skip * totedge];
+    for (k = 0; k < totedge; k++, edge++) {
+      edge->v1 += p_skip * totvert;
+      edge->v2 += p_skip * totvert;
     }
 
     /* create polys and loops */
     for (k = 0; k < totpoly; k++) {
 
       const MPoly *inMP = &orig_polys[k];
-      MPoly *mp = &polys[p_skip * totpoly + k];
+      MPoly *poly = &polys[p_skip * totpoly + k];
 
       CustomData_copy_data(&mesh->pdata, &result->pdata, k, p_skip * totpoly + k, 1);
-      *mp = *inMP;
-      mp->loopstart += p_skip * totloop;
+      *poly = *inMP;
+      poly->loopstart += p_skip * totloop;
 
       {
         const MLoop *inML = &orig_loops[inMP->loopstart];
-        MLoop *ml = &loops[mp->loopstart];
-        int j = mp->totloop;
+        MLoop *ml = &loops[poly->loopstart];
+        int j = poly->totloop;
 
-        CustomData_copy_data(&mesh->ldata, &result->ldata, inMP->loopstart, mp->loopstart, j);
+        CustomData_copy_data(&mesh->ldata, &result->ldata, inMP->loopstart, poly->loopstart, j);
         for (; j; j--, ml++, inML++) {
           ml->v = inML->v + (p_skip * totvert);
           ml->e = inML->e + (p_skip * totedge);
diff --git a/source/blender/modifiers/intern/MOD_screw.cc b/source/blender/modifiers/intern/MOD_screw.cc
index 8abb1815dd5..986e3fba52e 100644
--- a/source/blender/modifiers/intern/MOD_screw.cc
+++ b/source/blender/modifiers/intern/MOD_screw.cc
@@ -252,7 +252,7 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
 
   MPoly *mp_new;
   MLoop *ml_new;
-  MEdge *med_new, *med_new_firstloop;
+  MEdge *edge_new, *med_new_firstloop;
   Object *ob_axis = ltmd->ob_axis;
 
   ScrewVertConnect *vc, *vc_tmp, *vert_connect = nullptr;
@@ -444,11 +444,11 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
   /* Set the locations of the first set of verts */
 
   /* Copy the first set of edges */
-  const MEdge *med_orig = edges_orig.data();
-  med_new = edges_new.data();
-  for (uint i = 0; i < totedge; i++, med_orig++, med_new++) {
-    med_new->v1 = med_orig->v1;
-    med_new->v2 = med_orig->v2;
+  const MEdge *edge_orig = edges_orig.data();
+  edge_new = edges_new.data();
+  for (uint i = 0; i < totedge; i++, edge_orig++, edge_new++) {
+    edge_new->v1 = edge_orig->v1;
+    edge_new->v2 = edge_orig->v2;
   }
 
   /* build polygon -> edge map */
@@ -496,7 +496,7 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
     if (totedge != 0) {
       // printf("\n\n\n\n\nStarting Modifier\n");
       /* set edge users */
-      med_new = edges_new.data();
+      edge_new = edges_new.data();
 
       if (ob_axis != nullptr) {
         /* `mtx_tx` is initialized early on. */
@@ -536,31 +536,31 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
       }
 
       /* this loop builds connectivity info for verts */
-      for (uint i = 0; i < totedge; i++, med_new++) {
-        vc = &vert_connect[med_new->v1];
+      for (uint i = 0; i < totedge; i++, edge_new++) {
+        vc = &vert_connect[edge_new->v1];
 
         if (vc->v[0] == SV_UNUSED) { /* unused */
-          vc->v[0] = med_new->v2;
-          vc->e[0] = med_new;
+          vc->v[0] = edge_new->v2;
+          vc->e[0] = edge_new;
         }
         else if (vc->v[1] == SV_UNUSED) {
-          vc->v[1] = med_new->v2;
-          vc->e[1] = med_new;
+          vc->v[1] = edge_new->v2;
+          vc->e[1] = edge_new;
         }
         else {
           vc->v[0] = vc->v[1] = SV_INVALID; /* error value  - don't use, 3 edges on vert */
         }
 
-        vc = &vert_connect[med_new->v2];
+        vc = &vert_connect[edge_new->v2];
 
         /* same as above but swap v1/2 */
         if (vc->v[0] == SV_UNUSED) { /* unused */
-          vc->v[0] = med_new->v1;
-          vc->e[0] = med_new;
+          vc->v[0] = edge_new->v1;
+          vc->e[0] = edge_new;
         }
         else if (vc->v[1] == SV_UNUSED) {
-          vc->v[1] = med_new->v1;
-          vc->e[1] = med_new;
+          vc->v[1] = edge_new->v1;
+          vc->e[1] = edge_new;
         }
         else {
           vc->v[0] = vc->v[1] = SV_INVALID; /* error value  - don't use, 3 edges on vert */
@@ -798,9 +798,9 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
       }
 
       /* add the new edge */
-      med_new->v1 = varray_stride + j;
-      med_new->v2 = med_new->v1 - totvert;
-      med_new++;
+      edge_new->v1 = varray_stride + j;
+      edge_new->v2 = edge_new->v1 - totvert;
+      edge_new++;
     }
   }
 
@@ -815,9 +815,9 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
     const uint varray_stride = (step_tot - 1) * totvert;
 
     for (uint i = 0; i < totvert; i++) {
-      med_new->v1 = i;
-      med_new->v2 = varray_stride + i;
-      med_new++;
+      edge_new->v1 = i;
+      edge_new->v2 = varray_stride + i;
+      edge_new++;
     }
   }
 
@@ -943,9 +943,9 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
 
         /* new vertical edge */
         if (step) { /* The first set is already done */
-          med_new->v1 = i1;
-          med_new->v2 = i2;
-          med_new++;
+          edge_new->v1 = i1;
+          edge_new->v2 = i2;
+          edge_new++;
         }
         i1 += totvert;
         i2 += totvert;
@@ -969,9 +969,9 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
     }
 
     /* new vertical edge */
-    med_new->v1 = i1;
-    med_new->v2 = i2;
-    med_new++;
+    edge_new->v1 = i1;
+    edge_new->v2 = i2;
+    edge_new++;
   }
 
 /* validate loop edges */
diff --git a/source/blender/modifiers/intern/MOD_skin.cc b/source/blender/modifiers/intern/MOD_skin.cc
index 285ddbe0285..74b6de8562a 100644
--- a/source/blender/modifiers/intern/MOD_skin.cc
+++ b/source/blender/modifiers/intern/MOD_skin.cc
@@ -449,7 +449,7 @@ static void merge_frame_corners(Frame **frames, int totframe)
 static Frame **collect_hull_frames(int v,
                                    SkinNode *frames,
                                    const MeshElemMap *emap,
-                                   const blender::Span<MEdge> medge,
+                                   const blender::Span<MEdge> edges,
                                    int *tothullframe)
 {
   SkinNode *f;
@@ -460,8 +460,8 @@ static Frame **collect_hull_frames(int v,
   hull_frames = MEM_cnew_array<Frame *>(*tothullframe, __func__);
   hull_frames_num = 0;
   for (i = 0; i < emap[v].count; i++) {
-    const MEdge *e = &medge[emap[v].indices[i]];
-    f = &frames[BKE_mesh_edge_other_vert(e, v)];
+    const MEdge *edge = &edges[emap[v].indices[i]];
+    f = &frames[BKE_mesh_edge_other_vert(edge, v)];
     /* Can't have adjacent branch nodes yet */
     if (f->totframe) {
       hull_frames[hull_frames_num++] = &f->frames[0];
@@ -717,7 +717,7 @@ static void build_emats_stack(BLI_Stack *stack,
                               BLI_bitmap *visited_e,
                               EMat *emat,
                               const MeshElemMap *emap,
-                              const blender::Span<MEdge> medge,
+                              const blender::Span<MEdge> edges,
                               const MVertSkin *vs,
                               const float (*vert_positions)[3])
 {
@@ -741,7 +741,7 @@ static void build_emats_stack(BLI_Stack *stack,
 
   parent_is_branch = ((emap[parent_v].count > 2) || (vs[parent_v].flag & MVERT_SKIN_ROOT));
 
-  v = BKE_mesh_edge_other_vert(&medge[e], parent_v);
+  v = BKE_mesh_edge_other_vert(&edges[e], parent_v);
   emat[e].origin = parent_v;
 
   /* If parent is a branch node, start a new edge chain */
@@ -772,7 +772,7 @@ static void build_emats_stack(BLI_Stack *stack,
 static EMat *build_edge_mats(const MVertSkin *vs,
                              const float (*vert_positions)[3],
                              const int verts_num,
-                             const blender::Span<MEdge> medge,
+                             const blender::Span<MEdge> edges,
                              const MeshElemMap *emap,
                              bool *has_valid_root)
 {
@@ -784,17 +784,17 @@ static EMat *build_edge_mats(const MVertSkin *vs,
 
   stack = BLI_stack_new(sizeof(stack_elem), "build_edge_mats.stack");
 
-  visited_e = BLI_BITMAP_NEW(medge.size(), "build_edge_mats.visited_e");
-  emat = MEM_cnew_array<EMat>(medge.size(), __func__);
+  visited_e = BLI_BITMAP_NEW(edges.size(), "build_edge_mats.visited_e");
+  emat = MEM_cnew_array<EMat>(edges.size(), __func__);
 
   /* Edge matrices are built from the root nodes, add all roots with
    * children to the stack */
   for (v = 0; v < verts_num; v++) {
     if (vs[v].flag & MVERT_SKIN_ROOT) {
       if (emap[v].count >= 1) {
-        const MEdge *e = &medge[emap[v].indices[0]];
+        const MEdge *edge = &edges[emap[v].indices[0]];
         calc_edge_mat(
-            stack_elem.mat, vert_positions[v], vert_positions[BKE_mesh_edge_other_vert(e, v)]);
+            stack_elem.mat, vert_positions[v], vert_positions[BKE_mesh_edge_other_vert(edge, v)]);
         stack_elem.parent_v = v;
 
         /* Add adjacent edges to stack */
@@ -805,7 +805,7 @@ static EMat *build_edge_mats(const MVertSkin *vs,
 
         *has_valid_root = true;
       }
-      else if (medge.size() == 0) {
+      else if (edges.size() == 0) {
         /* Vertex-only mesh is valid, mark valid root as well (will display error otherwise). */
         *has_valid_root = true;
         break;
@@ -814,7 +814,7 @@ static EMat *build_edge_mats(const MVertSkin *vs,
   }
 
   while (!BLI_stack_is_empty(stack)) {
-    build_emats_stack(stack, visited_e, emat, emap, medge, vs, vert_positions);
+    build_emats_stack(stack, visited_e, emat, emap, edges, vs, vert_positions);
   }
 
   MEM_freeN(visited_e);
@@ -832,16 +832,16 @@ static EMat *build_edge_mats(const MVertSkin *vs,
  * two hulls.) */
 static int calc_edge_subdivisions(const float (*vert_positions)[3],
                                   const MVertSkin *nodes,
-                                  const MEdge *e,
+                                  const MEdge *edge,
                                   const int *degree)
 {
   /* prevent memory errors #38003. */
 #define NUM_SUBDIVISIONS_MAX 128
 
-  const MVertSkin *evs[2] = {&nodes[e->v1], &nodes[e->v2]};
+  const MVertSkin *evs[2] = {&nodes[edge->v1], &nodes[edge->v2]};
   float avg_radius;
-  const bool v1_branch = degree[e->v1] > 2;
-  const bool v2_branch = degree[e->v2] > 2;
+  const bool v1_branch = degree[edge->v1] > 2;
+  const bool v2_branch = degree[edge->v2] > 2;
   int subdivisions_num;
 
   /* If either end is a branch node marked 'loose', don't subdivide
@@ -860,7 +860,7 @@ static int calc_edge_subdivisions(const float (*vert_positions)[3],
   if (avg_radius != 0.0f) {
     /* possible (but unlikely) that we overflow INT_MAX */
     float subdivisions_num_fl;
-    const float edge_len = len_v3v3(vert_positions[e->v1], vert_positions[e->v2]);
+    const float edge_len = len_v3v3(vert_positions[edge->v1], vert_positions[edge->v2]);
     subdivisions_num_fl = (edge_len / avg_radius);
     if (subdivisions_num_fl < NUM_SUBDIVISIONS_MAX) {
       subdivisions_num = int(subdivisions_num_fl);
@@ -888,7 +888,6 @@ static int calc_edge_subdivisions(const float (*vert_positions)[3],
  * reasonably close. */
 static Mesh *subdivide_base(const Mesh *orig)
 {
-  const MEdge *e;
   int subd_num;
   int i, j, k, u, v;
   float radrat;
@@ -896,7 +895,7 @@ static Mesh *subdivide_base(const Mesh *orig)
   const MVertSkin *orignode = static_cast<const MVertSkin *>(
       CustomData_get_layer(&orig->vdata, CD_MVERT_SKIN));
   const float(*orig_vert_positions)[3] = BKE_mesh_vert_positions(orig);
-  const blender::Span<MEdge> origedge = orig->edges();
+  const blender::Span<MEdge> orig_edges = orig->edges();
   const MDeformVert *origdvert = BKE_mesh_deform_verts(orig);
   int orig_vert_num = orig->totvert;
   int orig_edge_num = orig->totedge;
@@ -904,14 +903,14 @@ static Mesh *subdivide_base(const Mesh *orig)
   /* Get degree of all vertices */
   int *degree = MEM_cnew_array<int>(orig_vert_num, __func__);
   for (i = 0; i < orig_edge_num; i++) {
-    degree[origedge[i].v1]++;
-    degree[origedge[i].v2]++;
+    degree[orig_edges[i].v1]++;
+    degree[orig_edges[i].v2]++;
   }
 
   /* Per edge, store how many subdivisions are needed */
   int *edge_subd = MEM_cnew_array<int>(orig_edge_num, __func__);
   for (i = 0, subd_num = 0; i < orig_edge_num; i++) {
-    edge_subd[i] += calc_edge_subdivisions(orig_vert_positions, orignode, &origedge[i], degree);
+    edge_subd[i] += calc_edge_subdivisions(orig_vert_positions, orignode, &orig_edges[i], degree);
     BLI_assert(edge_subd[i] >= 0);
     subd_num += edge_subd[i];
   }
@@ -945,11 +944,11 @@ static Mesh *subdivide_base(const Mesh *orig)
     VGroupData *vgroups = nullptr, *vg;
     int vgroups_num = 0;
 
-    e = &origedge[i];
+    const MEdge *edge = &orig_edges[i];
 
     if (origdvert) {
-      const MDeformVert *dv1 = &origdvert[e->v1];
-      const MDeformVert *dv2 = &origdvert[e->v2];
+      const MDeformVert *dv1 = &origdvert[edge->v1];
+      const MDeformVert *dv2 = &origdvert[edge->v2];
       vgroups = MEM_cnew_array<VGroupData>(dv1->totweight, __func__);
 
       /* Only want vertex groups used by both vertices */
@@ -971,8 +970,8 @@ static Mesh *subdivide_base(const Mesh *orig)
       }
     }
 
-    u = e->v1;
-    radrat = (half_v2(outnode[e->v2].radius) / half_v2(outnode[e->v1].radius));
+    u = edge->v1;
+    radrat = (half_v2(outnode[edge->v2].radius) / half_v2(outnode[edge->v1].radius));
     if (isfinite(radrat)) {
       radrat = (radrat + 1) / 2;
     }
@@ -988,10 +987,10 @@ static Mesh *subdivide_base(const Mesh *orig)
 
       /* Interpolate vertex coord */
       interp_v3_v3v3(
-          out_vert_positions[v], out_vert_positions[e->v1], out_vert_positions[e->v2], t);
+          out_vert_positions[v], out_vert_positions[edge->v1], out_vert_positions[edge->v2], t);
 
       /* Interpolate skin radii */
-      interp_v3_v3v3(outnode[v].radius, orignode[e->v1].radius, orignode[e->v2].radius, t);
+      interp_v3_v3v3(outnode[v].radius, orignode[edge->v1].radius, orignode[edge->v2].radius, t);
 
       /* Interpolate vertex group weights */
       for (k = 0; k < vgroups_num; k++) {
@@ -1017,7 +1016,7 @@ static Mesh *subdivide_base(const Mesh *orig)
 
     /* Link up to final vertex */
     result_edges[result_edge_i].v1 = u;
-    result_edges[result_edge_i].v2 = e->v2;
+    result_edges[result_edge_i].v2 = edge->v2;
     result_edge_i++;
   }
 
@@ -1565,7 +1564,7 @@ static void hull_merge_triangles(SkinOutput *so, const SkinModifierData *smd)
 static void skin_merge_close_frame_verts(SkinNode *skin_nodes,
                                          int verts_num,
                                          const MeshElemMap *emap,
-                                         const blender::Span<MEdge> medge)
+                                         const blender::Span<MEdge> edges)
 {
   Frame **hull_frames;
   int v, tothullframe;
@@ -1573,7 +1572,7 @@ static void skin_merge_close_frame_verts(SkinNode *skin_nodes,
   for (v = 0; v < verts_num; v++) {
     /* Only check branch nodes */
     if (!skin_nodes[v].totframe) {
-      hull_frames = collect_hull_frames(v, skin_nodes, emap, medge, &tothullframe);
+      hull_frames = collect_hull_frames(v, skin_nodes, emap, edges, &tothullframe);
       merge_frame_corners(hull_frames, tothullframe);
       MEM_freeN(hull_frames);
     }
@@ -1677,12 +1676,12 @@ static void skin_output_end_nodes(SkinOutput *so, SkinNode *skin_nodes, int vert
 
 static void skin_output_connections(SkinOutput *so,
                                     SkinNode *skin_nodes,
-                                    const blender::Span<MEdge> medge)
+                                    const blender::Span<MEdge> edges)
 {
-  for (const int e : medge.index_range()) {
+  for (const int e : edges.index_range()) {
     SkinNode *a, *b;
-    a = &skin_nodes[medge[e].v1];
-    b = &skin_nodes[medge[e].v2];
+    a = &skin_nodes[edges[e].v1];
+    b = &skin_nodes[edges[e].v2];
 
     if (a->totframe && b->totframe) {
       if ((a->flag & SEAM_FRAME) || (b->flag & SEAM_FRAME)) {
@@ -1787,7 +1786,7 @@ static bool skin_output_branch_hulls(SkinOutput *so,
                                      SkinNode *skin_nodes,
                                      int verts_num,
                                      const MeshElemMap *emap,
-                                     const blender::Span<MEdge> medge)
+                                     const blender::Span<MEdge> edges)
 {
   bool result = true;
   int v;
@@ -1800,7 +1799,7 @@ static bool skin_output_branch_hulls(SkinOutput *so,
       Frame **hull_frames;
       int tothullframe;
 
-      hull_frames = collect_hull_frames(v, skin_nodes, emap, medge, &tothullframe);
+      hull_frames = collect_hull_frames(v, skin_nodes, emap, edges, &tothullframe);
       if (!build_hull(so, hull_frames, tothullframe)) {
         result = false;
       }
@@ -1821,7 +1820,7 @@ ENUM_OPERATORS(eSkinErrorFlag, SKIN_ERROR_HULL);
 static BMesh *build_skin(SkinNode *skin_nodes,
                          int verts_num,
                          const MeshElemMap *emap,
-                         const blender::Span<MEdge> medge,
+                         const blender::Span<MEdge> edges,
                          const MDeformVert *input_dvert,
                          SkinModifierData *smd,
                          eSkinErrorFlag *r_error)
@@ -1846,7 +1845,7 @@ static BMesh *build_skin(SkinNode *skin_nodes,
 
   /* Check for mergeable frame corners around hulls before
    * outputting vertices */
-  skin_merge_close_frame_verts(skin_nodes, verts_num, emap, medge);
+  skin_merge_close_frame_verts(skin_nodes, verts_num, emap, edges);
 
   /* Write out all frame vertices to the mesh */
   for (v = 0; v < verts_num; v++) {
@@ -1858,7 +1857,7 @@ static BMesh *build_skin(SkinNode *skin_nodes,
   /* Update vertex pointers for merged frame corners */
   skin_update_merged_vertices(skin_nodes, verts_num);
 
-  if (!skin_output_branch_hulls(&so, skin_nodes, verts_num, emap, medge)) {
+  if (!skin_output_branch_hulls(&so, skin_nodes, verts_num, emap, edges)) {
     *r_error |= SKIN_ERROR_HULL;
   }
 
@@ -1881,7 +1880,7 @@ static BMesh *build_skin(SkinNode *skin_nodes,
   skin_smooth_hulls(so.bm, skin_nodes, verts_num, smd);
 
   skin_output_end_nodes(&so, skin_nodes, verts_num);
-  skin_output_connections(&so, skin_nodes, medge);
+  skin_output_connections(&so, skin_nodes, edges);
   hull_merge_triangles(&so, smd);
 
   bmesh_edit_end(so.bm, BMOpTypeFlag(0));
diff --git a/source/blender/modifiers/intern/MOD_solidify_extrude.cc b/source/blender/modifiers/intern/MOD_solidify_extrude.cc
index 1306679e286..a293573c7e1 100644
--- a/source/blender/modifiers/intern/MOD_solidify_extrude.cc
+++ b/source/blender/modifiers/intern/MOD_solidify_extrude.cc
@@ -99,9 +99,9 @@ static void mesh_calc_hq_normal(Mesh *mesh,
     }
 
     int i;
-    const MEdge *ed;
-    for (i = 0, ed = edges.data(), edge_ref = edge_ref_array; i < edges.size();
-         i++, ed++, edge_ref++) {
+    const MEdge *edge;
+    for (i = 0, edge = edges.data(), edge_ref = edge_ref_array; i < edges.size();
+         i++, edge++, edge_ref++) {
       /* Get the edge vert indices, and edge value (the face indices that use it) */
 
       if (edgeref_is_init(edge_ref) && (edge_ref->p1 != -1)) {
@@ -123,8 +123,8 @@ static void mesh_calc_hq_normal(Mesh *mesh,
           /* an edge without another attached- the weight on this is undefined */
           copy_v3_v3(edge_normal, poly_nors[edge_ref->p1]);
         }
-        add_v3_v3(r_vert_nors[ed->v1], edge_normal);
-        add_v3_v3(r_vert_nors[ed->v2], edge_normal);
+        add_v3_v3(r_vert_nors[edge->v1], edge_normal);
+        add_v3_v3(r_vert_nors[edge->v2], edge_normal);
       }
     }
     MEM_freeN(edge_ref_array);
@@ -243,8 +243,8 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
     copy_vn_i(edge_users, edges_num, INVALID_UNUSED);
 #endif
 
-    const MEdge *ed;
-    for (eidx = 0, ed = orig_edges.data(); eidx < edges_num; eidx++, ed++) {
+    const MEdge *edge;
+    for (eidx = 0, edge = orig_edges.data(); eidx < edges_num; eidx++, edge++) {
       edge_users[eidx] = INVALID_UNUSED;
     }
 
@@ -259,10 +259,10 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
         /* add edge user */
         eidx = ml_prev->e;
         if (edge_users[eidx] == INVALID_UNUSED) {
-          ed = &orig_edges[eidx];
-          BLI_assert(ELEM(ml_prev->v, ed->v1, ed->v2) && ELEM(ml->v, ed->v1, ed->v2));
-          edge_users[eidx] = (ml_prev->v > ml->v) == (ed->v1 < ed->v2) ? uint(i) :
-                                                                         (uint(i) + polys_num);
+          edge = &orig_edges[eidx];
+          BLI_assert(ELEM(ml_prev->v, edge->v1, edge->v2) && ELEM(ml->v, edge->v1, edge->v2));
+          edge_users[eidx] = (ml_prev->v > ml->v) == (edge->v1 < edge->v2) ? uint(i) :
+                                                                             (uint(i) + polys_num);
           edge_order[eidx] = j;
         }
         else {
@@ -272,10 +272,10 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
       }
     }
 
-    for (eidx = 0, ed = orig_edges.data(); eidx < edges_num; eidx++, ed++) {
+    for (eidx = 0, edge = orig_edges.data(); eidx < edges_num; eidx++, edge++) {
       if (!ELEM(edge_users[eidx], INVALID_UNUSED, INVALID_PAIR)) {
-        BLI_BITMAP_ENABLE(orig_mvert_tag, ed->v1);
-        BLI_BITMAP_ENABLE(orig_mvert_tag, ed->v2);
+        BLI_BITMAP_ENABLE(orig_mvert_tag, edge->v1);
+        BLI_BITMAP_ENABLE(orig_mvert_tag, edge->v2);
         STACK_PUSH(new_edge_arr, eidx);
         newPolys++;
         newLoops += 4;
@@ -415,40 +415,40 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
   if (do_shell) {
     uint i;
 
-    MPoly *mp = &polys[polys_num];
-    for (i = 0; i < mesh->totpoly; i++, mp++) {
-      const int loop_end = mp->totloop - 1;
+    MPoly *poly = &polys[polys_num];
+    for (i = 0; i < mesh->totpoly; i++, poly++) {
+      const int loop_end = poly->totloop - 1;
       MLoop *ml2;
       uint e;
       int j;
 
       /* reverses the loop direction (MLoop.v as well as custom-data)
        * MLoop.e also needs to be corrected too, done in a separate loop below. */
-      ml2 = &loops[mp->loopstart + mesh->totloop];
+      ml2 = &loops[poly->loopstart + mesh->totloop];
 #if 0
-      for (j = 0; j < mp->totloop; j++) {
+      for (j = 0; j < poly->totloop; j++) {
         CustomData_copy_data(&mesh->ldata,
                              &result->ldata,
-                             mp->loopstart + j,
-                             mp->loopstart + (loop_end - j) + mesh->totloop,
+                             poly->loopstart + j,
+                             poly->loopstart + (loop_end - j) + mesh->totloop,
                              1);
       }
 #else
       /* slightly more involved, keep the first vertex the same for the copy,
        * ensures the diagonals in the new face match the original. */
       j = 0;
-      for (int j_prev = loop_end; j < mp->totloop; j_prev = j++) {
+      for (int j_prev = loop_end; j < poly->totloop; j_prev = j++) {
         CustomData_copy_data(&mesh->ldata,
                              &result->ldata,
-                             mp->loopstart + j,
-                             mp->loopstart + (loop_end - j_prev) + mesh->totloop,
+                             poly->loopstart + j,
+                             poly->loopstart + (loop_end - j_prev) + mesh->totloop,
                              1);
       }
 #endif
 
       if (mat_ofs) {
-        dst_material_index[mp - polys.data()] += mat_ofs;
-        CLAMP(dst_material_index[mp - polys.data()], 0, mat_nr_max);
+        dst_material_index[poly - polys.data()] += mat_ofs;
+        CLAMP(dst_material_index[poly - polys.data()], 0, mat_nr_max);
       }
 
       e = ml2[0].e;
@@ -457,9 +457,9 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
       }
       ml2[loop_end].e = e;
 
-      mp->loopstart += mesh->totloop;
+      poly->loopstart += mesh->totloop;
 
-      for (j = 0; j < mp->totloop; j++) {
+      for (j = 0; j < poly->totloop; j++) {
         ml2[j].e += edges_num;
         ml2[j].v += verts_num;
       }
@@ -524,9 +524,9 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
         for (uint j = 0; j < poly.totloop; j++, ml++) {
           /* add edge user */
           eidx = ml_prev->e;
-          const MEdge *ed = &orig_edges[eidx];
-          BLI_assert(ELEM(ml_prev->v, ed->v1, ed->v2) && ELEM(ml->v, ed->v1, ed->v2));
-          char flip = char((ml_prev->v > ml->v) == (ed->v1 < ed->v2));
+          const MEdge *edge = &orig_edges[eidx];
+          BLI_assert(ELEM(ml_prev->v, edge->v1, edge->v2) && ELEM(ml->v, edge->v1, edge->v2));
+          char flip = char((ml_prev->v > ml->v) == (edge->v1 < edge->v2));
           if (edge_user_pairs[eidx][flip] == INVALID_UNUSED) {
             edge_user_pairs[eidx][flip] = uint(i);
           }
@@ -537,19 +537,19 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
           ml_prev = ml;
         }
       }
-      const MEdge *ed = orig_edges.data();
+      const MEdge *edge = orig_edges.data();
       float e[3];
-      for (uint i = 0; i < edges_num; i++, ed++) {
+      for (uint i = 0; i < edges_num; i++, edge++) {
         if (!ELEM(edge_user_pairs[i][0], INVALID_UNUSED, INVALID_PAIR) &&
             !ELEM(edge_user_pairs[i][1], INVALID_UNUSED, INVALID_PAIR)) {
           const float *n0 = poly_nors[edge_user_pairs[i][0]];
           const float *n1 = poly_nors[edge_user_pairs[i][1]];
-          sub_v3_v3v3(e, orig_vert_positions[ed->v1], orig_vert_positions[ed->v2]);
+          sub_v3_v3v3(e, orig_vert_positions[edge->v1], orig_vert_positions[edge->v2]);
           normalize_v3(e);
           const float angle = angle_signed_on_axis_v3v3_v3(n0, n1, e);
           if (do_angle_clamp) {
-            vert_angs[ed->v1] = max_ff(vert_angs[ed->v1], angle);
-            vert_angs[ed->v2] = max_ff(vert_angs[ed->v2], angle);
+            vert_angs[edge->v1] = max_ff(vert_angs[edge->v1], angle);
+            vert_angs[edge->v2] = max_ff(vert_angs[edge->v2], angle);
           }
           if (do_bevel_convex) {
             edge_angs[i] = angle;
@@ -716,21 +716,21 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
       }
     }
 
-    const MPoly *mp;
-    for (i = 0, mp = polys.data(); i < polys_num; i++, mp++) {
+    const MPoly *poly;
+    for (i = 0, poly = polys.data(); i < polys_num; i++, poly++) {
       /* #BKE_mesh_calc_poly_angles logic is inlined here */
       float nor_prev[3];
       float nor_next[3];
 
-      int i_curr = mp->totloop - 1;
+      int i_curr = poly->totloop - 1;
       int i_next = 0;
 
-      const MLoop *ml = &loops[mp->loopstart];
+      const MLoop *ml = &loops[poly->loopstart];
 
       sub_v3_v3v3(nor_prev, vert_positions[ml[i_curr - 1].v], vert_positions[ml[i_curr].v]);
       normalize_v3(nor_prev);
 
-      while (i_next < mp->totloop) {
+      while (i_next < poly->totloop) {
         float angle;
         sub_v3_v3v3(nor_next, vert_positions[ml[i_curr].v], vert_positions[ml[i_next].v]);
         normalize_v3(nor_next);
@@ -822,9 +822,9 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
         for (int j = 0; j < poly.totloop; j++, ml++) {
           /* add edge user */
           eidx = ml_prev->e;
-          const MEdge *ed = &orig_edges[eidx];
-          BLI_assert(ELEM(ml_prev->v, ed->v1, ed->v2) && ELEM(ml->v, ed->v1, ed->v2));
-          char flip = char((ml_prev->v > ml->v) == (ed->v1 < ed->v2));
+          const MEdge *edge = &orig_edges[eidx];
+          BLI_assert(ELEM(ml_prev->v, edge->v1, edge->v2) && ELEM(ml->v, edge->v1, edge->v2));
+          char flip = char((ml_prev->v > ml->v) == (edge->v1 < edge->v2));
           if (edge_user_pairs[eidx][flip] == INVALID_UNUSED) {
             edge_user_pairs[eidx][flip] = uint(i);
           }
@@ -835,20 +835,20 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
           ml_prev = ml;
         }
       }
-      const MEdge *ed = orig_edges.data();
+      const MEdge *edge = orig_edges.data();
       float e[3];
-      for (i = 0; i < edges_num; i++, ed++) {
+      for (i = 0; i < edges_num; i++, edge++) {
         if (!ELEM(edge_user_pairs[i][0], INVALID_UNUSED, INVALID_PAIR) &&
             !ELEM(edge_user_pairs[i][1], INVALID_UNUSED, INVALID_PAIR)) {
           const float *n0 = poly_nors[edge_user_pairs[i][0]];
           const float *n1 = poly_nors[edge_user_pairs[i][1]];
           if (do_angle_clamp) {
             const float angle = M_PI - angle_normalized_v3v3(n0, n1);
-            vert_angs[ed->v1] = max_ff(vert_angs[ed->v1], angle);
-            vert_angs[ed->v2] = max_ff(vert_angs[ed->v2], angle);
+            vert_angs[edge->v1] = max_ff(vert_angs[edge->v1], angle);
+            vert_angs[edge->v2] = max_ff(vert_angs[edge->v2], angle);
           }
           if (do_bevel_convex) {
-            sub_v3_v3v3(e, orig_vert_positions[ed->v1], orig_vert_positions[ed->v2]);
+            sub_v3_v3v3(e, orig_vert_positions[edge->v1], orig_vert_positions[edge->v2]);
             normalize_v3(e);
             edge_angs[i] = angle_signed_on_axis_v3v3_v3(n0, n1, e);
             if (!do_rim) {
@@ -1063,10 +1063,10 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
     }
 
     /* faces */
-    MPoly *mp = &polys[polys_num * stride];
+    MPoly *poly = &polys[polys_num * stride];
     MLoop *ml = &loops[loops_num * stride];
     j = 0;
-    for (i = 0; i < newPolys; i++, mp++) {
+    for (i = 0; i < newPolys; i++, poly++) {
       uint eidx = new_edge_arr[i];
       uint pidx = edge_users[eidx];
       int k1, k2;
@@ -1085,19 +1085,19 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
       /* copy most of the face settings */
       CustomData_copy_data(
           &mesh->pdata, &result->pdata, int(pidx), int((polys_num * stride) + i), 1);
-      mp->loopstart = int(j + (loops_num * stride));
-      mp->flag = polys[pidx].flag;
+      poly->loopstart = int(j + (loops_num * stride));
+      poly->flag = polys[pidx].flag;
 
-      /* notice we use 'mp->totloop' which is later overwritten,
+      /* notice we use 'poly->totloop' which is later overwritten,
        * we could lookup the original face but there's no point since this is a copy
        * and will have the same value, just take care when changing order of assignment */
 
       /* prev loop */
-      k1 = polys[pidx].loopstart + (((edge_order[eidx] - 1) + mp->totloop) % mp->totloop);
+      k1 = polys[pidx].loopstart + (((edge_order[eidx] - 1) + poly->totloop) % poly->totloop);
 
       k2 = polys[pidx].loopstart + (edge_order[eidx]);
 
-      mp->totloop = 4;
+      poly->totloop = 4;
 
       CustomData_copy_data(&mesh->ldata, &result->ldata, k2, int((loops_num * stride) + j + 0), 1);
       CustomData_copy_data(&mesh->ldata, &result->ldata, k1, int((loops_num * stride) + j + 1), 1);
@@ -1138,8 +1138,8 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
 
       /* use the next material index if option enabled */
       if (mat_ofs_rim) {
-        dst_material_index[mp - polys.data()] += mat_ofs_rim;
-        CLAMP(dst_material_index[mp - polys.data()], 0, mat_nr_max);
+        dst_material_index[poly - polys.data()] += mat_ofs_rim;
+        CLAMP(dst_material_index[poly - polys.data()], 0, mat_nr_max);
       }
       if (crease_outer) {
         /* crease += crease_outer; without wrapping */
@@ -1171,15 +1171,15 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
 
 #ifdef SOLIDIFY_SIDE_NORMALS
     if (do_side_normals) {
-      const MEdge *ed_orig = edges.data();
+      const MEdge *edge_orig = edges.data();
       ed = &edges[edges_num * stride];
-      for (i = 0; i < rimVerts; i++, ed++, ed_orig++) {
+      for (i = 0; i < rimVerts; i++, ed++, edge_orig++) {
         float nor_cpy[3];
         int k;
 
         /* NOTE: only the first vertex (lower half of the index) is calculated. */
         BLI_assert(ed->v1 < verts_num);
-        normalize_v3_v3(nor_cpy, edge_vert_nos[ed_orig->v1]);
+        normalize_v3_v3(nor_cpy, edge_vert_nos[edge_orig->v1]);
 
         for (k = 0; k < 2; k++) { /* loop over both verts of the edge */
           copy_v3_v3(nor, mesh_vert_normals[*(&ed->v1 + k)]);
diff --git a/source/blender/modifiers/intern/MOD_solidify_nonmanifold.cc b/source/blender/modifiers/intern/MOD_solidify_nonmanifold.cc
index f2c2bb1054f..8887b0efb40 100644
--- a/source/blender/modifiers/intern/MOD_solidify_nonmanifold.cc
+++ b/source/blender/modifiers/intern/MOD_solidify_nonmanifold.cc
@@ -224,9 +224,9 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
       const MPoly &poly = orig_polys[i];
       /* Make normals for faces without area (should really be avoided though). */
       if (len_squared_v3(poly_nors[i]) < 0.5f) {
-        const MEdge *e = &orig_edges[orig_loops[poly.loopstart].e];
+        const MEdge *edge = &orig_edges[orig_loops[poly.loopstart].e];
         float edgedir[3];
-        sub_v3_v3v3(edgedir, orig_vert_positions[e->v2], orig_vert_positions[e->v1]);
+        sub_v3_v3v3(edgedir, orig_vert_positions[edge->v2], orig_vert_positions[edge->v1]);
         if (fabsf(edgedir[2]) < fabsf(edgedir[1])) {
           poly_nors[i][2] = 1.0f;
         }
@@ -373,11 +373,11 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
       uint *combined_verts = static_cast<uint *>(
           MEM_calloc_arrayN(verts_num, sizeof(*combined_verts), __func__));
 
-      const MEdge *ed = orig_edges.data();
-      for (uint i = 0; i < edges_num; i++, ed++) {
+      const MEdge *edge = orig_edges.data();
+      for (uint i = 0; i < edges_num; i++, edge++) {
         if (edge_adj_faces_len[i] > 0) {
-          uint v1 = vm[ed->v1];
-          uint v2 = vm[ed->v2];
+          uint v1 = vm[edge->v1];
+          uint v2 = vm[edge->v2];
           if (v1 == v2) {
             continue;
           }
@@ -397,12 +397,12 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
               if (k != i && edge_adj_faces_len[k] > 0 &&
                   (ELEM(vm[orig_edges[k].v1], v1, v2) != ELEM(vm[orig_edges[k].v2], v1, v2))) {
                 for (uint j = 0; j < edge_adj_faces[k]->faces_len && can_merge; j++) {
-                  const MPoly *mp = &orig_polys[edge_adj_faces[k]->faces[j]];
+                  const MPoly *poly = &orig_polys[edge_adj_faces[k]->faces[j]];
                   uint changes = 0;
-                  int cur = mp->totloop - 1;
-                  for (int next = 0; next < mp->totloop && changes <= 2; next++) {
-                    uint cur_v = vm[orig_loops[mp->loopstart + cur].v];
-                    uint next_v = vm[orig_loops[mp->loopstart + next].v];
+                  int cur = poly->totloop - 1;
+                  for (int next = 0; next < poly->totloop && changes <= 2; next++) {
+                    uint cur_v = vm[orig_loops[poly->loopstart + cur].v];
+                    uint next_v = vm[orig_loops[poly->loopstart + next].v];
                     changes += (ELEM(cur_v, v1, v2) != ELEM(next_v, v1, v2));
                     cur = next;
                   }
@@ -449,10 +449,10 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
         }
       }
       /* remove zero faces in a second pass */
-      ed = orig_edges.data();
-      for (uint i = 0; i < edges_num; i++, ed++) {
-        const uint v1 = vm[ed->v1];
-        const uint v2 = vm[ed->v2];
+      edge = orig_edges.data();
+      for (uint i = 0; i < edges_num; i++, edge++) {
+        const uint v1 = vm[edge->v1];
+        const uint v2 = vm[edge->v2];
         if (v1 == v2 && edge_adj_faces[i]) {
           /* Remove polys. */
           for (uint j = 0; j < edge_adj_faces[i]->faces_len; j++) {
@@ -493,10 +493,10 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
 
     /* Create vert_adj_edges for verts. */
     {
-      const MEdge *ed = orig_edges.data();
-      for (uint i = 0; i < edges_num; i++, ed++) {
+      const MEdge *edge = orig_edges.data();
+      for (uint i = 0; i < edges_num; i++, edge++) {
         if (edge_adj_faces_len[i] > 0) {
-          const uint vs[2] = {vm[ed->v1], vm[ed->v2]};
+          const uint vs[2] = {vm[edge->v1], vm[edge->v2]};
           uint invalid_edge_index = 0;
           bool invalid_edge_reversed = false;
           for (uint j = 0; j < 2; j++) {
@@ -613,10 +613,10 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
 
     /* Filter duplicate polys. */
     {
-      const MEdge *ed = orig_edges.data();
+      const MEdge *edge = orig_edges.data();
       /* Iterate over edges and only check the faces around an edge for duplicates
        * (performance optimization). */
-      for (uint i = 0; i < edges_num; i++, ed++) {
+      for (uint i = 0; i < edges_num; i++, edge++) {
         if (edge_adj_faces_len[i] > 0) {
           const OldEdgeFaceRef *adj_faces = edge_adj_faces[i];
           uint adj_len = adj_faces->faces_len;
@@ -724,10 +724,10 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
 
     /* Create #NewEdgeRef array. */
     {
-      const MEdge *ed = orig_edges.data();
-      for (uint i = 0; i < edges_num; i++, ed++) {
-        const uint v1 = vm[ed->v1];
-        const uint v2 = vm[ed->v2];
+      const MEdge *edge = orig_edges.data();
+      for (uint i = 0; i < edges_num; i++, edge++) {
+        const uint v1 = vm[edge->v1];
+        const uint v2 = vm[edge->v2];
         if (edge_adj_faces_len[i] > 0) {
           if (LIKELY(orig_edge_lengths[i] > FLT_EPSILON)) {
             sub_v3_v3v3(edgedir, orig_mvert_co[v2], orig_mvert_co[v1]);
@@ -1799,8 +1799,8 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
               float tmp[3];
               int k;
               for (k = 1; k + 1 < g->edges_len; k++, edge_ptr++) {
-                const MEdge *e = &orig_edges[(*edge_ptr)->old_edge];
-                sub_v3_v3v3(tmp, orig_mvert_co[vm[e->v1] == i ? e->v2 : e->v1], orig_mvert_co[i]);
+                const MEdge *edge = &orig_edges[(*edge_ptr)->old_edge];
+                sub_v3_v3v3(tmp, orig_mvert_co[vm[edge->v1] == i ? edge->v2 : edge->v1], orig_mvert_co[i]);
                 add_v3_v3(move_nor, tmp);
               }
               if (k == 1) {
diff --git a/source/blender/modifiers/intern/MOD_uvwarp.cc b/source/blender/modifiers/intern/MOD_uvwarp.cc
index 69b28883238..d30bf78eb90 100644
--- a/source/blender/modifiers/intern/MOD_uvwarp.cc
+++ b/source/blender/modifiers/intern/MOD_uvwarp.cc
@@ -97,9 +97,9 @@ static void uv_warp_compute(void *__restrict userdata,
 {
   const UVWarpData *data = static_cast<const UVWarpData *>(userdata);
 
-  const MPoly *mp = &data->polys[i];
-  const MLoop *ml = &data->loops[mp->loopstart];
-  float(*mluv)[2] = &data->mloopuv[mp->loopstart];
+  const MPoly *poly = &data->polys[i];
+  const MLoop *ml = &data->loops[poly->loopstart];
+  float(*mluv)[2] = &data->mloopuv[poly->loopstart];
 
   const MDeformVert *dvert = data->dvert;
   const int defgrp_index = data->defgrp_index;
@@ -109,7 +109,7 @@ static void uv_warp_compute(void *__restrict userdata,
   int l;
 
   if (dvert) {
-    for (l = 0; l < mp->totloop; l++, ml++, mluv++) {
+    for (l = 0; l < poly->totloop; l++, ml++, mluv++) {
       float uv[2];
       const float weight = data->invert_vgroup ?
                                1.0f - BKE_defvert_find_weight(&dvert[ml->v], defgrp_index) :
@@ -120,7 +120,7 @@ static void uv_warp_compute(void *__restrict userdata,
     }
   }
   else {
-    for (l = 0; l < mp->totloop; l++, mluv++) {
+    for (l = 0; l < poly->totloop; l++, mluv++) {
       uv_warp_from_mat4_pair(*mluv, *mluv, warp_mat);
     }
   }
diff --git a/source/blender/modifiers/intern/MOD_weighted_normal.cc b/source/blender/modifiers/intern/MOD_weighted_normal.cc
index 95cfce858a6..4db720822a5 100644
--- a/source/blender/modifiers/intern/MOD_weighted_normal.cc
+++ b/source/blender/modifiers/intern/MOD_weighted_normal.cc
@@ -106,11 +106,11 @@ struct WeightedNormalData {
  */
 static bool check_item_poly_strength(WeightedNormalData *wn_data,
                                      WeightedNormalDataAggregateItem *item_data,
-                                     const int mp_index)
+                                     const int poly_index)
 {
   BLI_assert(wn_data->poly_strength != nullptr);
 
-  const int mp_strength = wn_data->poly_strength[mp_index];
+  const int mp_strength = wn_data->poly_strength[poly_index];
 
   if (mp_strength > item_data->curr_strength) {
     item_data->curr_strength = mp_strength;
@@ -126,7 +126,7 @@ static void aggregate_item_normal(WeightedNormalModifierData *wnmd,
                                   WeightedNormalData *wn_data,
                                   WeightedNormalDataAggregateItem *item_data,
                                   const int mv_index,
-                                  const int mp_index,
+                                  const int poly_index,
                                   const float curr_val,
                                   const bool use_face_influence)
 {
@@ -149,7 +149,7 @@ static void aggregate_item_normal(WeightedNormalModifierData *wnmd,
     return;
   }
 
-  if (use_face_influence && !check_item_poly_strength(wn_data, item_data, mp_index)) {
+  if (use_face_influence && !check_item_poly_strength(wn_data, item_data, poly_index)) {
     return;
   }
 
@@ -174,7 +174,7 @@ static void aggregate_item_normal(WeightedNormalModifierData *wnmd,
                                       cached_inverse_powers_of_weight[loops_num] :
                                       1.0f / powf(weight, loops_num);
 
-  madd_v3_v3fl(item_data->normal, poly_normals[mp_index], curr_val * inverted_n_weight);
+  madd_v3_v3fl(item_data->normal, poly_normals[poly_index], curr_val * inverted_n_weight);
 }
 
 static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
@@ -289,11 +289,11 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
   switch (mode) {
     case MOD_WEIGHTEDNORMAL_MODE_FACE:
       for (const int i : polys.index_range()) {
-        const int mp_index = mode_pair[i].index;
+        const int poly_index = mode_pair[i].index;
         const float mp_val = mode_pair[i].val;
 
-        int ml_index = polys[mp_index].loopstart;
-        const int ml_index_end = ml_index + polys[mp_index].totloop;
+        int ml_index = polys[poly_index].loopstart;
+        const int ml_index_end = ml_index + polys[poly_index].totloop;
         for (; ml_index < ml_index_end; ml_index++) {
           const int mv_index = loops[ml_index].v;
           WeightedNormalDataAggregateItem *item_data =
@@ -302,7 +302,7 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
                            &items_data[mv_index];
 
           aggregate_item_normal(
-              wnmd, wn_data, item_data, mv_index, mp_index, mp_val, use_face_influence);
+              wnmd, wn_data, item_data, mv_index, poly_index, mp_val, use_face_influence);
         }
       }
       break;
@@ -312,7 +312,7 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
         const int ml_index = mode_pair[i].index;
         const float ml_val = mode_pair[i].val;
 
-        const int mp_index = loop_to_poly[ml_index];
+        const int poly_index = loop_to_poly[ml_index];
         const int mv_index = loops[ml_index].v;
         WeightedNormalDataAggregateItem *item_data =
             keep_sharp ? static_cast<WeightedNormalDataAggregateItem *>(
@@ -320,7 +320,7 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
                          &items_data[mv_index];
 
         aggregate_item_normal(
-            wnmd, wn_data, item_data, mv_index, mp_index, ml_val, use_face_influence);
+            wnmd, wn_data, item_data, mv_index, poly_index, ml_val, use_face_influence);
       }
       break;
     default:
diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_angle.cc b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_angle.cc
index 8e7d3260353..9f3a355498c 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_angle.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_angle.cc
@@ -41,8 +41,8 @@ static Array<EdgeMapEntry> create_edge_map(const Span<MPoly> polys,
   Array<EdgeMapEntry> edge_map(total_edges, {0, 0, 0});
 
   for (const int i_poly : polys.index_range()) {
-    const MPoly &mpoly = polys[i_poly];
-    for (const MLoop &loop : loops.slice(mpoly.loopstart, mpoly.totloop)) {
+    const MPoly &poly = polys[i_poly];
+    for (const MLoop &loop : loops.slice(poly.loopstart, poly.totloop)) {
       EdgeMapEntry &entry = edge_map[loop.e];
       if (entry.face_count == 0) {
         entry.face_index_1 = i_poly;
@@ -77,15 +77,15 @@ class AngleFieldInput final : public bke::MeshFieldInput {
       if (edge_map[i].face_count != 2) {
         return 0.0f;
       }
-      const MPoly &mpoly_1 = polys[edge_map[i].face_index_1];
-      const MPoly &mpoly_2 = polys[edge_map[i].face_index_2];
+      const MPoly &poly_1 = polys[edge_map[i].face_index_1];
+      const MPoly &poly_2 = polys[edge_map[i].face_index_2];
       float3 normal_1, normal_2;
-      BKE_mesh_calc_poly_normal(&mpoly_1,
-                                &loops[mpoly_1.loopstart],
+      BKE_mesh_calc_poly_normal(&poly_1,
+                                &loops[poly_1.loopstart],
                                 reinterpret_cast<const float(*)[3]>(positions.data()),
                                 normal_1);
-      BKE_mesh_calc_poly_normal(&mpoly_2,
-                                &loops[mpoly_2.loopstart],
+      BKE_mesh_calc_poly_normal(&poly_2,
+                                &loops[poly_2.loopstart],
                                 reinterpret_cast<const float(*)[3]>(positions.data()),
                                 normal_2);
       return angle_normalized_v3v3(normal_1, normal_2);
@@ -134,17 +134,17 @@ class SignedAngleFieldInput final : public bke::MeshFieldInput {
       if (edge_map[i].face_count != 2) {
         return 0.0f;
       }
-      const MPoly &mpoly_1 = polys[edge_map[i].face_index_1];
-      const MPoly &mpoly_2 = polys[edge_map[i].face_index_2];
+      const MPoly &poly_1 = polys[edge_map[i].face_index_1];
+      const MPoly &poly_2 = polys[edge_map[i].face_index_2];
 
       /* Find the normals of the 2 polys. */
       float3 poly_1_normal, poly_2_normal;
-      BKE_mesh_calc_poly_normal(&mpoly_1,
-                                &loops[mpoly_1.loopstart],
+      BKE_mesh_calc_poly_normal(&poly_1,
+                                &loops[poly_1.loopstart],
                                 reinterpret_cast<const float(*)[3]>(positions.data()),
                                 poly_1_normal);
-      BKE_mesh_calc_poly_normal(&mpoly_2,
-                                &loops[mpoly_2.loopstart],
+      BKE_mesh_calc_poly_normal(&poly_2,
+                                &loops[poly_2.loopstart],
                                 reinterpret_cast<const float(*)[3]>(positions.data()),
                                 poly_2_normal);
 
@@ -154,8 +154,8 @@ class SignedAngleFieldInput final : public bke::MeshFieldInput {
       /* Get the centerpoint of poly 2 and subtract the edge centerpoint to get a tangent
        * normal for poly 2. */
       float3 poly_center_2;
-      BKE_mesh_calc_poly_center(&mpoly_2,
-                                &loops[mpoly_2.loopstart],
+      BKE_mesh_calc_poly_center(&poly_2,
+                                &loops[poly_2.loopstart],
                                 reinterpret_cast<const float(*)[3]>(positions.data()),
                                 poly_center_2);
       const float3 poly_2_tangent = math::normalize(poly_center_2 - edge_centerpoint);
diff --git a/source/blender/nodes/geometry/nodes/node_geo_uv_pack_islands.cc b/source/blender/nodes/geometry/nodes/node_geo_uv_pack_islands.cc
index 2224abd0a65..bff3c5761ea 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_uv_pack_islands.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_uv_pack_islands.cc
@@ -57,24 +57,24 @@ static VArray<float3> construct_uv_gvarray(const Mesh &mesh,
   evaluator.evaluate();
 
   ParamHandle *handle = GEO_uv_parametrizer_construct_begin();
-  for (const int mp_index : selection) {
-    const MPoly &mp = polys[mp_index];
-    Array<ParamKey, 16> mp_vkeys(mp.totloop);
-    Array<bool, 16> mp_pin(mp.totloop);
-    Array<bool, 16> mp_select(mp.totloop);
-    Array<const float *, 16> mp_co(mp.totloop);
-    Array<float *, 16> mp_uv(mp.totloop);
-    for (const int i : IndexRange(mp.totloop)) {
-      const MLoop &ml = loops[mp.loopstart + i];
+  for (const int poly_index : selection) {
+    const MPoly &poly = polys[poly_index];
+    Array<ParamKey, 16> mp_vkeys(poly.totloop);
+    Array<bool, 16> mp_pin(poly.totloop);
+    Array<bool, 16> mp_select(poly.totloop);
+    Array<const float *, 16> mp_co(poly.totloop);
+    Array<float *, 16> mp_uv(poly.totloop);
+    for (const int i : IndexRange(poly.totloop)) {
+      const MLoop &ml = loops[poly.loopstart + i];
       mp_vkeys[i] = ml.v;
       mp_co[i] = positions[ml.v];
-      mp_uv[i] = uv[mp.loopstart + i];
+      mp_uv[i] = uv[poly.loopstart + i];
       mp_pin[i] = false;
       mp_select[i] = false;
     }
     GEO_uv_parametrizer_face_add(handle,
-                                 mp_index,
-                                 mp.totloop,
+                                 poly_index,
+                                 poly.totloop,
                                  mp_vkeys.data(),
                                  mp_co.data(),
                                  mp_uv.data(),
diff --git a/source/blender/nodes/geometry/nodes/node_geo_uv_unwrap.cc b/source/blender/nodes/geometry/nodes/node_geo_uv_unwrap.cc
index b17c41f8189..ae289979b77 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_uv_unwrap.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_uv_unwrap.cc
@@ -85,24 +85,24 @@ static VArray<float3> construct_uv_gvarray(const Mesh &mesh,
   Array<float3> uv(loops.size(), float3(0));
 
   ParamHandle *handle = GEO_uv_parametrizer_construct_begin();
-  for (const int mp_index : selection) {
-    const MPoly &mp = polys[mp_index];
-    Array<ParamKey, 16> mp_vkeys(mp.totloop);
-    Array<bool, 16> mp_pin(mp.totloop);
-    Array<bool, 16> mp_select(mp.totloop);
-    Array<const float *, 16> mp_co(mp.totloop);
-    Array<float *, 16> mp_uv(mp.totloop);
-    for (const int i : IndexRange(mp.totloop)) {
-      const MLoop &ml = loops[mp.loopstart + i];
+  for (const int poly_index : selection) {
+    const MPoly &poly = polys[poly_index];
+    Array<ParamKey, 16> mp_vkeys(poly.totloop);
+    Array<bool, 16> mp_pin(poly.totloop);
+    Array<bool, 16> mp_select(poly.totloop);
+    Array<const float *, 16> mp_co(poly.totloop);
+    Array<float *, 16> mp_uv(poly.totloop);
+    for (const int i : IndexRange(poly.totloop)) {
+      const MLoop &ml = loops[poly.loopstart + i];
       mp_vkeys[i] = ml.v;
       mp_co[i] = positions[ml.v];
-      mp_uv[i] = uv[mp.loopstart + i];
+      mp_uv[i] = uv[poly.loopstart + i];
       mp_pin[i] = false;
       mp_select[i] = false;
     }
     GEO_uv_parametrizer_face_add(handle,
-                                 mp_index,
-                                 mp.totloop,
+                                 poly_index,
+                                 poly.totloop,
                                  mp_vkeys.data(),
                                  mp_co.data(),
                                  mp_uv.data(),
diff --git a/source/blender/render/intern/bake.cc b/source/blender/render/intern/bake.cc
index ee3aa9b58b9..8aa7bbde745 100644
--- a/source/blender/render/intern/bake.cc
+++ b/source/blender/render/intern/bake.cc
@@ -503,7 +503,7 @@ static TriTessFace *mesh_calc_tri_tessface(Mesh *me, bool tangent, Mesh *me_eval
   const float(*vert_normals)[3] = BKE_mesh_vert_normals_ensure(me);
   for (i = 0; i < tottri; i++) {
     const MLoopTri *lt = &looptri[i];
-    const MPoly *mp = &polys[lt->poly];
+    const MPoly *poly = &polys[lt->poly];
 
     triangles[i].positions[0] = positions[loops[lt->tri[0]].v];
     triangles[i].positions[1] = positions[loops[lt->tri[1]].v];
@@ -511,7 +511,7 @@ static TriTessFace *mesh_calc_tri_tessface(Mesh *me, bool tangent, Mesh *me_eval
     triangles[i].vert_normals[0] = vert_normals[loops[lt->tri[0]].v];
     triangles[i].vert_normals[1] = vert_normals[loops[lt->tri[1]].v];
     triangles[i].vert_normals[2] = vert_normals[loops[lt->tri[2]].v];
-    triangles[i].is_smooth = (mp->flag & ME_SMOOTH) != 0;
+    triangles[i].is_smooth = (poly->flag & ME_SMOOTH) != 0;
 
     if (tangent) {
       triangles[i].tspace[0] = &tspace[lt->tri[0]];
@@ -527,7 +527,7 @@ static TriTessFace *mesh_calc_tri_tessface(Mesh *me, bool tangent, Mesh *me_eval
 
     if (calculate_normal) {
       if (lt->poly != mpoly_prev) {
-        BKE_mesh_calc_poly_normal(mp, &loops[mp->loopstart], positions, no);
+        BKE_mesh_calc_poly_normal(poly, &loops[poly->loopstart], positions, no);
         mpoly_prev = lt->poly;
       }
       copy_v3_v3(triangles[i].normal, no);
diff --git a/source/blender/render/intern/multires_bake.cc b/source/blender/render/intern/multires_bake.cc
index d464cdcbaae..a77bc80911e 100644
--- a/source/blender/render/intern/multires_bake.cc
+++ b/source/blender/render/intern/multires_bake.cc
@@ -62,7 +62,7 @@ struct MultiresBakeResult {
 struct MResolvePixelData {
   const float (*vert_positions)[3];
   const float (*vert_normals)[3];
-  MPoly *mpoly;
+  MPoly *polys;
   const int *material_indices;
   MLoop *mloop;
   float (*mloopuv)[2];
@@ -113,8 +113,8 @@ static void multiresbake_get_normal(const MResolvePixelData *data,
                                     float r_normal[3])
 {
   const int poly_index = data->mlooptri[tri_num].poly;
-  const MPoly *mp = &data->mpoly[poly_index];
-  const bool smoothnormal = (mp->flag & ME_SMOOTH) != 0;
+  const MPoly *poly = &data->polys[poly_index];
+  const bool smoothnormal = (poly->flag & ME_SMOOTH) != 0;
 
   if (smoothnormal) {
     const int vi = data->mloop[data->mlooptri[tri_num].tri[vert_index]].v;
@@ -125,7 +125,8 @@ static void multiresbake_get_normal(const MResolvePixelData *data,
       copy_v3_v3(r_normal, data->precomputed_normals[poly_index]);
     }
     else {
-      BKE_mesh_calc_poly_normal(mp, &data->mloop[mp->loopstart], data->vert_positions, r_normal);
+      BKE_mesh_calc_poly_normal(
+          poly, &data->mloop[poly->loopstart], data->vert_positions, r_normal);
     }
   }
 }
@@ -473,7 +474,7 @@ static void do_multires_bake(MultiresBakeRender *bkr,
   MultiresBakeQueue queue;
 
   const float(*positions)[3] = (float(*)[3])dm->getVertArray(dm);
-  MPoly *mpoly = dm->getPolyArray(dm);
+  MPoly *polys = dm->getPolyArray(dm);
   MLoop *mloop = dm->getLoopArray(dm);
   float(*mloopuv)[2] = static_cast<float(*)[2]>(dm->getLoopDataArray(dm, CD_PROP_FLOAT2));
   float *pvtangent = nullptr;
@@ -546,7 +547,7 @@ static void do_multires_bake(MultiresBakeRender *bkr,
     handle->image = ima;
     handle->queue = &queue;
 
-    handle->data.mpoly = mpoly;
+    handle->data.polys = polys;
     handle->data.material_indices = static_cast<const int *>(
         CustomData_get_layer_named(&dm->polyData, CD_PROP_INT32, "material_index"));
     handle->data.vert_positions = positions;
@@ -663,13 +664,13 @@ static void get_ccgdm_data(DerivedMesh *lodm,
   hidm->getGridKey(hidm, &key);
 
   if (lvl == 0) {
-    MPoly *mpoly;
+    MPoly *poly;
     face_side = (grid_size << 1) - 1;
 
-    mpoly = lodm->getPolyArray(lodm) + poly_index;
+    poly = lodm->getPolyArray(lodm) + poly_index;
     g_index = grid_offset[poly_index];
     S = mdisp_rot_face_to_crn(
-        mpoly, face_side, u * (face_side - 1), v * (face_side - 1), &crn_x, &crn_y);
+        poly, face_side, u * (face_side - 1), v * (face_side - 1), &crn_x, &crn_y);
   }
   else {
     /* number of faces per grid side */
@@ -712,7 +713,7 @@ static void get_ccgdm_data(DerivedMesh *lodm,
 
 static void interp_bilinear_mpoly(DerivedMesh *dm,
                                   MLoop *mloop,
-                                  MPoly *mpoly,
+                                  MPoly *poly,
                                   const float u,
                                   const float v,
                                   const int mode,
@@ -721,16 +722,16 @@ static void interp_bilinear_mpoly(DerivedMesh *dm,
   float data[4][3];
 
   if (mode == 0) {
-    dm->getVertNo(dm, mloop[mpoly->loopstart].v, data[0]);
-    dm->getVertNo(dm, mloop[mpoly->loopstart + 1].v, data[1]);
-    dm->getVertNo(dm, mloop[mpoly->loopstart + 2].v, data[2]);
-    dm->getVertNo(dm, mloop[mpoly->loopstart + 3].v, data[3]);
+    dm->getVertNo(dm, mloop[poly->loopstart].v, data[0]);
+    dm->getVertNo(dm, mloop[poly->loopstart + 1].v, data[1]);
+    dm->getVertNo(dm, mloop[poly->loopstart + 2].v, data[2]);
+    dm->getVertNo(dm, mloop[poly->loopstart + 3].v, data[3]);
   }
   else {
-    dm->getVertCo(dm, mloop[mpoly->loopstart].v, data[0]);
-    dm->getVertCo(dm, mloop[mpoly->loopstart + 1].v, data[1]);
-    dm->getVertCo(dm, mloop[mpoly->loopstart + 2].v, data[2]);
-    dm->getVertCo(dm, mloop[mpoly->loopstart + 3].v, data[3]);
+    dm->getVertCo(dm, mloop[poly->loopstart].v, data[0]);
+    dm->getVertCo(dm, mloop[poly->loopstart + 1].v, data[1]);
+    dm->getVertCo(dm, mloop[poly->loopstart + 2].v, data[2]);
+    dm->getVertCo(dm, mloop[poly->loopstart + 3].v, data[3]);
   }
 
   interp_bilinear_quad_v3(data, u, v, res);
@@ -831,7 +832,7 @@ static void apply_heights_callback(DerivedMesh *lores_dm,
 {
   const MLoopTri *lt = lores_dm->getLoopTriArray(lores_dm) + tri_index;
   MLoop *mloop = lores_dm->getLoopArray(lores_dm);
-  MPoly *mpoly = lores_dm->getPolyArray(lores_dm) + lt->poly;
+  MPoly *poly = lores_dm->getPolyArray(lores_dm) + lt->poly;
   float(*mloopuv)[2] = static_cast<float(*)[2]>(
       lores_dm->getLoopDataArray(lores_dm, CD_PROP_FLOAT2));
   MHeightBakeData *height_data = (MHeightBakeData *)bake_data;
@@ -842,11 +843,11 @@ static void apply_heights_callback(DerivedMesh *lores_dm,
 
   /* ideally we would work on triangles only, however, we rely on quads to get orthogonal
    * coordinates for use in grid space (triangle barycentric is not orthogonal) */
-  if (mpoly->totloop == 4) {
-    st0 = mloopuv[mpoly->loopstart];
-    st1 = mloopuv[mpoly->loopstart + 1];
-    st2 = mloopuv[mpoly->loopstart + 2];
-    st3 = mloopuv[mpoly->loopstart + 3];
+  if (poly->totloop == 4) {
+    st0 = mloopuv[poly->loopstart];
+    st1 = mloopuv[poly->loopstart + 1];
+    st2 = mloopuv[poly->loopstart + 2];
+    st3 = mloopuv[poly->loopstart + 3];
     resolve_quad_uv_v2(uv, st, st0, st1, st2, st3);
   }
   else {
@@ -873,9 +874,9 @@ static void apply_heights_callback(DerivedMesh *lores_dm,
                    n);
   }
   else {
-    if (mpoly->totloop == 4) {
-      interp_bilinear_mpoly(lores_dm, mloop, mpoly, uv[0], uv[1], 1, p0);
-      interp_bilinear_mpoly(lores_dm, mloop, mpoly, uv[0], uv[1], 0, n);
+    if (poly->totloop == 4) {
+      interp_bilinear_mpoly(lores_dm, mloop, poly, uv[0], uv[1], 1, p0);
+      interp_bilinear_mpoly(lores_dm, mloop, poly, uv[0], uv[1], 0, n);
     }
     else {
       interp_barycentric_mlooptri(lores_dm, mloop, lt, uv[0], uv[1], 1, p0);
@@ -946,7 +947,7 @@ static void apply_tangmat_callback(DerivedMesh *lores_dm,
                                    const int y)
 {
   const MLoopTri *lt = lores_dm->getLoopTriArray(lores_dm) + tri_index;
-  MPoly *mpoly = lores_dm->getPolyArray(lores_dm) + lt->poly;
+  MPoly *poly = lores_dm->getPolyArray(lores_dm) + lt->poly;
   float(*mloopuv)[2] = static_cast<float(*)[2]>(
       lores_dm->getLoopDataArray(lores_dm, CD_PROP_FLOAT2));
   MNormalBakeData *normal_data = (MNormalBakeData *)bake_data;
@@ -956,11 +957,11 @@ static void apply_tangmat_callback(DerivedMesh *lores_dm,
 
   /* ideally we would work on triangles only, however, we rely on quads to get orthogonal
    * coordinates for use in grid space (triangle barycentric is not orthogonal) */
-  if (mpoly->totloop == 4) {
-    st0 = mloopuv[mpoly->loopstart];
-    st1 = mloopuv[mpoly->loopstart + 1];
-    st2 = mloopuv[mpoly->loopstart + 2];
-    st3 = mloopuv[mpoly->loopstart + 3];
+  if (poly->totloop == 4) {
+    st0 = mloopuv[poly->loopstart];
+    st1 = mloopuv[poly->loopstart + 1];
+    st2 = mloopuv[poly->loopstart + 2];
+    st3 = mloopuv[poly->loopstart + 3];
     resolve_quad_uv_v2(uv, st, st0, st1, st2, st3);
   }
   else {
@@ -1208,7 +1209,7 @@ static void apply_ao_callback(DerivedMesh *lores_dm,
                               const int y)
 {
   const MLoopTri *lt = lores_dm->getLoopTriArray(lores_dm) + tri_index;
-  MPoly *mpoly = lores_dm->getPolyArray(lores_dm) + lt->poly;
+  MPoly *poly = lores_dm->getPolyArray(lores_dm) + lt->poly;
   float (*mloopuv)[2] = lores_dm->getLoopDataArray(lores_dm, CD_PROP_FLOAT2);
   MAOBakeData *ao_data = (MAOBakeData *)bake_data;
 
@@ -1223,11 +1224,11 @@ static void apply_ao_callback(DerivedMesh *lores_dm,
 
   /* ideally we would work on triangles only, however, we rely on quads to get orthogonal
    * coordinates for use in grid space (triangle barycentric is not orthogonal) */
-  if (mpoly->totloop == 4) {
-    st0 = mloopuv[mpoly->loopstart];
-    st1 = mloopuv[mpoly->loopstart + 1];
-    st2 = mloopuv[mpoly->loopstart + 2];
-    st3 = mloopuv[mpoly->loopstart + 3];
+  if (poly->totloop == 4) {
+    st0 = mloopuv[poly->loopstart];
+    st1 = mloopuv[poly->loopstart + 1];
+    st2 = mloopuv[poly->loopstart + 2];
+    st3 = mloopuv[poly->loopstart + 3];
     resolve_quad_uv_v2(uv, st, st0, st1, st2, st3);
   }
   else {
diff --git a/source/blender/render/intern/texture_margin.cc b/source/blender/render/intern/texture_margin.cc
index c353f5f8975..09761b16149 100644
--- a/source/blender/render/intern/texture_margin.cc
+++ b/source/blender/render/intern/texture_margin.cc
@@ -54,7 +54,7 @@ class TextureMarginMap {
   uint32_t value_to_store_;
   char *mask_;
 
-  MPoly const *mpoly_;
+  MPoly const *polys_;
   MLoop const *mloop_;
   float2 const *mloopuv_;
   int totpoly_;
@@ -65,7 +65,7 @@ class TextureMarginMap {
   TextureMarginMap(size_t w,
                    size_t h,
                    const float uv_offset[2],
-                   MPoly const *mpoly,
+                   MPoly const *polys,
                    MLoop const *mloop,
                    float2 const *mloopuv,
                    int totpoly,
@@ -73,7 +73,7 @@ class TextureMarginMap {
                    int totedge)
       : w_(w),
         h_(h),
-        mpoly_(mpoly),
+        polys_(polys),
         mloop_(mloop),
         mloopuv_(mloopuv),
         totpoly_(totpoly),
@@ -290,7 +290,7 @@ class TextureMarginMap {
 
   void build_tables()
   {
-    loop_to_poly_map_ = blender::bke::mesh_topology::build_loop_to_poly_map({mpoly_, totpoly_},
+    loop_to_poly_map_ = blender::bke::mesh_topology::build_loop_to_poly_map({polys_, totpoly_},
                                                                             totloop_);
 
     loop_adjacency_map_.resize(totloop_, -1);
@@ -326,8 +326,8 @@ class TextureMarginMap {
       return true;
     }
 
-    int loopstart = mpoly_[*r_start_poly].loopstart;
-    int totloop = mpoly_[*r_start_poly].totloop;
+    int loopstart = polys_[*r_start_poly].loopstart;
+    int totloop = polys_[*r_start_poly].totloop;
 
     float destx, desty;
     int foundpoly;
@@ -384,11 +384,11 @@ class TextureMarginMap {
 
     /* Find the closest edge on which the point x,y can be projected.
      */
-    for (size_t i = 0; i < mpoly_[src_poly].totloop; i++) {
-      int l1 = mpoly_[src_poly].loopstart + i;
+    for (size_t i = 0; i < polys_[src_poly].totloop; i++) {
+      int l1 = polys_[src_poly].loopstart + i;
       int l2 = l1 + 1;
-      if (l2 >= mpoly_[src_poly].loopstart + mpoly_[src_poly].totloop) {
-        l2 = mpoly_[src_poly].loopstart;
+      if (l2 >= polys_[src_poly].loopstart + polys_[src_poly].totloop) {
+        l2 = polys_[src_poly].loopstart;
       }
       /* edge points */
       float2 edgepoint1 = uv_to_xy(mloopuv_[l1]);
@@ -423,7 +423,7 @@ class TextureMarginMap {
           /* Stother_ab the info of the closest edge so far. */
           found_dist = reflectLen;
           found_t = t;
-          found_edge = i + mpoly_[src_poly].loopstart;
+          found_edge = i + polys_[src_poly].loopstart;
         }
       }
     }
@@ -448,8 +448,8 @@ class TextureMarginMap {
     }
 
     int other_edge2 = other_edge + 1;
-    if (other_edge2 >= mpoly_[dst_poly].loopstart + mpoly_[dst_poly].totloop) {
-      other_edge2 = mpoly_[dst_poly].loopstart;
+    if (other_edge2 >= polys_[dst_poly].loopstart + polys_[dst_poly].totloop) {
+      other_edge2 = polys_[dst_poly].loopstart;
     }
 
     float2 other_edgepoint1 = uv_to_xy(mloopuv_[other_edge]);
@@ -487,7 +487,7 @@ static void generate_margin(ImBuf *ibuf,
                             const float uv_offset[2])
 {
 
-  const MPoly *mpoly;
+  const MPoly *polys;
   const MLoop *mloop;
   const float2 *mloopuv;
   int totpoly, totloop, totedge;
@@ -501,7 +501,7 @@ static void generate_margin(ImBuf *ibuf,
     totpoly = me->totpoly;
     totloop = me->totloop;
     totedge = me->totedge;
-    mpoly = me->polys().data();
+    polys = me->polys().data();
     mloop = me->loops().data();
 
     if ((uv_layer == nullptr) || (uv_layer[0] == '\0')) {
@@ -516,7 +516,7 @@ static void generate_margin(ImBuf *ibuf,
     tottri = poly_to_tri_count(me->totpoly, me->totloop);
     looptri_mem = static_cast<MLoopTri *>(MEM_mallocN(sizeof(*looptri) * tottri, __func__));
     BKE_mesh_recalc_looptri(mloop,
-                            mpoly,
+                            polys,
                             reinterpret_cast<const float(*)[3]>(me->vert_positions().data()),
                             me->totloop,
                             me->totpoly,
@@ -529,7 +529,7 @@ static void generate_margin(ImBuf *ibuf,
     totpoly = dm->getNumPolys(dm);
     totedge = dm->getNumEdges(dm);
     totloop = dm->getNumLoops(dm);
-    mpoly = dm->getPolyArray(dm);
+    polys = dm->getPolyArray(dm);
     mloop = dm->getLoopArray(dm);
     mloopuv = static_cast<const float2 *>(dm->getLoopDataArray(dm, CD_PROP_FLOAT2));
 
@@ -538,7 +538,7 @@ static void generate_margin(ImBuf *ibuf,
   }
 
   TextureMarginMap map(
-      ibuf->x, ibuf->y, uv_offset, mpoly, mloop, mloopuv, totpoly, totloop, totedge);
+      ibuf->x, ibuf->y, uv_offset, polys, mloop, mloopuv, totpoly, totloop, totedge);
 
   bool draw_new_mask = false;
   /* Now the map contains 3 sorts of values: 0xFFFFFFFF for empty pixels, `0x80000000 + polyindex`