Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.

5 files changed, 85 insertions, 85 deletions

diff --git a/editor/plugins/tiles/tile_data_editors.cpp b/editor/plugins/tiles/tile_data_editors.cpp
index d0f8e1f32d..73ca8b6176 100644
--- a/editor/plugins/tiles/tile_data_editors.cpp
+++ b/editor/plugins/tiles/tile_data_editors.cpp
@@ -212,8 +212,8 @@ void GenericTilePolygonEditor::_base_control_draw() {
 		for (int i = 0; i < (int)polygons.size(); i++) {
 			const Vector<Vector2> &polygon = polygons[i];
 			for (int j = 0; j < polygon.size(); j++) {
-				const Color modulate = (tinted_polygon_index == i && tinted_point_index == j) ? Color(0.5, 1, 2) : Color(1, 1, 1);
-				base_control->draw_texture(handle, xform.xform(polygon[j]) - handle->get_size() / 2, modulate);
+				const Color poly_modulate = (tinted_polygon_index == i && tinted_point_index == j) ? Color(0.5, 1, 2) : Color(1, 1, 1);
+				base_control->draw_texture(handle, xform.xform(polygon[j]) - handle->get_size() / 2, poly_modulate);
 			}
 		}
 	}
@@ -2662,27 +2662,27 @@ TileDataTerrainsEditor::~TileDataTerrainsEditor() {
 }
 
 Variant TileDataNavigationEditor::_get_painted_value() {
-	Ref<NavigationPolygon> navigation_polygon;
-	navigation_polygon.instantiate();
+	Ref<NavigationPolygon> nav_polygon;
+	nav_polygon.instantiate();
 
 	for (int i = 0; i < polygon_editor->get_polygon_count(); i++) {
 		Vector<Vector2> polygon = polygon_editor->get_polygon(i);
-		navigation_polygon->add_outline(polygon);
+		nav_polygon->add_outline(polygon);
 	}
 
-	navigation_polygon->make_polygons_from_outlines();
-	return navigation_polygon;
+	nav_polygon->make_polygons_from_outlines();
+	return nav_polygon;
 }
 
 void TileDataNavigationEditor::_set_painted_value(TileSetAtlasSource *p_tile_set_atlas_source, Vector2 p_coords, int p_alternative_tile) {
 	TileData *tile_data = p_tile_set_atlas_source->get_tile_data(p_coords, p_alternative_tile);
 	ERR_FAIL_COND(!tile_data);
 
-	Ref<NavigationPolygon> navigation_polygon = tile_data->get_navigation_polygon(navigation_layer);
+	Ref<NavigationPolygon> nav_polygon = tile_data->get_navigation_polygon(navigation_layer);
 	polygon_editor->clear_polygons();
-	if (navigation_polygon.is_valid()) {
-		for (int i = 0; i < navigation_polygon->get_outline_count(); i++) {
-			polygon_editor->add_polygon(navigation_polygon->get_outline(i));
+	if (nav_polygon.is_valid()) {
+		for (int i = 0; i < nav_polygon->get_outline_count(); i++) {
+			polygon_editor->add_polygon(nav_polygon->get_outline(i));
 		}
 	}
 	polygon_editor->set_background(p_tile_set_atlas_source->get_texture(), p_tile_set_atlas_source->get_tile_texture_region(p_coords), p_tile_set_atlas_source->get_tile_effective_texture_offset(p_coords, p_alternative_tile), tile_data->get_flip_h(), tile_data->get_flip_v(), tile_data->get_transpose(), tile_data->get_modulate());
@@ -2691,8 +2691,8 @@ void TileDataNavigationEditor::_set_painted_value(TileSetAtlasSource *p_tile_set
 void TileDataNavigationEditor::_set_value(TileSetAtlasSource *p_tile_set_atlas_source, Vector2 p_coords, int p_alternative_tile, Variant p_value) {
 	TileData *tile_data = p_tile_set_atlas_source->get_tile_data(p_coords, p_alternative_tile);
 	ERR_FAIL_COND(!tile_data);
-	Ref<NavigationPolygon> navigation_polygon = p_value;
-	tile_data->set_navigation_polygon(navigation_layer, navigation_polygon);
+	Ref<NavigationPolygon> nav_polygon = p_value;
+	tile_data->set_navigation_polygon(navigation_layer, nav_polygon);
 
 	polygon_editor->set_background(p_tile_set_atlas_source->get_texture(), p_tile_set_atlas_source->get_tile_texture_region(p_coords), p_tile_set_atlas_source->get_tile_effective_texture_offset(p_coords, p_alternative_tile), tile_data->get_flip_h(), tile_data->get_flip_v(), tile_data->get_transpose(), tile_data->get_modulate());
 }
@@ -2740,9 +2740,9 @@ void TileDataNavigationEditor::draw_over_tile(CanvasItem *p_canvas_item, Transfo
 	// Draw all shapes.
 	RenderingServer::get_singleton()->canvas_item_add_set_transform(p_canvas_item->get_canvas_item(), p_transform);
 
-	Ref<NavigationPolygon> navigation_polygon = tile_data->get_navigation_polygon(navigation_layer);
-	if (navigation_polygon.is_valid()) {
-		Vector<Vector2> verts = navigation_polygon->get_vertices();
+	Ref<NavigationPolygon> nav_polygon = tile_data->get_navigation_polygon(navigation_layer);
+	if (nav_polygon.is_valid()) {
+		Vector<Vector2> verts = nav_polygon->get_vertices();
 		if (verts.size() < 3) {
 			return;
 		}
@@ -2759,9 +2759,9 @@ void TileDataNavigationEditor::draw_over_tile(CanvasItem *p_canvas_item, Transfo
 		}
 
 		RandomPCG rand;
-		for (int i = 0; i < navigation_polygon->get_polygon_count(); i++) {
+		for (int i = 0; i < nav_polygon->get_polygon_count(); i++) {
 			// An array of vertices for this polygon.
-			Vector<int> polygon = navigation_polygon->get_polygon(i);
+			Vector<int> polygon = nav_polygon->get_polygon(i);
 			Vector<Vector2> vertices;
 			vertices.resize(polygon.size());
 			for (int j = 0; j < polygon.size(); j++) {
diff --git a/editor/plugins/tiles/tile_map_editor.cpp b/editor/plugins/tiles/tile_map_editor.cpp
index acfa8b3d00..7cc29dbfad 100644
--- a/editor/plugins/tiles/tile_map_editor.cpp
+++ b/editor/plugins/tiles/tile_map_editor.cpp
@@ -3190,10 +3190,10 @@ void TileMapEditorTerrainsPlugin::_update_tiles_list() {
 	TreeItem *selected_tree_item = terrains_tree->get_selected();
 	if (selected_tree_item && selected_tree_item->get_metadata(0)) {
 		Dictionary metadata_dict = selected_tree_item->get_metadata(0);
-		int selected_terrain_set = metadata_dict["terrain_set"];
-		int selected_terrain_id = metadata_dict["terrain_id"];
-		ERR_FAIL_INDEX(selected_terrain_set, tile_set->get_terrain_sets_count());
-		ERR_FAIL_INDEX(selected_terrain_id, tile_set->get_terrains_count(selected_terrain_set));
+		int sel_terrain_set = metadata_dict["terrain_set"];
+		int sel_terrain_id = metadata_dict["terrain_id"];
+		ERR_FAIL_INDEX(sel_terrain_set, tile_set->get_terrain_sets_count());
+		ERR_FAIL_INDEX(sel_terrain_id, tile_set->get_terrains_count(sel_terrain_set));
 
 		// Add the two first generic modes
 		int item_index = terrains_tile_list->add_icon_item(main_vbox_container->get_theme_icon(SNAME("TerrainConnect"), SNAME("EditorIcons")));
@@ -3211,13 +3211,13 @@ void TileMapEditorTerrainsPlugin::_update_tiles_list() {
 		// Sort the items in a map by the number of corresponding terrains.
 		RBMap<int, RBSet<TileSet::TerrainsPattern>> sorted;
 
-		for (const TileSet::TerrainsPattern &E : per_terrain_terrains_patterns[selected_terrain_set][selected_terrain_id]) {
+		for (const TileSet::TerrainsPattern &E : per_terrain_terrains_patterns[sel_terrain_set][sel_terrain_id]) {
 			// Count the number of matching sides/terrains.
 			int count = 0;
 
 			for (int i = 0; i < TileSet::CELL_NEIGHBOR_MAX; i++) {
 				TileSet::CellNeighbor bit = TileSet::CellNeighbor(i);
-				if (tile_set->is_valid_terrain_peering_bit(selected_terrain_set, bit) && E.get_terrain_peering_bit(bit) == selected_terrain_id) {
+				if (tile_set->is_valid_terrain_peering_bit(sel_terrain_set, bit) && E.get_terrain_peering_bit(bit) == sel_terrain_id) {
 					count++;
 				}
 			}
@@ -3234,7 +3234,7 @@ void TileMapEditorTerrainsPlugin::_update_tiles_list() {
 				bool transpose = false;
 
 				double max_probability = -1.0;
-				for (const TileMapCell &cell : tile_set->get_tiles_for_terrains_pattern(selected_terrain_set, terrains_pattern)) {
+				for (const TileMapCell &cell : tile_set->get_tiles_for_terrains_pattern(sel_terrain_set, terrains_pattern)) {
 					Ref<TileSetSource> source = tile_set->get_source(cell.source_id);
 
 					Ref<TileSetAtlasSource> atlas_source = source;
@@ -3689,8 +3689,8 @@ void TileMapEditor::_update_layers_selection() {
 }
 
 void TileMapEditor::_move_tile_map_array_element(Object *p_undo_redo, Object *p_edited, String p_array_prefix, int p_from_index, int p_to_pos) {
-	Ref<EditorUndoRedoManager> undo_redo = Object::cast_to<EditorUndoRedoManager>(p_undo_redo);
-	ERR_FAIL_COND(undo_redo.is_null());
+	Ref<EditorUndoRedoManager> undo_redo_man = Object::cast_to<EditorUndoRedoManager>(p_undo_redo);
+	ERR_FAIL_COND(undo_redo_man.is_null());
 
 	TileMap *tile_map = Object::cast_to<TileMap>(p_edited);
 	if (!tile_map) {
@@ -3721,12 +3721,12 @@ void TileMapEditor::_move_tile_map_array_element(Object *p_undo_redo, Object *p_
 		end = MIN(MAX(p_from_index, p_to_pos) + 1, end);
 	}
 
-#define ADD_UNDO(obj, property) undo_redo->add_undo_property(obj, property, obj->get(property));
+#define ADD_UNDO(obj, property) undo_redo_man->add_undo_property(obj, property, obj->get(property));
 	// Save layers' properties.
 	if (p_from_index < 0) {
-		undo_redo->add_undo_method(tile_map, "remove_layer", p_to_pos < 0 ? tile_map->get_layers_count() : p_to_pos);
+		undo_redo_man->add_undo_method(tile_map, "remove_layer", p_to_pos < 0 ? tile_map->get_layers_count() : p_to_pos);
 	} else if (p_to_pos < 0) {
-		undo_redo->add_undo_method(tile_map, "add_layer", p_from_index);
+		undo_redo_man->add_undo_method(tile_map, "add_layer", p_from_index);
 	}
 
 	List<PropertyInfo> properties;
@@ -3752,11 +3752,11 @@ void TileMapEditor::_move_tile_map_array_element(Object *p_undo_redo, Object *p_
 #undef ADD_UNDO
 
 	if (p_from_index < 0) {
-		undo_redo->add_do_method(tile_map, "add_layer", p_to_pos);
+		undo_redo_man->add_do_method(tile_map, "add_layer", p_to_pos);
 	} else if (p_to_pos < 0) {
-		undo_redo->add_do_method(tile_map, "remove_layer", p_from_index);
+		undo_redo_man->add_do_method(tile_map, "remove_layer", p_from_index);
 	} else {
-		undo_redo->add_do_method(tile_map, "move_layer", p_from_index, p_to_pos);
+		undo_redo_man->add_do_method(tile_map, "move_layer", p_from_index, p_to_pos);
 	}
 }
 
diff --git a/editor/plugins/tiles/tile_set_atlas_source_editor.cpp b/editor/plugins/tiles/tile_set_atlas_source_editor.cpp
index 4299ae8d3e..1857606f00 100644
--- a/editor/plugins/tiles/tile_set_atlas_source_editor.cpp
+++ b/editor/plugins/tiles/tile_set_atlas_source_editor.cpp
@@ -561,9 +561,9 @@ void TileSetAtlasSourceEditor::_update_fix_selected_and_hovered_tiles() {
 
 void TileSetAtlasSourceEditor::_update_atlas_source_inspector() {
 	// Update visibility.
-	bool visible = tools_button_group->get_pressed_button() == tool_setup_atlas_source_button;
-	atlas_source_inspector_label->set_visible(visible);
-	atlas_source_inspector->set_visible(visible);
+	bool inspector_visible = tools_button_group->get_pressed_button() == tool_setup_atlas_source_button;
+	atlas_source_inspector_label->set_visible(inspector_visible);
+	atlas_source_inspector->set_visible(inspector_visible);
 }
 
 void TileSetAtlasSourceEditor::_update_tile_inspector() {
@@ -2067,14 +2067,14 @@ void TileSetAtlasSourceEditor::_atlas_source_proxy_object_changed(String p_what)
 }
 
 void TileSetAtlasSourceEditor::_undo_redo_inspector_callback(Object *p_undo_redo, Object *p_edited, String p_property, Variant p_new_value) {
-	Ref<EditorUndoRedoManager> undo_redo = Object::cast_to<EditorUndoRedoManager>(p_undo_redo);
-	ERR_FAIL_COND(!undo_redo.is_valid());
+	Ref<EditorUndoRedoManager> undo_redo_man = Object::cast_to<EditorUndoRedoManager>(p_undo_redo);
+	ERR_FAIL_COND(!undo_redo_man.is_valid());
 
-#define ADD_UNDO(obj, property) undo_redo->add_undo_property(obj, property, obj->get(property));
+#define ADD_UNDO(obj, property) undo_redo_man->add_undo_property(obj, property, obj->get(property));
 
 	AtlasTileProxyObject *tile_data_proxy = Object::cast_to<AtlasTileProxyObject>(p_edited);
 	if (tile_data_proxy) {
-		UndoRedo *internal_undo_redo = undo_redo->get_history_for_object(tile_data_proxy).undo_redo;
+		UndoRedo *internal_undo_redo = undo_redo_man->get_history_for_object(tile_data_proxy).undo_redo;
 		internal_undo_redo->start_force_keep_in_merge_ends();
 
 		Vector<String> components = String(p_property).split("/", true, 2);
@@ -2107,7 +2107,7 @@ void TileSetAtlasSourceEditor::_undo_redo_inspector_callback(Object *p_undo_redo
 		TileSetAtlasSource *atlas_source = atlas_source_proxy->get_edited();
 		ERR_FAIL_COND(!atlas_source);
 
-		UndoRedo *internal_undo_redo = undo_redo->get_history_for_object(atlas_source).undo_redo;
+		UndoRedo *internal_undo_redo = undo_redo_man->get_history_for_object(atlas_source).undo_redo;
 		internal_undo_redo->start_force_keep_in_merge_ends();
 
 		PackedVector2Array arr;
diff --git a/editor/plugins/tiles/tile_set_editor.cpp b/editor/plugins/tiles/tile_set_editor.cpp
index 7394288fcd..3b057b7631 100644
--- a/editor/plugins/tiles/tile_set_editor.cpp
+++ b/editor/plugins/tiles/tile_set_editor.cpp
@@ -407,11 +407,11 @@ void TileSetEditor::_tab_changed(int p_tab_changed) {
 }
 
 void TileSetEditor::_move_tile_set_array_element(Object *p_undo_redo, Object *p_edited, String p_array_prefix, int p_from_index, int p_to_pos) {
-	Ref<EditorUndoRedoManager> undo_redo = Object::cast_to<EditorUndoRedoManager>(p_undo_redo);
-	ERR_FAIL_COND(undo_redo.is_null());
+	Ref<EditorUndoRedoManager> undo_redo_man = Object::cast_to<EditorUndoRedoManager>(p_undo_redo);
+	ERR_FAIL_COND(undo_redo_man.is_null());
 
-	TileSet *tile_set = Object::cast_to<TileSet>(p_edited);
-	if (!tile_set) {
+	TileSet *ed_tile_set = Object::cast_to<TileSet>(p_edited);
+	if (!ed_tile_set) {
 		return;
 	}
 
@@ -421,18 +421,18 @@ void TileSetEditor::_move_tile_set_array_element(Object *p_undo_redo, Object *p_
 	int begin = 0;
 	int end;
 	if (p_array_prefix == "occlusion_layer_") {
-		end = tile_set->get_occlusion_layers_count();
+		end = ed_tile_set->get_occlusion_layers_count();
 	} else if (p_array_prefix == "physics_layer_") {
-		end = tile_set->get_physics_layers_count();
+		end = ed_tile_set->get_physics_layers_count();
 	} else if (p_array_prefix == "terrain_set_") {
-		end = tile_set->get_terrain_sets_count();
+		end = ed_tile_set->get_terrain_sets_count();
 	} else if (components.size() >= 2 && components[0].begins_with("terrain_set_") && components[0].trim_prefix("terrain_set_").is_valid_int() && components[1] == "terrain_") {
 		int terrain_set = components[0].trim_prefix("terrain_set_").to_int();
-		end = tile_set->get_terrains_count(terrain_set);
+		end = ed_tile_set->get_terrains_count(terrain_set);
 	} else if (p_array_prefix == "navigation_layer_") {
-		end = tile_set->get_navigation_layers_count();
+		end = ed_tile_set->get_navigation_layers_count();
 	} else if (p_array_prefix == "custom_data_layer_") {
-		end = tile_set->get_custom_data_layers_count();
+		end = ed_tile_set->get_custom_data_layers_count();
 	} else {
 		ERR_FAIL_MSG("Invalid array prefix for TileSet.");
 	}
@@ -452,10 +452,10 @@ void TileSetEditor::_move_tile_set_array_element(Object *p_undo_redo, Object *p_
 		end = MIN(MAX(p_from_index, p_to_pos) + 1, end);
 	}
 
-#define ADD_UNDO(obj, property) undo_redo->add_undo_property(obj, property, obj->get(property));
+#define ADD_UNDO(obj, property) undo_redo_man->add_undo_property(obj, property, obj->get(property));
 	// Save layers' properties.
 	List<PropertyInfo> properties;
-	tile_set->get_property_list(&properties);
+	ed_tile_set->get_property_list(&properties);
 	for (PropertyInfo pi : properties) {
 		if (pi.name.begins_with(p_array_prefix)) {
 			String str = pi.name.trim_prefix(p_array_prefix);
@@ -469,17 +469,17 @@ void TileSetEditor::_move_tile_set_array_element(Object *p_undo_redo, Object *p_
 			if (to_char_index > 0) {
 				int array_index = str.left(to_char_index).to_int();
 				if (array_index >= begin && array_index < end) {
-					ADD_UNDO(tile_set, pi.name);
+					ADD_UNDO(ed_tile_set, pi.name);
 				}
 			}
 		}
 	}
 
 	// Save properties for TileSetAtlasSources tile data
-	for (int i = 0; i < tile_set->get_source_count(); i++) {
-		int source_id = tile_set->get_source_id(i);
+	for (int i = 0; i < ed_tile_set->get_source_count(); i++) {
+		int source_id = ed_tile_set->get_source_id(i);
 
-		Ref<TileSetAtlasSource> tas = tile_set->get_source(source_id);
+		Ref<TileSetAtlasSource> tas = ed_tile_set->get_source(source_id);
 		if (tas.is_valid()) {
 			for (int j = 0; j < tas->get_tiles_count(); j++) {
 				Vector2i tile_id = tas->get_tile_id(j);
@@ -537,68 +537,68 @@ void TileSetEditor::_move_tile_set_array_element(Object *p_undo_redo, Object *p_
 	// Add do method.
 	if (p_array_prefix == "occlusion_layer_") {
 		if (p_from_index < 0) {
-			undo_redo->add_do_method(tile_set, "add_occlusion_layer", p_to_pos);
+			undo_redo_man->add_do_method(ed_tile_set, "add_occlusion_layer", p_to_pos);
 		} else if (p_to_pos < 0) {
-			undo_redo->add_do_method(tile_set, "remove_occlusion_layer", p_from_index);
+			undo_redo_man->add_do_method(ed_tile_set, "remove_occlusion_layer", p_from_index);
 		} else {
-			undo_redo->add_do_method(tile_set, "move_occlusion_layer", p_from_index, p_to_pos);
+			undo_redo_man->add_do_method(ed_tile_set, "move_occlusion_layer", p_from_index, p_to_pos);
 		}
 	} else if (p_array_prefix == "physics_layer_") {
 		if (p_from_index < 0) {
-			undo_redo->add_do_method(tile_set, "add_physics_layer", p_to_pos);
+			undo_redo_man->add_do_method(ed_tile_set, "add_physics_layer", p_to_pos);
 		} else if (p_to_pos < 0) {
-			undo_redo->add_do_method(tile_set, "remove_physics_layer", p_from_index);
+			undo_redo_man->add_do_method(ed_tile_set, "remove_physics_layer", p_from_index);
 		} else {
-			undo_redo->add_do_method(tile_set, "move_physics_layer", p_from_index, p_to_pos);
+			undo_redo_man->add_do_method(ed_tile_set, "move_physics_layer", p_from_index, p_to_pos);
 		}
 	} else if (p_array_prefix == "terrain_set_") {
 		if (p_from_index < 0) {
-			undo_redo->add_do_method(tile_set, "add_terrain_set", p_to_pos);
+			undo_redo_man->add_do_method(ed_tile_set, "add_terrain_set", p_to_pos);
 		} else if (p_to_pos < 0) {
-			undo_redo->add_do_method(tile_set, "remove_terrain_set", p_from_index);
+			undo_redo_man->add_do_method(ed_tile_set, "remove_terrain_set", p_from_index);
 		} else {
-			undo_redo->add_do_method(tile_set, "move_terrain_set", p_from_index, p_to_pos);
+			undo_redo_man->add_do_method(ed_tile_set, "move_terrain_set", p_from_index, p_to_pos);
 		}
 	} else if (components.size() >= 2 && components[0].begins_with("terrain_set_") && components[0].trim_prefix("terrain_set_").is_valid_int() && components[1] == "terrain_") {
 		int terrain_set = components[0].trim_prefix("terrain_set_").to_int();
 		if (p_from_index < 0) {
-			undo_redo->add_do_method(tile_set, "add_terrain", terrain_set, p_to_pos);
+			undo_redo_man->add_do_method(ed_tile_set, "add_terrain", terrain_set, p_to_pos);
 		} else if (p_to_pos < 0) {
-			undo_redo->add_do_method(tile_set, "remove_terrain", terrain_set, p_from_index);
+			undo_redo_man->add_do_method(ed_tile_set, "remove_terrain", terrain_set, p_from_index);
 		} else {
-			undo_redo->add_do_method(tile_set, "move_terrain", terrain_set, p_from_index, p_to_pos);
+			undo_redo_man->add_do_method(ed_tile_set, "move_terrain", terrain_set, p_from_index, p_to_pos);
 		}
 	} else if (p_array_prefix == "navigation_layer_") {
 		if (p_from_index < 0) {
-			undo_redo->add_do_method(tile_set, "add_navigation_layer", p_to_pos);
+			undo_redo_man->add_do_method(ed_tile_set, "add_navigation_layer", p_to_pos);
 		} else if (p_to_pos < 0) {
-			undo_redo->add_do_method(tile_set, "remove_navigation_layer", p_from_index);
+			undo_redo_man->add_do_method(ed_tile_set, "remove_navigation_layer", p_from_index);
 		} else {
-			undo_redo->add_do_method(tile_set, "move_navigation_layer", p_from_index, p_to_pos);
+			undo_redo_man->add_do_method(ed_tile_set, "move_navigation_layer", p_from_index, p_to_pos);
 		}
 	} else if (p_array_prefix == "custom_data_layer_") {
 		if (p_from_index < 0) {
-			undo_redo->add_do_method(tile_set, "add_custom_data_layer", p_to_pos);
+			undo_redo_man->add_do_method(ed_tile_set, "add_custom_data_layer", p_to_pos);
 		} else if (p_to_pos < 0) {
-			undo_redo->add_do_method(tile_set, "remove_custom_data_layer", p_from_index);
+			undo_redo_man->add_do_method(ed_tile_set, "remove_custom_data_layer", p_from_index);
 		} else {
-			undo_redo->add_do_method(tile_set, "move_custom_data_layer", p_from_index, p_to_pos);
+			undo_redo_man->add_do_method(ed_tile_set, "move_custom_data_layer", p_from_index, p_to_pos);
 		}
 	}
 }
 
 void TileSetEditor::_undo_redo_inspector_callback(Object *p_undo_redo, Object *p_edited, String p_property, Variant p_new_value) {
-	Ref<EditorUndoRedoManager> undo_redo = Object::cast_to<EditorUndoRedoManager>(p_undo_redo);
-	ERR_FAIL_COND(undo_redo.is_null());
+	Ref<EditorUndoRedoManager> undo_redo_man = Object::cast_to<EditorUndoRedoManager>(p_undo_redo);
+	ERR_FAIL_COND(undo_redo_man.is_null());
 
-#define ADD_UNDO(obj, property) undo_redo->add_undo_property(obj, property, obj->get(property));
-	TileSet *tile_set = Object::cast_to<TileSet>(p_edited);
-	if (tile_set) {
+#define ADD_UNDO(obj, property) undo_redo_man->add_undo_property(obj, property, obj->get(property));
+	TileSet *ed_tile_set = Object::cast_to<TileSet>(p_edited);
+	if (ed_tile_set) {
 		Vector<String> components = p_property.split("/", true, 3);
-		for (int i = 0; i < tile_set->get_source_count(); i++) {
-			int source_id = tile_set->get_source_id(i);
+		for (int i = 0; i < ed_tile_set->get_source_count(); i++) {
+			int source_id = ed_tile_set->get_source_id(i);
 
-			Ref<TileSetAtlasSource> tas = tile_set->get_source(source_id);
+			Ref<TileSetAtlasSource> tas = ed_tile_set->get_source(source_id);
 			if (tas.is_valid()) {
 				for (int j = 0; j < tas->get_tiles_count(); j++) {
 					Vector2i tile_id = tas->get_tile_id(j);
diff --git a/editor/plugins/tiles/tiles_editor_plugin.cpp b/editor/plugins/tiles/tiles_editor_plugin.cpp
index 17115519e2..68bc4389a2 100644
--- a/editor/plugins/tiles/tiles_editor_plugin.cpp
+++ b/editor/plugins/tiles/tiles_editor_plugin.cpp
@@ -264,8 +264,8 @@ void TilesEditorPlugin::set_sorting_option(int p_option) {
 	source_sort = p_option;
 }
 
-List<int> TilesEditorPlugin::get_sorted_sources(const Ref<TileSet> tile_set) const {
-	SourceNameComparator::tile_set = tile_set;
+List<int> TilesEditorPlugin::get_sorted_sources(const Ref<TileSet> p_tile_set) const {
+	SourceNameComparator::tile_set = p_tile_set;
 	List<int> source_ids;
 
 	for (int i = 0; i < tile_set->get_source_count(); i++) {