[clang-tidy] Fixes to misc-forwarding-reference-overload check.

* Style fixes to tests
* Make it work consistently on all platforms

Patch by András Leitereg!

llvm-svn: 300320

diff --git a/clang-tools-extra/clang-tidy/misc/ForwardingReferenceOverloadCheck.cpp b/clang-tools-extra/clang-tidy/misc/ForwardingReferenceOverloadCheck.cpp
index 550c116..0055f35 100644 (file)
--- a/clang-tools-extra/clang-tidy/misc/ForwardingReferenceOverloadCheck.cpp
+++ b/clang-tools-extra/clang-tidy/misc/ForwardingReferenceOverloadCheck.cpp
@@ -56,7 +56,7 @@ AST_MATCHER_P(TemplateTypeParmDecl, hasDefaultArgument,
   return Node.hasDefaultArgument() &&\r
          TypeMatcher.matches(Node.getDefaultArgument(), Finder, Builder);\r
 }\r
-}\r
+} // namespace\r
 \r
 void ForwardingReferenceOverloadCheck::registerMatchers(MatchFinder *Finder) {\r
   // Forwarding references require C++11 or later.\r
@@ -123,7 +123,8 @@ void ForwardingReferenceOverloadCheck::check(
         (OtherCtor->isCopyConstructor() ? EnabledCopy : EnabledMove) = true;\r
     }\r
   }\r
-  bool Copy = !DisabledCopy || EnabledCopy, Move = !DisabledMove || EnabledMove;\r
+  bool Copy = !EnabledMove && !DisabledMove && !DisabledCopy || EnabledCopy;\r
+  bool Move = !DisabledMove || EnabledMove;\r
   if (!Copy && !Move)\r
     return;\r
   diag(Ctor->getLocation(),\r

diff --git a/clang-tools-extra/test/clang-tidy/misc-forwarding-reference-overload.cpp b/clang-tools-extra/test/clang-tidy/misc-forwarding-reference-overload.cpp
index 621654f..6725b0e 100644 (file)
--- a/clang-tools-extra/test/clang-tidy/misc-forwarding-reference-overload.cpp
+++ b/clang-tools-extra/test/clang-tidy/misc-forwarding-reference-overload.cpp
@@ -1,44 +1,37 @@
 // RUN: %check_clang_tidy %s misc-forwarding-reference-overload %t -- -- -std=c++14
 
 namespace std {
-template <bool B, class T = void>
-struct enable_if { typedef T type; };
+template <bool B, class T = void> struct enable_if { typedef T type; };
 
-template <class T>
-struct enable_if<true, T> { typedef T type; };
+template <class T> struct enable_if<true, T> { typedef T type; };
 
 template <bool B, class T = void>
 using enable_if_t = typename enable_if<B, T>::type;
 
-template <class T>
-struct enable_if_nice { typedef T type; };
-}
+template <class T> struct enable_if_nice { typedef T type; };
+} // namespace std
 
 namespace foo {
-template <class T>
-struct enable_if { typedef T type; };
-}
+template <class T> struct enable_if { typedef T type; };
+} // namespace foo
 
-template <typename T>
-constexpr bool just_true = true;
+template <typename T> constexpr bool just_true = true;
 
 class Test1 {
 public:
-  template <typename T>
-  Test1(T &&n);
-  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: constructor accepting a forwarding reference can hide the copy and move constructors [misc-forwarding-reference-overload]
+  template <typename T> Test1(T &&n);
+  // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: constructor accepting a forwarding reference can hide the copy and move constructors [misc-forwarding-reference-overload]
 
-  template <typename T>
-  Test1(T &&n, int i = 5, ...);
-  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: constructor accepting a forwarding reference can hide the copy and move constructors [misc-forwarding-reference-overload]
+  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
 
   template <typename T, typename U = typename std::enable_if_nice<T>::type>
   Test1(T &&n);
-  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: constructor accepting a forwarding reference can hide the copy and move constructors [misc-forwarding-reference-overload]
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: constructor accepting a forwarding reference can hide the copy and move constructors
 
   template <typename T>
   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 [misc-forwarding-reference-overload]
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: constructor accepting a forwarding reference can hide the copy and move constructors
 
   Test1(const Test1 &other) {}
   // CHECK-MESSAGES: :[[@LINE-1]]:3: note: copy constructor declared here
@@ -50,19 +43,19 @@ public:
   // CHECK-MESSAGES: :[[@LINE-1]]:3: note: move constructor declared here
 };
 
-template <typename U>
-class Test2 {
+template <typename U> class Test2 {
 public:
   // 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.
   template <typename T>
-  Test2(T &&n, int i = 5, std::enable_if_t<sizeof(int) < sizeof(long), int> a = 5, ...);
+  Test2(T &&n, int i = 5,
+        std::enable_if_t<sizeof(int) < sizeof(long), int> a = 5, ...);
 
   // Guarded with enable_if.
-  template <typename T, typename X = typename std::enable_if<sizeof(int) < sizeof(long), double>::type &>
+  template <typename T, typename X = typename std::enable_if<
+                            sizeof(int) < sizeof(long), double>::type &>
   Test2(T &&n);
 
   // Guarded with enable_if.
@@ -74,29 +67,24 @@ public:
   Test2(T &&n, double d = 0.0);
 
   // Not a forwarding reference parameter.
-  template <typename T>
-  Test2(const T &&n);
+  template <typename T> Test2(const T &&n);
 
   // Not a forwarding reference parameter.
   Test2(int &&x);
 
   // Two parameters without default value, can't act as copy / move constructor.
-  template <typename T>
-  Test2(T &&n, int x);
+  template <typename T> Test2(T &&n, int x);
 
   // Not a forwarding reference parameter.
-  template <typename T>
-  Test2(U &&n);
+  template <typename T> Test2(U &&n);
 };
 
 // The copy and move constructors are both disabled.
 class Test3 {
 public:
-  template <typename T>
-  Test3(T &&n);
+  template <typename T> Test3(T &&n);
 
-  template <typename T>
-  Test3(T &&n, int I = 5, ...);
+  template <typename T> Test3(T &&n, int I = 5, ...);
 
   Test3(const Test3 &rhs) = delete;
 
@@ -107,31 +95,26 @@ private:
 // Both the copy and the (compiler generated) move constructors can be hidden.
 class Test4 {
 public:
-  template <typename T>
-  Test4(T &&n);
-  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: constructor accepting a forwarding reference can hide the copy and move constructors [misc-forwarding-reference-overload]
+  template <typename T> Test4(T &&n);
+  // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: constructor accepting a forwarding reference can hide the copy and move constructors
 
   Test4(const Test4 &rhs);
   // CHECK-MESSAGES: :[[@LINE-1]]:3: note: copy constructor declared here
 };
 
-// Only the (compiler generated) copy constructor can be hidden.
-// FIXME: Temporarily disabled due to failer on windows build bots.
-//class Test5 {
-//public:
-//  template <typename T>
-//  Test5(T &&n);
-//  // CM: :[[@LINE-1]]:3: warning: constructor accepting a forwarding reference can hide the copy constructor [misc-forwarding-reference-overload]
-//
-//  Test5(Test5 &&rhs) = delete;
-//};
+// Nothing can be hidden, the copy constructor is implicitly deleted.
+class Test5 {
+public:
+  template <typename T> Test5(T &&n);
+
+  Test5(Test5 &&rhs) = delete;
+};
 
 // Only the move constructor can be hidden.
 class Test6 {
 public:
-  template <typename T>
-  Test6(T &&n);
-  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: constructor accepting a forwarding reference can hide the move constructor [misc-forwarding-reference-overload]
+  template <typename T> Test6(T &&n);
+  // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: constructor accepting a forwarding reference can hide the move constructor
 
   Test6(Test6 &&rhs);
   // CHECK-MESSAGES: :[[@LINE-1]]:3: note: move constructor declared here