Add -Wshadow=local to warnings and fix reported issues.

Fixes #25316.

22 files changed, 216 insertions, 219 deletions

diff --git a/modules/csg/csg.cpp b/modules/csg/csg.cpp
index a0be0138d3..fb7f829cf0 100644
--- a/modules/csg/csg.cpp
+++ b/modules/csg/csg.cpp
@@ -666,14 +666,14 @@ void CSGBrushOperation::_add_poly_points(const BuildPoly &p_poly, int p_edge, in
 				if (opposite_point == prev_point)
 					continue; //not going back
 
-				EdgeSort e;
+				EdgeSort e2;
 				Vector2 local_vec = t2d.xform(p_poly.points[opposite_point].point);
-				e.angle = -local_vec.angle(); //negate so we can sort by minimum angle
-				e.edge = edge;
-				e.edge_point = opposite_point;
-				e.prev_point = to_point;
+				e2.angle = -local_vec.angle(); //negate so we can sort by minimum angle
+				e2.edge = edge;
+				e2.edge_point = opposite_point;
+				e2.prev_point = to_point;
 
-				next_edges.push_back(e);
+				next_edges.push_back(e2);
 			}
 
 			//finally, sort by minimum angle
diff --git a/modules/dds/texture_loader_dds.cpp b/modules/dds/texture_loader_dds.cpp
index a063942269..0a94690989 100644
--- a/modules/dds/texture_loader_dds.cpp
+++ b/modules/dds/texture_loader_dds.cpp
@@ -263,14 +263,14 @@ RES ResourceFormatDDS::load(const String &p_path, const String &p_original_path,
 				colsize = 4;
 		}
 
-		int w = width;
-		int h = height;
+		int w2 = width;
+		int h2 = height;
 
 		for (uint32_t i = 1; i < mipmaps; i++) {
 
-			w = (w + 1) >> 1;
-			h = (h + 1) >> 1;
-			size += w * h * info.block_size;
+			w2 = (w2 + 1) >> 1;
+			h2 = (h2 + 1) >> 1;
+			size += w2 * h2 * info.block_size;
 		}
 
 		src_data.resize(size + 256 * colsize);
diff --git a/modules/gdnative/register_types.cpp b/modules/gdnative/register_types.cpp
index b38de75caa..2094dca6e4 100644
--- a/modules/gdnative/register_types.cpp
+++ b/modules/gdnative/register_types.cpp
@@ -125,8 +125,8 @@ static void actual_discoverer_handler() {
 
 	// Check for removed files
 	if (!changed) {
-		for (int i = 0; i < current_files.size(); i++) {
-			if (!file_paths.has(current_files[i])) {
+		for (int j = 0; j < current_files.size(); j++) {
+			if (!file_paths.has(current_files[j])) {
 				changed = true;
 				break;
 			}
diff --git a/modules/gdscript/gdscript.cpp b/modules/gdscript/gdscript.cpp
index f29432666e..dd9b36fd8c 100644
--- a/modules/gdscript/gdscript.cpp
+++ b/modules/gdscript/gdscript.cpp
@@ -1108,12 +1108,12 @@ void GDScriptInstance::get_property_list(List<PropertyInfo> *p_properties) const
 		//instance a fake script for editing the values
 
 		Vector<_GDScriptMemberSort> msort;
-		for (Map<StringName, PropertyInfo>::Element *E = sptr->member_info.front(); E; E = E->next()) {
+		for (Map<StringName, PropertyInfo>::Element *F = sptr->member_info.front(); F; F = F->next()) {
 
 			_GDScriptMemberSort ms;
-			ERR_CONTINUE(!sptr->member_indices.has(E->key()));
-			ms.index = sptr->member_indices[E->key()].index;
-			ms.name = E->key();
+			ERR_CONTINUE(!sptr->member_indices.has(F->key()));
+			ms.index = sptr->member_indices[F->key()].index;
+			ms.name = F->key();
 			msort.push_back(ms);
 		}
 
diff --git a/modules/gdscript/gdscript_compiler.cpp b/modules/gdscript/gdscript_compiler.cpp
index d256918b22..b2b7b1c260 100644
--- a/modules/gdscript/gdscript_compiler.cpp
+++ b/modules/gdscript/gdscript_compiler.cpp
@@ -1360,15 +1360,15 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 							// jump unconditionally
 							// continue address
 							// compile the condition
-							int ret = _parse_expression(codegen, branch.compiled_pattern, p_stack_level);
-							if (ret < 0) {
+							int ret2 = _parse_expression(codegen, branch.compiled_pattern, p_stack_level);
+							if (ret2 < 0) {
 								memdelete(id);
 								memdelete(op);
 								return ERR_PARSE_ERROR;
 							}
 
 							codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF);
-							codegen.opcodes.push_back(ret);
+							codegen.opcodes.push_back(ret2);
 							codegen.opcodes.push_back(codegen.opcodes.size() + 3);
 							int continue_addr = codegen.opcodes.size();
 							codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
@@ -1401,12 +1401,12 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 						codegen.opcodes.push_back(cf->line);
 						codegen.current_line = cf->line;
 #endif
-						int ret = _parse_expression(codegen, cf->arguments[0], p_stack_level, false);
-						if (ret < 0)
+						int ret2 = _parse_expression(codegen, cf->arguments[0], p_stack_level, false);
+						if (ret2 < 0)
 							return ERR_PARSE_ERROR;
 
 						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF_NOT);
-						codegen.opcodes.push_back(ret);
+						codegen.opcodes.push_back(ret2);
 						int else_addr = codegen.opcodes.size();
 						codegen.opcodes.push_back(0); //temporary
 
@@ -1421,9 +1421,9 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 							codegen.opcodes.push_back(0);
 							codegen.opcodes.write[else_addr] = codegen.opcodes.size();
 
-							Error err = _parse_block(codegen, cf->body_else, p_stack_level, p_break_addr, p_continue_addr);
-							if (err)
-								return err;
+							Error err2 = _parse_block(codegen, cf->body_else, p_stack_level, p_break_addr, p_continue_addr);
+							if (err2)
+								return err2;
 
 							codegen.opcodes.write[end_addr] = codegen.opcodes.size();
 						} else {
@@ -1444,14 +1444,14 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 						codegen.push_stack_identifiers();
 						codegen.add_stack_identifier(static_cast<const GDScriptParser::IdentifierNode *>(cf->arguments[0])->name, iter_stack_pos);
 
-						int ret = _parse_expression(codegen, cf->arguments[1], slevel, false);
-						if (ret < 0)
+						int ret2 = _parse_expression(codegen, cf->arguments[1], slevel, false);
+						if (ret2 < 0)
 							return ERR_COMPILATION_FAILED;
 
 						//assign container
 						codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN);
 						codegen.opcodes.push_back(container_pos);
-						codegen.opcodes.push_back(ret);
+						codegen.opcodes.push_back(ret2);
 
 						//begin loop
 						codegen.opcodes.push_back(GDScriptFunction::OPCODE_ITERATE_BEGIN);
@@ -1493,11 +1493,11 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 						codegen.opcodes.push_back(0);
 						int continue_addr = codegen.opcodes.size();
 
-						int ret = _parse_expression(codegen, cf->arguments[0], p_stack_level, false);
-						if (ret < 0)
+						int ret2 = _parse_expression(codegen, cf->arguments[0], p_stack_level, false);
+						if (ret2 < 0)
 							return ERR_PARSE_ERROR;
 						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF_NOT);
-						codegen.opcodes.push_back(ret);
+						codegen.opcodes.push_back(ret2);
 						codegen.opcodes.push_back(break_addr);
 						Error err = _parse_block(codegen, cf->body, p_stack_level, break_addr, continue_addr);
 						if (err)
@@ -1533,21 +1533,21 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 					} break;
 					case GDScriptParser::ControlFlowNode::CF_RETURN: {
 
-						int ret;
+						int ret2;
 
 						if (cf->arguments.size()) {
 
-							ret = _parse_expression(codegen, cf->arguments[0], p_stack_level, false);
-							if (ret < 0)
+							ret2 = _parse_expression(codegen, cf->arguments[0], p_stack_level, false);
+							if (ret2 < 0)
 								return ERR_PARSE_ERROR;
 
 						} else {
 
-							ret = GDScriptFunction::ADDR_TYPE_NIL << GDScriptFunction::ADDR_BITS;
+							ret2 = GDScriptFunction::ADDR_TYPE_NIL << GDScriptFunction::ADDR_BITS;
 						}
 
 						codegen.opcodes.push_back(GDScriptFunction::OPCODE_RETURN);
-						codegen.opcodes.push_back(ret);
+						codegen.opcodes.push_back(ret2);
 
 					} break;
 				}
@@ -1558,12 +1558,12 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 
 				const GDScriptParser::AssertNode *as = static_cast<const GDScriptParser::AssertNode *>(s);
 
-				int ret = _parse_expression(codegen, as->condition, p_stack_level, false);
-				if (ret < 0)
+				int ret2 = _parse_expression(codegen, as->condition, p_stack_level, false);
+				if (ret2 < 0)
 					return ERR_PARSE_ERROR;
 
 				codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSERT);
-				codegen.opcodes.push_back(ret);
+				codegen.opcodes.push_back(ret2);
 #endif
 			} break;
 			case GDScriptParser::Node::TYPE_BREAKPOINT: {
@@ -1590,8 +1590,8 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 			} break;
 			default: {
 				//expression
-				int ret = _parse_expression(codegen, s, p_stack_level, true);
-				if (ret < 0)
+				int ret2 = _parse_expression(codegen, s, p_stack_level, true);
+				if (ret2 < 0)
 					return ERR_PARSE_ERROR;
 			} break;
 		}
@@ -2116,8 +2116,8 @@ Error GDScriptCompiler::_parse_class_blocks(GDScript *p_script, const GDScriptPa
 					instance->owner = E->get();
 
 					//needed for hot reloading
-					for (Map<StringName, GDScript::MemberInfo>::Element *E = p_script->member_indices.front(); E; E = E->next()) {
-						instance->member_indices_cache[E->key()] = E->get().index;
+					for (Map<StringName, GDScript::MemberInfo>::Element *F = p_script->member_indices.front(); F; F = F->next()) {
+						instance->member_indices_cache[F->key()] = F->get().index;
 					}
 					instance->owner->set_script_instance(instance);
 
diff --git a/modules/gdscript/gdscript_editor.cpp b/modules/gdscript/gdscript_editor.cpp
index af770ac533..fafc73b7e6 100644
--- a/modules/gdscript/gdscript_editor.cpp
+++ b/modules/gdscript/gdscript_editor.cpp
@@ -785,12 +785,12 @@ static bool _guess_expression_type(GDScriptCompletionContext &p_context, const G
 								if (mb && mb->is_const()) {
 									bool all_is_const = true;
 									Vector<Variant> args;
-									GDScriptCompletionContext c = p_context;
-									c.line = op->line;
+									GDScriptCompletionContext c2 = p_context;
+									c2.line = op->line;
 									for (int i = 2; all_is_const && i < op->arguments.size(); i++) {
 										GDScriptCompletionIdentifier arg;
 
-										if (_guess_expression_type(c, op->arguments[i], arg)) {
+										if (_guess_expression_type(c2, op->arguments[i], arg)) {
 											if (arg.type.has_type && arg.type.is_constant && arg.value.get_type() != Variant::OBJECT) {
 												args.push_back(arg.value);
 											} else {
@@ -1282,9 +1282,9 @@ static bool _guess_identifier_type(GDScriptCompletionContext &p_context, const S
 					for (List<MethodInfo>::Element *E = methods.front(); E; E = E->next()) {
 						if (E->get().name == p_context.function->name) {
 							MethodInfo &mi = E->get();
-							for (List<PropertyInfo>::Element *E = mi.arguments.front(); E; E = E->next()) {
-								if (E->get().name == p_identifier) {
-									r_type = _type_from_property(E->get());
+							for (List<PropertyInfo>::Element *F = mi.arguments.front(); F; F = F->next()) {
+								if (F->get().name == p_identifier) {
+									r_type = _type_from_property(F->get());
 									return true;
 								}
 							}
@@ -2237,8 +2237,8 @@ static void _find_call_arguments(const GDScriptCompletionContext &p_context, con
 							if (obj) {
 								List<String> options;
 								obj->get_argument_options(p_method, p_argidx, &options);
-								for (List<String>::Element *E = options.front(); E; E = E->next()) {
-									r_result.insert(E->get());
+								for (List<String>::Element *F = options.front(); F; F = F->next()) {
+									r_result.insert(F->get());
 								}
 							}
 						}
@@ -2806,12 +2806,12 @@ Error GDScriptLanguage::complete_code(const String &p_code, const String &p_base
 						if (base_type.class_type) {
 							for (Map<StringName, GDScriptParser::ClassNode::Constant>::Element *E = base_type.class_type->constant_expressions.front(); E; E = E->next()) {
 								GDScriptCompletionIdentifier constant;
-								GDScriptCompletionContext c = context;
-								c._class = base_type.class_type;
-								c.function = NULL;
-								c.block = NULL;
-								c.line = E->value().expression->line;
-								if (_guess_expression_type(c, E->value().expression, constant)) {
+								GDScriptCompletionContext c2 = context;
+								c2._class = base_type.class_type;
+								c2.function = NULL;
+								c2.block = NULL;
+								c2.line = E->value().expression->line;
+								if (_guess_expression_type(c2, E->value().expression, constant)) {
 									if (constant.type.has_type && constant.type.is_meta_type) {
 										options.insert(E->key().operator String());
 									}
diff --git a/modules/gdscript/gdscript_parser.cpp b/modules/gdscript/gdscript_parser.cpp
index b53d37226c..a642abeb0a 100644
--- a/modules/gdscript/gdscript_parser.cpp
+++ b/modules/gdscript/gdscript_parser.cpp
@@ -2640,14 +2640,14 @@ void GDScriptParser::_transform_match_statment(MatchNode *p_match_statement) {
 			local_var->assign = e->value();
 			local_var->set_datatype(local_var->assign->get_datatype());
 
-			IdentifierNode *id = alloc_node<IdentifierNode>();
-			id->name = local_var->name;
-			id->declared_block = branch->body;
-			id->set_datatype(local_var->assign->get_datatype());
+			IdentifierNode *id2 = alloc_node<IdentifierNode>();
+			id2->name = local_var->name;
+			id2->declared_block = branch->body;
+			id2->set_datatype(local_var->assign->get_datatype());
 
 			OperatorNode *op = alloc_node<OperatorNode>();
 			op->op = OperatorNode::OP_ASSIGN;
-			op->arguments.push_back(id);
+			op->arguments.push_back(id2);
 			op->arguments.push_back(local_var->assign);
 
 			branch->body->statements.push_front(op);
@@ -2694,9 +2694,9 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 
 		if (pending_newline != -1) {
 
-			NewLineNode *nl = alloc_node<NewLineNode>();
-			nl->line = pending_newline;
-			p_block->statements.push_back(nl);
+			NewLineNode *nl2 = alloc_node<NewLineNode>();
+			nl2->line = pending_newline;
+			p_block->statements.push_back(nl2);
 			pending_newline = -1;
 		}
 
@@ -2735,9 +2735,9 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 					return;
 				}
 
-				NewLineNode *nl = alloc_node<NewLineNode>();
-				nl->line = tokenizer->get_token_line();
-				p_block->statements.push_back(nl);
+				NewLineNode *nl2 = alloc_node<NewLineNode>();
+				nl2->line = tokenizer->get_token_line();
+				p_block->statements.push_back(nl2);
 
 			} break;
 			case GDScriptTokenizer::TK_CF_PASS: {
@@ -2922,14 +2922,14 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 						cf_else->cf_type = ControlFlowNode::CF_IF;
 
 						//condition
-						Node *condition = _parse_and_reduce_expression(p_block, p_static);
-						if (!condition) {
+						Node *condition2 = _parse_and_reduce_expression(p_block, p_static);
+						if (!condition2) {
 							if (_recover_from_completion()) {
 								break;
 							}
 							return;
 						}
-						cf_else->arguments.push_back(condition);
+						cf_else->arguments.push_back(condition2);
 						cf_else->cf_type = ControlFlowNode::CF_IF;
 
 						cf_if->body_else->statements.push_back(cf_else);
@@ -2992,8 +2992,8 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 			case GDScriptTokenizer::TK_CF_WHILE: {
 
 				tokenizer->advance();
-				Node *condition = _parse_and_reduce_expression(p_block, p_static);
-				if (!condition) {
+				Node *condition2 = _parse_and_reduce_expression(p_block, p_static);
+				if (!condition2) {
 					if (_recover_from_completion()) {
 						break;
 					}
@@ -3003,7 +3003,7 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 				ControlFlowNode *cf_while = alloc_node<ControlFlowNode>();
 
 				cf_while->cf_type = ControlFlowNode::CF_WHILE;
-				cf_while->arguments.push_back(condition);
+				cf_while->arguments.push_back(condition2);
 
 				cf_while->body = alloc_node<BlockNode>();
 				cf_while->body->parent_block = p_block;
@@ -4705,12 +4705,12 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 					op->arguments.push_back(subexpr);
 
 #ifdef DEBUG_ENABLED
-					NewLineNode *nl = alloc_node<NewLineNode>();
-					nl->line = line;
+					NewLineNode *nl2 = alloc_node<NewLineNode>();
+					nl2->line = line;
 					if (onready)
-						p_class->ready->statements.push_back(nl);
+						p_class->ready->statements.push_back(nl2);
 					else
-						p_class->initializer->statements.push_back(nl);
+						p_class->initializer->statements.push_back(nl2);
 #endif
 					if (onready)
 						p_class->ready->statements.push_back(op);
@@ -4732,8 +4732,8 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 
 						ConstantNode *cn = alloc_node<ConstantNode>();
 
-						Variant::CallError ce;
-						cn->value = Variant::construct(member._export.type, NULL, 0, ce);
+						Variant::CallError ce2;
+						cn->value = Variant::construct(member._export.type, NULL, 0, ce2);
 
 						OperatorNode *op = alloc_node<OperatorNode>();
 						op->op = OperatorNode::OP_INIT_ASSIGN;
@@ -5523,10 +5523,10 @@ GDScriptParser::DataType GDScriptParser::_resolve_type(const DataType &p_source,
 					result.script_type = gds;
 					found = true;
 				} else {
-					Ref<Script> scr = constants[id];
-					if (scr.is_valid()) {
+					Ref<Script> scr2 = constants[id];
+					if (scr2.is_valid()) {
 						result.kind = DataType::SCRIPT;
-						result.script_type = scr;
+						result.script_type = scr2;
 						found = true;
 					}
 				}
@@ -6646,7 +6646,7 @@ GDScriptParser::DataType GDScriptParser::_reduce_function_call_type(const Operat
 			bool match = false;
 			List<MethodInfo> constructors;
 			Variant::get_constructor_list(tn->vtype, &constructors);
-			PropertyInfo return_type;
+			PropertyInfo return_type2;
 
 			for (List<MethodInfo>::Element *E = constructors.front(); E; E = E->next()) {
 				MethodInfo &mi = E->get();
@@ -6685,13 +6685,13 @@ GDScriptParser::DataType GDScriptParser::_reduce_function_call_type(const Operat
 
 				if (types_match) {
 					match = true;
-					return_type = mi.return_val;
+					return_type2 = mi.return_val;
 					break;
 				}
 			}
 
 			if (match) {
-				return _type_from_property(return_type, false);
+				return _type_from_property(return_type2, false);
 			} else if (check_types) {
 				String err = "No constructor of '";
 				err += Variant::get_type_name(tn->vtype);
@@ -7603,7 +7603,7 @@ void GDScriptParser::_check_function_types(FunctionNode *p_function) {
 				}
 				parent_signature += " " + p_function->name + "(";
 				if (arg_types.size()) {
-					int i = 0;
+					int j = 0;
 					for (List<DataType>::Element *E = arg_types.front(); E; E = E->next()) {
 						if (E != arg_types.front()) {
 							parent_signature += ", ";
@@ -7613,11 +7613,11 @@ void GDScriptParser::_check_function_types(FunctionNode *p_function) {
 							arg = "Variant";
 						}
 						parent_signature += arg;
-						if (i == arg_types.size() - default_arg_count) {
+						if (j == arg_types.size() - default_arg_count) {
 							parent_signature += "=default";
 						}
 
-						i++;
+						j++;
 					}
 				}
 				parent_signature += ")";
diff --git a/modules/gdscript/gdscript_tokenizer.cpp b/modules/gdscript/gdscript_tokenizer.cpp
index 0f2f0bbb26..dc9f2db331 100644
--- a/modules/gdscript/gdscript_tokenizer.cpp
+++ b/modules/gdscript/gdscript_tokenizer.cpp
@@ -989,11 +989,11 @@ void GDScriptTokenizerText::_advance() {
 
 							//built in func?
 
-							for (int i = 0; i < GDScriptFunctions::FUNC_MAX; i++) {
+							for (int j = 0; j < GDScriptFunctions::FUNC_MAX; j++) {
 
-								if (str == GDScriptFunctions::get_func_name(GDScriptFunctions::Function(i))) {
+								if (str == GDScriptFunctions::get_func_name(GDScriptFunctions::Function(j))) {
 
-									_make_built_in_func(GDScriptFunctions::Function(i));
+									_make_built_in_func(GDScriptFunctions::Function(j));
 									found = true;
 									break;
 								}
diff --git a/modules/gridmap/grid_map_editor_plugin.cpp b/modules/gridmap/grid_map_editor_plugin.cpp
index 12c4a18a64..fb98755444 100644
--- a/modules/gridmap/grid_map_editor_plugin.cpp
+++ b/modules/gridmap/grid_map_editor_plugin.cpp
@@ -289,11 +289,11 @@ void GridMapEditor::_update_selection_transform() {
 			scale *= node->get_cell_size();
 			pos *= node->get_cell_size();
 
-			Transform xf;
-			xf.basis.scale(scale);
-			xf.origin = pos;
+			Transform xf2;
+			xf2.basis.scale(scale);
+			xf2.origin = pos;
 
-			VisualServer::get_singleton()->instance_set_transform(selection_level_instance[i], xf);
+			VisualServer::get_singleton()->instance_set_transform(selection_level_instance[i], xf2);
 		}
 	}
 }
diff --git a/modules/mono/csharp_script.cpp b/modules/mono/csharp_script.cpp
index 9c127b837d..51615df64e 100644
--- a/modules/mono/csharp_script.cpp
+++ b/modules/mono/csharp_script.cpp
@@ -719,13 +719,13 @@ void CSharpLanguage::reload_assemblies(bool p_soft_reload) {
 		// Script::instances are deleted during managed object disposal, which happens on domain finalize.
 		// Only placeholders are kept. Therefore we need to keep a copy before that happens.
 
-		for (Set<Object *>::Element *E = script->instances.front(); E; E = E->next()) {
-			script->pending_reload_instances.insert(E->get()->get_instance_id());
+		for (Set<Object *>::Element *F = script->instances.front(); F; F = F->next()) {
+			script->pending_reload_instances.insert(F->get()->get_instance_id());
 		}
 
 #ifdef TOOLS_ENABLED
-		for (Set<PlaceHolderScriptInstance *>::Element *E = script->placeholders.front(); E; E = E->next()) {
-			script->pending_reload_instances.insert(E->get()->get_owner()->get_instance_id());
+		for (Set<PlaceHolderScriptInstance *>::Element *F = script->placeholders.front(); F; F = F->next()) {
+			script->pending_reload_instances.insert(F->get()->get_owner()->get_instance_id());
 		}
 #endif
 
diff --git a/modules/mono/editor/bindings_generator.cpp b/modules/mono/editor/bindings_generator.cpp
index 2161b15591..cffccd5cb5 100644
--- a/modules/mono/editor/bindings_generator.cpp
+++ b/modules/mono/editor/bindings_generator.cpp
@@ -365,8 +365,8 @@ void BindingsGenerator::_generate_global_constants(List<String> &p_output) {
 		p_output.push_back(enum_proxy_name);
 		p_output.push_back("\n" INDENT1 OPEN_BLOCK);
 
-		for (const List<ConstantInterface>::Element *E = ienum.constants.front(); E; E = E->next()) {
-			const ConstantInterface &iconstant = E->get();
+		for (const List<ConstantInterface>::Element *F = ienum.constants.front(); F; F = F->next()) {
+			const ConstantInterface &iconstant = F->get();
 
 			if (iconstant.const_doc && iconstant.const_doc->description.size()) {
 				p_output.push_back(INDENT2 "/// <summary>\n");
@@ -389,7 +389,7 @@ void BindingsGenerator::_generate_global_constants(List<String> &p_output) {
 			p_output.push_back(iconstant.proxy_name);
 			p_output.push_back(" = ");
 			p_output.push_back(itos(iconstant.value));
-			p_output.push_back(E != ienum.constants.back() ? ",\n" : "\n");
+			p_output.push_back(F != ienum.constants.back() ? ",\n" : "\n");
 		}
 
 		p_output.push_back(INDENT1 CLOSE_BLOCK);
@@ -472,8 +472,6 @@ Error BindingsGenerator::generate_cs_core_project(const String &p_solution_dir,
 		String output_dir = output_file.get_base_dir();
 
 		if (!DirAccess::exists(output_dir)) {
-			DirAccessRef da = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
-			ERR_FAIL_COND_V(!da, ERR_CANT_CREATE);
 			Error err = da->make_dir_recursive(ProjectSettings::get_singleton()->globalize_path(output_dir));
 			ERR_FAIL_COND_V(err != OK, ERR_CANT_CREATE);
 		}
@@ -806,8 +804,8 @@ Error BindingsGenerator::_generate_cs_type(const TypeInterface &itype, const Str
 			output.push_back(ienum.cname.operator String());
 			output.push_back(MEMBER_BEGIN OPEN_BLOCK);
 
-			for (const List<ConstantInterface>::Element *E = ienum.constants.front(); E; E = E->next()) {
-				const ConstantInterface &iconstant = E->get();
+			for (const List<ConstantInterface>::Element *F = ienum.constants.front(); F; F = F->next()) {
+				const ConstantInterface &iconstant = F->get();
 
 				if (iconstant.const_doc && iconstant.const_doc->description.size()) {
 					output.push_back(INDENT3 "/// <summary>\n");
@@ -830,7 +828,7 @@ Error BindingsGenerator::_generate_cs_type(const TypeInterface &itype, const Str
 				output.push_back(iconstant.proxy_name);
 				output.push_back(" = ");
 				output.push_back(itos(iconstant.value));
-				output.push_back(E != ienum.constants.back() ? ",\n" : "\n");
+				output.push_back(F != ienum.constants.back() ? ",\n" : "\n");
 			}
 
 			output.push_back(INDENT2 CLOSE_BLOCK);
@@ -1889,8 +1887,8 @@ void BindingsGenerator::_populate_object_type_interfaces() {
 			}
 
 			if (!imethod.is_virtual && imethod.name[0] == '_') {
-				for (const List<PropertyInterface>::Element *E = itype.properties.front(); E; E = E->next()) {
-					const PropertyInterface &iprop = E->get();
+				for (const List<PropertyInterface>::Element *F = itype.properties.front(); F; F = F->next()) {
+					const PropertyInterface &iprop = F->get();
 
 					if (iprop.setter == imethod.name || iprop.getter == imethod.name) {
 						imethod.is_internal = true;
@@ -2352,9 +2350,9 @@ void BindingsGenerator::_populate_global_constants() {
 
 			if (enum_name != StringName()) {
 				EnumInterface ienum(enum_name);
-				List<EnumInterface>::Element *match = global_enums.find(ienum);
-				if (match) {
-					match->get().constants.push_back(iconstant);
+				List<EnumInterface>::Element *enum_match = global_enums.find(ienum);
+				if (enum_match) {
+					enum_match->get().constants.push_back(iconstant);
 				} else {
 					ienum.constants.push_back(iconstant);
 					global_enums.push_back(ienum);
diff --git a/modules/mono/editor/godotsharp_export.cpp b/modules/mono/editor/godotsharp_export.cpp
index 7e2487a6e7..ee5fed1a0c 100644
--- a/modules/mono/editor/godotsharp_export.cpp
+++ b/modules/mono/editor/godotsharp_export.cpp
@@ -194,8 +194,8 @@ Error GodotSharpExport::_get_assembly_dependencies(GDMonoAssembly *p_assembly, c
 		String path;
 		bool has_extension = ref_name.ends_with(".dll") || ref_name.ends_with(".exe");
 
-		for (int i = 0; i < p_search_dirs.size(); i++) {
-			const String &search_dir = p_search_dirs[i];
+		for (int j = 0; j < p_search_dirs.size(); j++) {
+			const String &search_dir = p_search_dirs[j];
 
 			if (has_extension) {
 				path = search_dir.plus_file(ref_name);
diff --git a/modules/mono/editor/script_class_parser.cpp b/modules/mono/editor/script_class_parser.cpp
index 1281ed669f..53a043b675 100644
--- a/modules/mono/editor/script_class_parser.cpp
+++ b/modules/mono/editor/script_class_parser.cpp
@@ -346,7 +346,7 @@ Error ScriptClassParser::_parse_class_base(Vector<String> &r_base) {
 
 	bool generic = false;
 	if (tk == TK_OP_LESS) {
-		Error err = _skip_generic_type_params();
+		err = _skip_generic_type_params();
 		if (err)
 			return err;
 		// We don't add it to the base list if it's generic
@@ -355,11 +355,11 @@ Error ScriptClassParser::_parse_class_base(Vector<String> &r_base) {
 	}
 
 	if (tk == TK_COMMA) {
-		Error err = _parse_class_base(r_base);
+		err = _parse_class_base(r_base);
 		if (err)
 			return err;
 	} else if (tk == TK_IDENTIFIER && String(value) == "where") {
-		Error err = _parse_type_constraints();
+		err = _parse_type_constraints();
 		if (err) {
 			return err;
 		}
diff --git a/modules/mono/mono_gd/gd_mono_internals.cpp b/modules/mono/mono_gd/gd_mono_internals.cpp
index 14ec24466b..c8cba5cf1b 100644
--- a/modules/mono/mono_gd/gd_mono_internals.cpp
+++ b/modules/mono/mono_gd/gd_mono_internals.cpp
@@ -75,14 +75,14 @@ void tie_managed_to_unmanaged(MonoObject *managed, Object *unmanaged) {
 		script_binding.wrapper_class = klass;
 		script_binding.gchandle = MonoGCHandle::create_strong(managed);
 
-		Reference *ref = Object::cast_to<Reference>(unmanaged);
-		if (ref) {
+		Reference *kref = Object::cast_to<Reference>(unmanaged);
+		if (kref) {
 			// Unsafe refcount increment. The managed instance also counts as a reference.
 			// This way if the unmanaged world has no references to our owner
 			// but the managed instance is alive, the refcount will be 1 instead of 0.
 			// See: godot_icall_Reference_Dtor(MonoObject *p_obj, Object *p_ptr)
 
-			ref->reference();
+			kref->reference();
 		}
 
 		// The object was just created, no script instance binding should have been attached
@@ -96,8 +96,7 @@ void tie_managed_to_unmanaged(MonoObject *managed, Object *unmanaged) {
 		return;
 	}
 
-	Ref<MonoGCHandle> gchandle = ref ? MonoGCHandle::create_weak(managed) :
-									   MonoGCHandle::create_strong(managed);
+	Ref<MonoGCHandle> gchandle = ref ? MonoGCHandle::create_weak(managed) : MonoGCHandle::create_strong(managed);
 
 	Ref<CSharpScript> script = CSharpScript::create_for_managed_type(klass, native);
 
diff --git a/modules/mono/mono_gd/gd_mono_marshal.cpp b/modules/mono/mono_gd/gd_mono_marshal.cpp
index 18a49d0d1f..7fe8ae608a 100644
--- a/modules/mono/mono_gd/gd_mono_marshal.cpp
+++ b/modules/mono/mono_gd/gd_mono_marshal.cpp
@@ -68,39 +68,39 @@ Variant::Type managed_to_variant_type(const ManagedType &p_type) {
 		} break;
 
 		case MONO_TYPE_VALUETYPE: {
-			GDMonoClass *tclass = p_type.type_class;
+			GDMonoClass *vtclass = p_type.type_class;
 
-			if (tclass == CACHED_CLASS(Vector2))
+			if (vtclass == CACHED_CLASS(Vector2))
 				return Variant::VECTOR2;
 
-			if (tclass == CACHED_CLASS(Rect2))
+			if (vtclass == CACHED_CLASS(Rect2))
 				return Variant::RECT2;
 
-			if (tclass == CACHED_CLASS(Transform2D))
+			if (vtclass == CACHED_CLASS(Transform2D))
 				return Variant::TRANSFORM2D;
 
-			if (tclass == CACHED_CLASS(Vector3))
+			if (vtclass == CACHED_CLASS(Vector3))
 				return Variant::VECTOR3;
 
-			if (tclass == CACHED_CLASS(Basis))
+			if (vtclass == CACHED_CLASS(Basis))
 				return Variant::BASIS;
 
-			if (tclass == CACHED_CLASS(Quat))
+			if (vtclass == CACHED_CLASS(Quat))
 				return Variant::QUAT;
 
-			if (tclass == CACHED_CLASS(Transform))
+			if (vtclass == CACHED_CLASS(Transform))
 				return Variant::TRANSFORM;
 
-			if (tclass == CACHED_CLASS(AABB))
+			if (vtclass == CACHED_CLASS(AABB))
 				return Variant::AABB;
 
-			if (tclass == CACHED_CLASS(Color))
+			if (vtclass == CACHED_CLASS(Color))
 				return Variant::COLOR;
 
-			if (tclass == CACHED_CLASS(Plane))
+			if (vtclass == CACHED_CLASS(Plane))
 				return Variant::PLANE;
 
-			if (mono_class_is_enum(tclass->get_mono_ptr()))
+			if (mono_class_is_enum(vtclass->get_mono_ptr()))
 				return Variant::INT;
 		} break;
 
@@ -294,60 +294,60 @@ MonoObject *variant_to_mono_object(const Variant *p_var, const ManagedType &p_ty
 		} break;
 
 		case MONO_TYPE_VALUETYPE: {
-			GDMonoClass *tclass = p_type.type_class;
+			GDMonoClass *vtclass = p_type.type_class;
 
-			if (tclass == CACHED_CLASS(Vector2)) {
+			if (vtclass == CACHED_CLASS(Vector2)) {
 				GDMonoMarshal::M_Vector2 from = MARSHALLED_OUT(Vector2, p_var->operator ::Vector2());
 				return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Vector2), &from);
 			}
 
-			if (tclass == CACHED_CLASS(Rect2)) {
+			if (vtclass == CACHED_CLASS(Rect2)) {
 				GDMonoMarshal::M_Rect2 from = MARSHALLED_OUT(Rect2, p_var->operator ::Rect2());
 				return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Rect2), &from);
 			}
 
-			if (tclass == CACHED_CLASS(Transform2D)) {
+			if (vtclass == CACHED_CLASS(Transform2D)) {
 				GDMonoMarshal::M_Transform2D from = MARSHALLED_OUT(Transform2D, p_var->operator ::Transform2D());
 				return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Transform2D), &from);
 			}
 
-			if (tclass == CACHED_CLASS(Vector3)) {
+			if (vtclass == CACHED_CLASS(Vector3)) {
 				GDMonoMarshal::M_Vector3 from = MARSHALLED_OUT(Vector3, p_var->operator ::Vector3());
 				return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Vector3), &from);
 			}
 
-			if (tclass == CACHED_CLASS(Basis)) {
+			if (vtclass == CACHED_CLASS(Basis)) {
 				GDMonoMarshal::M_Basis from = MARSHALLED_OUT(Basis, p_var->operator ::Basis());
 				return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Basis), &from);
 			}
 
-			if (tclass == CACHED_CLASS(Quat)) {
+			if (vtclass == CACHED_CLASS(Quat)) {
 				GDMonoMarshal::M_Quat from = MARSHALLED_OUT(Quat, p_var->operator ::Quat());
 				return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Quat), &from);
 			}
 
-			if (tclass == CACHED_CLASS(Transform)) {
+			if (vtclass == CACHED_CLASS(Transform)) {
 				GDMonoMarshal::M_Transform from = MARSHALLED_OUT(Transform, p_var->operator ::Transform());
 				return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Transform), &from);
 			}
 
-			if (tclass == CACHED_CLASS(AABB)) {
+			if (vtclass == CACHED_CLASS(AABB)) {
 				GDMonoMarshal::M_AABB from = MARSHALLED_OUT(AABB, p_var->operator ::AABB());
 				return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(AABB), &from);
 			}
 
-			if (tclass == CACHED_CLASS(Color)) {
+			if (vtclass == CACHED_CLASS(Color)) {
 				GDMonoMarshal::M_Color from = MARSHALLED_OUT(Color, p_var->operator ::Color());
 				return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Color), &from);
 			}
 
-			if (tclass == CACHED_CLASS(Plane)) {
+			if (vtclass == CACHED_CLASS(Plane)) {
 				GDMonoMarshal::M_Plane from = MARSHALLED_OUT(Plane, p_var->operator ::Plane());
 				return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Plane), &from);
 			}
 
-			if (mono_class_is_enum(tclass->get_mono_ptr())) {
-				MonoType *enum_basetype = mono_class_enum_basetype(tclass->get_mono_ptr());
+			if (mono_class_is_enum(vtclass->get_mono_ptr())) {
+				MonoType *enum_basetype = mono_class_enum_basetype(vtclass->get_mono_ptr());
 				MonoClass *enum_baseclass = mono_class_from_mono_type(enum_basetype);
 				switch (mono_type_get_type(enum_basetype)) {
 					case MONO_TYPE_BOOLEAN: {
@@ -624,39 +624,39 @@ Variant mono_object_to_variant(MonoObject *p_obj) {
 		} break;
 
 		case MONO_TYPE_VALUETYPE: {
-			GDMonoClass *tclass = type.type_class;
+			GDMonoClass *vtclass = type.type_class;
 
-			if (tclass == CACHED_CLASS(Vector2))
+			if (vtclass == CACHED_CLASS(Vector2))
 				return MARSHALLED_IN(Vector2, (GDMonoMarshal::M_Vector2 *)mono_object_unbox(p_obj));
 
-			if (tclass == CACHED_CLASS(Rect2))
+			if (vtclass == CACHED_CLASS(Rect2))
 				return MARSHALLED_IN(Rect2, (GDMonoMarshal::M_Rect2 *)mono_object_unbox(p_obj));
 
-			if (tclass == CACHED_CLASS(Transform2D))
+			if (vtclass == CACHED_CLASS(Transform2D))
 				return MARSHALLED_IN(Transform2D, (GDMonoMarshal::M_Transform2D *)mono_object_unbox(p_obj));
 
-			if (tclass == CACHED_CLASS(Vector3))
+			if (vtclass == CACHED_CLASS(Vector3))
 				return MARSHALLED_IN(Vector3, (GDMonoMarshal::M_Vector3 *)mono_object_unbox(p_obj));
 
-			if (tclass == CACHED_CLASS(Basis))
+			if (vtclass == CACHED_CLASS(Basis))
 				return MARSHALLED_IN(Basis, (GDMonoMarshal::M_Basis *)mono_object_unbox(p_obj));
 
-			if (tclass == CACHED_CLASS(Quat))
+			if (vtclass == CACHED_CLASS(Quat))
 				return MARSHALLED_IN(Quat, (GDMonoMarshal::M_Quat *)mono_object_unbox(p_obj));
 
-			if (tclass == CACHED_CLASS(Transform))
+			if (vtclass == CACHED_CLASS(Transform))
 				return MARSHALLED_IN(Transform, (GDMonoMarshal::M_Transform *)mono_object_unbox(p_obj));
 
-			if (tclass == CACHED_CLASS(AABB))
+			if (vtclass == CACHED_CLASS(AABB))
 				return MARSHALLED_IN(AABB, (GDMonoMarshal::M_AABB *)mono_object_unbox(p_obj));
 
-			if (tclass == CACHED_CLASS(Color))
+			if (vtclass == CACHED_CLASS(Color))
 				return MARSHALLED_IN(Color, (GDMonoMarshal::M_Color *)mono_object_unbox(p_obj));
 
-			if (tclass == CACHED_CLASS(Plane))
+			if (vtclass == CACHED_CLASS(Plane))
 				return MARSHALLED_IN(Plane, (GDMonoMarshal::M_Plane *)mono_object_unbox(p_obj));
 
-			if (mono_class_is_enum(tclass->get_mono_ptr()))
+			if (mono_class_is_enum(vtclass->get_mono_ptr()))
 				return unbox<int32_t>(p_obj);
 		} break;
 
@@ -740,7 +740,7 @@ Variant mono_object_to_variant(MonoObject *p_obj) {
 			UNLIKELY_UNHANDLED_EXCEPTION(exc);
 
 			if (is_dict) {
-				MonoException *exc = NULL;
+				exc = NULL;
 				MonoObject *ret = type.type_class->get_method("GetPtr")->invoke(p_obj, &exc);
 				UNLIKELY_UNHANDLED_EXCEPTION(exc);
 				return *unbox<Dictionary *>(ret);
@@ -753,7 +753,7 @@ Variant mono_object_to_variant(MonoObject *p_obj) {
 			UNLIKELY_UNHANDLED_EXCEPTION(exc);
 
 			if (is_array) {
-				MonoException *exc = NULL;
+				exc = NULL;
 				MonoObject *ret = type.type_class->get_method("GetPtr")->invoke(p_obj, &exc);
 				UNLIKELY_UNHANDLED_EXCEPTION(exc);
 				return *unbox<Array *>(ret);
diff --git a/modules/recast/navigation_mesh_generator.cpp b/modules/recast/navigation_mesh_generator.cpp
index 29f5e4c363..80e98a13a5 100644
--- a/modules/recast/navigation_mesh_generator.cpp
+++ b/modules/recast/navigation_mesh_generator.cpp
@@ -66,26 +66,26 @@ void NavigationMeshGenerator::_add_mesh(const Ref<Mesh> &p_mesh, const Transform
 			PoolVector<int> mesh_indices = a[Mesh::ARRAY_INDEX];
 			PoolVector<int>::Read ir = mesh_indices.read();
 
-			for (int i = 0; i < mesh_vertices.size(); i++) {
-				_add_vertex(p_xform.xform(vr[i]), p_verticies);
+			for (int j = 0; j < mesh_vertices.size(); j++) {
+				_add_vertex(p_xform.xform(vr[j]), p_verticies);
 			}
 
-			for (int i = 0; i < face_count; i++) {
+			for (int j = 0; j < face_count; j++) {
 				// CCW
-				p_indices.push_back(current_vertex_count + (ir[i * 3 + 0]));
-				p_indices.push_back(current_vertex_count + (ir[i * 3 + 2]));
-				p_indices.push_back(current_vertex_count + (ir[i * 3 + 1]));
+				p_indices.push_back(current_vertex_count + (ir[j * 3 + 0]));
+				p_indices.push_back(current_vertex_count + (ir[j * 3 + 2]));
+				p_indices.push_back(current_vertex_count + (ir[j * 3 + 1]));
 			}
 		} else {
 			face_count = mesh_vertices.size() / 3;
-			for (int i = 0; i < face_count; i++) {
-				_add_vertex(p_xform.xform(vr[i * 3 + 0]), p_verticies);
-				_add_vertex(p_xform.xform(vr[i * 3 + 2]), p_verticies);
-				_add_vertex(p_xform.xform(vr[i * 3 + 1]), p_verticies);
-
-				p_indices.push_back(current_vertex_count + (i * 3 + 0));
-				p_indices.push_back(current_vertex_count + (i * 3 + 1));
-				p_indices.push_back(current_vertex_count + (i * 3 + 2));
+			for (int j = 0; j < face_count; j++) {
+				_add_vertex(p_xform.xform(vr[j * 3 + 0]), p_verticies);
+				_add_vertex(p_xform.xform(vr[j * 3 + 2]), p_verticies);
+				_add_vertex(p_xform.xform(vr[j * 3 + 1]), p_verticies);
+
+				p_indices.push_back(current_vertex_count + (j * 3 + 0));
+				p_indices.push_back(current_vertex_count + (j * 3 + 1));
+				p_indices.push_back(current_vertex_count + (j * 3 + 2));
 			}
 		}
 	}
diff --git a/modules/theora/video_stream_theora.cpp b/modules/theora/video_stream_theora.cpp
index 31723c5c76..14c5ddd7f2 100644
--- a/modules/theora/video_stream_theora.cpp
+++ b/modules/theora/video_stream_theora.cpp
@@ -296,8 +296,8 @@ void VideoStreamPlaybackTheora::set_file(const String &p_file) {
 		if (ogg_sync_pageout(&oy, &og) > 0) {
 			queue_page(&og); /* demux into the appropriate stream */
 		} else {
-			int ret = buffer_data(); /* someone needs more data */
-			if (ret == 0) {
+			int ret2 = buffer_data(); /* someone needs more data */
+			if (ret2 == 0) {
 				fprintf(stderr, "End of file while searching for codec headers.\n");
 				clear();
 				return;
diff --git a/modules/visual_script/visual_script.cpp b/modules/visual_script/visual_script.cpp
index 0027300e9f..2c89e5a35c 100644
--- a/modules/visual_script/visual_script.cpp
+++ b/modules/visual_script/visual_script.cpp
@@ -1165,9 +1165,9 @@ void VisualScript::_set_data(const Dictionary &p_data) {
 
 		Array nodes = func["nodes"];
 
-		for (int i = 0; i < nodes.size(); i += 3) {
+		for (int j = 0; j < nodes.size(); j += 3) {
 
-			add_node(name, nodes[i], nodes[i + 2], nodes[i + 1]);
+			add_node(name, nodes[j], nodes[j + 2], nodes[j + 1]);
 		}
 
 		Array sequence_connections = func["sequence_connections"];
diff --git a/modules/visual_script/visual_script_expression.cpp b/modules/visual_script/visual_script_expression.cpp
index 23942fdd2a..a76e4bc36f 100644
--- a/modules/visual_script/visual_script_expression.cpp
+++ b/modules/visual_script/visual_script_expression.cpp
@@ -679,10 +679,10 @@ VisualScriptExpression::ENode *VisualScriptExpression::_parse_expression() {
 					}
 					str_ofs = cofs; //revert
 					//parse an expression
-					ENode *expr = _parse_expression();
-					if (!expr)
+					ENode *expr2 = _parse_expression();
+					if (!expr2)
 						return NULL;
-					dn->dict.push_back(expr);
+					dn->dict.push_back(expr2);
 
 					_get_token(tk);
 					if (tk.type != TK_COLON) {
@@ -690,11 +690,11 @@ VisualScriptExpression::ENode *VisualScriptExpression::_parse_expression() {
 						return NULL;
 					}
 
-					expr = _parse_expression();
-					if (!expr)
+					expr2 = _parse_expression();
+					if (!expr2)
 						return NULL;
 
-					dn->dict.push_back(expr);
+					dn->dict.push_back(expr2);
 
 					cofs = str_ofs;
 					_get_token(tk);
@@ -723,10 +723,10 @@ VisualScriptExpression::ENode *VisualScriptExpression::_parse_expression() {
 					}
 					str_ofs = cofs; //revert
 					//parse an expression
-					ENode *expr = _parse_expression();
-					if (!expr)
+					ENode *expr2 = _parse_expression();
+					if (!expr2)
 						return NULL;
-					an->array.push_back(expr);
+					an->array.push_back(expr2);
 
 					cofs = str_ofs;
 					_get_token(tk);
@@ -807,11 +807,11 @@ VisualScriptExpression::ENode *VisualScriptExpression::_parse_expression() {
 					}
 					str_ofs = cofs; //revert
 					//parse an expression
-					ENode *expr = _parse_expression();
-					if (!expr)
+					ENode *expr2 = _parse_expression();
+					if (!expr2)
 						return NULL;
 
-					constructor->arguments.push_back(expr);
+					constructor->arguments.push_back(expr2);
 
 					cofs = str_ofs;
 					_get_token(tk);
@@ -848,11 +848,11 @@ VisualScriptExpression::ENode *VisualScriptExpression::_parse_expression() {
 					}
 					str_ofs = cofs; //revert
 					//parse an expression
-					ENode *expr = _parse_expression();
-					if (!expr)
+					ENode *expr2 = _parse_expression();
+					if (!expr2)
 						return NULL;
 
-					bifunc->arguments.push_back(expr);
+					bifunc->arguments.push_back(expr2);
 
 					cofs = str_ofs;
 					_get_token(tk);
@@ -947,25 +947,25 @@ VisualScriptExpression::ENode *VisualScriptExpression::_parse_expression() {
 
 						while (true) {
 
-							int cofs = str_ofs;
+							int cofs3 = str_ofs;
 							_get_token(tk);
 							if (tk.type == TK_PARENTHESIS_CLOSE) {
 								break;
 							}
-							str_ofs = cofs; //revert
+							str_ofs = cofs3; //revert
 							//parse an expression
-							ENode *expr = _parse_expression();
-							if (!expr)
+							ENode *expr2 = _parse_expression();
+							if (!expr2)
 								return NULL;
 
-							func_call->arguments.push_back(expr);
+							func_call->arguments.push_back(expr2);
 
-							cofs = str_ofs;
+							cofs3 = str_ofs;
 							_get_token(tk);
 							if (tk.type == TK_COMMA) {
 								//all good
 							} else if (tk.type == TK_PARENTHESIS_CLOSE) {
-								str_ofs = cofs;
+								str_ofs = cofs3;
 							} else {
 								_set_error("Expected ',' or ')'");
 							}
@@ -1426,8 +1426,8 @@ public:
 				for (int i = 0; i < call->arguments.size(); i++) {
 
 					Variant value;
-					bool ret = _execute(p_inputs, call->arguments[i], value, r_error_str, ce);
-					if (ret)
+					bool ret2 = _execute(p_inputs, call->arguments[i], value, r_error_str, ce);
+					if (ret2)
 						return true;
 					arr.write[i] = value;
 					argp.write[i] = &arr[i];
diff --git a/modules/visual_script/visual_script_property_selector.cpp b/modules/visual_script/visual_script_property_selector.cpp
index 9dc0e4edfa..fa7b13bf5b 100644
--- a/modules/visual_script/visual_script_property_selector.cpp
+++ b/modules/visual_script/visual_script_property_selector.cpp
@@ -514,26 +514,26 @@ void VisualScriptPropertySelector::_item_selected() {
 	if (names->find(name) != NULL) {
 		Ref<VisualScriptOperator> operator_node = VisualScriptLanguage::singleton->create_node_from_name(name);
 		if (operator_node.is_valid()) {
-			Map<String, DocData::ClassDoc>::Element *E = dd->class_list.find(operator_node->get_class_name());
-			if (E) {
+			Map<String, DocData::ClassDoc>::Element *F = dd->class_list.find(operator_node->get_class_name());
+			if (F) {
 				text = Variant::get_operator_name(operator_node->get_operator());
 			}
 		}
 		Ref<VisualScriptTypeCast> typecast_node = VisualScriptLanguage::singleton->create_node_from_name(name);
 		if (typecast_node.is_valid()) {
-			Map<String, DocData::ClassDoc>::Element *E = dd->class_list.find(typecast_node->get_class_name());
-			if (E) {
-				text = E->get().description;
+			Map<String, DocData::ClassDoc>::Element *F = dd->class_list.find(typecast_node->get_class_name());
+			if (F) {
+				text = F->get().description;
 			}
 		}
 
 		Ref<VisualScriptBuiltinFunc> builtin_node = VisualScriptLanguage::singleton->create_node_from_name(name);
 		if (builtin_node.is_valid()) {
-			Map<String, DocData::ClassDoc>::Element *E = dd->class_list.find(builtin_node->get_class_name());
-			if (E) {
-				for (int i = 0; i < E->get().constants.size(); i++) {
-					if (E->get().constants[i].value.to_int() == int(builtin_node->get_func())) {
-						text = E->get().constants[i].description;
+			Map<String, DocData::ClassDoc>::Element *F = dd->class_list.find(builtin_node->get_class_name());
+			if (F) {
+				for (int i = 0; i < F->get().constants.size(); i++) {
+					if (F->get().constants[i].value.to_int() == int(builtin_node->get_func())) {
+						text = F->get().constants[i].description;
 					}
 				}
 			}
diff --git a/modules/websocket/lws_client.cpp b/modules/websocket/lws_client.cpp
index 2fbb46f3e2..2dce0ed1f5 100644
--- a/modules/websocket/lws_client.cpp
+++ b/modules/websocket/lws_client.cpp
@@ -144,9 +144,9 @@ int LWSClient::_handle_cb(struct lws *wsi, enum lws_callback_reasons reason, voi
 
 		case LWS_CALLBACK_WS_PEER_INITIATED_CLOSE: {
 			int code;
-			String reason = peer->get_close_reason(in, len, code);
+			String reason2 = peer->get_close_reason(in, len, code);
 			peer_data->clean_close = true;
-			_on_close_request(code, reason);
+			_on_close_request(code, reason2);
 			return 0;
 		}
 
diff --git a/modules/websocket/lws_server.cpp b/modules/websocket/lws_server.cpp
index fe7da99a9f..61ccdca74a 100644
--- a/modules/websocket/lws_server.cpp
+++ b/modules/websocket/lws_server.cpp
@@ -109,9 +109,9 @@ int LWSServer::_handle_cb(struct lws *wsi, enum lws_callback_reasons reason, voi
 			if (_peer_map.has(id)) {
 				int code;
 				Ref<LWSPeer> peer = _peer_map[id];
-				String reason = peer->get_close_reason(in, len, code);
+				String reason2 = peer->get_close_reason(in, len, code);
 				peer_data->clean_close = true;
-				_on_close_request(id, code, reason);
+				_on_close_request(id, code, reason2);
 			}
 			return 0;
 		}