[clang-tidy] Add modernize-printf-to-std-print check

[mikecrowe]

Summary

Add FormatStringConverter utility class that is capable of converting
printf-style format strings into std::print-style format strings along
with recording a set of casts to wrap the arguments as required and
removing now-unnecessary calls to std::string::c_str() and
std::string::data()

Use FormatStringConverter to implement a new clang-tidy check that is
capable of converting calls to printf, fprintf, absl::PrintF,
absl::FPrintF, or any functions configured by an option to calls to
std::print and std::println, or other functions configured by options.

In other words, the check turns:

fprintf(stderr, "The %s is %3d\n", description.c_str(), value);

into:

std::println(stderr, "The {} is {:3}", description, value);

if it can.

std::print and std::println can do almost anything that standard printf
can, but the conversion has some some limitations that are described in
the documentation. If conversion is not possible then the call remains
unchanged.

Depends on D153716

[PiotrZSL]

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

28

NOTE: Consider using fully qualified names, like ::printf

45

TK_IgnoreUnlessSpelledInSource should be fine for this.

68

start warning with lower case, and maybe something like "use %0 instead of %1" (or whatever)

clang-tools-extra/clang-tidy/utils/FormatStringConverter.h

32–47

NOTE: Consider re-ordering private-public, like in other files, to first put public stuff, then private.

[Eugene.Zelenko]

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

66

Please don't use auto unless type is explicitly stated in same statement or iterator.

clang-tools-extra/clang-tidy/modernize/PrintfToStdPrintCheck.h

15

Should be elaborated or removed.

clang-tools-extra/docs/ReleaseNotes.rst

171

Please keep alphabetical order (by check name) in this section.

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

6

Please make first statement same as in Release Notes. Please highlight language constructs (like printf) with double back-ticks.

11

Please prepend with .. code-block:: c++ line. Same for other snippets.

73

Please add information about default value.

[mikecrowe]

Thanks for all the reviews.

In D149280#4301188, @njames93 wrote:

It may be a good idea to create unittests for the formatconverter in clang-tools-extra/unittests/clang-tidy/

I started there but had decided that the easiest and most reviewable form for the tests was in lit tests since the code that uses FormatStringConverter is so simple. (Particularly since I was hoping to persuade the inventor of std::format to review the tests too.) Are you proposing that I should duplicate (most of) the lit tests in the unit tests or migrate most of the lit tests to unit tests? Are there any existing tests that do similar things that I should model them on?

[mikecrowe]

Thank you for all the review comments.

clang-tools-extra/clang-tidy/utils/FormatStringConverter.cpp

322

Good spot. This was wider than I intended. The cast is only supposed to be used if the argument is a pointer to unsigned char or signed char.

I think that I probably ought to make sure that all the places that decide that conversion is not possible emit a warning explaining why.

412

Good spot. I'm sure I used the right cast in an earlier version... :(

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

73

The current implementation always "fixes" printf, fprintf, absl::PrintF and absl::FPrintf, even when this option is used (see UseStdPrintCheck constructor.) Should the option inhibit this default?

92

I shall investigate how to do that.

[Eugene.Zelenko]

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

73

It may be reasonable to provide possibility to override default.

[mikecrowe]

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

61

I think that's probably a good idea. The casts are ugly, and probably unnecessary in many cases. I've implemented it, but I'm currently wrestling with the lit tests for it.

73

I think it's likely that anyone using a custom value for either PrintfLikeFunctions or FPrintfLikeFunctions won't want the default function list for either.

[mikecrowe]

clang-tools-extra/test/clang-tidy/checkers/modernize/printf-to-std-print-convert.cpp

289

This requires a cast to unsigned char. It appears that Arg->getType()->isSignedIntegerType() inside the uArg case is returning false for signed char, which means that it doesn't get one. Strange!

[mikecrowe]

clang-tools-extra/test/clang-tidy/checkers/modernize/printf-to-std-print-convert.cpp

289

This requires a cast to unsigned char. It appears that Arg->getType()->isSignedIntegerType() inside the uArg case is returning false for signed char, which means that it doesn't get one. Strange!

Operator error. Apologies for the noise. :(

[mikecrowe]

I've addressed most of the review comments. The work that remains outstanding is:

• Emit warnings when conversion is not possible explaining why.

• Only add signed/unsigned casts when in StrictMode.

• Automatically remove now-unnecessary calls to c_str() in arguments rather than requiring readability-redundant-string-cstr check to be run afterwards.

[njames93]

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

20 ↗

(On Diff #518315)

This will need rebasing and changing to LangOpts.CPlusPlus23

clang-tools-extra/clang-tidy/utils/FormatStringConverter.cpp

409–414

Is it not nicer to just search for the compliment

clang-tools-extra/clang-tidy/utils/FormatStringConverter.h

58

Don't need to specify virtual here when the function is marked override

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

44–45 ↗

(On Diff #518315)

This should be relatively easy to address, just look at how other checks use the IncludeInserter to add includes.

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

124–126 ↗

(On Diff #518315)

It would be nice if the there was support for changing this to std::println("Integer {:d} from bool", b);

[mikecrowe]

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

124–126 ↗

(On Diff #518315)

Yes. That was item 2 on the plans for the future in my first comment. Would you prefer that everything is completed in this single commit, or would you be happy to the core functionality first with future enhancements in separate commits afterwards?

[mikecrowe]

Address many more review comments, including:

• Only add casts for signed/unsigned discrepancy if StrictMode option is set.
• Use IncludeInserter to add <print> or other required header.

Review comments still outstanding:

• Use println if format string ends in \n.
• Remove c_str() as part of the same check (I'm not really sure how to do this, are there any other checks that I should look at for inspiration?)
• Emit warnings to explain why if conversion is not possible.

[mikecrowe]

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

117 ↗

(On Diff #520439)

Is PrintFunction (and the soon-to-arrive PrintlnFunction) distinct enough from PrintfLikeFunctions and FprintfLikeFunctions? Should I use ReplacementPrintFunction instead?

[mikecrowe]

clang-tools-extra/clang-tidy/utils/FormatStringConverter.cpp

28

This apparently need to be Ty->getUnqualifiedDesugaredType() to ensure that arguments like std::string().c_str() are correctly treated as being of char type. Without, the dyn_cast<BuiltinType> fails.

[mikecrowe]

Implement review comments

I believe that I've now addressed all review comments. In particular:

• Use println if format string ends in \n, which required adding an extra replacement function configuration option.
• Remove c_str as part of the same check. I'm not really sure whether I've done this the right way, but it seems to work. I split some functionality out of the existing readability-redundant-string-cstr check in a separate change to support this. I needed to add an isRealChar AST matcher, which might be better somewhere else.
• Warnings are now emitted to explain why conversion is not possible.

In addition, I have also:

• Greatly improved turning signed integer types into their unsigned equivalents and vice-versa so that fixed-width integer types are now supported whether in the std namespace or not. This required adding dummy cstddef and cstdint headers.
• Added and fixed bugs in a few other test cases.

[mikecrowe]

Minor updates

• Use -std=c++23 rather than -std=c++2b in lit checks
• Enable check on C++23-and-later only if using std::println too
• Add comment in the style of add_new_check.py to UseStdPrintCheck
• Insert check in correct sorted location in docs/clang-tidy/checks/list.rst

[mikecrowe]

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

79 ↗

(On Diff #523531)

It turns out that absl::PrintF and absl::FPrintF work like std::format, fmt::printf, etc. and use the signedness of the argument rather than the signedness indicated in the format string to determine how to format the number. In other words:
unsigned int ui = 0xffffffff; absl::PrintF("%d\n", ui); yields 4294967295 (see https://godbolt.org/z/dYcbehxP9 ), so the casts that StrictMode adds would change the behaviour of the converted code.

I can think of several ways around this:

1. Update the documentation to explain this, recommending not to use StrictMode when converting Abseil functions.

2. Remove built-in support for Abseil functions from this check. Anyone wishing to convert them can do so via the customisation features, and can choose not to use StrictMode. (This could be documented here.)

3. Teach the code to recognise whether the arguments is being passed as a C-style variable argument list or as fully-typed arguments to a templated function and make StrictMode only add the casts for the former. (I've not investigated how feasible this is.)

4. Treat the known Abseil functions in this check differently by name and disable the casting behaviour. This means that conversion from fmt::printf via the customisation mechanism wouldn't automatically get that behaviour.

As someone who doesn't use Abseil I'm inclined towards option 2, with the possibility of implementing option 3 in a separate commit later. I'm not particularly keen on the other two options.

[mikecrowe]

Don't add casts when converting absl::PrintF and similar with StrictMode.

Remove extra space in release notes.

[mikecrowe]

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

79 ↗

(On Diff #523531)

It turns out that option 3 was easier to implement than I expected, so I've implemented it in the latest version.

[mikecrowe]

Rebase, stop including Optional.h which has been removed but wasn't
necessary anyway.

[PiotrZSL]

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

43–44 ↗

(On Diff #530386)

this code is already duplicated, move it to some separate private function, like isCpp23PrintConfigured or something...

56 ↗

(On Diff #530386)

Those TK_IgnoreUnlessSpelledInSource should be moved into getCheckTraversalKind()

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

33 ↗

(On Diff #530386)

missing store function, to properly export configuration via --export-config

40 ↗

(On Diff #530386)

I heard that using clang::tooling::HeaderIncludes is more recommended.
And this is just some house-made stuff

clang-tools-extra/clang-tidy/utils/FormatStringConverter.cpp

38–40

NOTE: no need fore else or {}

186

This may crash for wchar, maybe better limit StringLiteral to Ordinary and UTF8 or only Ordinary

190

magic number

203

this function should be split into smaller one.

231

general: no need for else after return

385–398

constant construction of those marchers may be costly.. can be cache them somehow in this object ?

419

maybe put that getType into some local variable, instead of constantly referencing it...

[mikecrowe]

Thanks for the comprehensive review.

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

43–44 ↗

(On Diff #530386)

You're correct that ReplacementPrintFunction == "std::print" || ReplacementPrintlnFunction == "std::println" is duplicated in isLanguageVersionSupported, but in that code we're considering which C++ version the functions require and in this code we're considering which header the functions require. These are not the same question. It just so happens that these checks are against the same function names now, but they need not be. If another function is added to <print> in C++26 and this code ends up being able to convert to it then the checks would need to diverge.

Nevertheless, I will do as you request if you still think it's worthwhile.

56 ↗

(On Diff #530386)

Ah, that was added since I wrote the original version of this check. I'll address this.

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

40 ↗

(On Diff #530386)

I'm afraid that I don't really understand this comment. The use of IncludeInserter is far more common in the existing checks than HeaderIncludes and from looking at IncludeCleaner.cpp the use of the latter is rather more complex. New features were being added to IncludeInserter within the last six months. I'm unsure what "house-made" means in the context of the IncludeInserter code that I didn't write.

Do you have anything more concrete than hearsay? If there is a plan to deprecate IncludeInserter then it feels like something closer to its convenient interface would need to be implemented in terms of HeaderIncludes for checks to use rather than them duplicating the code in IncludeCleaner.cpp.

If you can explain what you'd like me to do, and ideally provide pointers to similar things being done elsewhere then perhaps I can address this comment.

clang-tools-extra/clang-tidy/utils/FormatStringConverter.cpp

186

It doesn't look like there's any support for u8 literals in printf or std::print (yet), so I think just Ordinary is sufficient.

203

I agree. I'm surprised it hasn't come up in review earlier. I tried to do so prior to pushing the very first version of this for review and gave up since the parts ended up referring to so many local variables making the code even harder to understand than it is now. I will have another attempt.

231

In general, you're correct that I've used else after return in other places and I will fix them. However, in this case the else is required since the very first if block above doesn't have a return. (Hopefully this complexity will go away if I succeed in splitting this function up.)

385–398

Good idea. Do you have any pointers to code that does this? I couldn't find any.

The types involved all seem to be in the internal:: namespace and presumably subject to change. Ideally, I'd put:

std::optional<SomeSortOfMatcherType> StringCStrCallExprMatcher;

in the class and then populate it here the first time lazily. Unfortunately I have no idea what type to use for SomeSortOfMatcherType.

[mikecrowe]

Address a subset of the review comments

I've addressed some of PiotrZSL's review comments, so it seemed worth
'posting this update here, but I don't believe that this version
'needs reviewing until I receive responses to my questions and/or
'I've attempted to split the HandlePrintfSpecifier method.

[PiotrZSL]

Except readability issues with this check code (bunch of else, ..), and that I didn't took a deep dive into format string conversion (I hope that author is right there).
I would say that this check probably could be delivered. Would be nice to run it on some test projects, just to be sure that it wont crash or wont produce too much false-positives.
I still would expect that probably there can be some issues with it...

Next steps for this check would be:

• Fix some known (breaking) issues (like option naming)
• Deliver check to main
• Refactor code for performance / readability.
• Deliver code refactor.

Once on main branch, check can be tested by other users, and there is a chance that some issues with it could be found before branch-out.

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

117 ↗

(On Diff #532479)

Personally I would invert this, if (!...canApply()) { diag(PrintfCall->getBeginLoc(), "unable to use '%0' instead of %1 because %2") << ...; return; }

118 ↗

(On Diff #532479)

no need to assign this to Diag, it will be destroyed anyway, just call diag.

clang-tools-extra/clang-tidy/utils/FormatStringConverter.cpp

28

no need for anonymous namespace per LLVM codding standard, use static keyword for all functions, put them all into clang::tidy::utils namespace

147–149

do not put matchers into clang::ast_matchers to avoid ODR issues. put it into anonymous namespace under clang::tidy::utils

158–176

consider moving this into separate function that take Call and StrictMode as an argument this isn't readable. make function static.

385–398

clang::ast_matchers::StatementMatcher<CXXMemberCallExpr>, this is defined as using clang::ast_matchers::StatementMatcher = typedef internal::Matcher<Stmt>.
I would create it in class constructor as private member.

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

117 ↗

(On Diff #520439)

Use Replacement. It will be way better.

[mikecrowe]

clang-tools-extra/clang-tidy/utils/FormatStringConverter.cpp

203

It turns out that things are working out much better in my second attempt at splitting this function. I shall address the other new review comments before sending another revision for review though.

[mikecrowe]

I'm still working on the remaining items.

clang-tools-extra/clang-tidy/utils/FormatStringConverter.cpp

231

I've now reworked this function extensively, so there's no longer an else here.

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

117 ↗

(On Diff #520439)

I assume that you mean ReplacementPrintFunction. (I see ReplacementString used in other checks, so I think that just Replacement might be a bit vague.)

[PiotrZSL]

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

117 ↗

(On Diff #520439)

Yes, ... ReplacementPrintFunction

[mikecrowe]

clang-tools-extra/clang-tidy/utils/FormatStringConverter.cpp

385–398

Thanks for the pointer. It turns out that I need just clang::ast_matchers::StatementMatcher.

[mikecrowe]

Address review comments from PiotrZSL

• Name options ReplacementPrintFunction and ReplacementPrintlnFunction
• Use separate function not lambda in FormatStringConverter constructor
• Put isRealChar matcher outside clang::ast_matchers
• Remove anonymous namespace as suggested by PiotrZSL
• Split HandlePrintfSpecifier body into separate functions
• Make ArgKind a constant rather than calling Spec.getKind() every time
• Other simplifications, method renaming, comments and cleanups

[Eugene.Zelenko]

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

29 ↗

(On Diff #534221)

Please use single back-ticks for -Wformat (command-line option).

81 ↗

(On Diff #534221)

Please highlight true with back-ticks.

87 ↗

(On Diff #534221)

Please use single back-ticks for StrictMode (option).

103 ↗

(On Diff #534221)

Please highlight false and numbers with back-ticks.

112 ↗

(On Diff #534221)

Please use single back-ticks for FprintfLikeFunctions (option). Same for printf; absl::PrintF below.

122 ↗

(On Diff #534221)

Ditto.

144 ↗

(On Diff #534221)

Please use single back-ticks for ReplacementPrintFunction (option).

[mikecrowe]

@Eugene.Zelenko,
I will make the documentation changes you've suggested, but I can't say I really understand which document elements require single backticks and which require dual backticks. https://llvm.org/docs/SphinxQuickstartTemplate.html seems to imply that single backticks are only used for links and double backticks are used for monospace, but it's not completely clear. Most of the existing documentation seems to be consistent with what you've suggested though.

[mikecrowe]

Apply documentation backtick changes suggested by Eugene.Zelenko

[Eugene.Zelenko]

In D149280#4446591, @mikecrowe wrote:

@Eugene.Zelenko,
I will make the documentation changes you've suggested, but I can't say I really understand which document elements require single backticks and which require dual backticks. https://llvm.org/docs/SphinxQuickstartTemplate.html seems to imply that single backticks are only used for links and double backticks are used for monospace, but it's not completely clear. Most of the existing documentation seems to be consistent with what you've suggested though.

In short: double back-ticks are for language constructs. Single - for command-line options, options and their values.

[PiotrZSL]

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

37 ↗

(On Diff #534227)

those 2 looks in-depended. Cannot they be put as default value into Option config ?

70 ↗

(On Diff #534227)

call this function only if PrintfLikeFunctions is not empty.

78 ↗

(On Diff #534227)

call this function only if FprintfLikeFunctions is not empty

79 ↗

(On Diff #534227)

this could match also methods, maybe something unless(cxxMethodDecl()) ?

82 ↗

(On Diff #534227)

consider moving this stringLiteral to be first, consider adding something like unless(argumentCountIs(0)), unless(argumentCountIs(1))` at begining or create matcher that verify first that argument count is >= 2, so we could exlude most of callExpr at begining, even before we match functions

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

58 ↗

(On Diff #534227)

59 ↗

(On Diff #534227)

60 ↗

(On Diff #534227)

61 ↗

(On Diff #534227)

[mikecrowe]

Thanks for the further reviews.

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

37 ↗

(On Diff #534227)

My expectation was that if you didn't want to replace printf (and instead wanted to replace some other printf-like function) then you'd also not want to replace fprintf and vice-versa. In my head the two options do go together. If setting one didn't also remove the default for the other you'd end up having to specify PrintfLikeFunctions=my_printf, FPrintfLikeFunctions= just to replace a single function.

79 ↗

(On Diff #534227)

I would like to be able to match methods. The code I wrote this check to run on has classes that have methods that used to call std::fprintf, and currently call fmt::fprintf. I wish to convert those methods to use fmt::print and use this check to fix all their callers. Eventually I hope to be able to move to std::print.

However, the check doesn't currently seem to work for methods since the arguments are off-by-one and the replacement is incorrect too. I'll add the unless(cxxMethodDecl) checks for now and support can be added later.

82 ↗

(On Diff #534227)

I would have hoped that hasArgument would fail quite fast if the argument index passed is greater than the number of arguments. I will add argumentCountAtLeast and use it regardless though.

[mikecrowe]

Address further review comments from PiotrZSL

• Only add matchers if they are required.
• Check the number of arguments right at the start of the matcher using the new argumentCountAtLeast matcher added in D153716.
• Apply further documentation backtick changes.

[PiotrZSL]

Consider delivering this check. I do not think that it will become much better with more refactoring.

clang-tools-extra/clang-tidy/utils/FormatStringConverter.cpp

203–204

this check for isOrdinary could be done on matcher level, just add anonymous matcher, and use it there, you can still use it also here, but my idea is to reduce amount of calls to check method.

AST_MATCHER(StringLiteral, isOrdinary) {
  return Node.isOrdinary();
}

[mikecrowe]

Include isOrdinary in check as suggested by @PiotrZSL.

Thanks for all the reviews.

@PiotrZSL, if you think that this patch, and its dependency are ready
to land then please can you do so? I don't have permission to do so
myself.

[mikecrowe]

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

64 ↗

(On Diff #534354)

This is going to write the default value set in the constructor if ReplacementPrintFunction is std::print or ReplacementPrintlnFunction is std::println even if PrintHeader was not specified in the configuration. I don't know how much of a problem this is.

[thakis]

This breaks tests on windows: http://45.33.8.238/win/80283/step_8.txt

Please take a look and revert for now if it takes a while to fix.

[PiotrZSL]

@thakis Thank you.

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

9–15 ↗

(On Diff #534367)

Those includes need to be removed. We cannot use system includes, some dummy one can be used only.

[mikecrowe]

Add dummy <inttypes.h> header for tests

This header is hopefully correct for LP64 and P64, but I haven't tested it
on anything other than x86_64 Linux yet.

[mikecrowe]

In D149280#4447363, @thakis wrote:

This breaks tests on windows: http://45.33.8.238/win/80283/step_8.txt

Please take a look and revert for now if it takes a while to fix.

Thanks for letting me know, I thought I could get away with including <inttypes.h> from a test since it is a compiler header rather than a libc header.

I've added a potential fix, but I don't have a Windows machine (or many other targets) to test it on. Is there a way to get this change to run through the buildbots without landing it?

[mikecrowe]

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

9–15 ↗

(On Diff #534367)

I believe that <inttypes.h> is the only one that isn't present in test/clang-tidy/checkers/Inputs/Headers/. Hopefully adding it will have been sufficient.

[thakis]

None i know of, but given the bot's already red, you won't make it worse :)

Tests shouldn't include any headers generally, not even inttypes.h (unless the test tests that header).

[PiotrZSL]

clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/cstddef

12 ↗

(On Diff #534370)

We shouldn't include this stddef.h, it's being included from system headers.

[PiotrZSL]

Test is failing:
https://lab.llvm.org/buildbot/#/builders/230/builds/14939/steps/6/logs/FAIL__Clang_Tools__use-std-print_cpp
https://lab.llvm.org/buildbot/#/builders/245/builds/10266

[mikecrowe]

In D149280#4448158, @PiotrZSL wrote:

Test is failing:
https://lab.llvm.org/buildbot/#/builders/230/builds/14939/steps/6/logs/FAIL__Clang_Tools__use-std-print_cpp
https://lab.llvm.org/buildbot/#/builders/245/builds/10266

It looks like the char test is failing on targets where unadorned char is unsigned. I have access to two such machines, so I ought to be able to reproduce this myself (either on the up-to-date slow one, or the fast one that lacks a sufficiently-new cmake.)

@thakis, http://45.33.8.238/win/80313/summary.html makes it looks like Windows may be happy now, but I may be misinterpreting the results.

[mikecrowe]

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

169 ↗

(On Diff #534465)

This should have a cast to signed char if StrictMode=true. That cast is currently there by accident on targets where char is unsigned, but not on targets where char is signed. This is a real problem, but luckily one that's easy to fix.

[mikecrowe]

Fix tests on targets where char is unsigned

We need to cast chars to to signed char if we want to guarantee that
they are formatted as signed numbers on all targets.

Improve char formatting tests a little too.

[mikecrowe]

Add dummy stddef.h header

[mikecrowe]

Despite the fact that I've worked on what became this check for about two years, now that it's landed I've suddenly spotted a significant flaw: printf returns the number of characters printed, whereas std::print doesn't return anything. None of my test cases made use of the return value. I think this means that I need to only match on calls that don't make use of the return value. I shall try to do that.

[PiotrZSL]

In D149280#4450418, @mikecrowe wrote:

Despite the fact that I've worked on what became this check for about two years, now that it's landed I've suddenly spotted a significant flaw: printf returns the number of characters printed, whereas std::print doesn't return anything. None of my test cases made use of the return value. I think this means that I need to only match on calls that don't make use of the return value. I shall try to do that.

You can provide warning, but without fix. But that would need to be put into documentation.
If we lucky, and there will be no issues with current version, then you can put this in separate patch.
Anyway I do not think that many project use printf, most probably they use std::cout, fmt::format or some other custom wrapper around something.

clang-tools-extra/clang-tidy/modernize/CMakeLists.txt

add_clang_library(clangTidyModernizeModule
   LoopConvertCheck.cpp
   LoopConvertUtils.cpp
   MacroToEnumCheck.cpp
   MakeSharedCheck.cpp
   MakeSmartPtrCheck.cpp
   MakeUniqueCheck.cpp
   ModernizeTidyModule.cpp
   PassByValueCheck.cpp
+  PrintfToStdPrintCheck.cpp
   RawStringLiteralCheck.cpp
   RedundantVoidArgCheck.cpp
   ReplaceAutoPtrCheck.cpp
   ReplaceDisallowCopyAndAssignMacroCheck.cpp
   ReplaceRandomShuffleCheck.cpp
   ReturnBracedInitListCheck.cpp
   ShrinkToFitCheck.cpp
   TypeTraitsCheck.cpp

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

 #include "ConcatNestedNamespacesCheck.h"
 #include "DeprecatedHeadersCheck.h"
 #include "DeprecatedIosBaseAliasesCheck.h"
 #include "LoopConvertCheck.h"
 #include "MacroToEnumCheck.h"
 #include "MakeSharedCheck.h"
 #include "MakeUniqueCheck.h"
 #include "PassByValueCheck.h"
+#include "PrintfToStdPrintCheck.h"
 #include "RawStringLiteralCheck.h"
 #include "RedundantVoidArgCheck.h"
 #include "ReplaceAutoPtrCheck.h"
 #include "ReplaceDisallowCopyAndAssignMacroCheck.h"
 #include "ReplaceRandomShuffleCheck.h"
 #include "ReturnBracedInitListCheck.h"
 #include "ShrinkToFitCheck.h"
 #include "TypeTraitsCheck.h"
CheckFactories.registerCheck<DeprecatedHeadersCheck>(
         "modernize-deprecated-headers");
     CheckFactories.registerCheck<DeprecatedIosBaseAliasesCheck>(
         "modernize-deprecated-ios-base-aliases");
     CheckFactories.registerCheck<LoopConvertCheck>("modernize-loop-convert");
     CheckFactories.registerCheck<MacroToEnumCheck>("modernize-macro-to-enum");
     CheckFactories.registerCheck<MakeSharedCheck>("modernize-make-shared");
     CheckFactories.registerCheck<MakeUniqueCheck>("modernize-make-unique");
     CheckFactories.registerCheck<PassByValueCheck>("modernize-pass-by-value");
+    CheckFactories.registerCheck<PrintfToStdPrintCheck>(
+        "modernize-printf-to-std-print");
     CheckFactories.registerCheck<RawStringLiteralCheck>(
         "modernize-raw-string-literal");
     CheckFactories.registerCheck<RedundantVoidArgCheck>(
         "modernize-redundant-void-arg");
     CheckFactories.registerCheck<ReplaceAutoPtrCheck>(
         "modernize-replace-auto-ptr");
     CheckFactories.registerCheck<ReplaceDisallowCopyAndAssignMacroCheck>(
         "modernize-replace-disallow-copy-and-assign-macro");

clang-tools-extra/clang-tidy/modernize/PrintfToStdPrintCheck.h

+//===--- PrintfConvertCheck.h - clang-tidy-----------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FMT_PRINTFTOSTDPRINTCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FMT_PRINTFTOSTDPRINTCHECK_H
+
+#include "../ClangTidyCheck.h"
+
+namespace clang::tidy::modernize {
+/// Documentation goes here.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/fmt-to-std-print-check.html
+class PrintfToStdPrintCheck : public ClangTidyCheck {
+  std::vector<StringRef> PrintfLikeFunctions;
+  std::vector<StringRef> FprintfLikeFunctions;
+  StringRef ReplacementPrintFunction;
+
+public:
+  PrintfToStdPrintCheck(StringRef Name, ClangTidyContext *Context);
+  bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
+    if (ReplacementPrintFunction == "std::print")
+      return LangOpts.CPlusPlus2b;
+    return LangOpts.CPlusPlus;
+  }
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace clang::tidy::modernize
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FMT_PRINTFTOSTDPRINTCHECK_H

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

+//===--- PrintfToStdPrintCheck.cpp - clang-tidy------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "PrintfToStdPrintCheck.h"
+#include "../utils/FormatStringConverter.h"
+#include "../utils/Matchers.h"
+#include "../utils/OptionsUtils.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Lex/Lexer.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang::tidy::modernize {
+
+PrintfToStdPrintCheck::PrintfToStdPrintCheck(StringRef Name,
+                                             ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context),
+      PrintfLikeFunctions(utils::options::parseStringList(
+          Options.get("PrintfLikeFunctions", ""))),
+      FprintfLikeFunctions(utils::options::parseStringList(
+          Options.get("FprintfLikeFunctions", ""))),
+      ReplacementPrintFunction(Options.get("PrintFunction", "std::print")) {
+  PrintfLikeFunctions.push_back("printf");
+  PrintfLikeFunctions.push_back("absl::PrintF");
+  FprintfLikeFunctions.push_back("fprintf");
+  FprintfLikeFunctions.push_back("absl::FPrintF");
+}
+
+void PrintfToStdPrintCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(
+      traverse(TK_AsIs,
+               callExpr(callee(functionDecl(matchers::matchesAnyListedName(
+                                                PrintfLikeFunctions))
+                                   .bind("func_decl")),
+                        hasArgument(0, stringLiteral()))
+                   .bind("printf")),
+      this);
+
+  Finder->addMatcher(
+      traverse(TK_AsIs,
+               callExpr(callee(functionDecl(matchers::matchesAnyListedName(
+                                                FprintfLikeFunctions))
+                                   .bind("func_decl")),
+                        hasArgument(1, stringLiteral()))
+                   .bind("fprintf")),
+      this);
+}
+
+void PrintfToStdPrintCheck::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) {
+    Printf = Result.Nodes.getNodeAs<CallExpr>("fprintf");
+    FormatArgOffset = 1;
+  }
+
+  utils::FormatStringConverter Converter(Result.Context, Printf,
+                                         FormatArgOffset, getLangOpts());
+  if (Converter.canApply()) {
+    const auto *PrintfCall = Printf->getCallee();
+    DiagnosticBuilder Diag =
+        diag(PrintfCall->getBeginLoc(), "Replace %0 with '%1'")
+        << OldFunction->getIdentifier() << ReplacementPrintFunction;
+
+    Diag << FixItHint::CreateReplacement(
+        CharSourceRange::getTokenRange(PrintfCall->getBeginLoc(),
+                                       PrintfCall->getEndLoc()),
+        ReplacementPrintFunction);
+    Converter.applyFixes(Diag, *Result.SourceManager);
+  }
+}
+
+} // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/utils/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   FrontendOpenMP
   Support
   )
 
 add_clang_library(clangTidyUtils
   Aliasing.cpp
   ASTUtils.cpp
   DeclRefExprUtils.cpp
   ExceptionAnalyzer.cpp
   ExceptionSpecAnalyzer.cpp
   ExprSequence.cpp
   FileExtensionsUtils.cpp
+  FormatStringConverter.cpp
   FixItHintUtils.cpp
   HeaderGuard.cpp
   IncludeInserter.cpp
   IncludeSorter.cpp
   LexerUtils.cpp
   NamespaceAliaser.cpp
   OptionsUtils.cpp
   RenamerClangTidyCheck.cpp

clang-tools-extra/clang-tidy/utils/FormatStringConverter.h

+//===--- FormatStringConverter.h - clang-tidy--------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// Declaration of the FormatStringConverter class which is used to convert
+/// printf format strings to C++ std::formatter format strings.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_FORMATSTRINGCONVERTER_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_FORMATSTRINGCONVERTER_H
+
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/FormatString.h"
+#include "llvm/ADT/Optional.h"
+#include <string>
+
+namespace clang::tidy::utils {
+
+/// Convert a printf-style format string to a std::formatter-style one, and
+/// prepare any casts that are required to wrap the arguments to retain printf
+/// compatibility. This class is expecting to work on the already-cooked format
+/// string (i.e. all the escapes have been converted) so we have to convert them
+/// back. This means that we might not convert them back using the same form.
+class FormatStringConverter
+    : public clang::analyze_format_string::FormatStringHandler {
+  const ASTContext *Context;
+  bool ConversionPossible = true;
+  bool FormatStringNeededRewriting = false;
+  size_t PrintfFormatStringPos = 0U;
+  StringRef PrintfFormatString;
+
+  const Expr *const *Args;
+  const unsigned NumArgs;
+  unsigned ArgsOffset;
+  const LangOptions &LangOpts;
+
+  const StringLiteral *FormatExpr;
+  std::string StandardFormatString;
+
+  /// Casts to be used to wrap arguments to retain printf compatibility.
+  std::vector<std::tuple<const Expr *, std::string>> ArgFixes;
+
+  virtual bool HandlePrintfSpecifier(const analyze_printf::PrintfSpecifier &FS,
+                                     const char *startSpecifier,
+                                     unsigned specifierLen,
+                                     const TargetInfo &Target) override;
+  void appendFormatText(StringRef Text);
+  void finalizeFormatText();
+
+public:
+  FormatStringConverter(const ASTContext *Context, const CallExpr *Call,
+                        unsigned FormatArgOffset, const LangOptions &LO);
+
+  bool canApply() const { return ConversionPossible; }
+  void applyFixes(DiagnosticBuilder &Diag, SourceManager &SM);
+};
+
+} // namespace clang::tidy::utils
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_FORMATSTRINGCONVERTER_H

clang-tools-extra/clang-tidy/utils/FormatStringConverter.cpp

+//===--- FormatStringConverter.cpp - clang-tidy----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// Implementation of the FormatStringConverter class which is used to convert
+/// printf format strings to C++ std::formatter format strings.
+///
+//===----------------------------------------------------------------------===//
+
+#include "FormatStringConverter.h"
+#include "clang/AST/Expr.h"
+#include "clang/Basic/LangOptions.h"
+#include "clang/Lex/Lexer.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/Debug.h"
+
+namespace {
+/// Is the passed type the actual "char" type, whether that be signed or
+/// unsigned, rather than explicit signed char or unsigned char types.
+bool isRealCharType(const clang::QualType &Ty) {
+  using namespace clang;
+  if (const auto *BT = llvm::dyn_cast<BuiltinType>(Ty)) {
+    const bool result = (BT->getKind() == BuiltinType::Char_U ||
+                         BT->getKind() == BuiltinType::Char_S);
+    return result;
+  } else {
+    return false;
+  }
+}
+
+/// If possible, return the text name of the signed type that corresponds to the
+/// passed integer type. If the passed type is already signed then its name is
+/// just returned. Only supports BuiltinTypes.
+std::optional<llvm::StringRef>
+getCorrespondingSignedTypeName(const clang::QualType &QT) {
+  using namespace clang;
+  if (const auto *BT = llvm::dyn_cast<BuiltinType>(QT)) {
+    switch (BT->getKind()) {
+    case BuiltinType::UChar:
+    case BuiltinType::Char_U:
+    case BuiltinType::SChar:
+    case BuiltinType::Char_S:
+      return "signed char";
+    case BuiltinType::UShort:
+    case BuiltinType::Short:
+      return "short";
+    case BuiltinType::UInt:
+    case BuiltinType::Int:
+      return "int";
+    case BuiltinType::ULong:
+    case BuiltinType::Long:
+      return "long";
+    case BuiltinType::ULongLong:
+    case BuiltinType::LongLong:
+      return "long long";
+    default:
+      llvm::dbgs() << "Unknown corresponding signed type for BuiltinType '"
+                   << QT.getAsString() << "'\n";
+      return std::nullopt;
+    }
+  } else {
+    llvm::dbgs() << "Unknown corresponding signed type for non-BuiltinType '"
+                 << QT.getAsString() << "'\n";
+    return std::nullopt;
+  }
+}
+
+/// If possible, return the text name of the unsigned type that corresponds to
+/// the passed integer type. If the passed type is already unsigned then its
+/// name is just returned. Only supports BuiltinTypes.
+std::optional<llvm::StringRef>
+getCorrespondingUnsignedTypeName(const clang::QualType &QT) {
+  using namespace clang;
+  if (const auto *BT = llvm::dyn_cast<BuiltinType>(QT)) {
+    switch (BT->getKind()) {
+    case BuiltinType::SChar:
+    case BuiltinType::Char_S:
+    case BuiltinType::UChar:
+    case BuiltinType::Char_U:
+      return "unsigned char";
+    case BuiltinType::Short:
+    case BuiltinType::UShort:
+      return "unsigned short";
+    case BuiltinType::Int:
+    case BuiltinType::UInt:
+      return "unsigned int";
+    case BuiltinType::Long:
+    case BuiltinType::ULong:
+      return "unsigned long";
+    case BuiltinType::LongLong:
+    case BuiltinType::ULongLong:
+      return "unsigned long long";
+    default:
+      llvm::dbgs() << "Unknown corresponding unsigned type for BuiltinType '"
+                   << QT.getAsString() << "'\n";
+      return std::nullopt;
+    }
+  } else {
+    llvm::dbgs() << "Unknown corresponding unsigned type for non-BuiltinType '"
+                 << QT.getAsString() << "'\n";
+    return std::nullopt;
+  }
+}
+} // namespace
+
+namespace clang::tidy::utils {
+
+FormatStringConverter::FormatStringConverter(const ASTContext *ContextIn,
+                                             const CallExpr *Call,
+                                             unsigned FormatArgOffset,
+                                             const LangOptions &LO)
+    : Context(ContextIn), Args(Call->getArgs()), NumArgs(Call->getNumArgs()),
+      ArgsOffset(FormatArgOffset + 1), LangOpts(LO) {
+  assert(ArgsOffset <= NumArgs);
+  FormatExpr = llvm::dyn_cast<StringLiteral>(
+      Args[FormatArgOffset]->IgnoreImplicitAsWritten());
+  assert(FormatExpr);
+  PrintfFormatString = FormatExpr->getString();
+
+  // Assume that the output will be approximately the same size as the input,
+  // but perhaps with a few escapes expanded.
+  StandardFormatString.reserve(PrintfFormatString.size() + 8);
+  StandardFormatString.push_back('\"');
+
+  const bool IsFreeBsdkPrintf = false;
+
+  using clang::analyze_format_string::ParsePrintfString;
+  ParsePrintfString(*this, PrintfFormatString.data(),
+                    PrintfFormatString.data() + PrintfFormatString.size(),
+                    LangOpts, Context->getTargetInfo(), IsFreeBsdkPrintf);
+}
+
+/// Called for each format specifier by ParsePrintfString.
+bool FormatStringConverter::HandlePrintfSpecifier(
+    const analyze_printf::PrintfSpecifier &FS, const char *StartSpecifier,
+    unsigned SpecifierLen, const TargetInfo &Target) {
+  using namespace analyze_printf;
+
+  const size_t StartSpecifierPos = StartSpecifier - PrintfFormatString.data();
+  assert(StartSpecifierPos + SpecifierLen <= PrintfFormatString.size());
+
+  // Everything before the specifier needs copying verbatim
+  assert(StartSpecifierPos >= PrintfFormatStringPos);
+
+  appendFormatText(StringRef(PrintfFormatString.begin() + PrintfFormatStringPos,
+                             StartSpecifierPos - PrintfFormatStringPos));
+
+  using analyze_format_string::ConversionSpecifier;
+  const ConversionSpecifier Spec = FS.getConversionSpecifier();
+
+  if (Spec.getKind() == ConversionSpecifier::PercentArg)
+    StandardFormatString.push_back('%');
+  else if (Spec.getKind() == ConversionSpecifier::Kind::nArg) {
+    // std::format doesn't do the equivalent of %n
+    ConversionPossible = false;
+    return false;
+  } else if (Spec.getKind() == ConversionSpecifier::Kind::PrintErrno) {
+    // std::format doesn't support %m. In theory we could insert a
+    // strerror(errno) parameter (assuming that libc has a thread-safe
+    // implementation, which glibc does), but that would require keeping track
+    // of the input and output parameter indices for position arguments too.
+    ConversionPossible = false;
+    return false;
+  } else {
+    StandardFormatString.push_back('{');
+
+    if (FS.usesPositionalArg()) {
+      // std::format argument identifiers are zero-based, whereas printf ones
+      // are one based.
+      assert(FS.getPositionalArgIndex() > 0U);
+      StandardFormatString.append(llvm::utostr(FS.getPositionalArgIndex() - 1));
+    }
+
+    // std::format format argument:
+    // [[fill]align][sign]["#"]["0"][width]["."precision][type]
+    std::string FormatSpec;
+
+    // printf doesn't support specifying the fill character - it's always a
+    // space, so we never need to generate one.
+
+    // Convert alignment
+    {
+      // We only care about alignment if a field width is specified
+      if (FS.getFieldWidth().getHowSpecified() !=
+          OptionalAmount::NotSpecified) {
+        const ConversionSpecifier Spec = FS.getConversionSpecifier();
+        if (Spec.getKind() == ConversionSpecifier::sArg) {
+          // Strings are left-aligned by default with std::format, so we only
+          // need to emit an alignment if this one needs to be right aligned.
+          if (!FS.isLeftJustified())
+            FormatSpec.push_back('>');
+        } else {
+          // Numbers are right-aligned by default with std::format, so we only
+          // need to emit an alignment if this one needs to be left aligned.
+          if (FS.isLeftJustified())
+            FormatSpec.push_back('<');
+        }
+      }
+    }
+
+    // Convert sign
+    {
+      const ConversionSpecifier Spec = FS.getConversionSpecifier();
+      // Ignore on something that isn't numeric. For printf it's would be a
+      // compile-time warning but ignored at runtime, but for std::format it
+      // ought to be a compile-time error.
+      if (Spec.isAnyIntArg() || Spec.isDoubleArg()) {
+        // + is preferred to ' '
+        if (FS.hasPlusPrefix())
+          FormatSpec.push_back('+');
+        else if (FS.hasSpacePrefix())
+          FormatSpec.push_back(' ');
+      }
+    }
+
+    // Convert alternative form
+    if (FS.hasAlternativeForm()) {
+      switch (Spec.getKind()) {
+      case ConversionSpecifier::Kind::aArg:
+      case ConversionSpecifier::Kind::AArg:
+      case ConversionSpecifier::Kind::eArg:
+      case ConversionSpecifier::Kind::EArg:
+      case ConversionSpecifier::Kind::fArg:
+      case ConversionSpecifier::Kind::FArg:
+      case ConversionSpecifier::Kind::gArg:
+      case ConversionSpecifier::Kind::GArg:
+      case ConversionSpecifier::Kind::xArg:
+      case ConversionSpecifier::Kind::XArg:
+      case ConversionSpecifier::Kind::oArg:
+        FormatSpec.push_back('#');
+        break;
+      default:
+        // Alternative forms don't exist for other argument kinds
+        break;
+      }
+    }
+
+    // Convert leading zero
+    if (FS.hasLeadingZeros())
+      FormatSpec.push_back('0');
+
+    // Convert field width
+    {
+      const OptionalAmount FieldWidth = FS.getFieldWidth();
+      switch (FieldWidth.getHowSpecified()) {
+      case OptionalAmount::NotSpecified:
+        break;
+      case OptionalAmount::Constant:
+        FormatSpec.append(llvm::utostr(FieldWidth.getConstantAmount()));
+        break;
+      case OptionalAmount::Arg:
+        FormatSpec.push_back('{');
+        if (FieldWidth.usesPositionalArg()) {
+          // std::format argument identifiers are zero-based, whereas printf
+          // ones are one based.
+          assert(FieldWidth.getPositionalArgIndex() > 0U);
+          FormatSpec.append(
+              llvm::utostr(FieldWidth.getPositionalArgIndex() - 1));
+        }
+        FormatSpec.push_back('}');
+        break;
+      case OptionalAmount::Invalid:
+        break;
+      }
+    }
+
+    // Convert precision
+    {
+      const OptionalAmount FieldPrecision = FS.getPrecision();
+      switch (FieldPrecision.getHowSpecified()) {
+      case OptionalAmount::NotSpecified:
+        break;
+      case OptionalAmount::Constant:
+        FormatSpec.push_back('.');
+        FormatSpec.append(llvm::utostr(FieldPrecision.getConstantAmount()));
+        break;
+      case OptionalAmount::Arg:
+        FormatSpec.push_back('.');
+        FormatSpec.push_back('{');
+        if (FieldPrecision.usesPositionalArg()) {
+          // std::format argument identifiers are zero-based, whereas printf
+          // ones are one based.
+          assert(FieldPrecision.getPositionalArgIndex() > 0U);
+          FormatSpec.append(
+              llvm::utostr(FieldPrecision.getPositionalArgIndex() - 1));
+        }
+        FormatSpec.push_back('}');
+        break;
+      case OptionalAmount::Invalid:
+        break;
+      }
+    }
+
+    // Convert type
+    {
+      if (FS.getArgIndex() + ArgsOffset >= NumArgs) {
+        // Argument index out of range. Give up.
+        ConversionPossible = false;
+        return false;
+      }
+
+      // If we've got this far, then the specifier must have an associated
+      // argument
+      assert(FS.consumesDataArgument());
+
+      const Expr *Arg =
+          Args[FS.getArgIndex() + ArgsOffset]->IgnoreImplicitAsWritten();
+      using analyze_format_string::ConversionSpecifier;
+      const ConversionSpecifier Spec = FS.getConversionSpecifier();
+      switch (Spec.getKind()) {
+      case ConversionSpecifier::Kind::sArg:
+        if (Arg->getType()->isPointerType()) {
+          const auto Pointee = Arg->getType()->getPointeeType();
+          // If the type is not char then std::format can't handle it without
+          // needing a cast
+          if (!isRealCharType(Pointee))
+            ArgFixes.emplace_back(Arg, "reinterpret_cast<const char *>(");
+        }
+        // Strings never need to have their type specified.
+        break;
+      case ConversionSpecifier::Kind::cArg:
+        // The type must be "c" to get a character unless the type is exactly
+        // char (whether that be signed or unsigned for the target.)
+        if (!isRealCharType(Arg->getType()))
+          FormatSpec.push_back('c');
+        break;
+      case ConversionSpecifier::Kind::dArg:
+      case ConversionSpecifier::Kind::iArg:
+        if (Arg->getType()->isBooleanType()) {
+          // std::format will print bool as either "true" or "false" by default,
+          // but printf prints them as "0" or "1". Ber compatible with printf by
+          // requesting decimal output.
+          FormatSpec.push_back('d');
+        } else if (Arg->getType()->isEnumeralType()) {
+          // std::format will try to find a specialization to print the enum
+          // (and probably fail), whereas printf would have just expected it to
+          // be passed as its underlying type. However, printf will have forced
+          // the signedness based on the format string, so we need to do the
+          // same.
+          if (const auto *ET = Arg->getType()->getAs<EnumType>()) {
+            if (const auto MaybeSignedTypeName = getCorrespondingSignedTypeName(
+                    ET->getDecl()->getIntegerType()))
+              ArgFixes.emplace_back(
+                  Arg,
+                  (Twine("static_cast<") + *MaybeSignedTypeName + ">(").str());
+            else
+              ConversionPossible = false;
+          }
+        } else if (Arg->getType()->isUnsignedIntegerType()) {
+          // printf will happily print an unsigned type as signed if told to.
+          // Even -Wformat doesn't warn for this. std::format will format as
+          // unsigned unless we cast it.
+          if (const auto MaybeSignedTypeName =
+                  getCorrespondingSignedTypeName(Arg->getType()))
+            ArgFixes.emplace_back(
+                Arg,
+                (Twine("static_cast<") + *MaybeSignedTypeName + ">(").str());
+          else
+            ConversionPossible = false;
+        } else if (isRealCharType(Arg->getType()) ||
+                   !Arg->getType()->isIntegerType()) {
+          // Only specify integer if the argument is of a different type
+          FormatSpec.push_back('d');
+        }
+        break;
+      case ConversionSpecifier::Kind::uArg:
+        if (Arg->getType()->isEnumeralType()) {
+          // std::format will try to find a specialization to print the enum
+          // (and probably fail), whereas printf would have just expected it to
+          // be passed as its underlying type. However, printf will have forced
+          // the signedness based on the format string, so we need to do the
+          // same.
+          if (const auto *ET = Arg->getType()->getAs<EnumType>()) {
+            if (const auto MaybeUnsignedTypeName =
+                    getCorrespondingUnsignedTypeName(
+                        ET->getDecl()->getIntegerType()))
+              ArgFixes.emplace_back(
+                  Arg, (Twine("static_cast<") + *MaybeUnsignedTypeName + ">(")
+                           .str());
+            else
+              ConversionPossible = false;
+          }
+        } else if (Arg->getType()->isSignedIntegerType()) {
+          // printf will happily print an signed type as unsigned if told to.
+          // Even -Wformat doesn't warn for this. std::format will format as
+          // signed unless we cast it.
+          if (const auto MaybeUnsignedTypeName =
+                  getCorrespondingUnsignedTypeName(Arg->getType()))
+            ArgFixes.emplace_back(
+                Arg,
+                (Twine("static_cast<") + *MaybeUnsignedTypeName + ">(").str());
+          else
+            ConversionPossible = false;
+        } else if (isRealCharType(Arg->getType()) ||
+                   Arg->getType()->isBooleanType() ||
+                   !Arg->getType()->isIntegerType()) {
+          // Only specify integer if the argument is of a different type
+          FormatSpec.push_back('d');
+        }
+        break;
+      case ConversionSpecifier::Kind::pArg:
+        if (Arg->getType()->isNullPtrType())
+          ; // std::format knows how to format nullptr
+        else if (Arg->getType()->isVoidPointerType())
+          ; // std::format knows how to format void pointers
+        else
+          ArgFixes.emplace_back(Arg, "reinterpret_cast<const void *>(");
+        break;
+      case ConversionSpecifier::Kind::xArg:
+        FormatSpec.push_back('x');
+        break;
+      case ConversionSpecifier::Kind::XArg:
+        FormatSpec.push_back('X');
+        break;
+      case ConversionSpecifier::Kind::oArg:
+        FormatSpec.push_back('o');
+        break;
+      case ConversionSpecifier::Kind::aArg:
+        FormatSpec.push_back('a');
+        break;
+      case ConversionSpecifier::Kind::AArg:
+        FormatSpec.push_back('A');
+        break;
+      case ConversionSpecifier::Kind::eArg:
+        FormatSpec.push_back('e');
+        break;
+      case ConversionSpecifier::Kind::EArg:
+        FormatSpec.push_back('E');
+        break;
+      case ConversionSpecifier::Kind::fArg:
+        FormatSpec.push_back('f');
+        break;
+      case ConversionSpecifier::Kind::FArg:
+        FormatSpec.push_back('F');
+        break;
+      case ConversionSpecifier::Kind::gArg:
+        FormatSpec.push_back('g');
+        break;
+      case ConversionSpecifier::Kind::GArg:
+        FormatSpec.push_back('G');
+        break;
+      default:
+        // Something we don't understand
+        ConversionPossible = false;
+        return false;
+      }
+    }
+
+    if (!FormatSpec.empty()) {
+      StandardFormatString.push_back(':');
+      StandardFormatString.append(FormatSpec);
+    }
+
+    StandardFormatString.push_back('}');
+  }
+
+  // Skip over specifier
+  PrintfFormatStringPos = StartSpecifierPos + SpecifierLen;
+  assert(PrintfFormatStringPos <= PrintfFormatString.size());
+
+  FormatStringNeededRewriting = true;
+  return true;
+}
+
+/// Called at the very end just before applying fixes to capture the last part
+/// of the format string.
+void FormatStringConverter::finalizeFormatText() {
+  appendFormatText(
+      StringRef(PrintfFormatString.begin() + PrintfFormatStringPos,
+                PrintfFormatString.size() - PrintfFormatStringPos));
+  PrintfFormatStringPos = PrintfFormatString.size();
+
+  StandardFormatString.push_back('\"');
+}
+
+/// Append literal parts of the format text, reinstating escapes as required.
+void FormatStringConverter::appendFormatText(const StringRef Text) {
+  for (const char Ch : Text) {
+    if (Ch == '\a')
+      StandardFormatString += "\\a";
+    else if (Ch == '\b')
+      StandardFormatString += "\\b";
+    else if (Ch == '\f')
+      StandardFormatString += "\\f";
+    else if (Ch == '\n')
+      StandardFormatString += "\\n";
+    else if (Ch == '\r')
+      StandardFormatString += "\\r";
+    else if (Ch == '\t')
+      StandardFormatString += "\\t";
+    else if (Ch == '\v')
+      StandardFormatString += "\\v";
+    else if (Ch == '\"')
+      StandardFormatString += "\\\"";
+    else if (Ch == '\\')
+      StandardFormatString += "\\\\";
+    else if (Ch == '{') {
+      StandardFormatString += "{{";
+      FormatStringNeededRewriting = true;
+    } else if (Ch == '}') {
+      StandardFormatString += "}}";
+      FormatStringNeededRewriting = true;
+    } else if (Ch < 32) {
+      StandardFormatString += "\\x";
+      StandardFormatString += llvm::hexdigit(Ch >> 4, true);
+      StandardFormatString += llvm::hexdigit(Ch & 0xf, true);
+    } else
+      StandardFormatString += Ch;
+  }
+}
+
+/// Called by the check when it is ready to apply the fixes.
+void FormatStringConverter::applyFixes(DiagnosticBuilder &Diag,
+                                       SourceManager &SM) {
+  finalizeFormatText();
+  if (FormatStringNeededRewriting) {
+    Diag << FixItHint::CreateReplacement(
+        CharSourceRange::getTokenRange(FormatExpr->getBeginLoc(),
+                                       FormatExpr->getEndLoc()),
+        StandardFormatString);
+  }
+  for (const auto [Arg, Replacement] : ArgFixes) {
+    SourceLocation AfterOtherSide =
+        Lexer::findNextToken(Arg->getEndLoc(), SM, LangOpts)->getLocation();
+
+    Diag << FixItHint::CreateInsertion(Arg->getBeginLoc(), Replacement)
+         << FixItHint::CreateInsertion(AfterOtherSide, ")");
+  }
+}
+} // namespace clang::tidy::utils

clang-tools-extra/docs/ReleaseNotes.rst

- New :doc:`readability-avoid-unconditional-preprocessor-if
   ``#if 1``, etc.
 
 - New :doc:`readability-operators-representation
   <clang-tidy/checks/readability/operators-representation>` check.
 
   Enforces consistent token representation for invoked binary, unary and
   overloaded operators in C++ code.
 
+- New :doc: `modernize-printf-to-std-print
+  <clang-tidy/checks/modernize/printf-to-std-print>` check.
+
+  Converts calls to ``printf``, ``fprintf``, ``absl::PrintF``,
+  ``absl::FPrintf`` or other functions via a configuration option, to
+  equivalent calls to C++23's ``std::print`` or another function via a
+  configuration option, modifying the format string appropriately.
+
 New check aliases
 ^^^^^^^^^^^^^^^^^
 
 - New alias :doc:`cert-msc24-c
   <clang-tidy/checks/cert/msc24-c>` to :doc:`bugprone-unsafe-functions
   <clang-tidy/checks/bugprone/unsafe-functions>` was added.
 
 - New alias :doc:`cert-msc33-c

clang-tools-extra/docs/clang-tidy/checks/list.rst

.. csv-table::
    `modernize-concat-nested-namespaces <modernize/concat-nested-namespaces.html>`_, "Yes"
    `modernize-deprecated-headers <modernize/deprecated-headers.html>`_, "Yes"
    `modernize-deprecated-ios-base-aliases <modernize/deprecated-ios-base-aliases.html>`_, "Yes"
    `modernize-loop-convert <modernize/loop-convert.html>`_, "Yes"
    `modernize-macro-to-enum <modernize/macro-to-enum.html>`_, "Yes"
    `modernize-make-shared <modernize/make-shared.html>`_, "Yes"
    `modernize-make-unique <modernize/make-unique.html>`_, "Yes"
    `modernize-pass-by-value <modernize/pass-by-value.html>`_, "Yes"
+   `modernize-printf-to-std-print <modernize/printf-to-std-print>`_, "Yes"
    `modernize-raw-string-literal <modernize/raw-string-literal.html>`_, "Yes"
    `modernize-redundant-void-arg <modernize/redundant-void-arg.html>`_, "Yes"
    `modernize-replace-auto-ptr <modernize/replace-auto-ptr.html>`_, "Yes"
    `modernize-replace-disallow-copy-and-assign-macro <modernize/replace-disallow-copy-and-assign-macro.html>`_, "Yes"
    `modernize-replace-random-shuffle <modernize/replace-random-shuffle.html>`_, "Yes"
    `modernize-return-braced-init-list <modernize/return-braced-init-list.html>`_, "Yes"
    `modernize-shrink-to-fit <modernize/shrink-to-fit.html>`_, "Yes"
    `modernize-type-traits <modernize/type-traits.html>`_, "Yes"

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

+.. title:: clang-tidy - modernize-printf-to-std-print
+
+modernize-printf-to-std-print
+=============================
+
+This check is capable of converting calls to printf to calls to std::print
+whilst also modifying the format string appropriately.
+
+In other words, it turns lines like::
+
+ fprintf(stderr, "The %s is %3d\n", answer, value);
+
+into::
+
+ std::print(stderr, "The {} is {:3}\n", answer, value);
+
+and works for ``printf``, ``fprintf``, ``absl::PrintF``, ``absl::FPrintf``
+and any functions specified via the ``PrintfLikeFunctions`` and
+``FprintfLikeFunctions`` options.
+
+It doesn't do a bad job, but it's not perfect. In particular:
+
+- It assumes that the input is mostly sane. If you get any warnings when
+  compiling with ``-Wformat`` then misbehaviour is possible.
+
+- At the point that the check runs, the AST contains a single
+  ``StringLiteral`` for the format string and any macro expansion, token
+  pasting, adjacent string literal concatenation and escaping has been
+  handled. Although it's possible for the check to automatically put the
+  escapes back, they may not be exactly as they were written (e.g.
+  ``"\x0a"`` will become ``"\n"`` and ``"ab" "cd"`` will become
+  ``"abcd"``.) This is helpful since it means that the PRIx macros from
+  ``<inttypes.h>`` are removed correctly.
+
+- It supports field widths, precision, positional arguments, leading zeros,
+  leading +, alignment and alternative forms.
+
+- It is assumed that the ``<print>`` (or other appropriate) header has
+  already been included. No attempt is made to include it.
+
+- Use of any unsupported flags or specifiers will cause the entire
+  statement to be left alone. Particular unsupported features are:
+
+  - The ``%`` flag for thousands separators.
+
+  - The glibc extension ``%m``.
+
+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
+  ``PrintFunction`` option.
+- the format string is rewritten to use the ``std::formatter`` language.
+- any arguments that corresponded to ``%p`` specifiers that std::formatter
+  wouldn't accept are wrapped in a ``reinterpret_cast`` to ``const void *``.
+- any arguments where the format string and the parameter differ in
+  signedness will be wrapped in an approprate ``static_cast``. For example,
+  given ``int i = 42``, then ``printf("%u\n", i)`` will become
+  ``std::printf("{}\n", static_cast<unsigned int>(i))``.
+
+Options
+-------
+
+.. option:: PrintfLikeFunctions
+
+   A semicolon-separated list of (fully qualified) function/method/operator
+   names, with the requirement that the first parameter contains the
+   printf-style format string and the arguments to be formatted follow
+   immediately afterwards.
+
+.. option:: FprintfLikeFunctions
+
+   A semicolon-separated list of (fully qualified) function/method/operator
+   names, with the requirement that the first parameter is retained, the
+   second parameter contains the printf-style format string and the
+   arguments to be formatted follow immediately afterwards.
+
+.. option:: PrintFunction
+
+   The function that will be used to replace ``printf``, ``fprintf`` etc.
+   during conversion rather than the default ``std::print``. It is expected
+   that the function provides an interface that is compatible with
+   std::print. A suitable candidate would be ``fmt::print``.
+
+Companion checks
+----------------
+
+It is helpful to use the `readability-redundant-string-cstr
+<../readability/redundant-string-cstr.html>` check after this check to
+remove now-unnecessary calls to ``std::string::c_str()``.

clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/cstdio

-//===--- stdio.h - Stub header for tests ------------------------*- C++ -*-===//
+//===--- cstdio - Stub header for tests -------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef _STDIO_H_
-#define _STDIO_H_
+#ifndef _STDIO_
+#define _STDIO_
 
-// A header intended to contain C standard input and output library
-// declarations.
+#include <stdio.h>
 
-int printf(const char *, ...);
+namespace std {
+    using ::FILE;
+    using ::printf;
+    using ::fprintf;
+}
 
-#endif // _STDIO_H_
+#endif // _STDIO_
 

clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/stdio.h

 //===--- stdio.h - Stub header for tests ------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _STDIO_H_
 #define _STDIO_H_
 
 // A header intended to contain C standard input and output library
 // declarations.
 
+typedef struct structFILE {} FILE;
+extern FILE *stderr;
+
 int printf(const char *, ...);
+int fprintf(FILE *, const char *, ...);
+
+#define NULL (0)
 
 #endif // _STDIO_H_
 

clang-tools-extra/test/clang-tidy/checkers/modernize/printf-to-fmt-print-convert.cpp

+// RUN: %check_clang_tidy %s modernize-printf-to-std-print %t -- \
+// RUN:   -config="{CheckOptions: \
+// RUN:             [{key: modernize-printf-to-std-print.PrintFunction, \
+// RUN:               value: 'fmt::print'}] \
+// RUN:             }" \
+// RUN:   -- -isystem %clang_tidy_headers
+
+#include <cstdio>
+#include <string.h>
+
+void printf_simple() {
+  printf("Hello %s %d\n", "world", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'fmt::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: fmt::print("Hello {} {}\n", "world", 42);
+}
+
+void fprintf_simple(FILE *fp) {
+  fprintf(fp, "Hello %s %d\n", "world", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'fprintf' with 'fmt::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: fmt::print(fp, "Hello {} {}\n", "world", 42);
+}

clang-tools-extra/test/clang-tidy/checkers/modernize/printf-to-std-print-convert-absl.cpp

+// RUN: %check_clang_tidy -std=c++2b %s modernize-printf-to-std-print %t -- -- -isystem %clang_tidy_headers
+
+#include <cstdio>
+#include <string.h>
+
+namespace absl
+{
+// Use const char * for the format since the real type is hard to mock up.
+template <typename... Args>
+int PrintF(const char *format, const Args&... args);
+
+template <typename... Args>
+int FPrintF(FILE* output, const char *format, const Args&... args);
+}
+
+void printf_simple() {
+  absl::PrintF("Hello %s %d\n", "world", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'PrintF' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello {} {}\n", "world", 42);
+
+  using namespace absl;
+  PrintF("Hello %s %d\n", "world", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'PrintF' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello {} {}\n", "world", 42);
+}
+
+void fprintf_simple(FILE *fp) {
+  absl::FPrintF(fp, "Hello %s %d\n", "world", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'FPrintF' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print(fp, "Hello {} {}\n", "world", 42);
+
+  using namespace absl;
+  FPrintF(fp, "Hello %s %d\n", "world", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'FPrintF' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print(fp, "Hello {} {}\n", "world", 42);
+}

clang-tools-extra/test/clang-tidy/checkers/modernize/printf-to-std-print-convert-custom.cpp

+// RUN: %check_clang_tidy -std=c++2b %s modernize-printf-to-std-print %t -- \
+// RUN:   -config="{CheckOptions: \
+// RUN:             [ \
+// RUN:              { \
+// RUN:               key: modernize-printf-to-std-print.PrintfLikeFunctions, \
+// RUN:               value: '::myprintf; mynamespace::myprintf2' \
+// RUN:              }, \
+// RUN:              { \
+// RUN:               key: modernize-printf-to-std-print.FprintfLikeFunctions, \
+// RUN:               value: '::myfprintf; mynamespace::myfprintf2' \
+// RUN:              } \
+// RUN:             ] \
+// RUN:             }" \
+// RUN:   -- -isystem %clang_tidy_headers
+
+#include <cstdio>
+#include <string.h>
+
+int myprintf(const char *, ...);
+int myfprintf(FILE *fp, const char *, ...);
+
+namespace mynamespace {
+int myprintf2(const char *, ...);
+int myfprintf2(FILE *fp, const char *, ...);
+}
+
+void printf_simple() {
+  myprintf("Hello %s %d\n", "world", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'myprintf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello {} {}\n", "world", 42);
+
+  mynamespace::myprintf2("Hello %s %d\n", "world", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'myprintf2' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello {} {}\n", "world", 42);
+
+  using mynamespace::myprintf2;
+  myprintf2("Hello %s %d\n", "world", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'myprintf2' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello {} {}\n", "world", 42);
+}
+
+void fprintf_simple(FILE *fp)
+{
+  myfprintf(stderr, "Hello %s %d\n", "world", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'myfprintf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print(stderr, "Hello {} {}\n", "world", 42);
+
+  mynamespace::myfprintf2(stderr, "Hello %s %d\n", "world", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'myfprintf2' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print(stderr, "Hello {} {}\n", "world", 42);
+
+  using mynamespace::myfprintf2;
+  myfprintf2(stderr, "Hello %s %d\n", "world", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'myfprintf2' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print(stderr, "Hello {} {}\n", "world", 42);
+}

clang-tools-extra/test/clang-tidy/checkers/modernize/printf-to-std-print-convert.cpp

+// RUN: %check_clang_tidy -std=c++2b %s modernize-printf-to-std-print %t -- -- -isystem %clang_tidy_headers
+
+#include <cstdio>
+#include <inttypes.h>
+#include <string.h>
+
+void printf_simple() {
+  printf("Hello");
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello");
+}
+
+void fprintf_simple() {
+  fprintf(stderr, "Hello");
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'fprintf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print(stderr, "Hello");
+}
+
+void std_printf_simple() {
+  std::printf("std::Hello");
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("std::Hello");
+}
+
+void printf_escape() {
+  printf("before \t");
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("before \t");
+
+  printf("\n after");
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("\n after");
+
+  printf("before \a after");
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("before \a after");
+
+  printf("Bell\a%dBackspace\bFF%s\fNewline\nCR\rTab\tVT\vEscape\x1b\x07%d", 42, "string", 99);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Bell\a{}Backspace\bFF{}\fNewline\nCR\rTab\tVT\vEscape\x1b\a{}", 42, "string", 99);
+
+  printf("not special \x1b\x01\x7f");
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("not special \x1b\x01\x7f");
+}
+
+void printf_percent() {
+  printf("before %%");
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("before %");
+
+  printf("%% after");
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("% after");
+
+  printf("before %% after");
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("before % after");
+
+  printf("Hello %% and another %%");
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello % and another %");
+
+  printf("Not a string %%s");
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Not a string %s");
+}
+
+void printf_curlies() {
+  printf("%d {}", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{} {{[{][{]}}}}", 42);
+
+  printf("{}");
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{{[{][{]}}}}");
+}
+
+void printf_unsupported() {
+  int pos;
+  printf("%d %n %d\n", 42, &pos, 72);
+  // fmt doesn't do the equivalent of %n, so leave the call alone.
+
+  printf("Error %m\n");
+  // fmt doesn't support %m. In theory we could insert a strerror(errno)
+  // parameter (assuming that libc has a thread-safe implementation, which glibc
+  // does), but that would require keeping track of the input and output
+  // parameter indices for position arguments too.
+}
+
+void printf_not_string_literal(const char *fmt) {
+  // We can't convert the format string if it's not a literal
+  printf(fmt, 42);
+}
+
+void printf_inttypes_ugliness() {
+  // The one advantage of the checker seeing the token pasted version of the
+  // format string is that we automatically cope with the horrendously-ugly
+  // inttypes.h macros!
+  int64_t u64 = 42;
+  uintmax_t umax = 4242;
+  printf("uint64:%" PRId64 " uintmax:%" PRIuMAX "\n", u64, umax);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("uint64:{} uintmax:{}\n", u64, umax);
+}
+
+void printf_raw_string() {
+  // This one doesn't require the format string to be changed, so it stays intact
+  printf(R"(First\Second)");
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print(R"(First\Second)");
+
+  // This one does require the format string to be changed, so unfortunately it
+  // gets reformatted as a normal string.
+  printf(R"(First %d\Second)", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("First {}\\Second", 42);
+}
+
+void printf_integer_d() {
+  const bool b = true;
+  // The "d" type is necessary here for compatibility with printf since
+  // std::print will print booleans as "true" or "false".
+  printf("Integer %d from bool\n", b);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {:d} from bool\n", b);
+
+  // The "d" type is necessary here for compatibility with printf since
+  // std::print will print booleans as "true" or "false".
+  printf("Integer %i from bool\n", b);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {:d} from bool\n", b);
+
+  // The 'd' is always necessary since otherwise the parameter will be formatted as a character
+  const char c = 'A';
+  printf("Integer %d from char\n", c);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {:d} from char\n", c);
+
+  printf("Integer %i from char\n", 'A');
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {:d} from char\n", 'A');
+
+  const signed char sc = 'A';
+  printf("Integer %hhd from signed char\n", sc);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from signed char\n", sc);
+
+  printf("Integer %hhi from signed char\n", sc);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from signed char\n", sc);
+
+  const unsigned char uc = 'A';
+  printf("Integer %hhd from unsigned char\n", uc);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from unsigned char\n", static_cast<signed char>(uc));
+
+  printf("Integer %hhi from signed char\n", sc);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from signed char\n", sc);
+
+  const short s = 42;
+  printf("Integer %hd from short\n", s);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from short\n", s);
+
+  printf("Integer %hi from short\n", s);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from short\n", s);
+
+  const unsigned short us = 42U;
+  printf("Integer %hd from unsigned short\n", us);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from unsigned short\n", static_cast<short>(us));
+
+  printf("Integer %hi from unsigned short\n", us);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from unsigned short\n", static_cast<short>(us));
+
+  const int i = 42;
+  printf("Integer %d from integer\n", i);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from integer\n", i);
+
+  printf("Integer %i from integer\n", i);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from integer\n", i);
+
+  const unsigned int ui = 42U;
+  printf("Integer %d from unsigned integer\n", ui);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from unsigned integer\n", static_cast<int>(ui));
+
+  printf("Integer %i from unsigned integer\n", ui);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from unsigned integer\n", static_cast<int>(ui));
+
+  const long l = 42L;
+  printf("Integer %ld from long\n", l);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from long\n", l);
+
+  printf("Integer %li from long\n", l);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from long\n", l);
+
+  const unsigned long ul = 42UL;
+  printf("Integer %ld from unsigned long\n", ul);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from unsigned long\n", static_cast<long>(ul));
+
+  printf("Integer %li from unsigned long\n", ul);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from unsigned long\n", static_cast<long>(ul));
+
+  const long long ll = 42LL;
+  printf("Integer %lld from long long\n", ll);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from long long\n", ll);
+
+  printf("Integer %lli from long long\n", ll);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from long long\n", ll);
+
+  const unsigned long long ull = 42ULL;
+  printf("Integer %lld from unsigned long long\n", ull);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from unsigned long long\n", static_cast<long long>(ull));
+
+  printf("Integer %lli from unsigned long long\n", ull);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from unsigned long long\n", static_cast<long long>(ull));
+
+  const intmax_t im = 42;
+  printf("Integer %jd from intmax_t\n", im);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from intmax_t\n", im);
+
+  printf("Integer %ji from intmax_t\n", im);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from intmax_t\n", im);
+
+  // This doesn't currently work since getCorrespondingSignedTypeName() doesn't recognise uintmax_t.
+  const uintmax_t uim = 42;
+  printf("Integer %jd from uintmax_t\n", uim);
+  // CHECK-MESSAGES-NOTYET: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES-NOTYET: std::print("Integer {} from uintmax_t\n", static_cast<intmax_t>(im));
+
+  printf("Integer %ji from intmax_t\n", uim);
+  // CHECK-MESSAGES-NOTYET: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES-NOTYET: std::print("Integer {} from uintmax_t\n", static_cast<intmax_t>(im));
+
+  // We don't have ptrdiff_t here.
+  const int ai[] = { 0, 1, 2, 3};
+  const auto pd = &ai[3] - &ai[0];
+  printf("Integer %td from ptrdiff_t\n", pd);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from ptrdiff_t\n", pd);
+
+  printf("Integer %ti from ptrdiff_t\n", pd);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from ptrdiff_t\n", pd);
+
+  // This doesn't currently work since getCorrespondingSignedTypeName() doesn't
+  // recognize size_t.
+  const size_t z = 42UL;
+  printf("Integer %zd from size_t\n", z);
+  // CHECK-MESSAGES-NOTYET: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES-NOTYET: std::print("Integer {} from size_t\n", z);
+}
+
+void printf_integer_u()
+{
+  const bool b = true;
+  // The "d" type is necessary here for compatibility with printf since
+  // std::print will print booleans as "true" or "false".
+  printf("Integer %u from bool\n", b);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {:d} from bool\n", b);
+
+  const char c = 'A';
+  printf("Unsigned integer %hhu from char\n", c);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Unsigned integer {} from char\n", static_cast<unsigned char>(c));
+
+  const unsigned char sc = 'A';
+  printf("Integer %hhu from signed char\n", sc);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from signed char\n", sc);
+
+  printf("Integer %u from signed char\n", sc);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from signed char\n", sc);
+
+  const unsigned char uc = 'A';
+  printf("Integer %hhu from unsigned char\n", uc);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from unsigned char\n", uc);
+
+  printf("Integer %u from unsigned char\n", uc);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from unsigned char\n", uc);
+
+  const short s = 42;
+  printf("Integer %hu from short\n", s);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from short\n", static_cast<unsigned short>(s));
+
+  const unsigned short us = 42U;
+  printf("Integer %hu from unsigned short\n", us);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from unsigned short\n", us);
+
+  const int i = 42;
+  printf("Integer %u from signed integer\n", i);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from signed integer\n", static_cast<unsigned int>(i));
+
+  const unsigned int ui = 42U;
+  printf("Integer %u from unsigned integer\n", ui);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from unsigned integer\n", ui);
+
+  const long l = 42L;
+  printf("Integer %u from signed long\n", l);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from signed long\n", static_cast<unsigned long>(l));
+
+  const unsigned long ul = 42UL;
+  printf("Integer %lu from unsigned long\n", ul);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from unsigned long\n", ul);
+
+  const long long ll = 42LL;
+  printf("Integer %llu from long long\n", ll);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from long long\n", static_cast<unsigned long long>(ll));
+
+  const unsigned long long ull = 42ULL;
+  printf("Integer %llu from unsigned long long\n", ull);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from unsigned long long\n", ull);
+
+  // This doesn't work yet since getCorrespondingUnsignedTypeName doesn't understand intmax_t.
+  const intmax_t im = 42;
+  printf("Integer %ju from intmax_t\n", im);
+  // CHECK-MESSAGES-NOTYET: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES-NOTYET: std::print("Integer {} from uintmax_t\n", uim);
+
+  const uintmax_t uim = 42U;
+  printf("Integer %ju from uintmax_t\n", uim);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Integer {} from uintmax_t\n", uim);
+
+  // This can't currently be converted since getCorrespodningUnsignedTypeName
+  // doesn't understand ptrdiff_t.
+  const int ai[] = { 0, 1, 2, 3};
+  const auto pd = &ai[3] - &ai[0];
+  printf("Integer %tu from ptrdiff_t\n", pd);
+  // CHECK-MESSAGES-NOTYET: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES-NOTYET: std::print("Integer {} from ptrdiff_t\n", pd);
+
+  const size_t z = 42U;
+  printf("%zu\n", z);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}\n", z);
+}
+
+// This checks that we get the argument offset right with the extra FILE * argument
+void fprintf_integer() {
+  fprintf(stderr, "Integer %d from integer\n", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'fprintf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print(stderr, "Integer {} from integer\n", 42);
+
+  fprintf(stderr, "Integer %i from integer\n", 65);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'fprintf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print(stderr, "Integer {} from integer\n", 65);
+
+  fprintf(stderr, "Integer %i from char\n", 'A');
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'fprintf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print(stderr, "Integer {:d} from char\n", 'A');
+
+  fprintf(stderr, "Integer %d from char\n", 'A');
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'fprintf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print(stderr, "Integer {:d} from char\n", 'A');
+}
+
+void printf_char() {
+  const char c = 'A';
+  printf("Char %c from char\n", c);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Char {} from char\n", c);
+
+  const signed char sc = 'A';
+  printf("Char %c from signed char\n", sc);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Char {:c} from signed char\n", sc);
+
+  const unsigned char uc = 'A';
+  printf("Char %c from unsigned char\n", uc);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Char {:c} from unsigned char\n", uc);
+
+  const int i = 65;
+  printf("Char %c from integer\n", i);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Char {:c} from integer\n", i);
+
+  const unsigned int ui = 65;
+  printf("Char %c from unsigned integer\n", ui);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Char {:c} from unsigned integer\n", ui);
+
+  const unsigned long long ull = 65;
+  printf("Char %c from unsigned long long\n", ull);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Char {:c} from unsigned long long\n", ull);
+}
+
+void printf_bases() {
+  printf("Hex %lx\n", 42L);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hex {:x}\n", 42L);
+
+  printf("HEX %X\n", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("HEX {:X}\n", 42);
+
+  printf("Oct %lo\n", 42L);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Oct {:o}\n", 42L);
+}
+
+void printf_alternative_forms() {
+  printf("Hex %#lx\n", 42L);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hex {:#x}\n", 42L);
+
+  printf("HEX %#X\n", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("HEX {:#X}\n", 42);
+
+  printf("Oct %#lo\n", 42L);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Oct {:#o}\n", 42L);
+
+  printf("Double %#f %#F\n", -42.0, -42.0);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Double {:#f} {:#F}\n", -42.0, -42.0);
+
+  printf("Double %#g %#G\n", -42.0, -42.0);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Double {:#g} {:#G}\n", -42.0, -42.0);
+
+  printf("Double %#e %#E\n", -42.0, -42.0);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Double {:#e} {:#E}\n", -42.0, -42.0);
+
+  printf("Double %#a %#A\n", -42.0, -42.0);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Double {:#a} {:#A}\n", -42.0, -42.0);
+
+  // Characters don't have an alternate form
+  printf("Char %#c\n", 'A');
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Char {}\n", 'A');
+
+  // Strings don't have an alternate form
+  printf("Char %#c\n", 'A');
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Char {}\n", 'A');
+}
+
+void printf_string() {
+  printf("Hello %s after\n", "Goodbye");
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello {} after\n", "Goodbye");
+
+  // std::print can't print signed char strings.
+  const signed char *sstring = reinterpret_cast<const signed char *>("ustring");
+  printf("signed char string %s\n", sstring);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("signed char string {}\n", reinterpret_cast<const char *>(sstring));
+
+  // std::print can't print unsigned char strings.
+  const unsigned char *ustring = reinterpret_cast<const unsigned char *>("ustring");
+  printf("unsigned char string %s\n", ustring);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("unsigned char string {}\n", reinterpret_cast<const char *>(ustring));
+}
+
+void printf_float() {
+  // If the type is not specified then either f or e will be used depending on
+  // whichever is shorter. This means that it is necessary to be specific to
+  // maintain compatibility with printf.
+
+  // TODO: Should we force a cast here, since printf will promote to double
+  // automatically, but std::format will not, which could result in different
+  // output?
+
+  const float f = 42.0F;
+  printf("Hello %f after\n", f);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello {:f} after\n", f);
+
+  printf("Hello %g after\n", f);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello {:g} after\n", f);
+
+  printf("Hello %e after\n", f);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello {:e} after\n", f);
+}
+
+void printf_double() {
+  // If the type is not specified then either f or e will be used depending on
+  // whichever is shorter. This means that it is necessary to be specific to
+  // maintain compatibility with printf.
+
+  const double d = 42.0;
+  printf("Hello %f after\n", d);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello {:f} after\n", d);
+
+  printf("Hello %g after\n", d);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello {:g} after\n", d);
+
+  printf("Hello %e after\n", d);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello {:e} after\n", d);
+}
+
+void printf_long_double() {
+  // If the type is not specified then either f or e will be used depending on
+  // whichever is shorter. This means that it is necessary to be specific to
+  // maintain compatibility with printf.
+
+  const long double ld = 42.0L;
+  printf("Hello %Lf after\n", ld);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello {:f} after\n", ld);
+
+  printf("Hello %g after\n", ld);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello {:g} after\n", ld);
+
+  printf("Hello %e after\n", ld);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello {:e} after\n", ld);
+}
+
+void printf_pointer() {
+  int i;
+  double j;
+  printf("Int* %p %s %p\n", &i, "Double*", &j);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Int* {} {} {}\n", reinterpret_cast<const void *>(&i), "Double*", reinterpret_cast<const void *>(&j));
+
+  printf("%p\n", nullptr);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}\n", nullptr);
+
+  const auto np = nullptr;
+  printf("%p\n", np);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}\n", np);
+
+  // NULL isn't a pointer, so std::print needs some help.
+  printf("%p\n", NULL);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}\n", reinterpret_cast<const void *>(NULL));
+
+  printf("%p\n", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}\n", reinterpret_cast<const void *>(42));
+
+  // If we already have a void pointer then no cast is required.
+  printf("%p\n", reinterpret_cast<const void *>(44));
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}\n", reinterpret_cast<const void *>(44));
+
+  const void *p;
+  printf("%p\n", p);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}\n", p);
+
+  // But a pointer to a pointer to void does need a cast
+  const void **pp;
+  printf("%p\n", pp);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}\n", reinterpret_cast<const void *>(pp));
+
+  printf("%p\n", printf_pointer);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}\n", reinterpret_cast<const void *>(printf_pointer));
+}
+
+class AClass
+{
+  void printf_this_pointer()
+  {
+    printf("%p\n", this);
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+    // CHECK-FIXES: std::print("{}\n", reinterpret_cast<const void *>(this));
+  }
+};
+
+void printf_positional_arg() {
+  printf("%1$d", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{0}", 42);
+
+  printf("before %1$d", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("before {0}", 42);
+
+  printf("%1$d after", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{0} after", 42);
+
+  printf("before %1$d after", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("before {0} after", 42);
+
+  printf("before %2$d between %1$s after", "string", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("before {1} between {0} after", "string", 42);
+}
+
+// printf always defaults to right justification,, no matter what the type is of
+// the argument. std::format uses left justification by default for strings, and
+// right justification for numbers.
+void printf_right_justified() {
+  printf("Right-justified integer %4d after\n", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Right-justified integer {:4} after\n", 42);
+
+  printf("Right-justified double %4f\n", 227.2);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Right-justified double {:4f}\n", 227.2);
+
+  printf("Right-justified double %4g\n", 227.4);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Right-justified double {:4g}\n", 227.4);
+
+  printf("Right-justified integer with field width argument %*d after\n", 5, 424242);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Right-justified integer with field width argument {:{}} after\n", 5, 424242);
+
+  printf("Right-justified integer with field width argument %2$*1$d after\n", 5, 424242);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Right-justified integer with field width argument {1:{0}} after\n", 5, 424242);
+
+  printf("Right-justified string %20s\n", "Hello");
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Right-justified string {:>20}\n", "Hello");
+
+  printf("Right-justified string with field width argument %2$*1$s after\n", 20, "wibble");
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Right-justified string with field width argument {1:>{0}} after\n", 20, "wibble");
+}
+
+// printf always requires - for left justification, no matter what the type is
+// of the argument. std::format uses left justification by default for strings,
+// and right justification for numbers.
+void printf_left_justified() {
+  printf("Left-justified integer %-4d\n", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Left-justified integer {:<4}\n", 42);
+
+  printf("Left-justified integer %--4d\n", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Left-justified integer {:<4}\n", 42);
+
+  printf("Left-justified double %-4f\n", 227.2);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Left-justified double {:<4f}\n", 227.2);
+
+  printf("Left-justified double %-4g\n", 227.4);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Left-justified double {:<4g}\n", 227.4);
+
+  printf("Left-justified integer with field width argument %-*d after\n", 5, 424242);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Left-justified integer with field width argument {:<{}} after\n", 5, 424242);
+
+  printf("Left-justified integer with field width argument %2$-*1$d after\n", 5, 424242);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Left-justified integer with field width argument {1:<{0}} after\n", 5, 424242);
+
+  printf("Left-justified string %-20s\n", "Hello");
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Left-justified string {:20}\n", "Hello");
+
+  printf("Left-justified string with field width argument %2$-*1$s after\n", 5, "wibble");
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Left-justified string with field width argument {1:{0}} after\n", 5, "wibble");
+}
+
+void printf_precision() {
+  printf("Hello %.3f\n", 3.14159);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello {:.3f}\n", 3.14159);
+
+  printf("Hello %10.3f\n", 3.14159);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello {:10.3f}\n", 3.14159);
+
+  printf("Hello %.*f after\n", 10, 3.14159265358979323846);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello {:.{}f} after\n", 10, 3.14159265358979323846);
+
+  printf("Hello %10.*f after\n", 3, 3.14159265358979323846);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello {:10.{}f} after\n", 3, 3.14159265358979323846);
+
+  printf("Hello %*.*f after\n", 10, 4, 3.14159265358979323846);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello {:{}.{}f} after\n", 10, 4, 3.14159265358979323846);
+
+  printf("Hello %1$.*2$f after\n", 3.14159265358979323846, 4);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello {0:.{1}f} after\n", 3.14159265358979323846, 4);
+
+  // Precision is ignored, but maintained on non-numeric arguments
+  printf("Hello %.5s\n", "Goodbye");
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello {:.5}\n", "Goodbye");
+
+  printf("Hello %.5c\n", 'G');
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello {:.5}\n", 'G');
+}
+
+void printf_field_width_and_precision() {
+  printf("Hello %1$*2$.*3$f after\n", 3.14159265358979323846, 4, 2);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Hello {0:{1}.{2}f} after\n", 3.14159265358979323846, 4, 2);
+}
+
+void printf_alternative_form() {
+  printf("Wibble %#x\n", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Wibble {:#x}\n", 42);
+
+  printf("Wibble %#20x\n", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Wibble {:#20x}\n", 42);
+
+  printf("Wibble %#020x\n", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Wibble {:#020x}\n", 42);
+
+  printf("Wibble %#-20x\n", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Wibble {:<#20x}\n", 42);
+}
+
+void printf_leading_plus() {
+  printf("Positive integer %+d\n", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Positive integer {:+}\n", 42);
+
+  printf("Positive double %+f\n", 42.2);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Positive double {:+f}\n", 42.2);
+
+  printf("Positive double %+g\n", 42.2);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Positive double {:+g}\n", 42.2);
+
+  // Ignore leading plus on strings to avoid potential runtime exception where
+  // printf would have just ignored it.
+  printf("Positive string %+s\n", "string");
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Positive string {}\n", "string");
+}
+
+void printf_leading_space() {
+  printf("Spaced integer % d\n", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Spaced integer {: }\n", 42);
+
+  printf("Spaced integer %- d\n", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Spaced integer {: }\n", 42);
+
+  printf("Spaced double % f\n", 42.2);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Spaced double {: f}\n", 42.2);
+
+  printf("Spaced double % g\n", 42.2);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Spaced double {: g}\n", 42.2);
+}
+
+void printf_leading_zero() {
+  printf("Leading zero integer %03d\n", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Leading zero integer {:03}\n", 42);
+
+  printf("Leading minus and zero integer %-03d minus ignored\n", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Leading minus and zero integer {:<03} minus ignored\n", 42);
+
+  printf("Leading zero unsigned integer %03u\n", 42U);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Leading zero unsigned integer {:03}\n", 42U);
+
+  printf("Leading zero double %03f\n", 42.2);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Leading zero double {:03f}\n", 42.2);
+
+  printf("Leading zero double %03g\n", 42.2);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Leading zero double {:03g}\n", 42.2);
+}
+
+void printf_leading_plus_and_space() {
+  // printf prefers plus to space. {fmt} will throw if both are present.
+  printf("Spaced integer % +d\n", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Spaced integer {:+}\n", 42);
+
+  printf("Spaced double %+ f\n", 42.2);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Spaced double {:+f}\n", 42.2);
+
+  printf("Spaced double % +g\n", 42.2);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Spaced double {:+g}\n", 42.2);
+}
+
+void printf_leading_zero_and_plus() {
+  printf("Leading zero integer %+03d\n", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Leading zero integer {:+03}\n", 42);
+
+  printf("Leading zero double %0+3f\n", 42.2);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Leading zero double {:+03f}\n", 42.2);
+
+  printf("Leading zero double %0+3g\n", 42.2);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Leading zero double {:+03g}\n", 42.2);
+}
+
+void printf_leading_zero_and_space() {
+  printf("Leading zero and space integer %0 3d\n", 42);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Leading zero and space integer {: 03}\n", 42);
+
+  printf("Leading zero and space double %0 3f\n", 42.2);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Leading zero and space double {: 03f}\n", 42.2);
+
+  printf("Leading zero and space double %0 3g\n", 42.2);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("Leading zero and space double {: 03g}\n", 42.2);
+}
+
+// add signed plained enum too
+enum PlainEnum { red };
+enum SignedPlainEnum { black = -42 };
+enum BoolEnum : unsigned int { yellow };
+enum CharEnum : char { purple };
+enum SCharEnum : signed char  { aquamarine };
+enum UCharEnum : unsigned char  { pink };
+enum ShortEnum : short { beige };
+enum UShortEnum : unsigned short { grey };
+enum IntEnum : int { green };
+enum UIntEnum : unsigned int { blue };
+enum LongEnum : long { magenta };
+enum ULongEnum : unsigned long { cyan };
+enum LongLongEnum : long long { taupe };
+enum ULongLongEnum : unsigned long long { brown };
+
+void printf_enum_d() {
+  PlainEnum plain_enum;
+  printf("%d", plain_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<int>(plain_enum));
+
+  SignedPlainEnum splain_enum;
+  printf("%d", splain_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<int>(splain_enum));
+
+  BoolEnum bool_enum;
+  printf("%d", bool_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<int>(bool_enum));
+
+  CharEnum char_enum;
+  printf("%d", char_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<signed char>(char_enum));
+
+  SCharEnum schar_enum;
+  printf("%d", schar_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<signed char>(schar_enum));
+
+  UCharEnum uchar_enum;
+  printf("%d", uchar_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<signed char>(uchar_enum));
+
+  ShortEnum short_enum;
+  printf("%d", short_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<short>(short_enum));
+
+  UShortEnum ushort_enum;
+  printf("%d", ushort_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<short>(ushort_enum));
+
+  IntEnum int_enum;
+  printf("%d", int_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<int>(int_enum));
+
+  UIntEnum uint_enum;
+  printf("%d", uint_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<int>(uint_enum));
+
+  LongEnum long_enum;
+  printf("%d", long_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<long>(long_enum));
+
+  ULongEnum ulong_enum;
+  printf("%d", ulong_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<long>(ulong_enum));
+
+  LongLongEnum longlong_enum;
+  printf("%d", longlong_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<long long>(longlong_enum));
+
+  ULongLongEnum ulonglong_enum;
+  printf("%d", ulonglong_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<long long>(ulonglong_enum));
+}
+
+void printf_enum_u() {
+  PlainEnum plain_enum;
+  printf("%u", plain_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<unsigned int>(plain_enum));
+
+  SignedPlainEnum splain_enum;
+  printf("%u", splain_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<unsigned int>(splain_enum));
+
+  BoolEnum bool_enum;
+  printf("%u", bool_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<unsigned int>(bool_enum));
+
+  CharEnum char_enum;
+  printf("%u", char_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<unsigned char>(char_enum));
+
+  SCharEnum schar_enum;
+  printf("%u", schar_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<unsigned char>(schar_enum));
+
+  UCharEnum uchar_enum;
+  printf("%u", uchar_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<unsigned char>(uchar_enum));
+
+  ShortEnum short_enum;
+  printf("%u", short_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<unsigned short>(short_enum));
+
+  UShortEnum ushort_enum;
+  printf("%u", ushort_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<unsigned short>(ushort_enum));
+
+  IntEnum int_enum;
+  printf("%u", int_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<unsigned int>(int_enum));
+
+  UIntEnum uint_enum;
+  printf("%u", uint_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<unsigned int>(uint_enum));
+
+  LongEnum long_enum;
+  printf("%u", long_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<unsigned long>(long_enum));
+
+  ULongEnum ulong_enum;
+  printf("%u", ulong_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<unsigned long>(ulong_enum));
+
+  LongLongEnum longlong_enum;
+  printf("%u", longlong_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<unsigned long long>(longlong_enum));
+
+  ULongLongEnum ulonglong_enum;
+  printf("%u", ulonglong_enum);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: Replace 'printf' with 'std::print' [modernize-printf-to-std-print]
+  // CHECK-FIXES: std::print("{}", static_cast<unsigned long long>(ulonglong_enum));
+}