From 0103af1ddda6a2aa31227965141dd7d3a513e081 Mon Sep 17 00:00:00 2001
From: bruvzg <7645683+bruvzg@users.noreply.github.com>
Date: Thu, 29 Sep 2022 12:53:28 +0300
Subject: Fix MSVC warnings, rename shadowed variables, fix uninitialized
 values, change warnings=all to use /W4.

---
 modules/csg/csg_shape.cpp                          | 110 ++++++++---------
 modules/enet/enet_multiplayer_peer.cpp             |   6 +-
 modules/gdscript/editor/gdscript_highlighter.cpp   |  12 +-
 modules/gdscript/gdscript.cpp                      | 134 ++++++++++-----------
 modules/gdscript/gdscript.h                        |   2 +-
 modules/gdscript/gdscript_analyzer.cpp             |  30 ++---
 modules/gdscript/gdscript_compiler.cpp             | 104 ++++++++--------
 modules/gdscript/gdscript_compiler.h               |   8 +-
 modules/gdscript/gdscript_disassembler.cpp         |   4 +-
 modules/gdscript/gdscript_editor.cpp               |  28 ++---
 modules/gdscript/gdscript_function.cpp             |  10 +-
 modules/gdscript/gdscript_parser.cpp               |  22 ++--
 modules/gdscript/gdscript_parser.h                 |  20 +--
 modules/gdscript/gdscript_tokenizer.cpp            |  18 +--
 modules/gdscript/gdscript_vm.cpp                   |   2 +-
 .../language_server/gdscript_extend_parser.cpp     |  42 +++----
 .../language_server/gdscript_language_server.cpp   |  12 +-
 .../language_server/gdscript_text_document.cpp     |  22 ++--
 .../language_server/gdscript_workspace.cpp         |  36 +++---
 .../gltf/editor/editor_scene_importer_blend.cpp    |  10 +-
 modules/gltf/extensions/gltf_light.cpp             |   5 +-
 modules/gltf/gltf_document.cpp                     |  95 ++++++++-------
 modules/gridmap/grid_map.cpp                       |   8 +-
 modules/lightmapper_rd/lightmapper_rd.cpp          |   8 +-
 modules/multiplayer/scene_replication_config.cpp   |  16 +--
 modules/noise/noise_texture_2d.cpp                 |  18 +--
 modules/openxr/action_map/openxr_action.cpp        |   6 +-
 modules/openxr/openxr_interface.cpp                |  24 ++--
 modules/openxr/util.h                              |  84 ++++++-------
 modules/text_server_adv/text_server_adv.cpp        |   4 +-
 modules/theora/video_stream_theora.cpp             |  35 +++---
 31 files changed, 459 insertions(+), 476 deletions(-)

(limited to 'modules')

diff --git a/modules/csg/csg_shape.cpp b/modules/csg/csg_shape.cpp
index 3932c2377f..461960ab26 100644
--- a/modules/csg/csg_shape.cpp
+++ b/modules/csg/csg_shape.cpp
@@ -92,13 +92,13 @@ uint32_t CSGShape3D::get_collision_mask() const {
 void CSGShape3D::set_collision_layer_value(int p_layer_number, bool p_value) {
 	ERR_FAIL_COND_MSG(p_layer_number < 1, "Collision layer number must be between 1 and 32 inclusive.");
 	ERR_FAIL_COND_MSG(p_layer_number > 32, "Collision layer number must be between 1 and 32 inclusive.");
-	uint32_t collision_layer = get_collision_layer();
+	uint32_t layer = get_collision_layer();
 	if (p_value) {
-		collision_layer |= 1 << (p_layer_number - 1);
+		layer |= 1 << (p_layer_number - 1);
 	} else {
-		collision_layer &= ~(1 << (p_layer_number - 1));
+		layer &= ~(1 << (p_layer_number - 1));
 	}
-	set_collision_layer(collision_layer);
+	set_collision_layer(layer);
 }
 
 bool CSGShape3D::get_collision_layer_value(int p_layer_number) const {
@@ -690,7 +690,7 @@ CSGCombiner3D::CSGCombiner3D() {
 /////////////////////
 
 CSGBrush *CSGPrimitive3D::_create_brush_from_arrays(const Vector<Vector3> &p_vertices, const Vector<Vector2> &p_uv, const Vector<bool> &p_smooth, const Vector<Ref<Material>> &p_materials) {
-	CSGBrush *brush = memnew(CSGBrush);
+	CSGBrush *new_brush = memnew(CSGBrush);
 
 	Vector<bool> invert;
 	invert.resize(p_vertices.size() / 3);
@@ -701,9 +701,9 @@ CSGBrush *CSGPrimitive3D::_create_brush_from_arrays(const Vector<Vector3> &p_ver
 			w[i] = flip_faces;
 		}
 	}
-	brush->build_from_faces(p_vertices, p_uv, p_smooth, p_materials, invert);
+	new_brush->build_from_faces(p_vertices, p_uv, p_smooth, p_materials, invert);
 
-	return brush;
+	return new_brush;
 }
 
 void CSGPrimitive3D::_bind_methods() {
@@ -742,7 +742,7 @@ CSGBrush *CSGMesh3D::_build_brush() {
 	Vector<bool> smooth;
 	Vector<Ref<Material>> materials;
 	Vector<Vector2> uvs;
-	Ref<Material> material = get_material();
+	Ref<Material> base_material = get_material();
 
 	for (int i = 0; i < mesh->get_surface_count(); i++) {
 		if (mesh->surface_get_primitive_type(i) != Mesh::PRIMITIVE_TRIANGLES) {
@@ -776,8 +776,8 @@ CSGBrush *CSGMesh3D::_build_brush() {
 		}
 
 		Ref<Material> mat;
-		if (material.is_valid()) {
-			mat = material;
+		if (base_material.is_valid()) {
+			mat = base_material;
 		} else {
 			mat = mesh->surface_get_material(i);
 		}
@@ -933,12 +933,12 @@ Ref<Mesh> CSGMesh3D::get_mesh() {
 CSGBrush *CSGSphere3D::_build_brush() {
 	// set our bounding box
 
-	CSGBrush *brush = memnew(CSGBrush);
+	CSGBrush *new_brush = memnew(CSGBrush);
 
 	int face_count = rings * radial_segments * 2 - radial_segments * 2;
 
 	bool invert_val = get_flip_faces();
-	Ref<Material> material = get_material();
+	Ref<Material> base_material = get_material();
 
 	Vector<Vector3> faces;
 	Vector<Vector2> uvs;
@@ -1019,7 +1019,7 @@ CSGBrush *CSGSphere3D::_build_brush() {
 
 					smoothw[face] = smooth_faces;
 					invertw[face] = invert_val;
-					materialsw[face] = material;
+					materialsw[face] = base_material;
 
 					face++;
 				}
@@ -1036,7 +1036,7 @@ CSGBrush *CSGSphere3D::_build_brush() {
 
 					smoothw[face] = smooth_faces;
 					invertw[face] = invert_val;
-					materialsw[face] = material;
+					materialsw[face] = base_material;
 
 					face++;
 				}
@@ -1048,9 +1048,9 @@ CSGBrush *CSGSphere3D::_build_brush() {
 		}
 	}
 
-	brush->build_from_faces(faces, uvs, smooth, materials, invert);
+	new_brush->build_from_faces(faces, uvs, smooth, materials, invert);
 
-	return brush;
+	return new_brush;
 }
 
 void CSGSphere3D::_bind_methods() {
@@ -1137,12 +1137,12 @@ CSGSphere3D::CSGSphere3D() {
 CSGBrush *CSGBox3D::_build_brush() {
 	// set our bounding box
 
-	CSGBrush *brush = memnew(CSGBrush);
+	CSGBrush *new_brush = memnew(CSGBrush);
 
 	int face_count = 12; //it's a cube..
 
 	bool invert_val = get_flip_faces();
-	Ref<Material> material = get_material();
+	Ref<Material> base_material = get_material();
 
 	Vector<Vector3> faces;
 	Vector<Vector2> uvs;
@@ -1204,7 +1204,7 @@ CSGBrush *CSGBox3D::_build_brush() {
 
 				smoothw[face] = false;
 				invertw[face] = invert_val;
-				materialsw[face] = material;
+				materialsw[face] = base_material;
 
 				face++;
 				//face 2
@@ -1218,7 +1218,7 @@ CSGBrush *CSGBox3D::_build_brush() {
 
 				smoothw[face] = false;
 				invertw[face] = invert_val;
-				materialsw[face] = material;
+				materialsw[face] = base_material;
 
 				face++;
 			}
@@ -1229,9 +1229,9 @@ CSGBrush *CSGBox3D::_build_brush() {
 		}
 	}
 
-	brush->build_from_faces(faces, uvs, smooth, materials, invert);
+	new_brush->build_from_faces(faces, uvs, smooth, materials, invert);
 
-	return brush;
+	return new_brush;
 }
 
 void CSGBox3D::_bind_methods() {
@@ -1270,12 +1270,12 @@ Ref<Material> CSGBox3D::get_material() const {
 CSGBrush *CSGCylinder3D::_build_brush() {
 	// set our bounding box
 
-	CSGBrush *brush = memnew(CSGBrush);
+	CSGBrush *new_brush = memnew(CSGBrush);
 
 	int face_count = sides * (cone ? 1 : 2) + sides + (cone ? 0 : sides);
 
 	bool invert_val = get_flip_faces();
-	Ref<Material> material = get_material();
+	Ref<Material> base_material = get_material();
 
 	Vector<Vector3> faces;
 	Vector<Vector2> uvs;
@@ -1312,14 +1312,14 @@ CSGBrush *CSGCylinder3D::_build_brush() {
 				float ang = inc * Math_TAU;
 				float ang_n = inc_n * Math_TAU;
 
-				Vector3 base(Math::cos(ang), 0, Math::sin(ang));
-				Vector3 base_n(Math::cos(ang_n), 0, Math::sin(ang_n));
+				Vector3 face_base(Math::cos(ang), 0, Math::sin(ang));
+				Vector3 face_base_n(Math::cos(ang_n), 0, Math::sin(ang_n));
 
 				Vector3 face_points[4] = {
-					base + Vector3(0, -1, 0),
-					base_n + Vector3(0, -1, 0),
-					base_n * (cone ? 0.0 : 1.0) + Vector3(0, 1, 0),
-					base * (cone ? 0.0 : 1.0) + Vector3(0, 1, 0),
+					face_base + Vector3(0, -1, 0),
+					face_base_n + Vector3(0, -1, 0),
+					face_base_n * (cone ? 0.0 : 1.0) + Vector3(0, 1, 0),
+					face_base * (cone ? 0.0 : 1.0) + Vector3(0, 1, 0),
 				};
 
 				Vector2 u[4] = {
@@ -1340,7 +1340,7 @@ CSGBrush *CSGCylinder3D::_build_brush() {
 
 				smoothw[face] = smooth_faces;
 				invertw[face] = invert_val;
-				materialsw[face] = material;
+				materialsw[face] = base_material;
 
 				face++;
 
@@ -1356,7 +1356,7 @@ CSGBrush *CSGCylinder3D::_build_brush() {
 
 					smoothw[face] = smooth_faces;
 					invertw[face] = invert_val;
-					materialsw[face] = material;
+					materialsw[face] = base_material;
 					face++;
 				}
 
@@ -1371,7 +1371,7 @@ CSGBrush *CSGCylinder3D::_build_brush() {
 
 				smoothw[face] = false;
 				invertw[face] = invert_val;
-				materialsw[face] = material;
+				materialsw[face] = base_material;
 				face++;
 
 				if (!cone) {
@@ -1386,7 +1386,7 @@ CSGBrush *CSGCylinder3D::_build_brush() {
 
 					smoothw[face] = false;
 					invertw[face] = invert_val;
-					materialsw[face] = material;
+					materialsw[face] = base_material;
 					face++;
 				}
 			}
@@ -1397,9 +1397,9 @@ CSGBrush *CSGCylinder3D::_build_brush() {
 		}
 	}
 
-	brush->build_from_faces(faces, uvs, smooth, materials, invert);
+	new_brush->build_from_faces(faces, uvs, smooth, materials, invert);
 
-	return brush;
+	return new_brush;
 }
 
 void CSGCylinder3D::_bind_methods() {
@@ -1515,12 +1515,12 @@ CSGBrush *CSGTorus3D::_build_brush() {
 
 	float radius = (max_radius - min_radius) * 0.5;
 
-	CSGBrush *brush = memnew(CSGBrush);
+	CSGBrush *new_brush = memnew(CSGBrush);
 
 	int face_count = ring_sides * sides * 2;
 
 	bool invert_val = get_flip_faces();
-	Ref<Material> material = get_material();
+	Ref<Material> base_material = get_material();
 
 	Vector<Vector3> faces;
 	Vector<Vector2> uvs;
@@ -1596,7 +1596,7 @@ CSGBrush *CSGTorus3D::_build_brush() {
 
 					smoothw[face] = smooth_faces;
 					invertw[face] = invert_val;
-					materialsw[face] = material;
+					materialsw[face] = base_material;
 
 					face++;
 
@@ -1611,7 +1611,7 @@ CSGBrush *CSGTorus3D::_build_brush() {
 
 					smoothw[face] = smooth_faces;
 					invertw[face] = invert_val;
-					materialsw[face] = material;
+					materialsw[face] = base_material;
 					face++;
 				}
 			}
@@ -1622,9 +1622,9 @@ CSGBrush *CSGTorus3D::_build_brush() {
 		}
 	}
 
-	brush->build_from_faces(faces, uvs, smooth, materials, invert);
+	new_brush->build_from_faces(faces, uvs, smooth, materials, invert);
 
-	return brush;
+	return new_brush;
 }
 
 void CSGTorus3D::_bind_methods() {
@@ -1726,10 +1726,10 @@ CSGTorus3D::CSGTorus3D() {
 ///////////////
 
 CSGBrush *CSGPolygon3D::_build_brush() {
-	CSGBrush *brush = memnew(CSGBrush);
+	CSGBrush *new_brush = memnew(CSGBrush);
 
 	if (polygon.size() < 3) {
-		return brush;
+		return new_brush;
 	}
 
 	// Triangulate polygon shape.
@@ -1739,7 +1739,7 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 	}
 	int shape_sides = shape_polygon.size();
 	Vector<int> shape_faces = Geometry2D::triangulate_polygon(shape_polygon);
-	ERR_FAIL_COND_V_MSG(shape_faces.size() < 3, brush, "Failed to triangulate CSGPolygon. Make sure the polygon doesn't have any intersecting edges.");
+	ERR_FAIL_COND_V_MSG(shape_faces.size() < 3, new_brush, "Failed to triangulate CSGPolygon. Make sure the polygon doesn't have any intersecting edges.");
 
 	// Get polygon enclosing Rect2.
 	Rect2 shape_rect(shape_polygon[0], Vector2());
@@ -1764,12 +1764,12 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 		}
 
 		if (!path) {
-			return brush;
+			return new_brush;
 		}
 
 		curve = path->get_curve();
 		if (curve.is_null() || curve->get_point_count() < 2) {
-			return brush;
+			return new_brush;
 		}
 	}
 
@@ -1806,7 +1806,7 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 	int face_count = extrusions * extrusion_face_count + end_count * shape_face_count;
 
 	// Initialize variables used to create the mesh.
-	Ref<Material> material = get_material();
+	Ref<Material> base_material = get_material();
 
 	Vector<Vector3> faces;
 	Vector<Vector2> uvs;
@@ -1896,7 +1896,7 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 				}
 
 				smoothw[face] = false;
-				materialsw[face] = material;
+				materialsw[face] = base_material;
 				invertw[face] = flip_faces;
 				face++;
 			}
@@ -2003,7 +2003,7 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 
 				smoothw[face] = smooth_faces;
 				invertw[face] = flip_faces;
-				materialsw[face] = material;
+				materialsw[face] = base_material;
 
 				face++;
 
@@ -2018,7 +2018,7 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 
 				smoothw[face] = smooth_faces;
 				invertw[face] = flip_faces;
-				materialsw[face] = material;
+				materialsw[face] = base_material;
 
 				face++;
 			}
@@ -2041,14 +2041,14 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 				}
 
 				smoothw[face] = false;
-				materialsw[face] = material;
+				materialsw[face] = base_material;
 				invertw[face] = flip_faces;
 				face++;
 			}
 		}
 
 		face_count -= faces_removed;
-		ERR_FAIL_COND_V_MSG(face != face_count, brush, "Bug: Failed to create the CSGPolygon mesh correctly.");
+		ERR_FAIL_COND_V_MSG(face != face_count, new_brush, "Bug: Failed to create the CSGPolygon mesh correctly.");
 	}
 
 	if (faces_removed > 0) {
@@ -2059,9 +2059,9 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 		invert.resize(face_count);
 	}
 
-	brush->build_from_faces(faces, uvs, smooth, materials, invert);
+	new_brush->build_from_faces(faces, uvs, smooth, materials, invert);
 
-	return brush;
+	return new_brush;
 }
 
 void CSGPolygon3D::_notification(int p_what) {
diff --git a/modules/enet/enet_multiplayer_peer.cpp b/modules/enet/enet_multiplayer_peer.cpp
index dfdd08c9f4..e7728f4aec 100644
--- a/modules/enet/enet_multiplayer_peer.cpp
+++ b/modules/enet/enet_multiplayer_peer.cpp
@@ -436,9 +436,9 @@ Error ENetMultiplayerPeer::put_packet(const uint8_t *p_buffer, int p_buffer_size
 
 	int packet_flags = 0;
 	int channel = SYSCH_RELIABLE;
-	int transfer_channel = get_transfer_channel();
-	if (transfer_channel > 0) {
-		channel = SYSCH_MAX + transfer_channel - 1;
+	int tr_channel = get_transfer_channel();
+	if (tr_channel > 0) {
+		channel = SYSCH_MAX + tr_channel - 1;
 	} else {
 		switch (get_transfer_mode()) {
 			case TRANSFER_MODE_UNRELIABLE: {
diff --git a/modules/gdscript/editor/gdscript_highlighter.cpp b/modules/gdscript/editor/gdscript_highlighter.cpp
index 8b27307d0c..8645aa6f15 100644
--- a/modules/gdscript/editor/gdscript_highlighter.cpp
+++ b/modules/gdscript/editor/gdscript_highlighter.cpp
@@ -653,23 +653,23 @@ void GDScriptSyntaxHighlighter::_update_cache() {
 		add_color_region(beg, end, string_color, end.is_empty());
 	}
 
-	const Ref<Script> script = _get_edited_resource();
-	if (script.is_valid()) {
+	const Ref<Script> scr = _get_edited_resource();
+	if (scr.is_valid()) {
 		/* Member types. */
 		const Color member_variable_color = EDITOR_GET("text_editor/theme/highlighting/member_variable_color");
-		StringName instance_base = script->get_instance_base_type();
+		StringName instance_base = scr->get_instance_base_type();
 		if (instance_base != StringName()) {
 			List<PropertyInfo> plist;
 			ClassDB::get_property_list(instance_base, &plist);
 			for (const PropertyInfo &E : plist) {
-				String name = E.name;
+				String prop_name = E.name;
 				if (E.usage & PROPERTY_USAGE_CATEGORY || E.usage & PROPERTY_USAGE_GROUP || E.usage & PROPERTY_USAGE_SUBGROUP) {
 					continue;
 				}
-				if (name.contains("/")) {
+				if (prop_name.contains("/")) {
 					continue;
 				}
-				member_keywords[name] = member_variable_color;
+				member_keywords[prop_name] = member_variable_color;
 			}
 
 			List<String> clist;
diff --git a/modules/gdscript/gdscript.cpp b/modules/gdscript/gdscript.cpp
index 340f2af693..0a9dad04c7 100644
--- a/modules/gdscript/gdscript.cpp
+++ b/modules/gdscript/gdscript.cpp
@@ -111,9 +111,9 @@ GDScriptFunction *GDScript::_super_constructor(GDScript *p_script) {
 	if (p_script->initializer) {
 		return p_script->initializer;
 	} else {
-		GDScript *base = p_script->_base;
-		if (base != nullptr) {
-			return _super_constructor(base);
+		GDScript *base_src = p_script->_base;
+		if (base_src != nullptr) {
+			return _super_constructor(base_src);
 		} else {
 			return nullptr;
 		}
@@ -121,9 +121,9 @@ GDScriptFunction *GDScript::_super_constructor(GDScript *p_script) {
 }
 
 void GDScript::_super_implicit_constructor(GDScript *p_script, GDScriptInstance *p_instance, Callable::CallError &r_error) {
-	GDScript *base = p_script->_base;
-	if (base != nullptr) {
-		_super_implicit_constructor(base, p_instance, r_error);
+	GDScript *base_src = p_script->_base;
+	if (base_src != nullptr) {
+		_super_implicit_constructor(base_src, p_instance, r_error);
 		if (r_error.error != Callable::CallError::CALL_OK) {
 			return;
 		}
@@ -151,7 +151,7 @@ GDScriptInstance *GDScript::_create_instance(const Variant **p_args, int p_argco
 
 	/* STEP 2, INITIALIZE AND CONSTRUCT */
 	{
-		MutexLock lock(GDScriptLanguage::singleton->lock);
+		MutexLock lock(GDScriptLanguage::singleton->mutex);
 		instances.insert(instance->owner);
 	}
 
@@ -160,7 +160,7 @@ GDScriptInstance *GDScript::_create_instance(const Variant **p_args, int p_argco
 		instance->script = Ref<GDScript>();
 		instance->owner->set_script_instance(nullptr);
 		{
-			MutexLock lock(GDScriptLanguage::singleton->lock);
+			MutexLock lock(GDScriptLanguage::singleton->mutex);
 			instances.erase(p_owner);
 		}
 		ERR_FAIL_V_MSG(nullptr, "Error constructing a GDScriptInstance.");
@@ -177,7 +177,7 @@ GDScriptInstance *GDScript::_create_instance(const Variant **p_args, int p_argco
 			instance->script = Ref<GDScript>();
 			instance->owner->set_script_instance(nullptr);
 			{
-				MutexLock lock(GDScriptLanguage::singleton->lock);
+				MutexLock lock(GDScriptLanguage::singleton->mutex);
 				instances.erase(p_owner);
 			}
 			ERR_FAIL_V_MSG(nullptr, "Error constructing a GDScriptInstance.");
@@ -418,7 +418,7 @@ PlaceHolderScriptInstance *GDScript::placeholder_instance_create(Object *p_this)
 }
 
 bool GDScript::instance_has(const Object *p_this) const {
-	MutexLock lock(GDScriptLanguage::singleton->lock);
+	MutexLock lock(GDScriptLanguage::singleton->mutex);
 
 	return instances.has((Object *)p_this);
 }
@@ -620,11 +620,11 @@ void GDScript::_update_doc() {
 		}
 		if (!is_enum) {
 			DocData::ConstantDoc constant_doc;
-			String doc_description;
+			String const_description;
 			if (doc_constants.has(E.key)) {
-				doc_description = doc_constants[E.key];
+				const_description = doc_constants[E.key];
 			}
-			DocData::constant_doc_from_variant(constant_doc, E.key, E.value, doc_description);
+			DocData::constant_doc_from_variant(constant_doc, E.key, E.value, const_description);
 			doc.constants.push_back(constant_doc);
 		}
 	}
@@ -675,35 +675,35 @@ bool GDScript::_update_exports(bool *r_err, bool p_recursive_call, PlaceHolderSc
 			}
 
 			if (c->extends_used) {
-				String path = "";
+				String ext_path = "";
 				if (String(c->extends_path) != "" && String(c->extends_path) != get_path()) {
-					path = c->extends_path;
-					if (path.is_relative_path()) {
-						String base = get_path();
-						if (base.is_empty() || base.is_relative_path()) {
-							ERR_PRINT(("Could not resolve relative path for parent class: " + path).utf8().get_data());
+					ext_path = c->extends_path;
+					if (ext_path.is_relative_path()) {
+						String base_path = get_path();
+						if (base_path.is_empty() || base_path.is_relative_path()) {
+							ERR_PRINT(("Could not resolve relative path for parent class: " + ext_path).utf8().get_data());
 						} else {
-							path = base.get_base_dir().path_join(path);
+							ext_path = base_path.get_base_dir().path_join(ext_path);
 						}
 					}
 				} else if (c->extends.size() != 0) {
-					const StringName &base = c->extends[0];
+					const StringName &base_class = c->extends[0];
 
-					if (ScriptServer::is_global_class(base)) {
-						path = ScriptServer::get_global_class_path(base);
+					if (ScriptServer::is_global_class(base_class)) {
+						ext_path = ScriptServer::get_global_class_path(base_class);
 					}
 				}
 
-				if (!path.is_empty()) {
-					if (path != get_path()) {
-						Ref<GDScript> bf = ResourceLoader::load(path);
+				if (!ext_path.is_empty()) {
+					if (ext_path != get_path()) {
+						Ref<GDScript> bf = ResourceLoader::load(ext_path);
 
 						if (bf.is_valid()) {
 							base_cache = bf;
 							bf->inheriters_cache.insert(get_instance_id());
 						}
 					} else {
-						ERR_PRINT(("Path extending itself in  " + path).utf8().get_data());
+						ERR_PRINT(("Path extending itself in  " + ext_path).utf8().get_data());
 					}
 				}
 			}
@@ -843,7 +843,7 @@ String GDScript::_get_debug_path() const {
 Error GDScript::reload(bool p_keep_state) {
 	bool has_instances;
 	{
-		MutexLock lock(GDScriptLanguage::singleton->lock);
+		MutexLock lock(GDScriptLanguage::singleton->mutex);
 
 		has_instances = instances.size();
 	}
@@ -1187,7 +1187,7 @@ GDScript::GDScript() :
 		script_list(this) {
 #ifdef DEBUG_ENABLED
 	{
-		MutexLock lock(GDScriptLanguage::get_singleton()->lock);
+		MutexLock lock(GDScriptLanguage::get_singleton()->mutex);
 
 		GDScriptLanguage::get_singleton()->script_list.add(&script_list);
 	}
@@ -1258,7 +1258,7 @@ void GDScript::_init_rpc_methods_properties() {
 
 GDScript::~GDScript() {
 	{
-		MutexLock lock(GDScriptLanguage::get_singleton()->lock);
+		MutexLock lock(GDScriptLanguage::get_singleton()->mutex);
 
 		while (SelfList<GDScriptFunctionState> *E = pending_func_states.first()) {
 			// Order matters since clearing the stack may already cause
@@ -1295,7 +1295,7 @@ GDScript::~GDScript() {
 
 #ifdef DEBUG_ENABLED
 	{
-		MutexLock lock(GDScriptLanguage::get_singleton()->lock);
+		MutexLock lock(GDScriptLanguage::get_singleton()->mutex);
 
 		GDScriptLanguage::get_singleton()->script_list.remove(&script_list);
 	}
@@ -1722,7 +1722,7 @@ GDScriptInstance::GDScriptInstance() {
 }
 
 GDScriptInstance::~GDScriptInstance() {
-	MutexLock lock(GDScriptLanguage::get_singleton()->lock);
+	MutexLock lock(GDScriptLanguage::get_singleton()->mutex);
 
 	while (SelfList<GDScriptFunctionState> *E = pending_func_states.first()) {
 		// Order matters since clearing the stack may already cause
@@ -1825,7 +1825,7 @@ void GDScriptLanguage::finish() {
 
 void GDScriptLanguage::profiling_start() {
 #ifdef DEBUG_ENABLED
-	MutexLock lock(this->lock);
+	MutexLock lock(this->mutex);
 
 	SelfList<GDScriptFunction> *elem = function_list.first();
 	while (elem) {
@@ -1847,7 +1847,7 @@ void GDScriptLanguage::profiling_start() {
 
 void GDScriptLanguage::profiling_stop() {
 #ifdef DEBUG_ENABLED
-	MutexLock lock(this->lock);
+	MutexLock lock(this->mutex);
 
 	profiling = false;
 #endif
@@ -1857,7 +1857,7 @@ int GDScriptLanguage::profiling_get_accumulated_data(ProfilingInfo *p_info_arr,
 	int current = 0;
 #ifdef DEBUG_ENABLED
 
-	MutexLock lock(this->lock);
+	MutexLock lock(this->mutex);
 
 	SelfList<GDScriptFunction> *elem = function_list.first();
 	while (elem) {
@@ -1880,7 +1880,7 @@ int GDScriptLanguage::profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_
 	int current = 0;
 
 #ifdef DEBUG_ENABLED
-	MutexLock lock(this->lock);
+	MutexLock lock(this->mutex);
 
 	SelfList<GDScriptFunction> *elem = function_list.first();
 	while (elem) {
@@ -1926,7 +1926,7 @@ void GDScriptLanguage::reload_all_scripts() {
 	print_verbose("GDScript: Reloading all scripts");
 	List<Ref<GDScript>> scripts;
 	{
-		MutexLock lock(this->lock);
+		MutexLock lock(this->mutex);
 
 		SelfList<GDScript> *elem = script_list.first();
 		while (elem) {
@@ -1942,10 +1942,10 @@ void GDScriptLanguage::reload_all_scripts() {
 
 	scripts.sort_custom<GDScriptDepSort>(); //update in inheritance dependency order
 
-	for (Ref<GDScript> &script : scripts) {
-		print_verbose("GDScript: Reloading: " + script->get_path());
-		script->load_source_code(script->get_path());
-		script->reload(true);
+	for (Ref<GDScript> &scr : scripts) {
+		print_verbose("GDScript: Reloading: " + scr->get_path());
+		scr->load_source_code(scr->get_path());
+		scr->reload(true);
 	}
 #endif
 }
@@ -1955,7 +1955,7 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so
 
 	List<Ref<GDScript>> scripts;
 	{
-		MutexLock lock(this->lock);
+		MutexLock lock(this->mutex);
 
 		SelfList<GDScript> *elem = script_list.first();
 		while (elem) {
@@ -1974,21 +1974,21 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so
 
 	scripts.sort_custom<GDScriptDepSort>(); //update in inheritance dependency order
 
-	for (Ref<GDScript> &script : scripts) {
-		bool reload = script == p_script || to_reload.has(script->get_base());
+	for (Ref<GDScript> &scr : scripts) {
+		bool reload = scr == p_script || to_reload.has(scr->get_base());
 
 		if (!reload) {
 			continue;
 		}
 
-		to_reload.insert(script, HashMap<ObjectID, List<Pair<StringName, Variant>>>());
+		to_reload.insert(scr, HashMap<ObjectID, List<Pair<StringName, Variant>>>());
 
 		if (!p_soft_reload) {
 			//save state and remove script from instances
-			HashMap<ObjectID, List<Pair<StringName, Variant>>> &map = to_reload[script];
+			HashMap<ObjectID, List<Pair<StringName, Variant>>> &map = to_reload[scr];
 
-			while (script->instances.front()) {
-				Object *obj = script->instances.front()->get();
+			while (scr->instances.front()) {
+				Object *obj = scr->instances.front()->get();
 				//save instance info
 				List<Pair<StringName, Variant>> state;
 				if (obj->get_script_instance()) {
@@ -2001,8 +2001,8 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so
 //same thing for placeholders
 #ifdef TOOLS_ENABLED
 
-			while (script->placeholders.size()) {
-				Object *obj = (*script->placeholders.begin())->get_owner();
+			while (scr->placeholders.size()) {
+				Object *obj = (*scr->placeholders.begin())->get_owner();
 
 				//save instance info
 				if (obj->get_script_instance()) {
@@ -2012,13 +2012,13 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so
 					obj->set_script(Variant());
 				} else {
 					// no instance found. Let's remove it so we don't loop forever
-					script->placeholders.erase(*script->placeholders.begin());
+					scr->placeholders.erase(*scr->placeholders.begin());
 				}
 			}
 
 #endif
 
-			for (const KeyValue<ObjectID, List<Pair<StringName, Variant>>> &F : script->pending_reload_state) {
+			for (const KeyValue<ObjectID, List<Pair<StringName, Variant>>> &F : scr->pending_reload_state) {
 				map[F.key] = F.value; //pending to reload, use this one instead
 			}
 		}
@@ -2043,9 +2043,9 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so
 			}
 			obj->set_script(scr);
 
-			ScriptInstance *script_instance = obj->get_script_instance();
+			ScriptInstance *script_inst = obj->get_script_instance();
 
-			if (!script_instance) {
+			if (!script_inst) {
 				//failed, save reload state for next time if not saved
 				if (!scr->pending_reload_state.has(obj->get_instance_id())) {
 					scr->pending_reload_state[obj->get_instance_id()] = saved_state;
@@ -2053,14 +2053,14 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so
 				continue;
 			}
 
-			if (script_instance->is_placeholder() && scr->is_placeholder_fallback_enabled()) {
-				PlaceHolderScriptInstance *placeholder = static_cast<PlaceHolderScriptInstance *>(script_instance);
+			if (script_inst->is_placeholder() && scr->is_placeholder_fallback_enabled()) {
+				PlaceHolderScriptInstance *placeholder = static_cast<PlaceHolderScriptInstance *>(script_inst);
 				for (List<Pair<StringName, Variant>>::Element *G = saved_state.front(); G; G = G->next()) {
 					placeholder->property_set_fallback(G->get().first, G->get().second);
 				}
 			} else {
 				for (List<Pair<StringName, Variant>>::Element *G = saved_state.front(); G; G = G->next()) {
-					script_instance->set(G->get().first, G->get().second);
+					script_inst->set(G->get().first, G->get().second);
 				}
 			}
 
@@ -2078,7 +2078,7 @@ void GDScriptLanguage::frame() {
 
 #ifdef DEBUG_ENABLED
 	if (profiling) {
-		MutexLock lock(this->lock);
+		MutexLock lock(this->mutex);
 
 		SelfList<GDScriptFunction> *elem = function_list.first();
 		while (elem) {
@@ -2339,26 +2339,26 @@ GDScriptLanguage::~GDScriptLanguage() {
 	// Clear dependencies between scripts, to ensure cyclic references are broken (to avoid leaks at exit).
 	SelfList<GDScript> *s = script_list.first();
 	while (s) {
-		GDScript *script = s->self();
+		GDScript *scr = s->self();
 		// This ensures the current script is not released before we can check what's the next one
 		// in the list (we can't get the next upfront because we don't know if the reference breaking
 		// will cause it -or any other after it, for that matter- to be released so the next one
 		// is not the same as before).
-		script->reference();
+		scr->reference();
 
-		for (KeyValue<StringName, GDScriptFunction *> &E : script->member_functions) {
+		for (KeyValue<StringName, GDScriptFunction *> &E : scr->member_functions) {
 			GDScriptFunction *func = E.value;
 			for (int i = 0; i < func->argument_types.size(); i++) {
 				func->argument_types.write[i].script_type_ref = Ref<Script>();
 			}
 			func->return_type.script_type_ref = Ref<Script>();
 		}
-		for (KeyValue<StringName, GDScript::MemberInfo> &E : script->member_indices) {
+		for (KeyValue<StringName, GDScript::MemberInfo> &E : scr->member_indices) {
 			E.value.data_type.script_type_ref = Ref<Script>();
 		}
 
 		s = s->next();
-		script->unreference();
+		scr->unreference();
 	}
 
 	singleton = nullptr;
@@ -2390,20 +2390,20 @@ Ref<Resource> ResourceFormatLoaderGDScript::load(const String &p_path, const Str
 	}
 
 	Error err;
-	Ref<GDScript> script = GDScriptCache::get_full_script(p_path, err, "", p_cache_mode == CACHE_MODE_IGNORE);
+	Ref<GDScript> scr = GDScriptCache::get_full_script(p_path, err, "", p_cache_mode == CACHE_MODE_IGNORE);
 
 	// TODO: Reintroduce binary and encrypted scripts.
 
-	if (script.is_null()) {
+	if (scr.is_null()) {
 		// Don't fail loading because of parsing error.
-		script.instantiate();
+		scr.instantiate();
 	}
 
 	if (r_error) {
 		*r_error = OK;
 	}
 
-	return script;
+	return scr;
 }
 
 void ResourceFormatLoaderGDScript::get_recognized_extensions(List<String> *p_extensions) const {
diff --git a/modules/gdscript/gdscript.h b/modules/gdscript/gdscript.h
index e4b12d4ddb..0a010e5ad0 100644
--- a/modules/gdscript/gdscript.h
+++ b/modules/gdscript/gdscript.h
@@ -342,7 +342,7 @@ class GDScriptLanguage : public ScriptLanguage {
 
 	friend class GDScriptInstance;
 
-	Mutex lock;
+	Mutex mutex;
 
 	friend class GDScript;
 
diff --git a/modules/gdscript/gdscript_analyzer.cpp b/modules/gdscript/gdscript_analyzer.cpp
index 32d9aec84f..e1beb2f374 100644
--- a/modules/gdscript/gdscript_analyzer.cpp
+++ b/modules/gdscript/gdscript_analyzer.cpp
@@ -262,19 +262,19 @@ Error GDScriptAnalyzer::resolve_inheritance(GDScriptParser::ClassNode *p_class,
 			if (p_class->extends_path.is_relative_path()) {
 				p_class->extends_path = class_type.script_path.get_base_dir().path_join(p_class->extends_path).simplify_path();
 			}
-			Ref<GDScriptParserRef> parser = get_parser_for(p_class->extends_path);
-			if (parser.is_null()) {
+			Ref<GDScriptParserRef> ext_parser = get_parser_for(p_class->extends_path);
+			if (ext_parser.is_null()) {
 				push_error(vformat(R"(Could not resolve super class path "%s".)", p_class->extends_path), p_class);
 				return ERR_PARSE_ERROR;
 			}
 
-			Error err = parser->raise_status(GDScriptParserRef::INTERFACE_SOLVED);
+			Error err = ext_parser->raise_status(GDScriptParserRef::INTERFACE_SOLVED);
 			if (err != OK) {
 				push_error(vformat(R"(Could not resolve super class inheritance from "%s".)", p_class->extends_path), p_class);
 				return err;
 			}
 
-			base = parser->get_parser()->head->get_datatype();
+			base = ext_parser->get_parser()->head->get_datatype();
 		} else {
 			if (p_class->extends.is_empty()) {
 				push_error("Could not resolve an empty super class path.", p_class);
@@ -289,18 +289,18 @@ Error GDScriptAnalyzer::resolve_inheritance(GDScriptParser::ClassNode *p_class,
 				if (base_path == parser->script_path) {
 					base = parser->head->get_datatype();
 				} else {
-					Ref<GDScriptParserRef> parser = get_parser_for(base_path);
-					if (parser.is_null()) {
+					Ref<GDScriptParserRef> base_parser = get_parser_for(base_path);
+					if (base_parser.is_null()) {
 						push_error(vformat(R"(Could not resolve super class "%s".)", name), p_class);
 						return ERR_PARSE_ERROR;
 					}
 
-					Error err = parser->raise_status(GDScriptParserRef::INTERFACE_SOLVED);
+					Error err = base_parser->raise_status(GDScriptParserRef::INTERFACE_SOLVED);
 					if (err != OK) {
 						push_error(vformat(R"(Could not resolve super class inheritance from "%s".)", name), p_class);
 						return err;
 					}
-					base = parser->get_parser()->head->get_datatype();
+					base = base_parser->get_parser()->head->get_datatype();
 				}
 			} else if (ProjectSettings::get_singleton()->has_autoload(name) && ProjectSettings::get_singleton()->get_autoload(name).is_singleton) {
 				const ProjectSettings::AutoloadInfo &info = ProjectSettings::get_singleton()->get_autoload(name);
@@ -309,13 +309,13 @@ Error GDScriptAnalyzer::resolve_inheritance(GDScriptParser::ClassNode *p_class,
 					return ERR_PARSE_ERROR;
 				}
 
-				Ref<GDScriptParserRef> parser = get_parser_for(info.path);
-				if (parser.is_null()) {
+				Ref<GDScriptParserRef> info_parser = get_parser_for(info.path);
+				if (info_parser.is_null()) {
 					push_error(vformat(R"(Could not parse singleton from "%s".)", info.path), p_class);
 					return ERR_PARSE_ERROR;
 				}
 
-				Error err = parser->raise_status(GDScriptParserRef::INTERFACE_SOLVED);
+				Error err = info_parser->raise_status(GDScriptParserRef::INTERFACE_SOLVED);
 				if (err != OK) {
 					push_error(vformat(R"(Could not resolve super class inheritance from "%s".)", name), p_class);
 					return err;
@@ -3093,11 +3093,11 @@ void GDScriptAnalyzer::reduce_identifier(GDScriptParser::IdentifierNode *p_ident
 			result.kind = GDScriptParser::DataType::NATIVE;
 			result.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
 			if (autoload.path.to_lower().ends_with(GDScriptLanguage::get_singleton()->get_extension())) {
-				Ref<GDScriptParserRef> parser = get_parser_for(autoload.path);
-				if (parser.is_valid()) {
-					Error err = parser->raise_status(GDScriptParserRef::INTERFACE_SOLVED);
+				Ref<GDScriptParserRef> singl_parser = get_parser_for(autoload.path);
+				if (singl_parser.is_valid()) {
+					Error err = singl_parser->raise_status(GDScriptParserRef::INTERFACE_SOLVED);
 					if (err == OK) {
-						result = type_from_metatype(parser->get_parser()->head->get_datatype());
+						result = type_from_metatype(singl_parser->get_parser()->head->get_datatype());
 					}
 				}
 			}
diff --git a/modules/gdscript/gdscript_compiler.cpp b/modules/gdscript/gdscript_compiler.cpp
index fd418ced47..7acd1cdb96 100644
--- a/modules/gdscript/gdscript_compiler.cpp
+++ b/modules/gdscript/gdscript_compiler.cpp
@@ -522,11 +522,11 @@ GDScriptCodeGenerator::Address GDScriptCompiler::_parse_expression(CodeGen &code
 			// Create temporary for result first since it will be deleted last.
 			GDScriptCodeGenerator::Address result = codegen.add_temporary(cast_type);
 
-			GDScriptCodeGenerator::Address source = _parse_expression(codegen, r_error, cn->operand);
+			GDScriptCodeGenerator::Address src = _parse_expression(codegen, r_error, cn->operand);
 
-			gen->write_cast(result, source, cast_type);
+			gen->write_cast(result, src, cast_type);
 
-			if (source.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
+			if (src.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
 				gen->pop_temporary();
 			}
 
@@ -1650,7 +1650,7 @@ void GDScriptCompiler::_add_locals_in_block(CodeGen &codegen, const GDScriptPars
 }
 
 Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::SuiteNode *p_block, bool p_add_locals) {
-	Error error = OK;
+	Error err = OK;
 	GDScriptCodeGenerator *gen = codegen.generator;
 
 	codegen.start_block();
@@ -1676,9 +1676,9 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Sui
 
 				// Evaluate the match expression.
 				GDScriptCodeGenerator::Address value = codegen.add_local("@match_value", _gdtype_from_datatype(match->test->get_datatype()));
-				GDScriptCodeGenerator::Address value_expr = _parse_expression(codegen, error, match->test);
-				if (error) {
-					return error;
+				GDScriptCodeGenerator::Address value_expr = _parse_expression(codegen, err, match->test);
+				if (err) {
+					return err;
 				}
 
 				// Assign to local.
@@ -1723,9 +1723,9 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Sui
 					// For each pattern in branch.
 					GDScriptCodeGenerator::Address pattern_result = codegen.add_temporary();
 					for (int k = 0; k < branch->patterns.size(); k++) {
-						pattern_result = _parse_match_pattern(codegen, error, branch->patterns[k], value, type, pattern_result, k == 0, false);
-						if (error != OK) {
-							return error;
+						pattern_result = _parse_match_pattern(codegen, err, branch->patterns[k], value, type, pattern_result, k == 0, false);
+						if (err != OK) {
+							return err;
 						}
 					}
 
@@ -1736,9 +1736,9 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Sui
 					gen->pop_temporary();
 
 					// Parse the branch block.
-					error = _parse_block(codegen, branch->block, false); // Don't add locals again.
-					if (error) {
-						return error;
+					err = _parse_block(codegen, branch->block, false); // Don't add locals again.
+					if (err) {
+						return err;
 					}
 
 					codegen.end_block(); // Get out of extra block.
@@ -1753,9 +1753,9 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Sui
 			} break;
 			case GDScriptParser::Node::IF: {
 				const GDScriptParser::IfNode *if_n = static_cast<const GDScriptParser::IfNode *>(s);
-				GDScriptCodeGenerator::Address condition = _parse_expression(codegen, error, if_n->condition);
-				if (error) {
-					return error;
+				GDScriptCodeGenerator::Address condition = _parse_expression(codegen, err, if_n->condition);
+				if (err) {
+					return err;
 				}
 
 				gen->write_if(condition);
@@ -1764,17 +1764,17 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Sui
 					codegen.generator->pop_temporary();
 				}
 
-				error = _parse_block(codegen, if_n->true_block);
-				if (error) {
-					return error;
+				err = _parse_block(codegen, if_n->true_block);
+				if (err) {
+					return err;
 				}
 
 				if (if_n->false_block) {
 					gen->write_else();
 
-					error = _parse_block(codegen, if_n->false_block);
-					if (error) {
-						return error;
+					err = _parse_block(codegen, if_n->false_block);
+					if (err) {
+						return err;
 					}
 				}
 
@@ -1788,9 +1788,9 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Sui
 
 				gen->start_for(iterator.type, _gdtype_from_datatype(for_n->list->get_datatype()));
 
-				GDScriptCodeGenerator::Address list = _parse_expression(codegen, error, for_n->list);
-				if (error) {
-					return error;
+				GDScriptCodeGenerator::Address list = _parse_expression(codegen, err, for_n->list);
+				if (err) {
+					return err;
 				}
 
 				gen->write_for_assignment(iterator, list);
@@ -1801,9 +1801,9 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Sui
 
 				gen->write_for();
 
-				error = _parse_block(codegen, for_n->loop);
-				if (error) {
-					return error;
+				err = _parse_block(codegen, for_n->loop);
+				if (err) {
+					return err;
 				}
 
 				gen->write_endfor();
@@ -1815,9 +1815,9 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Sui
 
 				gen->start_while_condition();
 
-				GDScriptCodeGenerator::Address condition = _parse_expression(codegen, error, while_n->condition);
-				if (error) {
-					return error;
+				GDScriptCodeGenerator::Address condition = _parse_expression(codegen, err, while_n->condition);
+				if (err) {
+					return err;
 				}
 
 				gen->write_while(condition);
@@ -1826,9 +1826,9 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Sui
 					codegen.generator->pop_temporary();
 				}
 
-				error = _parse_block(codegen, while_n->loop);
-				if (error) {
-					return error;
+				err = _parse_block(codegen, while_n->loop);
+				if (err) {
+					return err;
 				}
 
 				gen->write_endwhile();
@@ -1850,9 +1850,9 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Sui
 				GDScriptCodeGenerator::Address return_value;
 
 				if (return_n->return_value != nullptr) {
-					return_value = _parse_expression(codegen, error, return_n->return_value);
-					if (error) {
-						return error;
+					return_value = _parse_expression(codegen, err, return_n->return_value);
+					if (err) {
+						return err;
 					}
 				}
 
@@ -1865,17 +1865,17 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Sui
 #ifdef DEBUG_ENABLED
 				const GDScriptParser::AssertNode *as = static_cast<const GDScriptParser::AssertNode *>(s);
 
-				GDScriptCodeGenerator::Address condition = _parse_expression(codegen, error, as->condition);
-				if (error) {
-					return error;
+				GDScriptCodeGenerator::Address condition = _parse_expression(codegen, err, as->condition);
+				if (err) {
+					return err;
 				}
 
 				GDScriptCodeGenerator::Address message;
 
 				if (as->message) {
-					message = _parse_expression(codegen, error, as->message);
-					if (error) {
-						return error;
+					message = _parse_expression(codegen, err, as->message);
+					if (err) {
+						return err;
 					}
 				}
 				gen->write_assert(condition, message);
@@ -1908,9 +1908,9 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Sui
 							codegen.generator->write_construct_array(local, Vector<GDScriptCodeGenerator::Address>());
 						}
 					}
-					GDScriptCodeGenerator::Address src_address = _parse_expression(codegen, error, lv->initializer);
-					if (error) {
-						return error;
+					GDScriptCodeGenerator::Address src_address = _parse_expression(codegen, err, lv->initializer);
+					if (err) {
+						return err;
 					}
 					if (lv->use_conversion_assign) {
 						gen->write_assign_with_conversion(local, src_address);
@@ -1946,9 +1946,9 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Sui
 			default: {
 				// Expression.
 				if (s->is_expression()) {
-					GDScriptCodeGenerator::Address expr = _parse_expression(codegen, error, static_cast<const GDScriptParser::ExpressionNode *>(s), true);
-					if (error) {
-						return error;
+					GDScriptCodeGenerator::Address expr = _parse_expression(codegen, err, static_cast<const GDScriptParser::ExpressionNode *>(s), true);
+					if (err) {
+						return err;
 					}
 					if (expr.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
 						codegen.generator->pop_temporary();
@@ -2180,7 +2180,7 @@ GDScriptFunction *GDScriptCompiler::_parse_function(Error &r_error, GDScript *p_
 }
 
 Error GDScriptCompiler::_parse_setter_getter(GDScript *p_script, const GDScriptParser::ClassNode *p_class, const GDScriptParser::VariableNode *p_variable, bool p_is_setter) {
-	Error error = OK;
+	Error err = OK;
 
 	GDScriptParser::FunctionNode *function;
 
@@ -2190,9 +2190,9 @@ Error GDScriptCompiler::_parse_setter_getter(GDScript *p_script, const GDScriptP
 		function = p_variable->getter;
 	}
 
-	_parse_function(error, p_script, p_class, function);
+	_parse_function(err, p_script, p_class, function);
 
-	return error;
+	return err;
 }
 
 Error GDScriptCompiler::_parse_class_level(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state) {
diff --git a/modules/gdscript/gdscript_compiler.h b/modules/gdscript/gdscript_compiler.h
index 4841884e2d..e4264ea55b 100644
--- a/modules/gdscript/gdscript_compiler.h
+++ b/modules/gdscript/gdscript_compiler.h
@@ -81,10 +81,10 @@ class GDScriptCompiler {
 					type.kind = GDScriptDataType::NATIVE;
 					type.native_type = obj->get_class_name();
 
-					Ref<Script> script = obj->get_script();
-					if (script.is_valid()) {
-						type.script_type = script.ptr();
-						Ref<GDScript> gdscript = script;
+					Ref<Script> scr = obj->get_script();
+					if (scr.is_valid()) {
+						type.script_type = scr.ptr();
+						Ref<GDScript> gdscript = scr;
 						if (gdscript.is_valid()) {
 							type.kind = GDScriptDataType::GDSCRIPT;
 						} else {
diff --git a/modules/gdscript/gdscript_disassembler.cpp b/modules/gdscript/gdscript_disassembler.cpp
index b38c7c6699..b5a209c805 100644
--- a/modules/gdscript/gdscript_disassembler.cpp
+++ b/modules/gdscript/gdscript_disassembler.cpp
@@ -104,10 +104,10 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
 		text += ": ";
 
 		// This makes the compiler complain if some opcode is unchecked in the switch.
-		Opcode code = Opcode(_code_ptr[ip] & INSTR_MASK);
+		Opcode opcode = Opcode(_code_ptr[ip] & INSTR_MASK);
 		int instr_var_args = (_code_ptr[ip] & INSTR_ARGS_MASK) >> INSTR_BITS;
 
-		switch (code) {
+		switch (opcode) {
 			case OPCODE_OPERATOR: {
 				int operation = _code_ptr[ip + 4];
 
diff --git a/modules/gdscript/gdscript_editor.cpp b/modules/gdscript/gdscript_editor.cpp
index 487a9dd35e..3c68993b36 100644
--- a/modules/gdscript/gdscript_editor.cpp
+++ b/modules/gdscript/gdscript_editor.cpp
@@ -61,8 +61,8 @@ bool GDScriptLanguage::is_using_templates() {
 }
 
 Ref<Script> GDScriptLanguage::make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const {
-	Ref<GDScript> script;
-	script.instantiate();
+	Ref<GDScript> scr;
+	scr.instantiate();
 	String processed_template = p_template;
 	bool type_hints = false;
 #ifdef TOOLS_ENABLED
@@ -82,8 +82,8 @@ Ref<Script> GDScriptLanguage::make_template(const String &p_template, const Stri
 	processed_template = processed_template.replace("_BASE_", p_base_class_name)
 								 .replace("_CLASS_", p_class_name)
 								 .replace("_TS_", _get_indentation());
-	script->set_source_code(processed_template);
-	return script;
+	scr->set_source_code(processed_template);
+	return scr;
 }
 
 Vector<ScriptLanguage::ScriptTemplate> GDScriptLanguage::get_built_in_templates(StringName p_object) {
@@ -318,10 +318,10 @@ void GDScriptLanguage::debug_get_stack_level_members(int p_level, List<String> *
 		return;
 	}
 
-	Ref<GDScript> script = instance->get_script();
-	ERR_FAIL_COND(script.is_null());
+	Ref<GDScript> scr = instance->get_script();
+	ERR_FAIL_COND(scr.is_null());
 
-	const HashMap<StringName, GDScript::MemberInfo> &mi = script->debug_get_member_indices();
+	const HashMap<StringName, GDScript::MemberInfo> &mi = scr->debug_get_member_indices();
 
 	for (const KeyValue<StringName, GDScript::MemberInfo> &E : mi) {
 		p_members->push_back(E.key);
@@ -344,7 +344,7 @@ ScriptInstance *GDScriptLanguage::debug_get_stack_level_instance(int p_level) {
 
 void GDScriptLanguage::debug_get_globals(List<String> *p_globals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
 	const HashMap<StringName, int> &name_idx = GDScriptLanguage::get_singleton()->get_global_map();
-	const Variant *globals = GDScriptLanguage::get_singleton()->get_global_array();
+	const Variant *gl_array = GDScriptLanguage::get_singleton()->get_global_array();
 
 	List<Pair<String, Variant>> cinfo;
 	get_public_constants(&cinfo);
@@ -365,7 +365,7 @@ void GDScriptLanguage::debug_get_globals(List<String> *p_globals, List<Variant>
 			continue;
 		}
 
-		const Variant &var = globals[E.value];
+		const Variant &var = gl_array[E.value];
 		if (Object *obj = var) {
 			if (Object::cast_to<GDScriptNativeClass>(obj)) {
 				continue;
@@ -3302,17 +3302,17 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 				if (ProjectSettings::get_singleton()->has_autoload(p_symbol)) {
 					const ProjectSettings::AutoloadInfo &autoload = ProjectSettings::get_singleton()->get_autoload(p_symbol);
 					if (autoload.is_singleton) {
-						String script = autoload.path;
-						if (!script.ends_with(".gd")) {
+						String scr_path = autoload.path;
+						if (!scr_path.ends_with(".gd")) {
 							// Not a script, try find the script anyway,
 							// may have some success.
-							script = script.get_basename() + ".gd";
+							scr_path = scr_path.get_basename() + ".gd";
 						}
 
-						if (FileAccess::exists(script)) {
+						if (FileAccess::exists(scr_path)) {
 							r_result.type = ScriptLanguage::LOOKUP_RESULT_SCRIPT_LOCATION;
 							r_result.location = 0;
-							r_result.script = ResourceLoader::load(script);
+							r_result.script = ResourceLoader::load(scr_path);
 							return OK;
 						}
 					}
diff --git a/modules/gdscript/gdscript_function.cpp b/modules/gdscript/gdscript_function.cpp
index cd3b7d69c5..98b3e40f1b 100644
--- a/modules/gdscript/gdscript_function.cpp
+++ b/modules/gdscript/gdscript_function.cpp
@@ -142,7 +142,7 @@ GDScriptFunction::GDScriptFunction() {
 	name = "<anonymous>";
 #ifdef DEBUG_ENABLED
 	{
-		MutexLock lock(GDScriptLanguage::get_singleton()->lock);
+		MutexLock lock(GDScriptLanguage::get_singleton()->mutex);
 		GDScriptLanguage::get_singleton()->function_list.add(&function_list);
 	}
 #endif
@@ -155,7 +155,7 @@ GDScriptFunction::~GDScriptFunction() {
 
 #ifdef DEBUG_ENABLED
 
-	MutexLock lock(GDScriptLanguage::get_singleton()->lock);
+	MutexLock lock(GDScriptLanguage::get_singleton()->mutex);
 
 	GDScriptLanguage::get_singleton()->function_list.remove(&function_list);
 #endif
@@ -201,7 +201,7 @@ bool GDScriptFunctionState::is_valid(bool p_extended_check) const {
 	}
 
 	if (p_extended_check) {
-		MutexLock lock(GDScriptLanguage::get_singleton()->lock);
+		MutexLock lock(GDScriptLanguage::get_singleton()->mutex);
 
 		// Script gone?
 		if (!scripts_list.in_list()) {
@@ -219,7 +219,7 @@ bool GDScriptFunctionState::is_valid(bool p_extended_check) const {
 Variant GDScriptFunctionState::resume(const Variant &p_arg) {
 	ERR_FAIL_COND_V(!function, Variant());
 	{
-		MutexLock lock(GDScriptLanguage::singleton->lock);
+		MutexLock lock(GDScriptLanguage::singleton->mutex);
 
 		if (!scripts_list.in_list()) {
 #ifdef DEBUG_ENABLED
@@ -304,7 +304,7 @@ GDScriptFunctionState::GDScriptFunctionState() :
 
 GDScriptFunctionState::~GDScriptFunctionState() {
 	{
-		MutexLock lock(GDScriptLanguage::singleton->lock);
+		MutexLock lock(GDScriptLanguage::singleton->mutex);
 		scripts_list.remove_from_list();
 		instances_list.remove_from_list();
 	}
diff --git a/modules/gdscript/gdscript_parser.cpp b/modules/gdscript/gdscript_parser.cpp
index 980a946e23..bdf6fb35b6 100644
--- a/modules/gdscript/gdscript_parser.cpp
+++ b/modules/gdscript/gdscript_parser.cpp
@@ -3953,28 +3953,22 @@ GDScriptParser::DataType GDScriptParser::SuiteNode::Local::get_datatype() const
 }
 
 String GDScriptParser::SuiteNode::Local::get_name() const {
-	String name;
 	switch (type) {
 		case SuiteNode::Local::PARAMETER:
-			name = "parameter";
-			break;
+			return "parameter";
 		case SuiteNode::Local::CONSTANT:
-			name = "constant";
-			break;
+			return "constant";
 		case SuiteNode::Local::VARIABLE:
-			name = "variable";
-			break;
+			return "variable";
 		case SuiteNode::Local::FOR_VARIABLE:
-			name = "for loop iterator";
-			break;
+			return "for loop iterator";
 		case SuiteNode::Local::PATTERN_BIND:
-			name = "pattern_bind";
-			break;
+			return "pattern_bind";
 		case SuiteNode::Local::UNDEFINED:
-			name = "<undefined>";
-			break;
+			return "<undefined>";
+		default:
+			return String();
 	}
-	return name;
 }
 
 String GDScriptParser::DataType::to_string() const {
diff --git a/modules/gdscript/gdscript_parser.h b/modules/gdscript/gdscript_parser.h
index d4efab173b..1850a44678 100644
--- a/modules/gdscript/gdscript_parser.h
+++ b/modules/gdscript/gdscript_parser.h
@@ -578,19 +578,19 @@ public:
 						return m_enum->get_datatype();
 					case ENUM_VALUE: {
 						// Always integer.
-						DataType type;
-						type.type_source = DataType::ANNOTATED_EXPLICIT;
-						type.kind = DataType::BUILTIN;
-						type.builtin_type = Variant::INT;
-						return type;
+						DataType out_type;
+						out_type.type_source = DataType::ANNOTATED_EXPLICIT;
+						out_type.kind = DataType::BUILTIN;
+						out_type.builtin_type = Variant::INT;
+						return out_type;
 					}
 					case SIGNAL: {
-						DataType type;
-						type.type_source = DataType::ANNOTATED_EXPLICIT;
-						type.kind = DataType::BUILTIN;
-						type.builtin_type = Variant::SIGNAL;
+						DataType out_type;
+						out_type.type_source = DataType::ANNOTATED_EXPLICIT;
+						out_type.kind = DataType::BUILTIN;
+						out_type.builtin_type = Variant::SIGNAL;
 						// TODO: Add parameter info.
-						return type;
+						return out_type;
 					}
 					case GROUP: {
 						return DataType();
diff --git a/modules/gdscript/gdscript_tokenizer.cpp b/modules/gdscript/gdscript_tokenizer.cpp
index 6c17afe939..9bbfd7aece 100644
--- a/modules/gdscript/gdscript_tokenizer.cpp
+++ b/modules/gdscript/gdscript_tokenizer.cpp
@@ -516,15 +516,15 @@ GDScriptTokenizer::Token GDScriptTokenizer::potential_identifier() {
 		_advance();
 	}
 
-	int length = _current - _start;
+	int len = _current - _start;
 
-	if (length == 1 && _peek(-1) == '_') {
+	if (len == 1 && _peek(-1) == '_') {
 		// Lone underscore.
 		return make_token(Token::UNDERSCORE);
 	}
 
-	String name(_start, length);
-	if (length < MIN_KEYWORD_LENGTH || length > MAX_KEYWORD_LENGTH) {
+	String name(_start, len);
+	if (len < MIN_KEYWORD_LENGTH || len > MAX_KEYWORD_LENGTH) {
 		// Cannot be a keyword, as the length doesn't match any.
 		return make_identifier(name);
 	}
@@ -538,7 +538,7 @@ GDScriptTokenizer::Token GDScriptTokenizer::potential_identifier() {
 		const int keyword_length = sizeof(keyword) - 1;                                                                   \
 		static_assert(keyword_length <= MAX_KEYWORD_LENGTH, "There's a keyword longer than the defined maximum length");  \
 		static_assert(keyword_length >= MIN_KEYWORD_LENGTH, "There's a keyword shorter than the defined minimum length"); \
-		if (keyword_length == length && name == keyword) {                                                                \
+		if (keyword_length == len && name == keyword) {                                                                   \
 			return make_token(token_type);                                                                                \
 		}                                                                                                                 \
 	}
@@ -551,13 +551,13 @@ GDScriptTokenizer::Token GDScriptTokenizer::potential_identifier() {
 	}
 
 	// Check if it's a special literal
-	if (length == 4) {
+	if (len == 4) {
 		if (name == "true") {
 			return make_literal(true);
 		} else if (name == "null") {
 			return make_literal(Variant());
 		}
-	} else if (length == 5) {
+	} else if (len == 5) {
 		if (name == "false") {
 			return make_literal(false);
 		}
@@ -725,8 +725,8 @@ GDScriptTokenizer::Token GDScriptTokenizer::number() {
 	}
 
 	// Create a string with the whole number.
-	int length = _current - _start;
-	String number = String(_start, length).replace("_", "");
+	int len = _current - _start;
+	String number = String(_start, len).replace("_", "");
 
 	// Convert to the appropriate literal type.
 	if (base == 16) {
diff --git a/modules/gdscript/gdscript_vm.cpp b/modules/gdscript/gdscript_vm.cpp
index afebe3c149..c73ba798aa 100644
--- a/modules/gdscript/gdscript_vm.cpp
+++ b/modules/gdscript/gdscript_vm.cpp
@@ -2216,7 +2216,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 					gdfs->state.line = line;
 					gdfs->state.script = _script;
 					{
-						MutexLock lock(GDScriptLanguage::get_singleton()->lock);
+						MutexLock lock(GDScriptLanguage::get_singleton()->mutex);
 						_script->pending_func_states.add(&gdfs->scripts_list);
 						if (p_instance) {
 							gdfs->state.instance = p_instance;
diff --git a/modules/gdscript/language_server/gdscript_extend_parser.cpp b/modules/gdscript/language_server/gdscript_extend_parser.cpp
index fa7e5924f9..de3becbaf8 100644
--- a/modules/gdscript/language_server/gdscript_extend_parser.cpp
+++ b/modules/gdscript/language_server/gdscript_extend_parser.cpp
@@ -38,8 +38,8 @@
 void ExtendGDScriptParser::update_diagnostics() {
 	diagnostics.clear();
 
-	const List<ParserError> &errors = get_errors();
-	for (const ParserError &error : errors) {
+	const List<ParserError> &parser_errors = get_errors();
+	for (const ParserError &error : parser_errors) {
 		lsp::Diagnostic diagnostic;
 		diagnostic.severity = lsp::DiagnosticSeverity::Error;
 		diagnostic.message = error.message;
@@ -47,9 +47,9 @@ void ExtendGDScriptParser::update_diagnostics() {
 		diagnostic.code = -1;
 		lsp::Range range;
 		lsp::Position pos;
-		const PackedStringArray lines = get_lines();
-		int line = CLAMP(LINE_NUMBER_TO_INDEX(error.line), 0, lines.size() - 1);
-		const String &line_text = lines[line];
+		const PackedStringArray line_array = get_lines();
+		int line = CLAMP(LINE_NUMBER_TO_INDEX(error.line), 0, line_array.size() - 1);
+		const String &line_text = line_array[line];
 		pos.line = line;
 		pos.character = line_text.length() - line_text.strip_edges(true, false).length();
 		range.start = pos;
@@ -59,8 +59,8 @@ void ExtendGDScriptParser::update_diagnostics() {
 		diagnostics.push_back(diagnostic);
 	}
 
-	const List<GDScriptWarning> &warnings = get_warnings();
-	for (const GDScriptWarning &warning : warnings) {
+	const List<GDScriptWarning> &parser_warnings = get_warnings();
+	for (const GDScriptWarning &warning : parser_warnings) {
 		lsp::Diagnostic diagnostic;
 		diagnostic.severity = lsp::DiagnosticSeverity::Warning;
 		diagnostic.message = "(" + warning.get_name() + "): " + warning.get_message();
@@ -83,8 +83,7 @@ void ExtendGDScriptParser::update_diagnostics() {
 void ExtendGDScriptParser::update_symbols() {
 	members.clear();
 
-	const GDScriptParser::Node *head = get_tree();
-	if (const GDScriptParser::ClassNode *gdclass = dynamic_cast<const GDScriptParser::ClassNode *>(head)) {
+	if (const GDScriptParser::ClassNode *gdclass = dynamic_cast<const GDScriptParser::ClassNode *>(get_tree())) {
 		parse_class_symbol(gdclass, class_symbol);
 
 		for (int i = 0; i < class_symbol.children.size(); i++) {
@@ -107,26 +106,26 @@ void ExtendGDScriptParser::update_symbols() {
 void ExtendGDScriptParser::update_document_links(const String &p_code) {
 	document_links.clear();
 
-	GDScriptTokenizer tokenizer;
+	GDScriptTokenizer scr_tokenizer;
 	Ref<FileAccess> fs = FileAccess::create(FileAccess::ACCESS_RESOURCES);
-	tokenizer.set_source_code(p_code);
+	scr_tokenizer.set_source_code(p_code);
 	while (true) {
-		GDScriptTokenizer::Token token = tokenizer.scan();
+		GDScriptTokenizer::Token token = scr_tokenizer.scan();
 		if (token.type == GDScriptTokenizer::Token::TK_EOF) {
 			break;
 		} else if (token.type == GDScriptTokenizer::Token::LITERAL) {
 			const Variant &const_val = token.literal;
 			if (const_val.get_type() == Variant::STRING) {
-				String path = const_val;
-				bool exists = fs->file_exists(path);
+				String scr_path = const_val;
+				bool exists = fs->file_exists(scr_path);
 				if (!exists) {
-					path = get_path().get_base_dir() + "/" + path;
-					exists = fs->file_exists(path);
+					scr_path = get_path().get_base_dir() + "/" + scr_path;
+					exists = fs->file_exists(scr_path);
 				}
 				if (exists) {
 					String value = const_val;
 					lsp::DocumentLink link;
-					link.target = GDScriptLanguageProtocol::get_singleton()->get_workspace()->get_file_uri(path);
+					link.target = GDScriptLanguageProtocol::get_singleton()->get_workspace()->get_file_uri(scr_path);
 					link.range.start.line = LINE_NUMBER_TO_INDEX(token.start_line);
 					link.range.end.line = LINE_NUMBER_TO_INDEX(token.end_line);
 					link.range.start.character = LINE_NUMBER_TO_INDEX(token.start_column);
@@ -731,7 +730,7 @@ Dictionary ExtendGDScriptParser::dump_class_api(const GDScriptParser::ClassNode
 
 	Array nested_classes;
 	Array constants;
-	Array members;
+	Array class_members;
 	Array signals;
 	Array methods;
 	Array static_functions;
@@ -792,7 +791,7 @@ Dictionary ExtendGDScriptParser::dump_class_api(const GDScriptParser::ClassNode
 					api["signature"] = symbol->detail;
 					api["description"] = symbol->documentation;
 				}
-				members.push_back(api);
+				class_members.push_back(api);
 			} break;
 			case ClassNode::Member::SIGNAL: {
 				Dictionary api;
@@ -824,7 +823,7 @@ Dictionary ExtendGDScriptParser::dump_class_api(const GDScriptParser::ClassNode
 
 	class_api["sub_classes"] = nested_classes;
 	class_api["constants"] = constants;
-	class_api["members"] = members;
+	class_api["members"] = class_members;
 	class_api["signals"] = signals;
 	class_api["methods"] = methods;
 	class_api["static_functions"] = static_functions;
@@ -834,8 +833,7 @@ Dictionary ExtendGDScriptParser::dump_class_api(const GDScriptParser::ClassNode
 
 Dictionary ExtendGDScriptParser::generate_api() const {
 	Dictionary api;
-	const GDScriptParser::Node *head = get_tree();
-	if (const GDScriptParser::ClassNode *gdclass = dynamic_cast<const GDScriptParser::ClassNode *>(head)) {
+	if (const GDScriptParser::ClassNode *gdclass = dynamic_cast<const GDScriptParser::ClassNode *>(get_tree())) {
 		api = dump_class_api(gdclass);
 	}
 	return api;
diff --git a/modules/gdscript/language_server/gdscript_language_server.cpp b/modules/gdscript/language_server/gdscript_language_server.cpp
index ead4ef1987..38bea314a0 100644
--- a/modules/gdscript/language_server/gdscript_language_server.cpp
+++ b/modules/gdscript/language_server/gdscript_language_server.cpp
@@ -61,12 +61,12 @@ void GDScriptLanguageServer::_notification(int p_what) {
 		} break;
 
 		case EditorSettings::NOTIFICATION_EDITOR_SETTINGS_CHANGED: {
-			String host = String(_EDITOR_GET("network/language_server/remote_host"));
-			int port = (int)_EDITOR_GET("network/language_server/remote_port");
-			bool use_thread = (bool)_EDITOR_GET("network/language_server/use_thread");
-			if (host != this->host || port != this->port || use_thread != this->use_thread) {
-				this->stop();
-				this->start();
+			String remote_host = String(_EDITOR_GET("network/language_server/remote_host"));
+			int remote_port = (int)_EDITOR_GET("network/language_server/remote_port");
+			bool remote_use_thread = (bool)_EDITOR_GET("network/language_server/use_thread");
+			if (remote_host != host || remote_port != port || remote_use_thread != use_thread) {
+				stop();
+				start();
 			}
 		} break;
 	}
diff --git a/modules/gdscript/language_server/gdscript_text_document.cpp b/modules/gdscript/language_server/gdscript_text_document.cpp
index 189e7fcc71..3905e28bcb 100644
--- a/modules/gdscript/language_server/gdscript_text_document.cpp
+++ b/modules/gdscript/language_server/gdscript_text_document.cpp
@@ -86,9 +86,9 @@ void GDScriptTextDocument::willSaveWaitUntil(const Variant &p_param) {
 	lsp::TextDocumentItem doc = load_document_item(p_param);
 
 	String path = GDScriptLanguageProtocol::get_singleton()->get_workspace()->get_file_path(doc.uri);
-	Ref<Script> script = ResourceLoader::load(path);
-	if (script.is_valid()) {
-		ScriptEditor::get_singleton()->clear_docs_from_script(script);
+	Ref<Script> scr = ResourceLoader::load(path);
+	if (scr.is_valid()) {
+		ScriptEditor::get_singleton()->clear_docs_from_script(scr);
 	}
 }
 
@@ -100,14 +100,14 @@ void GDScriptTextDocument::didSave(const Variant &p_param) {
 	sync_script_content(doc.uri, text);
 
 	String path = GDScriptLanguageProtocol::get_singleton()->get_workspace()->get_file_path(doc.uri);
-	Ref<GDScript> script = ResourceLoader::load(path);
-	if (script.is_valid() && (script->load_source_code(path) == OK)) {
-		if (script->is_tool()) {
-			script->get_language()->reload_tool_script(script, true);
+	Ref<GDScript> scr = ResourceLoader::load(path);
+	if (scr.is_valid() && (scr->load_source_code(path) == OK)) {
+		if (scr->is_tool()) {
+			scr->get_language()->reload_tool_script(scr, true);
 		} else {
-			script->reload(true);
+			scr->reload(true);
 		}
-		ScriptEditor::get_singleton()->update_docs_from_script(script);
+		ScriptEditor::get_singleton()->update_docs_from_script(scr);
 	}
 }
 
@@ -229,8 +229,8 @@ Array GDScriptTextDocument::completion(const Dictionary &p_params) {
 		arr = native_member_completions.duplicate();
 
 		for (KeyValue<String, ExtendGDScriptParser *> &E : GDScriptLanguageProtocol::get_singleton()->get_workspace()->scripts) {
-			ExtendGDScriptParser *script = E.value;
-			const Array &items = script->get_member_completions();
+			ExtendGDScriptParser *scr = E.value;
+			const Array &items = scr->get_member_completions();
 
 			const int start_size = arr.size();
 			arr.resize(start_size + items.size());
diff --git a/modules/gdscript/language_server/gdscript_workspace.cpp b/modules/gdscript/language_server/gdscript_workspace.cpp
index 16461b0a6c..390460bed9 100644
--- a/modules/gdscript/language_server/gdscript_workspace.cpp
+++ b/modules/gdscript/language_server/gdscript_workspace.cpp
@@ -55,14 +55,14 @@ void GDScriptWorkspace::_bind_methods() {
 }
 
 void GDScriptWorkspace::apply_new_signal(Object *obj, String function, PackedStringArray args) {
-	Ref<Script> script = obj->get_script();
+	Ref<Script> scr = obj->get_script();
 
-	if (script->get_language()->get_name() != "GDScript") {
+	if (scr->get_language()->get_name() != "GDScript") {
 		return;
 	}
 
 	String function_signature = "func " + function;
-	String source = script->get_source_code();
+	String source = scr->get_source_code();
 
 	if (source.contains(function_signature)) {
 		return;
@@ -98,7 +98,7 @@ void GDScriptWorkspace::apply_new_signal(Object *obj, String function, PackedStr
 
 	text_edit.newText = function_body;
 
-	String uri = get_file_uri(script->get_path());
+	String uri = get_file_uri(scr->get_path());
 
 	lsp::ApplyWorkspaceEditParams params;
 	params.edit.add_edit(uri, text_edit);
@@ -118,12 +118,12 @@ void GDScriptWorkspace::did_delete_files(const Dictionary &p_params) {
 
 void GDScriptWorkspace::remove_cache_parser(const String &p_path) {
 	HashMap<String, ExtendGDScriptParser *>::Iterator parser = parse_results.find(p_path);
-	HashMap<String, ExtendGDScriptParser *>::Iterator script = scripts.find(p_path);
-	if (parser && script) {
-		if (script->value && script->value == parser->value) {
-			memdelete(script->value);
+	HashMap<String, ExtendGDScriptParser *>::Iterator scr = scripts.find(p_path);
+	if (parser && scr) {
+		if (scr->value && scr->value == parser->value) {
+			memdelete(scr->value);
 		} else {
-			memdelete(script->value);
+			memdelete(scr->value);
 			memdelete(parser->value);
 		}
 		parse_results.erase(p_path);
@@ -131,8 +131,8 @@ void GDScriptWorkspace::remove_cache_parser(const String &p_path) {
 	} else if (parser) {
 		memdelete(parser->value);
 		parse_results.erase(p_path);
-	} else if (script) {
-		memdelete(script->value);
+	} else if (scr) {
+		memdelete(scr->value);
 		scripts.erase(p_path);
 	}
 }
@@ -587,8 +587,8 @@ void GDScriptWorkspace::completion(const lsp::CompletionParams &p_params, List<S
 
 			while (!stack.is_empty()) {
 				current = Object::cast_to<Node>(stack.pop_back());
-				Ref<GDScript> script = current->get_script();
-				if (script.is_valid() && script->get_path() == path) {
+				Ref<GDScript> scr = current->get_script();
+				if (scr.is_valid() && scr->get_path() == path) {
 					break;
 				}
 				for (int i = 0; i < current->get_child_count(); ++i) {
@@ -596,8 +596,8 @@ void GDScriptWorkspace::completion(const lsp::CompletionParams &p_params, List<S
 				}
 			}
 
-			Ref<GDScript> script = current->get_script();
-			if (!script.is_valid() || script->get_path() != path) {
+			Ref<GDScript> scr = current->get_script();
+			if (!scr.is_valid() || scr->get_path() != path) {
 				current = owner_scene_node;
 			}
 		}
@@ -691,13 +691,13 @@ void GDScriptWorkspace::resolve_related_symbols(const lsp::TextDocumentPositionP
 		}
 
 		for (const KeyValue<String, ExtendGDScriptParser *> &E : scripts) {
-			const ExtendGDScriptParser *script = E.value;
-			const ClassMembers &members = script->get_members();
+			const ExtendGDScriptParser *scr = E.value;
+			const ClassMembers &members = scr->get_members();
 			if (const lsp::DocumentSymbol *const *symbol = members.getptr(symbol_identifier)) {
 				r_list.push_back(*symbol);
 			}
 
-			for (const KeyValue<String, ClassMembers> &F : script->get_inner_classes()) {
+			for (const KeyValue<String, ClassMembers> &F : scr->get_inner_classes()) {
 				const ClassMembers *inner_class = &F.value;
 				if (const lsp::DocumentSymbol *const *symbol = inner_class->getptr(symbol_identifier)) {
 					r_list.push_back(*symbol);
diff --git a/modules/gltf/editor/editor_scene_importer_blend.cpp b/modules/gltf/editor/editor_scene_importer_blend.cpp
index dcf59bce24..20c9508474 100644
--- a/modules/gltf/editor/editor_scene_importer_blend.cpp
+++ b/modules/gltf/editor/editor_scene_importer_blend.cpp
@@ -179,13 +179,13 @@ Node *EditorSceneFormatImporterBlend::import_scene(const String &p_path, uint32_
 			"export_format='GLTF_SEPARATE',"
 			"export_yup=True," +
 			parameters_arg;
-	String script =
+	String export_script =
 			String("import bpy, sys;") +
 			"print('Blender 3.0 or higher is required.', file=sys.stderr) if bpy.app.version < (3, 0, 0) else None;" +
 			vformat("bpy.ops.wm.open_mainfile(filepath='%s');", source_global) +
 			unpack_all +
 			vformat("bpy.ops.export_scene.gltf(export_keep_originals=True,%s);", common_args);
-	print_verbose(script);
+	print_verbose(export_script);
 
 	// Run script with configured Blender binary.
 
@@ -200,7 +200,7 @@ Node *EditorSceneFormatImporterBlend::import_scene(const String &p_path, uint32_
 	List<String> args;
 	args.push_back("--background");
 	args.push_back("--python-expr");
-	args.push_back(script);
+	args.push_back(export_script);
 
 	String standard_out;
 	int ret;
@@ -349,9 +349,7 @@ static bool _test_blender_path(const String &p_path, String *r_err = nullptr) {
 bool EditorFileSystemImportFormatSupportQueryBlend::is_active() const {
 	bool blend_enabled = GLOBAL_GET("filesystem/import/blender/enabled");
 
-	String blender_path = EDITOR_GET("filesystem/import/blender/blender3_path");
-
-	if (blend_enabled && !_test_blender_path(blender_path)) {
+	if (blend_enabled && !_test_blender_path(EDITOR_GET("filesystem/import/blender/blender3_path").operator String())) {
 		// Intending to import Blender, but blend not configured.
 		return true;
 	}
diff --git a/modules/gltf/extensions/gltf_light.cpp b/modules/gltf/extensions/gltf_light.cpp
index 6923c765cb..d00bead61c 100644
--- a/modules/gltf/extensions/gltf_light.cpp
+++ b/modules/gltf/extensions/gltf_light.cpp
@@ -142,18 +142,17 @@ Light3D *GLTFLight::to_node() const {
 		light->set_color(color);
 		return light;
 	}
-	const float range = CLAMP(this->range, 0, 4096);
 	if (light_type == "point") {
 		OmniLight3D *light = memnew(OmniLight3D);
 		light->set_param(OmniLight3D::PARAM_ENERGY, intensity);
-		light->set_param(OmniLight3D::PARAM_RANGE, range);
+		light->set_param(OmniLight3D::PARAM_RANGE, CLAMP(range, 0, 4096));
 		light->set_color(color);
 		return light;
 	}
 	if (light_type == "spot") {
 		SpotLight3D *light = memnew(SpotLight3D);
 		light->set_param(SpotLight3D::PARAM_ENERGY, intensity);
-		light->set_param(SpotLight3D::PARAM_RANGE, range);
+		light->set_param(SpotLight3D::PARAM_RANGE, CLAMP(range, 0, 4096));
 		light->set_param(SpotLight3D::PARAM_SPOT_ANGLE, Math::rad_to_deg(outer_cone_angle));
 		light->set_color(color);
 		// Line of best fit derived from guessing, see https://www.desmos.com/calculator/biiflubp8b
diff --git a/modules/gltf/gltf_document.cpp b/modules/gltf/gltf_document.cpp
index 35358734d6..8272db9018 100644
--- a/modules/gltf/gltf_document.cpp
+++ b/modules/gltf/gltf_document.cpp
@@ -471,23 +471,23 @@ Error GLTFDocument::_serialize_nodes(Ref<GLTFState> state) {
 String GLTFDocument::_gen_unique_name(Ref<GLTFState> state, const String &p_name) {
 	const String s_name = p_name.validate_node_name();
 
-	String name;
+	String u_name;
 	int index = 1;
 	while (true) {
-		name = s_name;
+		u_name = s_name;
 
 		if (index > 1) {
-			name += itos(index);
+			u_name += itos(index);
 		}
-		if (!state->unique_names.has(name)) {
+		if (!state->unique_names.has(u_name)) {
 			break;
 		}
 		index++;
 	}
 
-	state->unique_names.insert(name);
+	state->unique_names.insert(u_name);
 
-	return name;
+	return u_name;
 }
 
 String GLTFDocument::_sanitize_animation_name(const String &p_name) {
@@ -495,39 +495,39 @@ String GLTFDocument::_sanitize_animation_name(const String &p_name) {
 	// (See animation/animation_player.cpp::add_animation)
 
 	// TODO: Consider adding invalid_characters or a validate_animation_name to animation_player to mirror Node.
-	String name = p_name.validate_node_name();
-	name = name.replace(",", "");
-	name = name.replace("[", "");
-	return name;
+	String anim_name = p_name.validate_node_name();
+	anim_name = anim_name.replace(",", "");
+	anim_name = anim_name.replace("[", "");
+	return anim_name;
 }
 
 String GLTFDocument::_gen_unique_animation_name(Ref<GLTFState> state, const String &p_name) {
 	const String s_name = _sanitize_animation_name(p_name);
 
-	String name;
+	String u_name;
 	int index = 1;
 	while (true) {
-		name = s_name;
+		u_name = s_name;
 
 		if (index > 1) {
-			name += itos(index);
+			u_name += itos(index);
 		}
-		if (!state->unique_animation_names.has(name)) {
+		if (!state->unique_animation_names.has(u_name)) {
 			break;
 		}
 		index++;
 	}
 
-	state->unique_animation_names.insert(name);
+	state->unique_animation_names.insert(u_name);
 
-	return name;
+	return u_name;
 }
 
 String GLTFDocument::_sanitize_bone_name(const String &p_name) {
-	String name = p_name;
-	name = name.replace(":", "_");
-	name = name.replace("/", "_");
-	return name;
+	String bone_name = p_name;
+	bone_name = bone_name.replace(":", "_");
+	bone_name = bone_name.replace("/", "_");
+	return bone_name;
 }
 
 String GLTFDocument::_gen_unique_bone_name(Ref<GLTFState> state, const GLTFSkeletonIndex skel_i, const String &p_name) {
@@ -535,23 +535,23 @@ String GLTFDocument::_gen_unique_bone_name(Ref<GLTFState> state, const GLTFSkele
 	if (s_name.is_empty()) {
 		s_name = "bone";
 	}
-	String name;
+	String u_name;
 	int index = 1;
 	while (true) {
-		name = s_name;
+		u_name = s_name;
 
 		if (index > 1) {
-			name += "_" + itos(index);
+			u_name += "_" + itos(index);
 		}
-		if (!state->skeletons[skel_i]->unique_names.has(name)) {
+		if (!state->skeletons[skel_i]->unique_names.has(u_name)) {
 			break;
 		}
 		index++;
 	}
 
-	state->skeletons.write[skel_i]->unique_names.insert(name);
+	state->skeletons.write[skel_i]->unique_names.insert(u_name);
 
-	return name;
+	return u_name;
 }
 
 Error GLTFDocument::_parse_scenes(Ref<GLTFState> state) {
@@ -2824,8 +2824,7 @@ Error GLTFDocument::_parse_meshes(Ref<GLTFState> state) {
 				if (j == 0) {
 					const Array &target_names = extras.has("targetNames") ? (Array)extras["targetNames"] : Array();
 					for (int k = 0; k < targets.size(); k++) {
-						const String name = k < target_names.size() ? (String)target_names[k] : String("morph_") + itos(k);
-						import_mesh->add_blend_shape(name);
+						import_mesh->add_blend_shape(k < target_names.size() ? (String)target_names[k] : String("morph_") + itos(k));
 					}
 				}
 
@@ -3034,12 +3033,12 @@ Error GLTFDocument::_serialize_images(Ref<GLTFState> state, const String &p_path
 			d["mimeType"] = "image/png";
 		} else {
 			ERR_FAIL_COND_V(p_path.is_empty(), ERR_INVALID_PARAMETER);
-			String name = state->images[i]->get_name();
-			if (name.is_empty()) {
-				name = itos(i);
+			String img_name = state->images[i]->get_name();
+			if (img_name.is_empty()) {
+				img_name = itos(i);
 			}
-			name = _gen_unique_name(state, name);
-			name = name.pad_zeros(3) + ".png";
+			img_name = _gen_unique_name(state, img_name);
+			img_name = img_name.pad_zeros(3) + ".png";
 			String texture_dir = "textures";
 			String path = p_path.get_base_dir();
 			String new_texture_dir = path + "/" + texture_dir;
@@ -3047,8 +3046,8 @@ Error GLTFDocument::_serialize_images(Ref<GLTFState> state, const String &p_path
 			if (!da->dir_exists(new_texture_dir)) {
 				da->make_dir(new_texture_dir);
 			}
-			image->save_png(new_texture_dir.path_join(name));
-			d["uri"] = texture_dir.path_join(name).uri_encode();
+			image->save_png(new_texture_dir.path_join(img_name));
+			d["uri"] = texture_dir.path_join(img_name).uri_encode();
 		}
 		images.push_back(d);
 	}
@@ -4422,14 +4421,14 @@ Error GLTFDocument::_determine_skeleton_roots(Ref<GLTFState> state, const GLTFSk
 
 	Ref<GLTFSkeleton> skeleton = state->skeletons.write[skel_i];
 
-	Vector<GLTFNodeIndex> owners;
-	disjoint_set.get_representatives(owners);
+	Vector<GLTFNodeIndex> representatives;
+	disjoint_set.get_representatives(representatives);
 
 	Vector<GLTFNodeIndex> roots;
 
-	for (int i = 0; i < owners.size(); ++i) {
+	for (int i = 0; i < representatives.size(); ++i) {
 		Vector<GLTFNodeIndex> set;
-		disjoint_set.get_members(set, owners[i]);
+		disjoint_set.get_members(set, representatives[i]);
 		const GLTFNodeIndex root = _find_highest_node(state, set);
 		ERR_FAIL_COND_V(root < 0, FAILED);
 		roots.push_back(root);
@@ -4960,12 +4959,12 @@ Error GLTFDocument::_parse_animations(Ref<GLTFState> state) {
 		Array samplers = d["samplers"];
 
 		if (d.has("name")) {
-			const String name = d["name"];
-			const String name_lower = name.to_lower();
-			if (name_lower.begins_with("loop") || name_lower.ends_with("loop") || name_lower.begins_with("cycle") || name_lower.ends_with("cycle")) {
+			const String anim_name = d["name"];
+			const String anim_name_lower = anim_name.to_lower();
+			if (anim_name_lower.begins_with("loop") || anim_name_lower.ends_with("loop") || anim_name_lower.begins_with("cycle") || anim_name_lower.ends_with("cycle")) {
 				animation->set_loop(true);
 			}
-			animation->set_name(_gen_unique_animation_name(state, name));
+			animation->set_name(_gen_unique_animation_name(state, anim_name));
 		}
 
 		for (int j = 0; j < channels.size(); j++) {
@@ -5828,15 +5827,15 @@ T GLTFDocument::_interpolate_track(const Vector<real_t> &p_times, const Vector<T
 void GLTFDocument::_import_animation(Ref<GLTFState> state, AnimationPlayer *ap, const GLTFAnimationIndex index, const int bake_fps) {
 	Ref<GLTFAnimation> anim = state->animations[index];
 
-	String name = anim->get_name();
-	if (name.is_empty()) {
+	String anim_name = anim->get_name();
+	if (anim_name.is_empty()) {
 		// No node represent these, and they are not in the hierarchy, so just make a unique name
-		name = _gen_unique_name(state, "Animation");
+		anim_name = _gen_unique_name(state, "Animation");
 	}
 
 	Ref<Animation> animation;
 	animation.instantiate();
-	animation->set_name(name);
+	animation->set_name(anim_name);
 
 	if (anim->get_loop()) {
 		animation->set_loop_mode(Animation::LOOP_LINEAR);
@@ -6059,7 +6058,7 @@ void GLTFDocument::_import_animation(Ref<GLTFState> state, AnimationPlayer *ap,
 	} else {
 		library = ap->get_animation_library("");
 	}
-	library->add_animation(name, animation);
+	library->add_animation(anim_name, animation);
 }
 
 void GLTFDocument::_convert_mesh_instances(Ref<GLTFState> state) {
diff --git a/modules/gridmap/grid_map.cpp b/modules/gridmap/grid_map.cpp
index 05ce2b6147..de50e9ea1e 100644
--- a/modules/gridmap/grid_map.cpp
+++ b/modules/gridmap/grid_map.cpp
@@ -157,13 +157,13 @@ uint32_t GridMap::get_collision_mask() const {
 void GridMap::set_collision_layer_value(int p_layer_number, bool p_value) {
 	ERR_FAIL_COND_MSG(p_layer_number < 1, "Collision layer number must be between 1 and 32 inclusive.");
 	ERR_FAIL_COND_MSG(p_layer_number > 32, "Collision layer number must be between 1 and 32 inclusive.");
-	uint32_t collision_layer = get_collision_layer();
+	uint32_t collision_layer_new = get_collision_layer();
 	if (p_value) {
-		collision_layer |= 1 << (p_layer_number - 1);
+		collision_layer_new |= 1 << (p_layer_number - 1);
 	} else {
-		collision_layer &= ~(1 << (p_layer_number - 1));
+		collision_layer_new &= ~(1 << (p_layer_number - 1));
 	}
-	set_collision_layer(collision_layer);
+	set_collision_layer(collision_layer_new);
 }
 
 bool GridMap::get_collision_layer_value(int p_layer_number) const {
diff --git a/modules/lightmapper_rd/lightmapper_rd.cpp b/modules/lightmapper_rd/lightmapper_rd.cpp
index 5b039e65c0..8785f327db 100644
--- a/modules/lightmapper_rd/lightmapper_rd.cpp
+++ b/modules/lightmapper_rd/lightmapper_rd.cpp
@@ -278,7 +278,7 @@ Lightmapper::BakeError LightmapperRD::_blit_meshes_into_atlas(int p_max_texture_
 	return BAKE_OK;
 }
 
-void LightmapperRD::_create_acceleration_structures(RenderingDevice *rd, Size2i atlas_size, int atlas_slices, AABB &bounds, int grid_size, Vector<Probe> &probe_positions, GenerateProbes p_generate_probes, Vector<int> &slice_triangle_count, Vector<int> &slice_seam_count, RID &vertex_buffer, RID &triangle_buffer, RID &lights_buffer, RID &triangle_cell_indices_buffer, RID &probe_positions_buffer, RID &grid_texture, RID &seams_buffer, BakeStepFunc p_step_function, void *p_bake_userdata) {
+void LightmapperRD::_create_acceleration_structures(RenderingDevice *rd, Size2i atlas_size, int atlas_slices, AABB &bounds, int grid_size, Vector<Probe> &p_probe_positions, GenerateProbes p_generate_probes, Vector<int> &slice_triangle_count, Vector<int> &slice_seam_count, RID &vertex_buffer, RID &triangle_buffer, RID &lights_buffer, RID &triangle_cell_indices_buffer, RID &probe_positions_buffer, RID &grid_texture, RID &seams_buffer, BakeStepFunc p_step_function, void *p_bake_userdata) {
 	HashMap<Vertex, uint32_t, VertexHash> vertex_map;
 
 	//fill triangles array and vertex array
@@ -403,8 +403,8 @@ void LightmapperRD::_create_acceleration_structures(RenderingDevice *rd, Size2i
 	}
 
 	//also consider probe positions for bounds
-	for (int i = 0; i < probe_positions.size(); i++) {
-		Vector3 pp(probe_positions[i].position[0], probe_positions[i].position[1], probe_positions[i].position[2]);
+	for (int i = 0; i < p_probe_positions.size(); i++) {
+		Vector3 pp(p_probe_positions[i].position[0], p_probe_positions[i].position[1], p_probe_positions[i].position[2]);
 		bounds.expand_to(pp);
 	}
 	bounds.grow_by(0.1); //grow a bit to avoid numerical error
@@ -520,7 +520,7 @@ void LightmapperRD::_create_acceleration_structures(RenderingDevice *rd, Size2i
 		}
 		seams_buffer = rd->storage_buffer_create(sb.size(), sb);
 
-		Vector<uint8_t> pb = probe_positions.to_byte_array();
+		Vector<uint8_t> pb = p_probe_positions.to_byte_array();
 		if (pb.size() == 0) {
 			pb.resize(sizeof(Probe));
 		}
diff --git a/modules/multiplayer/scene_replication_config.cpp b/modules/multiplayer/scene_replication_config.cpp
index ae06516b7b..61fe51b6c9 100644
--- a/modules/multiplayer/scene_replication_config.cpp
+++ b/modules/multiplayer/scene_replication_config.cpp
@@ -34,11 +34,11 @@
 #include "scene/main/node.h"
 
 bool SceneReplicationConfig::_set(const StringName &p_name, const Variant &p_value) {
-	String name = p_name;
+	String prop_name = p_name;
 
-	if (name.begins_with("properties/")) {
-		int idx = name.get_slicec('/', 1).to_int();
-		String what = name.get_slicec('/', 2);
+	if (prop_name.begins_with("properties/")) {
+		int idx = prop_name.get_slicec('/', 1).to_int();
+		String what = prop_name.get_slicec('/', 2);
 
 		if (properties.size() == idx && what == "path") {
 			ERR_FAIL_COND_V(p_value.get_type() != Variant::NODE_PATH, false);
@@ -72,11 +72,11 @@ bool SceneReplicationConfig::_set(const StringName &p_name, const Variant &p_val
 }
 
 bool SceneReplicationConfig::_get(const StringName &p_name, Variant &r_ret) const {
-	String name = p_name;
+	String prop_name = p_name;
 
-	if (name.begins_with("properties/")) {
-		int idx = name.get_slicec('/', 1).to_int();
-		String what = name.get_slicec('/', 2);
+	if (prop_name.begins_with("properties/")) {
+		int idx = prop_name.get_slicec('/', 1).to_int();
+		String what = prop_name.get_slicec('/', 2);
 		ERR_FAIL_INDEX_V(idx, properties.size(), false);
 		const ReplicationProperty &prop = properties[idx];
 		if (what == "path") {
diff --git a/modules/noise/noise_texture_2d.cpp b/modules/noise/noise_texture_2d.cpp
index 101a66371b..23d60c4866 100644
--- a/modules/noise/noise_texture_2d.cpp
+++ b/modules/noise/noise_texture_2d.cpp
@@ -152,24 +152,24 @@ Ref<Image> NoiseTexture2D::_generate_texture() {
 		return Ref<Image>();
 	}
 
-	Ref<Image> image;
+	Ref<Image> new_image;
 
 	if (seamless) {
-		image = ref_noise->get_seamless_image(size.x, size.y, invert, in_3d_space, seamless_blend_skirt);
+		new_image = ref_noise->get_seamless_image(size.x, size.y, invert, in_3d_space, seamless_blend_skirt);
 	} else {
-		image = ref_noise->get_image(size.x, size.y, invert, in_3d_space);
+		new_image = ref_noise->get_image(size.x, size.y, invert, in_3d_space);
 	}
 	if (color_ramp.is_valid()) {
-		image = _modulate_with_gradient(image, color_ramp);
+		new_image = _modulate_with_gradient(new_image, color_ramp);
 	}
 	if (as_normal_map) {
-		image->bump_map_to_normal_map(bump_strength);
+		new_image->bump_map_to_normal_map(bump_strength);
 	}
 	if (generate_mipmaps) {
-		image->generate_mipmaps();
+		new_image->generate_mipmaps();
 	}
 
-	return image;
+	return new_image;
 }
 
 Ref<Image> NoiseTexture2D::_modulate_with_gradient(Ref<Image> p_image, Ref<Gradient> p_gradient) {
@@ -206,8 +206,8 @@ void NoiseTexture2D::_update_texture() {
 		}
 
 	} else {
-		Ref<Image> image = _generate_texture();
-		_set_texture_image(image);
+		Ref<Image> new_image = _generate_texture();
+		_set_texture_image(new_image);
 	}
 	update_queued = false;
 }
diff --git a/modules/openxr/action_map/openxr_action.cpp b/modules/openxr/action_map/openxr_action.cpp
index 359975a480..0fb4f0773f 100644
--- a/modules/openxr/action_map/openxr_action.cpp
+++ b/modules/openxr/action_map/openxr_action.cpp
@@ -64,13 +64,13 @@ Ref<OpenXRAction> OpenXRAction::new_action(const char *p_name, const char *p_loc
 }
 
 String OpenXRAction::get_name_with_set() const {
-	String name = get_name();
+	String action_name = get_name();
 
 	if (action_set != nullptr) {
-		name = action_set->get_name() + "/" + name;
+		action_name = action_set->get_name() + "/" + action_name;
 	}
 
-	return name;
+	return action_name;
 }
 
 void OpenXRAction::set_localized_name(const String p_localized_name) {
diff --git a/modules/openxr/openxr_interface.cpp b/modules/openxr/openxr_interface.cpp
index 31dc2bbf43..68414ae84e 100644
--- a/modules/openxr/openxr_interface.cpp
+++ b/modules/openxr/openxr_interface.cpp
@@ -132,10 +132,10 @@ void OpenXRInterface::_load_action_map() {
 	if (action_map.is_valid()) {
 		HashMap<Ref<OpenXRAction>, Action *> xr_actions;
 
-		Array action_sets = action_map->get_action_sets();
-		for (int i = 0; i < action_sets.size(); i++) {
+		Array action_set_array = action_map->get_action_sets();
+		for (int i = 0; i < action_set_array.size(); i++) {
 			// Create our action set
-			Ref<OpenXRActionSet> xr_action_set = action_sets[i];
+			Ref<OpenXRActionSet> xr_action_set = action_set_array[i];
 			ActionSet *action_set = create_action_set(xr_action_set->get_name(), xr_action_set->get_localized_name(), xr_action_set->get_priority());
 			if (!action_set) {
 				continue;
@@ -147,20 +147,20 @@ void OpenXRInterface::_load_action_map() {
 				Ref<OpenXRAction> xr_action = actions[j];
 
 				PackedStringArray toplevel_paths = xr_action->get_toplevel_paths();
-				Vector<Tracker *> trackers;
+				Vector<Tracker *> trackers_new;
 
 				for (int k = 0; k < toplevel_paths.size(); k++) {
 					Tracker *tracker = find_tracker(toplevel_paths[k], true);
 					if (tracker) {
-						trackers.push_back(tracker);
+						trackers_new.push_back(tracker);
 					}
 				}
 
 				Action *action = create_action(action_set, xr_action->get_name(), xr_action->get_localized_name(), xr_action->get_action_type(), trackers);
 				if (action) {
 					// we link our actions back to our trackers so we know which actions to check when we're processing our trackers
-					for (int t = 0; t < trackers.size(); t++) {
-						link_action_to_tracker(trackers[t], action);
+					for (int t = 0; t < trackers_new.size(); t++) {
+						link_action_to_tracker(trackers_new[t], action);
 					}
 
 					// add this to our map for creating our interaction profiles
@@ -170,9 +170,9 @@ void OpenXRInterface::_load_action_map() {
 		}
 
 		// now do our suggestions
-		Array interaction_profiles = action_map->get_interaction_profiles();
-		for (int i = 0; i < interaction_profiles.size(); i++) {
-			Ref<OpenXRInteractionProfile> xr_interaction_profile = interaction_profiles[i];
+		Array interaction_profile_array = action_map->get_interaction_profiles();
+		for (int i = 0; i < interaction_profile_array.size(); i++) {
+			Ref<OpenXRInteractionProfile> xr_interaction_profile = interaction_profile_array[i];
 
 			// Note, we can only have one entry per interaction profile so if it already exists we clear it out
 			RID ip = openxr_api->interaction_profile_create(xr_interaction_profile->get_interaction_profile_path());
@@ -202,8 +202,8 @@ void OpenXRInterface::_load_action_map() {
 				openxr_api->interaction_profile_suggest_bindings(ip);
 
 				// And record it in our array so we can clean it up later on
-				if (interaction_profiles.has(ip)) {
-					interaction_profiles.push_back(ip);
+				if (interaction_profile_array.has(ip)) {
+					interaction_profile_array.push_back(ip);
 				}
 			}
 		}
diff --git a/modules/openxr/util.h b/modules/openxr/util.h
index 5c79890830..1b5e0451dc 100644
--- a/modules/openxr/util.h
+++ b/modules/openxr/util.h
@@ -53,58 +53,58 @@
 #define EXT_INIT_XR_FUNC(name) INIT_XR_FUNC(openxr_api, name)
 #define OPENXR_API_INIT_XR_FUNC(name) INIT_XR_FUNC(this, name)
 
-#define EXT_PROTO_XRRESULT_FUNC1(func_name, arg1_type, arg1)                \
-	PFN_##func_name func_name##_ptr = nullptr;                              \
-	XRAPI_ATTR XrResult XRAPI_CALL func_name(UNPACK arg1_type arg1) const { \
-		if (!func_name##_ptr) {                                             \
-			return XR_ERROR_HANDLE_INVALID;                                 \
-		}                                                                   \
-		return (*func_name##_ptr)(arg1);                                    \
+#define EXT_PROTO_XRRESULT_FUNC1(func_name, arg1_type, arg1)                    \
+	PFN_##func_name func_name##_ptr = nullptr;                                  \
+	XRAPI_ATTR XrResult XRAPI_CALL func_name(UNPACK arg1_type p_##arg1) const { \
+		if (!func_name##_ptr) {                                                 \
+			return XR_ERROR_HANDLE_INVALID;                                     \
+		}                                                                       \
+		return (*func_name##_ptr)(p_##arg1);                                    \
 	}
 
-#define EXT_PROTO_XRRESULT_FUNC2(func_name, arg1_type, arg1, arg2_type, arg2)                      \
-	PFN_##func_name func_name##_ptr = nullptr;                                                     \
-	XRAPI_ATTR XrResult XRAPI_CALL func_name(UNPACK arg1_type arg1, UNPACK arg2_type arg2) const { \
-		if (!func_name##_ptr) {                                                                    \
-			return XR_ERROR_HANDLE_INVALID;                                                        \
-		}                                                                                          \
-		return (*func_name##_ptr)(arg1, arg2);                                                     \
+#define EXT_PROTO_XRRESULT_FUNC2(func_name, arg1_type, arg1, arg2_type, arg2)                              \
+	PFN_##func_name func_name##_ptr = nullptr;                                                             \
+	XRAPI_ATTR XrResult XRAPI_CALL func_name(UNPACK arg1_type p_##arg1, UNPACK arg2_type p_##arg2) const { \
+		if (!func_name##_ptr) {                                                                            \
+			return XR_ERROR_HANDLE_INVALID;                                                                \
+		}                                                                                                  \
+		return (*func_name##_ptr)(p_##arg1, p_##arg2);                                                     \
 	}
 
-#define EXT_PROTO_XRRESULT_FUNC3(func_name, arg1_type, arg1, arg2_type, arg2, arg3_type, arg3)                            \
-	PFN_##func_name func_name##_ptr = nullptr;                                                                            \
-	XRAPI_ATTR XrResult XRAPI_CALL func_name(UNPACK arg1_type arg1, UNPACK arg2_type arg2, UNPACK arg3_type arg3) const { \
-		if (!func_name##_ptr) {                                                                                           \
-			return XR_ERROR_HANDLE_INVALID;                                                                               \
-		}                                                                                                                 \
-		return (*func_name##_ptr)(arg1, arg2, arg3);                                                                      \
+#define EXT_PROTO_XRRESULT_FUNC3(func_name, arg1_type, arg1, arg2_type, arg2, arg3_type, arg3)                                        \
+	PFN_##func_name func_name##_ptr = nullptr;                                                                                        \
+	XRAPI_ATTR XrResult XRAPI_CALL func_name(UNPACK arg1_type p_##arg1, UNPACK arg2_type p_##arg2, UNPACK arg3_type p_##arg3) const { \
+		if (!func_name##_ptr) {                                                                                                       \
+			return XR_ERROR_HANDLE_INVALID;                                                                                           \
+		}                                                                                                                             \
+		return (*func_name##_ptr)(p_##arg1, p_##arg2, p_##arg3);                                                                      \
 	}
 
-#define EXT_PROTO_XRRESULT_FUNC4(func_name, arg1_type, arg1, arg2_type, arg2, arg3_type, arg3, arg4_type, arg4)                                  \
-	PFN_##func_name func_name##_ptr = nullptr;                                                                                                   \
-	XRAPI_ATTR XrResult XRAPI_CALL func_name(UNPACK arg1_type arg1, UNPACK arg2_type arg2, UNPACK arg3_type arg3, UNPACK arg4_type arg4) const { \
-		if (!func_name##_ptr) {                                                                                                                  \
-			return XR_ERROR_HANDLE_INVALID;                                                                                                      \
-		}                                                                                                                                        \
-		return (*func_name##_ptr)(arg1, arg2, arg3, arg4);                                                                                       \
+#define EXT_PROTO_XRRESULT_FUNC4(func_name, arg1_type, arg1, arg2_type, arg2, arg3_type, arg3, arg4_type, arg4)                                                  \
+	PFN_##func_name func_name##_ptr = nullptr;                                                                                                                   \
+	XRAPI_ATTR XrResult XRAPI_CALL func_name(UNPACK arg1_type p_##arg1, UNPACK arg2_type p_##arg2, UNPACK arg3_type p_##arg3, UNPACK arg4_type p_##arg4) const { \
+		if (!func_name##_ptr) {                                                                                                                                  \
+			return XR_ERROR_HANDLE_INVALID;                                                                                                                      \
+		}                                                                                                                                                        \
+		return (*func_name##_ptr)(p_##arg1, p_##arg2, p_##arg3, p_##arg4);                                                                                       \
 	}
 
-#define EXT_PROTO_XRRESULT_FUNC5(func_name, arg1_type, arg1, arg2_type, arg2, arg3_type, arg3, arg4_type, arg4, arg5_type, arg5)                                        \
-	PFN_##func_name func_name##_ptr = nullptr;                                                                                                                          \
-	XRAPI_ATTR XrResult XRAPI_CALL func_name(UNPACK arg1_type arg1, UNPACK arg2_type arg2, UNPACK arg3_type arg3, UNPACK arg4_type arg4, UNPACK arg5_type arg5) const { \
-		if (!func_name##_ptr) {                                                                                                                                         \
-			return XR_ERROR_HANDLE_INVALID;                                                                                                                             \
-		}                                                                                                                                                               \
-		return (*func_name##_ptr)(arg1, arg2, arg3, arg4, arg5);                                                                                                        \
+#define EXT_PROTO_XRRESULT_FUNC5(func_name, arg1_type, arg1, arg2_type, arg2, arg3_type, arg3, arg4_type, arg4, arg5_type, arg5)                                                            \
+	PFN_##func_name func_name##_ptr = nullptr;                                                                                                                                              \
+	XRAPI_ATTR XrResult XRAPI_CALL func_name(UNPACK arg1_type p_##arg1, UNPACK arg2_type p_##arg2, UNPACK arg3_type p_##arg3, UNPACK arg4_type p_##arg4, UNPACK arg5_type p_##arg5) const { \
+		if (!func_name##_ptr) {                                                                                                                                                             \
+			return XR_ERROR_HANDLE_INVALID;                                                                                                                                                 \
+		}                                                                                                                                                                                   \
+		return (*func_name##_ptr)(p_##arg1, p_##arg2, p_##arg3, p_##arg4, p_##arg5);                                                                                                        \
 	}
 
-#define EXT_PROTO_XRRESULT_FUNC6(func_name, arg1_type, arg1, arg2_type, arg2, arg3_type, arg3, arg4_type, arg4, arg5_type, arg5, arg6_type, arg6)                                              \
-	PFN_##func_name func_name##_ptr = nullptr;                                                                                                                                                 \
-	XRAPI_ATTR XrResult XRAPI_CALL func_name(UNPACK arg1_type arg1, UNPACK arg2_type arg2, UNPACK arg3_type arg3, UNPACK arg4_type arg4, UNPACK arg5_type arg5, UNPACK arg6_type arg6) const { \
-		if (!func_name##_ptr) {                                                                                                                                                                \
-			return XR_ERROR_HANDLE_INVALID;                                                                                                                                                    \
-		}                                                                                                                                                                                      \
-		return (*func_name##_ptr)(arg1, arg2, arg3, arg4, arg5, arg6);                                                                                                                         \
+#define EXT_PROTO_XRRESULT_FUNC6(func_name, arg1_type, arg1, arg2_type, arg2, arg3_type, arg3, arg4_type, arg4, arg5_type, arg5, arg6_type, arg6)                                                                      \
+	PFN_##func_name func_name##_ptr = nullptr;                                                                                                                                                                         \
+	XRAPI_ATTR XrResult XRAPI_CALL func_name(UNPACK arg1_type p_##arg1, UNPACK arg2_type p_##arg2, UNPACK arg3_type p_##arg3, UNPACK arg4_type p_##arg4, UNPACK arg5_type p_##arg5, UNPACK arg6_type p_##arg6) const { \
+		if (!func_name##_ptr) {                                                                                                                                                                                        \
+			return XR_ERROR_HANDLE_INVALID;                                                                                                                                                                            \
+		}                                                                                                                                                                                                              \
+		return (*func_name##_ptr)(p_##arg1, p_##arg2, p_##arg3, p_##arg4, p_##arg5, p_##arg6);                                                                                                                         \
 	}
 
 #endif // UTIL_H
diff --git a/modules/text_server_adv/text_server_adv.cpp b/modules/text_server_adv/text_server_adv.cpp
index d0301eeae3..c9b0fa7dd5 100644
--- a/modules/text_server_adv/text_server_adv.cpp
+++ b/modules/text_server_adv/text_server_adv.cpp
@@ -5401,7 +5401,7 @@ bool TextServerAdvanced::_shaped_text_shape(const RID &p_shaped) {
 					int32_t script_run_end = MIN(sd->script_iter->script_ranges[j].end, bidi_run_end);
 					char scr_buffer[5] = { 0, 0, 0, 0, 0 };
 					hb_tag_to_string(hb_script_to_iso15924_tag(sd->script_iter->script_ranges[j].script), scr_buffer);
-					String script = String(scr_buffer);
+					String script_code = String(scr_buffer);
 
 					int spn_from = (is_rtl) ? 0 : sd->spans.size() - 1;
 					int spn_to = (is_rtl) ? sd->spans.size() : -1;
@@ -5441,7 +5441,7 @@ bool TextServerAdvanced::_shaped_text_shape(const RID &p_shaped) {
 								fonts.push_back(sd->spans[k].fonts[0]);
 							}
 							for (int l = 1; l < font_count; l++) {
-								if (_font_is_script_supported(span.fonts[l], script)) {
+								if (_font_is_script_supported(span.fonts[l], script_code)) {
 									if (_font_is_language_supported(span.fonts[l], span.language)) {
 										fonts.push_back(sd->spans[k].fonts[l]);
 									} else {
diff --git a/modules/theora/video_stream_theora.cpp b/modules/theora/video_stream_theora.cpp
index 57f055ca42..1284412cd8 100644
--- a/modules/theora/video_stream_theora.cpp
+++ b/modules/theora/video_stream_theora.cpp
@@ -33,8 +33,17 @@
 #include "core/config/project_settings.h"
 #include "core/os/os.h"
 
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4127)
+#endif
+
 #include "thirdparty/misc/yuv2rgb.h"
 
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
 int VideoStreamPlaybackTheora::buffer_data() {
 	char *buffer = ogg_sync_buffer(&oy, 4096);
 
@@ -242,16 +251,9 @@ void VideoStreamPlaybackTheora::set_file(const String &p_file) {
 
 	/* we're expecting more header packets. */
 	while ((theora_p && theora_p < 3) || (vorbis_p && vorbis_p < 3)) {
-#ifdef _MSC_VER
-		// Make exception for these assignments in conditional expression.
-#pragma warning(push)
-#pragma warning(disable : 4706)
-#endif
-
-		int ret;
-
 		/* look for further theora headers */
-		while (theora_p && (theora_p < 3) && (ret = ogg_stream_packetout(&to, &op))) {
+		int ret = ogg_stream_packetout(&to, &op);
+		while (theora_p && theora_p < 3 && ret) {
 			if (ret < 0) {
 				fprintf(stderr, "Error parsing Theora stream headers; corrupt stream?\n");
 				clear();
@@ -262,11 +264,13 @@ void VideoStreamPlaybackTheora::set_file(const String &p_file) {
 				clear();
 				return;
 			}
+			ret = ogg_stream_packetout(&to, &op);
 			theora_p++;
 		}
 
 		/* look for more vorbis header packets */
-		while (vorbis_p && (vorbis_p < 3) && (ret = ogg_stream_packetout(&vo, &op))) {
+		ret = ogg_stream_packetout(&vo, &op);
+		while (vorbis_p && vorbis_p < 3 && ret) {
 			if (ret < 0) {
 				fprintf(stderr, "Error parsing Vorbis stream headers; corrupt stream?\n");
 				clear();
@@ -282,12 +286,9 @@ void VideoStreamPlaybackTheora::set_file(const String &p_file) {
 			if (vorbis_p == 3) {
 				break;
 			}
+			ret = ogg_stream_packetout(&vo, &op);
 		}
 
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
 		/* The header pages/packets will arrive before anything else we
 		care about, or the stream is not obeying spec */
 
@@ -464,12 +465,6 @@ void VideoStreamPlaybackTheora::update(double p_delta) {
 		while (theora_p && !frame_done) {
 			/* theora is one in, one out... */
 			if (ogg_stream_packetout(&to, &op) > 0) {
-				if (false && pp_inc) {
-					pp_level += pp_inc;
-					th_decode_ctl(td, TH_DECCTL_SET_PPLEVEL, &pp_level,
-							sizeof(pp_level));
-					pp_inc = 0;
-				}
 				/*HACK: This should be set after a seek or a gap, but we might not have
 				a granulepos for the first packet (we only have them for the last
 				packet on a page), so we just set it as often as we get it.
-- 
cgit v1.2.3