[clang-tidy] Add new 'readability-uppercase-literal-suffix' check (CERT DCL16-C, MISRA C:2012, 7.3, MISRA C++:2008, 2-13-4)

[lebedev.ri]

Summary

Detects when the integral literal or floating point (decimal or hexadecimal)
literal has non-uppercase suffix, and suggests to make the suffix uppercase,
with fix-it.

All valid combinations of suffixes are supported.

auto x = 1;  // OK, no suffix.

auto x = 1u; // warning: integer literal suffix 'u' is not upper-case

auto x = 1U; // OK, suffix is uppercase.

...

References:

• CERT DCL16-C
• MISRA C:2012, 7.3 - The lowercase character "l" shall not be used in a literal suffix
• MISRA C++:2008, 2-13-4 - Literal suffixes shall be upper case

[Eugene.Zelenko]

docs/ReleaseNotes.rst

96

Please move alias after new checks.

[Eugene.Zelenko]

May be we should also create MISRA module?

[lebedev.ri]

Move alias to after the new check,

[lebedev.ri]

docs/ReleaseNotes.rst

96

BTW, is there some tool to actually add this alias? I didn't find it, and had to do it by hand..

[lebedev.ri]

• Deduplicate one test.

[JonasToth]

Thanks for working on this!

Related as well: http://www.codingstandard.com/rule/4-2-1-ensure-that-the-u-suffix-is-applied-to-a-literal-used-in-a-context-requiring-an-unsigned-integral-expression/
I think its wort a alias is hicpp as well

Please add tests that use user-defined literals and ensure there are no collision and that they are not diagnosed. Some examples: https://en.cppreference.com/w/cpp/language/user_literal

clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp

27

maybe ClangType is not a good name, how about just type to be consistent with e.g. std::vector convention.
The use-case in your template makes it clear, that we are talking about LiteralTypes.

34

why are these declarations necessary?

43

The second line of the comment is slightly confusing, please make a full sentence out of it.

53

as it hit me in my check: what about (1)ul? Is this syntactically correct and should be diagnosed too? (Please add tests if so).

In this case it should be Note.getType().IgnoreParens().getTypePtr()).

54

Maybe the if could init T? It would require a second return false; if i am not mistaken, but looks more regular to me. No strong opinion from my side.

70

Same comment as above

86

These types get really long. Is it possible to put NewSuffix into the anonymous namespace as well?

91

GIven that this variable is used mutliple times in a longer function, i feel it shuold get a longer, more descriptive name

96

Please check if the source text could be retrieved, with a final bool parameter, thats in/out and at least assert on that.

107

please use flloating-point instead of fp (same in other places)

130

Could this function return a Optional<FixitHint>? That would include the range and the relacement-text. I feel that is would simplify the code, especially the amount of state that one has to keep track of.

136

I think you can merge this matcher to stmt(eachOf(integerLiteral(intHasSuffix()).bind(), floatLiteral(fpHasSuffix()).bind()))

eachOf because we want to match all, and not short-circuit.

153

Wouldn't it make sense to warn for the literals in macros?

166

Lets move this diag into the true branch of the if stmt and drop the ´else`.

166

I think the warning should point at the suffix, which can be retrieved from the replacement range. Then you don't need to include the suffix itself in the diagnostic

docs/ReleaseNotes.rst

96

So far there is nothing, but would be a nice addition :)

docs/clang-tidy/checks/readability-uppercase-literal-suffix.rst

10

I feel that the sentence could be improved a bit.

• literal has *a* non-uppercase
• suffix and provides a fix-it-hint with the uppercase suffix. (i think the comma after suffix is not necessary)

test/clang-tidy/readability-uppercase-literal-suffix-floating-point.cpp

27

nit: comparing int to double, same below.

test/clang-tidy/readability-uppercase-literal-suffix-hexadecimal-floating-point.cpp

7

Please remove the TMP duplication and make a extra header for that, that is then included by these tests.

32

you can safely drop the [readability-..] part of the warning message. It will just make problems if the check should be renamed at some point.

[lebedev.ri]

docs/ReleaseNotes.rst

96

Oh, i was really hoping i simply did not find it :/

[lebedev.ri]

Thank you for taking a look!

• Rebased
• Added an alias in hicpp module
• Addressed most of the review comments.

In D52670#1249898, @JonasToth wrote:

Thanks for working on this!

Related as well: http://www.codingstandard.com/rule/4-2-1-ensure-that-the-u-suffix-is-applied-to-a-literal-used-in-a-context-requiring-an-unsigned-integral-expression/
I think its wort a alias is hicpp as well

Hmm, after digging but, i think you meant to link to https://www.codingstandard.com/rule/4-3-1-do-not-convert-an-expression-of-wider-floating-point-type-to-a-narrower-floating-point-type/
With some leeway, i think it does talk about the suffix being uppercase.
Added.

Please add tests that use user-defined literals and ensure there are no collision and that they are not diagnosed. Some examples: https://en.cppreference.com/w/cpp/language/user_literal

All those are UserDefinedLiteral, so we should be good.. https://godbolt.org/z/PcGi0B
Also, it seems the suffix can't be set for these constants: https://godbolt.org/z/YHTqke
So i'm not sure what to test. Can you give an example of a test?

clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp

34

Well, because these are *declarations*.
Else the linker complains, since i'm using these in non-constexpr context, but only provided definitions.

43

Rewrote, hopefully better?

53

clang says invalid
https://godbolt.org/z/R8bGe_

docs/clang-tidy/checks/readability-uppercase-literal-suffix.rst

10

Words are the hardest part :)

[lebedev.ri]

clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp

54

Then we will not have an early-return, which is worse than this.

86

No, because shouldReplaceLiteralSuffix() is a member function which returns that type.
I think it should stay a member function, so theoretically NewSuffix could be a [second] template param, but that is kinda ugly..
I also can't simplify it via using because the NewSuffix is private.

Perhaps we should keep this as-is?

96

I looked at a randomly-selected few dozen calls to this function within clang-tidy, and none of those do this.
But assert added, better than nothing.

130

I still want to see the old suffix, but i think we can form the FixitHint here, and store it.

136

bind() still wants the name though.

153

Very obscure example (like all macros is), but i think it shows the point:

#include <stdio.h>
#include <stdio.h>

#define xstr(s) str(s)
#define str(s) #s

#define dump(X) printf("%u is " str(X) "nits", X);

int main () {
  dump(1u);

  return 0;
}

will normally print 1 is 1units
But if you uppercase it, it will print 1 is 1Units.

I would honestly prefer to give macros a pass here..

166

If the warnings are aggregated (i.e. not raw make dump), with only the first line shown, the suffix will still be invisible.

Regarding the pointer direction, i'm not sure.
For now i have reworded the diag to justify pointing at the literal itself.

[JonasToth]

All those are UserDefinedLiteral, so we should be good.. https://godbolt.org/z/PcGi0B
Also, it seems the suffix can't be set for these constants: https://godbolt.org/z/YHTqke
So i'm not sure what to test. Can you give an example of a test?

I am not suggesting that these should be all uppercase or anything. But the tests should demonstrate, that user-defined literals do not impact analysis and give no false positives.

clang-tidy/hicpp/HICPPTidyModule.cpp

24

spurious formatting fix, can be committed separate.

clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp

43

Yes, few nits.

• 15 in decimal and is (no comma)
• skip to instead of skip until

53

fine then.

54

Ok. Can the dyn_cast be null at all? Shouldn't integerliteral always be a BuiltinType?

86

Why does it need to be a member? It looks like it only accesses NewSuffix which does nothing that requires private access to the check class.

91

you can remove the clang:: as we are in that namespace already.

93

I think you can drop some of the newlines in this function to make the code a bit more dense.

153

Transformation is excluded of course.
The user can still silence the warning in case it is misplaced.

166

I don't understand that. The warning message does include the source location that would be clearly on the literal suffix and the warning without the suffix printed is clear as well. Having this slightly simpler diagnostic would simplify the code significantly.

clang-tidy/utils/ASTUtils.cpp

70

Please add the missing . at the end of the sentence

docs/ReleaseNotes.rst

117

I believe the doc links for the aliases dangle right now. Please add the doc pages for them, too.

[lebedev.ri]

clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp

166

*location*. which will still be a location, if only the first line of the warning is displayed.

We won't even win all that much.
Sure, we will return Optional<FixitHint>, but we will still need to do all that internal stuff to find the old suffix, uppercase it, compare them, etc.

And we lose a very useful ability to check what it considered to be the old suffix in the tests.

It is basically the same question as in D51949.
If you insist, sure, i can do that, but i *really* do believe this is WRONG.

[lebedev.ri]

Addressed remaining review notes:

• Fixed dangling links in docs
• Don't mishandle user-defined literals
• Don't ignore macros, do check them. Thanks to @AaronBallman for the macro concatenation example :)
• Partial fix-it support for macros.

...

[lebedev.ri]

clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp

54

I don't know?
I would guess no.

86

Passing LangOpts turned out to be sufficient to move it into anon namespace.

166

And one more problem here, where do we point if we don't have a fix-it to get the suffix location from?

[JonasToth]

clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp

118

the comma is not necessary

120

values are usually not annotated with const, please remove it for consistency

123

please remove the Now this is troubling.
Please use two or more (what, macros?) instead of two+

166

That point is valid, but if we dont have a suffix location, there is no suffix?
I dont insist :)

193

ast_matchers:: is not necessary, because there is a using ... at the top of the file

clang-tidy/utils/ASTUtils.cpp

72

Does it make sense to have a nullptr for SM? I think you can use a reference here

docs/clang-tidy/checks/list.rst

67

hicpp alias is missing here

[lebedev.ri]

Address review notes.

clang-tidy/readability/IdentifierNamingCheck.cpp

660–678

@JonasToth that is what this code did.
From a quick look i'm not sure what it would decide without the source manager,
so i simply refactored it as a function, and kept the semantics.

clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp

166

See test/clang-tidy/readability-uppercase-literal-suffix-integer-macro.cpp, horrible_macros()
I guess if we point at the suffix, we will also get less useful expanded from messages.

[aaron.ballman]

Two main points: I don't think this check is covering all of the suffixes (I don't see q or i32 support, for instance), and at least for the CERT rule this is covering, it diagnoses more than it should. The CERT rule is specific to l vs L but imposes no requirements on u vs U.

clang-tidy/readability/ReadabilityTidyModule.cpp

88–89

Please keep this sorted alphabetically.

clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp

25

It's unfortunate that clang::IntegerLiteral and clang::tidy::readability::IntegerLiteral are distinct types that are strongly related to one another. I'm not keen on this name, as it means reading the code, an unqualified IntegerLiteral is hard to reason about.

30–31

There are other suffixes for integer literals. See NumericLiteralParser.

37

Same naming concerns here.

47–48

There are more suffixes here (see NumericLiteralParser again), and this comment seems to be copy pasta.

99–100

Don't use auto here.

122

Don't use auto here.

[lebedev.ri]

Hopefully address review notes:

• Support more (all?) obscure suffixes (complex, q, h, f16, i{8,16,32,64})
• Improve test coverage. There isn't coverage for every single combination/permuation of everything, but hopefully at least the basic coverage.
• Support a list of destination suffixes, thus the replacements can be finely controlled.

[JonasToth]

clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp

95

Is this std::find_if?

[lebedev.ri]

Bloat with llvm::find_if()

[aaron.ballman]

LGTM aside from minor wording nits.

clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp

32–33

The comment is somewhat out of sync with the code because of the i and j suffixes as well.

46

I think you mean f is both a valid hexadecimal digit in a hex float literal and a valid floating-point literal suffix.

102

i -> I

213

have already-uppercase suffix -> have a suffix that is already uppercase

217

upper-case -> uppercase

docs/clang-tidy/checks/readability-uppercase-literal-suffix.rst

29

I'd reword this slightly:

"and if a replacement is found that is different from the current suffix, then the diagnostic is issued. This allows for fine-grained control of what suffixes to consider and what their replacements should be."

[lebedev.ri]

• Apply minor wording nits.
• For cert-dcl16-c, only consider L, LL suffixes, not anything else (not even llu).

[aaron.ballman]

In D52670#1268170, @lebedev.ri wrote:

• Apply minor wording nits.
• For cert-dcl16-c, only consider L, LL suffixes, not anything else (not even llu).

I'll find out about the DCL16-C recommendation, as I suspect the intent is to cover lu and llu but not ul and ull. I've pinged the authors and can hopefully get an answer quickly, but if not, I'm fine with fixing that after the patch goes in.

clang-tidy/cert/CERTTidyModule.cpp

87

Don't use auto here.

docs/clang-tidy/checks/readability-uppercase-literal-suffix.rst

7

You should consider calling out the CERT behavioral differences.

[lebedev.ri]

In D52670#1268347, @aaron.ballman wrote:

In D52670#1268170, @lebedev.ri wrote:

• Apply minor wording nits.
• For cert-dcl16-c, only consider L, LL suffixes, not anything else (not even llu).

I'll find out about the DCL16-C recommendation, as I suspect the intent is to cover lu and llu but not ul and ull.

I agree, i've thought so too.

That will open an interesting question: in lu, l should be upper-case. What about u? We can't keep it as-is.
We will either consistently upper-case it, or consistently lower-case it.
I.e. given [lL][uU], should we *always* produce Lu, or LU?

I've pinged the authors

Thank you.

and can hopefully get an answer quickly, but if not, I'm fine with fixing that after the patch goes in.

Thank you.

[aaron.ballman]

In D52670#1268372, @lebedev.ri wrote:

In D52670#1268347, @aaron.ballman wrote:

In D52670#1268170, @lebedev.ri wrote:

• Apply minor wording nits.
• For cert-dcl16-c, only consider L, LL suffixes, not anything else (not even llu).

I'll find out about the DCL16-C recommendation, as I suspect the intent is to cover lu and llu but not ul and ull.

I agree, i've thought so too.

That will open an interesting question: in lu, l should be upper-case. What about u? We can't keep it as-is.
We will either consistently upper-case it, or consistently lower-case it.
I.e. given [lL][uU], should we *always* produce Lu, or LU?

I talked to someone at CERT responsible for maintaining DCL16-C to get their opinion on tightening the wording of the rule and their stated intent is:

"If the first character is 'ell', it should be capitalized. The other ells need not be, and the yew's need not be capitalized either."

e.g.,
11lu -> diagnose
11ul -> fine
11llu -> diagnose
11lLu -> diagnose
11Llu -> fine
11ul -> fine

That said, the author (and I) agree that it'd be perfectly okay to diagnose things like 11Llu and recommend 11LLU as a replacement.

[lebedev.ri]

In D52670#1268564, @aaron.ballman wrote:

In D52670#1268372, @lebedev.ri wrote:

In D52670#1268347, @aaron.ballman wrote:

In D52670#1268170, @lebedev.ri wrote:

• Apply minor wording nits.
• For cert-dcl16-c, only consider L, LL suffixes, not anything else (not even llu).

I'll find out about the DCL16-C recommendation, as I suspect the intent is to cover lu and llu but not ul and ull.

I agree, i've thought so too.

That will open an interesting question: in lu, l should be upper-case. What about u? We can't keep it as-is.
We will either consistently upper-case it, or consistently lower-case it.
I.e. given [lL][uU], should we *always* produce Lu, or LU?

I talked to someone at CERT responsible for maintaining DCL16-C to get their opinion on tightening the wording of the rule and their stated intent is:

Thank you!

"If the first character is 'ell', it should be capitalized. The other ells need not be, and the yew's need not be capitalized either."

e.g.,
11lu -> diagnose
11ul -> fine
11llu -> diagnose
11lLu -> diagnose
11Llu -> fine
11ul -> fine

That said, the author (and I) agree that it'd be perfectly okay to diagnose things like 11Llu and recommend 11LLU as a replacement.

Ok, nothing unexpected.
So the full revised list is: "L;LL:LU;LLU".

[aaron.ballman]

In D52670#1268569, @lebedev.ri wrote:

In D52670#1268564, @aaron.ballman wrote:

I talked to someone at CERT responsible for maintaining DCL16-C to get their opinion on tightening the wording of the rule and their stated intent is:

Thank you!

"If the first character is 'ell', it should be capitalized. The other ells need not be, and the yew's need not be capitalized either."

e.g.,
11lu -> diagnose
11ul -> fine
11llu -> diagnose
11lLu -> diagnose
11Llu -> fine
11ul -> fine

That said, the author (and I) agree that it'd be perfectly okay to diagnose things like 11Llu and recommend 11LLU as a replacement.

Ok, nothing unexpected.
So the full revised list is: "L;LL:LU;LLU".

Agreed. It might be reasonable to add the above as some extra test cases for the CERT check if they're not already covered elsewhere.

[lebedev.ri]

In D52670#1268572, @aaron.ballman wrote:

In D52670#1268569, @lebedev.ri wrote:

In D52670#1268564, @aaron.ballman wrote:

I talked to someone at CERT responsible for maintaining DCL16-C to get their opinion on tightening the wording of the rule and their stated intent is:

Thank you!

"If the first character is 'ell', it should be capitalized. The other ells need not be, and the yew's need not be capitalized either."

e.g.,
11lu -> diagnose
11ul -> fine
11llu -> diagnose
11lLu -> diagnose
11Llu -> fine
11ul -> fine

That said, the author (and I) agree that it'd be perfectly okay to diagnose things like 11Llu and recommend 11LLU as a replacement.

Ok, nothing unexpected.
So the full revised list is: "L;LL:LU;LLU".

Agreed. It might be reasonable to add the above as some extra test cases for the CERT check if they're not already covered elsewhere.

Those exist as the test cases for CERT (although, i only test the integer case for CERT, not float.), i will only need to adjust the expected output.

[lebedev.ri]

CERT: also handle "lu", "llu".

[aaron.ballman]

LGTM! Thanks for the changes!

[lebedev.ri]

Reverted in rL345305 due to multiple apparently-lurking bugs.

[lebedev.ri]

Finally finished creducing the issue i wasn't able to understand even after D53719+D53723,
and it turned out to be hasParent()vs.hasAncestor(). (all tests added)

With that fixed, i do not observe any other bugs.

[lebedev.ri]

Rerun on clang-tools-extra+lld+clang codebase, nothing broken.
I'm gonna reland.

clang-tidy/cert/CERTTidyModule.cpp

 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
 #include "../google/UnnamedNamespaceInHeaderCheck.h"
 #include "../misc/NewDeleteOverloadsCheck.h"
 #include "../misc/NonCopyableObjects.h"
 #include "../misc/StaticAssertCheck.h"
 #include "../misc/ThrowByValueCatchByReferenceCheck.h"
 #include "../performance/MoveConstructorInitCheck.h"
+#include "../readability/UppercaseLiteralSuffixCheck.h"
 #include "CommandProcessorCheck.h"
 #include "DontModifyStdNamespaceCheck.h"
 #include "FloatLoopCounter.h"
 #include "LimitedRandomnessCheck.h"
 #include "PostfixOperatorCheck.h"
 #include "ProperlySeededRandomGeneratorCheck.h"
 #include "SetLongJmpCheck.h"
 #include "StaticObjectExceptionCheck.h"
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     // MSC
     CheckFactories.registerCheck<LimitedRandomnessCheck>("cert-msc50-cpp");
     CheckFactories.registerCheck<ProperlySeededRandomGeneratorCheck>(
         "cert-msc51-cpp");
 
     // C checkers
     // DCL
     CheckFactories.registerCheck<misc::StaticAssertCheck>("cert-dcl03-c");
+    CheckFactories.registerCheck<readability::UppercaseLiteralSuffixCheck>(
+        "cert-dcl16-c");
     // ENV
     CheckFactories.registerCheck<CommandProcessorCheck>("cert-env33-c");
     // FLP
     CheckFactories.registerCheck<FloatLoopCounter>("cert-flp30-c");
     // FIO
     CheckFactories.registerCheck<misc::NonCopyableObjectsCheck>("cert-fio38-c");
     // ERR
     CheckFactories.registerCheck<StrToNumCheck>("cert-err34-c");
     // MSC
     CheckFactories.registerCheck<LimitedRandomnessCheck>("cert-msc30-c");
     CheckFactories.registerCheck<ProperlySeededRandomGeneratorCheck>(
         "cert-msc32-c");
   }
 };
 
 } // namespace cert
 
 // Register the MiscTidyModule using this statically initialized variable.
 static ClangTidyModuleRegistry::Add<cert::CERTModule>
     X("cert-module",
       "Adds lint checks corresponding to CERT secure coding guidelines.");
 
 // This anchor is used to force the linker to link in the generated object file
 // and thus register the CERTModule.
 volatile int CERTModuleAnchorSource = 0;
 
 } // namespace tidy
 } // namespace clang

clang-tidy/cert/CMakeLists.txt

add_clang_library(clangTidyCERTModule
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   clangTidy
   clangTidyGoogleModule
   clangTidyMiscModule
   clangTidyPerformanceModule
+  clangTidyReadabilityModule
   clangTidyUtils
   )

clang-tidy/hicpp/HICPPTidyModule.cpp

 #include "../cppcoreguidelines/ProBoundsArrayToPointerDecayCheck.h"
 #include "../cppcoreguidelines/ProTypeMemberInitCheck.h"
 #include "../cppcoreguidelines/ProTypeVarargCheck.h"
 #include "../cppcoreguidelines/SpecialMemberFunctionsCheck.h"
 #include "../google/DefaultArgumentsCheck.h"
 #include "../google/ExplicitConstructorCheck.h"
 #include "../misc/NewDeleteOverloadsCheck.h"
 #include "../misc/StaticAssertCheck.h"
 #include "../bugprone/UndelegatedConstructorCheck.h"
 #include "../modernize/DeprecatedHeadersCheck.h"
 #include "../modernize/UseAutoCheck.h"
 #include "../modernize/UseEmplaceCheck.h"
 #include "../modernize/UseEqualsDefaultCheck.h"
 #include "../modernize/UseEqualsDeleteCheck.h"
 #include "../modernize/UseNoexceptCheck.h"
 #include "../modernize/UseNullptrCheck.h"
 #include "../modernize/UseOverrideCheck.h"
 #include "../performance/MoveConstArgCheck.h"
 #include "../performance/NoexceptMoveConstructorCheck.h"
 #include "../readability/BracesAroundStatementsCheck.h"
 #include "../readability/FunctionSizeCheck.h"
 #include "../readability/IdentifierNamingCheck.h"
+#include "../readability/UppercaseLiteralSuffixCheck.h"
 #include "ExceptionBaseclassCheck.h"
 #include "MultiwayPathsCoveredCheck.h"
 #include "NoAssemblerCheck.h"
 #include "SignedBitwiseCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace hicpp {
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<modernize::UseEqualsDeleteCheck>(
         "hicpp-use-equals-delete");
     CheckFactories.registerCheck<modernize::UseNoexceptCheck>(
         "hicpp-use-noexcept");
     CheckFactories.registerCheck<modernize::UseNullptrCheck>(
         "hicpp-use-nullptr");
     CheckFactories.registerCheck<modernize::UseOverrideCheck>(
         "hicpp-use-override");
+    CheckFactories.registerCheck<readability::UppercaseLiteralSuffixCheck>(
+        "hicpp-uppercase-literal-suffix");
     CheckFactories.registerCheck<cppcoreguidelines::ProTypeVarargCheck>(
         "hicpp-vararg");
   }
 };
 
 // Register the HICPPModule using this statically initialized variable.
 static ClangTidyModuleRegistry::Add<HICPPModule>
     X("hicpp-module", "Adds High-Integrity C++ checks.");

clang-tidy/readability/CMakeLists.txt

add_clang_library(clangTidyReadabilityModule
   RedundantStringCStrCheck.cpp
   RedundantStringInitCheck.cpp
   SimplifyBooleanExprCheck.cpp
   SimplifySubscriptExprCheck.cpp
   StaticAccessedThroughInstanceCheck.cpp
   StaticDefinitionInAnonymousNamespaceCheck.cpp
   StringCompareCheck.cpp
   UniqueptrDeleteReleaseCheck.cpp
+  UppercaseLiteralSuffixCheck.cpp
 
   LINK_LIBS
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   clangTidy
   clangTidyUtils
   clangTooling
   )

clang-tidy/readability/IdentifierNamingCheck.cpp

 //===--- IdentifierNamingCheck.cpp - clang-tidy ---------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "IdentifierNamingCheck.h"
 
+#include "../utils/ASTUtils.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Preprocessor.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Format.h"
 
static void addUsage(IdentifierNamingCheck::NamingCheckFailureMap &Failures,
   // is already in there
   auto &Failure = Failures[Decl];
   if (!Failure.RawUsageLocs.insert(FixLocation.getRawEncoding()).second)
     return;
 
   if (!Failure.ShouldFix)
     return;
 
-  // Check if the range is entirely contained within a macro argument.
-  SourceLocation MacroArgExpansionStartForRangeBegin;
-  SourceLocation MacroArgExpansionStartForRangeEnd;
-  bool RangeIsEntirelyWithinMacroArgument =
-      SourceMgr &&
-      SourceMgr->isMacroArgExpansion(Range.getBegin(),
-                                     &MacroArgExpansionStartForRangeBegin) &&
-      SourceMgr->isMacroArgExpansion(Range.getEnd(),
-                                     &MacroArgExpansionStartForRangeEnd) &&
-      MacroArgExpansionStartForRangeBegin == MacroArgExpansionStartForRangeEnd;
-
-  // Check if the range contains any locations from a macro expansion.
-  bool RangeContainsMacroExpansion = RangeIsEntirelyWithinMacroArgument ||
-                                     Range.getBegin().isMacroID() ||
-                                     Range.getEnd().isMacroID();
-
-  bool RangeCanBeFixed =
-      RangeIsEntirelyWithinMacroArgument || !RangeContainsMacroExpansion;
-  Failure.ShouldFix = RangeCanBeFixed;
+  Failure.ShouldFix = utils::rangeCanBeFixed(Range, SourceMgr);
 }
 
 /// Convenience method when the usage to be added is a NamedDecl
 static void addUsage(IdentifierNamingCheck::NamingCheckFailureMap &Failures,
                      const NamedDecl *Decl, SourceRange Range,
                      SourceManager *SourceMgr = nullptr) {
   return addUsage(Failures,
                   IdentifierNamingCheck::NamingCheckId(Decl->getLocation(),

clang-tidy/readability/ReadabilityTidyModule.cpp

 #include "RedundantStringCStrCheck.h"
 #include "RedundantStringInitCheck.h"
 #include "SimplifyBooleanExprCheck.h"
 #include "SimplifySubscriptExprCheck.h"
 #include "StaticAccessedThroughInstanceCheck.h"
 #include "StaticDefinitionInAnonymousNamespaceCheck.h"
 #include "StringCompareCheck.h"
 #include "UniqueptrDeleteReleaseCheck.h"
+#include "UppercaseLiteralSuffixCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace readability {
 
 class ReadabilityModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<SimplifySubscriptExprCheck>(
         "readability-simplify-subscript-expr");
     CheckFactories.registerCheck<StaticAccessedThroughInstanceCheck>(
         "readability-static-accessed-through-instance");
     CheckFactories.registerCheck<StaticDefinitionInAnonymousNamespaceCheck>(
         "readability-static-definition-in-anonymous-namespace");
     CheckFactories.registerCheck<StringCompareCheck>(
         "readability-string-compare");
+    CheckFactories.registerCheck<UppercaseLiteralSuffixCheck>(
+        "readability-uppercase-literal-suffix");
     CheckFactories.registerCheck<readability::NamedParameterCheck>(
         "readability-named-parameter");
     CheckFactories.registerCheck<NonConstParameterCheck>(
         "readability-non-const-parameter");
     CheckFactories.registerCheck<RedundantControlFlowCheck>(
         "readability-redundant-control-flow");
     CheckFactories.registerCheck<RedundantDeclarationCheck>(
         "readability-redundant-declaration");

clang-tidy/readability/UppercaseLiteralSuffixCheck.h

+//===--- UppercaseLiteralSuffixCheck.h - clang-tidy -------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_UPPERCASELITERALSUFFIXCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_UPPERCASELITERALSUFFIXCHECK_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace readability {
+
+/// Detects when the integral literal or floating point literal has
+/// non-uppercase suffix, and suggests to make the suffix uppercase.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/readability-uppercase-literal-suffix.html
+class UppercaseLiteralSuffixCheck : public ClangTidyCheck {
+  template <typename LiteralType>
+  bool checkBoundMatch(const ast_matchers::MatchFinder::MatchResult &Result);
+
+public:
+  UppercaseLiteralSuffixCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace readability
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_UPPERCASELITERALSUFFIXCHECK_H

clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp

+//===--- UppercaseLiteralSuffixCheck.cpp - clang-tidy ---------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "UppercaseLiteralSuffixCheck.h"
+#include "../utils/ASTUtils.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallString.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace readability {
+
+namespace {
+
+struct IntegerLiteral {
+  using type = clang::IntegerLiteral;
+  static constexpr llvm::StringLiteral Name = llvm::StringLiteral("integer");
+  // What should be skipped before looking for the Suffixes? (Nothing here.)
+  static constexpr llvm::StringLiteral SkipFirst = llvm::StringLiteral("");
+  // Integer suffix can only consist of 'u' and 'l' chars.
+  static constexpr llvm::StringLiteral Suffixes = llvm::StringLiteral("uUlL");
+};
+constexpr llvm::StringLiteral IntegerLiteral::Name;
+constexpr llvm::StringLiteral IntegerLiteral::SkipFirst;
+constexpr llvm::StringLiteral IntegerLiteral::Suffixes;
+
+struct FloatingLiteral {
+  using type = clang::FloatingLiteral;
+  static constexpr llvm::StringLiteral Name =
+      llvm::StringLiteral("floating point");
+  // C++17 introduced hexadecimal floating-point literals, and 'f' is both
+  // 15 in decimal and is 'f' as in 'floating point suffix'.
+  // So we can't just "skip to the chars that can be in the suffix".
+  // Since the exponent ('p'/'P') is mandatory for hexadecimal floating-point
+  // literals, we first skip everything before the exponent.
+  static constexpr llvm::StringLiteral SkipFirst = llvm::StringLiteral("pP");
+  // Floating suffix can only consist of 'u' and 'l' chars.
+  static constexpr llvm::StringLiteral Suffixes = llvm::StringLiteral("fFlL");
+};
+constexpr llvm::StringLiteral FloatingLiteral::Name;
+constexpr llvm::StringLiteral FloatingLiteral::SkipFirst;
+constexpr llvm::StringLiteral FloatingLiteral::Suffixes;
+
+AST_MATCHER(clang::IntegerLiteral, intHasSuffix) {
+  switch (cast<BuiltinType>(Node.getType().getTypePtr())->getKind()) {
+  default:
+  case BuiltinType::Kind::Int:
+    return false;                    // No suffix.
+  case BuiltinType::Kind::UInt:      // 'u'
+  case BuiltinType::Kind::Long:      // 'l'
+  case BuiltinType::Kind::ULong:     // 'ul'
+  case BuiltinType::Kind::LongLong:  // 'll'
+  case BuiltinType::Kind::ULongLong: // 'ull'
+    return true;
+  }
+}
+
+AST_MATCHER(clang::FloatingLiteral, fpHasSuffix) {
+  switch (cast<BuiltinType>(Node.getType().getTypePtr())->getKind()) {
+  default:
+  case BuiltinType::Kind::Double:
+    return false;                     // No suffix.
+  case BuiltinType::Kind::Float:      // 'f'
+  case BuiltinType::Kind::LongDouble: // 'l'
+    return true;
+  }
+}
+
+struct NewSuffix {
+  SourceLocation LiteralLocation;
+  StringRef OldSuffix;
+  llvm::Optional<FixItHint> FixIt;
+};
+
+llvm::Optional<SourceLocation> GetMacroAwareLocation(SourceLocation Loc,
+                                                     const SourceManager &SM) {
+  // Do nothing if the provided location is invalid.
+  if (Loc.isInvalid())
+    return llvm::None;
+  // Look where the location was *actually* written.
+  SourceLocation SpellingLoc = SM.getSpellingLoc(Loc);
+  if (SpellingLoc.isInvalid())
+    return llvm::None;
+  return SpellingLoc;
+}
+
+llvm::Optional<SourceRange> GetMacroAwareSourceRange(SourceRange Loc,
+                                                     const SourceManager &SM) {
+  auto Begin = GetMacroAwareLocation(Loc.getBegin(), SM);
+  auto End = GetMacroAwareLocation(Loc.getEnd(), SM);
+  if (!Begin || !End)
+    return llvm::None;
+  return SourceRange(*Begin, *End);
+}
+
+template <typename LiteralType>
+llvm::Optional<NewSuffix> shouldReplaceLiteralSuffix(const Expr &Literal,
+                                                     const SourceManager &SM,
+                                                     const LangOptions &LO) {
+  NewSuffix ReplacementDsc;
+
+  const auto &L = cast<typename LiteralType::type>(Literal);
+
+  // The naive location of the literal. Is always valid.
+  ReplacementDsc.LiteralLocation = L.getLocation();
+
+  // Was this literal fully spelled or is it a product of macro expansion?
+  bool RangeCanBeFixed =
+      utils::rangeCanBeFixed(ReplacementDsc.LiteralLocation, &SM);
+
+  // The literal may have macro expansion, we need the final expanded src range.
+  auto Range = GetMacroAwareSourceRange(ReplacementDsc.LiteralLocation, SM);
+  if (!Range)
+    return llvm::None;
+
+  if (RangeCanBeFixed)
+    ReplacementDsc.LiteralLocation = Range->getBegin();
+  // Else keep the naive literal location!
+
+  // Get the whole literal from the source buffer.
+  bool Invalid;
+  const StringRef LiteralSourceText = Lexer::getSourceText(
+      CharSourceRange::getTokenRange(*Range), SM, LO, &Invalid);
+  assert(!Invalid && "Failed to retrieve the source text.");
+
+  size_t Skip = 0;
+
+  // Do we need to ignore something before actually looking for the suffix?
+  if (!LiteralType::SkipFirst.empty()) {
+    // E.g. we can't look for 'f' suffix in hexadecimal floating-point literals
+    // until after we skip to the exponent (which is mandatory there),
+    // because hex-digit-sequence may contain 'f'.
+    Skip = LiteralSourceText.find_first_of(LiteralType::SkipFirst);
+    // We could be in non-hexadecimal floating-point literal, with no exponent.
+    if (Skip == StringRef::npos)
+      Skip = 0;
+  }
+
+  // Find the beginning of the suffix by looking for the first char that is
+  // one of these chars that can be in the suffix, potentially starting looking
+  // in the exponent, if we are skipping hex-digit-sequence.
+  Skip = LiteralSourceText.find_first_of(LiteralType::Suffixes, /*From=*/Skip);
+  assert(
+      Skip != StringRef::npos &&
+      "we should not get here unless there was some suffix as per the type "
+      "system. Also, these two places should accept the same set of suffixes.");
+
+  // Move the cursor in the source range to the beginning of the suffix.
+  Range->setBegin(Range->getBegin().getLocWithOffset(Skip));
+  // And in our textual representation too.
+  ReplacementDsc.OldSuffix = LiteralSourceText.drop_front(Skip);
+  assert(!ReplacementDsc.OldSuffix.empty() &&
+         "We still should have some chars left.");
+
+  // And get the replacement suffix, with upper-case chars.
+  std::string NewSuffix = ReplacementDsc.OldSuffix.upper();
+  if (ReplacementDsc.OldSuffix == NewSuffix)
+    return llvm::None; // The suffix was already fully uppercase.
+
+  if (RangeCanBeFixed)
+    ReplacementDsc.FixIt = FixItHint::CreateReplacement(*Range, NewSuffix);
+
+  return ReplacementDsc;
+}
+
+} // namespace
+
+void UppercaseLiteralSuffixCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(
+      stmt(allOf(
+          eachOf(integerLiteral(intHasSuffix()).bind(IntegerLiteral::Name),
+                 floatLiteral(fpHasSuffix()).bind(FloatingLiteral::Name)),
+          unless(hasParent(userDefinedLiteral())))),
+      this);
+}
+
+template <typename LiteralType>
+bool UppercaseLiteralSuffixCheck::checkBoundMatch(
+    const MatchFinder::MatchResult &Result) {
+  const auto *Literal =
+      Result.Nodes.getNodeAs<typename LiteralType::type>(LiteralType::Name);
+  if (!Literal)
+    return false;
+
+  // We won't *always* want to diagnose. We might have already-uppercase suffix.
+  if (auto Details = shouldReplaceLiteralSuffix<LiteralType>(
+          *Literal, *Result.SourceManager, getLangOpts())) {
+    auto Complaint = diag(Details->LiteralLocation,
+                          "%0 literal has suffix '%1', which is not upper-case")
+                     << LiteralType::Name << Details->OldSuffix;
+    if (Details->FixIt) // Similarly, a fix-it is not always possible.
+      Complaint << *(Details->FixIt);
+  }
+
+  return true;
+}
+
+void UppercaseLiteralSuffixCheck::check(
+    const MatchFinder::MatchResult &Result) {
+  if (checkBoundMatch<IntegerLiteral>(Result))
+    return; // If it *was* IntegerLiteral, don't check for FloatingLiteral.
+  checkBoundMatch<FloatingLiteral>(Result);
+}
+
+} // namespace readability
+} // namespace tidy
+} // namespace clang

clang-tidy/utils/ASTUtils.h

 bool IsBinaryOrTernary(const Expr *E);
 
 /// Checks whether a macro flag is present in the given argument. Only considers
 /// cases of single match or match in a binary OR expression. For example,
 /// <needed-flag> or <flag> | <needed-flag> | ...
 bool exprHasBitFlagWithSpelling(const Expr *Flags, const SourceManager &SM,
                                 const LangOptions &LangOpts,
                                 StringRef FlagName);
+
+// Check if the range is entirely contained within a macro argument.
+bool rangeIsEntirelyWithinMacroArgument(SourceRange Range,
+                                        const SourceManager *SM);
+
+// Check if the range contains any locations from a macro expansion.
+bool rangeContainsMacroExpansion(SourceRange Range, const SourceManager *SM);
+
+// Can a fix-it be issued for this whole Range?
+// FIXME: false-negative if the entire range is fully expanded from a macro.
+bool rangeCanBeFixed(SourceRange Range, const SourceManager *SM);
+
 } // namespace utils
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ASTUTILS_H

clang-tidy/utils/ASTUtils.cpp

if (BO->getOpcode() == clang::BinaryOperatorKind::BO_Or)
                                         LangOpts, FlagName) ||
              exprHasBitFlagWithSpelling(BO->getRHS()->IgnoreParenCasts(), SM,
                                         LangOpts, FlagName);
 
   // Otherwise, assume it has the flag.
   return true;
 }
 
+bool rangeIsEntirelyWithinMacroArgument(SourceRange Range,
+                                        const SourceManager *SM) {
+  // Check if the range is entirely contained within a macro argument.
+  SourceLocation MacroArgExpansionStartForRangeBegin;
+  SourceLocation MacroArgExpansionStartForRangeEnd;
+  bool RangeIsEntirelyWithinMacroArgument =
+      SM &&
+      SM->isMacroArgExpansion(Range.getBegin(),
+                              &MacroArgExpansionStartForRangeBegin) &&
+      SM->isMacroArgExpansion(Range.getEnd(),
+                              &MacroArgExpansionStartForRangeEnd) &&
+      MacroArgExpansionStartForRangeBegin == MacroArgExpansionStartForRangeEnd;
+
+  return RangeIsEntirelyWithinMacroArgument;
+}
+
+bool rangeContainsMacroExpansion(SourceRange Range, const SourceManager *SM) {
+  return rangeIsEntirelyWithinMacroArgument(Range, SM) ||
+         Range.getBegin().isMacroID() || Range.getEnd().isMacroID();
+}
+
+bool rangeCanBeFixed(SourceRange Range, const SourceManager *SM) {
+  return utils::rangeIsEntirelyWithinMacroArgument(Range, SM) ||
+         !utils::rangeContainsMacroExpansion(Range, SM);
+}
+
 } // namespace utils
 } // namespace tidy
 } // namespace clang

docs/ReleaseNotes.rst

- New :doc:`abseil-redundant-strcat-calls
   being passed to another ``absl::StrCat`` or ``absl::StrAppend``.
 
 - New :doc:`abseil-str-cat-append
   <clang-tidy/checks/abseil-str-cat-append>` check.
 
   Flags uses of ``absl::StrCat()`` to append to a ``std::string``. Suggests
   ``absl::StrAppend()`` should be used instead.
 
 - New :doc:`modernize-concat-nested-namespaces
   <clang-tidy/checks/modernize-concat-nested-namespaces>` check.
 
   Checks for uses of nested namespaces in the form of
   ``namespace a { namespace b { ... }}`` and offers change to
   syntax introduced in C++17 standard: ``namespace a::b { ... }``.
 
 - New :doc:`readability-magic-numbers
   <clang-tidy/checks/readability-magic-numbers>` check.
 
   Detects usage of magic numbers, numbers that are used as literals instead of
   introduced via constants or symbols.
 
+- New :doc:`readability-uppercase-literal-suffix
+  <clang-tidy/checks/readability-uppercase-literal-suffix>` check.
+
+  Detects when the integral literal or floating point literal has non-uppercase
+  suffix, and suggests to make the suffix uppercase.
+
+- New alias :doc:`cert-dcl16-c
+  <clang-tidy/checks/cert-dcl16-c>` to :doc:`readability-uppercase-literal-suffix
+  <clang-tidy/checks/readability-uppercase-literal-suffix>`
+  added.
+
+- New alias :doc:`hicpp-uppercase-literal-suffix
+  <clang-tidy/checks/hicpp-uppercase-literal-suffix>` to
+  :doc:`readability-uppercase-literal-suffix
+  <clang-tidy/checks/readability-uppercase-literal-suffix>`
+  added.
+
 Improvements to include-fixer
 -----------------------------
 
 The improvements are...
 
 Improvements to modularize
 --------------------------
 
 The improvements are...

docs/clang-tidy/checks/cert-dcl16-c.rst

+.. title:: clang-tidy - cert-dcl16-c
+.. meta::
+   :http-equiv=refresh: 5;URL=readability-uppercase-literal-suffix.html
+
+cert-dcl16-c
+============
+
+The cert-dcl16-c check is an alias, please see
+`readability-uppercase-literal-suffix <readability-uppercase-literal-suffix.html>`_ for more information.

docs/clang-tidy/checks/hicpp-uppercase-literal-suffix.rst

+.. title:: clang-tidy - hicpp-uppercase-literal-suffix
+.. meta::
+   :http-equiv=refresh: 5;URL=readability-uppercase-literal-suffix.html
+
+hicpp-uppercase-literal-suffix
+==============================
+
+The hicpp-uppercase-literal-suffix check is an alias, please see
+`readability-uppercase-literal-suffix <readability-uppercase-literal-suffix.html>`_ for more information.

docs/clang-tidy/checks/list.rst

.. toctree::
    bugprone-terminating-continue
    bugprone-throw-keyword-missing
    bugprone-undefined-memory-manipulation
    bugprone-undelegated-constructor
    bugprone-unused-raii
    bugprone-unused-return-value
    bugprone-use-after-move
    bugprone-virtual-near-miss
    cert-dcl03-c (redirects to misc-static-assert) <cert-dcl03-c>
+   cert-dcl16-c (redirects to readability-uppercase-literal-suffix) <cert-dcl16-c>
    cert-dcl21-cpp
    cert-dcl50-cpp
    cert-dcl54-cpp (redirects to misc-new-delete-overloads) <cert-dcl54-cpp>
    cert-dcl58-cpp
    cert-dcl59-cpp (redirects to google-build-namespaces) <cert-dcl59-cpp>
    cert-env33-c
    cert-err09-cpp (redirects to misc-throw-by-value-catch-by-reference) <cert-err09-cpp>
    cert-err34-c
.. toctree::
    hicpp-use-auto (redirects to modernize-use-auto) <hicpp-use-auto>
    hicpp-use-emplace (redirects to modernize-use-emplace) <hicpp-use-emplace>
    hicpp-use-equals-default (redirects to modernize-use-equals-default) <hicpp-use-equals-default>
    hicpp-use-equals-delete (redirects to modernize-use-equals-delete) <hicpp-use-equals-delete>
    hicpp-use-noexcept (redirects to modernize-use-noexcept) <hicpp-use-noexcept>
    hicpp-use-nullptr (redirects to modernize-use-nullptr) <hicpp-use-nullptr>
    hicpp-use-override (redirects to modernize-use-override) <hicpp-use-override>
    hicpp-vararg (redirects to cppcoreguidelines-pro-type-vararg) <hicpp-vararg>
+   hicpp-uppercase-literal-suffix (redirects to readability-uppercase-literal-suffix) <hicpp-uppercase-literal-suffix>
    llvm-header-guard
    llvm-include-order
    llvm-namespace-comment
    llvm-twine-local
    misc-definitions-in-headers
    misc-misplaced-const
    misc-new-delete-overloads
    misc-non-copyable-objects
.. toctree::
    readability-redundant-string-cstr
    readability-redundant-string-init
    readability-simplify-boolean-expr
    readability-simplify-subscript-expr
    readability-static-accessed-through-instance
    readability-static-definition-in-anonymous-namespace
    readability-string-compare
    readability-uniqueptr-delete-release
+   readability-uppercase-literal-suffix
    zircon-temporary-objects

docs/clang-tidy/checks/readability-uppercase-literal-suffix.rst

+.. title:: clang-tidy - readability-uppercase-literal-suffix
+
+readability-uppercase-literal-suffix
+====================================
+
+`cert-dcl16-c` redirects here as an alias for this check.
+
+`hicpp-uppercase-literal-suffix` redirects here as an alias for this check.
+
+Detects when the integral literal or floating point (decimal or hexadecimal)
+literal has a non-uppercase suffix and provides a fix-it-hint
+with the uppercase suffix.
+
+All valid combinations of suffixes are supported.
+
+.. code:: c
+
+  auto x = 1;  // OK, no suffix.
+
+  auto x = 1u; // warning: integer literal suffix 'u' is not upper-case
+
+  auto x = 1U; // OK, suffix is uppercase.
+
+  ...

test/clang-tidy/readability-uppercase-literal-suffix-floating-point.cpp

+// RUN: %check_clang_tidy %s readability-uppercase-literal-suffix %t -- -- -I %S
+// RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp
+// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -fix -- -I %S
+// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -warnings-as-errors='-*,readability-uppercase-literal-suffix' -- -I %S
+
+#include "readability-uppercase-literal-suffix.h"
+
+void integer_suffix() {
+  static constexpr auto v0 = 1.; // no literal
+  static_assert(is_same<decltype(v0), const double>::value, "");
+  static_assert(v0 == 1., "");
+
+  static constexpr auto v1 = 1.e0; // no literal
+  static_assert(is_same<decltype(v1), const double>::value, "");
+  static_assert(v1 == 1., "");
+
+  // Float
+
+  static constexpr auto v2 = 1.f;
+  // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto v2 = 1.f;
+  // CHECK-MESSAGES-NEXT: ^ ~
+  // CHECK-MESSAGES-NEXT: {{^ *}}F{{$}}
+  // CHECK-FIXES: static constexpr auto v2 = 1.F;
+  static_assert(is_same<decltype(v2), const float>::value, "");
+  static_assert(v2 == 1.0F, "");
+
+  static constexpr auto v3 = 1.e0f;
+  // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto v3 = 1.e0f;
+  // CHECK-MESSAGES-NEXT: ^ ~
+  // CHECK-MESSAGES-NEXT: {{^ *}}F{{$}}
+  // CHECK-FIXES: static constexpr auto v3 = 1.e0F;
+  static_assert(is_same<decltype(v3), const float>::value, "");
+  static_assert(v3 == 1.0F, "");
+
+  static constexpr auto v4 = 1.F; // OK.
+  static_assert(is_same<decltype(v4), const float>::value, "");
+  static_assert(v4 == 1.0F, "");
+
+  static constexpr auto v5 = 1.e0F; // OK.
+  static_assert(is_same<decltype(v5), const float>::value, "");
+  static_assert(v5 == 1.0F, "");
+
+  // Long double
+
+  static constexpr auto v6 = 1.l;
+  // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'l', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto v6 = 1.l;
+  // CHECK-MESSAGES-NEXT: ^ ~
+  // CHECK-MESSAGES-NEXT: {{^ *}}L{{$}}
+  // CHECK-FIXES: static constexpr auto v6 = 1.L;
+  static_assert(is_same<decltype(v6), const long double>::value, "");
+  static_assert(v6 == 1., "");
+
+  static constexpr auto v7 = 1.e0l;
+  // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'l', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto v7 = 1.e0l;
+  // CHECK-MESSAGES-NEXT: ^ ~
+  // CHECK-MESSAGES-NEXT: {{^ *}}L{{$}}
+  // CHECK-FIXES: static constexpr auto v7 = 1.e0L;
+  static_assert(is_same<decltype(v7), const long double>::value, "");
+  static_assert(v7 == 1., "");
+
+  static constexpr auto v8 = 1.L; // OK.
+  static_assert(is_same<decltype(v8), const long double>::value, "");
+  static_assert(v8 == 1., "");
+
+  static constexpr auto v9 = 1.e0L; // OK.
+  static_assert(is_same<decltype(v9), const long double>::value, "");
+  static_assert(v9 == 1., "");
+}
+
+void macros() {
+#define PASSTHROUGH(X) X
+  static constexpr auto m0 = PASSTHROUGH(1.f);
+  // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: floating point literal has suffix 'f', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto m0 = PASSTHROUGH(1.f);
+  // CHECK-MESSAGES-NEXT: ^ ~
+  // CHECK-MESSAGES-NEXT: {{^ *}}F{{$}}
+  // CHECK-FIXES: static constexpr auto m0 = PASSTHROUGH(1.F);
+  static_assert(is_same<decltype(m0), const float>::value, "");
+  static_assert(m0 == 1.0F, "");
+}

test/clang-tidy/readability-uppercase-literal-suffix-hexadecimal-floating-point.cpp

+// RUN: %check_clang_tidy %s readability-uppercase-literal-suffix %t -- -- -I %S
+// RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp
+// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -fix -- -I %S
+// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -warnings-as-errors='-*,readability-uppercase-literal-suffix' -- -I %S
+
+#include "readability-uppercase-literal-suffix.h"
+
+void integer_suffix() {
+  static constexpr auto v0 = 0x0p0; // no literal
+  static_assert(is_same<decltype(v0), const double>::value, "");
+  static_assert(v0 == 0, "");
+
+  // Float
+
+  static constexpr auto v1 = 0xfp0f;
+  // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto v1 = 0xfp0f;
+  // CHECK-MESSAGES-NEXT: ^    ~
+  // CHECK-MESSAGES-NEXT: {{^ *}}F{{$}}
+  // CHECK-FIXES: static constexpr auto v1 = 0xfp0F;
+  static_assert(is_same<decltype(v1), const float>::value, "");
+  static_assert(v1 == 15, "");
+
+  static constexpr auto v2 = 0xfp0F; // OK
+  static_assert(is_same<decltype(v2), const float>::value, "");
+  static_assert(v2 == 15, "");
+
+  static constexpr auto v3 = 0xfP0f;
+  // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto v3 = 0xfP0f;
+  // CHECK-MESSAGES-NEXT: ^    ~
+  // CHECK-MESSAGES-NEXT: {{^ *}}F{{$}}
+  // CHECK-FIXES: static constexpr auto v3 = 0xfP0F;
+  static_assert(is_same<decltype(v3), const float>::value, "");
+  static_assert(v3 == 15, "");
+
+  static constexpr auto v4 = 0xfP0F; // OK
+  static_assert(is_same<decltype(v4), const float>::value, "");
+  static_assert(v4 == 15, "");
+
+  static constexpr auto v5 = 0xFP0f;
+  // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto v5 = 0xFP0f;
+  // CHECK-MESSAGES-NEXT: ^    ~
+  // CHECK-MESSAGES-NEXT: {{^ *}}F{{$}}
+  // CHECK-FIXES: static constexpr auto v5 = 0xFP0F;
+  static_assert(is_same<decltype(v5), const float>::value, "");
+  static_assert(v5 == 15, "");
+
+  static constexpr auto v6 = 0xFP0F; // OK
+  static_assert(is_same<decltype(v6), const float>::value, "");
+  static_assert(v6 == 15, "");
+
+  static constexpr auto v7 = 0xFp0f;
+  // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto v7 = 0xFp0f;
+  // CHECK-MESSAGES-NEXT: ^    ~
+  // CHECK-MESSAGES-NEXT: {{^ *}}F{{$}}
+  // CHECK-FIXES: static constexpr auto v7 = 0xFp0F;
+  static_assert(is_same<decltype(v7), const float>::value, "");
+  static_assert(v7 == 15, "");
+
+  static constexpr auto v8 = 0xFp0F; // OK
+  static_assert(is_same<decltype(v8), const float>::value, "");
+  static_assert(v8 == 15, "");
+}
+
+void macros() {
+#define PASSTHROUGH(X) X
+  static constexpr auto m0 = PASSTHROUGH(0x0p0f);
+  // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: floating point literal has suffix 'f', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto m0 = PASSTHROUGH(0x0p0f);
+  // CHECK-MESSAGES-NEXT: ^ ~
+  // CHECK-MESSAGES-NEXT: {{^ *}}F{{$}}
+  // CHECK-FIXES: static constexpr auto m0 = PASSTHROUGH(0x0p0F);
+  static_assert(is_same<decltype(m0), const float>::value, "");
+  static_assert(m0 == 0x0p0F, "");
+}

test/clang-tidy/readability-uppercase-literal-suffix-integer-macro.cpp

+// RUN: %check_clang_tidy %s readability-uppercase-literal-suffix %t -- -- -I %S
+
+void macros() {
+#define INMACRO(X) 1.f
+  static constexpr auto m1 = INMACRO();
+  // CHECK-NOTES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f', which is not upper-case
+  // CHECK-NOTES: :[[@LINE-3]]:20: note: expanded from macro 'INMACRO'
+  // CHECK-FIXES: #define INMACRO(X) 1.f
+  // CHECK-FIXES: static constexpr auto m1 = INMACRO();
+  // ^ so no fix-its here.
+}
+
+void horrible_macros() {
+#define MAKE_UNSIGNED(x) x##u
+#define ONE MAKE_UNSIGNED(1)
+  static constexpr auto hm0 = ONE;
+  // CHECK-NOTES: :[[@LINE-1]]:31: warning: integer literal has suffix 'u', which is not upper-case
+  // CHECK-NOTES: :[[@LINE-3]]:13: note: expanded from macro 'ONE'
+  // CHECK-NOTES: :[[@LINE-5]]:26: note: expanded from macro 'MAKE_UNSIGNED'
+  // CHECK-NOTES: note: expanded from here
+  // CHECK-FIXES: #define MAKE_UNSIGNED(x) x##u
+  // CHECK-FIXES: #define ONE MAKE_UNSIGNED(1)
+  // CHECK-FIXES: static constexpr auto hm0 = ONE;
+  // Certainly no fix-its.
+}

test/clang-tidy/readability-uppercase-literal-suffix-integer.cpp

+// RUN: %check_clang_tidy %s readability-uppercase-literal-suffix %t -- -- -I %S
+// RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp
+// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -fix -- -I %S
+// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -warnings-as-errors='-*,readability-uppercase-literal-suffix' -- -I %S
+
+#include "readability-uppercase-literal-suffix.h"
+
+void integer_suffix() {
+  static constexpr auto v0 = __LINE__; // synthetic
+  static_assert(v0 == 9 || v0 == 5, "");
+
+  static constexpr auto v1 = __cplusplus; // synthetic, long
+
+  static constexpr auto v2 = 1; // no literal
+  static_assert(is_same<decltype(v2), const int>::value, "");
+  static_assert(v2 == 1, "");
+
+  // Unsigned
+
+  static constexpr auto v3 = 1u;
+  // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'u', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto v3 = 1u;
+  // CHECK-MESSAGES-NEXT: ^~
+  // CHECK-MESSAGES-NEXT: {{^ *}}U{{$}}
+  // CHECK-FIXES: static constexpr auto v3 = 1U;
+  static_assert(is_same<decltype(v3), const unsigned int>::value, "");
+  static_assert(v3 == 1, "");
+
+  static constexpr auto v4 = 1U; // OK.
+  static_assert(is_same<decltype(v4), const unsigned int>::value, "");
+  static_assert(v4 == 1, "");
+
+  // Long
+
+  static constexpr auto v5 = 1l;
+  // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'l', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto v5 = 1l;
+  // CHECK-MESSAGES-NEXT: ^~
+  // CHECK-MESSAGES-NEXT: {{^ *}}L{{$}}
+  // CHECK-FIXES: static constexpr auto v5 = 1L;
+  static_assert(is_same<decltype(v5), const long>::value, "");
+  static_assert(v5 == 1, "");
+
+  static constexpr auto v6 = 1L; // OK.
+  static_assert(is_same<decltype(v6), const long>::value, "");
+  static_assert(v6 == 1, "");
+
+  // Long Long
+
+  static constexpr auto v7 = 1ll;
+  // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'll', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto v7 = 1ll;
+  // CHECK-MESSAGES-NEXT: ^~~
+  // CHECK-MESSAGES-NEXT: {{^ *}}LL{{$}}
+  // CHECK-FIXES: static constexpr auto v7 = 1LL;
+  static_assert(is_same<decltype(v7), const long long>::value, "");
+  static_assert(v7 == 1, "");
+
+  static constexpr auto v8 = 1LL; // OK.
+  static_assert(is_same<decltype(v8), const long long>::value, "");
+  static_assert(v8 == 1, "");
+
+  // Unsigned Long
+
+  static constexpr auto v9 = 1ul;
+  // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'ul', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto v9 = 1ul;
+  // CHECK-MESSAGES-NEXT: ^~~
+  // CHECK-MESSAGES-NEXT: {{^ *}}UL{{$}}
+  // CHECK-FIXES: static constexpr auto v9 = 1UL;
+  static_assert(is_same<decltype(v9), const unsigned long>::value, "");
+  static_assert(v9 == 1, "");
+
+  static constexpr auto v10 = 1uL;
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'uL', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto v10 = 1uL;
+  // CHECK-MESSAGES-NEXT: ^~~
+  // CHECK-MESSAGES-NEXT: {{^ *}}UL{{$}}
+  // CHECK-FIXES: static constexpr auto v10 = 1UL;
+  static_assert(is_same<decltype(v10), const unsigned long>::value, "");
+  static_assert(v10 == 1, "");
+
+  static constexpr auto v11 = 1Ul;
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'Ul', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto v11 = 1Ul;
+  // CHECK-MESSAGES-NEXT: ^~~
+  // CHECK-MESSAGES-NEXT: {{^ *}}UL{{$}}
+  // CHECK-FIXES: static constexpr auto v11 = 1UL;
+  static_assert(is_same<decltype(v11), const unsigned long>::value, "");
+  static_assert(v11 == 1, "");
+
+  static constexpr auto v12 = 1UL; // OK.
+  static_assert(is_same<decltype(v12), const unsigned long>::value, "");
+  static_assert(v12 == 1, "");
+
+  // Long Unsigned
+
+  static constexpr auto v13 = 1lu;
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'lu', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto v13 = 1lu;
+  // CHECK-MESSAGES-NEXT: ^~~
+  // CHECK-MESSAGES-NEXT: {{^ *}}LU{{$}}
+  // CHECK-FIXES: static constexpr auto v13 = 1LU;
+  static_assert(is_same<decltype(v13), const unsigned long>::value, "");
+  static_assert(v13 == 1, "");
+
+  static constexpr auto v14 = 1Lu;
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'Lu', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto v14 = 1Lu;
+  // CHECK-MESSAGES-NEXT: ^~~
+  // CHECK-MESSAGES-NEXT: {{^ *}}LU{{$}}
+  // CHECK-FIXES: static constexpr auto v14 = 1LU;
+  static_assert(is_same<decltype(v14), const unsigned long>::value, "");
+  static_assert(v14 == 1, "");
+
+  static constexpr auto v15 = 1lU;
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'lU', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto v15 = 1lU;
+  // CHECK-MESSAGES-NEXT: ^~~
+  // CHECK-MESSAGES-NEXT: {{^ *}}LU{{$}}
+  // CHECK-FIXES: static constexpr auto v15 = 1LU;
+  static_assert(is_same<decltype(v15), const unsigned long>::value, "");
+  static_assert(v15 == 1, "");
+
+  static constexpr auto v16 = 1LU; // OK.
+  static_assert(is_same<decltype(v16), const unsigned long>::value, "");
+  static_assert(v16 == 1, "");
+
+  // Unsigned Long Long
+
+  static constexpr auto v17 = 1ull;
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'ull', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto v17 = 1ull;
+  // CHECK-MESSAGES-NEXT: ^~~~
+  // CHECK-MESSAGES-NEXT: {{^ *}}ULL{{$}}
+  // CHECK-FIXES: static constexpr auto v17 = 1ULL;
+  static_assert(is_same<decltype(v17), const unsigned long long>::value, "");
+  static_assert(v17 == 1, "");
+
+  static constexpr auto v18 = 1uLL;
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'uLL', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto v18 = 1uLL;
+  // CHECK-MESSAGES-NEXT: ^~~~
+  // CHECK-MESSAGES-NEXT: {{^ *}}ULL{{$}}
+  // CHECK-FIXES: static constexpr auto v18 = 1ULL;
+  static_assert(is_same<decltype(v18), const unsigned long long>::value, "");
+  static_assert(v18 == 1, "");
+
+  static constexpr auto v19 = 1Ull;
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'Ull', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto v19 = 1Ull;
+  // CHECK-MESSAGES-NEXT: ^~~~
+  // CHECK-MESSAGES-NEXT: {{^ *}}ULL{{$}}
+  // CHECK-FIXES: static constexpr auto v19 = 1ULL;
+  static_assert(is_same<decltype(v19), const unsigned long long>::value, "");
+  static_assert(v19 == 1, "");
+
+  static constexpr auto v20 = 1ULL; // OK.
+  static_assert(is_same<decltype(v20), const unsigned long long>::value, "");
+  static_assert(v20 == 1, "");
+
+  // Long Long Unsigned
+
+  static constexpr auto v21 = 1llu;
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'llu', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto v21 = 1llu;
+  // CHECK-MESSAGES-NEXT: ^~~~
+  // CHECK-MESSAGES-NEXT: {{^ *}}LLU{{$}}
+  // CHECK-FIXES: static constexpr auto v21 = 1LLU;
+  static_assert(is_same<decltype(v21), const unsigned long long>::value, "");
+  static_assert(v21 == 1, "");
+
+  static constexpr auto v22 = 1LLu;
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'LLu', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto v22 = 1LLu;
+  // CHECK-MESSAGES-NEXT: ^~~~
+  // CHECK-MESSAGES-NEXT: {{^ *}}LLU{{$}}
+  // CHECK-FIXES: static constexpr auto v22 = 1LLU;
+  static_assert(is_same<decltype(v22), const unsigned long long>::value, "");
+  static_assert(v22 == 1, "");
+
+  static constexpr auto v23 = 1llU;
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'llU', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto v23 = 1llU;
+  // CHECK-MESSAGES-NEXT: ^~~~
+  // CHECK-MESSAGES-NEXT: {{^ *}}LLU{{$}}
+  // CHECK-FIXES: static constexpr auto v23 = 1LLU;
+  static_assert(is_same<decltype(v23), const unsigned long long>::value, "");
+  static_assert(v23 == 1, "");
+
+  static constexpr auto v24 = 1LLU; // OK.
+  static_assert(is_same<decltype(v24), const unsigned long long>::value, "");
+  static_assert(v24 == 1, "");
+}
+
+void macros() {
+#define PASSTHROUGH(X) X
+  static constexpr auto m0 = PASSTHROUGH(1u);
+  // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: integer literal has suffix 'u', which is not upper-case
+  // CHECK-MESSAGES-NEXT: static constexpr auto m0 = PASSTHROUGH(1u);
+  // CHECK-MESSAGES-NEXT: ^~
+  // CHECK-MESSAGES-NEXT: {{^ *}}U{{$}}
+  // CHECK-FIXES: static constexpr auto m0 = PASSTHROUGH(1U);
+  static_assert(is_same<decltype(m0), const unsigned int>::value, "");
+  static_assert(m0 == 1, "");
+}
+
+// Check that user-defined literals do not cause any diags.
+
+unsigned long long int operator"" _ull(unsigned long long int);
+void user_defined_literals() {
+  1_ull;
+}

test/clang-tidy/readability-uppercase-literal-suffix.h

+template <class T, T v>
+struct integral_constant {
+  static constexpr T value = v;
+  typedef T value_type;
+  typedef integral_constant type; // using injected-class-name
+  constexpr operator value_type() const noexcept { return value; }
+};
+
+using false_type = integral_constant<bool, false>;
+using true_type = integral_constant<bool, true>;
+
+template <class T, class U>
+struct is_same : false_type {};
+
+template <class T>
+struct is_same<T, T> : true_type {};