From 0ee0fa42e6639b6fa474b7cf6afc6b1a78142185 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9mi=20Verschelde?= <rverschelde@gmail.com>
Date: Thu, 14 May 2020 16:41:43 +0200
Subject: Style: Enforce braces around if blocks and loops

Using clang-tidy's `readability-braces-around-statements`.
https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
---
 modules/gdscript/editor/gdscript_highlighter.cpp   |   3 +-
 modules/gdscript/gdscript.cpp                      | 163 ++++++++----
 modules/gdscript/gdscript.h                        |  21 +-
 modules/gdscript/gdscript_compiler.cpp             | 293 ++++++++++++++-------
 modules/gdscript/gdscript_compiler.h               |   9 +-
 modules/gdscript/gdscript_editor.cpp               |  51 ++--
 modules/gdscript/gdscript_function.cpp             |  55 ++--
 modules/gdscript/gdscript_function.h               |   3 +-
 modules/gdscript/gdscript_functions.cpp            |  14 +-
 modules/gdscript/gdscript_parser.cpp               | 273 ++++++++++++-------
 modules/gdscript/gdscript_parser.h                 |   6 +-
 modules/gdscript/gdscript_tokenizer.cpp            |  51 ++--
 .../language_server/gdscript_extend_parser.cpp     |  12 +-
 .../language_server/gdscript_language_protocol.cpp |  10 +-
 .../language_server/gdscript_workspace.cpp         |   9 +-
 modules/gdscript/language_server/lsp.hpp           |  33 ++-
 modules/gdscript/register_types.cpp                |  19 +-
 17 files changed, 673 insertions(+), 352 deletions(-)

(limited to 'modules/gdscript')

diff --git a/modules/gdscript/editor/gdscript_highlighter.cpp b/modules/gdscript/editor/gdscript_highlighter.cpp
index c3091a56a6..d0f27b632b 100644
--- a/modules/gdscript/editor/gdscript_highlighter.cpp
+++ b/modules/gdscript/editor/gdscript_highlighter.cpp
@@ -178,8 +178,9 @@ Map<int, TextEdit::HighlighterInfo> GDScriptSyntaxHighlighter::_get_line_syntax_
 
 		if (in_region == -1 && !in_keyword && is_char && !prev_is_char) {
 			int to = j;
-			while (to < str.length() && _is_text_char(str[to]))
+			while (to < str.length() && _is_text_char(str[to])) {
 				to++;
+			}
 
 			String word = str.substr(j, to - j);
 			Color col = Color();
diff --git a/modules/gdscript/gdscript.cpp b/modules/gdscript/gdscript.cpp
index 1d26e2148e..632407c61f 100644
--- a/modules/gdscript/gdscript.cpp
+++ b/modules/gdscript/gdscript.cpp
@@ -180,10 +180,12 @@ Ref<Script> GDScript::get_base_script() const {
 }
 
 StringName GDScript::get_instance_base_type() const {
-	if (native.is_valid())
+	if (native.is_valid()) {
 		return native->get_name();
-	if (base.is_valid() && base->is_valid())
+	}
+	if (base.is_valid() && base->is_valid()) {
 		return base->get_instance_base_type();
+	}
 	return StringName();
 }
 
@@ -253,8 +255,9 @@ bool GDScript::has_method(const StringName &p_method) const {
 
 MethodInfo GDScript::get_method_info(const StringName &p_method) const {
 	const Map<StringName, GDScriptFunction *>::Element *E = member_functions.find(p_method);
-	if (!E)
+	if (!E) {
 		return MethodInfo();
+	}
 
 	GDScriptFunction *func = E->get();
 	MethodInfo mi;
@@ -285,8 +288,9 @@ bool GDScript::get_property_default_value(const StringName &p_property, Variant
 
 ScriptInstance *GDScript::instance_create(Object *p_this) {
 	GDScript *top = this;
-	while (top->_base)
+	while (top->_base) {
 		top = top->_base;
+	}
 
 	if (top->native.is_valid()) {
 		if (!ClassDB::is_parent_class(p_this->get_class_name(), top->native->get_name())) {
@@ -327,8 +331,9 @@ String GDScript::get_source_code() const {
 }
 
 void GDScript::set_source_code(const String &p_code) {
-	if (source == p_code)
+	if (source == p_code) {
 		return;
+	}
 	source = p_code;
 #ifdef TOOLS_ENABLED
 	source_changed_cache = true;
@@ -355,8 +360,9 @@ bool GDScript::_update_exports(bool *r_err, bool p_recursive_call) {
 #ifdef TOOLS_ENABLED
 
 	static Vector<GDScript *> base_caches;
-	if (!p_recursive_call)
+	if (!p_recursive_call) {
 		base_caches.clear();
+	}
 	base_caches.append(this);
 
 	bool changed = false;
@@ -367,11 +373,13 @@ bool GDScript::_update_exports(bool *r_err, bool p_recursive_call) {
 
 		String basedir = path;
 
-		if (basedir == "")
+		if (basedir == "") {
 			basedir = get_path();
+		}
 
-		if (basedir != "")
+		if (basedir != "") {
 			basedir = basedir.get_base_dir();
+		}
 
 		GDScriptParser parser;
 		Error err = parser.parse(source, basedir, true, path);
@@ -402,8 +410,9 @@ bool GDScript::_update_exports(bool *r_err, bool p_recursive_call) {
 				} else if (c->extends_class.size() != 0) {
 					String base = c->extends_class[0];
 
-					if (ScriptServer::is_global_class(base))
+					if (ScriptServer::is_global_class(base)) {
 						path = ScriptServer::get_global_class_path(base);
+					}
 				}
 
 				if (path != "") {
@@ -424,8 +433,9 @@ bool GDScript::_update_exports(bool *r_err, bool p_recursive_call) {
 			member_default_values_cache.clear();
 
 			for (int i = 0; i < c->variables.size(); i++) {
-				if (c->variables[i]._export.type == Variant::NIL)
+				if (c->variables[i]._export.type == Variant::NIL) {
 					continue;
+				}
 
 				members_cache.push_back(c->variables[i]._export);
 				member_default_values_cache[c->variables[i].identifier] = c->variables[i].default_value;
@@ -449,8 +459,9 @@ bool GDScript::_update_exports(bool *r_err, bool p_recursive_call) {
 	if (base_cache.is_valid() && base_cache->is_valid()) {
 		for (int i = 0; i < base_caches.size(); i++) {
 			if (base_caches[i] == base_cache.ptr()) {
-				if (r_err)
+				if (r_err) {
 					*r_err = true;
+				}
 				valid = false; // to show error in the editor
 				base_cache->valid = false;
 				base_cache->inheriters_cache.clear(); // to prevent future stackoverflows
@@ -461,8 +472,9 @@ bool GDScript::_update_exports(bool *r_err, bool p_recursive_call) {
 			}
 		}
 		if (base_cache->_update_exports(r_err, true)) {
-			if (r_err && *r_err)
+			if (r_err && *r_err) {
 				return false;
+			}
 			changed = true;
 		}
 	}
@@ -491,16 +503,18 @@ void GDScript::update_exports() {
 
 	bool cyclic_error = false;
 	_update_exports(&cyclic_error);
-	if (cyclic_error)
+	if (cyclic_error) {
 		return;
+	}
 
 	Set<ObjectID> copy = inheriters_cache; //might get modified
 
 	for (Set<ObjectID>::Element *E = copy.front(); E; E = E->next()) {
 		Object *id = ObjectDB::get_instance(E->get());
 		GDScript *s = Object::cast_to<GDScript>(id);
-		if (!s)
+		if (!s) {
 			continue;
+		}
 		s->update_exports();
 	}
 
@@ -526,11 +540,13 @@ Error GDScript::reload(bool p_keep_state) {
 
 	String basedir = path;
 
-	if (basedir == "")
+	if (basedir == "") {
 		basedir = get_path();
+	}
 
-	if (basedir != "")
+	if (basedir != "") {
 		basedir = basedir.get_base_dir();
+	}
 
 	if (source.find("%BASE%") != -1) {
 		//loading a template, don't parse
@@ -619,14 +635,16 @@ uint16_t GDScript::get_rpc_method_id(const StringName &p_method) const {
 }
 
 StringName GDScript::get_rpc_method(const uint16_t p_rpc_method_id) const {
-	if (p_rpc_method_id >= rpc_functions.size())
+	if (p_rpc_method_id >= rpc_functions.size()) {
 		return StringName();
+	}
 	return rpc_functions[p_rpc_method_id].name;
 }
 
 MultiplayerAPI::RPCMode GDScript::get_rpc_mode_by_id(const uint16_t p_rpc_method_id) const {
-	if (p_rpc_method_id >= rpc_functions.size())
+	if (p_rpc_method_id >= rpc_functions.size()) {
 		return MultiplayerAPI::RPC_MODE_DISABLED;
+	}
 	return rpc_functions[p_rpc_method_id].mode;
 }
 
@@ -648,14 +666,16 @@ uint16_t GDScript::get_rset_property_id(const StringName &p_variable) const {
 }
 
 StringName GDScript::get_rset_property(const uint16_t p_rset_member_id) const {
-	if (p_rset_member_id >= rpc_variables.size())
+	if (p_rset_member_id >= rpc_variables.size()) {
 		return StringName();
+	}
 	return rpc_variables[p_rset_member_id].name;
 }
 
 MultiplayerAPI::RPCMode GDScript::get_rset_mode_by_id(const uint16_t p_rset_member_id) const {
-	if (p_rset_member_id >= rpc_variables.size())
+	if (p_rset_member_id >= rpc_variables.size()) {
 		return MultiplayerAPI::RPC_MODE_DISABLED;
+	}
 	return rpc_variables[p_rset_member_id].mode;
 }
 
@@ -715,8 +735,9 @@ bool GDScript::_set(const StringName &p_name, const Variant &p_value) {
 	if (p_name == GDScriptLanguage::get_singleton()->strings._script_source) {
 		set_source_code(p_value);
 		reload();
-	} else
+	} else {
 		return false;
+	}
 
 	return true;
 }
@@ -776,11 +797,13 @@ Error GDScript::load_byte_code(const String &p_path) {
 
 	String basedir = path;
 
-	if (basedir == "")
+	if (basedir == "") {
 		basedir = get_path();
+	}
 
-	if (basedir != "")
+	if (basedir != "") {
 		basedir = basedir.get_base_dir();
+	}
 
 	valid = false;
 	GDScriptParser parser;
@@ -845,8 +868,9 @@ const Map<StringName, GDScriptFunction *> &GDScript::debug_get_member_functions(
 
 StringName GDScript::debug_get_member_by_index(int p_idx) const {
 	for (const Map<StringName, MemberInfo>::Element *E = member_indices.front(); E; E = E->next()) {
-		if (E->get().index == p_idx)
+		if (E->get().index == p_idx) {
 			return E->key();
+		}
 	}
 
 	return "<error>";
@@ -875,8 +899,9 @@ bool GDScript::inherits_script(const Ref<Script> &p_script) const {
 }
 
 bool GDScript::has_script_signal(const StringName &p_signal) const {
-	if (_signals.has(p_signal))
+	if (_signals.has(p_signal)) {
 		return true;
+	}
 	if (base.is_valid()) {
 		return base->has_script_signal(p_signal);
 	}
@@ -957,8 +982,9 @@ void GDScript::_save_orphaned_subclasses() {
 	for (int i = 0; i < weak_subclasses.size(); i++) {
 		ClassRefWithName subclass = weak_subclasses[i];
 		Object *obj = ObjectDB::get_instance(subclass.id);
-		if (!obj)
+		if (!obj) {
 			continue;
+		}
 		// subclass is not released
 		GDScriptLanguage::get_singleton()->add_orphan_subclass(subclass.fully_qualified_name, subclass.id);
 	}
@@ -999,13 +1025,15 @@ void GDScript::_init_rpc_methods_properties() {
 			}
 		}
 
-		if (cscript != this)
+		if (cscript != this) {
 			sub_E = sub_E->next();
+		}
 
-		if (sub_E)
+		if (sub_E) {
 			cscript = sub_E->get().ptr();
-		else
+		} else {
 			cscript = nullptr;
+		}
 	}
 
 	// Sort so we are 100% that they are always the same.
@@ -1084,8 +1112,9 @@ bool GDScriptInstance::set(const StringName &p_name, const Variant &p_value) {
 
 			Callable::CallError err;
 			Variant ret = E->get()->call(this, (const Variant **)args, 2, err);
-			if (err.error == Callable::CallError::CALL_OK && ret.get_type() == Variant::BOOL && ret.operator bool())
+			if (err.error == Callable::CallError::CALL_OK && ret.get_type() == Variant::BOOL && ret.operator bool()) {
 				return true;
+			}
 		}
 		sptr = sptr->_base;
 	}
@@ -1147,15 +1176,17 @@ Variant::Type GDScriptInstance::get_property_type(const StringName &p_name, bool
 	const GDScript *sptr = script.ptr();
 	while (sptr) {
 		if (sptr->member_info.has(p_name)) {
-			if (r_is_valid)
+			if (r_is_valid) {
 				*r_is_valid = true;
+			}
 			return sptr->member_info[p_name].type;
 		}
 		sptr = sptr->_base;
 	}
 
-	if (r_is_valid)
+	if (r_is_valid) {
 		*r_is_valid = false;
+	}
 	return Variant::NIL;
 }
 
@@ -1183,12 +1214,15 @@ void GDScriptInstance::get_property_list(List<PropertyInfo> *p_properties) const
 					ERR_CONTINUE(pinfo.type < 0 || pinfo.type >= Variant::VARIANT_MAX);
 					pinfo.name = d["name"];
 					ERR_CONTINUE(pinfo.name == "");
-					if (d.has("hint"))
+					if (d.has("hint")) {
 						pinfo.hint = PropertyHint(d["hint"].operator int());
-					if (d.has("hint_string"))
+					}
+					if (d.has("hint_string")) {
 						pinfo.hint_string = d["hint_string"];
-					if (d.has("usage"))
+					}
+					if (d.has("usage")) {
 						pinfo.usage = d["usage"];
+					}
 
 					props.push_back(pinfo);
 				}
@@ -1227,8 +1261,9 @@ void GDScriptInstance::get_method_list(List<MethodInfo> *p_list) const {
 			MethodInfo mi;
 			mi.name = E->key();
 			mi.flags |= METHOD_FLAG_FROM_SCRIPT;
-			for (int i = 0; i < E->get()->get_argument_count(); i++)
+			for (int i = 0; i < E->get()->get_argument_count(); i++) {
 				mi.arguments.push_back(PropertyInfo(Variant::NIL, "arg" + itos(i)));
+			}
 			p_list->push_back(mi);
 		}
 		sptr = sptr->_base;
@@ -1239,8 +1274,9 @@ bool GDScriptInstance::has_method(const StringName &p_method) const {
 	const GDScript *sptr = script.ptr();
 	while (sptr) {
 		const Map<StringName, GDScriptFunction *>::Element *E = sptr->member_functions.find(p_method);
-		if (E)
+		if (E) {
 			return true;
+		}
 		sptr = sptr->_base;
 	}
 
@@ -1274,8 +1310,9 @@ void GDScriptInstance::call_multilevel(const StringName &p_method, const Variant
 }
 
 void GDScriptInstance::_ml_call_reversed(GDScript *sptr, const StringName &p_method, const Variant **p_args, int p_argcount) {
-	if (sptr->_base)
+	if (sptr->_base) {
 		_ml_call_reversed(sptr->_base, p_method, p_args, p_argcount);
+	}
 
 	Callable::CallError ce;
 
@@ -1316,17 +1353,20 @@ String GDScriptInstance::to_string(bool *r_valid) {
 		Variant ret = call(CoreStringNames::get_singleton()->_to_string, nullptr, 0, ce);
 		if (ce.error == Callable::CallError::CALL_OK) {
 			if (ret.get_type() != Variant::STRING) {
-				if (r_valid)
+				if (r_valid) {
 					*r_valid = false;
+				}
 				ERR_FAIL_V_MSG(String(), "Wrong type for " + CoreStringNames::get_singleton()->_to_string + ", must be a String.");
 			}
-			if (r_valid)
+			if (r_valid) {
 				*r_valid = true;
+			}
 			return ret.operator String();
 		}
 	}
-	if (r_valid)
+	if (r_valid) {
 		*r_valid = false;
+	}
 	return String();
 }
 
@@ -1477,11 +1517,13 @@ void GDScriptLanguage::init() {
 	for (List<StringName>::Element *E = class_list.front(); E; E = E->next()) {
 		StringName n = E->get();
 		String s = String(n);
-		if (s.begins_with("_"))
+		if (s.begins_with("_")) {
 			n = s.substr(1, s.length());
+		}
 
-		if (globals.has(n))
+		if (globals.has(n)) {
 			continue;
+		}
 		Ref<GDScriptNativeClass> nc = memnew(GDScriptNativeClass(E->get()));
 		_add_global(n, nc);
 	}
@@ -1549,8 +1591,9 @@ int GDScriptLanguage::profiling_get_accumulated_data(ProfilingInfo *p_info_arr,
 
 	SelfList<GDScriptFunction> *elem = function_list.first();
 	while (elem) {
-		if (current >= p_info_max)
+		if (current >= p_info_max) {
 			break;
+		}
 		p_info_arr[current].call_count = elem->self()->profile.call_count;
 		p_info_arr[current].self_time = elem->self()->profile.self_time;
 		p_info_arr[current].total_time = elem->self()->profile.total_time;
@@ -1571,8 +1614,9 @@ int GDScriptLanguage::profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_
 
 	SelfList<GDScriptFunction> *elem = function_list.first();
 	while (elem) {
-		if (current >= p_info_max)
+		if (current >= p_info_max) {
 			break;
+		}
 		if (elem->self()->profile.last_frame_call_count > 0) {
 			p_info_arr[current].call_count = elem->self()->profile.last_frame_call_count;
 			p_info_arr[current].self_time = elem->self()->profile.last_frame_self_time;
@@ -1590,8 +1634,9 @@ int GDScriptLanguage::profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_
 struct GDScriptDepSort {
 	//must support sorting so inheritance works properly (parent must be reloaded first)
 	bool operator()(const Ref<GDScript> &A, const Ref<GDScript> &B) const {
-		if (A == B)
+		if (A == B) {
 			return false; //shouldn't happen but..
+		}
 		const GDScript *I = B->get_base().ptr();
 		while (I) {
 			if (I == A.ptr()) {
@@ -1662,8 +1707,9 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so
 	for (List<Ref<GDScript>>::Element *E = scripts.front(); E; E = E->next()) {
 		bool reload = E->get() == p_script || to_reload.has(E->get()->get_base());
 
-		if (!reload)
+		if (!reload) {
 			continue;
+		}
 
 		to_reload.insert(E->get(), Map<ObjectID, List<Pair<StringName, Variant>>>());
 
@@ -1717,8 +1763,9 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so
 			List<Pair<StringName, Variant>> &saved_state = F->get();
 
 			Object *obj = ObjectDB::get_instance(F->key());
-			if (!obj)
+			if (!obj) {
 				continue;
+			}
 
 			if (!p_soft_reload) {
 				//clear it just in case (may be a pending reload state)
@@ -1872,10 +1919,11 @@ String GDScriptLanguage::get_global_class_name(const String &p_path, String *r_b
 	if (parser.get_parse_tree() && parser.get_parse_tree()->type == GDScriptParser::Node::TYPE_CLASS) {
 		const GDScriptParser::ClassNode *c = static_cast<const GDScriptParser::ClassNode *>(parser.get_parse_tree());
 		if (r_icon_path) {
-			if (c->icon_path.empty() || c->icon_path.is_abs_path())
+			if (c->icon_path.empty() || c->icon_path.is_abs_path()) {
 				*r_icon_path = c->icon_path;
-			else if (c->icon_path.is_rel_path())
+			} else if (c->icon_path.is_rel_path()) {
 				*r_icon_path = p_path.get_base_dir().plus_file(c->icon_path).simplify_path();
+			}
 		}
 		if (r_base_type) {
 			const GDScriptParser::ClassNode *subclass = c;
@@ -2175,21 +2223,24 @@ void GDScriptLanguage::add_orphan_subclass(const String &p_qualified_name, const
 
 Ref<GDScript> GDScriptLanguage::get_orphan_subclass(const String &p_qualified_name) {
 	Map<String, ObjectID>::Element *orphan_subclass_element = orphan_subclasses.find(p_qualified_name);
-	if (!orphan_subclass_element)
+	if (!orphan_subclass_element) {
 		return Ref<GDScript>();
+	}
 	ObjectID orphan_subclass = orphan_subclass_element->get();
 	Object *obj = ObjectDB::get_instance(orphan_subclass);
 	orphan_subclasses.erase(orphan_subclass_element);
-	if (!obj)
+	if (!obj) {
 		return Ref<GDScript>();
+	}
 	return Ref<GDScript>(Object::cast_to<GDScript>(obj));
 }
 
 /*************** RESOURCE ***************/
 
 RES ResourceFormatLoaderGDScript::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, bool p_no_cache) {
-	if (r_error)
+	if (r_error) {
 		*r_error = ERR_FILE_CANT_OPEN;
+	}
 
 	GDScript *script = memnew(GDScript);
 
@@ -2210,8 +2261,9 @@ RES ResourceFormatLoaderGDScript::load(const String &p_path, const String &p_ori
 
 		script->reload();
 	}
-	if (r_error)
+	if (r_error) {
 		*r_error = OK;
+	}
 
 	return scriptres;
 }
@@ -2228,8 +2280,9 @@ bool ResourceFormatLoaderGDScript::handles_type(const String &p_type) const {
 
 String ResourceFormatLoaderGDScript::get_resource_type(const String &p_path) const {
 	String el = p_path.get_extension().to_lower();
-	if (el == "gd" || el == "gdc" || el == "gde")
+	if (el == "gd" || el == "gdc" || el == "gde") {
 		return "GDScript";
+	}
 	return "";
 }
 
diff --git a/modules/gdscript/gdscript.h b/modules/gdscript/gdscript.h
index ecaa2257ca..e770dc3abd 100644
--- a/modules/gdscript/gdscript.h
+++ b/modules/gdscript/gdscript.h
@@ -209,11 +209,11 @@ public:
 
 	virtual int get_member_line(const StringName &p_member) const {
 #ifdef TOOLS_ENABLED
-		if (member_lines.has(p_member))
+		if (member_lines.has(p_member)) {
 			return member_lines[p_member];
-		else
+		}
 #endif
-			return -1;
+		return -1;
 	}
 
 	virtual void get_constants(Map<StringName, Variant> *p_constants);
@@ -396,11 +396,13 @@ public:
 	bool debug_break_parse(const String &p_file, int p_line, const String &p_error);
 
 	_FORCE_INLINE_ void enter_function(GDScriptInstance *p_instance, GDScriptFunction *p_function, Variant *p_stack, int *p_ip, int *p_line) {
-		if (Thread::get_main_id() != Thread::get_caller_id())
+		if (Thread::get_main_id() != Thread::get_caller_id()) {
 			return; //no support for other threads than main for now
+		}
 
-		if (EngineDebugger::get_script_debugger()->get_lines_left() > 0 && EngineDebugger::get_script_debugger()->get_depth() >= 0)
+		if (EngineDebugger::get_script_debugger()->get_lines_left() > 0 && EngineDebugger::get_script_debugger()->get_depth() >= 0) {
 			EngineDebugger::get_script_debugger()->set_depth(EngineDebugger::get_script_debugger()->get_depth() + 1);
+		}
 
 		if (_debug_call_stack_pos >= _debug_max_call_stack) {
 			//stack overflow
@@ -418,11 +420,13 @@ public:
 	}
 
 	_FORCE_INLINE_ void exit_function() {
-		if (Thread::get_main_id() != Thread::get_caller_id())
+		if (Thread::get_main_id() != Thread::get_caller_id()) {
 			return; //no support for other threads than main for now
+		}
 
-		if (EngineDebugger::get_script_debugger()->get_lines_left() > 0 && EngineDebugger::get_script_debugger()->get_depth() >= 0)
+		if (EngineDebugger::get_script_debugger()->get_lines_left() > 0 && EngineDebugger::get_script_debugger()->get_depth() >= 0) {
 			EngineDebugger::get_script_debugger()->set_depth(EngineDebugger::get_script_debugger()->get_depth() - 1);
+		}
 
 		if (_debug_call_stack_pos == 0) {
 			_debug_error = "Stack Underflow (Engine Bug)";
@@ -434,8 +438,9 @@ public:
 	}
 
 	virtual Vector<StackInfo> debug_get_current_stack_info() {
-		if (Thread::get_main_id() != Thread::get_caller_id())
+		if (Thread::get_main_id() != Thread::get_caller_id()) {
 			return Vector<StackInfo>();
+		}
 
 		Vector<StackInfo> csi;
 		csi.resize(_debug_call_stack_pos);
diff --git a/modules/gdscript/gdscript_compiler.cpp b/modules/gdscript/gdscript_compiler.cpp
index deb725ea81..bc095ae1f9 100644
--- a/modules/gdscript/gdscript_compiler.cpp
+++ b/modules/gdscript/gdscript_compiler.cpp
@@ -33,11 +33,13 @@
 #include "gdscript.h"
 
 bool GDScriptCompiler::_is_class_member_property(CodeGen &codegen, const StringName &p_name) {
-	if (codegen.function_node && codegen.function_node->_static)
+	if (codegen.function_node && codegen.function_node->_static) {
 		return false;
+	}
 
-	if (codegen.stack_identifiers.has(p_name))
+	if (codegen.stack_identifiers.has(p_name)) {
 		return false; //shadowed
+	}
 
 	return _is_class_member_property(codegen.script, p_name);
 }
@@ -46,8 +48,9 @@ bool GDScriptCompiler::_is_class_member_property(GDScript *owner, const StringNa
 	GDScript *scr = owner;
 	GDScriptNativeClass *nc = nullptr;
 	while (scr) {
-		if (scr->native.is_valid())
+		if (scr->native.is_valid()) {
 			nc = scr->native.ptr();
+		}
 		scr = scr->_base;
 	}
 
@@ -57,8 +60,9 @@ bool GDScriptCompiler::_is_class_member_property(GDScript *owner, const StringNa
 }
 
 void GDScriptCompiler::_set_error(const String &p_error, const GDScriptParser::Node *p_node) {
-	if (error != "")
+	if (error != "") {
 		return;
+	}
 
 	error = p_error;
 	if (p_node) {
@@ -74,8 +78,9 @@ bool GDScriptCompiler::_create_unary_operator(CodeGen &codegen, const GDScriptPa
 	ERR_FAIL_COND_V(on->arguments.size() != 1, false);
 
 	int src_address_a = _parse_expression(codegen, on->arguments[0], p_stack_level);
-	if (src_address_a < 0)
+	if (src_address_a < 0) {
 		return false;
+	}
 
 	codegen.opcodes.push_back(GDScriptFunction::OPCODE_OPERATOR); // perform operator
 	codegen.opcodes.push_back(op); //which operator
@@ -89,14 +94,17 @@ bool GDScriptCompiler::_create_binary_operator(CodeGen &codegen, const GDScriptP
 	ERR_FAIL_COND_V(on->arguments.size() != 2, false);
 
 	int src_address_a = _parse_expression(codegen, on->arguments[0], p_stack_level, false, p_initializer, p_index_addr);
-	if (src_address_a < 0)
+	if (src_address_a < 0) {
 		return false;
-	if (src_address_a & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS)
+	}
+	if (src_address_a & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) {
 		p_stack_level++; //uses stack for return, increase stack
+	}
 
 	int src_address_b = _parse_expression(codegen, on->arguments[1], p_stack_level, false, p_initializer);
-	if (src_address_b < 0)
+	if (src_address_b < 0) {
 		return false;
+	}
 
 	codegen.opcodes.push_back(GDScriptFunction::OPCODE_OPERATOR); // perform operator
 	codegen.opcodes.push_back(op); //which operator
@@ -214,8 +222,9 @@ int GDScriptCompiler::_parse_assign_right_expression(CodeGen &codegen, const GDS
 		return _parse_expression(codegen, p_expression->arguments[1], p_stack_level, false, initializer);
 	}
 
-	if (!_create_binary_operator(codegen, p_expression, var_op, p_stack_level, initializer, p_index_addr))
+	if (!_create_binary_operator(codegen, p_expression, var_op, p_stack_level, initializer, p_index_addr)) {
 		return -1;
+	}
 
 	int dst_addr = (p_stack_level) | (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
 	codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode
@@ -276,8 +285,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						int idx = codegen.get_name_map_pos(identifier);
 						return idx | (GDScriptFunction::ADDR_TYPE_CLASS_CONSTANT << GDScriptFunction::ADDR_BITS); //argument (stack root)
 					}
-					if (scr->native.is_valid())
+					if (scr->native.is_valid()) {
 						nc = scr->native.ptr();
+					}
 					scr = scr->_base;
 				}
 
@@ -394,8 +404,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 
 			for (int i = 0; i < an->elements.size(); i++) {
 				int ret = _parse_expression(codegen, an->elements[i], slevel);
-				if (ret < 0)
+				if (ret < 0) {
 					return ret;
+				}
 				if ((ret >> GDScriptFunction::ADDR_BITS & GDScriptFunction::ADDR_TYPE_STACK) == GDScriptFunction::ADDR_TYPE_STACK) {
 					slevel++;
 					codegen.alloc_stack(slevel);
@@ -406,8 +417,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 
 			codegen.opcodes.push_back(GDScriptFunction::OPCODE_CONSTRUCT_ARRAY);
 			codegen.opcodes.push_back(values.size());
-			for (int i = 0; i < values.size(); i++)
+			for (int i = 0; i < values.size(); i++) {
 				codegen.opcodes.push_back(values[i]);
+			}
 
 			int dst_addr = (p_stack_level) | (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
 			codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode
@@ -423,8 +435,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 
 			for (int i = 0; i < dn->elements.size(); i++) {
 				int ret = _parse_expression(codegen, dn->elements[i].key, slevel);
-				if (ret < 0)
+				if (ret < 0) {
 					return ret;
+				}
 				if ((ret >> GDScriptFunction::ADDR_BITS & GDScriptFunction::ADDR_TYPE_STACK) == GDScriptFunction::ADDR_TYPE_STACK) {
 					slevel++;
 					codegen.alloc_stack(slevel);
@@ -433,8 +446,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 				values.push_back(ret);
 
 				ret = _parse_expression(codegen, dn->elements[i].value, slevel);
-				if (ret < 0)
+				if (ret < 0) {
 					return ret;
+				}
 				if ((ret >> GDScriptFunction::ADDR_BITS & GDScriptFunction::ADDR_TYPE_STACK) == GDScriptFunction::ADDR_TYPE_STACK) {
 					slevel++;
 					codegen.alloc_stack(slevel);
@@ -445,8 +459,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 
 			codegen.opcodes.push_back(GDScriptFunction::OPCODE_CONSTRUCT_DICTIONARY);
 			codegen.opcodes.push_back(dn->elements.size());
-			for (int i = 0; i < values.size(); i++)
+			for (int i = 0; i < values.size(); i++) {
 				codegen.opcodes.push_back(values[i]);
+			}
 
 			int dst_addr = (p_stack_level) | (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
 			codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode
@@ -459,8 +474,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 
 			int slevel = p_stack_level;
 			int src_addr = _parse_expression(codegen, cn->source_node, slevel);
-			if (src_addr < 0)
+			if (src_addr < 0) {
 				return src_addr;
+			}
 			if (src_addr & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) {
 				slevel++;
 				codegen.alloc_stack(slevel);
@@ -522,8 +538,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 					int slevel = p_stack_level;
 					for (int i = 1; i < on->arguments.size(); i++) {
 						int ret = _parse_expression(codegen, on->arguments[i], slevel);
-						if (ret < 0)
+						if (ret < 0) {
 							return ret;
+						}
 						if ((ret >> GDScriptFunction::ADDR_BITS & GDScriptFunction::ADDR_TYPE_STACK) == GDScriptFunction::ADDR_TYPE_STACK) {
 							slevel++;
 							codegen.alloc_stack(slevel);
@@ -537,8 +554,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 					codegen.opcodes.push_back(codegen.get_name_map_pos(in->name)); //instance
 					codegen.opcodes.push_back(arguments.size()); //argument count
 					codegen.alloc_call(arguments.size());
-					for (int i = 0; i < arguments.size(); i++)
+					for (int i = 0; i < arguments.size(); i++) {
 						codegen.opcodes.push_back(arguments[i]); //arguments
+					}
 
 				} break;
 				case GDScriptParser::OperatorNode::OP_CALL: {
@@ -553,8 +571,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						int slevel = p_stack_level;
 						for (int i = 1; i < on->arguments.size(); i++) {
 							int ret = _parse_expression(codegen, on->arguments[i], slevel);
-							if (ret < 0)
+							if (ret < 0) {
 								return ret;
+							}
 							if ((ret >> GDScriptFunction::ADDR_BITS & GDScriptFunction::ADDR_TYPE_STACK) == GDScriptFunction::ADDR_TYPE_STACK) {
 								slevel++;
 								codegen.alloc_stack(slevel);
@@ -567,8 +586,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						codegen.opcodes.push_back(vtype); //instance
 						codegen.opcodes.push_back(arguments.size()); //argument count
 						codegen.alloc_call(arguments.size());
-						for (int i = 0; i < arguments.size(); i++)
+						for (int i = 0; i < arguments.size(); i++) {
 							codegen.opcodes.push_back(arguments[i]); //arguments
+						}
 
 					} else if (on->arguments[0]->type == GDScriptParser::Node::TYPE_BUILT_IN_FUNCTION) {
 						//built in function
@@ -579,8 +599,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						int slevel = p_stack_level;
 						for (int i = 1; i < on->arguments.size(); i++) {
 							int ret = _parse_expression(codegen, on->arguments[i], slevel);
-							if (ret < 0)
+							if (ret < 0) {
 								return ret;
+							}
 
 							if ((ret >> GDScriptFunction::ADDR_BITS & GDScriptFunction::ADDR_TYPE_STACK) == GDScriptFunction::ADDR_TYPE_STACK) {
 								slevel++;
@@ -594,8 +615,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						codegen.opcodes.push_back(static_cast<const GDScriptParser::BuiltInFunctionNode *>(on->arguments[0])->function);
 						codegen.opcodes.push_back(on->arguments.size() - 1);
 						codegen.alloc_call(on->arguments.size() - 1);
-						for (int i = 0; i < arguments.size(); i++)
+						for (int i = 0; i < arguments.size(); i++) {
 							codegen.opcodes.push_back(arguments[i]);
+						}
 
 					} else {
 						//regular function
@@ -626,8 +648,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 
 							} else {
 								ret = _parse_expression(codegen, on->arguments[i], slevel);
-								if (ret < 0)
+								if (ret < 0) {
 									return ret;
+								}
 								if ((ret >> GDScriptFunction::ADDR_BITS & GDScriptFunction::ADDR_TYPE_STACK) == GDScriptFunction::ADDR_TYPE_STACK) {
 									slevel++;
 									codegen.alloc_stack(slevel);
@@ -639,8 +662,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						codegen.opcodes.push_back(p_root ? GDScriptFunction::OPCODE_CALL : GDScriptFunction::OPCODE_CALL_RETURN); // perform operator
 						codegen.opcodes.push_back(on->arguments.size() - 2);
 						codegen.alloc_call(on->arguments.size() - 2);
-						for (int i = 0; i < arguments.size(); i++)
+						for (int i = 0; i < arguments.size(); i++) {
 							codegen.opcodes.push_back(arguments[i]);
+						}
 					}
 				} break;
 				case GDScriptParser::OperatorNode::OP_YIELD: {
@@ -650,8 +674,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 					int slevel = p_stack_level;
 					for (int i = 0; i < on->arguments.size(); i++) {
 						int ret = _parse_expression(codegen, on->arguments[i], slevel);
-						if (ret < 0)
+						if (ret < 0) {
 							return ret;
+						}
 						if ((ret >> GDScriptFunction::ADDR_BITS & GDScriptFunction::ADDR_TYPE_STACK) == GDScriptFunction::ADDR_TYPE_STACK) {
 							slevel++;
 							codegen.alloc_stack(slevel);
@@ -661,8 +686,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 
 					//push call bytecode
 					codegen.opcodes.push_back(arguments.size() == 0 ? GDScriptFunction::OPCODE_YIELD : GDScriptFunction::OPCODE_YIELD_SIGNAL); // basic type constructor
-					for (int i = 0; i < arguments.size(); i++)
+					for (int i = 0; i < arguments.size(); i++) {
 						codegen.opcodes.push_back(arguments[i]); //arguments
+					}
 					codegen.opcodes.push_back(GDScriptFunction::OPCODE_YIELD_RESUME);
 					//next will be where to place the result :)
 
@@ -677,8 +703,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 					bool named = (on->op == GDScriptParser::OperatorNode::OP_INDEX_NAMED);
 
 					int from = _parse_expression(codegen, on->arguments[0], slevel);
-					if (from < 0)
+					if (from < 0) {
 						return from;
+					}
 
 					int index;
 					if (p_index_addr != 0) {
@@ -719,8 +746,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 							}
 
 							index = _parse_expression(codegen, on->arguments[1], slevel);
-							if (index < 0)
+							if (index < 0) {
 								return index;
+							}
 						}
 					}
 
@@ -733,16 +761,18 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 					// AND operator with early out on failure
 
 					int res = _parse_expression(codegen, on->arguments[0], p_stack_level);
-					if (res < 0)
+					if (res < 0) {
 						return res;
+					}
 					codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF_NOT);
 					codegen.opcodes.push_back(res);
 					int jump_fail_pos = codegen.opcodes.size();
 					codegen.opcodes.push_back(0);
 
 					res = _parse_expression(codegen, on->arguments[1], p_stack_level);
-					if (res < 0)
+					if (res < 0) {
 						return res;
+					}
 
 					codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF_NOT);
 					codegen.opcodes.push_back(res);
@@ -765,16 +795,18 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 					// OR operator with early out on success
 
 					int res = _parse_expression(codegen, on->arguments[0], p_stack_level);
-					if (res < 0)
+					if (res < 0) {
 						return res;
+					}
 					codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF);
 					codegen.opcodes.push_back(res);
 					int jump_success_pos = codegen.opcodes.size();
 					codegen.opcodes.push_back(0);
 
 					res = _parse_expression(codegen, on->arguments[1], p_stack_level);
-					if (res < 0)
+					if (res < 0) {
 						return res;
+					}
 
 					codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF);
 					codegen.opcodes.push_back(res);
@@ -798,16 +830,18 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 					// x IF a ELSE y operator with early out on failure
 
 					int res = _parse_expression(codegen, on->arguments[0], p_stack_level);
-					if (res < 0)
+					if (res < 0) {
 						return res;
+					}
 					codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF_NOT);
 					codegen.opcodes.push_back(res);
 					int jump_fail_pos = codegen.opcodes.size();
 					codegen.opcodes.push_back(0);
 
 					res = _parse_expression(codegen, on->arguments[1], p_stack_level);
-					if (res < 0)
+					if (res < 0) {
 						return res;
+					}
 
 					codegen.alloc_stack(p_stack_level); //it will be used..
 					codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN);
@@ -819,8 +853,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 
 					codegen.opcodes.write[jump_fail_pos] = codegen.opcodes.size();
 					res = _parse_expression(codegen, on->arguments[2], p_stack_level);
-					if (res < 0)
+					if (res < 0) {
 						return res;
+					}
 
 					codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN);
 					codegen.opcodes.push_back(p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
@@ -833,92 +868,113 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 				} break;
 				//unary operators
 				case GDScriptParser::OperatorNode::OP_NEG: {
-					if (!_create_unary_operator(codegen, on, Variant::OP_NEGATE, p_stack_level))
+					if (!_create_unary_operator(codegen, on, Variant::OP_NEGATE, p_stack_level)) {
 						return -1;
+					}
 				} break;
 				case GDScriptParser::OperatorNode::OP_POS: {
-					if (!_create_unary_operator(codegen, on, Variant::OP_POSITIVE, p_stack_level))
+					if (!_create_unary_operator(codegen, on, Variant::OP_POSITIVE, p_stack_level)) {
 						return -1;
+					}
 				} break;
 				case GDScriptParser::OperatorNode::OP_NOT: {
-					if (!_create_unary_operator(codegen, on, Variant::OP_NOT, p_stack_level))
+					if (!_create_unary_operator(codegen, on, Variant::OP_NOT, p_stack_level)) {
 						return -1;
+					}
 				} break;
 				case GDScriptParser::OperatorNode::OP_BIT_INVERT: {
-					if (!_create_unary_operator(codegen, on, Variant::OP_BIT_NEGATE, p_stack_level))
+					if (!_create_unary_operator(codegen, on, Variant::OP_BIT_NEGATE, p_stack_level)) {
 						return -1;
+					}
 				} break;
 				//binary operators (in precedence order)
 				case GDScriptParser::OperatorNode::OP_IN: {
-					if (!_create_binary_operator(codegen, on, Variant::OP_IN, p_stack_level))
+					if (!_create_binary_operator(codegen, on, Variant::OP_IN, p_stack_level)) {
 						return -1;
+					}
 				} break;
 				case GDScriptParser::OperatorNode::OP_EQUAL: {
-					if (!_create_binary_operator(codegen, on, Variant::OP_EQUAL, p_stack_level))
+					if (!_create_binary_operator(codegen, on, Variant::OP_EQUAL, p_stack_level)) {
 						return -1;
+					}
 				} break;
 				case GDScriptParser::OperatorNode::OP_NOT_EQUAL: {
-					if (!_create_binary_operator(codegen, on, Variant::OP_NOT_EQUAL, p_stack_level))
+					if (!_create_binary_operator(codegen, on, Variant::OP_NOT_EQUAL, p_stack_level)) {
 						return -1;
+					}
 				} break;
 				case GDScriptParser::OperatorNode::OP_LESS: {
-					if (!_create_binary_operator(codegen, on, Variant::OP_LESS, p_stack_level))
+					if (!_create_binary_operator(codegen, on, Variant::OP_LESS, p_stack_level)) {
 						return -1;
+					}
 				} break;
 				case GDScriptParser::OperatorNode::OP_LESS_EQUAL: {
-					if (!_create_binary_operator(codegen, on, Variant::OP_LESS_EQUAL, p_stack_level))
+					if (!_create_binary_operator(codegen, on, Variant::OP_LESS_EQUAL, p_stack_level)) {
 						return -1;
+					}
 				} break;
 				case GDScriptParser::OperatorNode::OP_GREATER: {
-					if (!_create_binary_operator(codegen, on, Variant::OP_GREATER, p_stack_level))
+					if (!_create_binary_operator(codegen, on, Variant::OP_GREATER, p_stack_level)) {
 						return -1;
+					}
 				} break;
 				case GDScriptParser::OperatorNode::OP_GREATER_EQUAL: {
-					if (!_create_binary_operator(codegen, on, Variant::OP_GREATER_EQUAL, p_stack_level))
+					if (!_create_binary_operator(codegen, on, Variant::OP_GREATER_EQUAL, p_stack_level)) {
 						return -1;
+					}
 				} break;
 				case GDScriptParser::OperatorNode::OP_ADD: {
-					if (!_create_binary_operator(codegen, on, Variant::OP_ADD, p_stack_level))
+					if (!_create_binary_operator(codegen, on, Variant::OP_ADD, p_stack_level)) {
 						return -1;
+					}
 				} break;
 				case GDScriptParser::OperatorNode::OP_SUB: {
-					if (!_create_binary_operator(codegen, on, Variant::OP_SUBTRACT, p_stack_level))
+					if (!_create_binary_operator(codegen, on, Variant::OP_SUBTRACT, p_stack_level)) {
 						return -1;
+					}
 				} break;
 				case GDScriptParser::OperatorNode::OP_MUL: {
-					if (!_create_binary_operator(codegen, on, Variant::OP_MULTIPLY, p_stack_level))
+					if (!_create_binary_operator(codegen, on, Variant::OP_MULTIPLY, p_stack_level)) {
 						return -1;
+					}
 				} break;
 				case GDScriptParser::OperatorNode::OP_DIV: {
-					if (!_create_binary_operator(codegen, on, Variant::OP_DIVIDE, p_stack_level))
+					if (!_create_binary_operator(codegen, on, Variant::OP_DIVIDE, p_stack_level)) {
 						return -1;
+					}
 				} break;
 				case GDScriptParser::OperatorNode::OP_MOD: {
-					if (!_create_binary_operator(codegen, on, Variant::OP_MODULE, p_stack_level))
+					if (!_create_binary_operator(codegen, on, Variant::OP_MODULE, p_stack_level)) {
 						return -1;
+					}
 				} break;
 				//case GDScriptParser::OperatorNode::OP_SHIFT_LEFT: { if (!_create_binary_operator(codegen,on,Variant::OP_SHIFT_LEFT,p_stack_level)) return -1;} break;
 				//case GDScriptParser::OperatorNode::OP_SHIFT_RIGHT: { if (!_create_binary_operator(codegen,on,Variant::OP_SHIFT_RIGHT,p_stack_level)) return -1;} break;
 				case GDScriptParser::OperatorNode::OP_BIT_AND: {
-					if (!_create_binary_operator(codegen, on, Variant::OP_BIT_AND, p_stack_level))
+					if (!_create_binary_operator(codegen, on, Variant::OP_BIT_AND, p_stack_level)) {
 						return -1;
+					}
 				} break;
 				case GDScriptParser::OperatorNode::OP_BIT_OR: {
-					if (!_create_binary_operator(codegen, on, Variant::OP_BIT_OR, p_stack_level))
+					if (!_create_binary_operator(codegen, on, Variant::OP_BIT_OR, p_stack_level)) {
 						return -1;
+					}
 				} break;
 				case GDScriptParser::OperatorNode::OP_BIT_XOR: {
-					if (!_create_binary_operator(codegen, on, Variant::OP_BIT_XOR, p_stack_level))
+					if (!_create_binary_operator(codegen, on, Variant::OP_BIT_XOR, p_stack_level)) {
 						return -1;
+					}
 				} break;
 				//shift
 				case GDScriptParser::OperatorNode::OP_SHIFT_LEFT: {
-					if (!_create_binary_operator(codegen, on, Variant::OP_SHIFT_LEFT, p_stack_level))
+					if (!_create_binary_operator(codegen, on, Variant::OP_SHIFT_LEFT, p_stack_level)) {
 						return -1;
+					}
 				} break;
 				case GDScriptParser::OperatorNode::OP_SHIFT_RIGHT: {
-					if (!_create_binary_operator(codegen, on, Variant::OP_SHIFT_RIGHT, p_stack_level))
+					if (!_create_binary_operator(codegen, on, Variant::OP_SHIFT_RIGHT, p_stack_level)) {
 						return -1;
+					}
 				} break;
 				//assignment operators
 				case GDScriptParser::OperatorNode::OP_ASSIGN_ADD:
@@ -978,8 +1034,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 									break;
 								}
 								n = static_cast<GDScriptParser::OperatorNode *>(n->arguments[0]);
-								if (n->op != GDScriptParser::OperatorNode::OP_INDEX && n->op != GDScriptParser::OperatorNode::OP_INDEX_NAMED)
+								if (n->op != GDScriptParser::OperatorNode::OP_INDEX && n->op != GDScriptParser::OperatorNode::OP_INDEX_NAMED) {
 									break;
+								}
 							}
 						}
 
@@ -987,8 +1044,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 
 						//get at (potential) root stack pos, so it can be returned
 						int prev_pos = _parse_expression(codegen, chain.back()->get()->arguments[0], slevel);
-						if (prev_pos < 0)
+						if (prev_pos < 0) {
 							return prev_pos;
+						}
 						int retval = prev_pos;
 
 						if (retval & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) {
@@ -1008,8 +1066,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						}
 
 						for (List<GDScriptParser::OperatorNode *>::Element *E = chain.back(); E; E = E->prev()) {
-							if (E == chain.front()) //ignore first
+							if (E == chain.front()) { //ignore first
 								break;
+							}
 
 							bool named = E->get()->op == GDScriptParser::OperatorNode::OP_INDEX_NAMED;
 							int key_idx;
@@ -1031,8 +1090,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 								//stack was raised here if retval was stack but..
 							}
 
-							if (key_idx < 0) //error
+							if (key_idx < 0) { //error
 								return key_idx;
+							}
 
 							codegen.opcodes.push_back(named ? GDScriptFunction::OPCODE_GET_NAMED : GDScriptFunction::OPCODE_GET);
 							codegen.opcodes.push_back(prev_pos);
@@ -1066,8 +1126,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 							named = false;
 						}
 
-						if (set_index < 0) //error
+						if (set_index < 0) { //error
 							return set_index;
+						}
 
 						if (set_index & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) {
 							slevel++;
@@ -1075,8 +1136,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						}
 
 						int set_value = _parse_assign_right_expression(codegen, on, slevel + 1, named ? 0 : set_index);
-						if (set_value < 0) //error
+						if (set_value < 0) { //error
 							return set_value;
+						}
 
 						codegen.opcodes.push_back(named ? GDScriptFunction::OPCODE_SET_NAMED : GDScriptFunction::OPCODE_SET);
 						codegen.opcodes.push_back(prev_pos);
@@ -1095,8 +1157,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						int slevel = p_stack_level;
 
 						int src_address = _parse_assign_right_expression(codegen, on, slevel);
-						if (src_address < 0)
+						if (src_address < 0) {
 							return -1;
+						}
 
 						StringName name = static_cast<GDScriptParser::IdentifierNode *>(on->arguments[0])->name;
 
@@ -1111,8 +1174,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						int slevel = p_stack_level;
 
 						int dst_address_a = _parse_expression(codegen, on->arguments[0], slevel, false, on->op == GDScriptParser::OperatorNode::OP_INIT_ASSIGN);
-						if (dst_address_a < 0)
+						if (dst_address_a < 0) {
 							return -1;
+						}
 
 						if (dst_address_a & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) {
 							slevel++;
@@ -1120,8 +1184,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						}
 
 						int src_address_b = _parse_assign_right_expression(codegen, on, slevel);
-						if (src_address_b < 0)
+						if (src_address_b < 0) {
 							return -1;
+						}
 
 						GDScriptDataType assign_type = _gdtype_from_datatype(on->arguments[0]->get_datatype());
 
@@ -1183,15 +1248,18 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 					int slevel = p_stack_level;
 
 					int src_address_a = _parse_expression(codegen, on->arguments[0], slevel);
-					if (src_address_a < 0)
+					if (src_address_a < 0) {
 						return -1;
+					}
 
-					if (src_address_a & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS)
+					if (src_address_a & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) {
 						slevel++; //uses stack for return, increase stack
+					}
 
 					int src_address_b = _parse_expression(codegen, on->arguments[1], slevel);
-					if (src_address_b < 0)
+					if (src_address_b < 0) {
 						return -1;
+					}
 
 					codegen.opcodes.push_back(GDScriptFunction::OPCODE_EXTENDS_TEST); // perform operator
 					codegen.opcodes.push_back(src_address_a); // argument 1
@@ -1205,11 +1273,13 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 					int slevel = p_stack_level;
 
 					int src_address_a = _parse_expression(codegen, on->arguments[0], slevel);
-					if (src_address_a < 0)
+					if (src_address_a < 0) {
 						return -1;
+					}
 
-					if (src_address_a & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS)
+					if (src_address_a & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) {
 						slevel++; //uses stack for return, increase stack
+					}
 
 					const GDScriptParser::TypeNode *tn = static_cast<const GDScriptParser::TypeNode *>(on->arguments[1]);
 
@@ -1332,8 +1402,9 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 
 					case GDScriptParser::ControlFlowNode::CF_IF: {
 						int ret2 = _parse_expression(codegen, cf->arguments[0], p_stack_level, false);
-						if (ret2 < 0)
+						if (ret2 < 0) {
 							return ERR_PARSE_ERROR;
+						}
 
 						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF_NOT);
 						codegen.opcodes.push_back(ret2);
@@ -1341,8 +1412,9 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 						codegen.opcodes.push_back(0); //temporary
 
 						Error err = _parse_block(codegen, cf->body, p_stack_level, p_break_addr, p_continue_addr);
-						if (err)
+						if (err) {
 							return err;
+						}
 
 						if (cf->body_else) {
 							codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
@@ -1351,8 +1423,9 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 							codegen.opcodes.write[else_addr] = codegen.opcodes.size();
 
 							Error err2 = _parse_block(codegen, cf->body_else, p_stack_level, p_break_addr, p_continue_addr);
-							if (err2)
+							if (err2) {
 								return err2;
+							}
 
 							codegen.opcodes.write[end_addr] = codegen.opcodes.size();
 						} else {
@@ -1373,8 +1446,9 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 						codegen.add_stack_identifier(static_cast<const GDScriptParser::IdentifierNode *>(cf->arguments[0])->name, iter_stack_pos);
 
 						int ret2 = _parse_expression(codegen, cf->arguments[1], slevel, false);
-						if (ret2 < 0)
+						if (ret2 < 0) {
 							return ERR_COMPILATION_FAILED;
+						}
 
 						//assign container
 						codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN);
@@ -1402,8 +1476,9 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 						codegen.opcodes.push_back(iterator_pos);
 
 						Error err = _parse_block(codegen, cf->body, slevel, break_pos, continue_pos);
-						if (err)
+						if (err) {
 							return err;
+						}
 
 						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
 						codegen.opcodes.push_back(continue_pos);
@@ -1421,14 +1496,16 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 						int continue_addr = codegen.opcodes.size();
 
 						int ret2 = _parse_expression(codegen, cf->arguments[0], p_stack_level, false);
-						if (ret2 < 0)
+						if (ret2 < 0) {
 							return ERR_PARSE_ERROR;
+						}
 						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF_NOT);
 						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)
+						if (err) {
 							return err;
+						}
 						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
 						codegen.opcodes.push_back(continue_addr);
 
@@ -1459,8 +1536,9 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 
 						if (cf->arguments.size()) {
 							ret2 = _parse_expression(codegen, cf->arguments[0], p_stack_level, false);
-							if (ret2 < 0)
+							if (ret2 < 0) {
 								return ERR_PARSE_ERROR;
+							}
 
 						} else {
 							ret2 = GDScriptFunction::ADDR_TYPE_NIL << GDScriptFunction::ADDR_BITS;
@@ -1479,14 +1557,16 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 				const GDScriptParser::AssertNode *as = static_cast<const GDScriptParser::AssertNode *>(s);
 
 				int ret2 = _parse_expression(codegen, as->condition, p_stack_level, false);
-				if (ret2 < 0)
+				if (ret2 < 0) {
 					return ERR_PARSE_ERROR;
+				}
 
 				int message_ret = 0;
 				if (as->message) {
 					message_ret = _parse_expression(codegen, as->message, p_stack_level + 1, false);
-					if (message_ret < 0)
+					if (message_ret < 0) {
 						return ERR_PARSE_ERROR;
+					}
 				}
 
 				codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSERT);
@@ -1518,8 +1598,9 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 			default: {
 				//expression
 				int ret2 = _parse_expression(codegen, s, p_stack_level, true);
-				if (ret2 < 0)
+				if (ret2 < 0) {
 					return ERR_PARSE_ERROR;
+				}
 			} break;
 		}
 	}
@@ -1575,8 +1656,9 @@ Error GDScriptCompiler::_parse_function(GDScript *p_script, const GDScriptParser
 			codegen.opcodes.push_back((GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) | 0);
 		}
 		Error err = _parse_block(codegen, p_class->initializer, stack_level);
-		if (err)
+		if (err) {
 			return err;
+		}
 		is_initializer = true;
 	}
 
@@ -1584,8 +1666,9 @@ Error GDScriptCompiler::_parse_function(GDScript *p_script, const GDScriptParser
 		//parse initializer for class members
 		if (p_class->ready->statements.size()) {
 			Error err = _parse_block(codegen, p_class->ready, stack_level);
-			if (err)
+			if (err) {
 				return err;
+			}
 		}
 	}
 
@@ -1607,15 +1690,17 @@ Error GDScriptCompiler::_parse_function(GDScript *p_script, const GDScriptParser
 		}
 
 		Error err = _parse_block(codegen, p_func->body, stack_level);
-		if (err)
+		if (err) {
 			return err;
+		}
 
 		func_name = p_func->name;
 	} else {
-		if (p_for_ready)
+		if (p_for_ready) {
 			func_name = "_ready";
-		else
+		} else {
 			func_name = "_init";
+		}
 	}
 
 	codegen.opcodes.push_back(GDScriptFunction::OPCODE_END);
@@ -1716,8 +1801,9 @@ Error GDScriptCompiler::_parse_function(GDScript *p_script, const GDScriptParser
 	if (EngineDebugger::is_active()) {
 		String signature;
 		//path
-		if (p_script->get_path() != String())
+		if (p_script->get_path() != String()) {
 			signature += p_script->get_path();
+		}
 		//loc
 		if (p_func) {
 			signature += "::" + itos(p_func->body->line);
@@ -1757,11 +1843,13 @@ Error GDScriptCompiler::_parse_function(GDScript *p_script, const GDScriptParser
 		gdfunc->_initial_line = 0;
 	}
 
-	if (codegen.debug_stack)
+	if (codegen.debug_stack) {
 		gdfunc->stack_debug = codegen.stack_debug;
+	}
 
-	if (is_initializer)
+	if (is_initializer) {
 		p_script->initializer = gdfunc;
+	}
 
 	return OK;
 }
@@ -1931,8 +2019,9 @@ Error GDScriptCompiler::_parse_class_level(GDScript *p_script, const GDScriptPar
 		// Subclass might still be parsing, just skip it
 		if (!parsed_classes.has(subclass_ptr) && !parsing_classes.has(subclass_ptr)) {
 			Error err = _parse_class_level(subclass_ptr, p_class->subclasses[i], p_keep_state);
-			if (err)
+			if (err) {
 				return err;
+			}
 		}
 
 #ifdef TOOLS_ENABLED
@@ -1953,35 +2042,41 @@ Error GDScriptCompiler::_parse_class_blocks(GDScript *p_script, const GDScriptPa
 	bool has_ready = false;
 
 	for (int i = 0; i < p_class->functions.size(); i++) {
-		if (!has_initializer && p_class->functions[i]->name == "_init")
+		if (!has_initializer && p_class->functions[i]->name == "_init") {
 			has_initializer = true;
-		if (!has_ready && p_class->functions[i]->name == "_ready")
+		}
+		if (!has_ready && p_class->functions[i]->name == "_ready") {
 			has_ready = true;
+		}
 		Error err = _parse_function(p_script, p_class, p_class->functions[i]);
-		if (err)
+		if (err) {
 			return err;
+		}
 	}
 
 	//parse static methods
 
 	for (int i = 0; i < p_class->static_functions.size(); i++) {
 		Error err = _parse_function(p_script, p_class, p_class->static_functions[i]);
-		if (err)
+		if (err) {
 			return err;
+		}
 	}
 
 	if (!has_initializer) {
 		//create a constructor
 		Error err = _parse_function(p_script, p_class, nullptr);
-		if (err)
+		if (err) {
 			return err;
+		}
 	}
 
 	if (!has_ready && p_class->ready->statements.size()) {
 		//create a constructor
 		Error err = _parse_function(p_script, p_class, nullptr, true);
-		if (err)
+		if (err) {
 			return err;
+		}
 	}
 
 #ifdef DEBUG_ENABLED
@@ -2101,13 +2196,15 @@ Error GDScriptCompiler::compile(const GDScriptParser *p_parser, GDScript *p_scri
 	p_script->_owner = nullptr;
 	Error err = _parse_class_level(p_script, static_cast<const GDScriptParser::ClassNode *>(root), p_keep_state);
 
-	if (err)
+	if (err) {
 		return err;
+	}
 
 	err = _parse_class_blocks(p_script, static_cast<const GDScriptParser::ClassNode *>(root), p_keep_state);
 
-	if (err)
+	if (err) {
 		return err;
+	}
 
 	return OK;
 }
diff --git a/modules/gdscript/gdscript_compiler.h b/modules/gdscript/gdscript_compiler.h
index 3a362c75bc..315d4f1842 100644
--- a/modules/gdscript/gdscript_compiler.h
+++ b/modules/gdscript/gdscript_compiler.h
@@ -110,8 +110,9 @@ class GDScriptCompiler {
 		}
 
 		int get_constant_pos(const Variant &p_constant) {
-			if (constant_map.has(p_constant))
+			if (constant_map.has(p_constant)) {
 				return constant_map[p_constant];
+			}
 			int pos = constant_map.size();
 			constant_map[p_constant] = pos;
 			return pos;
@@ -119,12 +120,14 @@ class GDScriptCompiler {
 
 		Vector<int> opcodes;
 		void alloc_stack(int p_level) {
-			if (p_level >= stack_max)
+			if (p_level >= stack_max) {
 				stack_max = p_level + 1;
+			}
 		}
 		void alloc_call(int p_params) {
-			if (p_params >= call_max)
+			if (p_params >= call_max) {
 				call_max = p_params;
+			}
 		}
 
 		int current_line;
diff --git a/modules/gdscript/gdscript_editor.cpp b/modules/gdscript/gdscript_editor.cpp
index 8aa7809347..7433c4a5bc 100644
--- a/modules/gdscript/gdscript_editor.cpp
+++ b/modules/gdscript/gdscript_editor.cpp
@@ -232,15 +232,17 @@ String GDScriptLanguage::debug_get_error() const {
 }
 
 int GDScriptLanguage::debug_get_stack_level_count() const {
-	if (_debug_parse_err_line >= 0)
+	if (_debug_parse_err_line >= 0) {
 		return 1;
+	}
 
 	return _debug_call_stack_pos;
 }
 
 int GDScriptLanguage::debug_get_stack_level_line(int p_level) const {
-	if (_debug_parse_err_line >= 0)
+	if (_debug_parse_err_line >= 0) {
 		return _debug_parse_err_line;
+	}
 
 	ERR_FAIL_INDEX_V(p_level, _debug_call_stack_pos, -1);
 
@@ -250,8 +252,9 @@ int GDScriptLanguage::debug_get_stack_level_line(int p_level) const {
 }
 
 String GDScriptLanguage::debug_get_stack_level_function(int p_level) const {
-	if (_debug_parse_err_line >= 0)
+	if (_debug_parse_err_line >= 0) {
 		return "";
+	}
 
 	ERR_FAIL_INDEX_V(p_level, _debug_call_stack_pos, "");
 	int l = _debug_call_stack_pos - p_level - 1;
@@ -259,8 +262,9 @@ String GDScriptLanguage::debug_get_stack_level_function(int p_level) const {
 }
 
 String GDScriptLanguage::debug_get_stack_level_source(int p_level) const {
-	if (_debug_parse_err_line >= 0)
+	if (_debug_parse_err_line >= 0) {
 		return _debug_parse_err_file;
+	}
 
 	ERR_FAIL_INDEX_V(p_level, _debug_call_stack_pos, "");
 	int l = _debug_call_stack_pos - p_level - 1;
@@ -268,8 +272,9 @@ String GDScriptLanguage::debug_get_stack_level_source(int p_level) const {
 }
 
 void GDScriptLanguage::debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
-	if (_debug_parse_err_line >= 0)
+	if (_debug_parse_err_line >= 0) {
 		return;
+	}
 
 	ERR_FAIL_INDEX(p_level, _debug_call_stack_pos);
 	int l = _debug_call_stack_pos - p_level - 1;
@@ -286,16 +291,18 @@ void GDScriptLanguage::debug_get_stack_level_locals(int p_level, List<String> *p
 }
 
 void GDScriptLanguage::debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
-	if (_debug_parse_err_line >= 0)
+	if (_debug_parse_err_line >= 0) {
 		return;
+	}
 
 	ERR_FAIL_INDEX(p_level, _debug_call_stack_pos);
 	int l = _debug_call_stack_pos - p_level - 1;
 
 	GDScriptInstance *instance = _call_stack[l].instance;
 
-	if (!instance)
+	if (!instance) {
 		return;
+	}
 
 	Ref<GDScript> script = instance->get_script();
 	ERR_FAIL_COND(script.is_null());
@@ -309,8 +316,9 @@ void GDScriptLanguage::debug_get_stack_level_members(int p_level, List<String> *
 }
 
 ScriptInstance *GDScriptLanguage::debug_get_stack_level_instance(int p_level) {
-	if (_debug_parse_err_line >= 0)
+	if (_debug_parse_err_line >= 0) {
 		return nullptr;
+	}
 
 	ERR_FAIL_INDEX_V(p_level, _debug_call_stack_pos, nullptr);
 
@@ -328,8 +336,9 @@ void GDScriptLanguage::debug_get_globals(List<String> *p_globals, List<Variant>
 	get_public_constants(&cinfo);
 
 	for (const Map<StringName, int>::Element *E = name_idx.front(); E; E = E->next()) {
-		if (ClassDB::class_exists(E->key()) || Engine::get_singleton()->has_singleton(E->key()))
+		if (ClassDB::class_exists(E->key()) || Engine::get_singleton()->has_singleton(E->key())) {
 			continue;
+		}
 
 		bool is_script_constant = false;
 		for (List<Pair<String, Variant>>::Element *CE = cinfo.front(); CE; CE = CE->next()) {
@@ -338,13 +347,15 @@ void GDScriptLanguage::debug_get_globals(List<String> *p_globals, List<Variant>
 				break;
 			}
 		}
-		if (is_script_constant)
+		if (is_script_constant) {
 			continue;
+		}
 
 		const Variant &var = globals[E->value()];
 		if (Object *obj = var) {
-			if (Object::cast_to<GDScriptNativeClass>(obj))
+			if (Object::cast_to<GDScriptNativeClass>(obj)) {
 				continue;
+			}
 		}
 
 		bool skip = false;
@@ -354,8 +365,9 @@ void GDScriptLanguage::debug_get_globals(List<String> *p_globals, List<Variant>
 				break;
 			}
 		}
-		if (skip)
+		if (skip) {
 			continue;
+		}
 
 		p_globals->push_back(E->key());
 		p_values->push_back(var);
@@ -436,8 +448,9 @@ String GDScriptLanguage::make_function(const String &p_class, const String &p_na
 	String s = "func " + p_name + "(";
 	if (p_args.size()) {
 		for (int i = 0; i < p_args.size(); i++) {
-			if (i > 0)
+			if (i > 0) {
 				s += ", ";
+			}
 			s += p_args[i].get_slice(":", 0);
 			if (th) {
 				String type = p_args[i].get_slice(":", 1);
@@ -2994,8 +3007,9 @@ void GDScriptLanguage::auto_indent_code(String &p_code, int p_from_line, int p_t
 		}
 
 		String st = l.substr(tc, l.length()).strip_edges();
-		if (st == "" || st.begins_with("#"))
+		if (st == "" || st.begins_with("#")) {
 			continue; //ignore!
+		}
 
 		int ilevel = 0;
 		if (indent_stack.size()) {
@@ -3009,8 +3023,9 @@ void GDScriptLanguage::auto_indent_code(String &p_code, int p_from_line, int p_t
 				indent_stack.pop_back();
 			}
 
-			if (indent_stack.size() && indent_stack.back()->get() != tc)
+			if (indent_stack.size() && indent_stack.back()->get() != tc) {
 				indent_stack.push_back(tc); //this is not right but gets the job done
+			}
 		}
 
 		if (i >= p_from_line) {
@@ -3029,8 +3044,9 @@ void GDScriptLanguage::auto_indent_code(String &p_code, int p_from_line, int p_t
 
 	p_code = "";
 	for (int i = 0; i < lines.size(); i++) {
-		if (i > 0)
+		if (i > 0) {
 			p_code += "\n";
+		}
 		p_code += lines[i];
 	}
 }
@@ -3349,8 +3365,9 @@ Error GDScriptLanguage::lookup_code(const String &p_code, const String &p_symbol
 
 				for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
 					String s = E->get().name;
-					if (!s.begins_with("autoload/"))
+					if (!s.begins_with("autoload/")) {
 						continue;
+					}
 					String name = s.get_slice("/", 1);
 					if (name == String(p_symbol)) {
 						String path = ProjectSettings::get_singleton()->get(s);
diff --git a/modules/gdscript/gdscript_function.cpp b/modules/gdscript/gdscript_function.cpp
index aa2ea149f5..92e07ab874 100644
--- a/modules/gdscript/gdscript_function.cpp
+++ b/modules/gdscript/gdscript_function.cpp
@@ -140,10 +140,11 @@ static String _get_var_type(const Variant *p_var) {
 				basestr = "previously freed";
 			}
 		} else {
-			if (bobj->get_script_instance())
+			if (bobj->get_script_instance()) {
 				basestr = bobj->get_class() + " (" + bobj->get_script_instance()->get_script()->get_path().get_file() + ")";
-			else
+			} else {
 				basestr = bobj->get_class();
+			}
 		}
 
 	} else {
@@ -366,8 +367,9 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 
 #ifdef DEBUG_ENABLED
 
-	if (EngineDebugger::is_active())
+	if (EngineDebugger::is_active()) {
 		GDScriptLanguage::get_singleton()->enter_function(p_instance, this, stack, &ip, &line);
+	}
 
 #define GD_ERR_BREAK(m_cond)                                                                                           \
 	{                                                                                                                  \
@@ -1149,8 +1151,9 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 				while (gds->base.ptr()) {
 					gds = gds->base.ptr();
 					E = gds->member_functions.find(*methodname);
-					if (E)
+					if (E) {
 						break;
+					}
 				}
 
 				Callable::CallError err;
@@ -1466,14 +1469,17 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 					bool do_break = false;
 
 					if (EngineDebugger::get_script_debugger()->get_lines_left() > 0) {
-						if (EngineDebugger::get_script_debugger()->get_depth() <= 0)
+						if (EngineDebugger::get_script_debugger()->get_depth() <= 0) {
 							EngineDebugger::get_script_debugger()->set_lines_left(EngineDebugger::get_script_debugger()->get_lines_left() - 1);
-						if (EngineDebugger::get_script_debugger()->get_lines_left() <= 0)
+						}
+						if (EngineDebugger::get_script_debugger()->get_lines_left() <= 0) {
 							do_break = true;
+						}
 					}
 
-					if (EngineDebugger::get_script_debugger()->is_breakpoint(line, source))
+					if (EngineDebugger::get_script_debugger()->is_breakpoint(line, source)) {
 						do_break = true;
+					}
 
 					if (do_break) {
 						GDScriptLanguage::get_singleton()->debug_break("Breakpoint", true);
@@ -1501,20 +1507,24 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 
 		OPCODES_END
 #ifdef DEBUG_ENABLED
-		if (exit_ok)
+		if (exit_ok) {
 			OPCODE_OUT;
+		}
 		//error
 		// function, file, line, error, explanation
 		String err_file;
-		if (p_instance && ObjectDB::get_instance(p_instance->owner_id) != nullptr && p_instance->script->is_valid() && p_instance->script->path != "")
+		if (p_instance && ObjectDB::get_instance(p_instance->owner_id) != nullptr && p_instance->script->is_valid() && p_instance->script->path != "") {
 			err_file = p_instance->script->path;
-		else if (script)
+		} else if (script) {
 			err_file = script->path;
-		if (err_file == "")
+		}
+		if (err_file == "") {
 			err_file = "<built-in>";
+		}
 		String err_func = name;
-		if (p_instance && ObjectDB::get_instance(p_instance->owner_id) != nullptr && p_instance->script->is_valid() && p_instance->script->name != "")
+		if (p_instance && ObjectDB::get_instance(p_instance->owner_id) != nullptr && p_instance->script->is_valid() && p_instance->script->name != "") {
 			err_func = p_instance->script->name + "." + err_func;
+		}
 		int err_line = line;
 		if (err_text == "") {
 			err_text = "Internal Script Error! - opcode #" + itos(last_opcode) + " (report please).";
@@ -1546,14 +1556,16 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 	// When it's the last resume it will postpone the exit from stack,
 	// so the debugger knows which function triggered the resume of the next function (if any)
 	if (!p_state || yielded) {
-		if (EngineDebugger::is_active())
+		if (EngineDebugger::is_active()) {
 			GDScriptLanguage::get_singleton()->exit_function();
+		}
 #endif
 
 		if (_stack_size) {
 			//free stack
-			for (int i = 0; i < _stack_size; i++)
+			for (int i = 0; i < _stack_size; i++) {
 				stack[i].~Variant();
+			}
 		}
 
 #ifdef DEBUG_ENABLED
@@ -1627,8 +1639,9 @@ void GDScriptFunction::debug_get_stack_member_state(int p_line, List<Pair<String
 	Map<StringName, _GDFKC> sdmap;
 	for (const List<StackDebug>::Element *E = stack_debug.front(); E; E = E->next()) {
 		const StackDebug &sd = E->get();
-		if (sd.line > p_line)
+		if (sd.line > p_line) {
 			break;
+		}
 
 		if (sd.added) {
 			if (!sdmap.has(sd.identifier)) {
@@ -1644,8 +1657,9 @@ void GDScriptFunction::debug_get_stack_member_state(int p_line, List<Pair<String
 			ERR_CONTINUE(!sdmap.has(sd.identifier));
 
 			sdmap[sd.identifier].pos.pop_back();
-			if (sdmap[sd.identifier].pos.empty())
+			if (sdmap[sd.identifier].pos.empty()) {
 				sdmap.erase(sd.identifier);
+			}
 		}
 	}
 
@@ -1740,8 +1754,9 @@ Variant GDScriptFunctionState::_signal_callback(const Variant **p_args, int p_ar
 }
 
 bool GDScriptFunctionState::is_valid(bool p_extended_check) const {
-	if (function == nullptr)
+	if (function == nullptr) {
 		return false;
+	}
 
 	if (p_extended_check) {
 		MutexLock lock(GDScriptLanguage::get_singleton()->lock);
@@ -1812,8 +1827,9 @@ Variant GDScriptFunctionState::resume(const Variant &p_arg) {
 		}
 
 #ifdef DEBUG_ENABLED
-		if (EngineDebugger::is_active())
+		if (EngineDebugger::is_active()) {
 			GDScriptLanguage::get_singleton()->exit_function();
+		}
 #endif
 	}
 
@@ -1823,8 +1839,9 @@ Variant GDScriptFunctionState::resume(const Variant &p_arg) {
 void GDScriptFunctionState::_clear_stack() {
 	if (state.stack_size) {
 		Variant *stack = (Variant *)state.stack.ptr();
-		for (int i = 0; i < state.stack_size; i++)
+		for (int i = 0; i < state.stack_size; i++) {
 			stack[i].~Variant();
+		}
 		state.stack_size = 0;
 	}
 }
diff --git a/modules/gdscript/gdscript_function.h b/modules/gdscript/gdscript_function.h
index 490da102c0..583eab744a 100644
--- a/modules/gdscript/gdscript_function.h
+++ b/modules/gdscript/gdscript_function.h
@@ -59,8 +59,9 @@ struct GDScriptDataType {
 	Ref<Script> script_type;
 
 	bool is_type(const Variant &p_variant, bool p_allow_implicit_conversion = false) const {
-		if (!has_type)
+		if (!has_type) {
 			return true; // Can't type check
+		}
 
 		switch (kind) {
 			case UNINITIALIZED:
diff --git a/modules/gdscript/gdscript_functions.cpp b/modules/gdscript/gdscript_functions.cpp
index 5df2c79df5..d4258c385e 100644
--- a/modules/gdscript/gdscript_functions.cpp
+++ b/modules/gdscript/gdscript_functions.cpp
@@ -672,10 +672,11 @@ void GDScriptFunctions::call(Function p_func, const Variant **p_args, int p_arg_
 			for (int i = 0; i < p_arg_count; i++) {
 				String os = p_args[i]->operator String();
 
-				if (i == 0)
+				if (i == 0) {
 					str = os;
-				else
+				} else {
 					str += os;
+				}
 			}
 
 			r_ret = str;
@@ -694,8 +695,9 @@ void GDScriptFunctions::call(Function p_func, const Variant **p_args, int p_arg_
 		case TEXT_PRINT_TABBED: {
 			String str;
 			for (int i = 0; i < p_arg_count; i++) {
-				if (i)
+				if (i) {
 					str += "\t";
+				}
 				str += p_args[i]->operator String();
 			}
 
@@ -706,8 +708,9 @@ void GDScriptFunctions::call(Function p_func, const Variant **p_args, int p_arg_
 		case TEXT_PRINT_SPACED: {
 			String str;
 			for (int i = 0; i < p_arg_count; i++) {
-				if (i)
+				if (i) {
 					str += " ";
+				}
 				str += p_args[i]->operator String();
 			}
 
@@ -936,8 +939,9 @@ void GDScriptFunctions::call(Function p_func, const Variant **p_args, int p_arg_
 						r_ret = Variant();
 						return;
 					}
-					for (int i = from; i < to; i++)
+					for (int i = from; i < to; i++) {
 						arr[i - from] = i;
+					}
 					r_ret = arr;
 				} break;
 				case 3: {
diff --git a/modules/gdscript/gdscript_parser.cpp b/modules/gdscript/gdscript_parser.cpp
index 09f5b13e22..d8f2c16638 100644
--- a/modules/gdscript/gdscript_parser.cpp
+++ b/modules/gdscript/gdscript_parser.cpp
@@ -47,8 +47,9 @@ T *GDScriptParser::alloc_node() {
 	t->next = list;
 	list = t;
 
-	if (!head)
+	if (!head) {
 		head = t;
+	}
 
 	t->line = tokenizer->get_token_line();
 	t->column = tokenizer->get_token_column();
@@ -269,8 +270,9 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 			parenthesis++;
 			Node *subexpr = _parse_expression(p_parent, p_static, p_allow_assign, p_parsing_constant);
 			parenthesis--;
-			if (!subexpr)
+			if (!subexpr) {
 				return nullptr;
+			}
 
 			if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 				_set_error("Expected ')' in expression");
@@ -463,8 +465,9 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 				return nullptr;
 			}
 
-			if (!path.is_abs_path() && base_path != "")
+			if (!path.is_abs_path() && base_path != "") {
 				path = base_path.plus_file(path);
+			}
 			path = path.replace("///", "//").simplify_path();
 			if (path == self_path) {
 				_set_error("Can't preload itself (use 'get_script()').");
@@ -543,8 +546,9 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 				parenthesis++;
 
 				Node *object = _parse_and_reduce_expression(p_parent, p_static);
-				if (!object)
+				if (!object) {
 					return nullptr;
+				}
 				yield->arguments.push_back(object);
 
 				if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
@@ -568,8 +572,9 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 				}
 
 				Node *signal = _parse_and_reduce_expression(p_parent, p_static);
-				if (!signal)
+				if (!signal) {
 					return nullptr;
+				}
 				yield->arguments.push_back(signal);
 
 				if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
@@ -628,8 +633,9 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 					id->name = identifier;
 					op->arguments.push_back(id);
 
-					if (!_parse_arguments(op, op->arguments, p_static, true, p_parsing_constant))
+					if (!_parse_arguments(op, op->arguments, p_static, true, p_parsing_constant)) {
 						return nullptr;
+					}
 
 					expr = op;
 				} else {
@@ -724,8 +730,9 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 				}
 			}
 			if (!replaced) {
-				if (!_parse_arguments(op, op->arguments, p_static, true, p_parsing_constant))
+				if (!_parse_arguments(op, op->arguments, p_static, true, p_parsing_constant)) {
 					return nullptr;
+				}
 				expr = op;
 			}
 		} else if (tokenizer->is_token_literal(0, true)) {
@@ -961,8 +968,9 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 						return nullptr;
 					}
 					Node *n = _parse_expression(arr, p_static, p_allow_assign, p_parsing_constant);
-					if (!n)
+					if (!n) {
 						return nullptr;
+					}
 					arr->elements.push_back(n);
 					expecting_comma = true;
 				}
@@ -1063,16 +1071,18 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 						} else {
 							//python/js style more flexible
 							key = _parse_expression(dict, p_static, p_allow_assign, p_parsing_constant);
-							if (!key)
+							if (!key) {
 								return nullptr;
+							}
 							expecting = DICT_EXPECT_COLON;
 						}
 					}
 
 					if (expecting == DICT_EXPECT_VALUE) {
 						Node *value = _parse_expression(dict, p_static, p_allow_assign, p_parsing_constant);
-						if (!value)
+						if (!value) {
 							return nullptr;
+						}
 						expecting = DICT_EXPECT_COMMA;
 
 						if (key->type == GDScriptParser::Node::TYPE_CONSTANT) {
@@ -1183,8 +1193,9 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 						_make_completable_call(0);
 						completion_node = op;
 					}
-					if (!_parse_arguments(op, op->arguments, p_static, true, p_parsing_constant))
+					if (!_parse_arguments(op, op->arguments, p_static, true, p_parsing_constant)) {
 						return nullptr;
+					}
 					expr = op;
 
 				} else {
@@ -1235,8 +1246,9 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 				tokenizer->advance(1);
 				expr = op;
 
-			} else
+			} else {
 				break;
+			}
 		}
 
 		/*****************/
@@ -1720,8 +1732,9 @@ GDScriptParser::Node *GDScriptParser::_reduce_expression(Node *p_node, bool p_to
 
 			for (int i = 0; i < an->elements.size(); i++) {
 				an->elements.write[i] = _reduce_expression(an->elements[i], p_to_const);
-				if (an->elements[i]->type != Node::TYPE_CONSTANT)
+				if (an->elements[i]->type != Node::TYPE_CONSTANT) {
 					all_constants = false;
+				}
 			}
 
 			if (all_constants && p_to_const) {
@@ -1748,11 +1761,13 @@ GDScriptParser::Node *GDScriptParser::_reduce_expression(Node *p_node, bool p_to
 
 			for (int i = 0; i < dn->elements.size(); i++) {
 				dn->elements.write[i].key = _reduce_expression(dn->elements[i].key, p_to_const);
-				if (dn->elements[i].key->type != Node::TYPE_CONSTANT)
+				if (dn->elements[i].key->type != Node::TYPE_CONSTANT) {
 					all_constants = false;
+				}
 				dn->elements.write[i].value = _reduce_expression(dn->elements[i].value, p_to_const);
-				if (dn->elements[i].value->type != Node::TYPE_CONSTANT)
+				if (dn->elements[i].value->type != Node::TYPE_CONSTANT) {
 					all_constants = false;
+				}
 			}
 
 			if (all_constants && p_to_const) {
@@ -1952,8 +1967,9 @@ GDScriptParser::Node *GDScriptParser::_reduce_expression(Node *p_node, bool p_to
 				}
 			}
 			//now se if all are constants
-			if (!all_constants)
+			if (!all_constants) {
 				return op; //nothing to reduce from here on
+			}
 #define _REDUCE_UNARY(m_vop)                                                                               \
 	bool valid = false;                                                                                    \
 	Variant res;                                                                                           \
@@ -2075,11 +2091,13 @@ GDScriptParser::Node *GDScriptParser::_reduce_expression(Node *p_node, bool p_to
 
 GDScriptParser::Node *GDScriptParser::_parse_and_reduce_expression(Node *p_parent, bool p_static, bool p_reduce_const, bool p_allow_assign) {
 	Node *expr = _parse_expression(p_parent, p_static, p_allow_assign, p_reduce_const);
-	if (!expr || error_set)
+	if (!expr || error_set) {
 		return nullptr;
+	}
 	expr = _reduce_expression(expr, p_reduce_const);
-	if (!expr || error_set)
+	if (!expr || error_set) {
 		return nullptr;
+	}
 	return expr;
 }
 
@@ -2087,8 +2105,9 @@ bool GDScriptParser::_reduce_export_var_type(Variant &p_value, int p_line) {
 	if (p_value.get_type() == Variant::ARRAY) {
 		Array arr = p_value;
 		for (int i = 0; i < arr.size(); i++) {
-			if (!_reduce_export_var_type(arr[i], p_line))
+			if (!_reduce_export_var_type(arr[i], p_line)) {
 				return false;
+			}
 		}
 		return true;
 	}
@@ -2097,8 +2116,9 @@ bool GDScriptParser::_reduce_export_var_type(Variant &p_value, int p_line) {
 		Dictionary dict = p_value;
 		for (int i = 0; i < dict.size(); i++) {
 			Variant value = dict.get_value_at_index(i);
-			if (!_reduce_export_var_type(value, p_line))
+			if (!_reduce_export_var_type(value, p_line)) {
 				return false;
+			}
 		}
 		return true;
 	}
@@ -2137,8 +2157,9 @@ GDScriptParser::PatternNode *GDScriptParser::_parse_pattern(bool p_static) {
 	PatternNode *pattern = alloc_node<PatternNode>();
 
 	GDScriptTokenizer::Token token = tokenizer->get_token();
-	if (error_set)
+	if (error_set) {
 		return nullptr;
+	}
 
 	if (token == GDScriptTokenizer::TK_EOF) {
 		return nullptr;
@@ -2333,12 +2354,14 @@ void GDScriptParser::_parse_pattern_block(BlockNode *p_block, Vector<PatternBran
 	bool catch_all_appeared = false;
 
 	while (true) {
-		while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE && _parse_newline())
+		while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE && _parse_newline()) {
 			;
+		}
 
 		// GDScriptTokenizer::Token token = tokenizer->get_token();
-		if (error_set)
+		if (error_set) {
 			return;
+		}
 
 		if (current_level.indent > indent_level.back()->get().indent) {
 			break; // go back a level
@@ -2820,8 +2843,9 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 		is_first_line = false;
 
 		GDScriptTokenizer::Token token = tokenizer->get_token();
-		if (error_set)
+		if (error_set) {
 			return;
+		}
 
 		if (current_level.indent > indent_level.back()->get().indent) {
 			p_block->end_line = tokenizer->get_token_line();
@@ -3007,16 +3031,18 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 				_parse_block(cf_if->body, p_static);
 				current_block = p_block;
 
-				if (error_set)
+				if (error_set) {
 					return;
+				}
 				p_block->statements.push_back(cf_if);
 
 				bool all_have_return = cf_if->body->has_return;
 				bool have_else = false;
 
 				while (true) {
-					while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE && _parse_newline())
+					while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE && _parse_newline()) {
 						;
+					}
 
 					if (indent_level.back()->get().indent < current_level.indent) { //not at current indent level
 						p_block->end_line = tokenizer->get_token_line();
@@ -3064,8 +3090,9 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 						current_block = cf_else->body;
 						_parse_block(cf_else->body, p_static);
 						current_block = p_block;
-						if (error_set)
+						if (error_set) {
 							return;
+						}
 
 						all_have_return = all_have_return && cf_else->body->has_return;
 
@@ -3088,16 +3115,18 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 						current_block = cf_if->body_else;
 						_parse_block(cf_if->body_else, p_static);
 						current_block = p_block;
-						if (error_set)
+						if (error_set) {
 							return;
+						}
 
 						all_have_return = all_have_return && cf_if->body_else->has_return;
 						have_else = true;
 
 						break; //after else, exit
 
-					} else
+					} else {
 						break;
+					}
 				}
 
 				cf_if->body->has_return = all_have_return;
@@ -3133,8 +3162,9 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 				current_block = cf_while->body;
 				_parse_block(cf_while->body, p_static);
 				current_block = p_block;
-				if (error_set)
+				if (error_set) {
 					return;
+				}
 				p_block->has_return = cf_while->body->has_return;
 				p_block->statements.push_back(cf_while);
 			} break;
@@ -3271,8 +3301,9 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 				_parse_block(cf_for->body, p_static);
 				current_block = p_block;
 
-				if (error_set)
+				if (error_set) {
 					return;
+				}
 				p_block->has_return = cf_for->body->has_return;
 				p_block->statements.push_back(cf_for);
 			} break;
@@ -3358,8 +3389,9 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 
 				_parse_pattern_block(compiled_branches, match_node->branches, p_static);
 
-				if (error_set)
+				if (error_set) {
 					return;
+				}
 
 				ControlFlowNode *match_cf_node = alloc_node<ControlFlowNode>();
 				match_cf_node->cf_type = ControlFlowNode::CF_MATCH;
@@ -3538,8 +3570,9 @@ void GDScriptParser::_parse_extends(ClassNode *p_class) {
 
 		if (tokenizer->get_token() != GDScriptTokenizer::TK_PERIOD) {
 			return;
-		} else
+		} else {
 			tokenizer->advance();
+		}
 	}
 
 	while (true) {
@@ -3576,8 +3609,9 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 
 	while (true) {
 		GDScriptTokenizer::Token token = tokenizer->get_token();
-		if (error_set)
+		if (error_set) {
 			return;
+		}
 
 		if (current_level.indent > indent_level.back()->get().indent) {
 			p_class->end_line = tokenizer->get_token_line();
@@ -3606,8 +3640,9 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 			case GDScriptTokenizer::TK_PR_EXTENDS: {
 				_mark_line_as_safe(tokenizer->get_token_line());
 				_parse_extends(p_class);
-				if (error_set)
+				if (error_set) {
 					return;
+				}
 				if (!_end_statement()) {
 					_set_end_statement_error("extends");
 					return;
@@ -3754,8 +3789,9 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 
 				if (tokenizer->get_token() == GDScriptTokenizer::TK_PR_EXTENDS) {
 					_parse_extends(newclass);
-					if (error_set)
+					if (error_set) {
 						return;
+					}
 				}
 
 				if (!_enter_indent_block()) {
@@ -3899,8 +3935,9 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 							defaulting = true;
 							tokenizer->advance(1);
 							Node *defval = _parse_and_reduce_expression(p_class, _static);
-							if (!defval || error_set)
+							if (!defval || error_set) {
 								return;
+							}
 
 							OperatorNode *on = alloc_node<OperatorNode>();
 							on->op = OperatorNode::OP_ASSIGN;
@@ -4025,10 +4062,11 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 
 				function->return_type = return_type;
 
-				if (_static)
+				if (_static) {
 					p_class->static_functions.push_back(function);
-				else
+				} else {
 					p_class->functions.push_back(function);
+				}
 
 				current_function = function;
 				function->body = block;
@@ -4160,16 +4198,18 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 											}
 
 											String c = tokenizer->get_token_constant();
-											if (!first)
+											if (!first) {
 												current_export.hint_string += ",";
-											else
+											} else {
 												first = false;
+											}
 
 											current_export.hint_string += c.xml_escape();
 
 											_ADVANCE_AND_CONSUME_NEWLINES;
-											if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE)
+											if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 												break;
+											}
 
 											if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
 												current_export = PropertyInfo();
@@ -4234,16 +4274,18 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 											}
 
 											String c = tokenizer->get_token_constant();
-											if (!first)
+											if (!first) {
 												current_export.hint_string += ",";
-											else
+											} else {
 												first = false;
+											}
 
 											current_export.hint_string += c.xml_escape();
 
 											_ADVANCE_AND_CONSUME_NEWLINES;
-											if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE)
+											if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 												break;
+											}
 
 											if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
 												current_export = PropertyInfo();
@@ -4275,15 +4317,16 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 										current_export.hint = PROPERTY_HINT_EXP_RANGE;
 										_ADVANCE_AND_CONSUME_NEWLINES;
 
-										if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE)
+										if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 											break;
-										else if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
+										} else if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
 											_set_error("Expected \")\" or \",\" in the exponential range hint.");
 											return;
 										}
 										_ADVANCE_AND_CONSUME_NEWLINES;
-									} else
+									} else {
 										current_export.hint = PROPERTY_HINT_RANGE;
+									}
 
 									float sign = 1.0;
 
@@ -4328,8 +4371,9 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 									current_export.hint_string += "," + rtos(sign * double(tokenizer->get_token_constant()));
 									_ADVANCE_AND_CONSUME_NEWLINES;
 
-									if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE)
+									if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 										break;
+									}
 
 									if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
 										current_export = PropertyInfo();
@@ -4367,15 +4411,17 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 											}
 
 											String c = tokenizer->get_token_constant();
-											if (!first)
+											if (!first) {
 												current_export.hint_string += ",";
-											else
+											} else {
 												first = false;
+											}
 
 											current_export.hint_string += c.xml_escape();
 											_ADVANCE_AND_CONSUME_NEWLINES;
-											if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE)
+											if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 												break;
+											}
 
 											if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
 												current_export = PropertyInfo();
@@ -4391,9 +4437,9 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 									if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "DIR") {
 										_ADVANCE_AND_CONSUME_NEWLINES;
 
-										if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE)
+										if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 											current_export.hint = PROPERTY_HINT_DIR;
-										else if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+										} else if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
 											_ADVANCE_AND_CONSUME_NEWLINES;
 
 											if (tokenizer->get_token() != GDScriptTokenizer::TK_IDENTIFIER || !(tokenizer->get_token_identifier() == "GLOBAL")) {
@@ -4433,21 +4479,22 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 												current_export.hint = PROPERTY_HINT_GLOBAL_FILE;
 												_ADVANCE_AND_CONSUME_NEWLINES;
 
-												if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE)
+												if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 													break;
-												else if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA)
+												} else if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
 													_ADVANCE_AND_CONSUME_NEWLINES;
-												else {
+												} else {
 													_set_error("Expected \")\" or \",\" in the hint.");
 													return;
 												}
 											}
 
 											if (tokenizer->get_token() != GDScriptTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type() != Variant::STRING) {
-												if (current_export.hint == PROPERTY_HINT_GLOBAL_FILE)
+												if (current_export.hint == PROPERTY_HINT_GLOBAL_FILE) {
 													_set_error("Expected string constant with filter.");
-												else
+												} else {
 													_set_error("Expected \"GLOBAL\" or string constant with filter.");
+												}
 												return;
 											}
 											current_export.hint_string = tokenizer->get_token_constant();
@@ -4559,10 +4606,11 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 							bool first = true;
 							for (List<Variant>::Element *E = keys.front(); E; E = E->next()) {
 								if (enum_values[E->get()].get_type() == Variant::INT) {
-									if (!first)
+									if (!first) {
 										current_export.hint_string += ",";
-									else
+									} else {
 										first = false;
+									}
 
 									current_export.hint_string += E->get().operator String().camelcase_to_underscore(true).capitalize().xml_escape();
 									if (!is_flags) {
@@ -4678,10 +4726,11 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 				//may be fallthrough from export, ignore if so
 				tokenizer->advance();
 				if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_FUNCTION) {
-					if (current_export.type)
+					if (current_export.type) {
 						_set_error("Expected \"var\".");
-					else
+					} else {
 						_set_error("Expected \"var\" or \"func\".");
+					}
 					return;
 				}
 
@@ -4692,10 +4741,11 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 				//may be fallthrough from export, ignore if so
 				tokenizer->advance();
 				if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_FUNCTION) {
-					if (current_export.type)
+					if (current_export.type) {
 						_set_error("Expected \"var\".");
-					else
+					} else {
 						_set_error("Expected \"var\" or \"func\".");
+					}
 					return;
 				}
 
@@ -4706,10 +4756,11 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 				//may be fallthrough from export, ignore if so
 				tokenizer->advance();
 				if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_FUNCTION) {
-					if (current_export.type)
+					if (current_export.type) {
 						_set_error("Expected \"var\".");
-					else
+					} else {
 						_set_error("Expected \"var\" or \"func\".");
+					}
 					return;
 				}
 
@@ -4859,8 +4910,9 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 							return;
 						}
 
-						if (!_reduce_export_var_type(cn->value, member.line))
+						if (!_reduce_export_var_type(cn->value, member.line)) {
 							return;
+						}
 
 						member._export.type = cn->value.get_type();
 						member._export.usage |= PROPERTY_USAGE_SCRIPT_VARIABLE;
@@ -4906,15 +4958,17 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 #ifdef DEBUG_ENABLED
 					NewLineNode *nl2 = alloc_node<NewLineNode>();
 					nl2->line = line;
-					if (onready)
+					if (onready) {
 						p_class->ready->statements.push_back(nl2);
-					else
+					} else {
 						p_class->initializer->statements.push_back(nl2);
+					}
 #endif
-					if (onready)
+					if (onready) {
 						p_class->ready->statements.push_back(op);
-					else
+					} else {
 						p_class->initializer->statements.push_back(op);
+					}
 
 					member.initial_assignment = op;
 
@@ -5360,10 +5414,12 @@ void GDScriptParser::_determine_inheritance(ClassNode *p_class, bool p_recursive
 					}
 				}
 
-				if (base_class)
+				if (base_class) {
 					break;
-				if (found)
+				}
+				if (found) {
 					continue;
+				}
 
 				if (p->constant_expressions.has(base)) {
 					if (p->constant_expressions[base].expression->type != Node::TYPE_CONSTANT) {
@@ -5457,12 +5513,14 @@ void GDScriptParser::_determine_inheritance(ClassNode *p_class, bool p_recursive
 }
 
 String GDScriptParser::DataType::to_string() const {
-	if (!has_type)
+	if (!has_type) {
 		return "var";
+	}
 	switch (kind) {
 		case BUILTIN: {
-			if (builtin_type == Variant::NIL)
+			if (builtin_type == Variant::NIL) {
 				return "null";
+			}
 			return Variant::get_type_name(builtin_type);
 		} break;
 		case NATIVE: {
@@ -5626,10 +5684,12 @@ bool GDScriptParser::_parse_type(DataType &r_type, bool p_can_be_void) {
 }
 
 GDScriptParser::DataType GDScriptParser::_resolve_type(const DataType &p_source, int p_line) {
-	if (!p_source.has_type)
+	if (!p_source.has_type) {
 		return p_source;
-	if (p_source.kind != DataType::UNRESOLVED)
+	}
+	if (p_source.kind != DataType::UNRESOLVED) {
 		return p_source;
+	}
 
 	Vector<String> full_name = p_source.native_type.operator String().split(".", false);
 	int name_part = 0;
@@ -6861,8 +6921,9 @@ bool GDScriptParser::_get_function_signature(DataType &p_base_type, const String
 		native = "_" + native.operator String();
 	}
 	if (!ClassDB::class_exists(native)) {
-		if (!check_types)
+		if (!check_types) {
 			return false;
+		}
 		ERR_FAIL_V_MSG(false, "Parser bug: Class '" + String(native) + "' not found.");
 	}
 
@@ -6953,8 +7014,9 @@ GDScriptParser::DataType GDScriptParser::_reduce_function_call_type(const Operat
 				par_types.write[i - 1] = _reduce_node_type(p_call->arguments[i]);
 			}
 
-			if (error_set)
+			if (error_set) {
 				return DataType();
+			}
 
 			// Special case: check copy constructor. Those are defined implicitly in Variant.
 			if (par_types.size() == 1) {
@@ -7022,8 +7084,9 @@ GDScriptParser::DataType GDScriptParser::_reduce_function_call_type(const Operat
 				err += "' matches the signature '";
 				err += Variant::get_type_name(tn->vtype) + "(";
 				for (int i = 0; i < par_types.size(); i++) {
-					if (i > 0)
+					if (i > 0) {
 						err += ", ";
+					}
 					err += par_types[i].to_string();
 				}
 				err += ")'.";
@@ -7263,8 +7326,9 @@ bool GDScriptParser::_get_member_type(const DataType &p_base_type, const StringN
 
 	while (base) {
 		if (base->constant_expressions.has(p_member)) {
-			if (r_is_const)
+			if (r_is_const) {
 				*r_is_const = true;
+			}
 			r_member_type = base->constant_expressions[p_member].expression->get_datatype();
 			return true;
 		}
@@ -7383,8 +7447,9 @@ bool GDScriptParser::_get_member_type(const DataType &p_base_type, const StringN
 		native = "_" + native.operator String();
 	}
 	if (!ClassDB::class_exists(native)) {
-		if (!check_types)
+		if (!check_types) {
 			return false;
+		}
 		ERR_FAIL_V_MSG(false, "Parser bug: Class \"" + String(native) + "\" not found.");
 	}
 
@@ -7680,14 +7745,16 @@ void GDScriptParser::_check_class_level_types(ClassNode *p_class) {
 	// Function declarations
 	for (int i = 0; i < p_class->static_functions.size(); i++) {
 		_check_function_types(p_class->static_functions[i]);
-		if (error_set)
+		if (error_set) {
 			return;
+		}
 	}
 
 	for (int i = 0; i < p_class->functions.size(); i++) {
 		_check_function_types(p_class->functions[i]);
-		if (error_set)
+		if (error_set) {
 			return;
+		}
 	}
 
 	// Class variables
@@ -7763,8 +7830,9 @@ void GDScriptParser::_check_class_level_types(ClassNode *p_class) {
 		}
 
 		// Setter and getter
-		if (v.setter == StringName() && v.getter == StringName())
+		if (v.setter == StringName() && v.getter == StringName()) {
 			continue;
+		}
 
 		bool found_getter = false;
 		bool found_setter = false;
@@ -7807,12 +7875,14 @@ void GDScriptParser::_check_class_level_types(ClassNode *p_class) {
 					return;
 				}
 			}
-			if (found_getter && found_setter)
+			if (found_getter && found_setter) {
 				break;
+			}
 		}
 
-		if ((found_getter || v.getter == StringName()) && (found_setter || v.setter == StringName()))
+		if ((found_getter || v.getter == StringName()) && (found_setter || v.setter == StringName())) {
 			continue;
+		}
 
 		// Check for static functions
 		for (int j = 0; j < p_class->static_functions.size(); j++) {
@@ -7843,8 +7913,9 @@ void GDScriptParser::_check_class_level_types(ClassNode *p_class) {
 	for (int i = 0; i < p_class->subclasses.size(); i++) {
 		current_class = p_class->subclasses[i];
 		_check_class_level_types(current_class);
-		if (error_set)
+		if (error_set) {
 			return;
+		}
 		current_class = p_class;
 	}
 }
@@ -7979,8 +8050,9 @@ void GDScriptParser::_check_class_blocks_types(ClassNode *p_class) {
 		_check_block_types(current_block);
 		current_block = nullptr;
 		current_function = nullptr;
-		if (error_set)
+		if (error_set) {
 			return;
+		}
 	}
 
 	for (int i = 0; i < p_class->functions.size(); i++) {
@@ -7990,8 +8062,9 @@ void GDScriptParser::_check_class_blocks_types(ClassNode *p_class) {
 		_check_block_types(current_block);
 		current_block = nullptr;
 		current_function = nullptr;
-		if (error_set)
+		if (error_set) {
 			return;
+		}
 	}
 
 #ifdef DEBUG_ENABLED
@@ -8012,8 +8085,9 @@ void GDScriptParser::_check_class_blocks_types(ClassNode *p_class) {
 	for (int i = 0; i < p_class->subclasses.size(); i++) {
 		current_class = p_class->subclasses[i];
 		_check_class_blocks_types(current_class);
-		if (error_set)
+		if (error_set) {
 			return;
+		}
 		current_class = p_class;
 	}
 }
@@ -8280,8 +8354,9 @@ void GDScriptParser::_check_block_types(BlockNode *p_block) {
 							_add_warning(GDScriptWarning::RETURN_VALUE_DISCARDED, op->line, func_name);
 						}
 #endif // DEBUG_ENABLED
-						if (error_set)
+						if (error_set) {
 							return;
+						}
 					} break;
 					case OperatorNode::OP_YIELD: {
 						_mark_line_as_safe(op->line);
@@ -8316,8 +8391,9 @@ void GDScriptParser::_check_block_types(BlockNode *p_block) {
 							}
 						}
 
-						if (!function_type.has_type)
+						if (!function_type.has_type) {
 							break;
+						}
 
 						if (function_type.kind == DataType::BUILTIN && function_type.builtin_type == Variant::NIL) {
 							// Return void, should not have arguments
@@ -8377,8 +8453,9 @@ void GDScriptParser::_check_block_types(BlockNode *p_block) {
 		current_block = p_block->sub_blocks[i];
 		_check_block_types(current_block);
 		current_block = p_block;
-		if (error_set)
+		if (error_set) {
 			return;
+		}
 	}
 
 #ifdef DEBUG_ENABLED
@@ -8397,8 +8474,9 @@ void GDScriptParser::_check_block_types(BlockNode *p_block) {
 }
 
 void GDScriptParser::_set_error(const String &p_error, int p_line, int p_column) {
-	if (error_set)
+	if (error_set) {
 		return; //allow no further errors
+	}
 
 	error = p_error;
 	error_line = p_line < 0 ? tokenizer->get_token_line() : p_line;
@@ -8517,8 +8595,9 @@ Error GDScriptParser::_parse(const String &p_base_path) {
 	current_function = nullptr;
 	current_block = nullptr;
 
-	if (for_completion)
+	if (for_completion) {
 		check_types = false;
+	}
 
 	// Resolve all class-level stuff before getting into function blocks
 	_check_class_level_types(main_class);
diff --git a/modules/gdscript/gdscript_parser.h b/modules/gdscript/gdscript_parser.h
index 4332fa7569..cfcca9584e 100644
--- a/modules/gdscript/gdscript_parser.h
+++ b/modules/gdscript/gdscript_parser.h
@@ -641,14 +641,16 @@ private:
 	void _check_block_types(BlockNode *p_block);
 	_FORCE_INLINE_ void _mark_line_as_safe(int p_line) const {
 #ifdef DEBUG_ENABLED
-		if (safe_lines)
+		if (safe_lines) {
 			safe_lines->insert(p_line);
+		}
 #endif // DEBUG_ENABLED
 	}
 	_FORCE_INLINE_ void _mark_line_as_unsafe(int p_line) const {
 #ifdef DEBUG_ENABLED
-		if (safe_lines)
+		if (safe_lines) {
 			safe_lines->erase(p_line);
+		}
 #endif // DEBUG_ENABLED
 	}
 
diff --git a/modules/gdscript/gdscript_tokenizer.cpp b/modules/gdscript/gdscript_tokenizer.cpp
index 9854b8d185..2db42601c6 100644
--- a/modules/gdscript/gdscript_tokenizer.cpp
+++ b/modules/gdscript/gdscript_tokenizer.cpp
@@ -574,8 +574,9 @@ void GDScriptTokenizerText::_advance() {
 					_make_token(TK_OP_EQUAL);
 					INCPOS(1);
 
-				} else
+				} else {
 					_make_token(TK_OP_ASSIGN);
+				}
 
 			} break;
 			case '<': {
@@ -590,8 +591,9 @@ void GDScriptTokenizerText::_advance() {
 						_make_token(TK_OP_SHIFT_LEFT);
 					}
 					INCPOS(1);
-				} else
+				} else {
 					_make_token(TK_OP_LESS);
+				}
 
 			} break;
 			case '>': {
@@ -741,8 +743,9 @@ void GDScriptTokenizerText::_advance() {
 				[[fallthrough]];
 			case '\'':
 			case '"': {
-				if (GETCHAR(0) == '\'')
+				if (GETCHAR(0) == '\'') {
 					string_mode = STRING_SINGLE_QUOTE;
+				}
 
 				int i = 1;
 				if (string_mode == STRING_DOUBLE_QUOTE && GETCHAR(i) == '"' && GETCHAR(i + 1) == '"') {
@@ -851,8 +854,9 @@ void GDScriptTokenizerText::_advance() {
 							} break;
 						}
 
-						if (next != '\n')
+						if (next != '\n') {
 							str += res;
+						}
 
 					} else {
 						if (CharType(GETCHAR(i)) == '\n') {
@@ -933,8 +937,9 @@ void GDScriptTokenizerText::_advance() {
 						} else if (GETCHAR(i) == '_') {
 							i++;
 							continue; // Included for readability, shouldn't be a part of the string
-						} else
+						} else {
 							break;
+						}
 
 						str += CharType(GETCHAR(i));
 						i++;
@@ -1034,8 +1039,9 @@ void GDScriptTokenizerText::_advance() {
 							}
 						}
 
-						if (!found)
+						if (!found) {
 							identifier = true;
+						}
 					}
 
 					if (identifier) {
@@ -1073,8 +1079,9 @@ void GDScriptTokenizerText::set_code(const String &p_code) {
 	ignore_warnings = false;
 #endif // DEBUG_ENABLED
 	last_error = "";
-	for (int i = 0; i < MAX_LOOKAHEAD + 1; i++)
+	for (int i = 0; i < MAX_LOOKAHEAD + 1; i++) {
 		_advance();
+	}
 }
 
 GDScriptTokenizerText::Token GDScriptTokenizerText::get_token(int p_offset) const {
@@ -1166,8 +1173,9 @@ String GDScriptTokenizerText::get_token_error(int p_offset) const {
 
 void GDScriptTokenizerText::advance(int p_amount) {
 	ERR_FAIL_COND(p_amount <= 0);
-	for (int i = 0; i < p_amount; i++)
+	for (int i = 0; i < p_amount; i++) {
 		_advance();
+	}
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1215,8 +1223,9 @@ Error GDScriptTokenizerBuffer::set_code_buffer(const Vector<uint8_t> &p_buffer)
 		int len;
 		// An object cannot be constant, never decode objects
 		Error err = decode_variant(v, b, total_len, &len, false);
-		if (err)
+		if (err) {
 			return err;
+		}
 		b += len;
 		total_len -= len;
 		constants.write[i] = v;
@@ -1311,8 +1320,9 @@ Vector<uint8_t> GDScriptTokenizerBuffer::parse_code_string(const String &p_code)
 
 		token_array.push_back(token);
 
-		if (tt.get_token() == TK_EOF)
+		if (tt.get_token() == TK_EOF) {
 			break;
+		}
 		tt.advance();
 	}
 
@@ -1352,8 +1362,9 @@ Vector<uint8_t> GDScriptTokenizerBuffer::parse_code_string(const String &p_code)
 		CharString cs = String(E->get()).utf8();
 		int len = cs.length() + 1;
 		int extra = 4 - (len % 4);
-		if (extra == 4)
+		if (extra == 4) {
 			extra = 0;
+		}
 
 		uint8_t ibuf[4];
 		encode_uint32(len + extra, ibuf);
@@ -1382,8 +1393,9 @@ Vector<uint8_t> GDScriptTokenizerBuffer::parse_code_string(const String &p_code)
 		uint8_t ibuf[8];
 		encode_uint32(E->key(), &ibuf[0]);
 		encode_uint32(E->get(), &ibuf[4]);
-		for (int i = 0; i < 8; i++)
+		for (int i = 0; i < 8; i++) {
 			buf.push_back(ibuf[i]);
+		}
 	}
 
 	for (int i = 0; i < token_array.size(); i++) {
@@ -1406,8 +1418,9 @@ Vector<uint8_t> GDScriptTokenizerBuffer::parse_code_string(const String &p_code)
 GDScriptTokenizerBuffer::Token GDScriptTokenizerBuffer::get_token(int p_offset) const {
 	int offset = token + p_offset;
 
-	if (offset < 0 || offset >= tokens.size())
+	if (offset < 0 || offset >= tokens.size()) {
 		return TK_EOF;
+	}
 
 	return GDScriptTokenizerBuffer::Token(tokens[offset] & TOKEN_MASK);
 }
@@ -1439,10 +1452,12 @@ int GDScriptTokenizerBuffer::get_token_line(int p_offset) const {
 	int offset = token + p_offset;
 	int pos = lines.find_nearest(offset);
 
-	if (pos < 0)
+	if (pos < 0) {
 		return -1;
-	if (pos >= lines.size())
+	}
+	if (pos >= lines.size()) {
 		pos = lines.size() - 1;
+	}
 
 	uint32_t l = lines.getv(pos);
 	return l & TOKEN_LINE_MASK;
@@ -1451,10 +1466,12 @@ int GDScriptTokenizerBuffer::get_token_line(int p_offset) const {
 int GDScriptTokenizerBuffer::get_token_column(int p_offset) const {
 	int offset = token + p_offset;
 	int pos = lines.find_nearest(offset);
-	if (pos < 0)
+	if (pos < 0) {
 		return -1;
-	if (pos >= lines.size())
+	}
+	if (pos >= lines.size()) {
 		pos = lines.size() - 1;
+	}
 
 	uint32_t l = lines.getv(pos);
 	return l >> TOKEN_LINE_BITS;
diff --git a/modules/gdscript/language_server/gdscript_extend_parser.cpp b/modules/gdscript/language_server/gdscript_extend_parser.cpp
index 9338dcadbe..f87e8687e5 100644
--- a/modules/gdscript/language_server/gdscript_extend_parser.cpp
+++ b/modules/gdscript/language_server/gdscript_extend_parser.cpp
@@ -144,8 +144,9 @@ void ExtendGDScriptParser::parse_class_symbol(const GDScriptParser::ClassNode *p
 	r_symbol.script_path = path;
 	r_symbol.children.clear();
 	r_symbol.name = p_class->name;
-	if (r_symbol.name.empty())
+	if (r_symbol.name.empty()) {
 		r_symbol.name = path.get_file();
+	}
 	r_symbol.kind = lsp::SymbolKind::Class;
 	r_symbol.deprecated = false;
 	r_symbol.range.start.line = LINE_NUMBER_TO_INDEX(p_class->line);
@@ -378,8 +379,9 @@ String ExtendGDScriptParser::parse_documentation(int p_line, bool p_docs_down) {
 	int step = p_docs_down ? 1 : -1;
 	int start_line = p_docs_down ? p_line : p_line - 1;
 	for (int i = start_line; true; i += step) {
-		if (i < 0 || i >= lines.size())
+		if (i < 0 || i >= lines.size()) {
 			break;
+		}
 
 		String line_comment = lines[i].strip_edges(true, false);
 		if (line_comment.begins_with("#")) {
@@ -413,8 +415,9 @@ String ExtendGDScriptParser::get_text_for_completion(const lsp::Position &p_curs
 			longthing += lines[i];
 		}
 
-		if (i != len - 1)
+		if (i != len - 1) {
 			longthing += "\n";
+		}
 	}
 
 	return longthing;
@@ -450,8 +453,9 @@ String ExtendGDScriptParser::get_text_for_lookup_symbol(const lsp::Position &p_c
 			longthing += lines[i];
 		}
 
-		if (i != len - 1)
+		if (i != len - 1) {
 			longthing += "\n";
+		}
 	}
 
 	return longthing;
diff --git a/modules/gdscript/language_server/gdscript_language_protocol.cpp b/modules/gdscript/language_server/gdscript_language_protocol.cpp
index c5bce5bb87..35bf4287b8 100644
--- a/modules/gdscript/language_server/gdscript_language_protocol.cpp
+++ b/modules/gdscript/language_server/gdscript_language_protocol.cpp
@@ -47,10 +47,11 @@ Error GDScriptLanguageProtocol::LSPeer::handle_data() {
 				ERR_FAIL_COND_V_MSG(true, ERR_OUT_OF_MEMORY, "Response header too big");
 			}
 			Error err = connection->get_partial_data(&req_buf[req_pos], 1, read);
-			if (err != OK)
+			if (err != OK) {
 				return FAILED;
-			else if (read != 1) // Busy, wait until next poll
+			} else if (read != 1) { // Busy, wait until next poll
 				return ERR_BUSY;
+			}
 			char *r = (char *)req_buf;
 			int l = req_pos;
 
@@ -75,10 +76,11 @@ Error GDScriptLanguageProtocol::LSPeer::handle_data() {
 				ERR_FAIL_COND_V_MSG(req_pos >= LSP_MAX_BUFFER_SIZE, ERR_OUT_OF_MEMORY, "Response content too big");
 			}
 			Error err = connection->get_partial_data(&req_buf[req_pos], 1, read);
-			if (err != OK)
+			if (err != OK) {
 				return FAILED;
-			else if (read != 1)
+			} else if (read != 1) {
 				return ERR_BUSY;
+			}
 			req_pos++;
 		}
 
diff --git a/modules/gdscript/language_server/gdscript_workspace.cpp b/modules/gdscript/language_server/gdscript_workspace.cpp
index 7c432bfc80..9285d88157 100644
--- a/modules/gdscript/language_server/gdscript_workspace.cpp
+++ b/modules/gdscript/language_server/gdscript_workspace.cpp
@@ -184,8 +184,9 @@ Array GDScriptWorkspace::symbol(const Dictionary &p_params) {
 }
 
 Error GDScriptWorkspace::initialize() {
-	if (initialized)
+	if (initialized) {
 		return OK;
+	}
 
 	DocData *doc = EditorHelp::get_doc_data();
 	for (Map<String, DocData::ClassDoc>::Element *E = doc->class_list.front(); E; E = E->next()) {
@@ -374,8 +375,9 @@ void GDScriptWorkspace::publish_diagnostics(const String &p_path) {
 }
 
 void GDScriptWorkspace::_get_owners(EditorFileSystemDirectory *efsd, String p_path, List<String> &owners) {
-	if (!efsd)
+	if (!efsd) {
 		return;
+	}
 
 	for (int i = 0; i < efsd->get_subdir_count(); i++) {
 		_get_owners(efsd->get_subdir(i), p_path, owners);
@@ -390,8 +392,9 @@ void GDScriptWorkspace::_get_owners(EditorFileSystemDirectory *efsd, String p_pa
 				break;
 			}
 		}
-		if (!found)
+		if (!found) {
 			continue;
+		}
 
 		owners.push_back(efsd->get_file_path(i));
 	}
diff --git a/modules/gdscript/language_server/lsp.hpp b/modules/gdscript/language_server/lsp.hpp
index f979171b6e..44a0076107 100644
--- a/modules/gdscript/language_server/lsp.hpp
+++ b/modules/gdscript/language_server/lsp.hpp
@@ -280,8 +280,9 @@ struct Command {
 		Dictionary dict;
 		dict["title"] = title;
 		dict["command"] = command;
-		if (arguments.size())
+		if (arguments.size()) {
 			dict["arguments"] = arguments;
+		}
 		return dict;
 	}
 };
@@ -945,20 +946,24 @@ struct CompletionItem {
 			dict["preselect"] = preselect;
 			dict["sortText"] = sortText;
 			dict["filterText"] = filterText;
-			if (commitCharacters.size())
+			if (commitCharacters.size()) {
 				dict["commitCharacters"] = commitCharacters;
+			}
 			dict["command"] = command.to_json();
 		}
 		return dict;
 	}
 
 	void load(const Dictionary &p_dict) {
-		if (p_dict.has("label"))
+		if (p_dict.has("label")) {
 			label = p_dict["label"];
-		if (p_dict.has("kind"))
+		}
+		if (p_dict.has("kind")) {
 			kind = p_dict["kind"];
-		if (p_dict.has("detail"))
+		}
+		if (p_dict.has("detail")) {
 			detail = p_dict["detail"];
+		}
 		if (p_dict.has("documentation")) {
 			Variant doc = p_dict["documentation"];
 			if (doc.get_type() == Variant::STRING) {
@@ -968,18 +973,24 @@ struct CompletionItem {
 				documentation.value = v["value"];
 			}
 		}
-		if (p_dict.has("deprecated"))
+		if (p_dict.has("deprecated")) {
 			deprecated = p_dict["deprecated"];
-		if (p_dict.has("preselect"))
+		}
+		if (p_dict.has("preselect")) {
 			preselect = p_dict["preselect"];
-		if (p_dict.has("sortText"))
+		}
+		if (p_dict.has("sortText")) {
 			sortText = p_dict["sortText"];
-		if (p_dict.has("filterText"))
+		}
+		if (p_dict.has("filterText")) {
 			filterText = p_dict["filterText"];
-		if (p_dict.has("insertText"))
+		}
+		if (p_dict.has("insertText")) {
 			insertText = p_dict["insertText"];
-		if (p_dict.has("data"))
+		}
+		if (p_dict.has("data")) {
 			data = p_dict["data"];
+		}
 	}
 };
 
diff --git a/modules/gdscript/register_types.cpp b/modules/gdscript/register_types.cpp
index 161ab692c9..0625123530 100644
--- a/modules/gdscript/register_types.cpp
+++ b/modules/gdscript/register_types.cpp
@@ -68,12 +68,14 @@ public:
 			script_key = preset->get_script_encryption_key().to_lower();
 		}
 
-		if (!p_path.ends_with(".gd") || script_mode == EditorExportPreset::MODE_SCRIPT_TEXT)
+		if (!p_path.ends_with(".gd") || script_mode == EditorExportPreset::MODE_SCRIPT_TEXT) {
 			return;
+		}
 
 		Vector<uint8_t> file = FileAccess::get_file_as_array(p_path);
-		if (file.empty())
+		if (file.empty()) {
 			return;
+		}
 
 		String txt;
 		txt.parse_utf8((const char *)file.ptr(), file.size());
@@ -90,19 +92,21 @@ public:
 					int v = 0;
 					if (i * 2 < script_key.length()) {
 						CharType ct = script_key[i * 2];
-						if (ct >= '0' && ct <= '9')
+						if (ct >= '0' && ct <= '9') {
 							ct = ct - '0';
-						else if (ct >= 'a' && ct <= 'f')
+						} else if (ct >= 'a' && ct <= 'f') {
 							ct = 10 + ct - 'a';
+						}
 						v |= ct << 4;
 					}
 
 					if (i * 2 + 1 < script_key.length()) {
 						CharType ct = script_key[i * 2 + 1];
-						if (ct >= '0' && ct <= '9')
+						if (ct >= '0' && ct <= '9') {
 							ct = ct - '0';
-						else if (ct >= 'a' && ct <= 'f')
+						} else if (ct >= 'a' && ct <= 'f') {
 							ct = 10 + ct - 'a';
+						}
 						v |= ct;
 					}
 					key.write[i] = v;
@@ -166,8 +170,9 @@ void register_gdscript_types() {
 void unregister_gdscript_types() {
 	ScriptServer::unregister_language(script_language_gd);
 
-	if (script_language_gd)
+	if (script_language_gd) {
 		memdelete(script_language_gd);
+	}
 
 	ResourceLoader::remove_resource_format_loader(resource_loader_gd);
 	resource_loader_gd.unref();
-- 
cgit v1.2.3