Style: clang-format: Disable AllowShortIfStatementsOnASingleLine

Part of #33027, also discussed in #29848.

Enforcing the use of brackets even on single line statements would be
preferred, but `clang-format` doesn't have this functionality yet.

130 files changed, 969 insertions, 513 deletions

diff --git a/.clang-format b/.clang-format
index b3f1954545..0ec0af54bc 100644
--- a/.clang-format
+++ b/.clang-format
@@ -15,7 +15,7 @@ AllowAllParametersOfDeclarationOnNextLine: false
 # AllowShortBlocksOnASingleLine: false
 AllowShortCaseLabelsOnASingleLine: true
 AllowShortFunctionsOnASingleLine: Inline
-AllowShortIfStatementsOnASingleLine: true
+# AllowShortIfStatementsOnASingleLine: false
 # AllowShortLoopsOnASingleLine: false
 # AlwaysBreakAfterDefinitionReturnType: None
 # AlwaysBreakAfterReturnType: None
diff --git a/core/class_db.cpp b/core/class_db.cpp
index 5e49688e9b..ee93ac73ae 100644
--- a/core/class_db.cpp
+++ b/core/class_db.cpp
@@ -1456,16 +1456,19 @@ Variant ClassDB::class_get_default_property_value(const StringName &p_class, con
 	}
 
 	if (!default_values.has(p_class)) {
-		if (r_valid != nullptr) *r_valid = false;
+		if (r_valid != nullptr)
+			*r_valid = false;
 		return Variant();
 	}
 
 	if (!default_values[p_class].has(p_property)) {
-		if (r_valid != nullptr) *r_valid = false;
+		if (r_valid != nullptr)
+			*r_valid = false;
 		return Variant();
 	}
 
-	if (r_valid != nullptr) *r_valid = true;
+	if (r_valid != nullptr)
+		*r_valid = true;
 	return default_values[p_class][p_property];
 }
 
diff --git a/core/color.cpp b/core/color.cpp
index 03aeb2085b..79b9f70a99 100644
--- a/core/color.cpp
+++ b/core/color.cpp
@@ -406,7 +406,8 @@ bool Color::html_is_valid(const String &p_color) {
 }
 
 Color Color::named(const String &p_name) {
-	if (_named_colors.empty()) _populate_named_colors(); // from color_names.inc
+	if (_named_colors.empty())
+		_populate_named_colors(); // from color_names.inc
 	String name = p_name;
 	// Normalize name
 	name = name.replace(" ", "");
diff --git a/core/color_names.inc b/core/color_names.inc
index 428a8473fe..f249ee9868 100644
--- a/core/color_names.inc
+++ b/core/color_names.inc
@@ -3,7 +3,8 @@
 
 static Map<String, Color> _named_colors;
 static void _populate_named_colors() {
-	if (!_named_colors.empty()) return;
+	if (!_named_colors.empty())
+		return;
 	_named_colors.insert("aliceblue", Color(0.94, 0.97, 1.00));
 	_named_colors.insert("antiquewhite", Color(0.98, 0.92, 0.84));
 	_named_colors.insert("aqua", Color(0.00, 1.00, 1.00));
diff --git a/core/command_queue_mt.h b/core/command_queue_mt.h
index 558453bdf5..2f2b3b783c 100644
--- a/core/command_queue_mt.h
+++ b/core/command_queue_mt.h
@@ -253,7 +253,8 @@
 		cmd->method = p_method;                                              \
 		SEMIC_SEP_LIST(CMD_ASSIGN_PARAM, N);                                 \
 		unlock();                                                            \
-		if (sync) sync->post();                                              \
+		if (sync)                                                            \
+			sync->post();                                                    \
 	}
 
 #define CMD_RET_TYPE(N) CommandRet##N<T, M, COMMA_SEP_LIST(TYPE_ARG, N) COMMA(N) R>
@@ -269,7 +270,8 @@
 		cmd->ret = r_ret;                                                                      \
 		cmd->sync_sem = ss;                                                                    \
 		unlock();                                                                              \
-		if (sync) sync->post();                                                                \
+		if (sync)                                                                              \
+			sync->post();                                                                      \
 		ss->sem.wait();                                                                        \
 		ss->in_use = false;                                                                    \
 	}
@@ -286,7 +288,8 @@
 		SEMIC_SEP_LIST(CMD_ASSIGN_PARAM, N);                                          \
 		cmd->sync_sem = ss;                                                           \
 		unlock();                                                                     \
-		if (sync) sync->post();                                                       \
+		if (sync)                                                                     \
+			sync->post();                                                             \
 		ss->sem.wait();                                                               \
 		ss->in_use = false;                                                           \
 	}
@@ -418,12 +421,14 @@ class CommandQueueMT {
 	}
 
 	bool flush_one(bool p_lock = true) {
-		if (p_lock) lock();
+		if (p_lock)
+			lock();
 	tryagain:
 
 		// tried to read an empty queue
 		if (read_ptr == write_ptr) {
-			if (p_lock) unlock();
+			if (p_lock)
+				unlock();
 			return false;
 		}
 
@@ -442,15 +447,18 @@ class CommandQueueMT {
 
 		read_ptr += size;
 
-		if (p_lock) unlock();
+		if (p_lock)
+			unlock();
 		cmd->call();
-		if (p_lock) lock();
+		if (p_lock)
+			lock();
 
 		cmd->post();
 		cmd->~CommandBase();
 		*(uint32_t *)&command_mem[size_ptr] &= ~1;
 
-		if (p_lock) unlock();
+		if (p_lock)
+			unlock();
 		return true;
 	}
 
diff --git a/core/image.cpp b/core/image.cpp
index 58351ae2e5..f696233b7a 100644
--- a/core/image.cpp
+++ b/core/image.cpp
@@ -3152,11 +3152,13 @@ void Image::bumpmap_to_normalmap(float bump_scale) {
 
 		for (int ty = 0; ty < height; ty++) {
 			int py = ty + 1;
-			if (py >= height) py -= height;
+			if (py >= height)
+				py -= height;
 
 			for (int tx = 0; tx < width; tx++) {
 				int px = tx + 1;
-				if (px >= width) px -= width;
+				if (px >= width)
+					px -= width;
 				float here = read_ptr[ty * width + tx];
 				float to_right = read_ptr[ty * width + px];
 				float above = read_ptr[py * width + tx];
diff --git a/core/io/file_access_pack.cpp b/core/io/file_access_pack.cpp
index 0a7dee9444..fd9b83eaf9 100644
--- a/core/io/file_access_pack.cpp
+++ b/core/io/file_access_pack.cpp
@@ -414,7 +414,8 @@ Error DirAccessPack::change_dir(String p_dir) {
 
 	nd = nd.simplify_path();
 
-	if (nd == "") nd = ".";
+	if (nd == "")
+		nd = ".";
 
 	if (nd.begins_with("/")) {
 		nd = nd.replace_first("/", "");
diff --git a/core/io/ip_address.h b/core/io/ip_address.h
index 89cf37ff8f..a59178063d 100644
--- a/core/io/ip_address.h
+++ b/core/io/ip_address.h
@@ -52,16 +52,20 @@ protected:
 public:
 	//operator Variant() const;
 	bool operator==(const IP_Address &p_ip) const {
-		if (p_ip.valid != valid) return false;
-		if (!valid) return false;
+		if (p_ip.valid != valid)
+			return false;
+		if (!valid)
+			return false;
 		for (int i = 0; i < 4; i++)
 			if (field32[i] != p_ip.field32[i])
 				return false;
 		return true;
 	}
 	bool operator!=(const IP_Address &p_ip) const {
-		if (p_ip.valid != valid) return true;
-		if (!valid) return true;
+		if (p_ip.valid != valid)
+			return true;
+		if (!valid)
+			return true;
 		for (int i = 0; i < 4; i++)
 			if (field32[i] != p_ip.field32[i])
 				return true;
diff --git a/core/io/marshalls.h b/core/io/marshalls.h
index d029ed238c..650c95364a 100644
--- a/core/io/marshalls.h
+++ b/core/io/marshalls.h
@@ -121,7 +121,8 @@ static inline int encode_cstring(const char *p_string, uint8_t *p_data) {
 		len++;
 	};
 
-	if (p_data) *p_data = 0;
+	if (p_data)
+		*p_data = 0;
 	return len + 1;
 }
 
diff --git a/core/io/multiplayer_api.cpp b/core/io/multiplayer_api.cpp
index 3bec52416e..94e2fdb72c 100644
--- a/core/io/multiplayer_api.cpp
+++ b/core/io/multiplayer_api.cpp
@@ -144,7 +144,8 @@ void MultiplayerAPI::set_root_node(Node *p_node) {
 
 void MultiplayerAPI::set_network_peer(const Ref<NetworkedMultiplayerPeer> &p_peer) {
 
-	if (p_peer == network_peer) return; // Nothing to do
+	if (p_peer == network_peer)
+		return; // Nothing to do
 
 	ERR_FAIL_COND_MSG(p_peer.is_valid() && p_peer->get_connection_status() == NetworkedMultiplayerPeer::CONNECTION_DISCONNECTED,
 			"Supplied NetworkedMultiplayerPeer must be connecting or connected.");
@@ -787,8 +788,9 @@ void MultiplayerAPI::_send_rpc(Node *p_from, int p_to, bool p_unreliable, bool p
 
 	int ofs = 0;
 
-#define MAKE_ROOM(m_amount) \
-	if (packet_cache.size() < m_amount) packet_cache.resize(m_amount);
+#define MAKE_ROOM(m_amount)             \
+	if (packet_cache.size() < m_amount) \
+		packet_cache.resize(m_amount);
 
 	// Encode meta.
 	// The meta is composed by a single byte that contains (starting from the least segnificant bit):
diff --git a/core/io/resource_loader.h b/core/io/resource_loader.h
index 2d95d5545f..b10c08d693 100644
--- a/core/io/resource_loader.h
+++ b/core/io/resource_loader.h
@@ -160,7 +160,8 @@ public:
 	static bool get_timestamp_on_load() { return timestamp_on_load; }
 
 	static void notify_load_error(const String &p_err) {
-		if (err_notify) err_notify(err_notify_ud, p_err);
+		if (err_notify)
+			err_notify(err_notify_ud, p_err);
 	}
 	static void set_error_notify_func(void *p_ud, ResourceLoadErrorNotify p_err_notify) {
 		err_notify = p_err_notify;
@@ -168,7 +169,8 @@ public:
 	}
 
 	static void notify_dependency_error(const String &p_path, const String &p_dependency, const String &p_type) {
-		if (dep_err_notify) dep_err_notify(dep_err_notify_ud, p_path, p_dependency, p_type);
+		if (dep_err_notify)
+			dep_err_notify(dep_err_notify_ud, p_path, p_dependency, p_type);
 	}
 	static void set_dependency_error_notify_func(void *p_ud, DependencyErrorNotify p_err_notify) {
 		dep_err_notify = p_err_notify;
diff --git a/core/list.h b/core/list.h
index be2dccd876..65d45ffdfc 100644
--- a/core/list.h
+++ b/core/list.h
@@ -353,7 +353,8 @@ public:
 
 		Element *it = front();
 		while (it) {
-			if (it->value == p_val) return it;
+			if (it->value == p_val)
+				return it;
 			it = it->next();
 		};
 
diff --git a/core/math/a_star.cpp b/core/math/a_star.cpp
index 3e3e6c50a7..3aba753f51 100644
--- a/core/math/a_star.cpp
+++ b/core/math/a_star.cpp
@@ -164,7 +164,8 @@ void AStar::connect_points(int p_id, int p_with_id, bool bidirectional) {
 	}
 
 	Segment s(p_id, p_with_id);
-	if (bidirectional) s.direction = Segment::BIDIRECTIONAL;
+	if (bidirectional)
+		s.direction = Segment::BIDIRECTIONAL;
 
 	Set<Segment>::Element *element = segments.find(s);
 	if (element != nullptr) {
@@ -290,7 +291,8 @@ int AStar::get_closest_point(const Vector3 &p_point, bool p_include_disabled) co
 
 	for (OAHashMap<int, Point *>::Iterator it = points.iter(); it.valid; it = points.next_iter(it)) {
 
-		if (!p_include_disabled && !(*it.value)->enabled) continue; // Disabled points should not be considered.
+		if (!p_include_disabled && !(*it.value)->enabled)
+			continue; // Disabled points should not be considered.
 
 		real_t d = p_point.distance_squared_to((*it.value)->pos);
 		if (closest_id < 0 || d < closest_dist) {
@@ -340,7 +342,8 @@ bool AStar::_solve(Point *begin_point, Point *end_point) {
 
 	pass++;
 
-	if (!end_point->enabled) return false;
+	if (!end_point->enabled)
+		return false;
 
 	bool found_route = false;
 
@@ -451,7 +454,8 @@ Vector<Vector3> AStar::get_point_path(int p_from_id, int p_to_id) {
 	Point *end_point = b;
 
 	bool found_route = _solve(begin_point, end_point);
-	if (!found_route) return Vector<Vector3>();
+	if (!found_route)
+		return Vector<Vector3>();
 
 	Point *p = end_point;
 	int pc = 1; // Begin point
@@ -499,7 +503,8 @@ Vector<int> AStar::get_id_path(int p_from_id, int p_to_id) {
 	Point *end_point = b;
 
 	bool found_route = _solve(begin_point, end_point);
-	if (!found_route) return Vector<int>();
+	if (!found_route)
+		return Vector<int>();
 
 	Point *p = end_point;
 	int pc = 1; // Begin point
@@ -729,7 +734,8 @@ Vector<Vector2> AStar2D::get_point_path(int p_from_id, int p_to_id) {
 	AStar::Point *end_point = b;
 
 	bool found_route = _solve(begin_point, end_point);
-	if (!found_route) return Vector<Vector2>();
+	if (!found_route)
+		return Vector<Vector2>();
 
 	AStar::Point *p = end_point;
 	int pc = 1; // Begin point
@@ -777,7 +783,8 @@ Vector<int> AStar2D::get_id_path(int p_from_id, int p_to_id) {
 	AStar::Point *end_point = b;
 
 	bool found_route = _solve(begin_point, end_point);
-	if (!found_route) return Vector<int>();
+	if (!found_route)
+		return Vector<int>();
 
 	AStar::Point *p = end_point;
 	int pc = 1; // Begin point
@@ -809,7 +816,8 @@ bool AStar2D::_solve(AStar::Point *begin_point, AStar::Point *end_point) {
 
 	astar.pass++;
 
-	if (!end_point->enabled) return false;
+	if (!end_point->enabled)
+		return false;
 
 	bool found_route = false;
 
diff --git a/core/math/basis.cpp b/core/math/basis.cpp
index 0f519a20d8..87abf2dbc1 100644
--- a/core/math/basis.cpp
+++ b/core/math/basis.cpp
@@ -783,7 +783,8 @@ void Basis::get_axis_angle(Vector3 &r_axis, real_t &r_angle) const {
 	real_t s = Math::sqrt((elements[1][2] - elements[2][1]) * (elements[1][2] - elements[2][1]) + (elements[2][0] - elements[0][2]) * (elements[2][0] - elements[0][2]) + (elements[0][1] - elements[1][0]) * (elements[0][1] - elements[1][0])); // s=|axis||sin(angle)|, used to normalise
 
 	angle = Math::acos((elements[0][0] + elements[1][1] + elements[2][2] - 1) / 2);
-	if (angle < 0) s = -s;
+	if (angle < 0)
+		s = -s;
 	x = (elements[2][1] - elements[1][2]) / s;
 	y = (elements[0][2] - elements[2][0]) / s;
 	z = (elements[1][0] - elements[0][1]) / s;
diff --git a/core/math/camera_matrix.cpp b/core/math/camera_matrix.cpp
index d2b20ac514..a091b5d00d 100644
--- a/core/math/camera_matrix.cpp
+++ b/core/math/camera_matrix.cpp
@@ -473,20 +473,23 @@ void CameraMatrix::invert() {
 
 		/** Divide column by minus pivot value **/
 		for (i = 0; i < 4; i++) {
-			if (i != k) matrix[i][k] /= (-pvt_val);
+			if (i != k)
+				matrix[i][k] /= (-pvt_val);
 		}
 
 		/** Reduce the matrix **/
 		for (i = 0; i < 4; i++) {
 			hold = matrix[i][k];
 			for (j = 0; j < 4; j++) {
-				if (i != k && j != k) matrix[i][j] += hold * matrix[k][j];
+				if (i != k && j != k)
+					matrix[i][j] += hold * matrix[k][j];
 			}
 		}
 
 		/** Divide row by pivot **/
 		for (j = 0; j < 4; j++) {
-			if (j != k) matrix[k][j] /= pvt_val;
+			if (j != k)
+				matrix[k][j] /= pvt_val;
 		}
 
 		/** Replace pivot by reciprocal (at last we can touch it). **/
diff --git a/core/math/geometry.h b/core/math/geometry.h
index ea063a8a59..3bbd1911ee 100644
--- a/core/math/geometry.h
+++ b/core/math/geometry.h
@@ -113,10 +113,14 @@ public:
 		real_t mub = (d_of(p1, q1, q2, q1) + mua * d_of(q2, q1, p2, p1)) / d_of(q2, q1, q2, q1);
 
 		// Clip the value between [0..1] constraining the solution to lie on the original curves.
-		if (mua < 0) mua = 0;
-		if (mub < 0) mub = 0;
-		if (mua > 1) mua = 1;
-		if (mub > 1) mub = 1;
+		if (mua < 0)
+			mua = 0;
+		if (mub < 0)
+			mub = 0;
+		if (mua > 1)
+			mua = 1;
+		if (mub > 1)
+			mub = 1;
 		c1 = p1.lerp(p2, mua);
 		c2 = q1.lerp(q2, mub);
 	}
@@ -497,7 +501,8 @@ public:
 
 		bool orientation = an.cross(bn) > 0;
 
-		if ((bn.cross(cn) > 0) != orientation) return false;
+		if ((bn.cross(cn) > 0) != orientation)
+			return false;
 
 		return (cn.cross(an) > 0) == orientation;
 	}
@@ -683,7 +688,8 @@ public:
 
 		// If the term we intend to square root is less than 0 then the answer won't be real,
 		// so it definitely won't be t in the range 0 to 1.
-		if (sqrtterm < 0) return -1;
+		if (sqrtterm < 0)
+			return -1;
 
 		// If we can assume that the line segment starts outside the circle (e.g. for continuous time collision detection)
 		// then the following can be skipped and we can just return the equivalent of res1.
@@ -691,8 +697,10 @@ public:
 		real_t res1 = (-b - sqrtterm) / (2 * a);
 		real_t res2 = (-b + sqrtterm) / (2 * a);
 
-		if (res1 >= 0 && res1 <= 1) return res1;
-		if (res2 >= 0 && res2 <= 1) return res2;
+		if (res1 >= 0 && res1 <= 1)
+			return res1;
+		if (res2 >= 0 && res2 <= 1)
+			return res2;
 		return -1;
 	}
 
diff --git a/core/math/math_funcs.h b/core/math/math_funcs.h
index 3e1eb14a6a..bd13c82894 100644
--- a/core/math/math_funcs.h
+++ b/core/math/math_funcs.h
@@ -233,12 +233,14 @@ public:
 	static _ALWAYS_INLINE_ float range_lerp(float p_value, float p_istart, float p_istop, float p_ostart, float p_ostop) { return Math::lerp(p_ostart, p_ostop, Math::inverse_lerp(p_istart, p_istop, p_value)); }
 
 	static _ALWAYS_INLINE_ double smoothstep(double p_from, double p_to, double p_weight) {
-		if (is_equal_approx(p_from, p_to)) return p_from;
+		if (is_equal_approx(p_from, p_to))
+			return p_from;
 		double x = CLAMP((p_weight - p_from) / (p_to - p_from), 0.0, 1.0);
 		return x * x * (3.0 - 2.0 * x);
 	}
 	static _ALWAYS_INLINE_ float smoothstep(float p_from, float p_to, float p_weight) {
-		if (is_equal_approx(p_from, p_to)) return p_from;
+		if (is_equal_approx(p_from, p_to))
+			return p_from;
 		float x = CLAMP((p_weight - p_from) / (p_to - p_from), 0.0f, 1.0f);
 		return x * x * (3.0f - 2.0f * x);
 	}
diff --git a/core/math/quat.cpp b/core/math/quat.cpp
index 61cd41b23d..6fbea70279 100644
--- a/core/math/quat.cpp
+++ b/core/math/quat.cpp
@@ -206,7 +206,8 @@ Quat Quat::slerpni(const Quat &q, const real_t &t) const {
 
 	real_t dot = from.dot(q);
 
-	if (Math::absf(dot) > 0.9999) return from;
+	if (Math::absf(dot) > 0.9999)
+		return from;
 
 	real_t theta = Math::acos(dot),
 		   sinT = 1.0 / Math::sin(theta),
diff --git a/core/math/triangle_mesh.cpp b/core/math/triangle_mesh.cpp
index 5c66721b9d..0f7350a260 100644
--- a/core/math/triangle_mesh.cpp
+++ b/core/math/triangle_mesh.cpp
@@ -558,14 +558,16 @@ bool TriangleMesh::intersect_convex_shape(const Plane *p_planes, int p_plane_cou
 								if (p.intersects_segment(point, next_point, &res)) {
 									bool inisde = true;
 									for (int k = 0; k < p_plane_count; k++) {
-										if (k == i) continue;
+										if (k == i)
+											continue;
 										const Plane &pp = p_planes[k];
 										if (pp.is_point_over(res)) {
 											inisde = false;
 											break;
 										}
 									}
-									if (inisde) return true;
+									if (inisde)
+										return true;
 								}
 
 								if (p.is_point_over(point)) {
@@ -573,7 +575,8 @@ bool TriangleMesh::intersect_convex_shape(const Plane *p_planes, int p_plane_cou
 									break;
 								}
 							}
-							if (over) return true;
+							if (over)
+								return true;
 						}
 
 						stack[level] = (VISIT_DONE_BIT << VISITED_BIT_SHIFT) | node;
@@ -652,7 +655,8 @@ bool TriangleMesh::inside_convex_shape(const Plane *p_planes, int p_plane_count,
 			case TEST_AABB_BIT: {
 
 				bool intersects = scale.xform(b.aabb).intersects_convex_shape(p_planes, p_plane_count, p_points, p_point_count);
-				if (!intersects) return false;
+				if (!intersects)
+					return false;
 
 				bool inside = scale.xform(b.aabb).inside_convex_shape(p_planes, p_plane_count);
 				if (inside) {
@@ -667,7 +671,8 @@ bool TriangleMesh::inside_convex_shape(const Plane *p_planes, int p_plane_count,
 							Vector3 point = scale.xform(vertexptr[s.indices[j]]);
 							for (int i = 0; i < p_plane_count; i++) {
 								const Plane &p = p_planes[i];
-								if (p.is_point_over(point)) return false;
+								if (p.is_point_over(point))
+									return false;
 							}
 						}
 
diff --git a/core/math/triangulate.cpp b/core/math/triangulate.cpp
index cbcb232745..ae278b034d 100644
--- a/core/math/triangulate.cpp
+++ b/core/math/triangulate.cpp
@@ -103,13 +103,16 @@ bool Triangulate::snip(const Vector<Vector2> &p_contour, int u, int v, int w, in
 	// To avoid that we allow zero-area triangles if all else failed.
 	float threshold = relaxed ? -CMP_EPSILON : CMP_EPSILON;
 
-	if (threshold > (((Bx - Ax) * (Cy - Ay)) - ((By - Ay) * (Cx - Ax)))) return false;
+	if (threshold > (((Bx - Ax) * (Cy - Ay)) - ((By - Ay) * (Cx - Ax))))
+		return false;
 
 	for (p = 0; p < n; p++) {
-		if ((p == u) || (p == v) || (p == w)) continue;
+		if ((p == u) || (p == v) || (p == w))
+			continue;
 		Px = contour[V[p]].x;
 		Py = contour[V[p]].y;
-		if (is_inside_triangle(Ax, Ay, Bx, By, Cx, Cy, Px, Py, relaxed)) return false;
+		if (is_inside_triangle(Ax, Ay, Bx, By, Cx, Cy, Px, Py, relaxed))
+			return false;
 	}
 
 	return true;
@@ -119,7 +122,8 @@ bool Triangulate::triangulate(const Vector<Vector2> &contour, Vector<int> &resul
 	/* allocate and initialize list of Vertices in polygon */
 
 	int n = contour.size();
-	if (n < 3) return false;
+	if (n < 3)
+		return false;
 
 	Vector<int> V;
 	V.resize(n);
@@ -161,11 +165,14 @@ bool Triangulate::triangulate(const Vector<Vector2> &contour, Vector<int> &resul
 
 		/* three consecutive vertices in current polygon, <u,v,w> */
 		int u = v;
-		if (nv <= u) u = 0; /* previous */
+		if (nv <= u)
+			u = 0; /* previous */
 		v = u + 1;
-		if (nv <= v) v = 0; /* new v    */
+		if (nv <= v)
+			v = 0; /* new v    */
 		int w = v + 1;
-		if (nv <= w) w = 0; /* next     */
+		if (nv <= w)
+			w = 0; /* next     */
 
 		if (snip(contour, u, v, w, nv, V, relaxed)) {
 			int a, b, c, s, t;
diff --git a/core/method_bind.h b/core/method_bind.h
index d39f107ba6..b3d4f1bf9b 100644
--- a/core/method_bind.h
+++ b/core/method_bind.h
@@ -165,7 +165,8 @@ struct VariantObjectClassChecker<Control *> {
 #define CHECK_NOARG(m_arg)                             \
 	{                                                  \
 		if (p_arg##m_arg.get_type() != Variant::NIL) { \
-			if (r_argerror) *r_argerror = (m_arg - 1); \
+			if (r_argerror)                            \
+				*r_argerror = (m_arg - 1);             \
 			return CALL_ERROR_EXTRA_ARGUMENT;          \
 		}                                              \
 	}
diff --git a/core/node_path.cpp b/core/node_path.cpp
index 83233622a0..25f1b38346 100644
--- a/core/node_path.cpp
+++ b/core/node_path.cpp
@@ -373,7 +373,8 @@ NodePath::NodePath(const String &p_path) {
 
 				String str = path.substr(from, i - from);
 				if (str == "") {
-					if (path[i] == 0) continue; // Allow end-of-path :
+					if (path[i] == 0)
+						continue; // Allow end-of-path :
 
 					ERR_FAIL_MSG("Invalid NodePath '" + p_path + "'.");
 				}
diff --git a/core/object.cpp b/core/object.cpp
index b0e6f2bdae..94d957f3af 100644
--- a/core/object.cpp
+++ b/core/object.cpp
@@ -543,7 +543,8 @@ void Object::set_indexed(const Vector<StringName> &p_names, const Variant &p_val
 	}
 
 	bool valid = false;
-	if (!r_valid) r_valid = &valid;
+	if (!r_valid)
+		r_valid = &valid;
 
 	List<Variant> value_stack;
 
diff --git a/core/object.h b/core/object.h
index b40aef2a42..3dec8a0480 100644
--- a/core/object.h
+++ b/core/object.h
@@ -346,7 +346,8 @@ protected:
 		return (bool (Object::*)(const StringName &, const Variant &)) & m_class::_set;                                                 \
 	}                                                                                                                                   \
 	virtual bool _setv(const StringName &p_name, const Variant &p_property) {                                                           \
-		if (m_inherits::_setv(p_name, p_property)) return true;                                                                         \
+		if (m_inherits::_setv(p_name, p_property))                                                                                      \
+			return true;                                                                                                                \
 		if (m_class::_get_set() != m_inherits::_get_set()) {                                                                            \
 			return _set(p_name, p_property);                                                                                            \
 		}                                                                                                                               \
diff --git a/core/os/dir_access.h b/core/os/dir_access.h
index 60eb553968..6c876cde5a 100644
--- a/core/os/dir_access.h
+++ b/core/os/dir_access.h
@@ -145,7 +145,8 @@ struct DirAccessRef {
 	DirAccess *f;
 	DirAccessRef(DirAccess *fa) { f = fa; }
 	~DirAccessRef() {
-		if (f) memdelete(f);
+		if (f)
+			memdelete(f);
 	}
 };
 
diff --git a/core/os/file_access.h b/core/os/file_access.h
index 010cc74a87..0f85c447b6 100644
--- a/core/os/file_access.h
+++ b/core/os/file_access.h
@@ -192,7 +192,8 @@ struct FileAccessRef {
 	operator FileAccess *() { return f; }
 	FileAccessRef(FileAccess *fa) { f = fa; }
 	~FileAccessRef() {
-		if (f) memdelete(f);
+		if (f)
+			memdelete(f);
 	}
 };
 
diff --git a/core/os/memory.h b/core/os/memory.h
index dcaedd92ba..d377d54fad 100644
--- a/core/os/memory.h
+++ b/core/os/memory.h
@@ -130,9 +130,10 @@ void memdelete_allocator(T *p_class) {
 	A::free(p_class);
 }
 
-#define memdelete_notnull(m_v)   \
-	{                            \
-		if (m_v) memdelete(m_v); \
+#define memdelete_notnull(m_v) \
+	{                          \
+		if (m_v)               \
+			memdelete(m_v);    \
 	}
 
 #define memnew_arr(m_class, m_count) memnew_arr_template<m_class>(m_count)
diff --git a/core/os/rw_lock.h b/core/os/rw_lock.h
index 64dfbef20c..2ef4df9b70 100644
--- a/core/os/rw_lock.h
+++ b/core/os/rw_lock.h
@@ -58,10 +58,12 @@ class RWLockRead {
 public:
 	RWLockRead(const RWLock *p_lock) {
 		lock = const_cast<RWLock *>(p_lock);
-		if (lock) lock->read_lock();
+		if (lock)
+			lock->read_lock();
 	}
 	~RWLockRead() {
-		if (lock) lock->read_unlock();
+		if (lock)
+			lock->read_unlock();
 	}
 };
 
@@ -72,10 +74,12 @@ class RWLockWrite {
 public:
 	RWLockWrite(RWLock *p_lock) {
 		lock = p_lock;
-		if (lock) lock->write_lock();
+		if (lock)
+			lock->write_lock();
 	}
 	~RWLockWrite() {
-		if (lock) lock->write_unlock();
+		if (lock)
+			lock->write_unlock();
 	}
 };
 
diff --git a/core/pool_allocator.cpp b/core/pool_allocator.cpp
index b74540395c..8fd67a47d2 100644
--- a/core/pool_allocator.cpp
+++ b/core/pool_allocator.cpp
@@ -182,7 +182,8 @@ PoolAllocator::ID PoolAllocator::alloc(int p_size) {
 
 	ERR_FAIL_COND_V(p_size < 1, POOL_ALLOCATOR_INVALID_ID);
 #ifdef DEBUG_ENABLED
-	if (p_size > free_mem) OS::get_singleton()->debug_break();
+	if (p_size > free_mem)
+		OS::get_singleton()->debug_break();
 #endif
 	ERR_FAIL_COND_V(p_size > free_mem, POOL_ALLOCATOR_INVALID_ID);
 
diff --git a/core/self_list.h b/core/self_list.h
index 43aeb44fea..2c44b0caec 100644
--- a/core/self_list.h
+++ b/core/self_list.h
@@ -121,7 +121,8 @@ private:
 public:
 	_FORCE_INLINE_ bool in_list() const { return _root; }
 	_FORCE_INLINE_ void remove_from_list() {
-		if (_root) _root->remove(this);
+		if (_root)
+			_root->remove(this);
 	}
 	_FORCE_INLINE_ SelfList<T> *next() { return _next; }
 	_FORCE_INLINE_ SelfList<T> *prev() { return _prev; }
diff --git a/core/translation.cpp b/core/translation.cpp
index 3f45bb17c9..5f31bc7399 100644
--- a/core/translation.cpp
+++ b/core/translation.cpp
@@ -989,7 +989,8 @@ String TranslationServer::get_locale() const {
 
 String TranslationServer::get_locale_name(const String &p_locale) const {
 
-	if (!locale_name_map.has(p_locale)) return String();
+	if (!locale_name_map.has(p_locale))
+		return String();
 	return locale_name_map[p_locale];
 }
 
diff --git a/core/ustring.cpp b/core/ustring.cpp
index fbe3fcb1b2..dbcb78d2fc 100644
--- a/core/ustring.cpp
+++ b/core/ustring.cpp
@@ -1882,7 +1882,8 @@ bool String::is_numeric() const {
 	};
 
 	int s = 0;
-	if (operator[](0) == '-') ++s;
+	if (operator[](0) == '-')
+		++s;
 	bool dot = false;
 	for (int i = s; i < length(); i++) {
 
diff --git a/core/variant.h b/core/variant.h
index 1ae09ad82f..8e924be00a 100644
--- a/core/variant.h
+++ b/core/variant.h
@@ -474,7 +474,8 @@ public:
 		type = NIL;
 	}
 	_FORCE_INLINE_ ~Variant() {
-		if (type != Variant::NIL) clear();
+		if (type != Variant::NIL)
+			clear();
 	}
 };
 
diff --git a/core/variant_op.cpp b/core/variant_op.cpp
index 6b462201a4..c77d67b04e 100644
--- a/core/variant_op.cpp
+++ b/core/variant_op.cpp
@@ -181,21 +181,26 @@ bool Variant::booleanize() const {
 		return;          \
 	}
 
-#define DEFAULT_OP_NUM(m_prefix, m_op_name, m_name, m_op, m_type)               \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                                    \
-		if (p_b.type == INT) _RETURN(p_a._data.m_type m_op p_b._data._int);     \
-		if (p_b.type == FLOAT) _RETURN(p_a._data.m_type m_op p_b._data._float); \
-                                                                                \
-		_RETURN_FAIL                                                            \
+#define DEFAULT_OP_NUM(m_prefix, m_op_name, m_name, m_op, m_type) \
+	CASE_TYPE(m_prefix, m_op_name, m_name) {                      \
+		if (p_b.type == INT)                                      \
+			_RETURN(p_a._data.m_type m_op p_b._data._int);        \
+		if (p_b.type == FLOAT)                                    \
+			_RETURN(p_a._data.m_type m_op p_b._data._float);      \
+                                                                  \
+		_RETURN_FAIL                                              \
 	};
 
-#define DEFAULT_OP_NUM_NULL(m_prefix, m_op_name, m_name, m_op, m_type)          \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                                    \
-		if (p_b.type == INT) _RETURN(p_a._data.m_type m_op p_b._data._int);     \
-		if (p_b.type == FLOAT) _RETURN(p_a._data.m_type m_op p_b._data._float); \
-		if (p_b.type == NIL) _RETURN(!(p_b.type m_op NIL));                     \
-                                                                                \
-		_RETURN_FAIL                                                            \
+#define DEFAULT_OP_NUM_NULL(m_prefix, m_op_name, m_name, m_op, m_type) \
+	CASE_TYPE(m_prefix, m_op_name, m_name) {                           \
+		if (p_b.type == INT)                                           \
+			_RETURN(p_a._data.m_type m_op p_b._data._int);             \
+		if (p_b.type == FLOAT)                                         \
+			_RETURN(p_a._data.m_type m_op p_b._data._float);           \
+		if (p_b.type == NIL)                                           \
+			_RETURN(!(p_b.type m_op NIL));                             \
+                                                                       \
+		_RETURN_FAIL                                                   \
 	};
 
 #ifdef DEBUG_ENABLED
@@ -219,12 +224,14 @@ bool Variant::booleanize() const {
 		_RETURN_FAIL                                            \
 	};
 #else
-#define DEFAULT_OP_NUM_DIV(m_prefix, m_op_name, m_name, m_type)              \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                                 \
-		if (p_b.type == INT) _RETURN(p_a._data.m_type / p_b._data._int);     \
-		if (p_b.type == FLOAT) _RETURN(p_a._data.m_type / p_b._data._float); \
-                                                                             \
-		_RETURN_FAIL                                                         \
+#define DEFAULT_OP_NUM_DIV(m_prefix, m_op_name, m_name, m_type) \
+	CASE_TYPE(m_prefix, m_op_name, m_name) {                    \
+		if (p_b.type == INT)                                    \
+			_RETURN(p_a._data.m_type / p_b._data._int);         \
+		if (p_b.type == FLOAT)                                  \
+			_RETURN(p_a._data.m_type / p_b._data._float);       \
+                                                                \
+		_RETURN_FAIL                                            \
 	};
 #endif
 
@@ -238,62 +245,84 @@ bool Variant::booleanize() const {
 		_RETURN(p_a._data.m_type);                              \
 	};
 
-#define DEFAULT_OP_NUM_VEC(m_prefix, m_op_name, m_name, m_op, m_type)                                                \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                                         \
-		if (p_b.type == INT) _RETURN(p_a._data.m_type m_op p_b._data._int);                                          \
-		if (p_b.type == FLOAT) _RETURN(p_a._data.m_type m_op p_b._data._float);                                      \
-		if (p_b.type == VECTOR2) _RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector2 *>(p_b._data._mem));  \
-		if (p_b.type == VECTOR3) _RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector3 *>(p_b._data._mem));  \
-		if (p_b.type == VECTOR2I) _RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector2 *>(p_b._data._mem)); \
-		if (p_b.type == VECTOR3I) _RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector3 *>(p_b._data._mem)); \
-                                                                                                                     \
-		_RETURN_FAIL                                                                                                 \
+#define DEFAULT_OP_NUM_VEC(m_prefix, m_op_name, m_name, m_op, m_type)                          \
+	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                   \
+		if (p_b.type == INT)                                                                   \
+			_RETURN(p_a._data.m_type m_op p_b._data._int);                                     \
+		if (p_b.type == FLOAT)                                                                 \
+			_RETURN(p_a._data.m_type m_op p_b._data._float);                                   \
+		if (p_b.type == VECTOR2)                                                               \
+			_RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector2 *>(p_b._data._mem)); \
+		if (p_b.type == VECTOR3)                                                               \
+			_RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector3 *>(p_b._data._mem)); \
+		if (p_b.type == VECTOR2I)                                                              \
+			_RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector2 *>(p_b._data._mem)); \
+		if (p_b.type == VECTOR3I)                                                              \
+			_RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector3 *>(p_b._data._mem)); \
+                                                                                               \
+		_RETURN_FAIL                                                                           \
 	};
 
-#define DEFAULT_OP_STR_REV(m_prefix, m_op_name, m_name, m_op, m_type)                                                                                       \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                                                                                \
-		if (p_b.type == STRING) _RETURN(*reinterpret_cast<const m_type *>(p_b._data._mem) m_op *reinterpret_cast<const String *>(p_a._data._mem));          \
-		if (p_b.type == STRING_NAME) _RETURN(*reinterpret_cast<const m_type *>(p_b._data._mem) m_op *reinterpret_cast<const StringName *>(p_a._data._mem)); \
-		if (p_b.type == NODE_PATH) _RETURN(*reinterpret_cast<const m_type *>(p_b._data._mem) m_op *reinterpret_cast<const NodePath *>(p_a._data._mem));     \
-                                                                                                                                                            \
-		_RETURN_FAIL                                                                                                                                        \
+#define DEFAULT_OP_STR_REV(m_prefix, m_op_name, m_name, m_op, m_type)                                                              \
+	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                                                       \
+		if (p_b.type == STRING)                                                                                                    \
+			_RETURN(*reinterpret_cast<const m_type *>(p_b._data._mem) m_op *reinterpret_cast<const String *>(p_a._data._mem));     \
+		if (p_b.type == STRING_NAME)                                                                                               \
+			_RETURN(*reinterpret_cast<const m_type *>(p_b._data._mem) m_op *reinterpret_cast<const StringName *>(p_a._data._mem)); \
+		if (p_b.type == NODE_PATH)                                                                                                 \
+			_RETURN(*reinterpret_cast<const m_type *>(p_b._data._mem) m_op *reinterpret_cast<const NodePath *>(p_a._data._mem));   \
+                                                                                                                                   \
+		_RETURN_FAIL                                                                                                               \
 	};
 
-#define DEFAULT_OP_STR(m_prefix, m_op_name, m_name, m_op, m_type)                                                                                           \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                                                                                \
-		if (p_b.type == STRING) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const String *>(p_b._data._mem));          \
-		if (p_b.type == STRING_NAME) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const StringName *>(p_b._data._mem)); \
-		if (p_b.type == NODE_PATH) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const NodePath *>(p_b._data._mem));     \
-                                                                                                                                                            \
-		_RETURN_FAIL                                                                                                                                        \
+#define DEFAULT_OP_STR(m_prefix, m_op_name, m_name, m_op, m_type)                                                                  \
+	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                                                       \
+		if (p_b.type == STRING)                                                                                                    \
+			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const String *>(p_b._data._mem));     \
+		if (p_b.type == STRING_NAME)                                                                                               \
+			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const StringName *>(p_b._data._mem)); \
+		if (p_b.type == NODE_PATH)                                                                                                 \
+			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const NodePath *>(p_b._data._mem));   \
+                                                                                                                                   \
+		_RETURN_FAIL                                                                                                               \
 	};
 
-#define DEFAULT_OP_STR_NULL(m_prefix, m_op_name, m_name, m_op, m_type)                                                                                      \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                                                                                \
-		if (p_b.type == STRING) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const String *>(p_b._data._mem));          \
-		if (p_b.type == STRING_NAME) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const StringName *>(p_b._data._mem)); \
-		if (p_b.type == NODE_PATH) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const NodePath *>(p_b._data._mem));     \
-		if (p_b.type == NIL) _RETURN(!(p_b.type m_op NIL));                                                                                                 \
-                                                                                                                                                            \
-		_RETURN_FAIL                                                                                                                                        \
+#define DEFAULT_OP_STR_NULL(m_prefix, m_op_name, m_name, m_op, m_type)                                                             \
+	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                                                       \
+		if (p_b.type == STRING)                                                                                                    \
+			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const String *>(p_b._data._mem));     \
+		if (p_b.type == STRING_NAME)                                                                                               \
+			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const StringName *>(p_b._data._mem)); \
+		if (p_b.type == NODE_PATH)                                                                                                 \
+			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const NodePath *>(p_b._data._mem));   \
+		if (p_b.type == NIL)                                                                                                       \
+			_RETURN(!(p_b.type m_op NIL));                                                                                         \
+                                                                                                                                   \
+		_RETURN_FAIL                                                                                                               \
 	};
 
-#define DEFAULT_OP_STR_NULL_NP(m_prefix, m_op_name, m_name, m_op, m_type)                                                                               \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                                                                            \
-		if (p_b.type == STRING) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const String *>(p_b._data._mem));      \
-		if (p_b.type == NODE_PATH) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const NodePath *>(p_b._data._mem)); \
-		if (p_b.type == NIL) _RETURN(!(p_b.type m_op NIL));                                                                                             \
-                                                                                                                                                        \
-		_RETURN_FAIL                                                                                                                                    \
+#define DEFAULT_OP_STR_NULL_NP(m_prefix, m_op_name, m_name, m_op, m_type)                                                        \
+	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                                                     \
+		if (p_b.type == STRING)                                                                                                  \
+			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const String *>(p_b._data._mem));   \
+		if (p_b.type == NODE_PATH)                                                                                               \
+			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const NodePath *>(p_b._data._mem)); \
+		if (p_b.type == NIL)                                                                                                     \
+			_RETURN(!(p_b.type m_op NIL));                                                                                       \
+                                                                                                                                 \
+		_RETURN_FAIL                                                                                                             \
 	};
 
-#define DEFAULT_OP_STR_NULL_SN(m_prefix, m_op_name, m_name, m_op, m_type)                                                                                   \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                                                                                \
-		if (p_b.type == STRING) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const String *>(p_b._data._mem));          \
-		if (p_b.type == STRING_NAME) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const StringName *>(p_b._data._mem)); \
-		if (p_b.type == NIL) _RETURN(!(p_b.type m_op NIL));                                                                                                 \
-                                                                                                                                                            \
-		_RETURN_FAIL                                                                                                                                        \
+#define DEFAULT_OP_STR_NULL_SN(m_prefix, m_op_name, m_name, m_op, m_type)                                                          \
+	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                                                       \
+		if (p_b.type == STRING)                                                                                                    \
+			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const String *>(p_b._data._mem));     \
+		if (p_b.type == STRING_NAME)                                                                                               \
+			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const StringName *>(p_b._data._mem)); \
+		if (p_b.type == NIL)                                                                                                       \
+			_RETURN(!(p_b.type m_op NIL));                                                                                         \
+                                                                                                                                   \
+		_RETURN_FAIL                                                                                                               \
 	};
 
 #define DEFAULT_OP_LOCALMEM_REV(m_prefix, m_op_name, m_name, m_op, m_type)                                                     \
@@ -332,13 +361,16 @@ bool Variant::booleanize() const {
 		_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem));  \
 	}
 
-#define DEFAULT_OP_LOCALMEM_NUM(m_prefix, m_op_name, m_name, m_op, m_type)                                                                         \
-	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                                                                       \
-		if (p_b.type == m_name) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const m_type *>(p_b._data._mem)); \
-		if (p_b.type == INT) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op p_b._data._int);                                       \
-		if (p_b.type == FLOAT) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op p_b._data._float);                                   \
-                                                                                                                                                   \
-		_RETURN_FAIL                                                                                                                               \
+#define DEFAULT_OP_LOCALMEM_NUM(m_prefix, m_op_name, m_name, m_op, m_type)                                                     \
+	CASE_TYPE(m_prefix, m_op_name, m_name) {                                                                                   \
+		if (p_b.type == m_name)                                                                                                \
+			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const m_type *>(p_b._data._mem)); \
+		if (p_b.type == INT)                                                                                                   \
+			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op p_b._data._int);                                    \
+		if (p_b.type == FLOAT)                                                                                                 \
+			_RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op p_b._data._float);                                  \
+                                                                                                                               \
+		_RETURN_FAIL                                                                                                           \
 	}
 
 #define DEFAULT_OP_PTR(m_op, m_name, m_sub)                \
@@ -436,7 +468,8 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a,
 	SWITCH(math, p_op, p_a.type) {
 		SWITCH_OP(math, OP_EQUAL, p_a.type) {
 			CASE_TYPE(math, OP_EQUAL, NIL) {
-				if (p_b.type == NIL) _RETURN(true);
+				if (p_b.type == NIL)
+					_RETURN(true);
 				if (p_b.type == OBJECT)
 					_RETURN(p_b._get_obj().obj == nullptr);
 
@@ -532,7 +565,8 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a,
 
 		SWITCH_OP(math, OP_NOT_EQUAL, p_a.type) {
 			CASE_TYPE(math, OP_NOT_EQUAL, NIL) {
-				if (p_b.type == NIL) _RETURN(false);
+				if (p_b.type == NIL)
+					_RETURN(false);
 				if (p_b.type == OBJECT)
 					_RETURN(p_b._get_obj().obj != nullptr);
 
@@ -1983,7 +2017,8 @@ Variant Variant::get_named(const StringName &p_index, bool *r_valid) const {
 
 #define DEFAULT_OP_DVECTOR_SET(m_name, m_type, skip_cond)                                    \
 	case m_name: {                                                                           \
-		if (skip_cond) return;                                                               \
+		if (skip_cond)                                                                       \
+			return;                                                                          \
                                                                                              \
 		if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::FLOAT) {    \
 			int index = p_index;                                                             \
diff --git a/core/vector.h b/core/vector.h
index 7277179621..b2133f800b 100644
--- a/core/vector.h
+++ b/core/vector.h
@@ -69,7 +69,8 @@ public:
 	void remove(int p_index) { _cowdata.remove(p_index); }
 	void erase(const T &p_val) {
 		int idx = find(p_val);
-		if (idx >= 0) remove(idx);
+		if (idx >= 0)
+			remove(idx);
 	}
 	void invert();
 
diff --git a/drivers/gles2/shaders/scene.glsl b/drivers/gles2/shaders/scene.glsl
index 84aadcbbc3..b720c71cec 100644
--- a/drivers/gles2/shaders/scene.glsl
+++ b/drivers/gles2/shaders/scene.glsl
@@ -1128,7 +1128,8 @@ float SchlickFresnel(float u) {
 }
 
 float GTR1(float NdotH, float a) {
-	if (a >= 1.0) return 1.0 / M_PI;
+	if (a >= 1.0)
+		return 1.0 / M_PI;
 	float a2 = a * a;
 	float t = 1.0 + (a2 - 1.0) * NdotH * NdotH;
 	return (a2 - 1.0) / (M_PI * log(a2) * t);
diff --git a/drivers/unix/ip_unix.cpp b/drivers/unix/ip_unix.cpp
index 5e3dedfc2f..56be9a2f74 100644
--- a/drivers/unix/ip_unix.cpp
+++ b/drivers/unix/ip_unix.cpp
@@ -248,7 +248,8 @@ void IP_Unix::get_local_interfaces(Map<String, Interface_Info> *r_interfaces) co
 		info.ip_addresses.push_front(_sockaddr2ip(ifa->ifa_addr));
 	}
 
-	if (ifAddrStruct != nullptr) freeifaddrs(ifAddrStruct);
+	if (ifAddrStruct != nullptr)
+		freeifaddrs(ifAddrStruct);
 }
 #endif
 
diff --git a/drivers/vulkan/vulkan_context.cpp b/drivers/vulkan/vulkan_context.cpp
index d293abdee3..a7eb3e53b9 100644
--- a/drivers/vulkan/vulkan_context.cpp
+++ b/drivers/vulkan/vulkan_context.cpp
@@ -601,12 +601,13 @@ Error VulkanContext::_initialize_queues(VkSurfaceKHR surface) {
 	_create_device();
 
 	static PFN_vkGetDeviceProcAddr g_gdpa = nullptr;
-#define GET_DEVICE_PROC_ADDR(dev, entrypoint)                                                              \
-	{                                                                                                      \
-		if (!g_gdpa) g_gdpa = (PFN_vkGetDeviceProcAddr)vkGetInstanceProcAddr(inst, "vkGetDeviceProcAddr"); \
-		fp##entrypoint = (PFN_vk##entrypoint)g_gdpa(dev, "vk" #entrypoint);                                \
-		ERR_FAIL_COND_V_MSG(fp##entrypoint == nullptr, ERR_CANT_CREATE,                                    \
-				"vkGetDeviceProcAddr failed to find vk" #entrypoint);                                      \
+#define GET_DEVICE_PROC_ADDR(dev, entrypoint)                                                     \
+	{                                                                                             \
+		if (!g_gdpa)                                                                              \
+			g_gdpa = (PFN_vkGetDeviceProcAddr)vkGetInstanceProcAddr(inst, "vkGetDeviceProcAddr"); \
+		fp##entrypoint = (PFN_vk##entrypoint)g_gdpa(dev, "vk" #entrypoint);                       \
+		ERR_FAIL_COND_V_MSG(fp##entrypoint == nullptr, ERR_CANT_CREATE,                           \
+				"vkGetDeviceProcAddr failed to find vk" #entrypoint);                             \
 	}
 
 	GET_DEVICE_PROC_ADDR(device, CreateSwapchainKHR);
diff --git a/editor/code_editor.cpp b/editor/code_editor.cpp
index 987d5649b1..76716f01b7 100644
--- a/editor/code_editor.cpp
+++ b/editor/code_editor.cpp
@@ -309,7 +309,8 @@ void FindReplaceBar::_update_results_count() {
 	results_count = 0;
 
 	String searched = get_search_text();
-	if (searched.empty()) return;
+	if (searched.empty())
+		return;
 
 	String full_text = text_edit->get_text();
 
@@ -317,7 +318,8 @@ void FindReplaceBar::_update_results_count() {
 
 	while (true) {
 		int pos = is_case_sensitive() ? full_text.find(searched, from_pos) : full_text.findn(searched, from_pos);
-		if (pos == -1) break;
+		if (pos == -1)
+			break;
 
 		if (is_whole_words()) {
 			from_pos++; // Making sure we won't hit the same match next time, if we get out via a continue.
diff --git a/editor/debugger/script_editor_debugger.cpp b/editor/debugger/script_editor_debugger.cpp
index 152989f90b..0fa62253c3 100644
--- a/editor/debugger/script_editor_debugger.cpp
+++ b/editor/debugger/script_editor_debugger.cpp
@@ -74,7 +74,8 @@ void ScriptEditorDebugger::_put_msg(String p_message, Array p_data) {
 
 void ScriptEditorDebugger::debug_copy() {
 	String msg = reason->get_text();
-	if (msg == "") return;
+	if (msg == "")
+		return;
 	DisplayServer::get_singleton()->clipboard_set(msg);
 }
 
diff --git a/editor/editor_file_dialog.cpp b/editor/editor_file_dialog.cpp
index 6a06c6657e..2411852541 100644
--- a/editor/editor_file_dialog.cpp
+++ b/editor/editor_file_dialog.cpp
@@ -691,7 +691,8 @@ bool EditorFileDialog::_is_open_should_be_disabled() {
 void EditorFileDialog::update_file_name() {
 	int idx = filter->get_selected() - 1;
 	if ((idx == -1 && filter->get_item_count() == 2) || (filter->get_item_count() > 2 && idx >= 0 && idx < filter->get_item_count() - 2)) {
-		if (idx == -1) idx += 1;
+		if (idx == -1)
+			idx += 1;
 		String filter_str = filters[idx];
 		String file_str = file->get_text();
 		String base_name = file_str.get_basename();
diff --git a/editor/editor_help.cpp b/editor/editor_help.cpp
index b566ad0fa4..deee6bc2cb 100644
--- a/editor/editor_help.cpp
+++ b/editor/editor_help.cpp
@@ -1786,7 +1786,8 @@ void FindBar::_update_results_count() {
 	results_count = 0;
 
 	String searched = search_text->get_text();
-	if (searched.empty()) return;
+	if (searched.empty())
+		return;
 
 	String full_text = rich_text_label->get_text();
 
diff --git a/editor/editor_node.cpp b/editor/editor_node.cpp
index 90cea06439..c37ede4166 100644
--- a/editor/editor_node.cpp
+++ b/editor/editor_node.cpp
@@ -3082,7 +3082,8 @@ void EditorNode::_remove_edited_scene(bool p_change_tab) {
 		ScriptEditor::get_singleton()->close_builtin_scripts_from_scene(editor_data.get_scene_path(old_index));
 	}
 
-	if (p_change_tab) _scene_tab_changed(new_index);
+	if (p_change_tab)
+		_scene_tab_changed(new_index);
 	editor_data.remove_scene(old_index);
 	editor_data.get_undo_redo().clear_history(false);
 	_update_title();
diff --git a/editor/node_3d_editor_gizmos.cpp b/editor/node_3d_editor_gizmos.cpp
index f83204fcdd..ce1f510fc9 100644
--- a/editor/node_3d_editor_gizmos.cpp
+++ b/editor/node_3d_editor_gizmos.cpp
@@ -431,7 +431,8 @@ bool EditorNode3DGizmo::intersect_frustum(const Camera3D *p_camera, const Vector
 	ERR_FAIL_COND_V(!spatial_node, false);
 	ERR_FAIL_COND_V(!valid, false);
 
-	if (hidden && !gizmo_plugin->is_selectable_when_hidden()) return false;
+	if (hidden && !gizmo_plugin->is_selectable_when_hidden())
+		return false;
 
 	if (selectable_icon_size > 0.0f) {
 		Vector3 origin = spatial_node->get_global_transform().get_origin();
@@ -470,10 +471,12 @@ bool EditorNode3DGizmo::intersect_frustum(const Camera3D *p_camera, const Vector
 					break;
 				}
 			}
-			if (any_out) break;
+			if (any_out)
+				break;
 		}
 
-		if (!any_out) return true;
+		if (!any_out)
+			return true;
 	}
 
 	if (collision_mesh.is_valid()) {
@@ -504,7 +507,8 @@ bool EditorNode3DGizmo::intersect_ray(Camera3D *p_camera, const Point2 &p_point,
 	ERR_FAIL_COND_V(!spatial_node, false);
 	ERR_FAIL_COND_V(!valid, false);
 
-	if (hidden && !gizmo_plugin->is_selectable_when_hidden()) return false;
+	if (hidden && !gizmo_plugin->is_selectable_when_hidden())
+		return false;
 
 	if (r_gizmo_handle && !hidden) {
 
@@ -785,7 +789,8 @@ EditorNode3DGizmo::EditorNode3DGizmo() {
 
 EditorNode3DGizmo::~EditorNode3DGizmo() {
 
-	if (gizmo_plugin != nullptr) gizmo_plugin->unregister_gizmo(this);
+	if (gizmo_plugin != nullptr)
+		gizmo_plugin->unregister_gizmo(this);
 	clear();
 }
 
diff --git a/editor/plugins/canvas_item_editor_plugin.cpp b/editor/plugins/canvas_item_editor_plugin.cpp
index e882b3a8d7..36184a3f42 100644
--- a/editor/plugins/canvas_item_editor_plugin.cpp
+++ b/editor/plugins/canvas_item_editor_plugin.cpp
@@ -1624,20 +1624,28 @@ bool CanvasItemEditor::_gui_input_anchors(const Ref<InputEvent> &p_event) {
 
 			switch (drag_type) {
 				case DRAG_ANCHOR_TOP_LEFT:
-					if (!use_single_axis || !use_y) control->set_anchor(MARGIN_LEFT, new_anchor.x, false, false);
-					if (!use_single_axis || use_y) control->set_anchor(MARGIN_TOP, new_anchor.y, false, false);
+					if (!use_single_axis || !use_y)
+						control->set_anchor(MARGIN_LEFT, new_anchor.x, false, false);
+					if (!use_single_axis || use_y)
+						control->set_anchor(MARGIN_TOP, new_anchor.y, false, false);
 					break;
 				case DRAG_ANCHOR_TOP_RIGHT:
-					if (!use_single_axis || !use_y) control->set_anchor(MARGIN_RIGHT, new_anchor.x, false, false);
-					if (!use_single_axis || use_y) control->set_anchor(MARGIN_TOP, new_anchor.y, false, false);
+					if (!use_single_axis || !use_y)
+						control->set_anchor(MARGIN_RIGHT, new_anchor.x, false, false);
+					if (!use_single_axis || use_y)
+						control->set_anchor(MARGIN_TOP, new_anchor.y, false, false);
 					break;
 				case DRAG_ANCHOR_BOTTOM_RIGHT:
-					if (!use_single_axis || !use_y) control->set_anchor(MARGIN_RIGHT, new_anchor.x, false, false);
-					if (!use_single_axis || use_y) control->set_anchor(MARGIN_BOTTOM, new_anchor.y, false, false);
+					if (!use_single_axis || !use_y)
+						control->set_anchor(MARGIN_RIGHT, new_anchor.x, false, false);
+					if (!use_single_axis || use_y)
+						control->set_anchor(MARGIN_BOTTOM, new_anchor.y, false, false);
 					break;
 				case DRAG_ANCHOR_BOTTOM_LEFT:
-					if (!use_single_axis || !use_y) control->set_anchor(MARGIN_LEFT, new_anchor.x, false, false);
-					if (!use_single_axis || use_y) control->set_anchor(MARGIN_BOTTOM, new_anchor.y, false, false);
+					if (!use_single_axis || !use_y)
+						control->set_anchor(MARGIN_LEFT, new_anchor.x, false, false);
+					if (!use_single_axis || use_y)
+						control->set_anchor(MARGIN_BOTTOM, new_anchor.y, false, false);
 					break;
 				case DRAG_ANCHOR_ALL:
 					if (!use_single_axis || !use_y) {
@@ -5037,7 +5045,8 @@ void CanvasItemEditor::_focus_selection(int p_op) {
 	Map<Node *, Object *> &selection = editor_selection->get_selection();
 	for (Map<Node *, Object *>::Element *E = selection.front(); E; E = E->next()) {
 		CanvasItem *canvas_item = Object::cast_to<CanvasItem>(E->key());
-		if (!canvas_item) continue;
+		if (!canvas_item)
+			continue;
 		if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
 			continue;
 
@@ -5065,7 +5074,8 @@ void CanvasItemEditor::_focus_selection(int p_op) {
 			rect = rect.merge(canvas_item_rect);
 		}
 	};
-	if (count == 0) return;
+	if (count == 0)
+		return;
 
 	if (p_op == VIEW_CENTER_TO_SELECTION) {
 
diff --git a/editor/plugins/debugger_editor_plugin.cpp b/editor/plugins/debugger_editor_plugin.cpp
index 566ff378c3..2b0d3f2582 100644
--- a/editor/plugins/debugger_editor_plugin.cpp
+++ b/editor/plugins/debugger_editor_plugin.cpp
@@ -179,12 +179,18 @@ void DebuggerEditorPlugin::_update_debug_options() {
 	bool check_reload_scripts = EditorSettings::get_singleton()->get_project_metadata("debug_options", "run_reload_scripts", false);
 	int instances = EditorSettings::get_singleton()->get_project_metadata("debug_options", "run_debug_instances", 1);
 
-	if (check_deploy_remote) _menu_option(RUN_DEPLOY_REMOTE_DEBUG);
-	if (check_file_server) _menu_option(RUN_FILE_SERVER);
-	if (check_debug_collisions) _menu_option(RUN_DEBUG_COLLISONS);
-	if (check_debug_navigation) _menu_option(RUN_DEBUG_NAVIGATION);
-	if (check_live_debug) _menu_option(RUN_LIVE_DEBUG);
-	if (check_reload_scripts) _menu_option(RUN_RELOAD_SCRIPTS);
+	if (check_deploy_remote)
+		_menu_option(RUN_DEPLOY_REMOTE_DEBUG);
+	if (check_file_server)
+		_menu_option(RUN_FILE_SERVER);
+	if (check_debug_collisions)
+		_menu_option(RUN_DEBUG_COLLISONS);
+	if (check_debug_navigation)
+		_menu_option(RUN_DEBUG_NAVIGATION);
+	if (check_live_debug)
+		_menu_option(RUN_LIVE_DEBUG);
+	if (check_reload_scripts)
+		_menu_option(RUN_RELOAD_SCRIPTS);
 
 	int len = instances_menu->get_item_count();
 	for (int idx = 0; idx < len; idx++) {
diff --git a/editor/plugins/node_3d_editor_plugin.cpp b/editor/plugins/node_3d_editor_plugin.cpp
index 7e65dd1c78..59f0edc347 100644
--- a/editor/plugins/node_3d_editor_plugin.cpp
+++ b/editor/plugins/node_3d_editor_plugin.cpp
@@ -718,9 +718,11 @@ void Node3DEditorViewport::_select_region() {
 			item = sel;
 		}
 
-		if (selected.find(item) != -1) continue;
+		if (selected.find(item) != -1)
+			continue;
 
-		if (_is_node_locked(item)) continue;
+		if (_is_node_locked(item))
+			continue;
 
 		Ref<EditorNode3DGizmo> seg = sp->get_gizmo();
 
@@ -1381,7 +1383,8 @@ void Node3DEditorViewport::_sinput(const Ref<InputEvent> &p_event) {
 
 					if (cursor.region_select) {
 
-						if (!clicked_wants_append) _clear_selected();
+						if (!clicked_wants_append)
+							_clear_selected();
 
 						_select_region();
 						cursor.region_select = false;
@@ -2076,7 +2079,8 @@ void Node3DEditorViewport::_sinput(const Ref<InputEvent> &p_event) {
 		}
 
 		if (k->get_keycode() == KEY_SPACE) {
-			if (!k->is_pressed()) emit_signal("toggle_maximize_view", this);
+			if (!k->is_pressed())
+				emit_signal("toggle_maximize_view", this);
 		}
 	}
 
@@ -4633,7 +4637,8 @@ Dictionary Node3DEditor::get_state() const {
 
 	Dictionary gizmos_status;
 	for (int i = 0; i < gizmo_plugins_by_name.size(); i++) {
-		if (!gizmo_plugins_by_name[i]->can_be_hidden()) continue;
+		if (!gizmo_plugins_by_name[i]->can_be_hidden())
+			continue;
 		int state = gizmos_menu->get_item_state(gizmos_menu->get_item_index(i));
 		String name = gizmo_plugins_by_name[i]->get_name();
 		gizmos_status[name] = state;
@@ -4727,7 +4732,8 @@ void Node3DEditor::set_state(const Dictionary &p_state) {
 		gizmos_status.get_key_list(&keys);
 
 		for (int j = 0; j < gizmo_plugins_by_name.size(); ++j) {
-			if (!gizmo_plugins_by_name[j]->can_be_hidden()) continue;
+			if (!gizmo_plugins_by_name[j]->can_be_hidden())
+				continue;
 			int state = EditorNode3DGizmoPlugin::VISIBLE;
 			for (int i = 0; i < keys.size(); i++) {
 				if (gizmo_plugins_by_name.write[j]->get_name() == keys[i]) {
@@ -5492,7 +5498,8 @@ void Node3DEditor::_update_gizmos_menu() {
 	gizmos_menu->clear();
 
 	for (int i = 0; i < gizmo_plugins_by_name.size(); ++i) {
-		if (!gizmo_plugins_by_name[i]->can_be_hidden()) continue;
+		if (!gizmo_plugins_by_name[i]->can_be_hidden())
+			continue;
 		String plugin_name = gizmo_plugins_by_name[i]->get_name();
 		const int plugin_state = gizmo_plugins_by_name[i]->get_state();
 		gizmos_menu->add_multistate_item(TTR(plugin_name), 3, plugin_state, i);
@@ -5513,7 +5520,8 @@ void Node3DEditor::_update_gizmos_menu() {
 
 void Node3DEditor::_update_gizmos_menu_theme() {
 	for (int i = 0; i < gizmo_plugins_by_name.size(); ++i) {
-		if (!gizmo_plugins_by_name[i]->can_be_hidden()) continue;
+		if (!gizmo_plugins_by_name[i]->can_be_hidden())
+			continue;
 		const int plugin_state = gizmo_plugins_by_name[i]->get_state();
 		const int idx = gizmos_menu->get_item_index(i);
 		switch (plugin_state) {
@@ -5924,9 +5932,11 @@ void Node3DEditor::_request_gizmo(Object *p_obj) {
 }
 
 void Node3DEditor::_toggle_maximize_view(Object *p_viewport) {
-	if (!p_viewport) return;
+	if (!p_viewport)
+		return;
 	Node3DEditorViewport *current_viewport = Object::cast_to<Node3DEditorViewport>(p_viewport);
-	if (!current_viewport) return;
+	if (!current_viewport)
+		return;
 
 	int index = -1;
 	bool maximized = false;
@@ -5938,7 +5948,8 @@ void Node3DEditor::_toggle_maximize_view(Object *p_viewport) {
 			break;
 		}
 	}
-	if (index == -1) return;
+	if (index == -1)
+		return;
 
 	if (!maximized) {
 
@@ -6655,7 +6666,8 @@ Ref<StandardMaterial3D> EditorNode3DGizmoPlugin::get_material(const String &p_na
 	ERR_FAIL_COND_V(!materials.has(p_name), Ref<StandardMaterial3D>());
 	ERR_FAIL_COND_V(materials[p_name].size() == 0, Ref<StandardMaterial3D>());
 
-	if (p_gizmo.is_null() || materials[p_name].size() == 1) return materials[p_name][0];
+	if (p_gizmo.is_null() || materials[p_name].size() == 1)
+		return materials[p_name][0];
 
 	int index = (p_gizmo->is_selected() ? 1 : 0) + (p_gizmo->is_editable() ? 2 : 0);
 
@@ -6692,7 +6704,8 @@ Ref<EditorNode3DGizmo> EditorNode3DGizmoPlugin::get_gizmo(Node3D *p_spatial) {
 
 	Ref<EditorNode3DGizmo> ref = create_gizmo(p_spatial);
 
-	if (ref.is_null()) return ref;
+	if (ref.is_null())
+		return ref;
 
 	ref->set_plugin(this);
 	ref->set_spatial_node(p_spatial);
@@ -6751,7 +6764,8 @@ Ref<EditorNode3DGizmo> EditorNode3DGizmoPlugin::create_gizmo(Node3D *p_spatial)
 	}
 
 	Ref<EditorNode3DGizmo> ref;
-	if (has_gizmo(p_spatial)) ref.instance();
+	if (has_gizmo(p_spatial))
+		ref.instance();
 	return ref;
 }
 
diff --git a/editor/plugins/path_2d_editor_plugin.cpp b/editor/plugins/path_2d_editor_plugin.cpp
index 4516b7035b..2edb337b1c 100644
--- a/editor/plugins/path_2d_editor_plugin.cpp
+++ b/editor/plugins/path_2d_editor_plugin.cpp
@@ -288,8 +288,10 @@ bool Path2DEditor::forward_gui_input(const Ref<InputEvent> &p_event) {
 			Vector2 gpoint = mm->get_position();
 
 			Ref<Curve2D> curve = node->get_curve();
-			if (curve == nullptr) return true;
-			if (curve->get_point_count() < 2) return true;
+			if (curve == nullptr)
+				return true;
+			if (curve->get_point_count() < 2)
+				return true;
 
 			// Find edge
 			edge_point = xform.xform(curve->get_closest_point(xform.affine_inverse().xform(mm->get_position())));
diff --git a/editor/plugins/path_3d_editor_plugin.cpp b/editor/plugins/path_3d_editor_plugin.cpp
index d3ece9556d..6c475d829f 100644
--- a/editor/plugins/path_3d_editor_plugin.cpp
+++ b/editor/plugins/path_3d_editor_plugin.cpp
@@ -631,7 +631,8 @@ Ref<EditorNode3DGizmo> Path3DGizmoPlugin::create_gizmo(Node3D *p_spatial) {
 	Ref<Path3DGizmo> ref;
 
 	Path3D *path = Object::cast_to<Path3D>(p_spatial);
-	if (path) ref = Ref<Path3DGizmo>(memnew(Path3DGizmo(path)));
+	if (path)
+		ref = Ref<Path3DGizmo>(memnew(Path3DGizmo(path)));
 
 	return ref;
 }
diff --git a/editor/plugins/script_text_editor.cpp b/editor/plugins/script_text_editor.cpp
index c79c97737a..109d83d838 100644
--- a/editor/plugins/script_text_editor.cpp
+++ b/editor/plugins/script_text_editor.cpp
@@ -822,7 +822,8 @@ void ScriptTextEditor::_code_complete_scripts(void *p_ud, const String &p_code,
 
 void ScriptTextEditor::_code_complete_script(const String &p_code, List<ScriptCodeCompletionOption> *r_options, bool &r_force) {
 
-	if (color_panel->is_visible()) return;
+	if (color_panel->is_visible())
+		return;
 	Node *base = get_tree()->get_edited_scene_root();
 	if (base) {
 		base = _find_node_for_script(base, base, script);
diff --git a/editor/plugins/tile_set_editor_plugin.cpp b/editor/plugins/tile_set_editor_plugin.cpp
index c393b15a97..b0d325efc1 100644
--- a/editor/plugins/tile_set_editor_plugin.cpp
+++ b/editor/plugins/tile_set_editor_plugin.cpp
@@ -126,7 +126,8 @@ void TileSetEditor::_import_node(Node *p_node, Ref<TileSet> p_library) {
 			sb->get_shape_owners(&shapes);
 
 			for (List<uint32_t>::Element *E = shapes.front(); E; E = E->next()) {
-				if (sb->is_shape_owner_disabled(E->get())) continue;
+				if (sb->is_shape_owner_disabled(E->get()))
+					continue;
 
 				Transform2D shape_transform = sb->get_transform() * sb->shape_owner_get_transform(E->get());
 				bool one_way = sb->is_shape_owner_one_way_collision_enabled(E->get());
diff --git a/editor/plugins/visual_shader_editor_plugin.cpp b/editor/plugins/visual_shader_editor_plugin.cpp
index 35ed29f562..07251ad7ad 100644
--- a/editor/plugins/visual_shader_editor_plugin.cpp
+++ b/editor/plugins/visual_shader_editor_plugin.cpp
@@ -1239,11 +1239,13 @@ void VisualShaderEditor::_port_name_focus_out(Object *line_edit, int p_node_id,
 	List<String> output_names;
 
 	for (int i = 0; i < node->get_input_port_count(); i++) {
-		if (!p_output && i == p_port_id) continue;
+		if (!p_output && i == p_port_id)
+			continue;
 		input_names.push_back(node->get_input_port_name(i));
 	}
 	for (int i = 0; i < node->get_output_port_count(); i++) {
-		if (p_output && i == p_port_id) continue;
+		if (p_output && i == p_port_id)
+			continue;
 		output_names.push_back(node->get_output_port_name(i));
 	}
 
diff --git a/editor/project_settings_editor.cpp b/editor/project_settings_editor.cpp
index 49c02dc895..f069886518 100644
--- a/editor/project_settings_editor.cpp
+++ b/editor/project_settings_editor.cpp
@@ -446,11 +446,13 @@ void ProjectSettingsEditor::_show_last_added(const Ref<InputEvent> &p_event, con
 			}
 			child = child->get_next();
 		}
-		if (found) break;
+		if (found)
+			break;
 		r = r->get_next();
 	}
 
-	if (found) input_editor->ensure_cursor_is_visible();
+	if (found)
+		input_editor->ensure_cursor_is_visible();
 }
 
 void ProjectSettingsEditor::_wait_for_key(const Ref<InputEvent> &p_event) {
@@ -1596,7 +1598,8 @@ void ProjectSettingsEditor::_update_translations() {
 			String n = names[i];
 			String l = langs[i];
 			bool is_checked = l_filter.has(l);
-			if (filter_mode == SHOW_ONLY_SELECTED_LOCALES && !is_checked) continue;
+			if (filter_mode == SHOW_ONLY_SELECTED_LOCALES && !is_checked)
+				continue;
 
 			TreeItem *t = translation_filter->create_item(root);
 			t->set_cell_mode(0, TreeItem::CELL_MODE_CHECK);
diff --git a/editor/scene_tree_dock.cpp b/editor/scene_tree_dock.cpp
index a8aeb05150..66b7ed7a43 100644
--- a/editor/scene_tree_dock.cpp
+++ b/editor/scene_tree_dock.cpp
@@ -491,8 +491,10 @@ void SceneTreeDock::_tool_selected(int p_tool, bool p_confirm_override) {
 			for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
 				int index = E->get()->get_index();
 
-				if (index > highest_id) highest_id = index;
-				if (index < lowest_id) lowest_id = index;
+				if (index > highest_id)
+					highest_id = index;
+				if (index < lowest_id)
+					lowest_id = index;
 
 				if (E->get()->get_parent() != common_parent)
 					common_parent = nullptr;
@@ -501,8 +503,10 @@ void SceneTreeDock::_tool_selected(int p_tool, bool p_confirm_override) {
 			if (!common_parent || (MOVING_DOWN && highest_id >= common_parent->get_child_count() - MOVING_DOWN) || (MOVING_UP && lowest_id == 0))
 				break; // one or more nodes can not be moved
 
-			if (selection.size() == 1) editor_data->get_undo_redo().create_action(TTR("Move Node In Parent"));
-			if (selection.size() > 1) editor_data->get_undo_redo().create_action(TTR("Move Nodes In Parent"));
+			if (selection.size() == 1)
+				editor_data->get_undo_redo().create_action(TTR("Move Node In Parent"));
+			if (selection.size() > 1)
+				editor_data->get_undo_redo().create_action(TTR("Move Nodes In Parent"));
 
 			for (int i = 0; i < selection.size(); i++) {
 				Node *top_node = selection[i];
diff --git a/editor/script_create_dialog.cpp b/editor/script_create_dialog.cpp
index 12b21d871b..f84b7e73ed 100644
--- a/editor/script_create_dialog.cpp
+++ b/editor/script_create_dialog.cpp
@@ -167,11 +167,14 @@ String ScriptCreateDialog::_validate_path(const String &p_path, bool p_file_must
 
 	String p = p_path.strip_edges();
 
-	if (p == "") return TTR("Path is empty.");
-	if (p.get_file().get_basename() == "") return TTR("Filename is empty.");
+	if (p == "")
+		return TTR("Path is empty.");
+	if (p.get_file().get_basename() == "")
+		return TTR("Filename is empty.");
 
 	p = ProjectSettings::get_singleton()->localize_path(p);
-	if (!p.begins_with("res://")) return TTR("Path is not local.");
+	if (!p.begins_with("res://"))
+		return TTR("Path is not local.");
 
 	DirAccess *d = DirAccess::create(DirAccess::ACCESS_RESOURCES);
 	if (d->change_dir(p.get_base_dir()) != OK) {
@@ -216,12 +219,15 @@ String ScriptCreateDialog::_validate_path(const String &p_path, bool p_file_must
 		index++;
 	}
 
-	if (!found) return TTR("Invalid extension.");
-	if (!match) return TTR("Wrong extension chosen.");
+	if (!found)
+		return TTR("Invalid extension.");
+	if (!match)
+		return TTR("Wrong extension chosen.");
 
 	/* Let ScriptLanguage do custom validation */
 	String path_error = ScriptServer::get_language(language_menu->get_selected())->validate_path(p);
-	if (path_error != "") return path_error;
+	if (path_error != "")
+		return path_error;
 
 	/* All checks passed */
 	return "";
diff --git a/main/main.cpp b/main/main.cpp
index 95449dd5cc..b6afd9160c 100644
--- a/main/main.cpp
+++ b/main/main.cpp
@@ -2260,7 +2260,8 @@ bool Main::iteration() {
 		uint64_t time_step = 1000000L / target_fps;
 		target_ticks += time_step;
 		uint64_t current_ticks = OS::get_singleton()->get_ticks_usec();
-		if (current_ticks < target_ticks) OS::get_singleton()->delay_usec(target_ticks - current_ticks);
+		if (current_ticks < target_ticks)
+			OS::get_singleton()->delay_usec(target_ticks - current_ticks);
 		current_ticks = OS::get_singleton()->get_ticks_usec();
 		target_ticks = MIN(MAX(target_ticks, current_ticks - time_step), current_ticks + time_step);
 	}
diff --git a/main/tests/test_astar.cpp b/main/tests/test_astar.cpp
index e0b4a7f2c8..66f9aa8ad6 100644
--- a/main/tests/test_astar.cpp
+++ b/main/tests/test_astar.cpp
@@ -173,7 +173,8 @@ bool test_add_remove() {
 	for (int i = 0; i < 20000; i++) {
 		int u = Math::rand() % 5;
 		int v = Math::rand() % 4;
-		if (u == v) v = 4;
+		if (u == v)
+			v = 4;
 		if (Math::rand() % 2 == 1) {
 			// Add a (possibly existing) directed edge and confirm connectivity
 			a.connect_points(u, v, false);
@@ -195,7 +196,8 @@ bool test_add_remove() {
 		for (int j = 0; j < 10; j++) {
 			int u = Math::rand() % 5;
 			int v = Math::rand() % 4;
-			if (u == v) v = 4;
+			if (u == v)
+				v = 4;
 			if (Math::rand() % 2 == 1)
 				a.connect_points(u, v, false);
 			else
@@ -239,7 +241,8 @@ bool test_solutions() {
 			int u, v;
 			u = Math::rand() % N;
 			v = Math::rand() % (N - 1);
-			if (u == v) v = N - 1;
+			if (u == v)
+				v = N - 1;
 
 			// Pick a random operation
 			int op = Math::rand();
@@ -253,14 +256,16 @@ bool test_solutions() {
 					// Add edge (u, v); possibly bidirectional
 					a.connect_points(u, v, op % 2);
 					adj[u][v] = true;
-					if (op % 2) adj[v][u] = true;
+					if (op % 2)
+						adj[v][u] = true;
 					break;
 				case 6:
 				case 7:
 					// Remove edge (u, v); possibly bidirectional
 					a.disconnect_points(u, v, op % 2);
 					adj[u][v] = false;
-					if (op % 2) adj[v][u] = false;
+					if (op % 2)
+						adj[v][u] = false;
 					break;
 				case 8:
 					// Remove point u and add it back; clears adjacent edges and changes coordinates
@@ -291,12 +296,14 @@ bool test_solutions() {
 		int count = 0;
 		for (int u = 0; u < N; u++)
 			for (int v = 0; v < N; v++)
-				if (adj[u][v]) count++;
+				if (adj[u][v])
+					count++;
 		printf("Test #%4d: %3d edges, ", test + 1, count);
 		count = 0;
 		for (int u = 0; u < N; u++)
 			for (int v = 0; v < N; v++)
-				if (!Math::is_inf(d[u][v])) count++;
+				if (!Math::is_inf(d[u][v]))
+					count++;
 		printf("%3d/%d pairs of reachable points\n", count - N, N * (N - 1));
 
 		// Check A*'s output
@@ -339,7 +346,8 @@ bool test_solutions() {
 				}
 
 	exit:
-		if (!match) return false;
+		if (!match)
+			return false;
 	}
 	return true;
 }
diff --git a/main/tests/test_string.cpp b/main/tests/test_string.cpp
index 7438e2bae9..34087c7204 100644
--- a/main/tests/test_string.cpp
+++ b/main/tests/test_string.cpp
@@ -972,22 +972,26 @@ bool test_31() {
 	String a = "";
 	success = a[0] == 0;
 	OS::get_singleton()->print("Is 0 String[0]:, %s\n", success ? "OK" : "FAIL");
-	if (!success) state = false;
+	if (!success)
+		state = false;
 
 	String b = "Godot";
 	success = b[b.size()] == 0;
 	OS::get_singleton()->print("Is 0 String[size()]:, %s\n", success ? "OK" : "FAIL");
-	if (!success) state = false;
+	if (!success)
+		state = false;
 
 	const String c = "";
 	success = c[0] == 0;
 	OS::get_singleton()->print("Is 0 const String[0]:, %s\n", success ? "OK" : "FAIL");
-	if (!success) state = false;
+	if (!success)
+		state = false;
 
 	const String d = "Godot";
 	success = d[d.size()] == 0;
 	OS::get_singleton()->print("Is 0 const String[size()]:, %s\n", success ? "OK" : "FAIL");
-	if (!success) state = false;
+	if (!success)
+		state = false;
 
 	return state;
 };
diff --git a/modules/bullet/shape_bullet.cpp b/modules/bullet/shape_bullet.cpp
index e28683ba78..f5932ac32d 100644
--- a/modules/bullet/shape_bullet.cpp
+++ b/modules/bullet/shape_bullet.cpp
@@ -81,7 +81,8 @@ void ShapeBullet::add_owner(ShapeOwnerBullet *p_owner) {
 
 void ShapeBullet::remove_owner(ShapeOwnerBullet *p_owner, bool p_permanentlyFromThisBody) {
 	Map<ShapeOwnerBullet *, int>::Element *E = owners.find(p_owner);
-	if (!E) return;
+	if (!E)
+		return;
 	E->get()--;
 	if (p_permanentlyFromThisBody || 0 >= E->get()) {
 		owners.erase(E);
diff --git a/modules/bullet/space_bullet.h b/modules/bullet/space_bullet.h
index 3d4a2aeceb..0173c5a1c7 100644
--- a/modules/bullet/space_bullet.h
+++ b/modules/bullet/space_bullet.h
@@ -170,7 +170,8 @@ public:
 		contactDebugCount = 0;
 	}
 	_FORCE_INLINE_ void add_debug_contact(const Vector3 &p_contact) {
-		if (contactDebugCount < contactDebug.size()) contactDebug.write[contactDebugCount++] = p_contact;
+		if (contactDebugCount < contactDebug.size())
+			contactDebug.write[contactDebugCount++] = p_contact;
 	}
 	_FORCE_INLINE_ Vector<Vector3> get_debug_contacts() { return contactDebug; }
 	_FORCE_INLINE_ int get_debug_contact_count() { return contactDebugCount; }
diff --git a/modules/csg/csg.cpp b/modules/csg/csg.cpp
index 6714db76bb..a6951a9320 100644
--- a/modules/csg/csg.cpp
+++ b/modules/csg/csg.cpp
@@ -138,10 +138,12 @@ inline bool is_point_in_triangle(const Vector3 &p_point, const Vector3 p_vertice
 	lambda[2] = p_vertices[0].cross(p_vertices[1]).dot(p_point) / det;
 
 	// Point is in the plane if all lambdas sum to 1.
-	if (!Math::is_equal_approx(lambda[0] + lambda[1] + lambda[2], 1)) return false;
+	if (!Math::is_equal_approx(lambda[0] + lambda[1] + lambda[2], 1))
+		return false;
 
 	// Point is inside the triangle if all lambdas are positive.
-	if (lambda[0] < 0 || lambda[1] < 0 || lambda[2] < 0) return false;
+	if (lambda[0] < 0 || lambda[1] < 0 || lambda[2] < 0)
+		return false;
 
 	return true;
 }
@@ -524,7 +526,8 @@ void CSGBrushOperation::MeshMerge::_add_distance(List<real_t> &r_intersectionsA,
 
 	// Check if distance exists.
 	for (const List<real_t>::Element *E = intersections.front(); E; E = E->next())
-		if (Math::abs(**E - p_distance) < vertex_snap) return;
+		if (Math::abs(**E - p_distance) < vertex_snap)
+			return;
 
 	intersections.push_back(p_distance);
 }
@@ -790,7 +793,8 @@ int CSGBrushOperation::Build2DFaces::_add_vertex(const Vertex2D &p_vertex) {
 
 	// Check if vertex exists.
 	int vertex_id = _get_point_idx(p_vertex.point);
-	if (vertex_id != -1) return vertex_id;
+	if (vertex_id != -1)
+		return vertex_id;
 
 	vertices.push_back(p_vertex);
 	return vertices.size() - 1;
@@ -816,7 +820,8 @@ void CSGBrushOperation::Build2DFaces::_add_vertex_idx_sorted(Vector<int> &r_vert
 
 			// Sort along the axis with the greatest difference.
 			int axis = 0;
-			if (Math::abs(new_point.x - first_point.x) < Math::abs(new_point.y - first_point.y)) axis = 1;
+			if (Math::abs(new_point.x - first_point.x) < Math::abs(new_point.y - first_point.y))
+				axis = 1;
 
 			// Add it to the beginning or the end appropriately.
 			if (new_point[axis] < first_point[axis])
@@ -834,7 +839,8 @@ void CSGBrushOperation::Build2DFaces::_add_vertex_idx_sorted(Vector<int> &r_vert
 
 		// Determine axis being sorted against i.e. the axis with the greatest difference.
 		int axis = 0;
-		if (Math::abs(last_point.x - first_point.x) < Math::abs(last_point.y - first_point.y)) axis = 1;
+		if (Math::abs(last_point.x - first_point.x) < Math::abs(last_point.y - first_point.y))
+			axis = 1;
 
 		// Insert the point at the appropriate index.
 		for (int insert_idx = 0; insert_idx < r_vertex_indices.size(); ++insert_idx) {
@@ -853,7 +859,8 @@ void CSGBrushOperation::Build2DFaces::_add_vertex_idx_sorted(Vector<int> &r_vert
 void CSGBrushOperation::Build2DFaces::_merge_faces(const Vector<int> &p_segment_indices) {
 
 	int segments = p_segment_indices.size() - 1;
-	if (segments < 2) return;
+	if (segments < 2)
+		return;
 
 	// Faces around an inner vertex are merged by moving the inner vertex to the first vertex.
 	for (int sorted_idx = 1; sorted_idx < segments; ++sorted_idx) {
@@ -893,7 +900,8 @@ void CSGBrushOperation::Build2DFaces::_merge_faces(const Vector<int> &p_segment_
 
 			// Skip flattened faces.
 			if (outer_edge_idx[0] == p_segment_indices[closest_idx] ||
-					outer_edge_idx[1] == p_segment_indices[closest_idx]) continue;
+					outer_edge_idx[1] == p_segment_indices[closest_idx])
+				continue;
 
 			//Don't create degenerate triangles.
 			Vector2 edge1[2] = {
@@ -924,7 +932,8 @@ void CSGBrushOperation::Build2DFaces::_merge_faces(const Vector<int> &p_segment_
 		for (int i = 0; i < merge_faces_idx.size(); ++i)
 			faces.remove(merge_faces_idx[i]);
 
-		if (degenerate_points.size() == 0) continue;
+		if (degenerate_points.size() == 0)
+			continue;
 
 		// Split faces using degenerate points.
 		for (int face_idx = 0; face_idx < faces.size(); ++face_idx) {
@@ -954,7 +963,8 @@ void CSGBrushOperation::Build2DFaces::_merge_faces(const Vector<int> &p_segment_
 						break;
 					}
 				}
-				if (existing) continue;
+				if (existing)
+					continue;
 
 				// Check if point is on an each edge.
 				for (int face_edge_idx = 0; face_edge_idx < 3; ++face_edge_idx) {
@@ -1043,10 +1053,12 @@ void CSGBrushOperation::Build2DFaces::_find_edge_intersections(const Vector2 p_s
 
 				// Check if intersection point is an edge point.
 				if ((intersection_point - edge_points[0]).length_squared() < vertex_snap2 ||
-						(intersection_point - edge_points[1]).length_squared() < vertex_snap2) continue;
+						(intersection_point - edge_points[1]).length_squared() < vertex_snap2)
+					continue;
 
 				// Check if edge exists, by checking if the intersecting segment is parallel to the edge.
-				if (are_segements_parallel(p_segment_points, edge_points, vertex_snap2)) continue;
+				if (are_segements_parallel(p_segment_points, edge_points, vertex_snap2))
+					continue;
 
 				// Add the intersection point as a new vertex.
 				Vertex2D new_vertex;
@@ -1384,7 +1396,8 @@ void CSGBrushOperation::update_faces(const CSGBrush &p_brush_a, const int p_face
 		p_collection.build2DFacesB[p_face_idx_b] = Build2DFaces();
 		has_degenerate = true;
 	}
-	if (has_degenerate) return;
+	if (has_degenerate)
+		return;
 
 	// Ensure B has points either side of or in the plane of A.
 	int in_plane_count = 0, over_count = 0, under_count = 0;
@@ -1400,7 +1413,8 @@ void CSGBrushOperation::update_faces(const CSGBrush &p_brush_a, const int p_face
 			under_count++;
 	}
 	// If all points under or over the plane, there is no intesection.
-	if (over_count == 3 || under_count == 3) return;
+	if (over_count == 3 || under_count == 3)
+		return;
 
 	// Ensure A has points either side of or in the plane of B.
 	in_plane_count = 0;
@@ -1418,7 +1432,8 @@ void CSGBrushOperation::update_faces(const CSGBrush &p_brush_a, const int p_face
 			under_count++;
 	}
 	// If all points under or over the plane, there is no intesection.
-	if (over_count == 3 || under_count == 3) return;
+	if (over_count == 3 || under_count == 3)
+		return;
 
 	// Check for intersection using the SAT theorem.
 	{
diff --git a/modules/csg/csg_shape.cpp b/modules/csg/csg_shape.cpp
index 550a919d0d..96f82ab21b 100644
--- a/modules/csg/csg_shape.cpp
+++ b/modules/csg/csg_shape.cpp
@@ -1783,11 +1783,15 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 			final_polygon_min = p;
 			final_polygon_max = final_polygon_min;
 		} else {
-			if (p.x < final_polygon_min.x) final_polygon_min.x = p.x;
-			if (p.y < final_polygon_min.y) final_polygon_min.y = p.y;
-
-			if (p.x > final_polygon_max.x) final_polygon_max.x = p.x;
-			if (p.y > final_polygon_max.y) final_polygon_max.y = p.y;
+			if (p.x < final_polygon_min.x)
+				final_polygon_min.x = p.x;
+			if (p.y < final_polygon_min.y)
+				final_polygon_min.y = p.y;
+
+			if (p.x > final_polygon_max.x)
+				final_polygon_max.x = p.x;
+			if (p.y > final_polygon_max.y)
+				final_polygon_max.y = p.y;
 		}
 	}
 	Vector2 final_polygon_size = final_polygon_max - final_polygon_min;
diff --git a/modules/gdnative/gdnative/gdnative.cpp b/modules/gdnative/gdnative/gdnative.cpp
index 3175340448..1216d1d9d3 100644
--- a/modules/gdnative/gdnative/gdnative.cpp
+++ b/modules/gdnative/gdnative/gdnative.cpp
@@ -177,7 +177,8 @@ void *godot_get_class_tag(const godot_string_name *p_class) {
 }
 
 godot_object *godot_object_cast_to(const godot_object *p_object, void *p_class_tag) {
-	if (!p_object) return nullptr;
+	if (!p_object)
+		return nullptr;
 	Object *o = (Object *)p_object;
 
 	return o->is_class_ptr(p_class_tag) ? (godot_object *)o : nullptr;
diff --git a/modules/gdscript/gdscript.cpp b/modules/gdscript/gdscript.cpp
index 5f659f70a0..e3c37d5078 100644
--- a/modules/gdscript/gdscript.cpp
+++ b/modules/gdscript/gdscript.cpp
@@ -658,12 +658,14 @@ 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()) return StringName();
+	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()) return MultiplayerAPI::RPC_MODE_DISABLED;
+	if (p_rpc_method_id >= rpc_functions.size())
+		return MultiplayerAPI::RPC_MODE_DISABLED;
 	return rpc_functions[p_rpc_method_id].mode;
 }
 
@@ -685,12 +687,14 @@ 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()) return StringName();
+	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()) return MultiplayerAPI::RPC_MODE_DISABLED;
+	if (p_rset_member_id >= rpc_variables.size())
+		return MultiplayerAPI::RPC_MODE_DISABLED;
 	return rpc_variables[p_rset_member_id].mode;
 }
 
diff --git a/modules/gdscript/gdscript_compiler.cpp b/modules/gdscript/gdscript_compiler.cpp
index 2bbec29043..d4c31903eb 100644
--- a/modules/gdscript/gdscript_compiler.cpp
+++ b/modules/gdscript/gdscript_compiler.cpp
@@ -861,71 +861,92 @@ 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)) return -1;
+					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)) return -1;
+					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)) return -1;
+					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)) return -1;
+					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)) return -1;
+					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)) return -1;
+					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)) return -1;
+					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)) return -1;
+					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)) return -1;
+					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)) return -1;
+					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)) return -1;
+					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)) return -1;
+					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)) return -1;
+					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)) return -1;
+					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)) return -1;
+					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)) return -1;
+					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)) return -1;
+					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)) return -1;
+					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)) return -1;
+					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)) return -1;
+					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;
+					if (!_create_binary_operator(codegen, on, Variant::OP_SHIFT_RIGHT, p_stack_level))
+						return -1;
 				} break;
 				//assignment operators
 				case GDScriptParser::OperatorNode::OP_ASSIGN_ADD:
diff --git a/modules/gdscript/gdscript_compiler.h b/modules/gdscript/gdscript_compiler.h
index 34b066b5c7..08e1ec74af 100644
--- a/modules/gdscript/gdscript_compiler.h
+++ b/modules/gdscript/gdscript_compiler.h
@@ -123,10 +123,12 @@ class GDScriptCompiler {
 
 		Vector<int> opcodes;
 		void alloc_stack(int p_level) {
-			if (p_level >= stack_max) stack_max = p_level + 1;
+			if (p_level >= stack_max)
+				stack_max = p_level + 1;
 		}
 		void alloc_call(int p_params) {
-			if (p_params >= call_max) call_max = p_params;
+			if (p_params >= call_max)
+				call_max = p_params;
 		}
 
 		int current_line;
diff --git a/modules/gdscript/gdscript_function.h b/modules/gdscript/gdscript_function.h
index d38b6d0739..89dbeacf34 100644
--- a/modules/gdscript/gdscript_function.h
+++ b/modules/gdscript/gdscript_function.h
@@ -56,7 +56,8 @@ struct GDScriptDataType {
 	Ref<Script> script_type;
 
 	bool is_type(const Variant &p_variant, bool p_allow_implicit_conversion = false) const {
-		if (!has_type) return true; // Can't type check
+		if (!has_type)
+			return true; // Can't type check
 
 		switch (kind) {
 			case UNINITIALIZED:
diff --git a/modules/gdscript/gdscript_parser.cpp b/modules/gdscript/gdscript_parser.cpp
index 3280b1f8e3..bf128af52e 100644
--- a/modules/gdscript/gdscript_parser.cpp
+++ b/modules/gdscript/gdscript_parser.cpp
@@ -2047,7 +2047,8 @@ 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)) return false;
+			if (!_reduce_export_var_type(arr[i], p_line))
+				return false;
 		}
 		return true;
 	}
@@ -2056,7 +2057,8 @@ 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)) return false;
+			if (!_reduce_export_var_type(value, p_line))
+				return false;
 		}
 		return true;
 	}
@@ -3337,7 +3339,8 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 
 				_parse_pattern_block(compiled_branches, match_node->branches, p_static);
 
-				if (error_set) return;
+				if (error_set)
+					return;
 
 				ControlFlowNode *match_cf_node = alloc_node<ControlFlowNode>();
 				match_cf_node->cf_type = ControlFlowNode::CF_MATCH;
@@ -4934,7 +4937,8 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 							return;
 						}
 
-						if (!_reduce_export_var_type(cn->value, member.line)) return;
+						if (!_reduce_export_var_type(cn->value, member.line))
+							return;
 
 						member._export.type = cn->value.get_type();
 						member._export.usage |= PROPERTY_USAGE_SCRIPT_VARIABLE;
@@ -5451,8 +5455,10 @@ void GDScriptParser::_determine_inheritance(ClassNode *p_class, bool p_recursive
 					}
 				}
 
-				if (base_class) break;
-				if (found) continue;
+				if (base_class)
+					break;
+				if (found)
+					continue;
 
 				if (p->constant_expressions.has(base)) {
 					if (p->constant_expressions[base].expression->type != Node::TYPE_CONSTANT) {
@@ -5554,10 +5560,12 @@ void GDScriptParser::_determine_inheritance(ClassNode *p_class, bool p_recursive
 }
 
 String GDScriptParser::DataType::to_string() const {
-	if (!has_type) return "var";
+	if (!has_type)
+		return "var";
 	switch (kind) {
 		case BUILTIN: {
-			if (builtin_type == Variant::NIL) return "null";
+			if (builtin_type == Variant::NIL)
+				return "null";
 			return Variant::get_type_name(builtin_type);
 		} break;
 		case NATIVE: {
@@ -5721,8 +5729,10 @@ 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) return p_source;
-	if (p_source.kind != DataType::UNRESOLVED) return p_source;
+	if (!p_source.has_type)
+		return p_source;
+	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;
@@ -6962,7 +6972,8 @@ bool GDScriptParser::_get_function_signature(DataType &p_base_type, const String
 		native = "_" + native.operator String();
 	}
 	if (!ClassDB::class_exists(native)) {
-		if (!check_types) return false;
+		if (!check_types)
+			return false;
 		ERR_FAIL_V_MSG(false, "Parser bug: Class '" + String(native) + "' not found.");
 	}
 
@@ -7053,7 +7064,8 @@ GDScriptParser::DataType GDScriptParser::_reduce_function_call_type(const Operat
 				par_types.write[i - 1] = _reduce_node_type(p_call->arguments[i]);
 			}
 
-			if (error_set) return DataType();
+			if (error_set)
+				return DataType();
 
 			// Special case: check copy constructor. Those are defined implicitly in Variant.
 			if (par_types.size() == 1) {
@@ -7121,7 +7133,8 @@ 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) err += ", ";
+					if (i > 0)
+						err += ", ";
 					err += par_types[i].to_string();
 				}
 				err += ")'.";
@@ -7479,7 +7492,8 @@ bool GDScriptParser::_get_member_type(const DataType &p_base_type, const StringN
 		native = "_" + native.operator String();
 	}
 	if (!ClassDB::class_exists(native)) {
-		if (!check_types) return false;
+		if (!check_types)
+			return false;
 		ERR_FAIL_V_MSG(false, "Parser bug: Class \"" + String(native) + "\" not found.");
 	}
 
@@ -7776,12 +7790,14 @@ 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) return;
+		if (error_set)
+			return;
 	}
 
 	for (int i = 0; i < p_class->functions.size(); i++) {
 		_check_function_types(p_class->functions[i]);
-		if (error_set) return;
+		if (error_set)
+			return;
 	}
 
 	// Class variables
@@ -7856,7 +7872,8 @@ void GDScriptParser::_check_class_level_types(ClassNode *p_class) {
 		}
 
 		// Setter and getter
-		if (v.setter == StringName() && v.getter == StringName()) continue;
+		if (v.setter == StringName() && v.getter == StringName())
+			continue;
 
 		bool found_getter = false;
 		bool found_setter = false;
@@ -7899,10 +7916,12 @@ void GDScriptParser::_check_class_level_types(ClassNode *p_class) {
 					return;
 				}
 			}
-			if (found_getter && found_setter) break;
+			if (found_getter && found_setter)
+				break;
 		}
 
-		if ((found_getter || v.getter == StringName()) && (found_setter || v.setter == StringName())) continue;
+		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++) {
@@ -7933,7 +7952,8 @@ 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) return;
+		if (error_set)
+			return;
 		current_class = p_class;
 	}
 }
@@ -8081,7 +8101,8 @@ void GDScriptParser::_check_class_blocks_types(ClassNode *p_class) {
 		_check_block_types(current_block);
 		current_block = nullptr;
 		current_function = nullptr;
-		if (error_set) return;
+		if (error_set)
+			return;
 	}
 
 	for (int i = 0; i < p_class->functions.size(); i++) {
@@ -8091,7 +8112,8 @@ void GDScriptParser::_check_class_blocks_types(ClassNode *p_class) {
 		_check_block_types(current_block);
 		current_block = nullptr;
 		current_function = nullptr;
-		if (error_set) return;
+		if (error_set)
+			return;
 	}
 
 #ifdef DEBUG_ENABLED
@@ -8112,7 +8134,8 @@ 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) return;
+		if (error_set)
+			return;
 		current_class = p_class;
 	}
 }
@@ -8375,7 +8398,8 @@ void GDScriptParser::_check_block_types(BlockNode *p_block) {
 							_add_warning(GDScriptWarning::RETURN_VALUE_DISCARDED, op->line, func_name);
 						}
 #endif // DEBUG_ENABLED
-						if (error_set) return;
+						if (error_set)
+							return;
 					} break;
 					case OperatorNode::OP_YIELD: {
 						_mark_line_as_safe(op->line);
@@ -8410,7 +8434,8 @@ void GDScriptParser::_check_block_types(BlockNode *p_block) {
 							}
 						}
 
-						if (!function_type.has_type) break;
+						if (!function_type.has_type)
+							break;
 
 						if (function_type.kind == DataType::BUILTIN && function_type.builtin_type == Variant::NIL) {
 							// Return void, should not have arguments
@@ -8470,7 +8495,8 @@ 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) return;
+		if (error_set)
+			return;
 	}
 
 #ifdef DEBUG_ENABLED
@@ -8613,7 +8639,8 @@ Error GDScriptParser::_parse(const String &p_base_path) {
 	current_function = nullptr;
 	current_block = nullptr;
 
-	if (for_completion) check_types = false;
+	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 b345a88744..a33417e536 100644
--- a/modules/gdscript/gdscript_parser.h
+++ b/modules/gdscript/gdscript_parser.h
@@ -648,12 +648,14 @@ 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) safe_lines->insert(p_line);
+		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) safe_lines->erase(p_line);
+		if (safe_lines)
+			safe_lines->erase(p_line);
 #endif // DEBUG_ENABLED
 	}
 
diff --git a/modules/gdscript/language_server/gdscript_extend_parser.cpp b/modules/gdscript/language_server/gdscript_extend_parser.cpp
index b2c6b0e1ab..a6b749059a 100644
--- a/modules/gdscript/language_server/gdscript_extend_parser.cpp
+++ b/modules/gdscript/language_server/gdscript_extend_parser.cpp
@@ -385,7 +385,8 @@ String ExtendGDScriptParser::parse_documentation(int p_line, bool p_docs_down) {
 	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()) break;
+		if (i < 0 || i >= lines.size())
+			break;
 
 		String line_comment = lines[i].strip_edges(true, false);
 		if (line_comment.begins_with("#")) {
diff --git a/modules/gdscript/language_server/gdscript_workspace.cpp b/modules/gdscript/language_server/gdscript_workspace.cpp
index 32fc8f36f0..be036b44c4 100644
--- a/modules/gdscript/language_server/gdscript_workspace.cpp
+++ b/modules/gdscript/language_server/gdscript_workspace.cpp
@@ -185,7 +185,8 @@ Array GDScriptWorkspace::symbol(const Dictionary &p_params) {
 }
 
 Error GDScriptWorkspace::initialize() {
-	if (initialized) return OK;
+	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()) {
diff --git a/modules/gdscript/language_server/lsp.hpp b/modules/gdscript/language_server/lsp.hpp
index 124fcbfed8..e469a26df8 100644
--- a/modules/gdscript/language_server/lsp.hpp
+++ b/modules/gdscript/language_server/lsp.hpp
@@ -282,7 +282,8 @@ struct Command {
 		Dictionary dict;
 		dict["title"] = title;
 		dict["command"] = command;
-		if (arguments.size()) dict["arguments"] = arguments;
+		if (arguments.size())
+			dict["arguments"] = arguments;
 		return dict;
 	}
 };
@@ -946,16 +947,20 @@ struct CompletionItem {
 			dict["preselect"] = preselect;
 			dict["sortText"] = sortText;
 			dict["filterText"] = filterText;
-			if (commitCharacters.size()) dict["commitCharacters"] = commitCharacters;
+			if (commitCharacters.size())
+				dict["commitCharacters"] = commitCharacters;
 			dict["command"] = command.to_json();
 		}
 		return dict;
 	}
 
 	void load(const Dictionary &p_dict) {
-		if (p_dict.has("label")) label = p_dict["label"];
-		if (p_dict.has("kind")) kind = p_dict["kind"];
-		if (p_dict.has("detail")) detail = p_dict["detail"];
+		if (p_dict.has("label"))
+			label = p_dict["label"];
+		if (p_dict.has("kind"))
+			kind = p_dict["kind"];
+		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) {
@@ -965,12 +970,18 @@ struct CompletionItem {
 				documentation.value = v["value"];
 			}
 		}
-		if (p_dict.has("deprecated")) deprecated = p_dict["deprecated"];
-		if (p_dict.has("preselect")) preselect = p_dict["preselect"];
-		if (p_dict.has("sortText")) sortText = p_dict["sortText"];
-		if (p_dict.has("filterText")) filterText = p_dict["filterText"];
-		if (p_dict.has("insertText")) insertText = p_dict["insertText"];
-		if (p_dict.has("data")) data = p_dict["data"];
+		if (p_dict.has("deprecated"))
+			deprecated = p_dict["deprecated"];
+		if (p_dict.has("preselect"))
+			preselect = p_dict["preselect"];
+		if (p_dict.has("sortText"))
+			sortText = p_dict["sortText"];
+		if (p_dict.has("filterText"))
+			filterText = p_dict["filterText"];
+		if (p_dict.has("insertText"))
+			insertText = p_dict["insertText"];
+		if (p_dict.has("data"))
+			data = p_dict["data"];
 	}
 };
 
diff --git a/modules/jsonrpc/jsonrpc.cpp b/modules/jsonrpc/jsonrpc.cpp
index 393269d422..208ce24f3d 100644
--- a/modules/jsonrpc/jsonrpc.cpp
+++ b/modules/jsonrpc/jsonrpc.cpp
@@ -148,7 +148,8 @@ Variant JSONRPC::process_action(const Variant &p_action, bool p_process_arr_elem
 
 String JSONRPC::process_string(const String &p_input) {
 
-	if (p_input.empty()) return String();
+	if (p_input.empty())
+		return String();
 
 	Variant ret;
 	Variant input;
diff --git a/modules/mbedtls/packet_peer_mbed_dtls.cpp b/modules/mbedtls/packet_peer_mbed_dtls.cpp
index b2aa5f5827..37477e1246 100755..100644
--- a/modules/mbedtls/packet_peer_mbed_dtls.cpp
+++ b/modules/mbedtls/packet_peer_mbed_dtls.cpp
@@ -36,7 +36,8 @@
 
 int PacketPeerMbedDTLS::bio_send(void *ctx, const unsigned char *buf, size_t len) {
 
-	if (buf == nullptr || len <= 0) return 0;
+	if (buf == nullptr || len <= 0)
+		return 0;
 
 	PacketPeerMbedDTLS *sp = (PacketPeerMbedDTLS *)ctx;
 
@@ -53,7 +54,8 @@ int PacketPeerMbedDTLS::bio_send(void *ctx, const unsigned char *buf, size_t len
 
 int PacketPeerMbedDTLS::bio_recv(void *ctx, unsigned char *buf, size_t len) {
 
-	if (buf == nullptr || len <= 0) return 0;
+	if (buf == nullptr || len <= 0)
+		return 0;
 
 	PacketPeerMbedDTLS *sp = (PacketPeerMbedDTLS *)ctx;
 
diff --git a/modules/mbedtls/stream_peer_mbedtls.cpp b/modules/mbedtls/stream_peer_mbedtls.cpp
index 983095c536..af36b29dac 100755..100644
--- a/modules/mbedtls/stream_peer_mbedtls.cpp
+++ b/modules/mbedtls/stream_peer_mbedtls.cpp
@@ -35,7 +35,8 @@
 
 int StreamPeerMbedTLS::bio_send(void *ctx, const unsigned char *buf, size_t len) {
 
-	if (buf == nullptr || len <= 0) return 0;
+	if (buf == nullptr || len <= 0)
+		return 0;
 
 	StreamPeerMbedTLS *sp = (StreamPeerMbedTLS *)ctx;
 
@@ -54,7 +55,8 @@ int StreamPeerMbedTLS::bio_send(void *ctx, const unsigned char *buf, size_t len)
 
 int StreamPeerMbedTLS::bio_recv(void *ctx, unsigned char *buf, size_t len) {
 
-	if (buf == nullptr || len <= 0) return 0;
+	if (buf == nullptr || len <= 0)
+		return 0;
 
 	StreamPeerMbedTLS *sp = (StreamPeerMbedTLS *)ctx;
 
diff --git a/modules/mobile_vr/mobile_vr_interface.cpp b/modules/mobile_vr/mobile_vr_interface.cpp
index 48276c0d3d..6d10de0096 100644
--- a/modules/mobile_vr/mobile_vr_interface.cpp
+++ b/modules/mobile_vr/mobile_vr_interface.cpp
@@ -61,13 +61,19 @@ Vector3 MobileVRInterface::scale_magneto(const Vector3 &p_magnetometer) {
 	};
 
 	// adjust our min and max
-	if (mag_raw.x > mag_next_max.x) mag_next_max.x = mag_raw.x;
-	if (mag_raw.y > mag_next_max.y) mag_next_max.y = mag_raw.y;
-	if (mag_raw.z > mag_next_max.z) mag_next_max.z = mag_raw.z;
-
-	if (mag_raw.x < mag_next_min.x) mag_next_min.x = mag_raw.x;
-	if (mag_raw.y < mag_next_min.y) mag_next_min.y = mag_raw.y;
-	if (mag_raw.z < mag_next_min.z) mag_next_min.z = mag_raw.z;
+	if (mag_raw.x > mag_next_max.x)
+		mag_next_max.x = mag_raw.x;
+	if (mag_raw.y > mag_next_max.y)
+		mag_next_max.y = mag_raw.y;
+	if (mag_raw.z > mag_next_max.z)
+		mag_next_max.z = mag_raw.z;
+
+	if (mag_raw.x < mag_next_min.x)
+		mag_next_min.x = mag_raw.x;
+	if (mag_raw.y < mag_next_min.y)
+		mag_next_min.y = mag_raw.y;
+	if (mag_raw.z < mag_next_min.z)
+		mag_next_min.z = mag_raw.z;
 
 	// scale our x, y and z
 	if (!(mag_current_max.x - mag_current_min.x)) {
diff --git a/modules/mono/editor/bindings_generator.h b/modules/mono/editor/bindings_generator.h
index 7c87c688db..5672231e9a 100644
--- a/modules/mono/editor/bindings_generator.h
+++ b/modules/mono/editor/bindings_generator.h
@@ -619,7 +619,8 @@ class BindingsGenerator {
 	const List<InternalCall>::Element *find_icall_by_name(const String &p_name, const List<InternalCall> &p_list) {
 		const List<InternalCall>::Element *it = p_list.front();
 		while (it) {
-			if (it->get().name == p_name) return it;
+			if (it->get().name == p_name)
+				return it;
 			it = it->next();
 		}
 		return nullptr;
diff --git a/modules/mono/mono_gd/gd_mono_utils.cpp b/modules/mono/mono_gd/gd_mono_utils.cpp
index f9d492dabb..c0fea6ede9 100644
--- a/modules/mono/mono_gd/gd_mono_utils.cpp
+++ b/modules/mono/mono_gd/gd_mono_utils.cpp
@@ -564,9 +564,10 @@ namespace Marshal {
 
 #ifdef MONO_GLUE_ENABLED
 #ifdef TOOLS_ENABLED
-#define NO_GLUE_RET(m_ret)                                                   \
-	{                                                                        \
-		if (!GDMonoCache::cached_data.godot_api_cache_updated) return m_ret; \
+#define NO_GLUE_RET(m_ret)                                     \
+	{                                                          \
+		if (!GDMonoCache::cached_data.godot_api_cache_updated) \
+			return m_ret;                                      \
 	}
 #else
 #define NO_GLUE_RET(m_ret) \
diff --git a/modules/opensimplex/noise_texture.cpp b/modules/opensimplex/noise_texture.cpp
index 2018f90e9f..16cd04b044 100644
--- a/modules/opensimplex/noise_texture.cpp
+++ b/modules/opensimplex/noise_texture.cpp
@@ -202,19 +202,22 @@ Ref<OpenSimplexNoise> NoiseTexture::get_noise() {
 }
 
 void NoiseTexture::set_width(int p_width) {
-	if (p_width == size.x) return;
+	if (p_width == size.x)
+		return;
 	size.x = p_width;
 	_queue_update();
 }
 
 void NoiseTexture::set_height(int p_height) {
-	if (p_height == size.y) return;
+	if (p_height == size.y)
+		return;
 	size.y = p_height;
 	_queue_update();
 }
 
 void NoiseTexture::set_seamless(bool p_seamless) {
-	if (p_seamless == seamless) return;
+	if (p_seamless == seamless)
+		return;
 	seamless = p_seamless;
 	_queue_update();
 }
@@ -224,7 +227,8 @@ bool NoiseTexture::get_seamless() {
 }
 
 void NoiseTexture::set_as_normalmap(bool p_as_normalmap) {
-	if (p_as_normalmap == as_normalmap) return;
+	if (p_as_normalmap == as_normalmap)
+		return;
 	as_normalmap = p_as_normalmap;
 	_queue_update();
 	_change_notify();
@@ -236,7 +240,8 @@ bool NoiseTexture::is_normalmap() {
 
 void NoiseTexture::set_bump_strength(float p_bump_strength) {
 
-	if (p_bump_strength == bump_strength) return;
+	if (p_bump_strength == bump_strength)
+		return;
 	bump_strength = p_bump_strength;
 	if (as_normalmap)
 		_queue_update();
diff --git a/modules/opensimplex/open_simplex_noise.cpp b/modules/opensimplex/open_simplex_noise.cpp
index 238faa4130..205c033614 100644
--- a/modules/opensimplex/open_simplex_noise.cpp
+++ b/modules/opensimplex/open_simplex_noise.cpp
@@ -70,7 +70,8 @@ int OpenSimplexNoise::get_seed() {
 }
 
 void OpenSimplexNoise::set_octaves(int p_octaves) {
-	if (p_octaves == octaves) return;
+	if (p_octaves == octaves)
+		return;
 
 	ERR_FAIL_COND_MSG(p_octaves > MAX_OCTAVES, vformat("The number of OpenSimplexNoise octaves is limited to %d; ignoring the new value.", MAX_OCTAVES));
 
@@ -79,19 +80,22 @@ void OpenSimplexNoise::set_octaves(int p_octaves) {
 }
 
 void OpenSimplexNoise::set_period(float p_period) {
-	if (p_period == period) return;
+	if (p_period == period)
+		return;
 	period = p_period;
 	emit_changed();
 }
 
 void OpenSimplexNoise::set_persistence(float p_persistence) {
-	if (p_persistence == persistence) return;
+	if (p_persistence == persistence)
+		return;
 	persistence = p_persistence;
 	emit_changed();
 }
 
 void OpenSimplexNoise::set_lacunarity(float p_lacunarity) {
-	if (p_lacunarity == lacunarity) return;
+	if (p_lacunarity == lacunarity)
+		return;
 	lacunarity = p_lacunarity;
 	emit_changed();
 }
diff --git a/modules/theora/video_stream_theora.cpp b/modules/theora/video_stream_theora.cpp
index b9f276fb12..f5a7b5fc06 100644
--- a/modules/theora/video_stream_theora.cpp
+++ b/modules/theora/video_stream_theora.cpp
@@ -209,7 +209,8 @@ void VideoStreamPlaybackTheora::set_file(const String &p_file) {
 
 	while (!stateflag) {
 		int ret = buffer_data();
-		if (ret == 0) break;
+		if (ret == 0)
+			break;
 		while (ogg_sync_pageout(&oy, &og) > 0) {
 			ogg_stream_state test;
 
@@ -286,7 +287,8 @@ void VideoStreamPlaybackTheora::set_file(const String &p_file) {
 				return;
 			}
 			vorbis_p++;
-			if (vorbis_p == 3) break;
+			if (vorbis_p == 3)
+				break;
 		}
 
 		/* The header pages/packets will arrive before anything else we
diff --git a/modules/webrtc/webrtc_multiplayer.cpp b/modules/webrtc/webrtc_multiplayer.cpp
index 78a4d1e61a..f294733961 100644
--- a/modules/webrtc/webrtc_multiplayer.cpp
+++ b/modules/webrtc/webrtc_multiplayer.cpp
@@ -144,7 +144,8 @@ void WebRTCMultiplayer::poll() {
 
 void WebRTCMultiplayer::_find_next_peer() {
 	Map<int, Ref<ConnectedPeer>>::Element *E = peer_map.find(next_packet_peer);
-	if (E) E = E->next();
+	if (E)
+		E = E->next();
 	// After last.
 	while (E) {
 		for (List<Ref<WebRTCDataChannel>>::Element *F = E->get()->channels.front(); F; F = F->next()) {
diff --git a/platform/android/export/export.cpp b/platform/android/export/export.cpp
index d4fc52eaa9..f346ca54d2 100644
--- a/platform/android/export/export.cpp
+++ b/platform/android/export/export.cpp
@@ -372,7 +372,8 @@ class EditorExportPlatformAndroid : public EditorExportPlatform {
 							}
 
 							d.name = vendor + " " + device;
-							if (device == String()) continue;
+							if (device == String())
+								continue;
 						}
 
 						ndevices.push_back(d);
diff --git a/platform/android/java/lib/src/org/godotengine/godot/Godot.java b/platform/android/java/lib/src/org/godotengine/godot/Godot.java
index 957f6223a9..ffe5402a54 100644
--- a/platform/android/java/lib/src/org/godotengine/godot/Godot.java
+++ b/platform/android/java/lib/src/org/godotengine/godot/Godot.java
@@ -920,7 +920,8 @@ public abstract class Godot extends FragmentActivity implements SensorEventListe
 		int cnt = 0;
 		for (int i = cc.length; --i >= 0; cnt += cc[i] != 0 ? 1 : 0)
 			;
-		if (cnt == 0) return super.onKeyMultiple(inKeyCode, repeatCount, event);
+		if (cnt == 0)
+			return super.onKeyMultiple(inKeyCode, repeatCount, event);
 		mRenderView.queueOnRenderThread(new Runnable() {
 			// This method will be called on the rendering thread:
 			public void run() {
diff --git a/platform/iphone/export/export.cpp b/platform/iphone/export/export.cpp
index 3efe338ac7..2222a7f552 100644
--- a/platform/iphone/export/export.cpp
+++ b/platform/iphone/export/export.cpp
@@ -423,7 +423,8 @@ String EditorExportPlatformIOS::_get_linker_flags() {
 	String result;
 	for (int i = 0; i < export_plugins.size(); ++i) {
 		String flags = export_plugins[i]->get_ios_linker_flags();
-		if (flags.length() == 0) continue;
+		if (flags.length() == 0)
+			continue;
 		if (result.length() > 0) {
 			result += ' ';
 		}
@@ -456,8 +457,10 @@ void EditorExportPlatformIOS::_blend_and_rotate(Ref<Image> &p_dst, Ref<Image> &p
 	int xs = (x_pos >= 0) ? 0 : -x_pos;
 	int ys = (y_pos >= 0) ? 0 : -y_pos;
 
-	if (sw + x_pos > p_dst->get_width()) sw = p_dst->get_width() - x_pos;
-	if (sh + y_pos > p_dst->get_height()) sh = p_dst->get_height() - y_pos;
+	if (sw + x_pos > p_dst->get_width())
+		sw = p_dst->get_width() - x_pos;
+	if (sh + y_pos > p_dst->get_height())
+		sh = p_dst->get_height() - y_pos;
 
 	for (int y = ys; y < sh; y++) {
 		for (int x = xs; x < sw; x++) {
diff --git a/platform/iphone/godot_iphone.cpp b/platform/iphone/godot_iphone.cpp
index 3e67362e16..cea0e5c7f0 100644
--- a/platform/iphone/godot_iphone.cpp
+++ b/platform/iphone/godot_iphone.cpp
@@ -50,7 +50,8 @@ int iphone_main(int width, int height, int argc, char **argv, String data_dir) {
 	size_t len = strlen(argv[0]);
 
 	while (len--) {
-		if (argv[0][len] == '/') break;
+		if (argv[0][len] == '/')
+			break;
 	}
 
 	if (len >= 0) {
diff --git a/platform/linuxbsd/detect_prime_x11.cpp b/platform/linuxbsd/detect_prime_x11.cpp
index 1bec65ff04..1e46d3222d 100644
--- a/platform/linuxbsd/detect_prime_x11.cpp
+++ b/platform/linuxbsd/detect_prime_x11.cpp
@@ -178,7 +178,8 @@ int detect_prime() {
 
 			close(fdset[0]);
 
-			if (i) setenv("DRI_PRIME", "1", 1);
+			if (i)
+				setenv("DRI_PRIME", "1", 1);
 			create_context();
 
 			const char *vendor = (const char *)glGetString(GL_VENDOR);
diff --git a/platform/linuxbsd/display_server_x11.cpp b/platform/linuxbsd/display_server_x11.cpp
index dd9298d667..f016892453 100644
--- a/platform/linuxbsd/display_server_x11.cpp
+++ b/platform/linuxbsd/display_server_x11.cpp
@@ -551,7 +551,8 @@ int DisplayServerX11::get_screen_count() const {
 	// Using Xinerama Extension
 	int event_base, error_base;
 	const Bool ext_okay = XineramaQueryExtension(x11_display, &event_base, &error_base);
-	if (!ext_okay) return 0;
+	if (!ext_okay)
+		return 0;
 
 	int count;
 	XineramaScreenInfo *xsi = XineramaQueryScreens(x11_display, &count);
@@ -600,11 +601,13 @@ Rect2i DisplayServerX11::screen_get_usable_rect(int p_screen) const {
 	// Using Xinerama Extension
 	int event_base, error_base;
 	const Bool ext_okay = XineramaQueryExtension(x11_display, &event_base, &error_base);
-	if (!ext_okay) return Rect2i(0, 0, 0, 0);
+	if (!ext_okay)
+		return Rect2i(0, 0, 0, 0);
 
 	int count;
 	XineramaScreenInfo *xsi = XineramaQueryScreens(x11_display, &count);
-	if (p_screen >= count) return Rect2i(0, 0, 0, 0);
+	if (p_screen >= count)
+		return Rect2i(0, 0, 0, 0);
 
 	Rect2i rect = Rect2i(xsi[p_screen].x_org, xsi[p_screen].y_org, xsi[p_screen].width, xsi[p_screen].height);
 	XFree(xsi);
@@ -827,7 +830,8 @@ void DisplayServerX11::window_set_current_screen(int p_screen, WindowID p_window
 	WindowData &wd = windows[p_window];
 
 	int count = get_screen_count();
-	if (p_screen >= count) return;
+	if (p_screen >= count)
+		return;
 
 	if (window_get_mode(p_window) == WINDOW_MODE_FULLSCREEN) {
 		Point2i position = screen_get_position(p_screen);
diff --git a/platform/linuxbsd/joypad_linux.cpp b/platform/linuxbsd/joypad_linux.cpp
index 5ceea788e0..f57f74907f 100644
--- a/platform/linuxbsd/joypad_linux.cpp
+++ b/platform/linuxbsd/joypad_linux.cpp
@@ -463,7 +463,8 @@ void JoypadLinux::process_joypads() {
 	}
 	for (int i = 0; i < JOYPADS_MAX; i++) {
 
-		if (joypads[i].fd == -1) continue;
+		if (joypads[i].fd == -1)
+			continue;
 
 		input_event events[32];
 		Joypad *joy = &joypads[i];
diff --git a/platform/osx/display_server_osx.mm b/platform/osx/display_server_osx.mm
index 9d92992332..5dc14bc33f 100644
--- a/platform/osx/display_server_osx.mm
+++ b/platform/osx/display_server_osx.mm
@@ -1656,7 +1656,8 @@ String DisplayServerOSX::global_menu_get_item_submenu(const String &p_menu_root,
 			const NSMenu *sub_menu = [menu_item submenu];
 			if (sub_menu) {
 				for (Map<String, NSMenu *>::Element *E = submenu.front(); E; E = E->next()) {
-					if (E->get() == sub_menu) return E->key();
+					if (E->get() == sub_menu)
+						return E->key();
 				}
 			}
 		}
@@ -2479,7 +2480,8 @@ void DisplayServerOSX::_set_window_per_pixel_transparency_enabled(bool p_enabled
 	ERR_FAIL_COND(!windows.has(p_window));
 	WindowData &wd = windows[p_window];
 
-	if (!OS_OSX::get_singleton()->is_layered_allowed()) return;
+	if (!OS_OSX::get_singleton()->is_layered_allowed())
+		return;
 	if (wd.layered_window != p_enabled) {
 		if (p_enabled) {
 			[wd.window_object setBackgroundColor:[NSColor clearColor]];
diff --git a/platform/osx/joypad_osx.cpp b/platform/osx/joypad_osx.cpp
index 7f5ec05967..0f50ba63c6 100644
--- a/platform/osx/joypad_osx.cpp
+++ b/platform/osx/joypad_osx.cpp
@@ -374,7 +374,8 @@ bool joypad::check_ff_features() {
 	if (ret == FF_OK && (features.supportedEffects & FFCAP_ET_CONSTANTFORCE)) {
 		uint32_t val;
 		ret = FFDeviceGetForceFeedbackProperty(ff_device, FFPROP_FFGAIN, &val, sizeof(val));
-		if (ret != FF_OK) return false;
+		if (ret != FF_OK)
+			return false;
 		int num_axes = features.numFfAxes;
 		ff_axes = (DWORD *)memalloc(sizeof(DWORD) * num_axes);
 		ff_directions = (LONG *)memalloc(sizeof(LONG) * num_axes);
@@ -509,14 +510,16 @@ void JoypadOSX::joypad_vibration_stop(int p_id, uint64_t p_timestamp) {
 
 int JoypadOSX::get_joy_index(int p_id) const {
 	for (int i = 0; i < device_list.size(); i++) {
-		if (device_list[i].id == p_id) return i;
+		if (device_list[i].id == p_id)
+			return i;
 	}
 	return -1;
 }
 
 int JoypadOSX::get_joy_ref(IOHIDDeviceRef p_device) const {
 	for (int i = 0; i < device_list.size(); i++) {
-		if (device_list[i].device_ref == p_device) return i;
+		if (device_list[i].device_ref == p_device)
+			return i;
 	}
 	return -1;
 }
diff --git a/platform/uwp/export/export.cpp b/platform/uwp/export/export.cpp
index 06bf738dc1..f6618bfb47 100644
--- a/platform/uwp/export/export.cpp
+++ b/platform/uwp/export/export.cpp
@@ -265,7 +265,8 @@ void AppxPackager::make_content_types(const String &p_path) {
 
 		String ext = file_metadata[i].name.get_extension();
 
-		if (types.has(ext)) continue;
+		if (types.has(ext))
+			continue;
 
 		types[ext] = content_type(ext);
 
@@ -664,8 +665,10 @@ class EditorExportPlatformUWP : public EditorExportPlatform {
 
 	bool _valid_resource_name(const String &p_name) const {
 
-		if (p_name.empty()) return false;
-		if (p_name.ends_with(".")) return false;
+		if (p_name.empty())
+			return false;
+		if (p_name.ends_with("."))
+			return false;
 
 		static const char *invalid_names[] = {
 			"CON", "PRN", "AUX", "NUL", "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7",
@@ -675,7 +678,8 @@ class EditorExportPlatformUWP : public EditorExportPlatform {
 
 		const char **t = invalid_names;
 		while (*t) {
-			if (p_name == *t) return false;
+			if (p_name == *t)
+				return false;
 			t++;
 		}
 
@@ -686,19 +690,25 @@ class EditorExportPlatformUWP : public EditorExportPlatform {
 
 		Vector<String> parts = p_guid.split("-");
 
-		if (parts.size() != 5) return false;
-		if (parts[0].length() != 8) return false;
+		if (parts.size() != 5)
+			return false;
+		if (parts[0].length() != 8)
+			return false;
 		for (int i = 1; i < 4; i++)
-			if (parts[i].length() != 4) return false;
-		if (parts[4].length() != 12) return false;
+			if (parts[i].length() != 4)
+				return false;
+		if (parts[4].length() != 12)
+			return false;
 
 		return true;
 	}
 
 	bool _valid_bgcolor(const String &p_color) const {
 
-		if (p_color.empty()) return true;
-		if (p_color.begins_with("#") && p_color.is_valid_html_color()) return true;
+		if (p_color.empty())
+			return true;
+		if (p_color.begins_with("#") && p_color.is_valid_html_color())
+			return true;
 
 		// Colors from https://msdn.microsoft.com/en-us/library/windows/apps/dn934817.aspx
 		static const char *valid_colors[] = {
@@ -732,7 +742,8 @@ class EditorExportPlatformUWP : public EditorExportPlatform {
 		const char **color = valid_colors;
 
 		while (*color) {
-			if (p_color == *color) return true;
+			if (p_color == *color)
+				return true;
 			color++;
 		}
 
@@ -896,7 +907,8 @@ class EditorExportPlatformUWP : public EditorExportPlatform {
 			ERR_PRINT("Unable to load logo");
 		}
 
-		if (!image) return data;
+		if (!image)
+			return data;
 
 		String tmp_path = EditorSettings::get_singleton()->get_cache_dir().plus_file("uwp_tmp_logo.png");
 
@@ -1301,7 +1313,8 @@ public:
 				path = path.replace(".scale-100", "");
 
 				data = _get_image_data(p_preset, path);
-				if (data.size() > 0) do_read = false;
+				if (data.size() > 0)
+					do_read = false;
 			}
 
 			//read
diff --git a/platform/uwp/joypad_uwp.cpp b/platform/uwp/joypad_uwp.cpp
index 90df6fe5d7..93a9992706 100644
--- a/platform/uwp/joypad_uwp.cpp
+++ b/platform/uwp/joypad_uwp.cpp
@@ -48,7 +48,8 @@ void JoypadUWP::process_controllers() {
 
 		ControllerDevice &joy = controllers[i];
 
-		if (!joy.connected) break;
+		if (!joy.connected)
+			break;
 
 		switch (joy.type) {
 
diff --git a/platform/uwp/os_uwp.cpp b/platform/uwp/os_uwp.cpp
index f5e989b370..1c83ebfdf7 100644
--- a/platform/uwp/os_uwp.cpp
+++ b/platform/uwp/os_uwp.cpp
@@ -123,7 +123,8 @@ bool OS_UWP::is_window_fullscreen() const {
 
 void OS_UWP::set_keep_screen_on(bool p_enabled) {
 
-	if (is_keep_screen_on() == p_enabled) return;
+	if (is_keep_screen_on() == p_enabled)
+		return;
 
 	if (p_enabled)
 		display_request->RequestActive();
@@ -826,7 +827,8 @@ void OS_UWP::run() {
 	while (!force_quit) {
 
 		CoreWindow::GetForCurrentThread()->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessAllIfPresent);
-		if (managed_object->alert_close_handle) continue;
+		if (managed_object->alert_close_handle)
+			continue;
 		process_events(); // get rid of pending events
 		if (Main::iteration())
 			break;
diff --git a/platform/windows/display_server_windows.cpp b/platform/windows/display_server_windows.cpp
index 701cf69207..5063a0929a 100644
--- a/platform/windows/display_server_windows.cpp
+++ b/platform/windows/display_server_windows.cpp
@@ -677,7 +677,8 @@ void DisplayServerWindows::window_set_position(const Point2i &p_position, Window
 	ERR_FAIL_COND(!windows.has(p_window));
 	WindowData &wd = windows[p_window];
 
-	if (wd.fullscreen) return;
+	if (wd.fullscreen)
+		return;
 #if 0
 	//wrong needs to account properly for decorations
 	RECT r;
@@ -1474,19 +1475,22 @@ DisplayServer::LatinKeyboardVariant DisplayServerWindows::get_latin_keyboard_var
 
 	int i = 0;
 	while (azerty[i] != 0) {
-		if (azerty[i] == hex) return LATIN_KEYBOARD_AZERTY;
+		if (azerty[i] == hex)
+			return LATIN_KEYBOARD_AZERTY;
 		i++;
 	}
 
 	i = 0;
 	while (qwertz[i] != 0) {
-		if (qwertz[i] == hex) return LATIN_KEYBOARD_QWERTZ;
+		if (qwertz[i] == hex)
+			return LATIN_KEYBOARD_QWERTZ;
 		i++;
 	}
 
 	i = 0;
 	while (dvorak[i] != 0) {
-		if (dvorak[i] == hex) return LATIN_KEYBOARD_DVORAK;
+		if (dvorak[i] == hex)
+			return LATIN_KEYBOARD_DVORAK;
 		i++;
 	}
 
diff --git a/platform/windows/joypad_windows.cpp b/platform/windows/joypad_windows.cpp
index 2adf2a8652..8fdc92a79c 100644
--- a/platform/windows/joypad_windows.cpp
+++ b/platform/windows/joypad_windows.cpp
@@ -112,7 +112,8 @@ bool JoypadWindows::is_xinput_device(const GUID *p_guid) {
 		return false;
 	}
 	dev_list = (PRAWINPUTDEVICELIST)malloc(sizeof(RAWINPUTDEVICELIST) * dev_list_count);
-	if (!dev_list) return false;
+	if (!dev_list)
+		return false;
 
 	if (GetRawInputDeviceList(dev_list, &dev_list_count, sizeof(RAWINPUTDEVICELIST)) == (UINT)-1) {
 		free(dev_list);
@@ -267,7 +268,8 @@ void JoypadWindows::close_joypad(int id) {
 		return;
 	}
 
-	if (!d_joypads[id].attached) return;
+	if (!d_joypads[id].attached)
+		return;
 
 	d_joypads[id].di_joy->Unacquire();
 	d_joypads[id].di_joy->Release();
diff --git a/scene/2d/cpu_particles_2d.cpp b/scene/2d/cpu_particles_2d.cpp
index 0a6b091a51..c37cd398c4 100644
--- a/scene/2d/cpu_particles_2d.cpp
+++ b/scene/2d/cpu_particles_2d.cpp
@@ -961,7 +961,8 @@ void CPUParticles2D::_particles_process(float p_delta) {
 
 		//scale by scale
 		float base_scale = tex_scale * Math::lerp(parameters[PARAM_SCALE], 1.0f, p.scale_rand * randomness[PARAM_SCALE]);
-		if (base_scale < 0.000001) base_scale = 0.000001;
+		if (base_scale < 0.000001)
+			base_scale = 0.000001;
 
 		p.transform.elements[0] *= base_scale;
 		p.transform.elements[1] *= base_scale;
@@ -1196,7 +1197,8 @@ void CPUParticles2D::convert_from_particles(Node *p_particles) {
 	set_param(m_param, material->get_param(ParticlesMaterial::m_param));                  \
 	{                                                                                     \
 		Ref<CurveTexture> ctex = material->get_param_texture(ParticlesMaterial::m_param); \
-		if (ctex.is_valid()) set_param_curve(m_param, ctex->get_curve());                 \
+		if (ctex.is_valid())                                                              \
+			set_param_curve(m_param, ctex->get_curve());                                  \
 	}                                                                                     \
 	set_param_randomness(m_param, material->get_param_randomness(ParticlesMaterial::m_param));
 
diff --git a/scene/2d/navigation_agent_2d.cpp b/scene/2d/navigation_agent_2d.cpp
index 32da46e8a8..df23a40721 100644
--- a/scene/2d/navigation_agent_2d.cpp
+++ b/scene/2d/navigation_agent_2d.cpp
@@ -288,9 +288,12 @@ String NavigationAgent2D::get_configuration_warning() const {
 
 void NavigationAgent2D::update_navigation() {
 
-	if (agent_parent == nullptr) return;
-	if (navigation == nullptr) return;
-	if (update_frame_id == Engine::get_singleton()->get_physics_frames()) return;
+	if (agent_parent == nullptr)
+		return;
+	if (navigation == nullptr)
+		return;
+	if (update_frame_id == Engine::get_singleton()->get_physics_frames())
+		return;
 
 	update_frame_id = Engine::get_singleton()->get_physics_frames();
 
diff --git a/scene/2d/physics_body_2d.cpp b/scene/2d/physics_body_2d.cpp
index de15f0efc2..4198eb6c06 100644
--- a/scene/2d/physics_body_2d.cpp
+++ b/scene/2d/physics_body_2d.cpp
@@ -1394,7 +1394,8 @@ Vector2 KinematicCollision2D::get_remainder() const {
 	return collision.remainder;
 }
 Object *KinematicCollision2D::get_local_shape() const {
-	if (!owner) return nullptr;
+	if (!owner)
+		return nullptr;
 	uint32_t ownerid = owner->shape_find_owner(collision.local_shape);
 	return owner->shape_owner_get_owner(ownerid);
 }
diff --git a/scene/2d/tile_map.cpp b/scene/2d/tile_map.cpp
index 86e61fe878..ac8136a79f 100644
--- a/scene/2d/tile_map.cpp
+++ b/scene/2d/tile_map.cpp
@@ -1355,7 +1355,8 @@ bool TileMap::get_collision_use_parent() const {
 
 void TileMap::set_collision_use_parent(bool p_use_parent) {
 
-	if (use_parent == p_use_parent) return;
+	if (use_parent == p_use_parent)
+		return;
 
 	_clear_quadrants();
 
diff --git a/scene/3d/cpu_particles_3d.cpp b/scene/3d/cpu_particles_3d.cpp
index 4c25f55f0b..414dc6f97b 100644
--- a/scene/3d/cpu_particles_3d.cpp
+++ b/scene/3d/cpu_particles_3d.cpp
@@ -1004,7 +1004,8 @@ void CPUParticles3D::_particles_process(float p_delta) {
 
 		//scale by scale
 		float base_scale = tex_scale * Math::lerp(parameters[PARAM_SCALE], 1.0f, p.scale_rand * randomness[PARAM_SCALE]);
-		if (base_scale < 0.000001) base_scale = 0.000001;
+		if (base_scale < 0.000001)
+			base_scale = 0.000001;
 
 		p.transform.basis.scale(Vector3(1, 1, 1) * base_scale);
 
@@ -1253,7 +1254,8 @@ void CPUParticles3D::convert_from_particles(Node *p_particles) {
 	set_param(m_param, material->get_param(ParticlesMaterial::m_param));                  \
 	{                                                                                     \
 		Ref<CurveTexture> ctex = material->get_param_texture(ParticlesMaterial::m_param); \
-		if (ctex.is_valid()) set_param_curve(m_param, ctex->get_curve());                 \
+		if (ctex.is_valid())                                                              \
+			set_param_curve(m_param, ctex->get_curve());                                  \
 	}                                                                                     \
 	set_param_randomness(m_param, material->get_param_randomness(ParticlesMaterial::m_param));
 
diff --git a/scene/3d/gpu_particles_3d.cpp b/scene/3d/gpu_particles_3d.cpp
index 7744c477cb..01886a730f 100644
--- a/scene/3d/gpu_particles_3d.cpp
+++ b/scene/3d/gpu_particles_3d.cpp
@@ -257,7 +257,8 @@ String GPUParticles3D::get_configuration_warning() const {
 				StandardMaterial3D *spat = Object::cast_to<StandardMaterial3D>(draw_passes[i]->surface_get_material(j).ptr());
 				anim_material_found = anim_material_found || (spat && spat->get_billboard_mode() == StandardMaterial3D::BILLBOARD_PARTICLES);
 			}
-			if (anim_material_found) break;
+			if (anim_material_found)
+				break;
 		}
 	}
 
diff --git a/scene/3d/navigation_agent_3d.cpp b/scene/3d/navigation_agent_3d.cpp
index 0449ab15b7..e672ed9a54 100644
--- a/scene/3d/navigation_agent_3d.cpp
+++ b/scene/3d/navigation_agent_3d.cpp
@@ -306,9 +306,12 @@ String NavigationAgent3D::get_configuration_warning() const {
 
 void NavigationAgent3D::update_navigation() {
 
-	if (agent_parent == nullptr) return;
-	if (navigation == nullptr) return;
-	if (update_frame_id == Engine::get_singleton()->get_physics_frames()) return;
+	if (agent_parent == nullptr)
+		return;
+	if (navigation == nullptr)
+		return;
+	if (update_frame_id == Engine::get_singleton()->get_physics_frames())
+		return;
 
 	update_frame_id = Engine::get_singleton()->get_physics_frames();
 
diff --git a/scene/3d/physics_body_3d.cpp b/scene/3d/physics_body_3d.cpp
index 3991efc7c0..280bab5d45 100644
--- a/scene/3d/physics_body_3d.cpp
+++ b/scene/3d/physics_body_3d.cpp
@@ -1346,7 +1346,8 @@ Vector3 KinematicCollision3D::get_remainder() const {
 	return collision.remainder;
 }
 Object *KinematicCollision3D::get_local_shape() const {
-	if (!owner) return nullptr;
+	if (!owner)
+		return nullptr;
 	uint32_t ownerid = owner->shape_find_owner(collision.local_shape);
 	return owner->shape_owner_get_owner(ownerid);
 }
diff --git a/scene/3d/voxelizer.cpp b/scene/3d/voxelizer.cpp
index f30c58be55..a2d305f3cb 100644
--- a/scene/3d/voxelizer.cpp
+++ b/scene/3d/voxelizer.cpp
@@ -36,10 +36,14 @@
 
 #define FINDMINMAX(x0, x1, x2, min, max) \
 	min = max = x0;                      \
-	if (x1 < min) min = x1;              \
-	if (x1 > max) max = x1;              \
-	if (x2 < min) min = x2;              \
-	if (x2 > max) max = x2;
+	if (x1 < min)                        \
+		min = x1;                        \
+	if (x1 > max)                        \
+		max = x1;                        \
+	if (x2 < min)                        \
+		min = x2;                        \
+	if (x2 > max)                        \
+		max = x2;
 
 static bool planeBoxOverlap(Vector3 normal, float d, Vector3 maxbox) {
 	int q;
@@ -53,8 +57,10 @@ static bool planeBoxOverlap(Vector3 normal, float d, Vector3 maxbox) {
 			vmax[q] = -maxbox[q];
 		}
 	}
-	if (normal.dot(vmin) + d > 0.0f) return false;
-	if (normal.dot(vmax) + d >= 0.0f) return true;
+	if (normal.dot(vmin) + d > 0.0f)
+		return false;
+	if (normal.dot(vmax) + d >= 0.0f)
+		return true;
 
 	return false;
 }
@@ -71,7 +77,8 @@ static bool planeBoxOverlap(Vector3 normal, float d, Vector3 maxbox) {
 		max = p0;                                  \
 	}                                              \
 	rad = fa * boxhalfsize.y + fb * boxhalfsize.z; \
-	if (min > rad || max < -rad) return false;
+	if (min > rad || max < -rad)                   \
+		return false;
 
 #define AXISTEST_X2(a, b, fa, fb)                  \
 	p0 = a * v0.y - b * v0.z;                      \
@@ -84,7 +91,8 @@ static bool planeBoxOverlap(Vector3 normal, float d, Vector3 maxbox) {
 		max = p0;                                  \
 	}                                              \
 	rad = fa * boxhalfsize.y + fb * boxhalfsize.z; \
-	if (min > rad || max < -rad) return false;
+	if (min > rad || max < -rad)                   \
+		return false;
 
 /*======================== Y-tests ========================*/
 #define AXISTEST_Y02(a, b, fa, fb)                 \
@@ -98,7 +106,8 @@ static bool planeBoxOverlap(Vector3 normal, float d, Vector3 maxbox) {
 		max = p0;                                  \
 	}                                              \
 	rad = fa * boxhalfsize.x + fb * boxhalfsize.z; \
-	if (min > rad || max < -rad) return false;
+	if (min > rad || max < -rad)                   \
+		return false;
 
 #define AXISTEST_Y1(a, b, fa, fb)                  \
 	p0 = -a * v0.x + b * v0.z;                     \
@@ -111,7 +120,8 @@ static bool planeBoxOverlap(Vector3 normal, float d, Vector3 maxbox) {
 		max = p0;                                  \
 	}                                              \
 	rad = fa * boxhalfsize.x + fb * boxhalfsize.z; \
-	if (min > rad || max < -rad) return false;
+	if (min > rad || max < -rad)                   \
+		return false;
 
 /*======================== Z-tests ========================*/
 
@@ -126,7 +136,8 @@ static bool planeBoxOverlap(Vector3 normal, float d, Vector3 maxbox) {
 		max = p2;                                  \
 	}                                              \
 	rad = fa * boxhalfsize.x + fb * boxhalfsize.y; \
-	if (min > rad || max < -rad) return false;
+	if (min > rad || max < -rad)                   \
+		return false;
 
 #define AXISTEST_Z0(a, b, fa, fb)                  \
 	p0 = a * v0.x - b * v0.y;                      \
@@ -139,7 +150,8 @@ static bool planeBoxOverlap(Vector3 normal, float d, Vector3 maxbox) {
 		max = p0;                                  \
 	}                                              \
 	rad = fa * boxhalfsize.x + fb * boxhalfsize.y; \
-	if (min > rad || max < -rad) return false;
+	if (min > rad || max < -rad)                   \
+		return false;
 
 static bool fast_tri_box_overlap(const Vector3 &boxcenter, const Vector3 boxhalfsize, const Vector3 *triverts) {
 
@@ -197,15 +209,18 @@ static bool fast_tri_box_overlap(const Vector3 &boxcenter, const Vector3 boxhalf
 
 	/* test in X-direction */
 	FINDMINMAX(v0.x, v1.x, v2.x, min, max);
-	if (min > boxhalfsize.x || max < -boxhalfsize.x) return false;
+	if (min > boxhalfsize.x || max < -boxhalfsize.x)
+		return false;
 
 	/* test in Y-direction */
 	FINDMINMAX(v0.y, v1.y, v2.y, min, max);
-	if (min > boxhalfsize.y || max < -boxhalfsize.y) return false;
+	if (min > boxhalfsize.y || max < -boxhalfsize.y)
+		return false;
 
 	/* test in Z-direction */
 	FINDMINMAX(v0.z, v1.z, v2.z, min, max);
-	if (min > boxhalfsize.z || max < -boxhalfsize.z) return false;
+	if (min > boxhalfsize.z || max < -boxhalfsize.z)
+		return false;
 
 	/* Bullet 2: */
 	/*  test if the box intersects the plane of the triangle */
diff --git a/scene/animation/tween.cpp b/scene/animation/tween.cpp
index d0c6cac8cf..963ba2a106 100644
--- a/scene/animation/tween.cpp
+++ b/scene/animation/tween.cpp
@@ -353,7 +353,8 @@ Variant Tween::_get_final_val(const InterpolateData &p_data) const {
 
 			// If we're looking at an INT value, instead convert it to a FLOAT
 			// This is better for interpolation
-			if (final_val.get_type() == Variant::INT) final_val = final_val.operator real_t();
+			if (final_val.get_type() == Variant::INT)
+				final_val = final_val.operator real_t();
 
 			return final_val;
 		}
@@ -395,7 +396,8 @@ Variant &Tween::_get_delta_val(InterpolateData &p_data) {
 
 			// If we're looking at an INT value, instead convert it to a FLOAT
 			// This is better for interpolation
-			if (final_val.get_type() == Variant::INT) final_val = final_val.operator real_t();
+			if (final_val.get_type() == Variant::INT)
+				final_val = final_val.operator real_t();
 
 			// Calculate the delta based on the initial value and the final value
 			_calc_delta_val(p_data.initial_val, final_val, p_data.delta_val);
@@ -409,7 +411,8 @@ Variant &Tween::_get_delta_val(InterpolateData &p_data) {
 
 			// If we're looking at an INT value, instead convert it to a FLOAT
 			// This is better for interpolation
-			if (initial_val.get_type() == Variant::INT) initial_val = initial_val.operator real_t();
+			if (initial_val.get_type() == Variant::INT)
+				initial_val = initial_val.operator real_t();
 
 			// Calculate the delta based on the initial value and the final value
 			_calc_delta_val(initial_val, p_data.final_val, p_data.delta_val);
@@ -1334,11 +1337,14 @@ void Tween::interpolate_property(Object *p_object, NodePath p_property, Variant
 
 	// If no initial value given, grab the initial value from the object
 	// TODO: Is this documented? This is very useful and removes a lot of clutter from tweens!
-	if (p_initial_val.get_type() == Variant::NIL) p_initial_val = p_object->get_indexed(p_property.get_subnames());
+	if (p_initial_val.get_type() == Variant::NIL)
+		p_initial_val = p_object->get_indexed(p_property.get_subnames());
 
 	// Convert any integers into REALs as they are better for interpolation
-	if (p_initial_val.get_type() == Variant::INT) p_initial_val = p_initial_val.operator real_t();
-	if (p_final_val.get_type() == Variant::INT) p_final_val = p_final_val.operator real_t();
+	if (p_initial_val.get_type() == Variant::INT)
+		p_initial_val = p_initial_val.operator real_t();
+	if (p_final_val.get_type() == Variant::INT)
+		p_final_val = p_final_val.operator real_t();
 
 	// Build the interpolation data
 	_build_interpolation(INTER_PROPERTY, p_object, &p_property, nullptr, p_initial_val, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay);
@@ -1352,8 +1358,10 @@ void Tween::interpolate_method(Object *p_object, StringName p_method, Variant p_
 	}
 
 	// Convert any integers into REALs as they are better for interpolation
-	if (p_initial_val.get_type() == Variant::INT) p_initial_val = p_initial_val.operator real_t();
-	if (p_final_val.get_type() == Variant::INT) p_final_val = p_final_val.operator real_t();
+	if (p_initial_val.get_type() == Variant::INT)
+		p_initial_val = p_initial_val.operator real_t();
+	if (p_final_val.get_type() == Variant::INT)
+		p_final_val = p_final_val.operator real_t();
 
 	// Build the interpolation data
 	_build_interpolation(INTER_METHOD, p_object, nullptr, &p_method, p_initial_val, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay);
@@ -1486,10 +1494,12 @@ void Tween::follow_property(Object *p_object, NodePath p_property, Variant p_ini
 
 	// If no initial value is given, grab it from the source object
 	// TODO: Is this documented? It's really helpful for decluttering tweens
-	if (p_initial_val.get_type() == Variant::NIL) p_initial_val = p_object->get_indexed(p_property.get_subnames());
+	if (p_initial_val.get_type() == Variant::NIL)
+		p_initial_val = p_object->get_indexed(p_property.get_subnames());
 
 	// Convert initial INT values to FLOAT as they are better for interpolation
-	if (p_initial_val.get_type() == Variant::INT) p_initial_val = p_initial_val.operator real_t();
+	if (p_initial_val.get_type() == Variant::INT)
+		p_initial_val = p_initial_val.operator real_t();
 
 	// Confirm the source and target objects are valid
 	ERR_FAIL_COND(p_object == nullptr);
@@ -1515,7 +1525,8 @@ void Tween::follow_property(Object *p_object, NodePath p_property, Variant p_ini
 	ERR_FAIL_COND(!target_prop_valid);
 
 	// Convert target INT to FLOAT since it is better for interpolation
-	if (target_val.get_type() == Variant::INT) target_val = target_val.operator real_t();
+	if (target_val.get_type() == Variant::INT)
+		target_val = target_val.operator real_t();
 
 	// Verify that the target value and initial value are the same type
 	ERR_FAIL_COND(target_val.get_type() != p_initial_val.get_type());
@@ -1550,7 +1561,8 @@ void Tween::follow_method(Object *p_object, StringName p_method, Variant p_initi
 		return;
 	}
 	// Convert initial INT values to FLOAT as they are better for interpolation
-	if (p_initial_val.get_type() == Variant::INT) p_initial_val = p_initial_val.operator real_t();
+	if (p_initial_val.get_type() == Variant::INT)
+		p_initial_val = p_initial_val.operator real_t();
 
 	// Verify the source and target objects are valid
 	ERR_FAIL_COND(p_object == nullptr);
@@ -1576,7 +1588,8 @@ void Tween::follow_method(Object *p_object, StringName p_method, Variant p_initi
 	ERR_FAIL_COND(error.error != Callable::CallError::CALL_OK);
 
 	// Convert target INT values to FLOAT as they are better for interpolation
-	if (target_val.get_type() == Variant::INT) target_val = target_val.operator real_t();
+	if (target_val.get_type() == Variant::INT)
+		target_val = target_val.operator real_t();
 	ERR_FAIL_COND(target_val.get_type() != p_initial_val.get_type());
 
 	// Make the new InterpolateData for the method follow
@@ -1613,7 +1626,8 @@ void Tween::targeting_property(Object *p_object, NodePath p_property, Object *p_
 	p_initial_property = p_initial_property.get_as_property_path();
 
 	// Convert the initial INT values to FLOAT as they are better for Interpolation
-	if (p_final_val.get_type() == Variant::INT) p_final_val = p_final_val.operator real_t();
+	if (p_final_val.get_type() == Variant::INT)
+		p_final_val = p_final_val.operator real_t();
 
 	// Verify both objects are valid
 	ERR_FAIL_COND(p_object == nullptr);
@@ -1639,7 +1653,8 @@ void Tween::targeting_property(Object *p_object, NodePath p_property, Object *p_
 	ERR_FAIL_COND(!initial_prop_valid);
 
 	// Convert the initial INT value to FLOAT as it is better for interpolation
-	if (initial_val.get_type() == Variant::INT) initial_val = initial_val.operator real_t();
+	if (initial_val.get_type() == Variant::INT)
+		initial_val = initial_val.operator real_t();
 	ERR_FAIL_COND(initial_val.get_type() != p_final_val.get_type());
 
 	// Build the InterpolateData object
@@ -1679,7 +1694,8 @@ void Tween::targeting_method(Object *p_object, StringName p_method, Object *p_in
 	}
 
 	// Convert final INT values to FLOAT as they are better for interpolation
-	if (p_final_val.get_type() == Variant::INT) p_final_val = p_final_val.operator real_t();
+	if (p_final_val.get_type() == Variant::INT)
+		p_final_val = p_final_val.operator real_t();
 
 	// Make sure the given objects are valid
 	ERR_FAIL_COND(p_object == nullptr);
@@ -1705,7 +1721,8 @@ void Tween::targeting_method(Object *p_object, StringName p_method, Object *p_in
 	ERR_FAIL_COND(error.error != Callable::CallError::CALL_OK);
 
 	// Convert initial INT values to FLOAT as they aer better for interpolation
-	if (initial_val.get_type() == Variant::INT) initial_val = initial_val.operator real_t();
+	if (initial_val.get_type() == Variant::INT)
+		initial_val = initial_val.operator real_t();
 	ERR_FAIL_COND(initial_val.get_type() != p_final_val.get_type());
 
 	// Build the new InterpolateData object
diff --git a/scene/gui/file_dialog.cpp b/scene/gui/file_dialog.cpp
index 89d13ecd7f..a449d680a8 100644
--- a/scene/gui/file_dialog.cpp
+++ b/scene/gui/file_dialog.cpp
@@ -410,7 +410,8 @@ void FileDialog::_tree_item_activated() {
 void FileDialog::update_file_name() {
 	int idx = filter->get_selected() - 1;
 	if ((idx == -1 && filter->get_item_count() == 2) || (filter->get_item_count() > 2 && idx >= 0 && idx < filter->get_item_count() - 2)) {
-		if (idx == -1) idx += 1;
+		if (idx == -1)
+			idx += 1;
 		String filter_str = filters[idx];
 		String file_str = file->get_text();
 		String base_name = file_str.get_basename();
diff --git a/scene/gui/line_edit.cpp b/scene/gui/line_edit.cpp
index b9b7560f2e..8574b05016 100644
--- a/scene/gui/line_edit.cpp
+++ b/scene/gui/line_edit.cpp
@@ -463,14 +463,16 @@ void LineEdit::_gui_input(Ref<InputEvent> p_event) {
 				case KEY_UP: {
 
 					shift_selection_check_pre(k->get_shift());
-					if (get_cursor_position() == 0) handled = false;
+					if (get_cursor_position() == 0)
+						handled = false;
 					set_cursor_position(0);
 					shift_selection_check_post(k->get_shift());
 				} break;
 				case KEY_DOWN: {
 
 					shift_selection_check_pre(k->get_shift());
-					if (get_cursor_position() == text.length()) handled = false;
+					if (get_cursor_position() == text.length())
+						handled = false;
 					set_cursor_position(text.length());
 					shift_selection_check_post(k->get_shift());
 				} break;
@@ -988,7 +990,8 @@ void LineEdit::paste_text() {
 	if (paste_buffer != "") {
 
 		int prev_len = text.length();
-		if (selection.enabled) selection_delete();
+		if (selection.enabled)
+			selection_delete();
 		append_at_cursor(paste_buffer);
 
 		if (!text_changed_dirty) {
@@ -1204,7 +1207,8 @@ void LineEdit::_toggle_draw_caret() {
 
 void LineEdit::delete_char() {
 
-	if ((text.length() <= 0) || (cursor_pos == 0)) return;
+	if ((text.length() <= 0) || (cursor_pos == 0))
+		return;
 
 	Ref<Font> font = get_theme_font("font");
 	if (font != nullptr) {
@@ -1379,7 +1383,8 @@ int LineEdit::get_cursor_position() const {
 void LineEdit::set_window_pos(int p_pos) {
 
 	window_pos = p_pos;
-	if (window_pos < 0) window_pos = 0;
+	if (window_pos < 0)
+		window_pos = 0;
 }
 
 void LineEdit::append_at_cursor(String p_text) {
diff --git a/scene/gui/rich_text_label.cpp b/scene/gui/rich_text_label.cpp
index 84097eb6a1..b5b61e2631 100644
--- a/scene/gui/rich_text_label.cpp
+++ b/scene/gui/rich_text_label.cpp
@@ -255,7 +255,8 @@ int RichTextLabel::_process_line(ItemFrame *p_frame, const Vector2 &p_ofs, int &
 			line_descent = line < l.descent_caches.size() ? l.descent_caches[line] : 1;                                                                         \
 		}                                                                                                                                                       \
 		if (p_mode == PROCESS_POINTER && r_click_item && p_click_pos.y >= p_ofs.y + y && p_click_pos.y <= p_ofs.y + y + lh && p_click_pos.x < p_ofs.x + wofs) { \
-			if (r_outside) *r_outside = true;                                                                                                                   \
+			if (r_outside)                                                                                                                                      \
+				*r_outside = true;                                                                                                                              \
 			*r_click_item = it;                                                                                                                                 \
 			*r_click_char = rchar;                                                                                                                              \
 			RETURN;                                                                                                                                             \
@@ -275,7 +276,8 @@ int RichTextLabel::_process_line(ItemFrame *p_frame, const Vector2 &p_ofs, int &
 		}                                                                                                                                   \
 		const bool x_in_range = (p_click_pos.x > p_ofs.x + wofs) && (!p_frame->cell || p_click_pos.x < p_ofs.x + p_width);                  \
 		if (p_mode == PROCESS_POINTER && r_click_item && p_click_pos.y >= p_ofs.y + y && p_click_pos.y <= p_ofs.y + y + lh && x_in_range) { \
-			if (r_outside) *r_outside = true;                                                                                               \
+			if (r_outside)                                                                                                                  \
+				*r_outside = true;                                                                                                          \
 			*r_click_item = it;                                                                                                             \
 			*r_click_char = rchar;                                                                                                          \
 			RETURN;                                                                                                                         \
@@ -286,7 +288,8 @@ int RichTextLabel::_process_line(ItemFrame *p_frame, const Vector2 &p_ofs, int &
 #define ADVANCE(m_width)                                                                                                                                                                                     \
 	{                                                                                                                                                                                                        \
 		if (p_mode == PROCESS_POINTER && r_click_item && p_click_pos.y >= p_ofs.y + y && p_click_pos.y <= p_ofs.y + y + lh && p_click_pos.x >= p_ofs.x + wofs && p_click_pos.x < p_ofs.x + wofs + m_width) { \
-			if (r_outside) *r_outside = false;                                                                                                                                                               \
+			if (r_outside)                                                                                                                                                                                   \
+				*r_outside = false;                                                                                                                                                                          \
 			*r_click_item = it;                                                                                                                                                                              \
 			*r_click_char = rchar;                                                                                                                                                                           \
 			RETURN;                                                                                                                                                                                          \
@@ -855,7 +858,8 @@ int RichTextLabel::_process_line(ItemFrame *p_frame, const Vector2 &p_ofs, int &
 
 			if (p_mode == PROCESS_POINTER && r_click_item && p_click_pos.y >= p_ofs.y + y && p_click_pos.y <= p_ofs.y + y + lh) {
 				//went to next line, but pointer was on the previous one
-				if (r_outside) *r_outside = true;
+				if (r_outside)
+					*r_outside = true;
 				*r_click_item = itp;
 				*r_click_char = rchar;
 				RETURN;
diff --git a/scene/gui/slider.cpp b/scene/gui/slider.cpp
index 1f135163d4..910d5f8230 100644
--- a/scene/gui/slider.cpp
+++ b/scene/gui/slider.cpp
@@ -182,7 +182,8 @@ void Slider::_notification(int p_what) {
 				if (ticks > 1) {
 					int grabber_offset = (grabber->get_size().height / 2 - tick->get_height() / 2);
 					for (int i = 0; i < ticks; i++) {
-						if (!ticks_on_borders && (i == 0 || i + 1 == ticks)) continue;
+						if (!ticks_on_borders && (i == 0 || i + 1 == ticks))
+							continue;
 						int ofs = (i * areasize / (ticks - 1)) + grabber_offset;
 						tick->draw(ci, Point2i((size.width - widget_width) / 2, ofs));
 					}
@@ -199,7 +200,8 @@ void Slider::_notification(int p_what) {
 				if (ticks > 1) {
 					int grabber_offset = (grabber->get_size().width / 2 - tick->get_width() / 2);
 					for (int i = 0; i < ticks; i++) {
-						if ((!ticks_on_borders) && ((i == 0) || ((i + 1) == ticks))) continue;
+						if ((!ticks_on_borders) && ((i == 0) || ((i + 1) == ticks)))
+							continue;
 						int ofs = (i * areasize / (ticks - 1)) + grabber_offset;
 						tick->draw(ci, Point2i(ofs, (size.height - widget_height) / 2));
 					}
diff --git a/scene/gui/tabs.cpp b/scene/gui/tabs.cpp
index 1a3b53f489..b856d3ab3a 100644
--- a/scene/gui/tabs.cpp
+++ b/scene/gui/tabs.cpp
@@ -399,7 +399,8 @@ int Tabs::get_tab_count() const {
 
 void Tabs::set_current_tab(int p_current) {
 
-	if (current == p_current) return;
+	if (current == p_current)
+		return;
 	ERR_FAIL_INDEX(p_current, get_tab_count());
 
 	current = p_current;
@@ -856,7 +857,8 @@ void Tabs::ensure_tab_visible(int p_idx) {
 	if (!is_inside_tree())
 		return;
 
-	if (tabs.size() == 0) return;
+	if (tabs.size() == 0)
+		return;
 	ERR_FAIL_INDEX(p_idx, tabs.size());
 
 	if (p_idx == offset) {
diff --git a/scene/gui/text_edit.cpp b/scene/gui/text_edit.cpp
index aa518fbb7d..132ee0f249 100644
--- a/scene/gui/text_edit.cpp
+++ b/scene/gui/text_edit.cpp
@@ -2991,7 +2991,8 @@ void TextEdit::_gui_input(const Ref<InputEvent> &p_gui_input) {
 				}
 			} break;
 			case KEY_TAB: {
-				if (k->get_command()) break; // Avoid tab when command.
+				if (k->get_command())
+					break; // Avoid tab when command.
 
 				if (readonly)
 					break;
diff --git a/scene/gui/tree.cpp b/scene/gui/tree.cpp
index 329c1085df..4a550727fc 100644
--- a/scene/gui/tree.cpp
+++ b/scene/gui/tree.cpp
@@ -2277,7 +2277,8 @@ void Tree::_gui_input(Ref<InputEvent> p_event) {
 	bool is_command = k.is_valid() && k->get_command();
 	if (p_event->is_action("ui_right") && p_event->is_pressed()) {
 
-		if (!cursor_can_exit_tree) accept_event();
+		if (!cursor_can_exit_tree)
+			accept_event();
 
 		if (!selected_item || select_mode == SELECT_ROW || selected_col > (columns.size() - 1)) {
 			return;
@@ -2294,7 +2295,8 @@ void Tree::_gui_input(Ref<InputEvent> p_event) {
 		}
 	} else if (p_event->is_action("ui_left") && p_event->is_pressed()) {
 
-		if (!cursor_can_exit_tree) accept_event();
+		if (!cursor_can_exit_tree)
+			accept_event();
 
 		if (!selected_item || select_mode == SELECT_ROW || selected_col < 0) {
 			return;
@@ -2313,19 +2315,22 @@ void Tree::_gui_input(Ref<InputEvent> p_event) {
 
 	} else if (p_event->is_action("ui_up") && p_event->is_pressed() && !is_command) {
 
-		if (!cursor_can_exit_tree) accept_event();
+		if (!cursor_can_exit_tree)
+			accept_event();
 
 		_go_up();
 
 	} else if (p_event->is_action("ui_down") && p_event->is_pressed() && !is_command) {
 
-		if (!cursor_can_exit_tree) accept_event();
+		if (!cursor_can_exit_tree)
+			accept_event();
 
 		_go_down();
 
 	} else if (p_event->is_action("ui_page_down") && p_event->is_pressed()) {
 
-		if (!cursor_can_exit_tree) accept_event();
+		if (!cursor_can_exit_tree)
+			accept_event();
 
 		TreeItem *next = nullptr;
 		if (!selected_item)
@@ -2363,7 +2368,8 @@ void Tree::_gui_input(Ref<InputEvent> p_event) {
 		ensure_cursor_is_visible();
 	} else if (p_event->is_action("ui_page_up") && p_event->is_pressed()) {
 
-		if (!cursor_can_exit_tree) accept_event();
+		if (!cursor_can_exit_tree)
+			accept_event();
 
 		TreeItem *prev = nullptr;
 		if (!selected_item)
diff --git a/scene/main/canvas_item.h b/scene/main/canvas_item.h
index dc17c5283b..5f1798cc2a 100644
--- a/scene/main/canvas_item.h
+++ b/scene/main/canvas_item.h
@@ -247,9 +247,11 @@ private:
 
 protected:
 	_FORCE_INLINE_ void _notify_transform() {
-		if (!is_inside_tree()) return;
+		if (!is_inside_tree())
+			return;
 		_notify_transform(this);
-		if (!block_transform_notify && notify_local_transform) notification(NOTIFICATION_LOCAL_TRANSFORM_CHANGED);
+		if (!block_transform_notify && notify_local_transform)
+			notification(NOTIFICATION_LOCAL_TRANSFORM_CHANGED);
 	}
 
 	void item_rect_changed(bool p_size_changed = true);
diff --git a/scene/main/scene_tree.cpp b/scene/main/scene_tree.cpp
index 7afc1b2edd..94be22ccd2 100644
--- a/scene/main/scene_tree.cpp
+++ b/scene/main/scene_tree.cpp
@@ -1372,7 +1372,8 @@ void SceneTree::get_argument_options(const StringName &p_function, int p_idx, Li
 
 SceneTree::SceneTree() {
 
-	if (singleton == nullptr) singleton = this;
+	if (singleton == nullptr)
+		singleton = this;
 	_quit = false;
 	accept_quit = true;
 	quit_on_go_back = true;
@@ -1478,5 +1479,6 @@ SceneTree::~SceneTree() {
 		memdelete(root);
 	}
 
-	if (singleton == this) singleton = nullptr;
+	if (singleton == this)
+		singleton = nullptr;
 }
diff --git a/scene/resources/texture.cpp b/scene/resources/texture.cpp
index d57af29599..91c40d871d 100644
--- a/scene/resources/texture.cpp
+++ b/scene/resources/texture.cpp
@@ -1037,8 +1037,10 @@ bool AtlasTexture::is_pixel_opaque(int p_x, int p_y) const {
 	int y = p_y + region.position.y - margin.position.y;
 
 	// margin edge may outside of atlas
-	if (x < 0 || x >= atlas->get_width()) return false;
-	if (y < 0 || y >= atlas->get_height()) return false;
+	if (x < 0 || x >= atlas->get_width())
+		return false;
+	if (y < 0 || y >= atlas->get_height())
+		return false;
 
 	return atlas->is_pixel_opaque(x, y);
 }
diff --git a/scene/resources/tile_set.cpp b/scene/resources/tile_set.cpp
index 6f8a53be1a..1b68b7486b 100644
--- a/scene/resources/tile_set.cpp
+++ b/scene/resources/tile_set.cpp
@@ -993,7 +993,8 @@ void TileSet::_tile_set_shapes(int p_id, const Array &p_shapes) {
 
 		if (p_shapes[i].get_type() == Variant::OBJECT) {
 			Ref<Shape2D> shape = p_shapes[i];
-			if (shape.is_null()) continue;
+			if (shape.is_null())
+				continue;
 
 			s.shape = shape;
 			s.shape_transform = default_transform;
diff --git a/servers/audio/audio_filter_sw.cpp b/servers/audio/audio_filter_sw.cpp
index 2771fc177b..3928ba1388 100644
--- a/servers/audio/audio_filter_sw.cpp
+++ b/servers/audio/audio_filter_sw.cpp
@@ -58,7 +58,8 @@ void AudioFilterSW::prepare_coefficients(Coeffs *p_coeffs) {
 	int sr_limit = (sampling_rate / 2) + 512;
 
 	double final_cutoff = (cutoff > sr_limit) ? sr_limit : cutoff;
-	if (final_cutoff < 1) final_cutoff = 1; //don't allow less than this
+	if (final_cutoff < 1)
+		final_cutoff = 1; //don't allow less than this
 
 	double omega = 2.0 * Math_PI * final_cutoff / sampling_rate;
 
diff --git a/servers/audio/effects/audio_effect_filter.h b/servers/audio/effects/audio_effect_filter.h
index 0088118d8c..c439c5a5b5 100644
--- a/servers/audio/effects/audio_effect_filter.h
+++ b/servers/audio/effects/audio_effect_filter.h
@@ -99,7 +99,8 @@ class AudioEffectLowPassFilter : public AudioEffectFilter {
 	GDCLASS(AudioEffectLowPassFilter, AudioEffectFilter);
 
 	void _validate_property(PropertyInfo &property) const {
-		if (property.name == "gain") property.usage = 0;
+		if (property.name == "gain")
+			property.usage = 0;
 	}
 
 public:
@@ -110,7 +111,8 @@ public:
 class AudioEffectHighPassFilter : public AudioEffectFilter {
 	GDCLASS(AudioEffectHighPassFilter, AudioEffectFilter);
 	void _validate_property(PropertyInfo &property) const {
-		if (property.name == "gain") property.usage = 0;
+		if (property.name == "gain")
+			property.usage = 0;
 	}
 
 public:
@@ -121,7 +123,8 @@ public:
 class AudioEffectBandPassFilter : public AudioEffectFilter {
 	GDCLASS(AudioEffectBandPassFilter, AudioEffectFilter);
 	void _validate_property(PropertyInfo &property) const {
-		if (property.name == "gain") property.usage = 0;
+		if (property.name == "gain")
+			property.usage = 0;
 	}
 
 public:
diff --git a/servers/audio/effects/audio_effect_spectrum_analyzer.cpp b/servers/audio/effects/audio_effect_spectrum_analyzer.cpp
index 47aee02de2..680ef567fd 100644
--- a/servers/audio/effects/audio_effect_spectrum_analyzer.cpp
+++ b/servers/audio/effects/audio_effect_spectrum_analyzer.cpp
@@ -50,7 +50,8 @@ static void smbFft(float *fftBuffer, long fftFrameSize, long sign)
 
 	for (i = 2; i < 2 * fftFrameSize - 2; i += 2) {
 		for (bitm = 2, j = 0; bitm < 2 * fftFrameSize; bitm <<= 1) {
-			if (i & bitm) j++;
+			if (i & bitm)
+				j++;
 			j <<= 1;
 		}
 		if (i < j) {
diff --git a/servers/physics_2d/body_2d_sw.h b/servers/physics_2d/body_2d_sw.h
index 0514b263b4..a36dc3bfe2 100644
--- a/servers/physics_2d/body_2d_sw.h
+++ b/servers/physics_2d/body_2d_sw.h
@@ -158,7 +158,8 @@ public:
 	_FORCE_INLINE_ void set_max_contacts_reported(int p_size) {
 		contacts.resize(p_size);
 		contact_count = 0;
-		if (mode == PhysicsServer2D::BODY_MODE_KINEMATIC && p_size) set_active(true);
+		if (mode == PhysicsServer2D::BODY_MODE_KINEMATIC && p_size)
+			set_active(true);
 	}
 
 	_FORCE_INLINE_ int get_max_contacts_reported() const { return contacts.size(); }
diff --git a/servers/physics_2d/space_2d_sw.h b/servers/physics_2d/space_2d_sw.h
index c6b324c928..e87d842ef1 100644
--- a/servers/physics_2d/space_2d_sw.h
+++ b/servers/physics_2d/space_2d_sw.h
@@ -192,7 +192,8 @@ public:
 	void set_debug_contacts(int p_amount) { contact_debug.resize(p_amount); }
 	_FORCE_INLINE_ bool is_debugging_contacts() const { return !contact_debug.empty(); }
 	_FORCE_INLINE_ void add_debug_contact(const Vector2 &p_contact) {
-		if (contact_debug_count < contact_debug.size()) contact_debug.write[contact_debug_count++] = p_contact;
+		if (contact_debug_count < contact_debug.size())
+			contact_debug.write[contact_debug_count++] = p_contact;
 	}
 	_FORCE_INLINE_ Vector<Vector2> get_debug_contacts() { return contact_debug; }
 	_FORCE_INLINE_ int get_debug_contact_count() { return contact_debug_count; }
diff --git a/servers/physics_3d/body_3d_sw.h b/servers/physics_3d/body_3d_sw.h
index 2bd335e6c0..a67894b64b 100644
--- a/servers/physics_3d/body_3d_sw.h
+++ b/servers/physics_3d/body_3d_sw.h
@@ -175,7 +175,8 @@ public:
 	_FORCE_INLINE_ void set_max_contacts_reported(int p_size) {
 		contacts.resize(p_size);
 		contact_count = 0;
-		if (mode == PhysicsServer3D::BODY_MODE_KINEMATIC && p_size) set_active(true);
+		if (mode == PhysicsServer3D::BODY_MODE_KINEMATIC && p_size)
+			set_active(true);
 	}
 	_FORCE_INLINE_ int get_max_contacts_reported() const { return contacts.size(); }
 
diff --git a/servers/physics_3d/collision_object_3d_sw.h b/servers/physics_3d/collision_object_3d_sw.h
index c5773d0c61..9dd798af26 100644
--- a/servers/physics_3d/collision_object_3d_sw.h
+++ b/servers/physics_3d/collision_object_3d_sw.h
@@ -92,7 +92,8 @@ protected:
 #endif
 
 		transform = p_transform;
-		if (p_update_shapes) _update_shapes();
+		if (p_update_shapes)
+			_update_shapes();
 	}
 	_FORCE_INLINE_ void _set_inv_transform(const Transform &p_transform) { inv_transform = p_transform; }
 	void _set_static(bool p_static);
diff --git a/servers/physics_3d/joints/generic_6dof_joint_3d_sw.cpp b/servers/physics_3d/joints/generic_6dof_joint_3d_sw.cpp
index e15aeca842..017568d61f 100644
--- a/servers/physics_3d/joints/generic_6dof_joint_3d_sw.cpp
+++ b/servers/physics_3d/joints/generic_6dof_joint_3d_sw.cpp
@@ -83,7 +83,8 @@ int G6DOFRotationalLimitMotor3DSW::testLimitValue(real_t test_value) {
 real_t G6DOFRotationalLimitMotor3DSW::solveAngularLimits(
 		real_t timeStep, Vector3 &axis, real_t jacDiagABInv,
 		Body3DSW *body0, Body3DSW *body1) {
-	if (!needApplyTorques()) return 0.0f;
+	if (!needApplyTorques())
+		return 0.0f;
 
 	real_t target_velocity = m_targetVelocity;
 	real_t maxMotorForce = m_maxMotorForce;
@@ -137,7 +138,8 @@ real_t G6DOFRotationalLimitMotor3DSW::solveAngularLimits(
 	Vector3 motorImp = clippedMotorImpulse * axis;
 
 	body0->apply_torque_impulse(motorImp);
-	if (body1) body1->apply_torque_impulse(-motorImp);
+	if (body1)
+		body1->apply_torque_impulse(-motorImp);
 
 	return clippedMotorImpulse;
 }
diff --git a/servers/physics_3d/space_3d_sw.h b/servers/physics_3d/space_3d_sw.h
index 3634834952..a0b4379376 100644
--- a/servers/physics_3d/space_3d_sw.h
+++ b/servers/physics_3d/space_3d_sw.h
@@ -187,7 +187,8 @@ public:
 	void set_debug_contacts(int p_amount) { contact_debug.resize(p_amount); }
 	_FORCE_INLINE_ bool is_debugging_contacts() const { return !contact_debug.empty(); }
 	_FORCE_INLINE_ void add_debug_contact(const Vector3 &p_contact) {
-		if (contact_debug_count < contact_debug.size()) contact_debug.write[contact_debug_count++] = p_contact;
+		if (contact_debug_count < contact_debug.size())
+			contact_debug.write[contact_debug_count++] = p_contact;
 	}
 	_FORCE_INLINE_ Vector<Vector3> get_debug_contacts() { return contact_debug; }
 	_FORCE_INLINE_ int get_debug_contact_count() { return contact_debug_count; }
diff --git a/servers/rendering/rasterizer.h b/servers/rendering/rasterizer.h
index 955241e79c..099e155553 100644
--- a/servers/rendering/rasterizer.h
+++ b/servers/rendering/rasterizer.h
@@ -721,14 +721,16 @@ public:
 	Color get_default_clear_color() const {
 		return default_clear_color;
 	}
-#define TIMESTAMP_BEGIN()                                                                 \
-	{                                                                                     \
-		if (RSG::storage->capturing_timestamps) RSG::storage->capture_timestamps_begin(); \
+#define TIMESTAMP_BEGIN()                             \
+	{                                                 \
+		if (RSG::storage->capturing_timestamps)       \
+			RSG::storage->capture_timestamps_begin(); \
 	}
 
-#define RENDER_TIMESTAMP(m_text)                                                         \
-	{                                                                                    \
-		if (RSG::storage->capturing_timestamps) RSG::storage->capture_timestamp(m_text); \
+#define RENDER_TIMESTAMP(m_text)                     \
+	{                                                \
+		if (RSG::storage->capturing_timestamps)      \
+			RSG::storage->capture_timestamp(m_text); \
 	}
 
 	bool capturing_timestamps = false;
@@ -857,7 +859,8 @@ public:
 
 		_FORCE_INLINE_ TextureBinding() { binding_id = 0; }
 		_FORCE_INLINE_ ~TextureBinding() {
-			if (binding_id) singleton->free_texture_binding(binding_id);
+			if (binding_id)
+				singleton->free_texture_binding(binding_id);
 		}
 	};
 
@@ -886,7 +889,8 @@ public:
 
 		_FORCE_INLINE_ Polygon() { polygon_id = 0; }
 		_FORCE_INLINE_ ~Polygon() {
-			if (polygon_id) singleton->free_polygon(polygon_id);
+			if (polygon_id)
+				singleton->free_polygon(polygon_id);
 		}
 	};
 
@@ -1288,7 +1292,8 @@ public:
 			for (int i = 0; i < blocks.size(); i++) {
 				memfree(blocks[i].memory);
 			}
-			if (copy_back_buffer) memdelete(copy_back_buffer);
+			if (copy_back_buffer)
+				memdelete(copy_back_buffer);
 			if (custom_data) {
 				memdelete(custom_data);
 			}
diff --git a/servers/rendering/rasterizer_rd/shaders/giprobe_debug.glsl b/servers/rendering/rasterizer_rd/shaders/giprobe_debug.glsl
index b1784e7eee..8ffdaefdff 100644
--- a/servers/rendering/rasterizer_rd/shaders/giprobe_debug.glsl
+++ b/servers/rendering/rasterizer_rd/shaders/giprobe_debug.glsl
@@ -184,22 +184,38 @@ void main() {
 	int index = x + y * 4;
 	float limit = 0.0;
 	if (x < 8) {
-		if (index == 0) limit = 0.0625;
-		if (index == 1) limit = 0.5625;
-		if (index == 2) limit = 0.1875;
-		if (index == 3) limit = 0.6875;
-		if (index == 4) limit = 0.8125;
-		if (index == 5) limit = 0.3125;
-		if (index == 6) limit = 0.9375;
-		if (index == 7) limit = 0.4375;
-		if (index == 8) limit = 0.25;
-		if (index == 9) limit = 0.75;
-		if (index == 10) limit = 0.125;
-		if (index == 11) limit = 0.625;
-		if (index == 12) limit = 1.0;
-		if (index == 13) limit = 0.5;
-		if (index == 14) limit = 0.875;
-		if (index == 15) limit = 0.375;
+		if (index == 0)
+			limit = 0.0625;
+		if (index == 1)
+			limit = 0.5625;
+		if (index == 2)
+			limit = 0.1875;
+		if (index == 3)
+			limit = 0.6875;
+		if (index == 4)
+			limit = 0.8125;
+		if (index == 5)
+			limit = 0.3125;
+		if (index == 6)
+			limit = 0.9375;
+		if (index == 7)
+			limit = 0.4375;
+		if (index == 8)
+			limit = 0.25;
+		if (index == 9)
+			limit = 0.75;
+		if (index == 10)
+			limit = 0.125;
+		if (index == 11)
+			limit = 0.625;
+		if (index == 12)
+			limit = 1.0;
+		if (index == 13)
+			limit = 0.5;
+		if (index == 14)
+			limit = 0.875;
+		if (index == 15)
+			limit = 0.375;
 	}
 	if (frag_color.a < limit) {
 		discard;
diff --git a/servers/rendering/rasterizer_rd/shaders/scene_high_end.glsl b/servers/rendering/rasterizer_rd/shaders/scene_high_end.glsl
index ec47887036..4eba5d41d8 100644
--- a/servers/rendering/rasterizer_rd/shaders/scene_high_end.glsl
+++ b/servers/rendering/rasterizer_rd/shaders/scene_high_end.glsl
@@ -420,7 +420,8 @@ float SchlickFresnel(float u) {
 }
 
 float GTR1(float NdotH, float a) {
-	if (a >= 1.0) return 1.0 / M_PI;
+	if (a >= 1.0)
+		return 1.0 / M_PI;
 	float a2 = a * a;
 	float t = 1.0 + (a2 - 1.0) * NdotH * NdotH;
 	return (a2 - 1.0) / (M_PI * log(a2) * t);
diff --git a/servers/rendering/shader_language.cpp b/servers/rendering/shader_language.cpp
index 93593effd4..d29dac1902 100644
--- a/servers/rendering/shader_language.cpp
+++ b/servers/rendering/shader_language.cpp
@@ -6688,7 +6688,8 @@ static int _get_first_ident_pos(const String &p_code) {
 		if (GETCHAR(0) == '/' && GETCHAR(1) == '/') {
 			idx += 2;
 			while (true) {
-				if (GETCHAR(0) == 0) return 0;
+				if (GETCHAR(0) == 0)
+					return 0;
 				if (GETCHAR(0) == '\n') {
 					idx++;
 					break; // loop
@@ -6698,7 +6699,8 @@ static int _get_first_ident_pos(const String &p_code) {
 		} else if (GETCHAR(0) == '/' && GETCHAR(1) == '*') {
 			idx += 2;
 			while (true) {
-				if (GETCHAR(0) == 0) return 0;
+				if (GETCHAR(0) == 0)
+					return 0;
 				if (GETCHAR(0) == '*' && GETCHAR(1) == '/') {
 					idx += 2;
 					break; // loop