This is an archive of the discontinued LLVM Phabricator instance.

Differential D52186

[clang-tidy] use CHECK-NOTES in bugprone-forwarding-reference-overload
ClosedPublic

Authored by JonasToth on Sep 17 2018, 12:36 PM.

Details

Reviewers
aaron.ballman
alexfh
hokein
Commits
rGe8b31285aa8f: [clang-tidy] use CHECK-NOTES in bugprone-forwarding-reference-overload
rL342459: [clang-tidy] use CHECK-NOTES in bugprone-forwarding-reference-overload
rCTE342459: [clang-tidy] use CHECK-NOTES in bugprone-forwarding-reference-overload

Diff Detail

Event Timeline

JonasToth created this revision.Sep 17 2018, 12:36 PM
Herald added subscribers: cfe-commits, xazax.hun. · View Herald TranscriptSep 17 2018, 12:36 PM
Harbormaster completed remote builds in B22735: Diff 165806.Sep 17 2018, 12:36 PM
alexfh accepted this revision.Sep 18 2018, 2:24 AM

LG

This revision is now accepted and ready to land.Sep 18 2018, 2:24 AM
Closed by commit rCTE342459: [clang-tidy] use CHECK-NOTES in bugprone-forwarding-reference-overload (authored by JonasToth). · Explain WhySep 18 2018, 3:26 AM
Closed by commit rL342459: [clang-tidy] use CHECK-NOTES in bugprone-forwarding-reference-overload (authored by JonasToth). · Explain Why
This revision was automatically updated to reflect the committed changes.
This revision was automatically updated to reflect the committed changes.
Herald added a subscriber: llvm-commits. · View Herald TranscriptSep 18 2018, 3:26 AM

Revision Contents

PathSize
test/
clang-tidy/
35 lines

Diff 165920

test/clang-tidy/bugprone-forwarding-reference-overload.cpp

Show All 14 Lines
template <class T> struct enable_if { typedef T type; }; template <class T> struct enable_if { typedef T type; };
} // namespace foo } // namespace foo
template <typename T> constexpr bool just_true = true; template <typename T> constexpr bool just_true = true;
class Test1 { class Test1 {
public: public:
template <typename T> Test1(T &&n); template <typename T> Test1(T &&n);
// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: constructor accepting a forwarding reference can hide the copy and move constructors [bugprone-forwarding-reference-overload] // CHECK-NOTES: [[@LINE-1]]:25: warning: constructor accepting a forwarding reference can hide the copy and move constructors [bugprone-forwarding-reference-overload]
// CHECK-NOTES: 48:3: note: copy constructor declared here
// CHECK-NOTES: 49:3: note: copy constructor declared here
// CHECK-NOTES: 50:3: note: move constructor declared here
template <typename T> Test1(T &&n, int i = 5, ...); template <typename T> Test1(T &&n, int i = 5, ...);
// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: constructor accepting a forwarding reference can hide the copy and move constructors // CHECK-NOTES: :[[@LINE-1]]:25: warning: constructor accepting a forwarding reference can hide the copy and move constructors
// CHECK-NOTES: 48:3: note: copy constructor declared here
// CHECK-NOTES: 49:3: note: copy constructor declared here
// CHECK-NOTES: 50:3: note: move constructor declared here
template <typename T, typename U = typename std::enable_if_nice<T>::type> template <typename T, typename U = typename std::enable_if_nice<T>::type>
Test1(T &&n); Test1(T &&n);
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: constructor accepting a forwarding reference can hide the copy and move constructors // CHECK-NOTES: :[[@LINE-1]]:3: warning: constructor accepting a forwarding reference can hide the copy and move constructors
// CHECK-NOTES: 48:3: note: copy constructor declared here
// CHECK-NOTES: 49:3: note: copy constructor declared here
// CHECK-NOTES: 50:3: note: move constructor declared here
template <typename T> template <typename T>
Test1(T &&n, typename foo::enable_if<long>::type i = 5, ...); Test1(T &&n, typename foo::enable_if<long>::type i = 5, ...);
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: constructor accepting a forwarding reference can hide the copy and move constructors // CHECK-NOTES: :[[@LINE-1]]:3: warning: constructor accepting a forwarding reference can hide the copy and move constructors
// CHECK-NOTES: 48:3: note: copy constructor declared here
// CHECK-NOTES: 49:3: note: copy constructor declared here
// CHECK-NOTES: 50:3: note: move constructor declared here
Test1(const Test1 &other) {} Test1(const Test1 &other) {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: note: copy constructor declared here
Test1(Test1 &other) {} Test1(Test1 &other) {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: note: copy constructor declared here
Test1(Test1 &&other) {} Test1(Test1 &&other) {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: note: move constructor declared here
}; };
template <typename U> class Test2 { template <typename U> class Test2 {
public: public:
// Two parameters without default value, can't act as copy / move constructor. // Two parameters without default value, can't act as copy / move constructor.
template <typename T, class V> Test2(T &&n, V &&m, int i = 5, ...); template <typename T, class V> Test2(T &&n, V &&m, int i = 5, ...);
// Guarded with enable_if. // Guarded with enable_if.
Show All 39 Lines
private: private:
Test3(Test3 &&rhs); Test3(Test3 &&rhs);
}; };
// Both the copy and the (compiler generated) move constructors can be hidden. // Both the copy and the (compiler generated) move constructors can be hidden.
class Test4 { class Test4 {
public: public:
template <typename T> Test4(T &&n); template <typename T> Test4(T &&n);
// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: constructor accepting a forwarding reference can hide the copy and move constructors // CHECK-NOTES: :[[@LINE-1]]:25: warning: constructor accepting a forwarding reference can hide the copy and move constructors
Test4(const Test4 &rhs); Test4(const Test4 &rhs);
// CHECK-MESSAGES: :[[@LINE-1]]:3: note: copy constructor declared here // CHECK-NOTES: :[[@LINE-1]]:3: note: copy constructor declared here
}; };
// Nothing can be hidden, the copy constructor is implicitly deleted. // Nothing can be hidden, the copy constructor is implicitly deleted.
class Test5 { class Test5 {
public: public:
template <typename T> Test5(T &&n); template <typename T> Test5(T &&n);
Test5(Test5 &&rhs) = delete; Test5(Test5 &&rhs) = delete;
}; };
// Only the move constructor can be hidden. // Only the move constructor can be hidden.
class Test6 { class Test6 {
public: public:
template <typename T> Test6(T &&n); template <typename T> Test6(T &&n);
// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: constructor accepting a forwarding reference can hide the move constructor // CHECK-NOTES: :[[@LINE-1]]:25: warning: constructor accepting a forwarding reference can hide the move constructor
Test6(Test6 &&rhs); Test6(Test6 &&rhs);
// CHECK-MESSAGES: :[[@LINE-1]]:3: note: move constructor declared here // CHECK-NOTES: :[[@LINE-1]]:3: note: move constructor declared here
private: private:
Test6(const Test6 &rhs); Test6(const Test6 &rhs);
}; };
// Do not dereference a null BaseType. // Do not dereference a null BaseType.
template <class _Callable> class result_of; template <class _Callable> class result_of;
template <class _Fp, class ..._Args> class result_of<_Fp(_Args...)> { }; template <class _Fp, class ..._Args> class result_of<_Fp(_Args...)> { };
template <class _Tp> using result_of_t = typename result_of<_Tp>::type; template <class _Tp> using result_of_t = typename result_of<_Tp>::type;
template <class... _Types> struct __overload; template <class... _Types> struct __overload;
template <class _Tp, class... _Types> template <class _Tp, class... _Types>
struct __overload<_Tp, _Types...> : __overload<_Types...> { struct __overload<_Tp, _Types...> : __overload<_Types...> {
using __overload<_Types...>::operator(); using __overload<_Types...>::operator();
}; };
template <class _Tp, class... _Types> template <class _Tp, class... _Types>
using __best_match_t = typename result_of_t<__overload<_Types...>(_Tp&&)>::type; using __best_match_t = typename result_of_t<__overload<_Types...>(_Tp&&)>::type;
template <class... _Types> template <class... _Types>
class variant { class variant {
public: public:
template <class _Arg, class _Tp = __best_match_t<_Arg, _Types...> > template <class _Arg, class _Tp = __best_match_t<_Arg, _Types...> >
constexpr variant(_Arg&& __arg) {} constexpr variant(_Arg&& __arg) {}
// CHECK-MESSAGES: :[[@LINE-1]]:13: warning: constructor accepting a forwarding reference can hide the copy and move constructors // CHECK-NOTES: :[[@LINE-1]]:13: warning: constructor accepting a forwarding reference can hide the copy and move constructors
}; };