Cleanup: renaming mostly, plus some const qualifiers etc.

4 files changed, 180 insertions, 180 deletions

diff --git a/source/blender/bmesh/intern/bmesh_mesh.c b/source/blender/bmesh/intern/bmesh_mesh.c
index ab6ac9edef4..99582089bde 100644
--- a/source/blender/bmesh/intern/bmesh_mesh.c
+++ b/source/blender/bmesh/intern/bmesh_mesh.c
@@ -1330,7 +1330,7 @@ static int bm_loop_normal_mark_indiv(BMesh *bm, BLI_bitmap *loops)
 	return totloopsel;
 }
 
-static void InitTransDataNormal(BMesh *bm, BMLoopNorEditData *tld, BMVert *v, BMLoop *l, const int offset)
+static void loop_normal_editdata_init(BMesh *bm, BMLoopNorEditData *lnor_ed, BMVert *v, BMLoop *l, const int offset)
 {
 	BLI_assert(bm->lnor_spacearr != NULL);
 	BLI_assert(bm->lnor_spacearr->lspacearr != NULL);
@@ -1338,25 +1338,25 @@ static void InitTransDataNormal(BMesh *bm, BMLoopNorEditData *tld, BMVert *v, BM
 	const int l_index = BM_elem_index_get(l);
 	short *clnors_data = BM_ELEM_CD_GET_VOID_P(l, offset);
 
-	tld->loop_index = l_index;
-	tld->loop = l;
+	lnor_ed->loop_index = l_index;
+	lnor_ed->loop = l;
 
 	float custom_normal[3];
 	BKE_lnor_space_custom_data_to_normal(bm->lnor_spacearr->lspacearr[l_index], clnors_data, custom_normal);
 
-	tld->clnors_data = clnors_data;
-	copy_v3_v3(tld->nloc, custom_normal);
-	copy_v3_v3(tld->niloc, custom_normal);
+	lnor_ed->clnors_data = clnors_data;
+	copy_v3_v3(lnor_ed->nloc, custom_normal);
+	copy_v3_v3(lnor_ed->niloc, custom_normal);
 
 	if (v) {
-		tld->loc = v->co;
+		lnor_ed->loc = v->co;
 	}
 	else {
-		tld->loc = NULL;
+		lnor_ed->loc = NULL;
 	}
 }
 
-BMLoopNorEditDataArray *BM_loop_normal_editdata_init(BMesh *bm)
+BMLoopNorEditDataArray *BM_loop_normal_editdata_array_init(BMesh *bm)
 {
 	BMLoop *l;
 	BMVert *v;
@@ -1369,8 +1369,8 @@ BMLoopNorEditDataArray *BM_loop_normal_editdata_init(BMesh *bm)
 
 	BLI_assert(bm->spacearr_dirty == 0);
 
-	BMLoopNorEditDataArray *ld = MEM_mallocN(sizeof(*ld), __func__);
-	ld->lidx_to_lnor_editdata = MEM_callocN(sizeof(*ld->lidx_to_lnor_editdata) * bm->totloop, __func__);
+	BMLoopNorEditDataArray *lnors_ed_arr = MEM_mallocN(sizeof(*lnors_ed_arr), __func__);
+	lnors_ed_arr->lidx_to_lnor_editdata = MEM_callocN(sizeof(*lnors_ed_arr->lidx_to_lnor_editdata) * bm->totloop, __func__);
 
 	if (!CustomData_has_layer(&bm->ldata, CD_CUSTOMLOOPNORMAL)) {
 		BM_data_layer_add(bm, &bm->ldata, CD_CUSTOMLOOPNORMAL);
@@ -1386,45 +1386,45 @@ BMLoopNorEditDataArray *BM_loop_normal_editdata_init(BMesh *bm)
 	}
 
 	if (totloopsel) {
-		BMLoopNorEditData *tld = ld->lnor_editdata = MEM_mallocN(sizeof(*tld) * totloopsel, __func__);
+		BMLoopNorEditData *lnor_ed = lnors_ed_arr->lnor_editdata = MEM_mallocN(sizeof(*lnor_ed) * totloopsel, __func__);
 
 		BM_ITER_MESH(v, &viter, bm, BM_VERTS_OF_MESH) {
 			BM_ITER_ELEM(l, &liter, v, BM_LOOPS_OF_VERT) {
 				if (BLI_BITMAP_TEST(loops, BM_elem_index_get(l))) {
-					InitTransDataNormal(bm, tld, v, l, cd_custom_normal_offset);
-					ld->lidx_to_lnor_editdata[BM_elem_index_get(l)] = tld;
-					tld++;
+					loop_normal_editdata_init(bm, lnor_ed, v, l, cd_custom_normal_offset);
+					lnors_ed_arr->lidx_to_lnor_editdata[BM_elem_index_get(l)] = lnor_ed;
+					lnor_ed++;
 				}
 			}
 		}
-		ld->totloop = totloopsel;
+		lnors_ed_arr->totloop = totloopsel;
 	}
 	else {  /* If multiple selection modes are inactive OR no such loop is found, fall back to editing all loops. */
 		totloopsel = BM_total_loop_select(bm);
-		BMLoopNorEditData *tld = ld->lnor_editdata = MEM_mallocN(sizeof(*tld) * totloopsel, __func__);
+		BMLoopNorEditData *tld = lnors_ed_arr->lnor_editdata = MEM_mallocN(sizeof(*tld) * totloopsel, __func__);
 
 		BM_ITER_MESH(v, &viter, bm, BM_VERTS_OF_MESH) {
 			if (BM_elem_flag_test(v, BM_ELEM_SELECT)) {
 				BM_ITER_ELEM(l, &liter, v, BM_LOOPS_OF_VERT) {
-					InitTransDataNormal(bm, tld, v, l, cd_custom_normal_offset);
-					ld->lidx_to_lnor_editdata[BM_elem_index_get(l)] = tld;
+					loop_normal_editdata_init(bm, tld, v, l, cd_custom_normal_offset);
+					lnors_ed_arr->lidx_to_lnor_editdata[BM_elem_index_get(l)] = tld;
 					tld++;
 				}
 			}
 		}
-		ld->totloop = totloopsel;
+		lnors_ed_arr->totloop = totloopsel;
 	}
 
 	MEM_freeN(loops);
-	ld->cd_custom_normal_offset = cd_custom_normal_offset;
-	return ld;
+	lnors_ed_arr->cd_custom_normal_offset = cd_custom_normal_offset;
+	return lnors_ed_arr;
 }
 
-void BM_loop_normal_editdata_free(BMLoopNorEditDataArray *ld)
+void BM_loop_normal_editdata_array_free(BMLoopNorEditDataArray *lnors_ed_arr)
 {
-	MEM_SAFE_FREE(ld->lnor_editdata);
-	MEM_SAFE_FREE(ld->lidx_to_lnor_editdata);
-	MEM_freeN(ld);
+	MEM_SAFE_FREE(lnors_ed_arr->lnor_editdata);
+	MEM_SAFE_FREE(lnors_ed_arr->lidx_to_lnor_editdata);
+	MEM_freeN(lnors_ed_arr);
 }
 
 int BM_total_loop_select(BMesh *bm)
diff --git a/source/blender/bmesh/intern/bmesh_mesh.h b/source/blender/bmesh/intern/bmesh_mesh.h
index 98439c8b4a1..51f58a7f44c 100644
--- a/source/blender/bmesh/intern/bmesh_mesh.h
+++ b/source/blender/bmesh/intern/bmesh_mesh.h
@@ -64,12 +64,10 @@ void BM_lnorspace_err(BMesh *bm);
 #endif
 
 /* Loop Generics */
-struct BMLoopNorEditDataArray *BM_loop_normal_editdata_init(BMesh *bm);
-void BM_loop_normal_editdata_free(struct BMLoopNorEditDataArray *ld);
+struct BMLoopNorEditDataArray *BM_loop_normal_editdata_array_init(BMesh *bm);
+void BM_loop_normal_editdata_array_free(struct BMLoopNorEditDataArray *lnors_ed_arr);
 int BM_total_loop_select(BMesh *bm);
 
-bool BM_loop_check_cyclic_smooth_fan(BMLoop *l_curr);
-
 
 void BM_edges_sharp_from_angle_set(BMesh *bm, const float split_angle);
 
diff --git a/source/blender/editors/mesh/editmesh_tools.c b/source/blender/editors/mesh/editmesh_tools.c
index 9fc89ba7f42..79adba36302 100644
--- a/source/blender/editors/mesh/editmesh_tools.c
+++ b/source/blender/editors/mesh/editmesh_tools.c
@@ -5995,34 +5995,34 @@ void MESH_OT_mark_freestyle_face(wmOperatorType *ot)
 #endif
 
 /* Initialize loop normal data */
-static int init_point_normals(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
+static int point_normals_init(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
 {
 	Object *obedit = CTX_data_edit_object(C);
 	BMEditMesh *em = BKE_editmesh_from_object(obedit);
 	BMesh *bm = em->bm;
 
 	BKE_editmesh_lnorspace_update(em);
-	BMLoopNorEditDataArray *ld = BM_loop_normal_editdata_init(bm);
+	BMLoopNorEditDataArray *lnors_ed_arr = BM_loop_normal_editdata_array_init(bm);
 
-	ld->funcdata = NULL;
-	op->customdata = ld;
+	lnors_ed_arr->funcdata = NULL;
+	op->customdata = lnors_ed_arr;
 
-	return ld->totloop;
+	return lnors_ed_arr->totloop;
 }
 
-static void apply_point_normals(bContext *C, wmOperator *op, const wmEvent *UNUSED(event), float target[3])
+static void point_normals_apply(bContext *C, wmOperator *op, const wmEvent *UNUSED(event), float target[3])
 {
 	Object *obedit = CTX_data_edit_object(C);
 	BMesh *bm = BKE_editmesh_from_object(obedit)->bm;
-	BMLoopNorEditDataArray *ld = op->customdata;
-	BMLoopNorEditData *tld = ld->lnor_editdata;
+	BMLoopNorEditDataArray *lnors_ed_arr = op->customdata;
 
-	const bool point_away = RNA_boolean_get(op->ptr, "point_away");
-	const bool spherize = RNA_boolean_get(op->ptr, "spherize");
-	const bool align = RNA_boolean_get(op->ptr, "align");
-	float zero[3] = { 0.0f }, center[3];
+	const bool do_point_away = RNA_boolean_get(op->ptr, "point_away");
+	const bool do_spherize = RNA_boolean_get(op->ptr, "spherize");
+	const bool do_align = RNA_boolean_get(op->ptr, "align");
+	const float null_vec[3] = { 0.0f };
+	float center[3];
 
-	if (align) {
+	if (do_align) {
 		BMVert *v;
 		BMIter viter;
 		int i = 0;
@@ -6036,40 +6036,42 @@ static void apply_point_normals(bContext *C, wmOperator *op, const wmEvent *UNUS
 		mul_v3_fl(center, 1.0f / (float)i);
 	}
 
-	for (int i = 0; i < ld->totloop; i++, tld++) {
-		if (spherize) {
-			float strength = RNA_float_get(op->ptr, "strength");
+	BMLoopNorEditData *lnor_ed = lnors_ed_arr->lnor_editdata;
+	for (int i = 0; i < lnors_ed_arr->totloop; i++, lnor_ed++) {
+		if (do_spherize) {
+			const float strength = RNA_float_get(op->ptr, "strength");
 			float spherized_normal[3] = { 0.0f };
 
-			sub_v3_v3v3(spherized_normal, target, tld->loc);
+			sub_v3_v3v3(spherized_normal, target, lnor_ed->loc);
 			sub_v3_v3(spherized_normal, obedit->loc);
 			mul_v3_fl(spherized_normal, strength);
-			mul_v3_fl(tld->nloc, 1.0f - strength);
-			sub_v3_v3(tld->nloc, spherized_normal);
+			mul_v3_fl(lnor_ed->nloc, 1.0f - strength);
+			sub_v3_v3(lnor_ed->nloc, spherized_normal);
 		}
-		else if (align) {
-			sub_v3_v3v3(tld->nloc, target, center);
-			sub_v3_v3(tld->nloc, obedit->loc);
+		else if (do_align) {
+			sub_v3_v3v3(lnor_ed->nloc, target, center);
+			sub_v3_v3(lnor_ed->nloc, obedit->loc);
 		}
 		else {
-			sub_v3_v3v3(tld->nloc, target, tld->loc);
-			sub_v3_v3(tld->nloc, obedit->loc);
+			sub_v3_v3v3(lnor_ed->nloc, target, lnor_ed->loc);
+			sub_v3_v3(lnor_ed->nloc, obedit->loc);
 		}
 
-		if (point_away) {
-			negate_v3(tld->nloc);
+		if (do_point_away) {
+			negate_v3(lnor_ed->nloc);
 		}
-		if (tld->loop_index != -1 && !compare_v3v3(tld->nloc, zero, 1e-4f)) {
-			normalize_v3(tld->nloc);
-			BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[tld->loop_index], tld->nloc, tld->clnors_data);
+		if (lnor_ed->loop_index != -1 && !compare_v3v3(lnor_ed->nloc, null_vec, 1e-4f)) {
+			normalize_v3(lnor_ed->nloc);
+			BKE_lnor_space_custom_normal_to_data(
+			            bm->lnor_spacearr->lspacearr[lnor_ed->loop_index], lnor_ed->nloc, lnor_ed->clnors_data);
 		}
 	}
 }
 
 static void point_normals_free(bContext *C, wmOperator *op)
 {
-	BMLoopNorEditDataArray *ld = op->customdata;
-	BM_loop_normal_editdata_free(ld);
+	BMLoopNorEditDataArray *lnors_ed_arr = op->customdata;
+	BM_loop_normal_editdata_array_free(lnors_ed_arr);
 	op->customdata = NULL;
 	ED_area_headerprint(CTX_wm_area(C), NULL);
 }
@@ -6101,7 +6103,7 @@ static int point_normals_mouse(bContext *C, wmOperator *op, const wmEvent *event
 
 	ED_view3d_win_to_3d_int(v3d, ar, center, event->mval, target);
 
-	apply_point_normals(C, op, event, target);
+	point_normals_apply(C, op, event, target);
 	EDBM_update_generic(em, true, false);
 
 	if (event->type == LEFTMOUSE) {
@@ -6110,11 +6112,14 @@ static int point_normals_mouse(bContext *C, wmOperator *op, const wmEvent *event
 		return OPERATOR_FINISHED;
 	}
 	else if ((ISKEYBOARD(event->type) || event->type == RIGHTMOUSE) && event->type != MKEY) {
-		BMLoopNorEditDataArray *ld = op->customdata;
-		BMLoopNorEditData *tld = ld->lnor_editdata;
+		BMLoopNorEditDataArray *lnors_ed_arr = op->customdata;
 
-		for (i = 0; i < ld->totloop; i++, tld++) {  /* Reset custom normal data. */
-			BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[tld->loop_index], tld->niloc, tld->clnors_data);
+		BMLoopNorEditData *lnor_ed = lnors_ed_arr->lnor_editdata;
+		for (i = 0; i < lnors_ed_arr->totloop; i++, lnor_ed++) {  /* Reset custom normal data. */
+			if (lnor_ed->loop_index != -1) {
+				BKE_lnor_space_custom_normal_to_data(
+				            bm->lnor_spacearr->lspacearr[lnor_ed->loop_index], lnor_ed->niloc, lnor_ed->clnors_data);
+			}
 		}
 		point_normals_free(C, op);
 		return OPERATOR_CANCELLED;
@@ -6132,36 +6137,36 @@ static int edbm_point_normals_modal(bContext *C, wmOperator *op, const wmEvent *
 	float target[3];
 
 	bool handled = false;
-	PropertyRNA *prop = RNA_struct_find_property(op->ptr, "target_location");
-	BMLoopNorEditDataArray *ld = op->customdata;
+	PropertyRNA *prop_target = RNA_struct_find_property(op->ptr, "target_location");
+	BMLoopNorEditDataArray *lnors_ed_arr = op->customdata;
 
-	if (ld->funcdata) {  /* Executes and transfers control to point_normals_mouse. */
-		int(*apply)(bContext *, wmOperator *, const wmEvent *);
-		apply = ld->funcdata;
+	if (lnors_ed_arr->funcdata) {  /* Executes and transfers control to point_normals_mouse. */
+		int (*apply)(bContext *, wmOperator *, const wmEvent *);
+		apply = lnors_ed_arr->funcdata;
 		return apply(C, op, event);
 	}
 
 	if (event->val == KM_PRESS) {
 		BMVert *v;
 		BMIter viter;
-		
+
 		if (event->type == LEFTMOUSE) {
 			ED_view3d_cursor3d_update(C, event->mval);
 			copy_v3_v3(target, ED_view3d_cursor3d_get(scene, v3d));
-			RNA_property_float_set_array(op->ptr, prop, target);
+			RNA_property_float_set_array(op->ptr, prop_target, target);
 
 			handled = true;
 		}
 		if (event->type == RIGHTMOUSE) {
 			view3d_operator_needs_opengl(C);
-			bool retval = EDBM_select_pick(C, event->mval, false, false, false);
+			const bool retval = EDBM_select_pick(C, event->mval, false, false, false);
 			if (!retval) {
 				point_normals_free(C, op);
 				return OPERATOR_CANCELLED;
 			}
-			ED_object_editmode_calc_active_center(obedit, false, target);	/* Point to newly selected active */
+			ED_object_editmode_calc_active_center(obedit, false, target);  /* Point to newly selected active */
 			add_v3_v3(target, obedit->loc);
-			RNA_property_float_set_array(op->ptr, prop, target);
+			RNA_property_float_set_array(op->ptr, prop_target, target);
 			handled = true;
 		}
 		else if (event->type == LKEY) {
@@ -6184,7 +6189,7 @@ static int edbm_point_normals_modal(bContext *C, wmOperator *op, const wmEvent *
 					}
 					mid_v3_v3v3(target, min, max);
 					add_v3_v3(target, obedit->loc);
-					RNA_property_float_set_array(op->ptr, prop, target);
+					RNA_property_float_set_array(op->ptr, prop_target, target);
 					break;
 				}
 
@@ -6200,13 +6205,13 @@ static int edbm_point_normals_modal(bContext *C, wmOperator *op, const wmEvent *
 						}
 					}
 					mul_v3_fl(target, 1.0f / (float)i);
-					RNA_property_float_set_array(op->ptr, prop, target);
+					RNA_property_float_set_array(op->ptr, prop_target, target);
 					break;
 				}
 
 				case V3D_AROUND_CURSOR:
 					copy_v3_v3(target, ED_view3d_cursor3d_get(scene, v3d));
-					RNA_property_float_set_array(op->ptr, prop, target);
+					RNA_property_float_set_array(op->ptr, prop_target, target);
 					break;
 
 				case V3D_AROUND_ACTIVE:
@@ -6215,7 +6220,7 @@ static int edbm_point_normals_modal(bContext *C, wmOperator *op, const wmEvent *
 						return OPERATOR_CANCELLED;
 					}
 					add_v3_v3(target, obedit->loc);
-					RNA_property_float_set_array(op->ptr, prop, target);
+					RNA_property_float_set_array(op->ptr, prop_target, target);
 					break;
 
 				default:
@@ -6226,7 +6231,7 @@ static int edbm_point_normals_modal(bContext *C, wmOperator *op, const wmEvent *
 			handled = true;
 		}
 		else if (event->type == MKEY) {
-			ld->funcdata = point_normals_mouse;
+			lnors_ed_arr->funcdata = point_normals_mouse;
 			char header[UI_MAX_DRAW_STR];
 			BLI_snprintf(header, sizeof(header), IFACE_("Left Click to Confirm, Right click to Cancel"));
 
@@ -6234,7 +6239,7 @@ static int edbm_point_normals_modal(bContext *C, wmOperator *op, const wmEvent *
 		}
 		else if (event->type == OKEY) {
 			copy_v3_v3(target, obedit->loc);
-			RNA_property_float_set_array(op->ptr, prop, target);
+			RNA_property_float_set_array(op->ptr, prop_target, target);
 			handled = true;
 		}
 		else if (ISKEYBOARD(event->type) && event->type != RIGHTALTKEY) {
@@ -6244,12 +6249,11 @@ static int edbm_point_normals_modal(bContext *C, wmOperator *op, const wmEvent *
 	}
 	
 	if (handled || event->type == RIGHTMOUSE) {
-		prop = RNA_struct_find_property(op->ptr, "align");
-		RNA_property_boolean_set(op->ptr, prop, false);
+		RNA_boolean_set(op->ptr, "align", false);
 	}
 
 	if (handled) {
-		apply_point_normals(C, op, event, target);
+		point_normals_apply(C, op, event, target);
 		EDBM_update_generic(em, true, false);  /* Recheck bools. */
 		point_normals_free(C, op);
 
@@ -6261,7 +6265,7 @@ static int edbm_point_normals_modal(bContext *C, wmOperator *op, const wmEvent *
 
 static int edbm_point_normals_invoke(bContext *C, wmOperator *op, const wmEvent *event)
 {
-	if (!init_point_normals(C, op, event)) {
+	if (!point_normals_init(C, op, event)) {
 		point_normals_free(C, op);
 		return OPERATOR_CANCELLED;
 	}
@@ -6284,17 +6288,15 @@ static int edbm_point_normals_exec(bContext *C, wmOperator *op)
 	Object *obedit = CTX_data_edit_object(C);
 	BMEditMesh *em = BKE_editmesh_from_object(obedit);
 
-	PropertyRNA *prop;
-
-	if (!init_point_normals(C, op, NULL)) {
+	if (!point_normals_init(C, op, NULL)) {
 		point_normals_free(C, op);
 		return OPERATOR_CANCELLED;
 	}
+
 	float target[3];
+	RNA_float_get_array(op->ptr, "target_location", target);
 
-	prop = RNA_struct_find_property(op->ptr, "target_location");
-	RNA_property_float_get_array(op->ptr, prop, target);
-	apply_point_normals(C, op, NULL, target);
+	point_normals_apply(C, op, NULL, target);
 
 	EDBM_update_generic(em, true, false);
 	point_normals_free(C, op);
@@ -6396,13 +6398,13 @@ static void custom_loops_tag(BMesh *bm, const bool do_edges)
 	bm->elem_index_dirty &= ~(BM_FACE | BM_LOOP);
 }
 
-static void merge_loop(bContext *C, BMLoopNorEditDataArray *ld)
+static void loop_normal_merge(bContext *C, BMLoopNorEditDataArray *lnors_ed_arr)
 {
 	Object *obedit = CTX_data_edit_object(C);
 	BMEditMesh *em = BKE_editmesh_from_object(obedit);
 	BMesh *bm = em->bm;
 
-	BMLoopNorEditData *tld = ld->lnor_editdata;
+	BMLoopNorEditData *lnor_ed = lnors_ed_arr->lnor_editdata;
 
 	BLI_SMALLSTACK_DECLARE(clnors, short *);
 
@@ -6410,12 +6412,12 @@ static void merge_loop(bContext *C, BMLoopNorEditDataArray *ld)
 
 	custom_loops_tag(bm, false);
 
-	for (int i = 0; i < ld->totloop; i++, tld++) {
-		if (BM_elem_flag_test(tld->loop, BM_ELEM_TAG)) {
+	for (int i = 0; i < lnors_ed_arr->totloop; i++, lnor_ed++) {
+		if (BM_elem_flag_test(lnor_ed->loop, BM_ELEM_TAG)) {
 			continue;
 		}
 
-		MLoopNorSpace *lnor_space = bm->lnor_spacearr->lspacearr[tld->loop_index];
+		MLoopNorSpace *lnor_space = bm->lnor_spacearr->lspacearr[lnor_ed->loop_index];
 
 		if ((lnor_space->flags & MLNOR_SPACE_IS_SINGLE) == 0) {
 			LinkNode *loops = lnor_space->loops;
@@ -6426,10 +6428,10 @@ static void merge_loop(bContext *C, BMLoopNorEditDataArray *ld)
 				BMLoop *l = loops->link;
 				const int loop_index = BM_elem_index_get(l);
 
-				BMLoopNorEditData *temp = ld->lidx_to_lnor_editdata[loop_index];
-				BLI_assert(temp->loop_index == loop_index && temp->loop == l);
-				add_v3_v3(avg_normal, temp->nloc);
-				BLI_SMALLSTACK_PUSH(clnors, temp->clnors_data);
+				BMLoopNorEditData *lnor_ed_tmp = lnors_ed_arr->lidx_to_lnor_editdata[loop_index];
+				BLI_assert(lnor_ed_tmp->loop_index == loop_index && lnor_ed_tmp->loop == l);
+				add_v3_v3(avg_normal, lnor_ed_tmp->nloc);
+				BLI_SMALLSTACK_PUSH(clnors, lnor_ed_tmp->clnors_data);
 				BM_elem_flag_enable(l, BM_ELEM_TAG);
 			}
 			if (len_squared_v3(avg_normal) < 1e-4f) {  /* If avg normal is nearly 0, set clnor to default value. */
@@ -6447,7 +6449,7 @@ static void merge_loop(bContext *C, BMLoopNorEditDataArray *ld)
 	}
 }
 
-static void split_loop(bContext *C)
+static void loop_normla_split(bContext *C)
 {
 	Object *obedit = CTX_data_edit_object(C);
 	BMEditMesh *em = BKE_editmesh_from_object(obedit);
@@ -6460,7 +6462,7 @@ static void split_loop(bContext *C)
 
 	custom_loops_tag(bm, true);
 
-	int cd_clnors_offset = CustomData_get_offset(&bm->ldata, CD_CUSTOMLOOPNORMAL);
+	const int cd_clnors_offset = CustomData_get_offset(&bm->ldata, CD_CUSTOMLOOPNORMAL);
 	BM_ITER_MESH(f, &fiter, bm, BM_FACES_OF_MESH) {
 		l_curr = l_first = BM_FACE_FIRST_LOOP(f);
 		do {
@@ -6512,7 +6514,7 @@ static void split_loop(bContext *C)
 	}
 }
 
-static int split_merge_loop_normals(bContext *C, const bool do_merge)
+static int loop_normals_split_merge(bContext *C, const bool do_merge)
 {
 	Object *obedit = CTX_data_edit_object(C);
 	BMEditMesh *em = BKE_editmesh_from_object(obedit);
@@ -6522,7 +6524,7 @@ static int split_merge_loop_normals(bContext *C, const bool do_merge)
 
 	BKE_editmesh_lnorspace_update(em);
 
-	BMLoopNorEditDataArray *ld = do_merge ? BM_loop_normal_editdata_init(bm) : NULL;
+	BMLoopNorEditDataArray *lnors_ed_arr = do_merge ? BM_loop_normal_editdata_array_init(bm) : NULL;
 
 	mesh_set_smooth_faces(em, do_merge);
 
@@ -6540,14 +6542,14 @@ static int split_merge_loop_normals(bContext *C, const bool do_merge)
 	BKE_editmesh_lnorspace_update(em);
 
 	if (do_merge) {
-		merge_loop(C, ld);
+		loop_normal_merge(C, lnors_ed_arr);
 	}
 	else {
-		split_loop(C);
+		loop_normla_split(C);
 	}
 
-	if (ld) {
-		BM_loop_normal_editdata_free(ld);
+	if (lnors_ed_arr) {
+		BM_loop_normal_editdata_array_free(lnors_ed_arr);
 	}
 
 	EDBM_update_generic(em, true, false);
@@ -6557,13 +6559,13 @@ static int split_merge_loop_normals(bContext *C, const bool do_merge)
 
 static int edbm_merge_loop_normals_exec(bContext *C, wmOperator *UNUSED(op))
 {
-	return split_merge_loop_normals(C, true);
+	return loop_normals_split_merge(C, true);
 }
 
 void MESH_OT_merge_loop_normals(struct wmOperatorType *ot)
 {
 	/* identifiers */
-	ot->name = "Merge Loop";
+	ot->name = "Merge Loop Normals";
 	ot->description = "Merge loop normals of selected vertices";
 	ot->idname = "MESH_OT_merge_loop_normals";
 
@@ -6577,13 +6579,13 @@ void MESH_OT_merge_loop_normals(struct wmOperatorType *ot)
 
 static int edbm_split_loop_normals_exec(bContext *C, wmOperator *UNUSED(op))
 {
-	return split_merge_loop_normals(C, false);
+	return loop_normals_split_merge(C, false);
 }
 
 void MESH_OT_split_loop_normals(struct wmOperatorType *ot)
 {
 	/* identifiers */
-	ot->name = "Split Loop";
+	ot->name = "Split Loop Normals";
 	ot->description = "Split loop normals of selected vertices";
 	ot->idname = "MESH_OT_split_loop_normals";
 
@@ -6604,9 +6606,9 @@ enum {
 };
 
 static EnumPropertyItem average_method_items[] = {
-	{EDBM_CLNOR_AVERAGE_LOOP, "Custom Normal", 0, "Custom Normal", "Take Average of vert Normals"},
-	{EDBM_CLNOR_AVERAGE_FACE_AREA, "Face Area", 0, "Face Area", "Set all vert normals by Face Area"},
-	{EDBM_CLNOR_AVERAGE_ANGLE, "Corner Angle", 0, "Corner Angle", "Set all vert normals by Corner Angle"},
+	{EDBM_CLNOR_AVERAGE_LOOP, "CUSTOM_NORMAL", 0, "Custom Normal", "Take Average of vert Normals"},
+	{EDBM_CLNOR_AVERAGE_FACE_AREA, "FACE_AREA", 0, "Face Area", "Set all vert normals by Face Area"},
+	{EDBM_CLNOR_AVERAGE_ANGLE, "CORNER_ANGLE", 0, "Corner Angle", "Set all vert normals by Corner Angle"},
 	{0, NULL, 0, NULL, NULL}
 };
 
@@ -6623,15 +6625,15 @@ static int edbm_average_loop_normals_exec(bContext *C, wmOperator *op)
 	BKE_editmesh_lnorspace_update(em);
 
 	const int average_type = RNA_enum_get(op->ptr, "average_type");
-	int cd_clnors_offset = CustomData_get_offset(&bm->ldata, CD_CUSTOMLOOPNORMAL);
-	float absweight = (float) RNA_int_get(op->ptr, "weight");
-	float threshold = RNA_float_get(op->ptr, "threshold");
-	float weight = absweight / 50.0f;
+	const int cd_clnors_offset = CustomData_get_offset(&bm->ldata, CD_CUSTOMLOOPNORMAL);
+	const float absweight = (float) RNA_int_get(op->ptr, "weight");
+	const float threshold = RNA_float_get(op->ptr, "threshold");
 
-	if (absweight == 100) {
+	float weight = absweight / 50.0f;
+	if (absweight == 100.0f) {
 		weight = (float)SHRT_MAX;
 	}
-	else if (absweight == 1) {
+	else if (absweight == 1.0f) {
 		weight = 1 / (float)SHRT_MAX;
 	}
 	else if ((weight - 1) * 25 > 1) {
@@ -6646,10 +6648,10 @@ static int edbm_average_loop_normals_exec(bContext *C, wmOperator *op)
 		l_curr = l_first = BM_FACE_FIRST_LOOP(f);
 		do {
 			if (BM_elem_flag_test(l_curr->v, BM_ELEM_SELECT) && (!BM_elem_flag_test(l_curr->e, BM_ELEM_TAG) ||
-				(!BM_elem_flag_test(l_curr, BM_ELEM_TAG) && BM_loop_check_cyclic_smooth_fan(l_curr))))
+			    (!BM_elem_flag_test(l_curr, BM_ELEM_TAG) && BM_loop_check_cyclic_smooth_fan(l_curr))))
 			{
 				if (!BM_elem_flag_test(l_curr->e, BM_ELEM_TAG) && !BM_elem_flag_test(l_curr->prev->e, BM_ELEM_TAG)) {
-					int loop_index = BM_elem_index_get(l_curr);
+					const int loop_index = BM_elem_index_get(l_curr);
 					short *clnors = BM_ELEM_CD_GET_VOID_P(l_curr, cd_clnors_offset);
 					BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[loop_index], f->no, clnors);
 				}
@@ -6692,7 +6694,7 @@ static int edbm_average_loop_normals_exec(bContext *C, wmOperator *op)
 					float val = BLI_heap_node_value(BLI_heap_top(loop_weight));
 
 					while (!BLI_heap_is_empty(loop_weight)) {
-						float cur_val = BLI_heap_node_value(BLI_heap_top(loop_weight));
+						const float cur_val = BLI_heap_node_value(BLI_heap_top(loop_weight));
 						if (!compare_ff(val, cur_val, threshold)) {
 							count++;
 							val = cur_val;
@@ -6700,10 +6702,10 @@ static int edbm_average_loop_normals_exec(bContext *C, wmOperator *op)
 						l = BLI_heap_pop_min(loop_weight);
 						BLI_SMALLSTACK_PUSH(loops, l);
 
-						float n_weight = pow(weight, count);
+						const float n_weight = pow(weight, count);
 
 						if (average_type == EDBM_CLNOR_AVERAGE_LOOP) {
-							int l_index = BM_elem_index_get(l);
+							const int l_index = BM_elem_index_get(l);
 							short *clnors = BM_ELEM_CD_GET_VOID_P(l, cd_clnors_offset);
 							BKE_lnor_space_custom_data_to_normal(bm->lnor_spacearr->lspacearr[l_index], clnors, wnor);
 						}
@@ -6717,7 +6719,7 @@ static int edbm_average_loop_normals_exec(bContext *C, wmOperator *op)
 					normalize_v3(avg_normal);
 
 					while ((l = BLI_SMALLSTACK_POP(loops))) {
-						int l_index = BM_elem_index_get(l);
+						const int l_index = BM_elem_index_get(l);
 						short *clnors = BM_ELEM_CD_GET_VOID_P(l, cd_clnors_offset);
 						BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[l_index], avg_normal, clnors);
 					}
@@ -6795,11 +6797,11 @@ enum {
 };
 
 static EnumPropertyItem normal_vector_tool_items[] = {
-	{EDBM_CLNOR_TOOLS_COPY, "Copy", 0, "Copy Normal", "Copy normal to buffer"},
-	{EDBM_CLNOR_TOOLS_PASTE, "Paste", 0, "Paste Normal", "Paste normal from buffer"},
-	{EDBM_CLNOR_TOOLS_ADD, "Add", 0, "Add Normal", "Add normal vector with selection"},
-	{EDBM_CLNOR_TOOLS_MULTIPLY, "Multiply", 0, "Multiply Normal", "Multiply normal vector with selection"},
-	{EDBM_CLNOR_TOOLS_RESET, "Reset", 0, "Reset Normal", "Reset buffer and/or normal of selected element"},
+	{EDBM_CLNOR_TOOLS_COPY, "COPY", 0, "Copy Normal", "Copy normal to buffer"},
+	{EDBM_CLNOR_TOOLS_PASTE, "PASTE", 0, "Paste Normal", "Paste normal from buffer"},
+	{EDBM_CLNOR_TOOLS_ADD, "ADD", 0, "Add Normal", "Add normal vector with selection"},
+	{EDBM_CLNOR_TOOLS_MULTIPLY, "MULTIPLY", 0, "Multiply Normal", "Multiply normal vector with selection"},
+	{EDBM_CLNOR_TOOLS_RESET, "RESET", 0, "Reset Normal", "Reset buffer and/or normal of selected element"},
 	{0, NULL, 0, NULL, NULL}
 };
 
@@ -6814,26 +6816,26 @@ static int edbm_custom_normal_tools_exec(bContext *C, wmOperator *op)
 	const bool absolute = RNA_boolean_get(op->ptr, "absolute");
 
 	BKE_editmesh_lnorspace_update(em);
-	BMLoopNorEditDataArray *ld = BM_loop_normal_editdata_init(bm);
-	BMLoopNorEditData *tld = ld->lnor_editdata;
+	BMLoopNorEditDataArray *lnors_ed_arr = BM_loop_normal_editdata_array_init(bm);
+	BMLoopNorEditData *lnor_ed = lnors_ed_arr->lnor_editdata;
 
 	float *normal_vector = scene->toolsettings->normal_vector;
 
 	switch (mode) {
 		case EDBM_CLNOR_TOOLS_COPY:
-			if (bm->totfacesel != 1 && ld->totloop != 1 && bm->totvertsel != 1) {
+			if (bm->totfacesel != 1 && lnors_ed_arr->totloop != 1 && bm->totvertsel != 1) {
 				BKE_report(op->reports, RPT_ERROR, "Can only copy Split normal, Averaged vertex normal or Face normal");
-				BM_loop_normal_editdata_free(ld);
+				BM_loop_normal_editdata_array_free(lnors_ed_arr);
 				return OPERATOR_CANCELLED;
 			}
 			bool join = true;
-			for (int i = 0; i < ld->totloop; i++, tld++) {
-				if (!compare_v3v3(ld->lnor_editdata->nloc, tld->nloc, 1e-4f)) {
+			for (int i = 0; i < lnors_ed_arr->totloop; i++, lnor_ed++) {
+				if (!compare_v3v3(lnors_ed_arr->lnor_editdata->nloc, lnor_ed->nloc, 1e-4f)) {
 					join = false;
 				}
 			}
-			if (ld->totloop == 1) {
-				copy_v3_v3(scene->toolsettings->normal_vector, ld->lnor_editdata->nloc);
+			if (lnors_ed_arr->totloop == 1) {
+				copy_v3_v3(scene->toolsettings->normal_vector, lnors_ed_arr->lnor_editdata->nloc);
 			}
 			else if (bm->totfacesel == 1) {
 				BMFace *f;
@@ -6845,7 +6847,7 @@ static int edbm_custom_normal_tools_exec(bContext *C, wmOperator *op)
 				}
 			}
 			else if (join) {
-				copy_v3_v3(scene->toolsettings->normal_vector, ld->lnor_editdata->nloc);
+				copy_v3_v3(scene->toolsettings->normal_vector, lnors_ed_arr->lnor_editdata->nloc);
 			}
 			break;
 
@@ -6853,43 +6855,43 @@ static int edbm_custom_normal_tools_exec(bContext *C, wmOperator *op)
 			if (!absolute) {
 				normalize_v3(normal_vector);
 			}
-			for (int i = 0; i < ld->totloop; i++, tld++) {
+			for (int i = 0; i < lnors_ed_arr->totloop; i++, lnor_ed++) {
 				if (absolute) {
 					float abs_normal[3];
-					copy_v3_v3(abs_normal, tld->loc);
+					copy_v3_v3(abs_normal, lnor_ed->loc);
 					negate_v3(abs_normal);
 					add_v3_v3(abs_normal, normal_vector);
 					normalize_v3(abs_normal);
 
-					BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[tld->loop_index], abs_normal, tld->clnors_data);
+					BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[lnor_ed->loop_index], abs_normal, lnor_ed->clnors_data);
 				}
 				else {
-					BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[tld->loop_index], normal_vector, tld->clnors_data);
+					BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[lnor_ed->loop_index], normal_vector, lnor_ed->clnors_data);
 				}
 			}
 			break;
 
 		case EDBM_CLNOR_TOOLS_MULTIPLY:
-			for (int i = 0; i < ld->totloop; i++, tld++) {
-				mul_v3_v3(tld->nloc, normal_vector);
-				normalize_v3(tld->nloc);
-				BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[tld->loop_index], tld->nloc, tld->clnors_data);
+			for (int i = 0; i < lnors_ed_arr->totloop; i++, lnor_ed++) {
+				mul_v3_v3(lnor_ed->nloc, normal_vector);
+				normalize_v3(lnor_ed->nloc);
+				BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[lnor_ed->loop_index], lnor_ed->nloc, lnor_ed->clnors_data);
 			}
 			break;
 
 		case EDBM_CLNOR_TOOLS_ADD:
-			for (int i = 0; i < ld->totloop; i++, tld++) {
-				add_v3_v3(tld->nloc, normal_vector);
-				normalize_v3(tld->nloc);
-				BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[tld->loop_index], tld->nloc, tld->clnors_data);
+			for (int i = 0; i < lnors_ed_arr->totloop; i++, lnor_ed++) {
+				add_v3_v3(lnor_ed->nloc, normal_vector);
+				normalize_v3(lnor_ed->nloc);
+				BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[lnor_ed->loop_index], lnor_ed->nloc, lnor_ed->clnors_data);
 			}
 			break;
 
 		case EDBM_CLNOR_TOOLS_RESET:
 			zero_v3(normal_vector);
-			for (int i = 0; i < ld->totloop; i++, tld++) {
-				zero_v3(tld->nloc);
-				BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[tld->loop_index], tld->nloc, tld->clnors_data);
+			for (int i = 0; i < lnors_ed_arr->totloop; i++, lnor_ed++) {
+				zero_v3(lnor_ed->nloc);
+				BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[lnor_ed->loop_index], lnor_ed->nloc, lnor_ed->clnors_data);
 			}
 			break;
 
@@ -6898,7 +6900,7 @@ static int edbm_custom_normal_tools_exec(bContext *C, wmOperator *op)
 			break;
 	}
 
-	BM_loop_normal_editdata_free(ld);
+	BM_loop_normal_editdata_array_free(lnors_ed_arr);
 
 	EDBM_update_generic(em, true, false);
 	return OPERATOR_FINISHED;
@@ -6949,7 +6951,7 @@ void MESH_OT_custom_normal_tools(struct wmOperatorType *ot)
 	                        "Mode", "Mode of tools taking input from Interface");
 	RNA_def_property_flag(ot->prop, PROP_HIDDEN);
 
-	RNA_def_boolean(ot->srna, "absolute", 0, "Absolute Coordinates", "Copy Absolute coordinates or Normal vector");
+	RNA_def_boolean(ot->srna, "absolute", false, "Absolute Coordinates", "Copy Absolute coordinates or Normal vector");
 }
 
 static int edbm_set_normals_from_faces_exec(bContext *C, wmOperator *op)
@@ -6971,7 +6973,7 @@ static int edbm_set_normals_from_faces_exec(bContext *C, wmOperator *op)
 	BM_ITER_MESH(f, &fiter, bm, BM_FACES_OF_MESH) {
 		if (BM_elem_flag_test(f, BM_ELEM_SELECT)) {
 			BM_ITER_ELEM(v, &viter, f, BM_VERTS_OF_FACE) {
-				int v_index = BM_elem_index_get(v);
+				const int v_index = BM_elem_index_get(v);
 				add_v3_v3(vnors[v_index], f->no);
 			}
 		}
@@ -6983,7 +6985,7 @@ static int edbm_set_normals_from_faces_exec(bContext *C, wmOperator *op)
 	}
 
 	BLI_bitmap *loop_set = BLI_BITMAP_NEW(bm->totloop, __func__);
-	int cd_clnors_offset = CustomData_get_offset(&bm->ldata, CD_CUSTOMLOOPNORMAL);
+	const int cd_clnors_offset = CustomData_get_offset(&bm->ldata, CD_CUSTOMLOOPNORMAL);
 
 	BM_ITER_MESH(f, &fiter, bm, BM_FACES_OF_MESH) {
 		BM_ITER_ELEM(e, &eiter, f, BM_EDGES_OF_FACE) {
@@ -7017,7 +7019,7 @@ static int edbm_set_normals_from_faces_exec(bContext *C, wmOperator *op)
 	BM_ITER_MESH_INDEX(v, &viter, bm, BM_VERTS_OF_MESH, v_index) {
 		BM_ITER_ELEM(l, &liter, v, BM_LOOPS_OF_VERT) {
 			if (BLI_BITMAP_TEST(loop_set, BM_elem_index_get(l))) {
-				int loop_index = BM_elem_index_get(l);
+				const int loop_index = BM_elem_index_get(l);
 				short *clnors = BM_ELEM_CD_GET_VOID_P(l, cd_clnors_offset);
 				BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[loop_index], vnors[v_index], clnors);
 			}
@@ -7058,21 +7060,20 @@ static int edbm_smoothen_normals_exec(bContext *C, wmOperator *op)
 	BMIter fiter, liter;
 
 	BKE_editmesh_lnorspace_update(em);
-	BMLoopNorEditDataArray *ld = BM_loop_normal_editdata_init(bm);
-
-	float(*smooth_normal)[3] = MEM_callocN(sizeof(*smooth_normal) * ld->totloop, __func__);
+	BMLoopNorEditDataArray *lnors_ed_arr = BM_loop_normal_editdata_array_init(bm);
 
-	BMLoopNorEditData *tld = ld->lnor_editdata;
+	float(*smooth_normal)[3] = MEM_callocN(sizeof(*smooth_normal) * lnors_ed_arr->totloop, __func__);
 
-	for (int i = 0; i < ld->totloop; i++, tld++) {
-		l = tld->loop;
+	BMLoopNorEditData *lnor_ed = lnors_ed_arr->lnor_editdata;
+	for (int i = 0; i < lnors_ed_arr->totloop; i++, lnor_ed++) {
+		l = lnor_ed->loop;
 		float loop_normal[3];
 
 		BM_ITER_ELEM(f, &fiter, l->v, BM_FACES_OF_VERT) {
 			BMLoop *l_other;
 			BM_ITER_ELEM(l_other, &liter, f, BM_LOOPS_OF_FACE) {
-				int index_other = BM_elem_index_get(l_other);
-				short *clnors = BM_ELEM_CD_GET_VOID_P(l_other, ld->cd_custom_normal_offset);
+				const int index_other = BM_elem_index_get(l_other);
+				short *clnors = BM_ELEM_CD_GET_VOID_P(l_other, lnors_ed_arr->cd_custom_normal_offset);
 				BKE_lnor_space_custom_data_to_normal(bm->lnor_spacearr->lspacearr[index_other], clnors, loop_normal);
 				add_v3_v3(smooth_normal[i], loop_normal);
 			}
@@ -7080,23 +7081,23 @@ static int edbm_smoothen_normals_exec(bContext *C, wmOperator *op)
 		normalize_v3(smooth_normal[i]);
 	}
 
-	float factor = RNA_float_get(op->ptr, "factor");
-	tld = ld->lnor_editdata;
+	const float factor = RNA_float_get(op->ptr, "factor");
 
-	for (int i = 0; i < ld->totloop; i++, tld++) {
+	lnor_ed = lnors_ed_arr->lnor_editdata;
+	for (int i = 0; i < lnors_ed_arr->totloop; i++, lnor_ed++) {
 		float current_normal[3];
 
-		BKE_lnor_space_custom_data_to_normal(bm->lnor_spacearr->lspacearr[tld->loop_index], tld->clnors_data, current_normal);
+		BKE_lnor_space_custom_data_to_normal(bm->lnor_spacearr->lspacearr[lnor_ed->loop_index], lnor_ed->clnors_data, current_normal);
 
 		mul_v3_fl(current_normal, 1.0f - factor);
 		mul_v3_fl(smooth_normal[i], factor);
 		add_v3_v3(current_normal, smooth_normal[i]);
 		normalize_v3(current_normal);
 
-		BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[tld->loop_index], current_normal, tld->clnors_data);
+		BKE_lnor_space_custom_normal_to_data(bm->lnor_spacearr->lspacearr[lnor_ed->loop_index], current_normal, lnor_ed->clnors_data);
 	}
 
-	BM_loop_normal_editdata_free(ld);
+	BM_loop_normal_editdata_array_free(lnors_ed_arr);
 	MEM_freeN(smooth_normal);
 
 	EDBM_update_generic(em, true, false);
@@ -7118,7 +7119,8 @@ void MESH_OT_smoothen_custom_normals(struct wmOperatorType *ot)
 	/* flags */
 	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
-	RNA_def_float(ot->srna, "factor", 0.5f, 0.0f, 1.0f, "Factor", "Specifies weight of smooth vs original normal", 0.0f, 1.0f);
+	RNA_def_float(ot->srna, "factor", 0.5f, 0.0f, 1.0f, "Factor",
+	              "Specifies weight of smooth vs original normal", 0.0f, 1.0f);
 }
 
 /********************** Weighted Normal Modifier Face Strength **********************/
@@ -7131,7 +7133,7 @@ static int edbm_mod_weighted_strength_exec(bContext *C, wmOperator *op)
 	BMesh *bm = em->bm;
 	BMFace *f;
 	BMIter fiter;
-	
+
 	BM_select_history_clear(bm);
 
 	int cd_prop_int_offset = CustomData_get_offset(&bm->pdata, CD_PROP_INT);
diff --git a/source/blender/editors/transform/transform.c b/source/blender/editors/transform/transform.c
index 9aa2ab06b1c..95a78e818f0 100644
--- a/source/blender/editors/transform/transform.c
+++ b/source/blender/editors/transform/transform.c
@@ -4223,7 +4223,7 @@ static void StoreCustomlnorValue(TransInfo *t, BMesh *bm)
 {
 	float mtx[3][3], smtx[3][3];
 
-	BMLoopNorEditDataArray *ld = BM_loop_normal_editdata_init(bm);
+	BMLoopNorEditDataArray *ld = BM_loop_normal_editdata_array_init(bm);
 
 	copy_m3_m4(mtx, t->obedit->obmat);
 	pseudoinverse_m3_m3(smtx, mtx, PSEUDOINVERSE_EPSILON);
@@ -4252,7 +4252,7 @@ void freeCustomNormalArray(TransInfo *t, TransCustomData *custom_data)
 		}
 	}
 
-	BM_loop_normal_editdata_free(ld);
+	BM_loop_normal_editdata_array_free(ld);
 
 	t->custom.mode.data = NULL;
 	t->custom.mode.free_cb = NULL;