seedlingattempt/godot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Style: Enforce braces around if blocks and loops

Browse Source 
Using clang-tidy's `readability-braces-around-statements`.
https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
This commit is contained in:
Rémi Verschelde
2021-05-05 12:44:11 +02:00
parent b8d198eeed
commit 140350d767
694 changed files with 23283 additions and 12499 deletions
Download Patch File Download Diff File Expand all files Collapse all files

275
core/variant.cpp
View File

@ -160,10 +160,12 @@ String Variant::get_type_name(Variant::Type p_type) {
}
bool Variant::can_convert(Variant::Type p_type_from, Variant::Type p_type_to) {
if (p_type_from == p_type_to)
if (p_type_from == p_type_to) {
return true;
if (p_type_to == NIL && p_type_from != NIL) //nil can convert to anything
}
if (p_type_to == NIL && p_type_from != NIL) { //nil can convert to anything
return true;
}
if (p_type_from == NIL) {
return (p_type_to == OBJECT);
@ -363,16 +365,18 @@ bool Variant::can_convert(Variant::Type p_type_from, Variant::Type p_type_to) {
if (valid_types) {
int i = 0;
while (valid_types[i] != NIL) {
if (p_type_from == valid_types[i])
if (p_type_from == valid_types[i]) {
return true;
}
i++;
}
} else if (invalid_types) {
int i = 0;
while (invalid_types[i] != NIL) {
if (p_type_from == invalid_types[i])
if (p_type_from == invalid_types[i]) {
return false;
}
i++;
}
@ -383,10 +387,12 @@ bool Variant::can_convert(Variant::Type p_type_from, Variant::Type p_type_to) {
}
bool Variant::can_convert_strict(Variant::Type p_type_from, Variant::Type p_type_to) {
if (p_type_from == p_type_to)
if (p_type_from == p_type_to) {
return true;
if (p_type_to == NIL && p_type_from != NIL) //nil can convert to anything
}
if (p_type_to == NIL && p_type_from != NIL) { //nil can convert to anything
return true;
}
if (p_type_from == NIL) {
return (p_type_to == OBJECT);
@ -585,8 +591,9 @@ bool Variant::can_convert_strict(Variant::Type p_type_from, Variant::Type p_type
if (valid_types) {
int i = 0;
while (valid_types[i] != NIL) {
if (p_type_from == valid_types[i])
if (p_type_from == valid_types[i]) {
return true;
}
i++;
}
}
@ -595,8 +602,9 @@ bool Variant::can_convert_strict(Variant::Type p_type_from, Variant::Type p_type
}
bool Variant::operator==(const Variant &p_variant) const {
if (type != p_variant.type) //evaluation of operator== needs to be more strict
if (type != p_variant.type) { //evaluation of operator== needs to be more strict
return false;
}
bool v;
Variant r;
evaluate(OP_EQUAL, *this, p_variant, r, v);
@ -604,8 +612,9 @@ bool Variant::operator==(const Variant &p_variant) const {
}
bool Variant::operator!=(const Variant &p_variant) const {
if (type != p_variant.type) //evaluation of operator== needs to be more strict
if (type != p_variant.type) { //evaluation of operator== needs to be more strict
return true;
}
bool v;
Variant r;
evaluate(OP_NOT_EQUAL, *this, p_variant, r, v);
@ -613,8 +622,9 @@ bool Variant::operator!=(const Variant &p_variant) const {
}
bool Variant::operator<(const Variant &p_variant) const {
if (type != p_variant.type) //if types differ, then order by type first
if (type != p_variant.type) { //if types differ, then order by type first
return type < p_variant.type;
}
bool v;
Variant r;
evaluate(OP_LESS, *this, p_variant, r, v);
@ -1338,14 +1348,16 @@ String Variant::stringify(List<const void *> &stack) const {
String mtx("(");
for (int i = 0; i < 3; i++) {
if (i != 0)
if (i != 0) {
mtx += ", ";
}
mtx += "(";
for (int j = 0; j < 3; j++) {
if (j != 0)
if (j != 0) {
mtx += ", ";
}
mtx += Variant(mat3.elements[i][j]).operator String();
}
@ -1387,8 +1399,9 @@ String Variant::stringify(List<const void *> &stack) const {
pairs.sort();
for (int i = 0; i < pairs.size(); i++) {
if (i > 0)
if (i > 0) {
str += ", ";
}
str += pairs[i].key + ":" + pairs[i].value;
}
str += "}";
@ -1399,8 +1412,9 @@ String Variant::stringify(List<const void *> &stack) const {
PoolVector<Vector2> vec = operator PoolVector<Vector2>();
String str("[");
for (int i = 0; i < vec.size(); i++) {
if (i > 0)
if (i > 0) {
str += ", ";
}
str = str + Variant(vec[i]);
}
str += "]";
@ -1410,8 +1424,9 @@ String Variant::stringify(List<const void *> &stack) const {
PoolVector<Vector3> vec = operator PoolVector<Vector3>();
String str("[");
for (int i = 0; i < vec.size(); i++) {
if (i > 0)
if (i > 0) {
str += ", ";
}
str = str + Variant(vec[i]);
}
str += "]";
@ -1421,8 +1436,9 @@ String Variant::stringify(List<const void *> &stack) const {
PoolVector<String> vec = operator PoolVector<String>();
String str("[");
for (int i = 0; i < vec.size(); i++) {
if (i > 0)
if (i > 0) {
str += ", ";
}
str = str + vec[i];
}
str += "]";
@ -1432,8 +1448,9 @@ String Variant::stringify(List<const void *> &stack) const {
PoolVector<int> vec = operator PoolVector<int>();
String str("[");
for (int i = 0; i < vec.size(); i++) {
if (i > 0)
if (i > 0) {
str += ", ";
}
str = str + itos(vec[i]);
}
str += "]";
@ -1443,8 +1460,9 @@ String Variant::stringify(List<const void *> &stack) const {
PoolVector<real_t> vec = operator PoolVector<real_t>();
String str("[");
for (int i = 0; i < vec.size(); i++) {
if (i > 0)
if (i > 0) {
str += ", ";
}
str = str + rtos(vec[i]);
}
str += "]";
@ -1459,8 +1477,9 @@ String Variant::stringify(List<const void *> &stack) const {
String str("[");
for (int i = 0; i < arr.size(); i++) {
if (i)
if (i) {
str += ", ";
}
str += arr[i].stringify(stack);
}
@ -1495,73 +1514,80 @@ String Variant::stringify(List<const void *> &stack) const {
}
Variant::operator Vector2() const {
if (type == VECTOR2)
if (type == VECTOR2) {
return *reinterpret_cast<const Vector2 *>(_data._mem);
else if (type == VECTOR3)
} else if (type == VECTOR3) {
return Vector2(reinterpret_cast<const Vector3 *>(_data._mem)->x, reinterpret_cast<const Vector3 *>(_data._mem)->y);
else
} else {
return Vector2();
}
}
Variant::operator Rect2() const {
if (type == RECT2)
if (type == RECT2) {
return *reinterpret_cast<const Rect2 *>(_data._mem);
else
} else {
return Rect2();
}
}
Variant::operator Vector3() const {
if (type == VECTOR3)
if (type == VECTOR3) {
return *reinterpret_cast<const Vector3 *>(_data._mem);
else if (type == VECTOR2)
} else if (type == VECTOR2) {
return Vector3(reinterpret_cast<const Vector2 *>(_data._mem)->x, reinterpret_cast<const Vector2 *>(_data._mem)->y, 0.0);
else
} else {
return Vector3();
}
}
Variant::operator Plane() const {
if (type == PLANE)
if (type == PLANE) {
return *reinterpret_cast<const Plane *>(_data._mem);
else
} else {
return Plane();
}
}
Variant::operator ::AABB() const {
if (type == AABB)
if (type == AABB) {
return *_data._aabb;
else
} else {
return ::AABB();
}
}
Variant::operator Basis() const {
if (type == BASIS)
if (type == BASIS) {
return *_data._basis;
else if (type == QUAT)
} else if (type == QUAT) {
return *reinterpret_cast<const Quat *>(_data._mem);
else if (type == VECTOR3) {
} else if (type == VECTOR3) {
return Basis(*reinterpret_cast<const Vector3 *>(_data._mem));
} else if (type == TRANSFORM) // unexposed in Variant::can_convert?
} else if (type == TRANSFORM) { // unexposed in Variant::can_convert?
return _data._transform->basis;
else
} else {
return Basis();
}
}
Variant::operator Quat() const {
if (type == QUAT)
if (type == QUAT) {
return *reinterpret_cast<const Quat *>(_data._mem);
else if (type == BASIS)
} else if (type == BASIS) {
return *_data._basis;
else if (type == TRANSFORM)
} else if (type == TRANSFORM) {
return _data._transform->basis;
else
} else {
return Quat();
}
}
Variant::operator Transform() const {
if (type == TRANSFORM)
if (type == TRANSFORM) {
return *_data._transform;
else if (type == BASIS)
} else if (type == BASIS) {
return Transform(*_data._basis, Vector3());
else if (type == QUAT)
} else if (type == QUAT) {
return Transform(Basis(*reinterpret_cast<const Quat *>(_data._mem)), Vector3());
else if (type == TRANSFORM2D) {
} else if (type == TRANSFORM2D) {
const Transform2D &t = *_data._transform2d;
Transform m;
m.basis.elements[0][0] = t.elements[0][0];
@ -1571,8 +1597,9 @@ Variant::operator Transform() const {
m.origin[0] = t.elements[2][0];
m.origin[1] = t.elements[2][1];
return m;
} else
} else {
return Transform();
}
}
Variant::operator Transform2D() const {
@ -1588,35 +1615,39 @@ Variant::operator Transform2D() const {
m.elements[2][0] = t.origin[0];
m.elements[2][1] = t.origin[1];
return m;
} else
} else {
return Transform2D();
}
}
Variant::operator Color() const {
if (type == COLOR)
if (type == COLOR) {
return *reinterpret_cast<const Color *>(_data._mem);
else if (type == STRING)
} else if (type == STRING) {
return Color::html(operator String());
else if (type == INT)
} else if (type == INT) {
return Color::hex(operator int());
else
} else {
return Color();
}
}
Variant::operator NodePath() const {
if (type == NODE_PATH)
if (type == NODE_PATH) {
return *reinterpret_cast<const NodePath *>(_data._mem);
else if (type == STRING)
} else if (type == STRING) {
return NodePath(operator String());
else
} else {
return NodePath();
}
}
Variant::operator RefPtr() const {
if (type == OBJECT)
if (type == OBJECT) {
return _get_obj().ref;
else
} else {
return RefPtr();
}
}
Variant::operator RID() const {
@ -1654,10 +1685,11 @@ Variant::operator RID() const {
}
Variant::operator Object *() const {
if (type == OBJECT)
if (type == OBJECT) {
return _OBJ_PTR(*this);
else
} else {
return nullptr;
}
}
Variant::operator Node *() const {
if (type == OBJECT) {
@ -1683,10 +1715,11 @@ Variant::operator Control *() const {
}
Variant::operator Dictionary() const {
if (type == DICTIONARY)
if (type == DICTIONARY) {
return *reinterpret_cast<const Dictionary *>(_data._mem);
else
} else {
return Dictionary();
}
}
template <class DA, class SA>
@ -1735,55 +1768,63 @@ inline DA _convert_array_from_variant(const Variant &p_variant) {
}
Variant::operator Array() const {
if (type == ARRAY)
if (type == ARRAY) {
return *reinterpret_cast<const Array *>(_data._mem);
else
} else {
return _convert_array_from_variant<Array>(*this);
}
}
Variant::operator PoolVector<uint8_t>() const {
if (type == POOL_BYTE_ARRAY)
if (type == POOL_BYTE_ARRAY) {
return *reinterpret_cast<const PoolVector<uint8_t> *>(_data._mem);
else
} else {
return _convert_array_from_variant<PoolVector<uint8_t>>(*this);
}
}
Variant::operator PoolVector<int>() const {
if (type == POOL_INT_ARRAY)
if (type == POOL_INT_ARRAY) {
return *reinterpret_cast<const PoolVector<int> *>(_data._mem);
else
} else {
return _convert_array_from_variant<PoolVector<int>>(*this);
}
}
Variant::operator PoolVector<real_t>() const {
if (type == POOL_REAL_ARRAY)
if (type == POOL_REAL_ARRAY) {
return *reinterpret_cast<const PoolVector<real_t> *>(_data._mem);
else
} else {
return _convert_array_from_variant<PoolVector<real_t>>(*this);
}
}
Variant::operator PoolVector<String>() const {
if (type == POOL_STRING_ARRAY)
if (type == POOL_STRING_ARRAY) {
return *reinterpret_cast<const PoolVector<String> *>(_data._mem);
else
} else {
return _convert_array_from_variant<PoolVector<String>>(*this);
}
}
Variant::operator PoolVector<Vector3>() const {
if (type == POOL_VECTOR3_ARRAY)
if (type == POOL_VECTOR3_ARRAY) {
return *reinterpret_cast<const PoolVector<Vector3> *>(_data._mem);
else
} else {
return _convert_array_from_variant<PoolVector<Vector3>>(*this);
}
}
Variant::operator PoolVector<Vector2>() const {
if (type == POOL_VECTOR2_ARRAY)
if (type == POOL_VECTOR2_ARRAY) {
return *reinterpret_cast<const PoolVector<Vector2> *>(_data._mem);
else
} else {
return _convert_array_from_variant<PoolVector<Vector2>>(*this);
}
}
Variant::operator PoolVector<Color>() const {
if (type == POOL_COLOR_ARRAY)
if (type == POOL_COLOR_ARRAY) {
return *reinterpret_cast<const PoolVector<Color> *>(_data._mem);
else
} else {
return _convert_array_from_variant<PoolVector<Color>>(*this);
}
}
/* helpers */
@ -1792,8 +1833,9 @@ Variant::operator Vector<RID>() const {
Array va = operator Array();
Vector<RID> rids;
rids.resize(va.size());
for (int i = 0; i < rids.size(); i++)
for (int i = 0; i < rids.size(); i++) {
rids.write[i] = va[i];
}
return rids;
}
@ -1801,8 +1843,9 @@ Variant::operator Vector<Vector2>() const {
PoolVector<Vector2> from = operator PoolVector<Vector2>();
Vector<Vector2> to;
int len = from.size();
if (len == 0)
if (len == 0) {
return Vector<Vector2>();
}
to.resize(len);
PoolVector<Vector2>::Read r = from.read();
Vector2 *w = to.ptrw();
@ -1816,14 +1859,16 @@ Variant::operator PoolVector<Plane>() const {
Array va = operator Array();
PoolVector<Plane> planes;
int va_size = va.size();
if (va_size == 0)
if (va_size == 0) {
return planes;
}
planes.resize(va_size);
PoolVector<Plane>::Write w = planes.write();
for (int i = 0; i < va_size; i++)
for (int i = 0; i < va_size; i++) {
w[i] = va[i];
}
return planes;
}
@ -1832,15 +1877,17 @@ Variant::operator PoolVector<Face3>() const {
PoolVector<Vector3> va = operator PoolVector<Vector3>();
PoolVector<Face3> faces;
int va_size = va.size();
if (va_size == 0)
if (va_size == 0) {
return faces;
}
faces.resize(va_size / 3);
PoolVector<Face3>::Write w = faces.write();
PoolVector<Vector3>::Read r = va.read();
for (int i = 0; i < va_size; i++)
for (int i = 0; i < va_size; i++) {
w[i / 3].vertex[i % 3] = r[i];
}
return faces;
}
@ -1849,13 +1896,15 @@ Variant::operator Vector<Plane>() const {
Array va = operator Array();
Vector<Plane> planes;
int va_size = va.size();
if (va_size == 0)
if (va_size == 0) {
return planes;
}
planes.resize(va_size);
for (int i = 0; i < va_size; i++)
for (int i = 0; i < va_size; i++) {
planes.write[i] = va[i];
}
return planes;
}
@ -1927,8 +1976,9 @@ Variant::operator Vector<Vector3>() const {
PoolVector<Vector3> from = operator PoolVector<Vector3>();
Vector<Vector3> to;
int len = from.size();
if (len == 0)
if (len == 0) {
return Vector<Vector3>();
}
to.resize(len);
PoolVector<Vector3>::Read r = from.read();
Vector3 *w = to.ptrw();
@ -1941,8 +1991,9 @@ Variant::operator Vector<Color>() const {
PoolVector<Color> from = operator PoolVector<Color>();
Vector<Color> to;
int len = from.size();
if (len == 0)
if (len == 0) {
return Vector<Color>();
}
to.resize(len);
PoolVector<Color>::Read r = from.read();
Color *w = to.ptrw();
@ -2198,8 +2249,9 @@ Variant::Variant(const Vector<Vector2> &p_array) {
PoolVector<Vector2>::Write w = v.write();
const Vector2 *r = p_array.ptr();
for (int i = 0; i < len; i++)
for (int i = 0; i < len; i++) {
w[i] = r[i];
}
}
*this = v;
}
@ -2244,8 +2296,9 @@ Variant::Variant(const PoolVector<Face3> &p_face_array) {
PoolVector<Vector3>::Write w = vertices.write();
for (int i = 0; i < face_count; i++) {
for (int j = 0; j < 3; j++)
for (int j = 0; j < 3; j++) {
w[i * 3 + j] = r[i].vertex[j];
}
}
}
@ -2261,8 +2314,9 @@ Variant::Variant(const Vector<Variant> &p_array) {
Array v;
int len = p_array.size();
v.resize(len);
for (int i = 0; i < len; i++)
for (int i = 0; i < len; i++) {
v.set(i, p_array[i]);
}
*this = v;
}
@ -2271,8 +2325,9 @@ Variant::Variant(const Vector<uint8_t> &p_array) {
PoolVector<uint8_t> v;
int len = p_array.size();
v.resize(len);
for (int i = 0; i < len; i++)
for (int i = 0; i < len; i++) {
v.set(i, p_array[i]);
}
*this = v;
}
@ -2281,8 +2336,9 @@ Variant::Variant(const Vector<int> &p_array) {
PoolVector<int> v;
int len = p_array.size();
v.resize(len);
for (int i = 0; i < len; i++)
for (int i = 0; i < len; i++) {
v.set(i, p_array[i]);
}
*this = v;
}
@ -2291,8 +2347,9 @@ Variant::Variant(const Vector<real_t> &p_array) {
PoolVector<real_t> v;
int len = p_array.size();
v.resize(len);
for (int i = 0; i < len; i++)
for (int i = 0; i < len; i++) {
v.set(i, p_array[i]);
}
*this = v;
}
@ -2301,8 +2358,9 @@ Variant::Variant(const Vector<String> &p_array) {
PoolVector<String> v;
int len = p_array.size();
v.resize(len);
for (int i = 0; i < len; i++)
for (int i = 0; i < len; i++) {
v.set(i, p_array[i]);
}
*this = v;
}
@ -2311,8 +2369,9 @@ Variant::Variant(const Vector<StringName> &p_array) {
PoolVector<String> v;
int len = p_array.size();
v.resize(len);
for (int i = 0; i < len; i++)
for (int i = 0; i < len; i++) {
v.set(i, p_array[i]);
}
*this = v;
}
@ -2325,8 +2384,9 @@ Variant::Variant(const Vector<Vector3> &p_array) {
PoolVector<Vector3>::Write w = v.write();
const Vector3 *r = p_array.ptr();
for (int i = 0; i < len; i++)
for (int i = 0; i < len; i++) {
w[i] = r[i];
}
}
*this = v;
}
@ -2336,14 +2396,16 @@ Variant::Variant(const Vector<Color> &p_array) {
PoolVector<Color> v;
int len = p_array.size();
v.resize(len);
for (int i = 0; i < len; i++)
for (int i = 0; i < len; i++) {
v.set(i, p_array[i]);
}
*this = v;
}
void Variant::operator=(const Variant &p_variant) {
if (unlikely(this == &p_variant))
if (unlikely(this == &p_variant)) {
return;
}
if (unlikely(type != p_variant.type)) {
reference(p_variant);
@ -2746,8 +2808,9 @@ uint32_t Variant::hash() const {
return true
bool Variant::hash_compare(const Variant &p_variant) const {
if (type != p_variant.type)
if (type != p_variant.type) {
return false;
}
switch (type) {
case REAL: {
@ -2774,8 +2837,9 @@ bool Variant::hash_compare(const Variant &p_variant) const {
Transform2D *r = p_variant._data._transform2d;
for (int i = 0; i < 3; i++) {
if (!(hash_compare_vector2(l->elements[i], r->elements[i])))
if (!(hash_compare_vector2(l->elements[i], r->elements[i]))) {
return false;
}
}
return true;
@ -2817,8 +2881,9 @@ bool Variant::hash_compare(const Variant &p_variant) const {
const Basis *r = p_variant._data._basis;
for (int i = 0; i < 3; i++) {
if (!(hash_compare_vector3(l->elements[i], r->elements[i])))
if (!(hash_compare_vector3(l->elements[i], r->elements[i]))) {
return false;
}
}
return true;
@ -2829,8 +2894,9 @@ bool Variant::hash_compare(const Variant &p_variant) const {
const Transform *r = p_variant._data._transform;
for (int i = 0; i < 3; i++) {
if (!(hash_compare_vector3(l->basis.elements[i], r->basis.elements[i])))
if (!(hash_compare_vector3(l->basis.elements[i], r->basis.elements[i]))) {
return false;
}
}
return hash_compare_vector3(l->origin, r->origin);
@ -2847,12 +2913,14 @@ bool Variant::hash_compare(const Variant &p_variant) const {
const Array &l = *(reinterpret_cast<const Array *>(_data._mem));
const Array &r = *(reinterpret_cast<const Array *>(p_variant._data._mem));
if (l.size() != r.size())
if (l.size() != r.size()) {
return false;
}
for (int i = 0; i < l.size(); ++i) {
if (!l[i].hash_compare(r[i]))
if (!l[i].hash_compare(r[i])) {
return false;
}
}
return true;
@ -2951,8 +3019,9 @@ Variant Variant::call(const StringName &p_method, VARIANT_ARG_DECLARE) {
VARIANT_ARGPTRS;
int argc = 0;
for (int i = 0; i < VARIANT_ARG_MAX; i++) {
if (argptr[i]->get_type() == Variant::NIL)
if (argptr[i]->get_type() == Variant::NIL) {
break;
}
argc++;
}