[clang-tidy] New check bugprone-unused-return-value

[khuttun]

Summary

Detects function calls where the return value is unused.

Checked functions can be configured.

[Eugene.Zelenko]

clang-tidy/bugprone/UnusedReturnValueCheck.cpp

13

Please include cassert, Regex.h, raw_ostream.h, SmallString.h.

clang-tidy/bugprone/UnusedReturnValueCheck.h

14

Please include string.

docs/clang-tidy/checks/bugprone-unused-return-value.rst

17

Please add round brackets to all functions/methods here and below.

[JonasToth]

I think it would be more user friendly if the configured list can be a list and the | concatenation is done within your code.

clang-tidy/bugprone/UnusedReturnValueCheck.cpp

29

Don't use auto here, because the type is not written somewhere

53

Missing full stop.

[aaron.ballman]

clang-tidy/bugprone/UnusedReturnValueCheck.cpp

62–63

const auto Matched -> const auto *Matched

You can elide the curly braces.

The diagnostic doesn't really help the user understand what's wrong with the code. How about "the value returned by this function should be used" and add a note diagnostic that says "cast expression to void to silence warning". Also, you should pass in the SourceRange for the function call expression to the call to diag() so that it highlights the call in question.

test/clang-tidy/bugprone-unused-return-value.cpp

200

Can you also add a test for ignoring the result of a call to std::empty(SomeContainerWithAnEmptyMethod)?

[khuttun]

In D41655#965551, @JonasToth wrote:

I think it would be more user friendly if the configured list can be a list and the | concatenation is done within your code.

What do you exactly mean by list? It seems some other checks use comma or semicolon separators in their configuration strings, but is that really more user friendly than using "|"? At least now it's clear that the whole string is a regex.

[khuttun]

Fix review comments

[aaron.ballman]

clang-tidy/bugprone/UnusedReturnValueCheck.cpp

69

"Normally" is probably a bad term to use here. How about "the value returned by %0 is usually not intended to be discarded"?

70

In the event this returns null, the diagnostic is going to look rather odd. Because the value of the call expression is unused, this will most often trigger in a context where the method call can be inferred (especially because you're now highlighting the source range). It might make sense to simply replace the %0 with "this call expression" or somesuch in the diagnostic.

[khuttun]

clang-tidy/bugprone/UnusedReturnValueCheck.cpp

70

I can remove the function name from the diagnostic. Out of curiosity, in which situations could it be null?

[khuttun]

Fix review comments

[aaron.ballman]

clang-tidy/bugprone/UnusedReturnValueCheck.cpp

70

Situations where the call doesn't refer back to a declaration at all. For instance, a lambda or block.

docs/clang-tidy/checks/bugprone-unused-return-value.rst

23

resource leaks, if the -> resource leaks if the
Often -> Often,

32

I'd reword this sentence to: Not using the return value often indicates that the programmer confused the function with clear().

test/clang-tidy/bugprone-unused-return-value.cpp

164

Sorry, I just realized that we're missing a test case for a common situation -- where the result is used as part of another call expression. Can you add a test to noWarning() to make sure this does not warn:

std::vector<int> v;
extern void f(bool);

f(v.empty()); // Should not warn

[khuttun]

test/clang-tidy/bugprone-unused-return-value.cpp

164

See line 199 in this file.

[khuttun]

Fix review comments

[aaron.ballman]

test/clang-tidy/bugprone-unused-return-value.cpp

164

Ah, my eyes missed that, thank you!

Hmm, I *think* this test should also be okay, but I want to be sure:

std::vector<int> v;
bool b = ({v.empty()}); // Should not warn
({v.empty()}); // ???

I kind of thing that, as an extension to the spirit of this check, any GNU expression statement whose result is unused should probably be diagnosed; what do you think?

You should add tests for the above so we document the expected behavior here.

[khuttun]

test/clang-tidy/bugprone-unused-return-value.cpp

164

Getting a warning when just surrounding the call expression with parenthesis is tested in bugprone-unused-return-value-custom.cpp.

Would your example be parsed as creating an initializer_list? In that case it should not warn. I can add test cases for that.

What do you mean by "GNU expression"?

[aaron.ballman]

test/clang-tidy/bugprone-unused-return-value.cpp

164

Getting a warning when just surrounding the call expression with parenthesis is tested in bugprone-unused-return-value-custom.cpp.

Yup, this is something entirely different, however.

Would your example be parsed as creating an initializer_list? In that case it should not warn. I can add test cases for that.

What do you mean by "GNU expression"?

Those examples are GNU expression statements, which is a GCC extension that Clang also supports. See https://gcc.gnu.org/onlinedocs/gcc/Statement-Exprs.html for more information.

Effectively, the last statement in the GNU expression statement is the "return value" of the expression statement. We should make sure the warnings are sensible with this construct.

[khuttun]

test/clang-tidy/bugprone-unused-return-value.cpp

164

This was a good catch. Code like this

auto Gnu = ({ fun(); });

is currently causing a warning.

[khuttun]

The checker is now disabled inside GNU statement expressions

[aaron.ballman]

test/clang-tidy/bugprone-unused-return-value.cpp

211

Not diagnosing this case is questionable -- the return value *is* unused and that's a bad thing. However, this is likely to be an uncommon code pattern, so I'd be fine if you added a FIXME to the AST matcher code that excludes GNU expression statements to handle this case someday, and add a FIXME comment here as well so we know what we would like the behavior to be (you could fix the FIXMEs in a follow-up patch if you'd like).

[JonasToth]

High Integrity C++ has the rule 17.5.1 Do not ignore the result of std::remove, std::remove_if or std::unique. Do we want to add those to the preconfigured list?

[JonasToth]

clang-tidy/bugprone/UnusedReturnValueCheck.cpp

48

Is the following type a problem for you check?

std::unique_ptr<std::vector<int>> should not be matchable with regex but I don't know if that would have an impact on the functionality.

[khuttun]

In D41655#974725, @JonasToth wrote:

High Integrity C++ has the rule 17.5.1 Do not ignore the result of std::remove, std::remove_if or std::unique. Do we want to add those to the preconfigured list?

To me these sound like reasonable additions. I can add them and run the checker against LLVM source to see if we get any false positives with them.

I also noticed that the checker currently misses unused values inside other kinds of statements than compound statement (if statements, case statements etc.). I will also update the checker to handle these.

clang-tidy/bugprone/UnusedReturnValueCheck.cpp

48

std::unique_ptr<std::vector<int>> is also matched. I added a test case for it.

test/clang-tidy/bugprone-unused-return-value.cpp

211

I'm not so sure whether this code should cause a warning. I see it as equivalent to this

[]{ return std::async(increment, 42); }();

, where the return value of std::async is used in the return statement.

One situation related to the GNU statement expressions that the checker currently misses is if the return value is unused inside the statement expression at some other than the last statement. I can see if this could be somehow covered.

[aaron.ballman]

test/clang-tidy/bugprone-unused-return-value.cpp

211

It all depends on how far down the rabbit hole you want the check to go, I guess.

auto fn = []{ return std::async(increment, 42); };
fn(); // Could also be reasonable to diagnose

I'm fine leaving it alone, but I'd like to see test coverage and comments showing the cases were explicitly considered.

[JonasToth]

clang-tidy/bugprone/UnusedReturnValueCheck.cpp

48

Alright. I think i had a error in my thinking. Because there are followup letters in the regex there are no problems. I thought it would end on the first >, but thats no the case! Thank you for clarification :)

[khuttun]

• Detect unused return values also inside other kinds of statements than compound statements
• Ignore void functions in the checker
• Check std::remove, std::remove_if and std::unique by default

[khuttun]

The checker reports 7 warnings on LLVM + Clang code bases, all on std::unique_ptr::release:

lib/Bitcode/Reader/BitReader.cpp:114:3

• release() called on moved-from unique_ptr
• no harm, just unnecessary

lib/ExecutionEngine/ExecutionEngine.cpp:149:7

• release() called before erasing unique_ptr from a container
• false positive?

lib/Target/AMDGPU/GCNIterativeScheduler.cpp:196:5

• release() called before assigning new pointer to unique_ptr
• false positive?

lib/AsmParser/LLParser.cpp:855:3

• get() + release() could be replaced with release()

tools/clang/lib/Lex/ModuleMap.cpp:791:3

• false positive?

tools/clang/tools/extra/clangd/Compiler.cpp:61:3

• get() + release() could potentially be replaced with release()?

unittests/Support/Casting.cpp:144:3

• release() called to avoid calling delete on a pointer to global object
• false positive?

[khuttun]

Any more comments on this?

[alexfh]

clang-tidy/bugprone/UnusedReturnValueCheck.cpp

37

Can we avoid creating the regex on each match? For example, by changing the parameter type to llvm::Regex. If we need the matcher at all - see the comment below.

46–49

I strongly suspect that we could get away without regexs here. hasAnyName supports inline namespaces, so at least the first five entries here are covered. The main problem with std::unique_ptr<.*>::release is the need to match any template parameters. I *think*, we could adjust hasName to allow omitting template parameters (so that std::unique_ptr::release would match specializations of unique_ptr as well). The empty and allocate would need some research. Can we just list all specific classes where we care about empty? (Alternatively, can we match empty unqualified and check that it's somewhere inside std, but I don't like that much, since it would add inconsistency in how this check is configured.)

62

This is a rather expensive matcher and it is going to be run on each callExpr, which is a lot. Let's at least swap it with the unless(returns(voidType())) below to reduce the number of times it's called.

[alexfh]

clang-tidy/bugprone/UnusedReturnValueCheck.cpp

46–49

A clarification: we could go with your current version and optimize this part later. But the option may start being used by someone and then will change - that would be nice to avoid.

Alternatively, we could switch to hasAnyName right away and leave only the functions that can be easily supported, and then figure out what to do with release, allocate and empty.

I'd probably prefer the latter.

[aaron.ballman]

In D41655#980672, @khuttun wrote:

The checker reports 7 warnings on LLVM + Clang code bases, all on std::unique_ptr::release:

lib/Bitcode/Reader/BitReader.cpp:114:3

• release() called on moved-from unique_ptr
• no harm, just unnecessary

Agreed.

lib/ExecutionEngine/ExecutionEngine.cpp:149:7

• release() called before erasing unique_ptr from a container
• false positive?

False positive.

lib/Target/AMDGPU/GCNIterativeScheduler.cpp:196:5

• release() called before assigning new pointer to unique_ptr
• false positive?

False positive, but a bad code smell given that the assignment operator will perform the release.

lib/AsmParser/LLParser.cpp:855:3

• get() + release() could be replaced with release()

tools/clang/lib/Lex/ModuleMap.cpp:791:3

• false positive?

False positive.

tools/clang/tools/extra/clangd/Compiler.cpp:61:3

• get() + release() could potentially be replaced with release()?

False positive.

unittests/Support/Casting.cpp:144:3

• release() called to avoid calling delete on a pointer to global object
• false positive?

False positive.

From what I can tell of these reports, they almost all boil down to ignoring the call to release() because the pointer is no longer owned by the unique_ptr. This is a pretty reasonable code pattern, but it also seems reasonable to expect users to cast the result to void to silence the warning, so I think this is fine. Have you checked any other large C++ code bases, like Qt or boost?

[khuttun]

From what I can tell of these reports, they almost all boil down to ignoring the call to release() because the pointer is no longer owned by the unique_ptr. This is a pretty reasonable code pattern, but it also seems reasonable to expect users to cast the result to void to silence the warning, so I think this is fine. Have you checked any other large C++ code bases, like Qt or boost?

Yep, there's already code also in LLVM where the release() return value is cast to void, for example in lib/Bitcode/Reader/BitReader.cpp. I haven't run the checker on other large code bases yet, but I can test also that.

clang-tidy/bugprone/UnusedReturnValueCheck.cpp

46–49

If the ultimate goal would be to have this checker working without regexes, then I agree that we shouldn't introduce a version that uses them in the config string, as changing that later would break things.

About creating a version of hasName that ignores template arguments: as I understand it we'd need a new PrintingPolicy to suppress printing the template argument list in NamedDecl::printQualifiedName. Is this correct?

WG21 P0600R1 lists 8 allocate() and 24 empty() functions in std that should be marked with [[nodiscard]]. We could list all of them separately in the checker config, but the config string would get quite long. Regex matching handles these nicely, but if the performance is unacceptable, we have to look for other ways or just skip checking these.

[khuttun]

I changed the checker to use hasAnyName. Checking for unique_ptr::release() and all the empty() functions is removed.

The checker doesn't report any warnings from LLVM + clang codebases now.

[khuttun]

Should I close this review?

[aaron.ballman]

I think this check LGTM.

[alexfh]

LG. Thank you!

BTW, there's an old related patch https://reviews.llvm.org/D17043, which mostly focuses on member functions of STL containers. It might be useful as a reference (there's a pretty extensive list of member functions and containers).

[alexfh]

Do you need help committing the patch?

[khuttun]

In D41655#1037234, @alexfh wrote:

Do you need help committing the patch?

Yes please, I don't have commit access to the repo.

I think the next step for improving this checker could be to make it work with class template member functions. That would allow to add checking also to those container functions that D17043 handles.

[alexfh]

In D41655#1037552, @khuttun wrote:

In D41655#1037234, @alexfh wrote:

Do you need help committing the patch?

Yes please, I don't have commit access to the repo.

The patch doesn't apply cleanly. Please rebase against current HEAD.

I think the next step for improving this checker could be to make it work with class template member functions. That would allow to add checking also to those container functions that D17043 handles.

Yep, sounds reasonable. Thank you for working on this!

[khuttun]

Rebased

clang-tidy/bugprone/BugproneTidyModule.cpp

 #include "InaccurateEraseCheck.h"
 #include "IntegerDivisionCheck.h"
 #include "MisplacedOperatorInStrlenInAllocCheck.h"
 #include "MoveForwardingReferenceCheck.h"
 #include "MultipleStatementMacroCheck.h"
 #include "StringConstructorCheck.h"
 #include "SuspiciousMemsetUsageCheck.h"
 #include "UndefinedMemoryManipulationCheck.h"
+#include "UnusedReturnValueCheck.h"
 #include "UseAfterMoveCheck.h"
 #include "VirtualNearMissCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace bugprone {
 
 class BugproneModule : public ClangTidyModule {
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<MultipleStatementMacroCheck>(
         "bugprone-multiple-statement-macro");
     CheckFactories.registerCheck<StringConstructorCheck>(
         "bugprone-string-constructor");
     CheckFactories.registerCheck<SuspiciousMemsetUsageCheck>(
         "bugprone-suspicious-memset-usage");
     CheckFactories.registerCheck<UndefinedMemoryManipulationCheck>(
         "bugprone-undefined-memory-manipulation");
+    CheckFactories.registerCheck<UnusedReturnValueCheck>(
+        "bugprone-unused-return-value");
     CheckFactories.registerCheck<UseAfterMoveCheck>(
         "bugprone-use-after-move");
     CheckFactories.registerCheck<VirtualNearMissCheck>(
         "bugprone-virtual-near-miss");
   }
 };
 
 } // namespace bugprone

clang-tidy/bugprone/CMakeLists.txt

add_clang_library(clangTidyBugproneModule
   InaccurateEraseCheck.cpp
   IntegerDivisionCheck.cpp
   MisplacedOperatorInStrlenInAllocCheck.cpp
   MoveForwardingReferenceCheck.cpp
   MultipleStatementMacroCheck.cpp
   StringConstructorCheck.cpp
   SuspiciousMemsetUsageCheck.cpp
   UndefinedMemoryManipulationCheck.cpp
+  UnusedReturnValueCheck.cpp
   UseAfterMoveCheck.cpp
   VirtualNearMissCheck.cpp
 
   LINK_LIBS
   clangAnalysis
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   clangTidy
   clangTidyUtils
   clangTooling
   )

clang-tidy/bugprone/UnusedReturnValueCheck.h

+//===--- UnusedReturnValueCheck.h - clang-tidy-------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_UNUSEDRETURNVALUECHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_UNUSEDRETURNVALUECHECK_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace bugprone {
+
+/// Detects function calls where the return value is unused.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-unused-return-value.html
+class UnusedReturnValueCheck : public ClangTidyCheck {
+public:
+  UnusedReturnValueCheck(StringRef Name, ClangTidyContext *Context);
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+
+private:
+  std::string FuncRegex;
+};
+
+} // namespace bugprone
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_UNUSEDRETURNVALUECHECK_H

clang-tidy/bugprone/UnusedReturnValueCheck.cpp

+//===--- UnusedReturnValueCheck.cpp - clang-tidy---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "UnusedReturnValueCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+
+using namespace clang::ast_matchers;
+using namespace clang::ast_matchers::internal;
+
+namespace clang {
+namespace tidy {
+namespace bugprone {
+
+namespace {
+
+// Same as matchesName, but instead of fully qualified name, matches on a name
+// where inline namespaces have been ignored.
+AST_MATCHER_P(NamedDecl, matchesInlinedName, std::string, RegExp) {
+  assert(!RegExp.empty());
+  llvm::SmallString<128> InlinedName("::");
+  llvm::raw_svector_ostream OS(InlinedName);
+  auto Policy = Node.getASTContext().getPrintingPolicy();
+  Policy.SuppressUnwrittenScope = true;
+  Node.printQualifiedName(OS, Policy);
+  return llvm::Regex(RegExp).match(OS.str());
+}
+
+} // namespace
+
+UnusedReturnValueCheck::UnusedReturnValueCheck(llvm::StringRef Name,
+                                               ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context),
+      FuncRegex(Options.get("FunctionsRegex",
+                            "^::std::async$|"
+                            "^::std::launder$|"
+                            "^::std::unique_ptr<.*>::release$|"
+                            "^::std::.*::allocate$|"
+                            "^::std::.*::empty$")) {}
+
+void UnusedReturnValueCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "FunctionsRegex", FuncRegex);
+}
+
+void UnusedReturnValueCheck::registerMatchers(MatchFinder *Finder) {
+  // Detect unused return values by finding CallExprs with CompoundStmt parent,
+  // ignoring any implicit nodes and parentheses in between
+  Finder->addMatcher(
+      compoundStmt(forEach(expr(ignoringImplicit(ignoringParenImpCasts(
+          callExpr(callee(functionDecl(matchesInlinedName(FuncRegex))))
+              .bind("match")))))),
+      this);
+}
+
+void UnusedReturnValueCheck::check(const MatchFinder::MatchResult &Result) {
+  if (const auto Matched = Result.Nodes.getNodeAs<Stmt>("match")) {
+    diag(Matched->getLocStart(), "unused return value");
+  }
+}
+
+} // namespace bugprone
+} // namespace tidy
+} // namespace clang

docs/ReleaseNotes.rst

- New `bugprone-misplaced-operator-in-strlen-in-alloc
   <http://clang.llvm.org/extra/clang-tidy/checks/bugprone-misplaced-operator-in-strlen-in-alloc.html>`_ check
 
   Finds cases where ``1`` is added to the string in the argument to
   ``strlen()``, ``strnlen()``, ``strnlen_s()``, ``wcslen()``, ``wcsnlen()``, and
   ``wcsnlen_s()`` instead of the result and the value is used as an argument to
   a memory allocation function (``malloc()``, ``calloc()``, ``realloc()``,
   ``alloca()``) or the ``new[]`` operator in `C++`.
 
+- New `bugprone-unused-return-value
+  <http://clang.llvm.org/extra/clang-tidy/checks/bugprone-unused-return-value.html>`_ check
+
+  Warns on unused function return values.
+
 - New `cppcoreguidelines-owning-memory <http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-owning-memory.html>`_ check 
 
   This check implements the type-based semantic of ``gsl::owner<T*>``, but without
   flow analysis.
 
 - New `fuchsia-default-arguments
   <http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-default-arguments.html>`_ check
 

docs/clang-tidy/checks/bugprone-unused-return-value.rst

+.. title:: clang-tidy - bugprone-unused-return-value
+
+bugprone-unused-return-value
+============================
+
+Warns on unused function return values. The checked funtions can be configured.
+
+Options
+-------
+
+.. option:: FunctionsRegex
+
+   A regular expression specifying the functions to check. Defaults to
+   ``^::std::async$|^::std::launder$|^::std::unique_ptr<.*>::release$|^::std::.*::allocate$|^::std::.*::empty$``.
+   This means that the calls to following functions are checked by default:
+
+   - ``std::async``. Not using the return value makes the call synchronous.
+   - ``std::launder``. Not using the return value usually means that the
+     function interface was misunderstood by the programmer. Only the returned
+     pointer is "laundered", not the argument.
+   - ``std::unique_ptr::release``. Not using the return value can lead to
+     resource leaks, if the same pointer isn't stored anywhere else. Often
+     ignoring the ``release`` return value indicates that the programmer
+     confused the function with ``reset``.
+   - All ``allocate`` calls in ``std``. For example ``std::allocator::allocate``
+     and ``std::pmr::memory_resource::allocate``. Not using the return value is
+     a resource leak.
+   - All ``empty`` calls in ``std``. For example ``std::vector::empty`` and
+     ``std::filesystem::path::empty``. Not using the return value doesn't cause
+     any issues on itself, but often it indicates that the programmer confused
+     the function with ``clear``.

docs/clang-tidy/checks/list.rst

.. toctree::
    bugprone-inaccurate-erase
    bugprone-integer-division
    bugprone-misplaced-operator-in-strlen-in-alloc
    bugprone-move-forwarding-reference
    bugprone-multiple-statement-macro
    bugprone-string-constructor
    bugprone-suspicious-memset-usage
    bugprone-undefined-memory-manipulation
+   bugprone-unused-return-value
    bugprone-use-after-move
    bugprone-virtual-near-miss
    cert-dcl03-c (redirects to misc-static-assert) <cert-dcl03-c>
    cert-dcl21-cpp
    cert-dcl50-cpp
    cert-dcl54-cpp (redirects to misc-new-delete-overloads) <cert-dcl54-cpp>
    cert-dcl58-cpp
    cert-dcl59-cpp (redirects to google-build-namespaces) <cert-dcl59-cpp>

test/clang-tidy/bugprone-unused-return-value-custom.cpp

+// RUN: %check_clang_tidy %s bugprone-unused-return-value %t \
+// RUN: -config='{CheckOptions: \
+// RUN:  [{key: bugprone-unused-return-value.FunctionsRegex, \
+// RUN:    value: "^::fun$|^::ns::Template<.*>::Inner::memFun$|^::ns::Type::staticFun$"}]}' \
+// RUN: --
+
+namespace std {
+
+template <typename T>
+T *launder(T *);
+
+} // namespace std
+
+namespace ns {
+
+template <typename T>
+struct Template {
+  struct Inner {
+    bool memFun();
+  };
+};
+
+using IntType = Template<int>;
+
+struct Derived : public Template<bool>::Inner {};
+
+struct Retval {
+  int *P;
+  Retval() { P = new int; }
+  ~Retval() { delete P; }
+};
+
+struct Type {
+  Retval memFun();
+  static Retval staticFun();
+};
+
+} // namespace ns
+
+int fun();
+
+void warning() {
+  fun();
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: unused return value [bugprone-unused-return-value]
+
+  (fun());
+  // CHECK-MESSAGES: [[@LINE-1]]:4: warning: unused return value [bugprone-unused-return-value]
+
+  ns::Template<bool>::Inner ObjA1;
+  ObjA1.memFun();
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: unused return value [bugprone-unused-return-value]
+
+  ns::IntType::Inner ObjA2;
+  ObjA2.memFun();
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: unused return value [bugprone-unused-return-value]
+
+  ns::Derived ObjA3;
+  ObjA3.memFun();
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: unused return value [bugprone-unused-return-value]
+
+  ns::Type::staticFun();
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: unused return value [bugprone-unused-return-value]
+}
+
+void noWarning() {
+  auto R1 = fun();
+
+  ns::Template<bool>::Inner ObjB1;
+  auto R2 = ObjB1.memFun();
+
+  auto R3 = ns::Type::staticFun();
+
+  // test discarding return value of functions that are not configured to be checked
+  int I = 1;
+  std::launder(&I);
+
+  ns::Type ObjB2;
+  ObjB2.memFun();
+}

test/clang-tidy/bugprone-unused-return-value.cpp

+// RUN: %check_clang_tidy %s bugprone-unused-return-value %t
+
+namespace std {
+
+using size_t = decltype(sizeof(int));
+
+using max_align_t = long double;
+
+struct future {};
+
+enum class launch {
+  async,
+  deferred
+};
+
+template <typename Function, typename... Args>
+future async(Function &&, Args &&...);
+
+template <typename Function, typename... Args>
+future async(launch, Function &&, Args &&...);
+
+// the check should be able to match std lib calls even if the functions are
+// declared inside inline namespaces
+inline namespace v1 {
+
+template <typename T>
+T *launder(T *);
+
+} // namespace v1
+
+template <typename T>
+struct allocator {
+  using value_type = T;
+  T *allocate(std::size_t);
+  T *allocate(std::size_t, const void *);
+};
+
+template <typename Alloc>
+struct allocator_traits {
+  using value_type = typename Alloc::value_type;
+  using pointer = value_type *;
+  using size_type = size_t;
+  using const_void_pointer = const void *;
+  static pointer allocate(Alloc &, size_type);
+  static pointer allocate(Alloc &, size_type, const_void_pointer);
+};
+
+template <typename OuterAlloc, typename... InnerAlloc>
+struct scoped_allocator_adaptor : public OuterAlloc {
+  using pointer = typename allocator_traits<OuterAlloc>::pointer;
+  using size_type = typename allocator_traits<OuterAlloc>::size_type;
+  using const_void_pointer = typename allocator_traits<OuterAlloc>::const_void_pointer;
+  pointer allocate(size_type);
+  pointer allocate(size_type, const_void_pointer);
+};
+
+template <typename T>
+struct default_delete {};
+
+template <typename T, typename Deleter = default_delete<T>>
+struct unique_ptr {
+  using pointer = T *;
+  pointer release() noexcept;
+};
+
+template <typename T, typename Allocator = allocator<T>>
+struct vector {
+  bool empty() const noexcept;
+};
+
+namespace filesystem {
+
+struct path {
+  bool empty() const noexcept;
+};
+
+} // namespace filesystem
+
+namespace pmr {
+
+struct memory_resource {
+  void *allocate(size_t, size_t = alignof(max_align_t));
+};
+
+template <typename T>
+struct polymorphic_allocator {
+  T *allocate(size_t);
+};
+
+} // namespace pmr
+
+} // namespace std
+
+struct Foo {
+  void f();
+};
+
+int increment(int i) {
+  return i + 1;
+}
+
+void useFuture(const std::future &fut);
+
+struct FooAlloc {
+  using value_type = Foo;
+};
+
+void warning() {
+  std::async(increment, 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: unused return value [bugprone-unused-return-value]
+
+  std::async(std::launch::async, increment, 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: unused return value [bugprone-unused-return-value]
+
+  Foo F;
+  std::launder(&F);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: unused return value [bugprone-unused-return-value]
+
+  std::unique_ptr<Foo> UP;
+  UP.release();
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: unused return value [bugprone-unused-return-value]
+
+  std::allocator<Foo> FA;
+  FA.allocate(1);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: unused return value [bugprone-unused-return-value]
+  FA.allocate(1, nullptr);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: unused return value [bugprone-unused-return-value]
+
+  std::allocator_traits<std::allocator<Foo>>::allocate(FA, 1);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: unused return value [bugprone-unused-return-value]
+  std::allocator_traits<std::allocator<Foo>>::allocate(FA, 1, nullptr);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: unused return value [bugprone-unused-return-value]
+
+  std::scoped_allocator_adaptor<FooAlloc, FooAlloc> SAA;
+  SAA.allocate(1);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: unused return value [bugprone-unused-return-value]
+  SAA.allocate(1, nullptr);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: unused return value [bugprone-unused-return-value]
+
+  std::pmr::memory_resource MR;
+  MR.allocate(1);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: unused return value [bugprone-unused-return-value]
+
+  std::pmr::polymorphic_allocator<Foo> PA;
+  PA.allocate(1);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: unused return value [bugprone-unused-return-value]
+
+  std::vector<Foo> FV;
+  FV.empty();
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: unused return value [bugprone-unused-return-value]
+
+  std::filesystem::path P;
+  P.empty();
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: unused return value [bugprone-unused-return-value]
+}
+
+void noWarning() {
+  auto AsyncRetval1 = std::async(increment, 42);
+  auto AsyncRetval2 = std::async(std::launch::async, increment, 42);
+
+  Foo FNoWarning;
+  auto LaunderRetval = std::launder(&FNoWarning);
+
+  std::unique_ptr<Foo> UPNoWarning;
+  auto ReleaseRetval = UPNoWarning.release();
+
+  std::allocator<Foo> FANoWarning;
+  auto AllocRetval1 = FANoWarning.allocate(1, nullptr);
+  auto AllocRetval2 = FANoWarning.allocate(1);
+
+  auto AllocRetval3 = std::allocator_traits<std::allocator<Foo>>::allocate(FANoWarning, 1);
+  auto AllocRetval4 = std::allocator_traits<std::allocator<Foo>>::allocate(FANoWarning, 1, nullptr);
+
+  std::scoped_allocator_adaptor<FooAlloc, FooAlloc> SAANoWarning;
+  auto AllocRetval5 = SAANoWarning.allocate(1);
+  auto AllocRetval6 = SAANoWarning.allocate(1, nullptr);
+
+  std::pmr::memory_resource MRNoWarning;
+  auto AllocRetval7 = MRNoWarning.allocate(1);
+
+  std::pmr::polymorphic_allocator<Foo> PANoWarning;
+  auto AllocRetval8 = PANoWarning.allocate(1);
+
+  std::vector<Foo> FVNoWarning;
+  auto VectorEmptyRetval = FVNoWarning.empty();
+
+  std::filesystem::path PNoWarning;
+  auto PathEmptyRetval = PNoWarning.empty();
+
+  // test using the return value in different kinds of expressions
+  useFuture(std::async(increment, 42));
+  std::launder(&FNoWarning)->f();
+  delete std::launder(&FNoWarning);
+
+  // cast to void should allow ignoring the return value
+  (void)std::async(increment, 42);
+
+  // test discarding return value of functions that are not configured to be checked
+  increment(1);
+}