diff --git a/source/blender/blenkernel/BKE_editmesh_tangent.hh b/source/blender/blenkernel/BKE_editmesh_tangent.hh
index eb68bfd3a53..f87b335b648 100644
--- a/source/blender/blenkernel/BKE_editmesh_tangent.hh
+++ b/source/blender/blenkernel/BKE_editmesh_tangent.hh
@@ -24,7 +24,7 @@ void BKE_editmesh_loop_tangent_calc(BMEditMesh *em,
                                     const char (*tangent_names)[MAX_CUSTOMDATA_LAYER_NAME],
                                     int tangent_names_len,
                                     const float (*face_normals)[3],
-                                    const float (*loop_normals)[3],
+                                    const float (*corner_normals)[3],
                                     const float (*vert_orco)[3],
                                     CustomData *dm_loopdata_out,
                                     uint dm_loopdata_out_len,
diff --git a/source/blender/blenkernel/BKE_mesh_tangent.hh b/source/blender/blenkernel/BKE_mesh_tangent.hh
index a7848047c30..3ed972c0653 100644
--- a/source/blender/blenkernel/BKE_mesh_tangent.hh
+++ b/source/blender/blenkernel/BKE_mesh_tangent.hh
@@ -25,7 +25,7 @@ void BKE_mesh_calc_loop_tangent_single_ex(const float (*vert_positions)[3],
                                           int numVerts,
                                           const int *corner_verts,
                                           float (*r_looptangent)[4],
-                                          const float (*loop_normals)[3],
+                                          const float (*corner_normals)[3],
                                           const float (*loopuv)[2],
                                           int numLoops,
                                           blender::OffsetIndices<int> faces,
@@ -59,7 +59,7 @@ void BKE_mesh_calc_loop_tangent_ex(const float (*vert_positions)[3],
                                    int tangent_names_len,
                                    const float (*vert_normals)[3],
                                    const float (*face_normals)[3],
-                                   const float (*loop_normals)[3],
+                                   const float (*corner_normals)[3],
                                    const float (*vert_orco)[3],
                                    /* result */
                                    CustomData *loopdata_out,
diff --git a/source/blender/blenkernel/BKE_mesh_types.hh b/source/blender/blenkernel/BKE_mesh_types.hh
index 4cf9c4dae71..3148e4e3ea0 100644
--- a/source/blender/blenkernel/BKE_mesh_types.hh
+++ b/source/blender/blenkernel/BKE_mesh_types.hh
@@ -170,9 +170,9 @@ struct MeshRuntime {
 
   /** Lazily computed vertex normals (#Mesh::vert_normals()). */
   SharedCache<Vector<float3>> vert_normals_cache;
-  /** Lazily computed face normals (#Mesh::vert_normals()). */
+  /** Lazily computed face normals (#Mesh::face_normals()). */
   SharedCache<Vector<float3>> face_normals_cache;
-  /** Lazily computed face corner normals (#Mesh::vert_normals()). */
+  /** Lazily computed face corner normals (#Mesh::corner_normals()). */
   SharedCache<Vector<float3>> corner_normals_cache;
 
   /**
diff --git a/source/blender/blenkernel/intern/mesh_mirror.cc b/source/blender/blenkernel/intern/mesh_mirror.cc
index e2226bc1cea..f7c27f635ba 100644
--- a/source/blender/blenkernel/intern/mesh_mirror.cc
+++ b/source/blender/blenkernel/intern/mesh_mirror.cc
@@ -396,7 +396,7 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
   if (ob->type == OB_MESH && CustomData_has_layer(&result->corner_data, CD_CUSTOMLOOPNORMAL) &&
       result->faces_num > 0)
   {
-    blender::Array<blender::float3> loop_normals(result_corner_verts.size());
+    blender::Array<blender::float3> corner_normals(result_corner_verts.size());
     blender::short2 *clnors = static_cast<blender::short2 *>(CustomData_get_layer_for_write(
         &result->corner_data, CD_CUSTOMLOOPNORMAL, result->corners_num));
     blender::bke::mesh::CornerNormalSpaceArray lnors_spacearr;
@@ -407,7 +407,7 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
     invert_m4_m4(mtx_nor, mtx);
     transpose_m4(mtx_nor);
 
-    /* calculate custom normals into loop_normals, then mirror first half into second half */
+    /* calculate custom normals into corner_normals, then mirror first half into second half */
     const bke::AttributeAccessor attributes = result->attributes();
     const VArraySpan sharp_edges = *attributes.lookup<bool>("sharp_edge", AttrDomain::Edge);
     const VArraySpan sharp_faces = *attributes.lookup<bool>("sharp_face", AttrDomain::Face);
@@ -423,7 +423,7 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
                                              sharp_faces,
                                              clnors,
                                              &lnors_spacearr,
-                                             loop_normals);
+                                             corner_normals);
 
     /* mirroring has to account for loops being reversed in faces in second half */
     for (const int i : src_faces.index_range()) {
@@ -436,12 +436,12 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
           mirrorj += result_faces[mirror_i].size() - (j - src_face.start());
         }
 
-        copy_v3_v3(loop_normals[mirrorj], loop_normals[j]);
-        mul_m4_v3(mtx_nor, loop_normals[mirrorj]);
+        copy_v3_v3(corner_normals[mirrorj], corner_normals[j]);
+        mul_m4_v3(mtx_nor, corner_normals[mirrorj]);
 
         const int space_index = lnors_spacearr.corner_space_indices[mirrorj];
         clnors[mirrorj] = blender::bke::mesh::corner_space_custom_normal_to_data(
-            lnors_spacearr.spaces[space_index], loop_normals[mirrorj]);
+            lnors_spacearr.spaces[space_index], corner_normals[mirrorj]);
       }
     }
   }
diff --git a/source/blender/blenkernel/intern/mesh_tangent.cc b/source/blender/blenkernel/intern/mesh_tangent.cc
index a381f571d96..0709318c6f9 100644
--- a/source/blender/blenkernel/intern/mesh_tangent.cc
+++ b/source/blender/blenkernel/intern/mesh_tangent.cc
@@ -61,7 +61,7 @@ struct BKEMeshToTangent {
 
   mikk::float3 GetNormal(const uint face_num, const uint vert_num)
   {
-    return mikk::float3(loop_normals[uint(faces[face_num].start()) + vert_num]);
+    return mikk::float3(corner_normals[uint(faces[face_num].start()) + vert_num]);
   }
 
   void SetTangentSpace(const uint face_num, const uint vert_num, mikk::float3 T, bool orientation)
@@ -74,7 +74,7 @@ struct BKEMeshToTangent {
   const int *corner_verts;           /* faces vertices */
   const float (*positions)[3];       /* vertices */
   const float (*luvs)[2];            /* texture coordinates */
-  const float (*loop_normals)[3];    /* loops' normals */
+  const float (*corner_normals)[3];  /* loops' normals */
   float (*tangents)[4];              /* output tangents */
   int num_faces;                     /* number of polygons */
 };
@@ -83,7 +83,7 @@ void BKE_mesh_calc_loop_tangent_single_ex(const float (*vert_positions)[3],
                                           const int /*numVerts*/,
                                           const int *corner_verts,
                                           float (*r_looptangent)[4],
-                                          const float (*loop_normals)[3],
+                                          const float (*corner_normals)[3],
                                           const float (*loop_uvs)[2],
                                           const int /*numLoops*/,
                                           const blender::OffsetIndices<int> faces,
@@ -95,7 +95,7 @@ void BKE_mesh_calc_loop_tangent_single_ex(const float (*vert_positions)[3],
   mesh_to_tangent.corner_verts = corner_verts;
   mesh_to_tangent.positions = vert_positions;
   mesh_to_tangent.luvs = loop_uvs;
-  mesh_to_tangent.loop_normals = loop_normals;
+  mesh_to_tangent.corner_normals = corner_normals;
   mesh_to_tangent.tangents = r_looptangent;
   mesh_to_tangent.num_faces = int(faces.size());
 
@@ -401,7 +401,7 @@ void BKE_mesh_calc_loop_tangent_ex(const float (*vert_positions)[3],
                                    int tangent_names_len,
                                    const float (*vert_normals)[3],
                                    const float (*face_normals)[3],
-                                   const float (*loop_normals)[3],
+                                   const float (*corner_normals)[3],
                                    const float (*vert_orco)[3],
                                    /* result */
                                    CustomData *loopdata_out,
@@ -503,7 +503,7 @@ void BKE_mesh_calc_loop_tangent_ex(const float (*vert_positions)[3],
         mesh2tangent->sharp_faces = sharp_faces;
         /* NOTE: we assume we do have tessellated loop normals at this point
          * (in case it is object-enabled), have to check this is valid. */
-        mesh2tangent->precomputedLoopNormals = loop_normals;
+        mesh2tangent->precomputedLoopNormals = corner_normals;
         mesh2tangent->precomputedFaceNormals = face_normals;
 
         mesh2tangent->orco = nullptr;
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 de0ac167aea..ac1ecf75078 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
@@ -490,7 +490,7 @@ void mesh_render_data_update_normals(MeshRenderData &mr, const eMRDataType data_
          mr.normals_domain == bke::MeshNormalDomain::Corner) ||
         (data_flag & MR_DATA_TAN_LOOP_NOR))
     {
-      mr.loop_normals = mr.mesh->corner_normals();
+      mr.corner_normals = mr.mesh->corner_normals();
     }
   }
   else {
@@ -525,7 +525,7 @@ void mesh_render_data_update_normals(MeshRenderData &mr, const eMRDataType data_
                                 nullptr,
                                 clnors_offset,
                                 false);
-      mr.loop_normals = mr.bm_loop_normals;
+      mr.corner_normals = mr.bm_loop_normals;
     }
   }
 }
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh.hh b/source/blender/draw/intern/mesh_extractors/extract_mesh.hh
index 40a9f32f90d..9f4437ea98e 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh.hh
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh.hh
@@ -102,7 +102,7 @@ struct MeshRenderData {
   bke::MeshNormalDomain normals_domain;
   Span<float3> vert_normals;
   Span<float3> face_normals;
-  Span<float3> loop_normals;
+  Span<float3> corner_normals;
 
   VArraySpan<bool> hide_vert;
   VArraySpan<bool> hide_edge;
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 23cd25ae9b8..b7faa746438 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
@@ -42,8 +42,8 @@ static void extract_lnor_iter_face_bm(const MeshRenderData &mr,
   l_iter = l_first = BM_FACE_FIRST_LOOP(f);
   do {
     const int l_index = BM_elem_index_get(l_iter);
-    if (!mr.loop_normals.is_empty()) {
-      (*(GPUPackedNormal **)data)[l_index] = GPU_normal_convert_i10_v3(mr.loop_normals[l_index]);
+    if (!mr.corner_normals.is_empty()) {
+      (*(GPUPackedNormal **)data)[l_index] = GPU_normal_convert_i10_v3(mr.corner_normals[l_index]);
     }
     else {
       if (BM_elem_flag_test(f, BM_ELEM_SMOOTH)) {
@@ -65,8 +65,8 @@ static void extract_lnor_iter_face_mesh(const MeshRenderData &mr, const int face
   for (const int corner : mr.faces[face_index]) {
     const int vert = mr.corner_verts[corner];
     GPUPackedNormal *lnor_data = &(*(GPUPackedNormal **)data)[corner];
-    if (!mr.loop_normals.is_empty()) {
-      *lnor_data = GPU_normal_convert_i10_v3(mr.loop_normals[corner]);
+    if (!mr.corner_normals.is_empty()) {
+      *lnor_data = GPU_normal_convert_i10_v3(mr.corner_normals[corner]);
     }
     else if (mr.normals_domain == bke::MeshNormalDomain::Face ||
              (!mr.sharp_faces.is_empty() && mr.sharp_faces[face_index]))
@@ -165,8 +165,8 @@ static void extract_lnor_hq_iter_face_bm(const MeshRenderData &mr,
   l_iter = l_first = BM_FACE_FIRST_LOOP(f);
   do {
     const int l_index = BM_elem_index_get(l_iter);
-    if (!mr.loop_normals.is_empty()) {
-      normal_float_to_short_v3(&(*(gpuHQNor **)data)[l_index].x, mr.loop_normals[l_index]);
+    if (!mr.corner_normals.is_empty()) {
+      normal_float_to_short_v3(&(*(gpuHQNor **)data)[l_index].x, mr.corner_normals[l_index]);
     }
     else {
       if (BM_elem_flag_test(f, BM_ELEM_SMOOTH)) {
@@ -188,8 +188,8 @@ static void extract_lnor_hq_iter_face_mesh(const MeshRenderData &mr,
   for (const int corner : mr.faces[face_index]) {
     const int vert = mr.corner_verts[corner];
     gpuHQNor *lnor_data = &(*(gpuHQNor **)data)[corner];
-    if (!mr.loop_normals.is_empty()) {
-      normal_float_to_short_v3(&lnor_data->x, mr.loop_normals[corner]);
+    if (!mr.corner_normals.is_empty()) {
+      normal_float_to_short_v3(&lnor_data->x, mr.corner_normals[corner]);
     }
     else if (mr.normals_domain == bke::MeshNormalDomain::Face ||
              (!mr.sharp_faces.is_empty() && mr.sharp_faces[face_index]))
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_tan.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_tan.cc
index 94cd641720f..b35613f96cf 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_tan.cc
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_tan.cc
@@ -111,7 +111,7 @@ static void extract_tan_init_common(const MeshRenderData &mr,
                                      r_tangent_names,
                                      tan_len,
                                      reinterpret_cast<const float(*)[3]>(mr.face_normals.data()),
-                                     reinterpret_cast<const float(*)[3]>(mr.loop_normals.data()),
+                                     reinterpret_cast<const float(*)[3]>(mr.corner_normals.data()),
                                      orco,
                                      r_loop_data,
                                      mr.loop_len,
@@ -131,7 +131,7 @@ static void extract_tan_init_common(const MeshRenderData &mr,
                                     tan_len,
                                     reinterpret_cast<const float(*)[3]>(mr.vert_normals.data()),
                                     reinterpret_cast<const float(*)[3]>(mr.face_normals.data()),
-                                    reinterpret_cast<const float(*)[3]>(mr.loop_normals.data()),
+                                    reinterpret_cast<const float(*)[3]>(mr.corner_normals.data()),
                                     orco,
                                     r_loop_data,
                                     mr.corner_verts.size(),
diff --git a/source/blender/freestyle/intern/blender_interface/BlenderFileLoader.cpp b/source/blender/freestyle/intern/blender_interface/BlenderFileLoader.cpp
index 7b71d720e98..3d784afa4d1 100644
--- a/source/blender/freestyle/intern/blender_interface/BlenderFileLoader.cpp
+++ b/source/blender/freestyle/intern/blender_interface/BlenderFileLoader.cpp
@@ -428,7 +428,7 @@ void BlenderFileLoader::insertShapeNode(Object *ob, Mesh *mesh, int id)
   blender::bke::mesh::corner_tris_calc(
       vert_positions, mesh_polys, corner_verts, {corner_tris, tottri});
   const blender::Span<int> tri_faces = mesh->corner_tri_faces();
-  const blender::Span<blender::float3> lnors = mesh->corner_normals();
+  const blender::Span<blender::float3> corner_normals = mesh->corner_normals();
 
   // Get other mesh data
   const FreestyleEdge *fed = (const FreestyleEdge *)CustomData_get_layer(&mesh->edge_data,
@@ -546,9 +546,9 @@ void BlenderFileLoader::insertShapeNode(Object *ob, Mesh *mesh, int id)
     v3[2] += _z_offset;
 
     if (_smooth && (!sharp_faces[poly_i])) {
-      copy_v3_v3(n1, lnors[tri[0]]);
-      copy_v3_v3(n2, lnors[tri[1]]);
-      copy_v3_v3(n3, lnors[tri[2]]);
+      copy_v3_v3(n1, corner_normals[tri[0]]);
+      copy_v3_v3(n2, corner_normals[tri[1]]);
+      copy_v3_v3(n3, corner_normals[tri[2]]);
 
       mul_mat3_m4_v3(nmat, n1);
       mul_mat3_m4_v3(nmat, n2);
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 5290c4c232c..a9fc1b90ff0 100644
--- a/source/blender/io/wavefront_obj/importer/obj_import_mesh.cc
+++ b/source/blender/io/wavefront_obj/importer/obj_import_mesh.cc
@@ -372,7 +372,7 @@ void MeshFromGeometry::create_normals(Mesh *mesh)
     return;
   }
 
-  float(*loop_normals)[3] = static_cast<float(*)[3]>(
+  float(*corner_normals)[3] = static_cast<float(*)[3]>(
       MEM_malloc_arrayN(mesh_geometry_.total_loops_, sizeof(float[3]), __func__));
   int tot_loop_idx = 0;
   for (const PolyElem &curr_face : mesh_geometry_.face_elements_) {
@@ -383,12 +383,12 @@ void MeshFromGeometry::create_normals(Mesh *mesh)
       if (n_index >= 0 && n_index < global_vertices_.vert_normals.size()) {
         normal = global_vertices_.vert_normals[n_index];
       }
-      copy_v3_v3(loop_normals[tot_loop_idx], normal);
+      copy_v3_v3(corner_normals[tot_loop_idx], normal);
       tot_loop_idx++;
     }
   }
-  BKE_mesh_set_custom_normals(mesh, loop_normals);
-  MEM_freeN(loop_normals);
+  BKE_mesh_set_custom_normals(mesh, corner_normals);
+  MEM_freeN(corner_normals);
 }
 
 void MeshFromGeometry::create_colors(Mesh *mesh)
diff --git a/source/blender/io/wavefront_obj/tests/obj_importer_tests.cc b/source/blender/io/wavefront_obj/tests/obj_importer_tests.cc
index f84856c58d5..7374196ae6f 100644
--- a/source/blender/io/wavefront_obj/tests/obj_importer_tests.cc
+++ b/source/blender/io/wavefront_obj/tests/obj_importer_tests.cc
@@ -137,10 +137,10 @@ class obj_importer_test : public BlendfileLoadingBaseTest {
         const Span<float3> positions = mesh->vert_positions();
         EXPECT_V3_NEAR(positions.first(), exp.vert_first, 0.0001f);
         EXPECT_V3_NEAR(positions.last(), exp.vert_last, 0.0001f);
-        const float3 *lnors = mesh->normals_domain() == bke::MeshNormalDomain::Corner ?
-                                  mesh->corner_normals().data() :
-                                  nullptr;
-        float3 normal_first = lnors != nullptr ? lnors[0] : float3(0, 0, 0);
+        const float3 *corner_normals = mesh->normals_domain() == bke::MeshNormalDomain::Corner ?
+                                           mesh->corner_normals().data() :
+                                           nullptr;
+        float3 normal_first = corner_normals != nullptr ? corner_normals[0] : float3(0, 0, 0);
         EXPECT_V3_NEAR(normal_first, exp.normal_first, 0.0001f);
         const float2 *mloopuv = static_cast<const float2 *>(
             CustomData_get_layer(&mesh->corner_data, CD_PROP_FLOAT2));
diff --git a/source/blender/makesrna/intern/rna_mesh.cc b/source/blender/makesrna/intern/rna_mesh.cc
index a8a963c72f5..dc70ad08879 100644
--- a/source/blender/makesrna/intern/rna_mesh.cc
+++ b/source/blender/makesrna/intern/rna_mesh.cc
@@ -705,11 +705,11 @@ static void rna_MeshLoopTriangle_normal_get(PointerRNA *ptr, float *values)
 static void rna_MeshLoopTriangle_split_normals_get(PointerRNA *ptr, float *values)
 {
   Mesh *mesh = rna_mesh(ptr);
-  const blender::Span<blender::float3> loop_normals = mesh->corner_normals();
+  const blender::Span<blender::float3> corner_normals = mesh->corner_normals();
   const blender::int3 tri = *(const blender::int3 *)ptr->data;
-  copy_v3_v3(values + 0, loop_normals[tri[0]]);
-  copy_v3_v3(values + 3, loop_normals[tri[1]]);
-  copy_v3_v3(values + 6, loop_normals[tri[2]]);
+  copy_v3_v3(values + 0, corner_normals[tri[0]]);
+  copy_v3_v3(values + 3, corner_normals[tri[1]]);
+  copy_v3_v3(values + 6, corner_normals[tri[2]]);
 }
 
 static float rna_MeshLoopTriangle_area_get(PointerRNA *ptr)
diff --git a/source/blender/makesrna/intern/rna_mesh_api.cc b/source/blender/makesrna/intern/rna_mesh_api.cc
index 6a8a6d53014..b359f316bc1 100644
--- a/source/blender/makesrna/intern/rna_mesh_api.cc
+++ b/source/blender/makesrna/intern/rna_mesh_api.cc
@@ -109,7 +109,7 @@ static void rna_Mesh_normals_split_custom_set(Mesh *mesh,
                                               const float *normals,
                                               int normals_num)
 {
-  float(*loop_normals)[3] = (float(*)[3])normals;
+  float(*corner_normals)[3] = (float(*)[3])normals;
   const int numloops = mesh->corners_num;
   if (normals_num != numloops * 3) {
     BKE_reportf(reports,
@@ -120,7 +120,7 @@ static void rna_Mesh_normals_split_custom_set(Mesh *mesh,
     return;
   }
 
-  BKE_mesh_set_custom_normals(mesh, loop_normals);
+  BKE_mesh_set_custom_normals(mesh, corner_normals);
 
   DEG_id_tag_update(&mesh->id, 0);
 }
diff --git a/source/blender/modifiers/intern/MOD_multires.cc b/source/blender/modifiers/intern/MOD_multires.cc
index b71d3d85e3b..df40faf0b8f 100644
--- a/source/blender/modifiers/intern/MOD_multires.cc
+++ b/source/blender/modifiers/intern/MOD_multires.cc
@@ -260,9 +260,9 @@ static Mesh *modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh
     result = multires_as_mesh(mmd, ctx, mesh, subdiv);
 
     if (use_clnors) {
-      float(*lnors)[3] = static_cast<float(*)[3]>(
+      float(*corner_normals)[3] = static_cast<float(*)[3]>(
           CustomData_get_layer_for_write(&result->corner_data, CD_NORMAL, result->corners_num));
-      BKE_mesh_set_custom_normals(result, lnors);
+      BKE_mesh_set_custom_normals(result, corner_normals);
       CustomData_free_layers(&result->corner_data, CD_NORMAL, result->corners_num);
     }
     // BKE_subdiv_stats_print(&subdiv->stats);
diff --git a/source/blender/modifiers/intern/MOD_normal_edit.cc b/source/blender/modifiers/intern/MOD_normal_edit.cc
index 0ff4d5fa3fc..c52efe38f4d 100644
--- a/source/blender/modifiers/intern/MOD_normal_edit.cc
+++ b/source/blender/modifiers/intern/MOD_normal_edit.cc
@@ -219,7 +219,7 @@ static void normalEditModifier_do_radial(NormalEditModifierData *enmd,
                                          Object *ob,
                                          Mesh *mesh,
                                          blender::MutableSpan<blender::short2> clnors,
-                                         blender::MutableSpan<blender::float3> loop_normals,
+                                         blender::MutableSpan<blender::float3> corner_normals,
                                          const short mix_mode,
                                          const float mix_factor,
                                          const float mix_limit,
@@ -307,7 +307,7 @@ static void normalEditModifier_do_radial(NormalEditModifierData *enmd,
     }
   }
 
-  if (!loop_normals.is_empty()) {
+  if (!corner_normals.is_empty()) {
     mix_normals(mix_factor,
                 dvert,
                 defgrp_index,
@@ -316,7 +316,7 @@ static void normalEditModifier_do_radial(NormalEditModifierData *enmd,
                 mix_mode,
                 vert_positions.size(),
                 corner_verts,
-                loop_normals.data(),
+                corner_normals.data(),
                 nos.data());
   }
 
@@ -346,7 +346,7 @@ static void normalEditModifier_do_directional(NormalEditModifierData *enmd,
                                               Object *ob,
                                               Mesh *mesh,
                                               blender::MutableSpan<blender::short2> clnors,
-                                              blender::MutableSpan<blender::float3> loop_normals,
+                                              blender::MutableSpan<blender::float3> corner_normals,
                                               const short mix_mode,
                                               const float mix_factor,
                                               const float mix_limit,
@@ -413,7 +413,7 @@ static void normalEditModifier_do_directional(NormalEditModifierData *enmd,
     MEM_freeN(cos);
   }
 
-  if (!loop_normals.is_empty()) {
+  if (!corner_normals.is_empty()) {
     mix_normals(mix_factor,
                 dvert,
                 defgrp_index,
@@ -422,7 +422,7 @@ static void normalEditModifier_do_directional(NormalEditModifierData *enmd,
                 mix_mode,
                 positions.size(),
                 corner_verts,
-                loop_normals.data(),
+                corner_normals.data(),
                 nos.data());
   }
 
@@ -500,7 +500,7 @@ static Mesh *normalEditModifier_do(NormalEditModifierData *enmd,
   int defgrp_index;
   const MDeformVert *dvert;
 
-  blender::Array<blender::float3> loop_normals;
+  blender::Array<blender::float3> corner_normals;
 
   CustomData *ldata = &result->corner_data;
 
@@ -513,7 +513,7 @@ static Mesh *normalEditModifier_do(NormalEditModifierData *enmd,
   if (use_current_clnors) {
     clnors = static_cast<blender::short2 *>(
         CustomData_get_layer_for_write(ldata, CD_CUSTOMLOOPNORMAL, corner_verts.size()));
-    loop_normals.reinitialize(corner_verts.size());
+    corner_normals.reinitialize(corner_verts.size());
     const VArraySpan sharp_faces = *attributes.lookup<bool>("sharp_face", bke::AttrDomain::Face);
     blender::bke::mesh::normals_calc_corners(positions,
                                              edges,
@@ -527,7 +527,7 @@ static Mesh *normalEditModifier_do(NormalEditModifierData *enmd,
                                              sharp_faces,
                                              clnors,
                                              nullptr,
-                                             loop_normals);
+                                             corner_normals);
   }
 
   if (clnors == nullptr) {
@@ -543,7 +543,7 @@ static Mesh *normalEditModifier_do(NormalEditModifierData *enmd,
                                  ob,
                                  result,
                                  {clnors, result->corners_num},
-                                 loop_normals,
+                                 corner_normals,
                                  enmd->mix_mode,
                                  enmd->mix_factor,
                                  enmd->mix_limit,
@@ -563,7 +563,7 @@ static Mesh *normalEditModifier_do(NormalEditModifierData *enmd,
                                       ob,
                                       result,
                                       {clnors, result->corners_num},
-                                      loop_normals,
+                                      corner_normals,
                                       enmd->mix_mode,
                                       enmd->mix_factor,
                                       enmd->mix_limit,
diff --git a/source/blender/modifiers/intern/MOD_triangulate.cc b/source/blender/modifiers/intern/MOD_triangulate.cc
index d7077735b02..c5f414f4669 100644
--- a/source/blender/modifiers/intern/MOD_triangulate.cc
+++ b/source/blender/modifiers/intern/MOD_triangulate.cc
@@ -72,9 +72,9 @@ static Mesh *triangulate_mesh(Mesh *mesh,
   BM_mesh_free(bm);
 
   if (keep_clnors) {
-    float(*lnors)[3] = static_cast<float(*)[3]>(
+    float(*corner_normals)[3] = static_cast<float(*)[3]>(
         CustomData_get_layer_for_write(&result->corner_data, CD_NORMAL, result->corners_num));
-    BKE_mesh_set_custom_normals(result, lnors);
+    BKE_mesh_set_custom_normals(result, corner_normals);
     CustomData_free_layers(&result->corner_data, CD_NORMAL, result->corners_num);
   }
 
diff --git a/source/blender/modifiers/intern/MOD_weighted_normal.cc b/source/blender/modifiers/intern/MOD_weighted_normal.cc
index 9ec97fde184..6799585771f 100644
--- a/source/blender/modifiers/intern/MOD_weighted_normal.cc
+++ b/source/blender/modifiers/intern/MOD_weighted_normal.cc
@@ -214,13 +214,13 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
                                   face_strength != nullptr;
   const bool has_vgroup = dvert != nullptr;
 
-  blender::Array<blender::float3> loop_normals;
+  blender::Array<blender::float3> corner_normals;
 
   Array<WeightedNormalDataAggregateItem> items_data;
   if (keep_sharp) {
     /* This will give us loop normal spaces,
-     * we do not actually care about computed loop_normals for now... */
-    loop_normals.reinitialize(corner_verts.size());
+     * we do not actually care about computed corner_normals for now... */
+    corner_normals.reinitialize(corner_verts.size());
     bke::mesh::normals_calc_corners(positions,
                                     edges,
                                     faces,
@@ -233,7 +233,7 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
                                     wn_data->sharp_faces,
                                     has_clnors ? clnors.data() : nullptr,
                                     &lnors_spacearr,
-                                    loop_normals);
+                                    corner_normals);
 
     WeightedNormalDataAggregateItem start_item{};
     start_item.curr_strength = FACE_STRENGTH_WEAK;
@@ -295,14 +295,14 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
 
   if (keep_sharp) {
     /* Set loop normals for normal computed for each lnor space (smooth fan).
-     * Note that loop_normals is already populated with clnors
+     * Note that corner_normals is already populated with clnors
      * (before this modifier is applied, at start of this function),
      * so no need to recompute them here. */
     for (int corner = 0; corner < corner_verts.size(); corner++) {
       const int space_index = lnors_spacearr.corner_space_indices[corner];
       WeightedNormalDataAggregateItem *item_data = &items_data[space_index];
       if (!is_zero_v3(item_data->normal)) {
-        copy_v3_v3(loop_normals[corner], item_data->normal);
+        copy_v3_v3(corner_normals[corner], item_data->normal);
       }
     }
 
@@ -315,7 +315,7 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
                                                   face_normals,
                                                   wn_data->sharp_faces,
                                                   wn_data->sharp_edges,
-                                                  loop_normals,
+                                                  corner_normals,
                                                   clnors);
   }
   else {
@@ -348,7 +348,7 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
                                                                clnors);
     }
     else {
-      loop_normals.reinitialize(corner_verts.size());
+      corner_normals.reinitialize(corner_verts.size());
       blender::bke::mesh::normals_calc_corners(positions,
                                                edges,
                                                faces,
@@ -361,12 +361,12 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
                                                wn_data->sharp_faces,
                                                has_clnors ? clnors.data() : nullptr,
                                                nullptr,
-                                               loop_normals);
+                                               corner_normals);
 
       for (int corner = 0; corner < corner_verts.size(); corner++) {
         const int item_index = corner_verts[corner];
         if (!is_zero_v3(items_data[item_index].normal)) {
-          copy_v3_v3(loop_normals[corner], items_data[item_index].normal);
+          copy_v3_v3(corner_normals[corner], items_data[item_index].normal);
         }
       }
       blender::bke::mesh::normals_corner_custom_set(positions,
@@ -378,7 +378,7 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
                                                     face_normals,
                                                     wn_data->sharp_faces,
                                                     wn_data->sharp_edges,
-                                                    loop_normals,
+                                                    corner_normals,
                                                     clnors);
     }
   }