Style: clang-format: Disable KeepEmptyLinesAtTheStartOfBlocks

Which means that reduz' beloved style which we all became used to
will now be changed automatically to remove the first empty line.

This makes us lean closer to 1TBS (the one true brace style) instead
of hybridating it with some Allman-inspired spacing.

There's still the case of braces around single-statement blocks that
needs to be addressed (but clang-format can't help with that, but
clang-tidy may if we agree about it).

Part of #33027.

1 files changed, 0 insertions, 158 deletions

diff --git a/core/math/expression.cpp b/core/math/expression.cpp
index c43831ddee..7bfebded6a 100644
--- a/core/math/expression.cpp
+++ b/core/math/expression.cpp
@@ -110,7 +110,6 @@ const char *Expression::func_name[Expression::FUNC_MAX] = {
 };
 
 Expression::BuiltinFunc Expression::find_function(const String &p_string) {
-
 	for (int i = 0; i < FUNC_MAX; i++) {
 		if (p_string == func_name[i])
 			return BuiltinFunc(i);
@@ -120,15 +119,12 @@ Expression::BuiltinFunc Expression::find_function(const String &p_string) {
 }
 
 String Expression::get_func_name(BuiltinFunc p_func) {
-
 	ERR_FAIL_INDEX_V(p_func, FUNC_MAX, String());
 	return func_name[p_func];
 }
 
 int Expression::get_func_argument_count(BuiltinFunc p_func) {
-
 	switch (p_func) {
-
 		case MATH_RANDOMIZE:
 		case MATH_RAND:
 		case MATH_RANDF:
@@ -220,194 +216,157 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
 	r_error.error = Callable::CallError::CALL_OK;
 	switch (p_func) {
 		case MATH_SIN: {
-
 			VALIDATE_ARG_NUM(0);
 			*r_return = Math::sin((double)*p_inputs[0]);
 		} break;
 		case MATH_COS: {
-
 			VALIDATE_ARG_NUM(0);
 			*r_return = Math::cos((double)*p_inputs[0]);
 		} break;
 		case MATH_TAN: {
-
 			VALIDATE_ARG_NUM(0);
 			*r_return = Math::tan((double)*p_inputs[0]);
 		} break;
 		case MATH_SINH: {
-
 			VALIDATE_ARG_NUM(0);
 			*r_return = Math::sinh((double)*p_inputs[0]);
 		} break;
 		case MATH_COSH: {
-
 			VALIDATE_ARG_NUM(0);
 			*r_return = Math::cosh((double)*p_inputs[0]);
 		} break;
 		case MATH_TANH: {
-
 			VALIDATE_ARG_NUM(0);
 			*r_return = Math::tanh((double)*p_inputs[0]);
 		} break;
 		case MATH_ASIN: {
-
 			VALIDATE_ARG_NUM(0);
 			*r_return = Math::asin((double)*p_inputs[0]);
 		} break;
 		case MATH_ACOS: {
-
 			VALIDATE_ARG_NUM(0);
 			*r_return = Math::acos((double)*p_inputs[0]);
 		} break;
 		case MATH_ATAN: {
-
 			VALIDATE_ARG_NUM(0);
 			*r_return = Math::atan((double)*p_inputs[0]);
 		} break;
 		case MATH_ATAN2: {
-
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
 			*r_return = Math::atan2((double)*p_inputs[0], (double)*p_inputs[1]);
 		} break;
 		case MATH_SQRT: {
-
 			VALIDATE_ARG_NUM(0);
 			*r_return = Math::sqrt((double)*p_inputs[0]);
 		} break;
 		case MATH_FMOD: {
-
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
 			*r_return = Math::fmod((double)*p_inputs[0], (double)*p_inputs[1]);
 		} break;
 		case MATH_FPOSMOD: {
-
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
 			*r_return = Math::fposmod((double)*p_inputs[0], (double)*p_inputs[1]);
 		} break;
 		case MATH_POSMOD: {
-
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
 			*r_return = Math::posmod((int)*p_inputs[0], (int)*p_inputs[1]);
 		} break;
 		case MATH_FLOOR: {
-
 			VALIDATE_ARG_NUM(0);
 			*r_return = Math::floor((double)*p_inputs[0]);
 		} break;
 		case MATH_CEIL: {
-
 			VALIDATE_ARG_NUM(0);
 			*r_return = Math::ceil((double)*p_inputs[0]);
 		} break;
 		case MATH_ROUND: {
-
 			VALIDATE_ARG_NUM(0);
 			*r_return = Math::round((double)*p_inputs[0]);
 		} break;
 		case MATH_ABS: {
-
 			if (p_inputs[0]->get_type() == Variant::INT) {
-
 				int64_t i = *p_inputs[0];
 				*r_return = ABS(i);
 			} else if (p_inputs[0]->get_type() == Variant::FLOAT) {
-
 				real_t r = *p_inputs[0];
 				*r_return = Math::abs(r);
 			} else {
-
 				r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
 				r_error.argument = 0;
 				r_error.expected = Variant::FLOAT;
 			}
 		} break;
 		case MATH_SIGN: {
-
 			if (p_inputs[0]->get_type() == Variant::INT) {
-
 				int64_t i = *p_inputs[0];
 				*r_return = i < 0 ? -1 : (i > 0 ? +1 : 0);
 			} else if (p_inputs[0]->get_type() == Variant::FLOAT) {
-
 				real_t r = *p_inputs[0];
 				*r_return = r < 0.0 ? -1.0 : (r > 0.0 ? +1.0 : 0.0);
 			} else {
-
 				r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
 				r_error.argument = 0;
 				r_error.expected = Variant::FLOAT;
 			}
 		} break;
 		case MATH_POW: {
-
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
 			*r_return = Math::pow((double)*p_inputs[0], (double)*p_inputs[1]);
 		} break;
 		case MATH_LOG: {
-
 			VALIDATE_ARG_NUM(0);
 			*r_return = Math::log((double)*p_inputs[0]);
 		} break;
 		case MATH_EXP: {
-
 			VALIDATE_ARG_NUM(0);
 			*r_return = Math::exp((double)*p_inputs[0]);
 		} break;
 		case MATH_ISNAN: {
-
 			VALIDATE_ARG_NUM(0);
 			*r_return = Math::is_nan((double)*p_inputs[0]);
 		} break;
 		case MATH_ISINF: {
-
 			VALIDATE_ARG_NUM(0);
 			*r_return = Math::is_inf((double)*p_inputs[0]);
 		} break;
 		case MATH_EASE: {
-
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
 			*r_return = Math::ease((double)*p_inputs[0], (double)*p_inputs[1]);
 		} break;
 		case MATH_STEP_DECIMALS: {
-
 			VALIDATE_ARG_NUM(0);
 			*r_return = Math::step_decimals((double)*p_inputs[0]);
 		} break;
 		case MATH_STEPIFY: {
-
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
 			*r_return = Math::stepify((double)*p_inputs[0], (double)*p_inputs[1]);
 		} break;
 		case MATH_LERP: {
-
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
 			VALIDATE_ARG_NUM(2);
 			*r_return = Math::lerp((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
 		} break;
 		case MATH_LERP_ANGLE: {
-
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
 			VALIDATE_ARG_NUM(2);
 			*r_return = Math::lerp_angle((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
 		} break;
 		case MATH_INVERSE_LERP: {
-
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
 			VALIDATE_ARG_NUM(2);
 			*r_return = Math::inverse_lerp((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
 		} break;
 		case MATH_RANGE_LERP: {
-
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
 			VALIDATE_ARG_NUM(2);
@@ -422,14 +381,12 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
 			*r_return = Math::smoothstep((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
 		} break;
 		case MATH_MOVE_TOWARD: {
-
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
 			VALIDATE_ARG_NUM(2);
 			*r_return = Math::move_toward((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
 		} break;
 		case MATH_DECTIME: {
-
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
 			VALIDATE_ARG_NUM(2);
@@ -446,20 +403,17 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
 			*r_return = Math::randf();
 		} break;
 		case MATH_RANDOM: {
-
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
 			*r_return = Math::random((double)*p_inputs[0], (double)*p_inputs[1]);
 		} break;
 		case MATH_SEED: {
-
 			VALIDATE_ARG_NUM(0);
 			uint64_t seed = *p_inputs[0];
 			Math::seed(seed);
 
 		} break;
 		case MATH_RANDSEED: {
-
 			VALIDATE_ARG_NUM(0);
 			uint64_t seed = *p_inputs[0];
 			int ret = Math::rand_from_seed(&seed);
@@ -470,22 +424,18 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
 
 		} break;
 		case MATH_DEG2RAD: {
-
 			VALIDATE_ARG_NUM(0);
 			*r_return = Math::deg2rad((double)*p_inputs[0]);
 		} break;
 		case MATH_RAD2DEG: {
-
 			VALIDATE_ARG_NUM(0);
 			*r_return = Math::rad2deg((double)*p_inputs[0]);
 		} break;
 		case MATH_LINEAR2DB: {
-
 			VALIDATE_ARG_NUM(0);
 			*r_return = Math::linear2db((double)*p_inputs[0]);
 		} break;
 		case MATH_DB2LINEAR: {
-
 			VALIDATE_ARG_NUM(0);
 			*r_return = Math::db2linear((double)*p_inputs[0]);
 		} break;
@@ -516,9 +466,7 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
 			*r_return = Math::wrapf((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
 		} break;
 		case LOGIC_MAX: {
-
 			if (p_inputs[0]->get_type() == Variant::INT && p_inputs[1]->get_type() == Variant::INT) {
-
 				int64_t a = *p_inputs[0];
 				int64_t b = *p_inputs[1];
 				*r_return = MAX(a, b);
@@ -534,9 +482,7 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
 
 		} break;
 		case LOGIC_MIN: {
-
 			if (p_inputs[0]->get_type() == Variant::INT && p_inputs[1]->get_type() == Variant::INT) {
-
 				int64_t a = *p_inputs[0];
 				int64_t b = *p_inputs[1];
 				*r_return = MIN(a, b);
@@ -551,9 +497,7 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
 			}
 		} break;
 		case LOGIC_CLAMP: {
-
 			if (p_inputs[0]->get_type() == Variant::INT && p_inputs[1]->get_type() == Variant::INT && p_inputs[2]->get_type() == Variant::INT) {
-
 				int64_t a = *p_inputs[0];
 				int64_t b = *p_inputs[1];
 				int64_t c = *p_inputs[2];
@@ -571,15 +515,12 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
 			}
 		} break;
 		case LOGIC_NEAREST_PO2: {
-
 			VALIDATE_ARG_NUM(0);
 			int64_t num = *p_inputs[0];
 			*r_return = next_power_of_2(num);
 		} break;
 		case OBJ_WEAKREF: {
-
 			if (p_inputs[0]->get_type() != Variant::OBJECT) {
-
 				r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
 				r_error.argument = 0;
 				r_error.expected = Variant::OBJECT;
@@ -588,10 +529,8 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
 			}
 
 			if (p_inputs[0]->is_ref()) {
-
 				REF r = *p_inputs[0];
 				if (!r.is_valid()) {
-
 					return;
 				}
 
@@ -601,7 +540,6 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
 			} else {
 				Object *obj = *p_inputs[0];
 				if (!obj) {
-
 					return;
 				}
 				Ref<WeakRef> wref = memnew(WeakRef);
@@ -611,9 +549,7 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
 
 		} break;
 		case FUNC_FUNCREF: {
-
 			if (p_inputs[0]->get_type() != Variant::OBJECT) {
-
 				r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
 				r_error.argument = 0;
 				r_error.expected = Variant::OBJECT;
@@ -621,7 +557,6 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
 				return;
 			}
 			if (p_inputs[1]->get_type() != Variant::STRING && p_inputs[1]->get_type() != Variant::NODE_PATH) {
-
 				r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
 				r_error.argument = 1;
 				r_error.expected = Variant::STRING;
@@ -638,11 +573,9 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
 
 		} break;
 		case TYPE_CONVERT: {
-
 			VALIDATE_ARG_NUM(1);
 			int type = *p_inputs[1];
 			if (type < 0 || type >= Variant::VARIANT_MAX) {
-
 				r_error_str = RTR("Invalid type argument to convert(), use TYPE_* constants.");
 				r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
 				r_error.argument = 0;
@@ -650,31 +583,25 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
 				return;
 
 			} else {
-
 				*r_return = Variant::construct(Variant::Type(type), p_inputs, 1, r_error);
 			}
 		} break;
 		case TYPE_OF: {
-
 			*r_return = p_inputs[0]->get_type();
 
 		} break;
 		case TYPE_EXISTS: {
-
 			*r_return = ClassDB::class_exists(*p_inputs[0]);
 
 		} break;
 		case TEXT_CHAR: {
-
 			CharType result[2] = { *p_inputs[0], 0 };
 
 			*r_return = String(result);
 
 		} break;
 		case TEXT_ORD: {
-
 			if (p_inputs[0]->get_type() != Variant::STRING) {
-
 				r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
 				r_error.argument = 0;
 				r_error.expected = Variant::STRING;
@@ -685,7 +612,6 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
 			String str = *p_inputs[0];
 
 			if (str.length() != 1) {
-
 				r_error_str = RTR("Expected a string of length 1 (a character).");
 				r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
 				r_error.argument = 0;
@@ -698,39 +624,33 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
 
 		} break;
 		case TEXT_STR: {
-
 			String str = *p_inputs[0];
 
 			*r_return = str;
 
 		} break;
 		case TEXT_PRINT: {
-
 			String str = *p_inputs[0];
 			print_line(str);
 
 		} break;
 
 		case TEXT_PRINTERR: {
-
 			String str = *p_inputs[0];
 			print_error(str);
 
 		} break;
 		case TEXT_PRINTRAW: {
-
 			String str = *p_inputs[0];
 			OS::get_singleton()->print("%s", str.utf8().get_data());
 
 		} break;
 		case VAR_TO_STR: {
-
 			String vars;
 			VariantWriter::write_to_string(*p_inputs[0], vars);
 			*r_return = vars;
 		} break;
 		case STR_TO_VAR: {
-
 			if (p_inputs[0]->get_type() != Variant::STRING) {
 				r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
 				r_error.argument = 0;
@@ -756,7 +676,6 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
 
 		} break;
 		case VAR_TO_BYTES: {
-
 			PackedByteArray barr;
 			bool full_objects = *p_inputs[1];
 			int len;
@@ -777,7 +696,6 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
 			*r_return = barr;
 		} break;
 		case BYTES_TO_VAR: {
-
 			if (p_inputs[0]->get_type() != Variant::PACKED_BYTE_ARRAY) {
 				r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
 				r_error.argument = 0;
@@ -805,7 +723,6 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
 
 		} break;
 		case COLORN: {
-
 			VALIDATE_ARG_NUM(1);
 
 			Color color = Color::named(*p_inputs[0]);
@@ -826,60 +743,49 @@ static bool _is_number(CharType c) {
 }
 
 Error Expression::_get_token(Token &r_token) {
-
 	while (true) {
 #define GET_CHAR() (str_ofs >= expression.length() ? 0 : expression[str_ofs++])
 
 		CharType cchar = GET_CHAR();
 
 		switch (cchar) {
-
 			case 0: {
 				r_token.type = TK_EOF;
 				return OK;
 			};
 			case '{': {
-
 				r_token.type = TK_CURLY_BRACKET_OPEN;
 				return OK;
 			};
 			case '}': {
-
 				r_token.type = TK_CURLY_BRACKET_CLOSE;
 				return OK;
 			};
 			case '[': {
-
 				r_token.type = TK_BRACKET_OPEN;
 				return OK;
 			};
 			case ']': {
-
 				r_token.type = TK_BRACKET_CLOSE;
 				return OK;
 			};
 			case '(': {
-
 				r_token.type = TK_PARENTHESIS_OPEN;
 				return OK;
 			};
 			case ')': {
-
 				r_token.type = TK_PARENTHESIS_CLOSE;
 				return OK;
 			};
 			case ',': {
-
 				r_token.type = TK_COMMA;
 				return OK;
 			};
 			case ':': {
-
 				r_token.type = TK_COLON;
 				return OK;
 			};
 			case '$': {
-
 				r_token.type = TK_INPUT;
 				int index = 0;
 				do {
@@ -898,7 +804,6 @@ Error Expression::_get_token(Token &r_token) {
 				return OK;
 			};
 			case '=': {
-
 				cchar = GET_CHAR();
 				if (cchar == '=') {
 					r_token.type = TK_OP_EQUAL;
@@ -910,7 +815,6 @@ Error Expression::_get_token(Token &r_token) {
 				return OK;
 			};
 			case '!': {
-
 				if (expression[str_ofs] == '=') {
 					r_token.type = TK_OP_NOT_EQUAL;
 					str_ofs++;
@@ -920,7 +824,6 @@ Error Expression::_get_token(Token &r_token) {
 				return OK;
 			};
 			case '>': {
-
 				if (expression[str_ofs] == '=') {
 					r_token.type = TK_OP_GREATER_EQUAL;
 					str_ofs++;
@@ -933,7 +836,6 @@ Error Expression::_get_token(Token &r_token) {
 				return OK;
 			};
 			case '<': {
-
 				if (expression[str_ofs] == '=') {
 					r_token.type = TK_OP_LESS_EQUAL;
 					str_ofs++;
@@ -966,7 +868,6 @@ Error Expression::_get_token(Token &r_token) {
 				return OK;
 			};
 			case '&': {
-
 				if (expression[str_ofs] == '&') {
 					r_token.type = TK_OP_AND;
 					str_ofs++;
@@ -976,7 +877,6 @@ Error Expression::_get_token(Token &r_token) {
 				return OK;
 			};
 			case '|': {
-
 				if (expression[str_ofs] == '|') {
 					r_token.type = TK_OP_OR;
 					str_ofs++;
@@ -986,22 +886,18 @@ Error Expression::_get_token(Token &r_token) {
 				return OK;
 			};
 			case '^': {
-
 				r_token.type = TK_OP_BIT_XOR;
 
 				return OK;
 			};
 			case '~': {
-
 				r_token.type = TK_OP_BIT_INVERT;
 
 				return OK;
 			};
 			case '"': {
-
 				String str;
 				while (true) {
-
 					CharType ch = GET_CHAR();
 
 					if (ch == 0) {
@@ -1022,7 +918,6 @@ Error Expression::_get_token(Token &r_token) {
 						CharType res = 0;
 
 						switch (next) {
-
 							case 'b':
 								res = 8;
 								break;
@@ -1049,7 +944,6 @@ Error Expression::_get_token(Token &r_token) {
 										return ERR_PARSE_ERROR;
 									}
 									if (!(_is_number(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))) {
-
 										_set_error("Malformed hex constant in string");
 										r_token.type = TK_ERROR;
 										return ERR_PARSE_ERROR;
@@ -1091,7 +985,6 @@ Error Expression::_get_token(Token &r_token) {
 
 			} break;
 			default: {
-
 				if (cchar <= 32) {
 					break;
 				}
@@ -1114,10 +1007,8 @@ Error Expression::_get_token(Token &r_token) {
 					bool is_float = false;
 
 					while (true) {
-
 						switch (reading) {
 							case READING_INT: {
-
 								if (_is_number(c)) {
 									//pass
 								} else if (c == '.') {
@@ -1131,9 +1022,7 @@ Error Expression::_get_token(Token &r_token) {
 
 							} break;
 							case READING_DEC: {
-
 								if (_is_number(c)) {
-
 								} else if (c == 'e') {
 									reading = READING_EXP;
 
@@ -1143,7 +1032,6 @@ Error Expression::_get_token(Token &r_token) {
 
 							} break;
 							case READING_EXP: {
-
 								if (_is_number(c)) {
 									exp_beg = true;
 
@@ -1175,12 +1063,10 @@ Error Expression::_get_token(Token &r_token) {
 					return OK;
 
 				} else if ((cchar >= 'A' && cchar <= 'Z') || (cchar >= 'a' && cchar <= 'z') || cchar == '_') {
-
 					String id;
 					bool first = true;
 
 					while ((cchar >= 'A' && cchar <= 'Z') || (cchar >= 'a' && cchar <= 'z') || cchar == '_' || (!first && _is_number(cchar))) {
-
 						id += String::chr(cchar);
 						cchar = GET_CHAR();
 						first = false;
@@ -1220,7 +1106,6 @@ Error Expression::_get_token(Token &r_token) {
 					} else if (id == "self") {
 						r_token.type = TK_SELF;
 					} else {
-
 						for (int i = 0; i < Variant::VARIANT_MAX; i++) {
 							if (id == Variant::get_type_name(Variant::Type(i))) {
 								r_token.type = TK_BASIC_TYPE;
@@ -1303,7 +1188,6 @@ const char *Expression::token_name[TK_MAX] = {
 };
 
 Expression::ENode *Expression::_parse_expression() {
-
 	Vector<ExpressionNode> expression;
 
 	while (true) {
@@ -1321,7 +1205,6 @@ Expression::ENode *Expression::_parse_expression() {
 				DictionaryNode *dn = alloc_node<DictionaryNode>();
 
 				while (true) {
-
 					int cofs = str_ofs;
 					_get_token(tk);
 					if (tk.type == TK_CURLY_BRACKET_CLOSE) {
@@ -1365,7 +1248,6 @@ Expression::ENode *Expression::_parse_expression() {
 				ArrayNode *an = alloc_node<ArrayNode>();
 
 				while (true) {
-
 					int cofs = str_ofs;
 					_get_token(tk);
 					if (tk.type == TK_BRACKET_CLOSE) {
@@ -1406,7 +1288,6 @@ Expression::ENode *Expression::_parse_expression() {
 
 			} break;
 			case TK_IDENTIFIER: {
-
 				String identifier = tk.value;
 
 				int cofs = str_ofs;
@@ -1419,7 +1300,6 @@ Expression::ENode *Expression::_parse_expression() {
 					func_call->base = self_node;
 
 					while (true) {
-
 						int cofs2 = str_ofs;
 						_get_token(tk);
 						if (tk.type == TK_PARENTHESIS_CLOSE) {
@@ -1462,7 +1342,6 @@ Expression::ENode *Expression::_parse_expression() {
 						input->index = input_index;
 						expr = input;
 					} else {
-
 						NamedIndexNode *index = alloc_node<NamedIndexNode>();
 						SelfNode *self_node = alloc_node<SelfNode>();
 						index->base = self_node;
@@ -1472,13 +1351,11 @@ Expression::ENode *Expression::_parse_expression() {
 				}
 			} break;
 			case TK_INPUT: {
-
 				InputNode *input = alloc_node<InputNode>();
 				input->index = tk.value;
 				expr = input;
 			} break;
 			case TK_SELF: {
-
 				SelfNode *self = alloc_node<SelfNode>();
 				expr = self;
 			} break;
@@ -1501,7 +1378,6 @@ Expression::ENode *Expression::_parse_expression() {
 				constructor->data_type = bt;
 
 				while (true) {
-
 					int cofs = str_ofs;
 					_get_token(tk);
 					if (tk.type == TK_PARENTHESIS_CLOSE) {
@@ -1542,7 +1418,6 @@ Expression::ENode *Expression::_parse_expression() {
 				bifunc->func = BuiltinFunc(int(tk.value));
 
 				while (true) {
-
 					int cofs = str_ofs;
 					_get_token(tk);
 					if (tk.type == TK_PARENTHESIS_CLOSE) {
@@ -1576,7 +1451,6 @@ Expression::ENode *Expression::_parse_expression() {
 
 			} break;
 			case TK_OP_SUB: {
-
 				ExpressionNode e;
 				e.is_op = true;
 				e.op = Variant::OP_NEGATE;
@@ -1584,7 +1458,6 @@ Expression::ENode *Expression::_parse_expression() {
 				continue;
 			} break;
 			case TK_OP_NOT: {
-
 				ExpressionNode e;
 				e.is_op = true;
 				e.op = Variant::OP_NOT;
@@ -1648,7 +1521,6 @@ Expression::ENode *Expression::_parse_expression() {
 						func_call->base = expr;
 
 						while (true) {
-
 							int cofs3 = str_ofs;
 							_get_token(tk);
 							if (tk.type == TK_PARENTHESIS_CLOSE) {
@@ -1797,15 +1669,12 @@ Expression::ENode *Expression::_parse_expression() {
 	/* Reduce the set set of expressions and place them in an operator tree, respecting precedence */
 
 	while (expression.size() > 1) {
-
 		int next_op = -1;
 		int min_priority = 0xFFFFF;
 		bool is_unary = false;
 
 		for (int i = 0; i < expression.size(); i++) {
-
 			if (!expression[i].is_op) {
-
 				continue;
 			}
 
@@ -1814,7 +1683,6 @@ Expression::ENode *Expression::_parse_expression() {
 			bool unary = false;
 
 			switch (expression[i].op) {
-
 				case Variant::OP_BIT_NEGATE:
 					priority = 0;
 					unary = true;
@@ -1910,17 +1778,14 @@ Expression::ENode *Expression::_parse_expression() {
 		}
 
 		if (next_op == -1) {
-
 			_set_error("Yet another parser bug....");
 			ERR_FAIL_V(nullptr);
 		}
 
 		// OK! create operator..
 		if (is_unary) {
-
 			int expr_pos = next_op;
 			while (expression[expr_pos].is_op) {
-
 				expr_pos++;
 				if (expr_pos == expression.size()) {
 					//can happen..
@@ -1931,7 +1796,6 @@ Expression::ENode *Expression::_parse_expression() {
 
 			//consecutively do unary operators
 			for (int i = expr_pos - 1; i >= next_op; i--) {
-
 				OperatorNode *op = alloc_node<OperatorNode>();
 				op->op = expression[i].op;
 				op->nodes[0] = expression[i + 1].node;
@@ -1942,7 +1806,6 @@ Expression::ENode *Expression::_parse_expression() {
 			}
 
 		} else {
-
 			if (next_op < 1 || next_op >= (expression.size() - 1)) {
 				_set_error("Parser bug...");
 				ERR_FAIL_V(nullptr);
@@ -1952,7 +1815,6 @@ Expression::ENode *Expression::_parse_expression() {
 			op->op = expression[next_op].op;
 
 			if (expression[next_op - 1].is_op) {
-
 				_set_error("Parser bug...");
 				ERR_FAIL_V(nullptr);
 			}
@@ -1981,7 +1843,6 @@ Expression::ENode *Expression::_parse_expression() {
 }
 
 bool Expression::_compile_expression() {
-
 	if (!expression_dirty)
 		return error_set;
 
@@ -2011,10 +1872,8 @@ bool Expression::_compile_expression() {
 }
 
 bool Expression::_execute(const Array &p_inputs, Object *p_instance, Expression::ENode *p_node, Variant &r_ret, String &r_error_str) {
-
 	switch (p_node->type) {
 		case Expression::ENode::TYPE_INPUT: {
-
 			const Expression::InputNode *in = static_cast<const Expression::InputNode *>(p_node);
 			if (in->index < 0 || in->index >= p_inputs.size()) {
 				r_error_str = vformat(RTR("Invalid input %i (not passed) in expression"), in->index);
@@ -2023,13 +1882,11 @@ bool Expression::_execute(const Array &p_inputs, Object *p_instance, Expression:
 			r_ret = p_inputs[in->index];
 		} break;
 		case Expression::ENode::TYPE_CONSTANT: {
-
 			const Expression::ConstantNode *c = static_cast<const Expression::ConstantNode *>(p_node);
 			r_ret = c->value;
 
 		} break;
 		case Expression::ENode::TYPE_SELF: {
-
 			if (!p_instance) {
 				r_error_str = RTR("self can't be used because instance is null (not passed)");
 				return true;
@@ -2037,7 +1894,6 @@ bool Expression::_execute(const Array &p_inputs, Object *p_instance, Expression:
 			r_ret = p_instance;
 		} break;
 		case Expression::ENode::TYPE_OPERATOR: {
-
 			const Expression::OperatorNode *op = static_cast<const Expression::OperatorNode *>(p_node);
 
 			Variant a;
@@ -2062,7 +1918,6 @@ bool Expression::_execute(const Array &p_inputs, Object *p_instance, Expression:
 
 		} break;
 		case Expression::ENode::TYPE_INDEX: {
-
 			const Expression::IndexNode *index = static_cast<const Expression::IndexNode *>(p_node);
 
 			Variant base;
@@ -2085,7 +1940,6 @@ bool Expression::_execute(const Array &p_inputs, Object *p_instance, Expression:
 
 		} break;
 		case Expression::ENode::TYPE_NAMED_INDEX: {
-
 			const Expression::NamedIndexNode *index = static_cast<const Expression::NamedIndexNode *>(p_node);
 
 			Variant base;
@@ -2107,7 +1961,6 @@ bool Expression::_execute(const Array &p_inputs, Object *p_instance, Expression:
 			Array arr;
 			arr.resize(array->array.size());
 			for (int i = 0; i < array->array.size(); i++) {
-
 				Variant value;
 				bool ret = _execute(p_inputs, p_instance, array->array[i], value, r_error_str);
 
@@ -2124,7 +1977,6 @@ bool Expression::_execute(const Array &p_inputs, Object *p_instance, Expression:
 
 			Dictionary d;
 			for (int i = 0; i < dictionary->dict.size(); i += 2) {
-
 				Variant key;
 				bool ret = _execute(p_inputs, p_instance, dictionary->dict[i + 0], key, r_error_str);
 
@@ -2142,7 +1994,6 @@ bool Expression::_execute(const Array &p_inputs, Object *p_instance, Expression:
 			r_ret = d;
 		} break;
 		case Expression::ENode::TYPE_CONSTRUCTOR: {
-
 			const Expression::ConstructorNode *constructor = static_cast<const Expression::ConstructorNode *>(p_node);
 
 			Vector<Variant> arr;
@@ -2151,7 +2002,6 @@ bool Expression::_execute(const Array &p_inputs, Object *p_instance, Expression:
 			argp.resize(constructor->arguments.size());
 
 			for (int i = 0; i < constructor->arguments.size(); i++) {
-
 				Variant value;
 				bool ret = _execute(p_inputs, p_instance, constructor->arguments[i], value, r_error_str);
 
@@ -2171,7 +2021,6 @@ bool Expression::_execute(const Array &p_inputs, Object *p_instance, Expression:
 
 		} break;
 		case Expression::ENode::TYPE_BUILTIN_FUNC: {
-
 			const Expression::BuiltinFuncNode *bifunc = static_cast<const Expression::BuiltinFuncNode *>(p_node);
 
 			Vector<Variant> arr;
@@ -2180,7 +2029,6 @@ bool Expression::_execute(const Array &p_inputs, Object *p_instance, Expression:
 			argp.resize(bifunc->arguments.size());
 
 			for (int i = 0; i < bifunc->arguments.size(); i++) {
-
 				Variant value;
 				bool ret = _execute(p_inputs, p_instance, bifunc->arguments[i], value, r_error_str);
 				if (ret)
@@ -2199,7 +2047,6 @@ bool Expression::_execute(const Array &p_inputs, Object *p_instance, Expression:
 
 		} break;
 		case Expression::ENode::TYPE_CALL: {
-
 			const Expression::CallNode *call = static_cast<const Expression::CallNode *>(p_node);
 
 			Variant base;
@@ -2214,7 +2061,6 @@ bool Expression::_execute(const Array &p_inputs, Object *p_instance, Expression:
 			argp.resize(call->arguments.size());
 
 			for (int i = 0; i < call->arguments.size(); i++) {
-
 				Variant value;
 				ret = _execute(p_inputs, p_instance, call->arguments[i], value, r_error_str);
 
@@ -2238,7 +2084,6 @@ bool Expression::_execute(const Array &p_inputs, Object *p_instance, Expression:
 }
 
 Error Expression::parse(const String &p_expression, const Vector<String> &p_input_names) {
-
 	if (nodes) {
 		memdelete(nodes);
 		nodes = nullptr;
@@ -2266,7 +2111,6 @@ Error Expression::parse(const String &p_expression, const Vector<String> &p_inpu
 }
 
 Variant Expression::execute(Array p_inputs, Object *p_base, bool p_show_error) {
-
 	ERR_FAIL_COND_V_MSG(error_set, Variant(), "There was previously a parse error: " + error_str + ".");
 
 	execution_error = false;
@@ -2291,7 +2135,6 @@ String Expression::get_error_text() const {
 }
 
 void Expression::_bind_methods() {
-
 	ClassDB::bind_method(D_METHOD("parse", "expression", "input_names"), &Expression::parse, DEFVAL(Vector<String>()));
 	ClassDB::bind_method(D_METHOD("execute", "inputs", "base_instance", "show_error"), &Expression::execute, DEFVAL(Array()), DEFVAL(Variant()), DEFVAL(true));
 	ClassDB::bind_method(D_METHOD("has_execute_failed"), &Expression::has_execute_failed);
@@ -2299,7 +2142,6 @@ void Expression::_bind_methods() {
 }
 
 Expression::~Expression() {
-
 	if (nodes) {
 		memdelete(nodes);
 	}