Whitelist operator== and operator!= as valid for unused value warnings,

even when overloaded and user-defined. These operators are both more
valuable to warn on (due to likely typos) and extremely unlikely to be
reasonable for use to trigger side-effects.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@137823 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
index 5e795be56d13f882766e51296d1a3cee18e43a1a..41fa850184efe6ba2b25a0c525dfdcc71ac9d991 100644 (file)
--- a/lib/AST/Expr.cpp
+++ b/lib/AST/Expr.cpp
@@ -1524,8 +1524,21 @@ bool Expr::isUnusedResultAWarning(SourceLocation &Loc, SourceRange &R1,
     R2 = cast<ArraySubscriptExpr>(this)->getRHS()->getSourceRange();
     return true;
 
+  case CXXOperatorCallExprClass: {
+    // We warn about operator== and operator!= even when user-defined operator
+    // overloads as there is no reasonable way to define these such that they
+    // have non-trivial, desirable side-effects. See the -Wunused-comparison
+    // warning: these operators are commonly typo'ed, and so warning on them
+    // provides additional value as well. If this list is updated,
+    // DiagnoseUnusedComparison should be as well.
+    const CXXOperatorCallExpr *Op = cast<CXXOperatorCallExpr>(this);
+    if (Op->getOperator() == OO_EqualEqual ||
+        Op->getOperator() == OO_ExclaimEqual)
+      return true;
+
+    // Fallthrough for generic call handling.
+  }
   case CallExprClass:
-  case CXXOperatorCallExprClass:
   case CXXMemberCallExprClass: {
     // If this is a direct call, get the callee.
     const CallExpr *CE = cast<CallExpr>(this);

diff --git a/test/SemaCXX/overloaded-operator.cpp b/test/SemaCXX/overloaded-operator.cpp
index 462d0234f39fd591a942049b87b420598975aed9..36d95599ffb261ce69f2ca959eba8ae3e6cc7f1b 100644 (file)
--- a/test/SemaCXX/overloaded-operator.cpp
+++ b/test/SemaCXX/overloaded-operator.cpp
@@ -36,7 +36,7 @@ A make_A();
 bool operator==(A&, Z&); // expected-note 3{{candidate function}}
 
 void h(A a, const A ac, Z z) {
-  make_A() == z;
+  make_A() == z; // expected-warning{{equality comparison result unused}}
   a == z; // expected-error{{use of overloaded operator '==' is ambiguous}}
   ac == z; // expected-error{{invalid operands to binary expression ('const A' and 'Z')}}
 }
@@ -45,7 +45,7 @@ struct B {
   bool operator==(const B&) const;
 
   void test(Z z) {
-    make_A() == z;
+    make_A() == z; // expected-warning{{equality comparison result unused}}
   }
 };
 

diff --git a/test/SemaCXX/warn-unused-comparison.cpp b/test/SemaCXX/warn-unused-comparison.cpp
index 79a644cefc01777a75256dbeda43191057a8dea1..f790c669ff5e60d29701b9fd79f8e5625e8f8c63 100644 (file)
--- a/test/SemaCXX/warn-unused-comparison.cpp
+++ b/test/SemaCXX/warn-unused-comparison.cpp
@@ -19,13 +19,13 @@ void test() {
   p == p; // expected-warning {{equality comparison result unused}} \
           // expected-note {{use '=' to turn this equality comparison into an assignment}} \
           // expected-warning {{self-comparison always evaluates to true}}
-  a == a; // FIXME: missing-warning {{equality comparison result unused}} \
-          // FIXME: missing-note {{use '=' to turn this equality comparison into an assignment}}
-  a == b; // FIXME: missing-warning {{equality comparison result unused}} \
-          // FIXME: missing-note {{use '=' to turn this equality comparison into an assignment}}
-  a != b; // FIXME: missing-warning {{inequality comparison result unused}} \
-          // FIXME: missing-note {{use '|=' to turn this inequality comparison into an or-assignment}}
-  A() == b; // FIXME: missing-warning {{equality comparison result unused}}
+  a == a; // expected-warning {{equality comparison result unused}} \
+          // expected-note {{use '=' to turn this equality comparison into an assignment}}
+  a == b; // expected-warning {{equality comparison result unused}} \
+          // expected-note {{use '=' to turn this equality comparison into an assignment}}
+  a != b; // expected-warning {{inequality comparison result unused}} \
+          // expected-note {{use '|=' to turn this inequality comparison into an or-assignment}}
+  A() == b; // expected-warning {{equality comparison result unused}}
   if (42) x == 7; // expected-warning {{equality comparison result unused}} \
                   // expected-note {{use '=' to turn this equality comparison into an assignment}}
   else if (42) x == 7; // expected-warning {{equality comparison result unused}} \

diff --git a/test/SemaTemplate/overload-uneval.cpp b/test/SemaTemplate/overload-uneval.cpp
index 632d1cd521d9d132efc3d860995e3ea5940f9c2b..8d8a2f42cf283cb807334509b46945a9d83d6408 100644 (file)
--- a/test/SemaTemplate/overload-uneval.cpp
+++ b/test/SemaTemplate/overload-uneval.cpp
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -Wno-unused %s
 
 // Tests that overload resolution is treated as an unevaluated context.
 // PR5541