Corrrect warn_unused_result attribute
The original idea was that if the attribute on an operator,
that the return-value unused-ness wouldn't matter. However,
all of the operators except postfix inc/dec return
references! References don't result in this warning
anyway, so those are already excluded.
Differential Revision: https://reviews.llvm.org/D32207
llvm-svn: 300764
diff --git a/clang/include/clang/AST/Decl.h b/clang/include/clang/AST/Decl.h
index ad723a3e..573ea55 100644
--- a/clang/include/clang/AST/Decl.h
+++ b/clang/include/clang/AST/Decl.h
@@ -2082,10 +2082,7 @@
const Attr *getUnusedResultAttr() const;
/// \brief Returns true if this function or its return type has the
- /// warn_unused_result attribute. If the return type has the attribute and
- /// this function is a method of the return type's class, then false will be
- /// returned to avoid spurious warnings on member methods such as assignment
- /// operators.
+ /// warn_unused_result attribute.
bool hasUnusedResultAttr() const { return getUnusedResultAttr() != nullptr; }
/// \brief Returns the storage class as written in the source. For the
diff --git a/clang/lib/AST/Decl.cpp b/clang/lib/AST/Decl.cpp
index 2b22e5b..094e8dc 100644
--- a/clang/lib/AST/Decl.cpp
+++ b/clang/lib/AST/Decl.cpp
@@ -3003,9 +3003,7 @@
const Attr *FunctionDecl::getUnusedResultAttr() const {
QualType RetType = getReturnType();
if (RetType->isRecordType()) {
- const CXXRecordDecl *Ret = RetType->getAsCXXRecordDecl();
- const auto *MD = dyn_cast<CXXMethodDecl>(this);
- if (Ret && !(MD && MD->getCorrespondingMethodInClass(Ret, true))) {
+ if (const CXXRecordDecl *Ret = RetType->getAsCXXRecordDecl()) {
if (const auto *R = Ret->getAttr<WarnUnusedResultAttr>())
return R;
}
diff --git a/clang/test/SemaCXX/warn-unused-result.cpp b/clang/test/SemaCXX/warn-unused-result.cpp
index 01bc457e..88f5ab1 100644
--- a/clang/test/SemaCXX/warn-unused-result.cpp
+++ b/clang/test/SemaCXX/warn-unused-result.cpp
@@ -160,3 +160,49 @@
(void)noexcept(f(), false); // Should not warn.
}
}
+
+namespace {
+// C++ Methods should warn even in their own class.
+struct [[clang::warn_unused_result]] S {
+ S DoThing() { return {}; };
+ S operator++(int) { return {}; };
+ S operator--(int) { return {}; };
+ // Improperly written prefix.
+ S operator++() { return {}; };
+ S operator--() { return {}; };
+};
+
+struct [[clang::warn_unused_result]] P {
+ P DoThing() { return {}; };
+};
+
+P operator++(const P &, int) { return {}; };
+P operator--(const P &, int) { return {}; };
+// Improperly written prefix.
+P operator++(const P &) { return {}; };
+P operator--(const P &) { return {}; };
+
+void f() {
+ S s;
+ P p;
+ s.DoThing(); // expected-warning {{ignoring return value}}
+ p.DoThing(); // expected-warning {{ignoring return value}}
+ // Only postfix is expected to warn when written correctly.
+ s++; // expected-warning {{ignoring return value}}
+ s--; // expected-warning {{ignoring return value}}
+ p++; // expected-warning {{ignoring return value}}
+ p--; // expected-warning {{ignoring return value}}
+ // Improperly written prefix operators should still warn.
+ ++s; // expected-warning {{ignoring return value}}
+ --s; // expected-warning {{ignoring return value}}
+ ++p; // expected-warning {{ignoring return value}}
+ --p; // expected-warning {{ignoring return value}}
+
+ // Silencing the warning by cast to void still works.
+ (void)s.DoThing();
+ (void)s++;
+ (void)p++;
+ (void)++s;
+ (void)++p;
+}
+} // namespace