blob: 49a41ae18cf8b2875424adbdffc713e9d4ab014f [file] [log] [blame]
// RUN: %check_clang_tidy %s modernize-return-braced-init-list %t -- -- -std=c++14
namespace std {
typedef decltype(sizeof(int)) size_t;
// libc++'s implementation
template <class _E>
class initializer_list {
const _E *__begin_;
size_t __size_;
initializer_list(const _E *__b, size_t __s)
: __begin_(__b),
__size_(__s) {}
public:
typedef _E value_type;
typedef const _E &reference;
typedef const _E &const_reference;
typedef size_t size_type;
typedef const _E *iterator;
typedef const _E *const_iterator;
initializer_list() : __begin_(nullptr), __size_(0) {}
size_t size() const { return __size_; }
const _E *begin() const { return __begin_; }
const _E *end() const { return __begin_ + __size_; }
};
template <typename T>
class vector {
public:
vector(T) {}
vector(std::initializer_list<T>) {}
};
}
class Bar {};
Bar b0;
class Foo {
public:
Foo(Bar) {}
explicit Foo(Bar, unsigned int) {}
Foo(unsigned int) {}
};
class Baz {
public:
Foo m() {
Bar bm;
return Foo(bm);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: avoid repeating the return type from the declaration; use a braced initializer list instead [modernize-return-braced-init-list]
// CHECK-FIXES: return {bm};
}
};
class Quux : public Foo {
public:
Quux(Bar bar) : Foo(bar) {}
Quux(unsigned, unsigned, unsigned k = 0) : Foo(k) {}
};
Foo f() {
Bar b1;
return Foo(b1);
// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: avoid repeating the return type
// CHECK-FIXES: return {b1};
}
Foo f2() {
Bar b2;
return {b2};
}
auto f3() {
Bar b3;
return Foo(b3);
}
#define A(b) Foo(b)
Foo f4() {
Bar b4;
return A(b4);
}
Foo f5() {
Bar b5;
return Quux(b5);
}
Foo f6() {
Bar b6;
return Foo(b6, 1);
}
std::vector<int> f7() {
int i7 = 1;
return std::vector<int>(i7);
// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: avoid repeating the return type
}
Bar f8() {
return {};
}
Bar f9() {
return Bar();
// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: avoid repeating the return type
}
Bar f10() {
return Bar{};
}
Foo f11(Bar b11) {
return Foo(b11);
// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: avoid repeating the return type
// CHECK-FIXES: return {b11};
}
Foo f12() {
return f11(Bar());
}
Foo f13() {
return Foo(Bar()); // 13
// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: avoid repeating the return type
// CHECK-FIXES: return {Bar()}; // 13
}
Foo f14() {
// FIXME: Type narrowing should not occur!
return Foo(-1);
// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: avoid repeating the return type
// CHECK-FIXES: return {-1};
}
Foo f15() {
return Foo(f10());
// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: avoid repeating the return type
// CHECK-FIXES: return {f10()};
}
Quux f16() {
return Quux(1, 2);
// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: avoid repeating the return type
// CHECK-FIXES: return {1, 2};
}
Quux f17() {
return Quux(1, 2, 3);
// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: avoid repeating the return type
// CHECK-FIXES: return {1, 2, 3};
}
template <typename T>
T f19() {
return T();
}
Bar i1 = f19<Bar>();
Baz i2 = f19<Baz>();
template <typename T>
Foo f20(T t) {
return Foo(t);
}
Foo i3 = f20(b0);
template <typename T>
class BazT {
public:
T m() {
Bar b;
return T(b);
}
Foo m2(T t) {
return Foo(t);
}
};
BazT<Foo> bazFoo;
Foo i4 = bazFoo.m();
Foo i5 = bazFoo.m2(b0);
BazT<Quux> bazQuux;
Foo i6 = bazQuux.m();
Foo i7 = bazQuux.m2(b0);
auto v1 = []() { return std::vector<int>({1, 2}); }();
auto v2 = []() -> std::vector<int> { return std::vector<int>({1, 2}); }();