[clang-tidy] Fix modernize-use-std-print check when return value used

[mikecrowe]

Summary

The initial implementation of the modernize-use-std-print check was
capable of converting calls to printf (etc.) which used the return value
to calls to std::print which has no return value, thus breaking the
code.

Use code inspired by the implementation of bugprone-unused-return-value
check to ignore cases where the return value is used. Add appropriate
lit test cases and documentation.

[PiotrZSL]

LGTM

clang-tools-extra/clang-tidy/modernize/UseStdPrintCheck.cpp

73–95

NOTE: Personally I do not thing that this is right way. Instead of using "inclusion" matcher, better would be to use elimination. like: `callExpr(unless(hasParent(anyOf(varDecl(), callExpr(), ifStmt(), ...`.

But if it's working fine, then it could be for now, so lets leave it. Simply with this it may not find all cases.

clang-tools-extra/test/clang-tidy/checkers/modernize/use-std-print-absl.cpp

63

NOTE: I don't think that those FIXES-NOT are needed.

[mikecrowe]

clang-tools-extra/clang-tidy/modernize/UseStdPrintCheck.cpp

73–95

I'm happy to try doing it a different way. I just took this code from the bugprone-unused-return-value check. I had a go at using:

C++
    Finder->addMatcher(
      callExpr(unless(hasParent(anyOf(varDecl(), callExpr(), ifStmt(), whileStmt(), doStmt(), forStmt(), cxxForRangeStmt(), switchCase()))), argumentCountAtLeast(1),

but there's no overload of hasParent that will accept the return type of anyOf:

/home/mac/git/llvm-project/clang-tools-extra/clang-tidy/modernize/UseStdPrintCheck.cpp:100:23: error: no matching function for call to object of type 'const internal::ArgumentAdaptingMatcherFunc<clang::ast_matchers::internal::HasParentMatcher, internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>, internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc, Attr>>'
      callExpr(unless(hasParent(anyOf(varDecl(), callExpr(), ifStmt(), whileStmt(), doStmt(), forStmt(), cxxForRangeStmt(), switchCase()))), argumentCountAtLeast(1),
                      ^~~~~~~~~
/home/mac/git/llvm-project/clang/include/clang/ASTMatchers/ASTMatchersInternal.h:1491:3: note: candidate template ignored: could not match 'Matcher' against 'VariadicOperatorMatcher'
  operator()(const Matcher<T> &InnerMatcher) const {
  ^
/home/mac/git/llvm-project/clang/include/clang/ASTMatchers/ASTMatchersInternal.h:1498:3: note: candidate template ignored: could not match 'MapAnyOfHelper' against 'VariadicOperatorMatcher'
  operator()(const MapAnyOfHelper<T...> &InnerMatcher) const {

(Reducing the set of matchers inside the anyOf didn't help.)

clang-tools-extra/test/clang-tidy/checkers/modernize/use-std-print-absl.cpp

63

OK. I'll leave only the ones that are for deficiencies that might one day be fixed.

[dyung]

@mikecrowe Your change is causing a test failure on the PS4 linux and PS5 Windows build bots. Can you take a look and fix or revert if you need time to investigate?

https://lab.llvm.org/buildbot/#/builders/139/builds/43856
https://lab.llvm.org/buildbot/#/builders/216/builds/23017

[mikecrowe]

In D153860#4453572, @dyung wrote:

@mikecrowe Your change is causing a test failure on the PS4 linux and PS5 Windows build bots. Can you take a look and fix or revert if you need time to investigate?

https://lab.llvm.org/buildbot/#/builders/139/builds/43856
https://lab.llvm.org/buildbot/#/builders/216/builds/23017

The failure is due to:

use-std-print.cpp.tmp.cpp:125:3: error: cannot use 'try' with exceptions disabled [clang-diagnostic-error]

I wasn't expecting that!

It looks like I failed to notice that the bugprone-unused-return-value check explicitly added -fexceptions to the clang-tidy command line to avoid this problem. I can add that to hopefully fix the problem, and I had some other changes that I hadn't pushed for review before this landed the first time too.

[mikecrowe]

Fix test failures on PS4 and PS5 and improve tests

• Ensure that exceptions are available so the test can use try/catch
• Remove unwanted -NOT checks
• Add more return value tests

[mikecrowe]

I believe that the problems that caused this to be reverted have been fixed.

clang-tools-extra/clang-tidy/modernize/UseStdPrintCheck.cpp

 }
 
 void UseStdPrintCheck::registerPPCallbacks(const SourceManager &SM,
                                            Preprocessor *PP,
                                            Preprocessor *ModuleExpanderPP) {
   IncludeInserter.registerPreprocessor(PP);
 }
 
+static clang::ast_matchers::StatementMatcher
+unusedReturnValue(clang::ast_matchers::StatementMatcher MatchedCallExpr) {
+  auto UnusedInCompoundStmt =
+      compoundStmt(forEach(MatchedCallExpr),
+                   // The checker can't currently differentiate between the
+                   // return statement and other statements inside GNU statement
+                   // expressions, so disable the checker inside them to avoid
+                   // false positives.
+                   unless(hasParent(stmtExpr())));
+  auto UnusedInIfStmt =
+      ifStmt(eachOf(hasThen(MatchedCallExpr), hasElse(MatchedCallExpr)));
+  auto UnusedInWhileStmt = whileStmt(hasBody(MatchedCallExpr));
+  auto UnusedInDoStmt = doStmt(hasBody(MatchedCallExpr));
+  auto UnusedInForStmt =
+      forStmt(eachOf(hasLoopInit(MatchedCallExpr),
+                     hasIncrement(MatchedCallExpr), hasBody(MatchedCallExpr)));
+  auto UnusedInRangeForStmt = cxxForRangeStmt(hasBody(MatchedCallExpr));
+  auto UnusedInCaseStmt = switchCase(forEach(MatchedCallExpr));
+
+  return stmt(anyOf(UnusedInCompoundStmt, UnusedInIfStmt, UnusedInWhileStmt,
+                    UnusedInDoStmt, UnusedInForStmt, UnusedInRangeForStmt,
+                    UnusedInCaseStmt));
+}
+
 void UseStdPrintCheck::registerMatchers(MatchFinder *Finder) {
   if (!PrintfLikeFunctions.empty())
     Finder->addMatcher(
+        unusedReturnValue(
             callExpr(argumentCountAtLeast(1),
                      hasArgument(0, stringLiteral(isOrdinary())),
-                 callee(functionDecl(
-                            unless(cxxMethodDecl()),
-                            matchers::matchesAnyListedName(PrintfLikeFunctions))
+                     callee(functionDecl(unless(cxxMethodDecl()),
+                                         matchers::matchesAnyListedName(
+                                             PrintfLikeFunctions))
                                 .bind("func_decl")))
-            .bind("printf"),
+                .bind("printf")),
         this);
 
   if (!FprintfLikeFunctions.empty())
     Finder->addMatcher(
+        unusedReturnValue(
             callExpr(argumentCountAtLeast(2),
                      hasArgument(1, stringLiteral(isOrdinary())),
                      callee(functionDecl(unless(cxxMethodDecl()),
                                          matchers::matchesAnyListedName(
                                              FprintfLikeFunctions))
                                 .bind("func_decl")))
-            .bind("fprintf"),
+                .bind("fprintf")),
         this);
 }
 
 void UseStdPrintCheck::check(const MatchFinder::MatchResult &Result) {
   unsigned FormatArgOffset = 0;
   const auto *OldFunction = Result.Nodes.getNodeAs<FunctionDecl>("func_decl");
   const auto *Printf = Result.Nodes.getNodeAs<CallExpr>("printf");
   if (!Printf) {

clang-tools-extra/docs/clang-tidy/checks/modernize/use-std-print.rst

 - Use of any unsupported flags or specifiers will cause the entire
   statement to be left alone and a warning to be emitted. Particular
   unsupported features are:
 
   - The ``%'`` flag for thousands separators.
 
   - The glibc extension ``%m``.
 
+- ``printf`` and similar functions return the number of characters printed.
+  ``std::print`` does not. This means that any invocations that use the
+  return value will not be converted. Unfortunately this currently includes
+  explicitly-casting to ``void``. Deficiencies in this check mean that any
+  invocations inside ``GCC`` compound statements cannot be converted even
+  if the resulting value is not used.
+
 If conversion would be incomplete or unsafe then the entire invocation will
 be left unchanged.
 
 If the call is deemed suitable for conversion then:
 
 - ``printf``, ``fprintf``, ``absl::PrintF``, ``absl::FPrintF`` and any
   functions specified by the `PrintfLikeFunctions` option or
   `FprintfLikeFunctions` are replaced with the function specified by the

clang-tools-extra/test/clang-tidy/checkers/modernize/use-std-print-absl.cpp

void printf_no_casts_in_strict_mode() {
   // CHECK-FIXES: std::println("Integer {} from unsigned short", us);
 
   const short s = 42;
   PrintF("Unsigned integer %hu from short\n", s);
   // CHECK-MESSAGES: [[@LINE-1]]:3: warning: use 'std::println' instead of 'PrintF' [modernize-use-std-print]
   // CHECK-FIXES: std::println("Unsigned integer {} from short", s);
 }
 
+int printf_uses_return_value(int i) {
+  using namespace absl;
+
+  return PrintF("return value %d\n", i);
+}
+
 void fprintf_simple(FILE *fp) {
   absl::FPrintF(fp, "Hello %s %d", "world", 42);
   // CHECK-MESSAGES: [[@LINE-1]]:3: warning: use 'std::print' instead of 'FPrintF' [modernize-use-std-print]
   // CHECK-FIXES: std::print(fp, "Hello {} {}", "world", 42);
 }
 
 void fprintf_newline(FILE *fp) {
   absl::FPrintF(fp, "Hello %s %d\n", "world", 42);
void fprintf_no_casts_in_strict_mode(FILE *fp) {
   // CHECK-MESSAGES: [[@LINE-1]]:3: warning: use 'std::println' instead of 'FPrintF' [modernize-use-std-print]
   // CHECK-FIXES: std::println(fp, "Integer {} from unsigned short", us);
 
   const short s = 42;
   FPrintF(fp, "Unsigned integer %hu from short\n", s);
   // CHECK-MESSAGES: [[@LINE-1]]:3: warning: use 'std::println' instead of 'FPrintF' [modernize-use-std-print]
   // CHECK-FIXES: std::println(fp, "Unsigned integer {} from short", s);
 }
+
+int fprintf_uses_return_value(FILE *fp, int i) {
+  using namespace absl;
+
+  return FPrintF(fp, "return value %d\n", i);
+}

clang-tools-extra/test/clang-tidy/checkers/modernize/use-std-print-custom.cpp

void printf_newline() {
   myprintf2("Hello %s %d\n", "world", 42);
   // CHECK-MESSAGES: [[@LINE-1]]:3: warning: use 'std::println' instead of 'myprintf2' [modernize-use-std-print]
   // CHECK-FIXES: std::println("Hello {} {}", "world", 42);
 
   // When using custom options leave printf alone
   printf("Hello %s %d\n", "world", 42);
 }
 
+int printf_uses_return_value(int i) {
+  return myprintf("return value %d\n", i);
+  // CHECK-MESSAGES-NOT: [[@LINE-1]]:10: warning: use 'std::println' instead of 'myprintf' [modernize-use-std-print]
+  // CHECK-FIXES-NOT: std::println("return value {}", i);
+}
+
 void fprintf_simple(FILE *fp)
 {
   myfprintf(stderr, "Hello %s %d", "world", 42);
   // CHECK-MESSAGES: [[@LINE-1]]:3: warning: use 'std::print' instead of 'myfprintf' [modernize-use-std-print]
   // CHECK-FIXES: std::print(stderr, "Hello {} {}", "world", 42);
 }
 
 void fprintf_newline(FILE *fp)
void fprintf_newline(FILE *fp)
   using mynamespace::myfprintf2;
   myfprintf2(stderr, "Hello %s %d\n", "world", 42);
   // CHECK-MESSAGES: [[@LINE-1]]:3: warning: use 'std::println' instead of 'myfprintf2' [modernize-use-std-print]
   // CHECK-FIXES: std::println(stderr, "Hello {} {}", "world", 42);
 
   // When using custom options leave fprintf alone
   fprintf(stderr, "Hello %s %d\n", "world", 42);
 }
+
+int fprintf_uses_return_value(int i) {
+  return myfprintf(stderr, "return value %d\n", i);
+  // CHECK-MESSAGES-NOT: [[@LINE-1]]:10: warning: use 'std::println' instead of 'myprintf' [modernize-use-std-print]
+  // CHECK-FIXES-NOT: std::println(stderr, "return value {}", i);
+}

clang-tools-extra/test/clang-tidy/checkers/modernize/use-std-print.cpp

 // RUN: %check_clang_tidy -check-suffixes=,STRICT \
 // RUN:   -std=c++23 %s modernize-use-std-print %t -- \
 // RUN:   -config="{CheckOptions: [{key: StrictMode, value: true}]}" \
-// RUN:   -- -isystem %clang_tidy_headers
+// RUN:   -- -isystem %clang_tidy_headers -fexceptions
 // RUN: %check_clang_tidy -check-suffixes=,NOTSTRICT \
 // RUN:   -std=c++23 %s modernize-use-std-print %t -- \
 // RUN:   -config="{CheckOptions: [{key: StrictMode, value: false}]}" \
-// RUN:   -- -isystem %clang_tidy_headers
+// RUN:   -- -isystem %clang_tidy_headers -fexceptions
 #include <cstddef>
 #include <cstdint>
 #include <cstdio>
 // CHECK-FIXES: #include <print>
 #include <inttypes.h>
 #include <string.h>
 #include <string>
 
void printf_deceptive_newline() {
   // CHECK-MESSAGES: [[@LINE-1]]:3: warning: use 'std::print' instead of 'printf' [modernize-use-std-print]
   // CHECK-FIXES: std::print("Hello\\n");
 
   printf("Hello\x0a");
   // CHECK-MESSAGES: [[@LINE-1]]:3: warning: use 'std::println' instead of 'printf' [modernize-use-std-print]
   // CHECK-FIXES: std::println("Hello");
 }
 
+// std::print returns nothing, so any callers that use the return
+// value cannot be automatically translated.
+int printf_uses_return_value(int choice) {
+  const int i = printf("Return value assigned to variable %d\n", 42);
+
+  extern void accepts_int(int);
+  accepts_int(printf("Return value passed to function %d\n", 42));
+
+  if (choice == 0)
+    printf("if body %d\n", i);
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: use 'std::println' instead of 'printf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println("if body {}", i);
+  else if (choice == 1)
+    printf("else if body %d\n", i);
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: use 'std::println' instead of 'printf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println("else if body {}", i);
+  else
+    printf("else body %d\n", i);
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: use 'std::println' instead of 'printf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println("else body {}", i);
+
+  if (printf("Return value used as boolean in if statement"))
+    if (printf("Return value used in expression if statement") == 44)
+      if (const int j = printf("Return value used in assignment in if statement"))
+        if (const int k = printf("Return value used with initializer in if statement"); k == 44)
+          ;
+
+  int d = 0;
+  while (printf("%d", d) < 2)
+    ++d;
+
+  while (true)
+    printf("while body %d\n", i);
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: use 'std::println' instead of 'printf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println("while body {}", i);
+
+  do
+    printf("do body %d\n", i);
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: use 'std::println' instead of 'printf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println("do body {}", i);
+  while (true);
+
+  for (;;)
+    printf("for body %d\n", i);
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: use 'std::println' instead of 'printf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println("for body {}", i);
+
+  for (printf("for init statement %d\n", i);;)
+    // CHECK-MESSAGES: [[@LINE-1]]:8: warning: use 'std::println' instead of 'printf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println("for init statement {}", i);
+    ;;
+
+  for (int j = printf("for init statement %d\n", i);;)
+    ;;
+
+  for (; printf("for condition %d\n", i);)
+    ;;
+
+  for (;; printf("for expression %d\n", i))
+    // CHECK-MESSAGES: [[@LINE-1]]:11: warning: use 'std::println' instead of 'printf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println("for expression {}", i)
+    ;;
+
+  for (auto C : "foo")
+    printf("ranged-for body %d\n", i);
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: use 'std::println' instead of 'printf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println("ranged-for body {}", i);
+
+  switch (1) {
+  case 1:
+    printf("switch case body %d\n", i);
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: use 'std::println' instead of 'printf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println("switch case body {}", i);
+    break;
+  default:
+    printf("switch default body %d\n", i);
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: use 'std::println' instead of 'printf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println("switch default body {}", i);
+    break;
+  }
+
+  try {
+    printf("try body %d\n", i);
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: use 'std::println' instead of 'printf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println("try body {}", i);
+  } catch (int) {
+    printf("catch body %d\n", i);
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: use 'std::println' instead of 'printf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println("catch body {}", i);
+  }
+
+  (printf("Parenthesised expression %d\n", i));
+  // CHECK-MESSAGES: [[@LINE-1]]:4: warning: use 'std::println' instead of 'printf' [modernize-use-std-print]
+  // CHECK-FIXES: (std::println("Parenthesised expression {}", i));
+
+  // Ideally we would convert these two, but the current check doesn't cope with
+  // that.
+  (void)printf("cast to void %d\n", i);
+  // CHECK-MESSAGES-NOT: [[@LINE-1]]:9: warning: use 'std::println' instead of 'printf' [modernize-use-std-print]
+  // CHECK-FIXES-NOT: std::println("cast to void {}", i);
+
+  static_cast<void>(printf("static_cast to void %d\n", i));
+  // CHECK-MESSAGES-NOT: [[@LINE-1]]:9: warning: use 'std::println' instead of 'printf' [modernize-use-std-print]
+  // CHECK-FIXES-NOT: std::println("static cast to void {}", i);
+
+  const int x = ({ printf("GCC statement expression using return value immediately %d\n", i); });
+  const int y = ({ const int y = printf("GCC statement expression using return value immediately %d\n", i); y; });
+
+  // Ideally we would convert this one, but the current check doesn't cope with
+  // that.
+  ({ printf("GCC statement expression with unused result %d\n", i); });
+  // CHECK-MESSAGES-NOT: [[@LINE-1]]:6: warning: use 'std::println' instead of 'printf' [modernize-use-std-print]
+  // CHECK-FIXES-NOT: std::println("GCC statement expression with unused result {}", i);
+
+  return printf("Return value used in return\n");
+}
+
+int fprintf_uses_return_value(int choice) {
+  const int i = fprintf(stderr, "Return value assigned to variable %d\n", 42);
+
+  extern void accepts_int(int);
+  accepts_int(fprintf(stderr, "Return value passed to function %d\n", 42));
+
+  if (choice == 0)
+    fprintf(stderr, "if body %d\n", i);
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: use 'std::println' instead of 'fprintf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println(stderr, "if body {}", i);
+  else if (choice == 1)
+    fprintf(stderr, "else if body %d\n", i);
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: use 'std::println' instead of 'fprintf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println(stderr, "else if body {}", i);
+  else
+    fprintf(stderr, "else body %d\n", i);
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: use 'std::println' instead of 'fprintf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println(stderr, "else body {}", i);
+
+  if (fprintf(stderr, "Return value used as boolean in if statement"))
+    if (fprintf(stderr, "Return value used in expression if statement") == 44)
+      if (const int j = fprintf(stderr, "Return value used in assignment in if statement"))
+        if (const int k = fprintf(stderr, "Return value used with initializer in if statement"); k == 44)
+          ;
+
+  int d = 0;
+  while (fprintf(stderr, "%d", d) < 2)
+    ++d;
+
+  while (true)
+    fprintf(stderr, "while body %d\n", i);
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: use 'std::println' instead of 'fprintf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println(stderr, "while body {}", i);
+
+  do
+    fprintf(stderr, "do body %d\n", i);
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: use 'std::println' instead of 'fprintf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println(stderr, "do body {}", i);
+  while (true);
+
+  for (;;)
+    fprintf(stderr, "for body %d\n", i);
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: use 'std::println' instead of 'fprintf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println(stderr, "for body {}", i);
+
+  for (fprintf(stderr, "for init statement %d\n", i);;)
+    // CHECK-MESSAGES: [[@LINE-1]]:8: warning: use 'std::println' instead of 'fprintf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println(stderr, "for init statement {}", i);
+    ;;
+
+  for (int j = fprintf(stderr, "for init statement %d\n", i);;)
+    ;;
+
+  for (; fprintf(stderr, "for condition %d\n", i);)
+    ;;
+
+  for (;; fprintf(stderr, "for expression %d\n", i))
+    // CHECK-MESSAGES: [[@LINE-1]]:11: warning: use 'std::println' instead of 'fprintf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println(stderr, "for expression {}", i)
+    ;;
+
+  for (auto C : "foo")
+    fprintf(stderr, "ranged-for body %d\n", i);
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: use 'std::println' instead of 'fprintf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println(stderr, "ranged-for body {}", i);
+
+  switch (1) {
+  case 1:
+    fprintf(stderr, "switch case body %d\n", i);
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: use 'std::println' instead of 'fprintf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println(stderr, "switch case body {}", i);
+    break;
+  default:
+    fprintf(stderr, "switch default body %d\n", i);
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: use 'std::println' instead of 'fprintf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println(stderr, "switch default body {}", i);
+    break;
+  }
+
+  try {
+    fprintf(stderr, "try body %d\n", i);
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: use 'std::println' instead of 'fprintf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println(stderr, "try body {}", i);
+  } catch (int) {
+    fprintf(stderr, "catch body %d\n", i);
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: use 'std::println' instead of 'fprintf' [modernize-use-std-print]
+    // CHECK-FIXES: std::println(stderr, "catch body {}", i);
+  }
+
+
+  (printf("Parenthesised expression %d\n", i));
+  // CHECK-MESSAGES: [[@LINE-1]]:4: warning: use 'std::println' instead of 'printf' [modernize-use-std-print]
+  // CHECK-FIXES: (std::println("Parenthesised expression {}", i));
+
+  // Ideally we would convert these two, but the current check doesn't cope with
+  // that.
+  (void)fprintf(stderr, "cast to void %d\n", i);
+  // CHECK-MESSAGES-NOT: [[@LINE-1]]:9: warning: use 'std::println' instead of 'fprintf' [modernize-use-std-print]
+  // CHECK-FIXES-NOT: std::println(stderr, "cast to void {}", i);
+
+  static_cast<void>(fprintf(stderr, "static_cast to void %d\n", i));
+  // CHECK-MESSAGES-NOT: [[@LINE-1]]:9: warning: use 'std::println' instead of 'fprintf' [modernize-use-std-print]
+  // CHECK-FIXES-NOT: std::println(stderr, "static cast to void {}", i);
+
+  const int x = ({ fprintf(stderr, "GCC statement expression using return value immediately %d\n", i); });
+  const int y = ({ const int y = fprintf(stderr, "GCC statement expression using return value immediately %d\n", i); y; });
+
+  // Ideally we would convert this one, but the current check doesn't cope with
+  // that.
+  ({ fprintf(stderr, "GCC statement expression with unused result %d\n", i); });
+  // CHECK-MESSAGES-NOT: [[@LINE-1]]:6: warning: use 'std::println' instead of 'fprintf' [modernize-use-std-print]
+  // CHECK-FIXES-NOT: std::println("GCC statement expression with unused result {}", i);
+
+  return fprintf(stderr, "Return value used in return\n");
+}
+
 void fprintf_simple() {
   fprintf(stderr, "Hello");
   // CHECK-MESSAGES: [[@LINE-1]]:3: warning: use 'std::print' instead of 'fprintf' [modernize-use-std-print]
   // CHECK-FIXES: std::print(stderr, "Hello");
 }
 
 void std_printf_simple() {
   std::printf("std::Hello");