[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 ↗

(On Diff #167540)

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 ↗

(On Diff #167540)

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

26 ↗

(On Diff #167552)

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.

33 ↗

(On Diff #167552)

why are these declarations necessary?

42 ↗

(On Diff #167552)

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

52 ↗

(On Diff #167552)

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()).

53 ↗

(On Diff #167552)

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.

69 ↗

(On Diff #167552)

Same comment as above

85 ↗

(On Diff #167552)

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

90 ↗

(On Diff #167552)

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

95 ↗

(On Diff #167552)

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

106 ↗

(On Diff #167552)

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

129 ↗

(On Diff #167552)

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.

135 ↗

(On Diff #167552)

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.

152 ↗

(On Diff #167552)

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

165 ↗

(On Diff #167552)

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

165 ↗

(On Diff #167552)

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 ↗

(On Diff #167540)

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

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

9 ↗

(On Diff #167552)

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

26 ↗

(On Diff #167552)

nit: comparing int to double, same below.

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

6 ↗

(On Diff #167552)

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

31 ↗

(On Diff #167552)

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 ↗

(On Diff #167540)

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

33 ↗

(On Diff #167552)

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

42 ↗

(On Diff #167552)

Rewrote, hopefully better?

52 ↗

(On Diff #167552)

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

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

9 ↗

(On Diff #167552)

Words are the hardest part :)

[lebedev.ri]

clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp

53 ↗

(On Diff #167552)

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

85 ↗

(On Diff #167552)

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?

95 ↗

(On Diff #167552)

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.

129 ↗

(On Diff #167552)

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

135 ↗

(On Diff #167552)

bind() still wants the name though.

152 ↗

(On Diff #167552)

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..

165 ↗

(On Diff #167552)

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 ↗

(On Diff #167620)

spurious formatting fix, can be committed separate.

clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp

42 ↗

(On Diff #167552)

Yes, few nits.

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

52 ↗

(On Diff #167552)

fine then.

53 ↗

(On Diff #167552)

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

85 ↗

(On Diff #167552)

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.

152 ↗

(On Diff #167552)

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

165 ↗

(On Diff #167552)

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.

90 ↗

(On Diff #167620)

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

92 ↗

(On Diff #167620)

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

clang-tidy/utils/ASTUtils.cpp

70 ↗

(On Diff #167620)

Please add the missing . at the end of the sentence

docs/ReleaseNotes.rst

117 ↗

(On Diff #167620)

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

165 ↗

(On Diff #167552)

*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

53 ↗

(On Diff #167552)

I don't know?
I would guess no.

85 ↗

(On Diff #167552)

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

165 ↗

(On Diff #167552)

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

165 ↗

(On Diff #167552)

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

117 ↗

(On Diff #167658)

the comma is not necessary

119 ↗

(On Diff #167658)

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

122 ↗

(On Diff #167658)

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

192 ↗

(On Diff #167658)

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

clang-tidy/utils/ASTUtils.cpp

72 ↗

(On Diff #167658)

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 ↗

(On Diff #167658)

hicpp alias is missing here

[lebedev.ri]

Address review notes.

clang-tidy/readability/IdentifierNamingCheck.cpp

660–678 ↗

(On Diff #167658)

@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

165 ↗

(On Diff #167552)

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 ↗

(On Diff #167661)

Please keep this sorted alphabetically.

clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp

25 ↗

(On Diff #167661)

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 ↗

(On Diff #167661)

There are other suffixes for integer literals. See NumericLiteralParser.

37 ↗

(On Diff #167661)

Same naming concerns here.

47–48 ↗

(On Diff #167661)

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

99–100 ↗

(On Diff #167661)

Don't use auto here.

122 ↗

(On Diff #167661)

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

94 ↗

(On Diff #169554)

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

31–32 ↗

(On Diff #169556)

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

45 ↗

(On Diff #169556)

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

101 ↗

(On Diff #169556)

i -> I

212 ↗

(On Diff #169556)

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

216 ↗

(On Diff #169556)

upper-case -> uppercase

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

28 ↗

(On Diff #169556)

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 ↗

(On Diff #170045)

Don't use auto here.

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

6 ↗

(On Diff #170045)

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-tools-extra/trunk/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");
   }
+
+  ClangTidyOptions getModuleOptions() override {
+    ClangTidyOptions Options;
+    ClangTidyOptions::OptionMap &Opts = Options.CheckOptions;
+    Opts["cert-dcl16-c.NewSuffixes"] = "L;LL;LU;LLU";
+    return Options;
+  }
 };
 
 } // 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-tools-extra/trunk/clang-tidy/cert/CMakeLists.txt

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

clang-tools-extra/trunk/clang-tidy/hicpp/HICPPTidyModule.cpp

 #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-tools-extra/trunk/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-tools-extra/trunk/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-tools-extra/trunk/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<RedundantStringCStrCheck>(
         "readability-redundant-string-cstr");
     CheckFactories.registerCheck<RedundantStringInitCheck>(
         "readability-redundant-string-init");
     CheckFactories.registerCheck<SimplifyBooleanExprCheck>(
         "readability-simplify-boolean-expr");
     CheckFactories.registerCheck<UniqueptrDeleteReleaseCheck>(
         "readability-uniqueptr-delete-release");
+    CheckFactories.registerCheck<UppercaseLiteralSuffixCheck>(
+        "readability-uppercase-literal-suffix");
   }
 };
 
 // Register the ReadabilityModule using this statically initialized variable.
 static ClangTidyModuleRegistry::Add<ReadabilityModule>
     X("readability-module", "Adds readability-related checks.");
 
 } // namespace readability
 
 // This anchor is used to force the linker to link in the generated object file
 // and thus register the ReadabilityModule.
 volatile int ReadabilityModuleAnchorSource = 0;
 
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/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"
+#include "../utils/OptionsUtils.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.
+/// Alternatively, a list of destination suffixes can be provided.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/readability-uppercase-literal-suffix.html
+class UppercaseLiteralSuffixCheck : public ClangTidyCheck {
+public:
+  UppercaseLiteralSuffixCheck(StringRef Name, ClangTidyContext *Context);
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+
+private:
+  template <typename LiteralType>
+  bool checkBoundMatch(const ast_matchers::MatchFinder::MatchResult &Result);
+
+  const std::vector<std::string> NewSuffixes;
+};
+
+} // namespace readability
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_UPPERCASELITERALSUFFIXCHECK_H

clang-tools-extra/trunk/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 "../utils/OptionsUtils.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 IntegerLiteralCheck {
+  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("");
+  // Suffix can only consist of 'u' and 'l' chars, and can be a complex number
+  // ('i', 'j'). In MS compatibility mode, suffixes like i32 are supported.
+  static constexpr llvm::StringLiteral Suffixes =
+      llvm::StringLiteral("uUlLiIjJ");
+};
+constexpr llvm::StringLiteral IntegerLiteralCheck::Name;
+constexpr llvm::StringLiteral IntegerLiteralCheck::SkipFirst;
+constexpr llvm::StringLiteral IntegerLiteralCheck::Suffixes;
+
+struct FloatingLiteralCheck {
+  using type = clang::FloatingLiteral;
+  static constexpr llvm::StringLiteral Name =
+      llvm::StringLiteral("floating point");
+  // C++17 introduced hexadecimal floating-point literals, and 'f' is both a
+  // valid hexadecimal digit in a hex float literal and a valid floating-point
+  // literal 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");
+  // Suffix can only consist of 'f', 'l', "f16", 'h', 'q' chars,
+  // and can be a complex number ('i', 'j').
+  static constexpr llvm::StringLiteral Suffixes =
+      llvm::StringLiteral("fFlLhHqQiIjJ");
+};
+constexpr llvm::StringLiteral FloatingLiteralCheck::Name;
+constexpr llvm::StringLiteral FloatingLiteralCheck::SkipFirst;
+constexpr llvm::StringLiteral FloatingLiteralCheck::Suffixes;
+
+struct NewSuffix {
+  SourceRange 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) {
+  llvm::Optional<SourceLocation> Begin =
+      GetMacroAwareLocation(Loc.getBegin(), SM);
+  llvm::Optional<SourceLocation> End = GetMacroAwareLocation(Loc.getEnd(), SM);
+  if (!Begin || !End)
+    return llvm::None;
+  return SourceRange(*Begin, *End);
+}
+
+llvm::Optional<std::string>
+getNewSuffix(llvm::StringRef OldSuffix,
+             const std::vector<std::string> &NewSuffixes) {
+  // If there is no config, just uppercase the entirety of the suffix.
+  if (NewSuffixes.empty())
+    return OldSuffix.upper();
+  // Else, find matching suffix, case-*insensitive*ly.
+  auto NewSuffix = llvm::find_if(
+      NewSuffixes, [OldSuffix](const std::string &PotentialNewSuffix) {
+        return OldSuffix.equals_lower(PotentialNewSuffix);
+      });
+  // Have a match, return it.
+  if (NewSuffix != NewSuffixes.end())
+    return *NewSuffix;
+  // Nope, I guess we have to keep it as-is.
+  return llvm::None;
+}
+
+template <typename LiteralType>
+llvm::Optional<NewSuffix>
+shouldReplaceLiteralSuffix(const Expr &Literal,
+                           const std::vector<std::string> &NewSuffixes,
+                           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.getSourceRange();
+
+  // 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.
+  llvm::Optional<SourceRange> Range =
+      GetMacroAwareSourceRange(ReplacementDsc.LiteralLocation, SM);
+  if (!Range)
+    return llvm::None;
+
+  if (RangeCanBeFixed)
+    ReplacementDsc.LiteralLocation = *Range;
+  // 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);
+
+  // We can't check whether the *Literal has any suffix or not without actually
+  // looking for the suffix. So it is totally possible that there is no suffix.
+  if (Skip == StringRef::npos)
+    return llvm::None;
+
+  // 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.
+  llvm::Optional<std::string> NewSuffix =
+      getNewSuffix(ReplacementDsc.OldSuffix, NewSuffixes);
+  if (!NewSuffix || ReplacementDsc.OldSuffix == *NewSuffix)
+    return llvm::None; // The suffix was already the way it should be.
+
+  if (RangeCanBeFixed)
+    ReplacementDsc.FixIt = FixItHint::CreateReplacement(*Range, *NewSuffix);
+
+  return ReplacementDsc;
+}
+
+} // namespace
+
+UppercaseLiteralSuffixCheck::UppercaseLiteralSuffixCheck(
+    StringRef Name, ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context),
+      NewSuffixes(
+          utils::options::parseStringList(Options.get("NewSuffixes", ""))) {}
+
+void UppercaseLiteralSuffixCheck::storeOptions(
+    ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "NewSuffixes",
+                utils::options::serializeStringList(NewSuffixes));
+}
+
+void UppercaseLiteralSuffixCheck::registerMatchers(MatchFinder *Finder) {
+  // Sadly, we can't check whether the literal has sufix or not.
+  // E.g. i32 suffix still results in 'BuiltinType::Kind::Int'.
+  // And such an info is not stored in the *Literal itself.
+  Finder->addMatcher(
+      stmt(allOf(eachOf(integerLiteral().bind(IntegerLiteralCheck::Name),
+                        floatLiteral().bind(FloatingLiteralCheck::Name)),
+                 unless(anyOf(hasParent(userDefinedLiteral()),
+                              hasAncestor(isImplicit()),
+                              hasAncestor(substNonTypeTemplateParmExpr()))))),
+      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 a suffix that is already uppercase.
+  if (auto Details = shouldReplaceLiteralSuffix<LiteralType>(
+          *Literal, NewSuffixes, *Result.SourceManager, getLangOpts())) {
+    auto Complaint = diag(Details->LiteralLocation.getBegin(),
+                          "%0 literal has suffix '%1', which is not uppercase")
+                     << 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<IntegerLiteralCheck>(Result))
+    return; // If it *was* IntegerLiteral, don't check for FloatingLiteral.
+  checkBoundMatch<FloatingLiteralCheck>(Result);
+}
+
+} // namespace readability
+} // namespace tidy
+} // namespace clang

clang-tools-extra/trunk/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-tools-extra/trunk/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

clang-tools-extra/trunk/docs/ReleaseNotes.rst

- New :doc:`modernize-deprecated-ios-base-aliases
   those that have a non-deprecated equivalent.
 
 - 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. The list of destination
+  suffixes can be optionally provided.
+
+- 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:`cppcoreguidelines-non-private-member-variables-in-classes
   <clang-tidy/checks/cppcoreguidelines-non-private-member-variables-in-classes>`
   to :doc:`misc-non-private-member-variables-in-classes
   <clang-tidy/checks/misc-non-private-member-variables-in-classes>`
   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.
+
 - The :doc:`readability-redundant-smartptr-get
   <clang-tidy/checks/readability-redundant-smartptr-get>` check does not warn
   about calls inside macros anymore by default.
 
 Improvements to include-fixer
 -----------------------------
 
 The improvements are...
 
 Improvements to modularize
 --------------------------
 
 The improvements are...

clang-tools-extra/trunk/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.

clang-tools-extra/trunk/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.

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

.. toctree::
    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

clang-tools-extra/trunk/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.
+By default, only the suffixes that begin with 'l' ("l", "ll", "lu", "llu",
+but not "u", "ul", "ull") are diagnosed by that alias.
+
+`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.
+
+  ...
+
+Optionally, a list of the destination suffixes can be provided.
+When the suffix is found, a case-insensitive lookup in that list is made,
+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.
+
+For example, given a list ``L;uL``:
+* ``l`` -> ``L``
+* ``L`` will be kept as is.
+* ``ul`` -> ``uL``
+* ``Ul`` -> ``uL``
+* ``UL`` -> ``uL``
+* ``uL`` will be kept as is.
+* ``ull`` will be kept as is, since it is not in the list
+* and so on.

clang-tools-extra/trunk/test/clang-tidy/cert-uppercase-literal-suffix-integer.cpp

+// RUN: %check_clang_tidy %s cert-dcl16-c %t -- -- -I %S
+// RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp
+// RUN: clang-tidy %t.cpp -checks='-*,cert-dcl16-c' -fix -- -I %S
+// RUN: clang-tidy %t.cpp -checks='-*,cert-dcl16-c' -warnings-as-errors='-*,cert-dcl16-c' -- -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;
+  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 uppercase
+  // 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 uppercase
+  // 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;
+  static_assert(is_same<decltype(v9), const unsigned long>::value, "");
+  static_assert(v9 == 1, "");
+
+  static constexpr auto v10 = 1uL;
+  static_assert(is_same<decltype(v10), const unsigned long>::value, "");
+  static_assert(v10 == 1, "");
+
+  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 uppercase
+  // 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 uppercase
+  // 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 uppercase
+  // 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;
+  static_assert(is_same<decltype(v17), const unsigned long long>::value, "");
+  static_assert(v17 == 1, "");
+
+  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;
+  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 uppercase
+  // 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 uppercase
+  // 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 uppercase
+  // 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, "");
+}

clang-tools-extra/trunk/test/clang-tidy/readability-uppercase-literal-suffix-floating-point-opencl-half.cpp

+// RUN: %check_clang_tidy %s readability-uppercase-literal-suffix %t -- -- -target x86_64-pc-linux-gnu -I %S -std=cl2.0 -x cl
+// RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp
+// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -fix -- -target x86_64-pc-linux-gnu -I %S -std=cl2.0 -x cl
+// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -warnings-as-errors='-*,readability-uppercase-literal-suffix' -- -target x86_64-pc-linux-gnu -I %S -std=cl2.0 -x cl
+
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+
+void floating_point_half_suffix() {
+  static half v0 = 0x0p0; // no literal
+
+  // half
+
+  static half v2 = 1.h;
+  // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: floating point literal has suffix 'h', which is not uppercase
+  // CHECK-MESSAGES-NEXT: static half v2 = 1.h;
+  // CHECK-MESSAGES-NEXT: ^ ~
+  // CHECK-MESSAGES-NEXT: {{^ *}}H{{$}}
+  // CHECK-HIXES: static half v2 = 1.H;
+
+  static half v3 = 1.e0h;
+  // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: floating point literal has suffix 'h', which is not uppercase
+  // CHECK-MESSAGES-NEXT: static half v3 = 1.e0h;
+  // CHECK-MESSAGES-NEXT: ^ ~
+  // CHECK-MESSAGES-NEXT: {{^ *}}H{{$}}
+  // CHECK-HIXES: static half v3 = 1.e0H;
+
+  static half v4 = 1.H; // OK.
+
+  static half v5 = 1.e0H; // OK.
+}

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

+// RUN: %check_clang_tidy %s readability-uppercase-literal-suffix %t -- -- -target x86_64-pc-linux-gnu -I %S
+// RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp
+// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -fix -- -target x86_64-pc-linux-gnu -I %S
+// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -warnings-as-errors='-*,readability-uppercase-literal-suffix' -- -target x86_64-pc-linux-gnu -I %S
+
+#include "readability-uppercase-literal-suffix.h"
+
+void floating_point_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 uppercase
+  // 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 uppercase
+  // 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 uppercase
+  // 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 uppercase
+  // 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., "");
+
+  // __float128
+
+  static constexpr auto v10 = 1.q;
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'q', which is not uppercase
+  // CHECK-MESSAGES-NEXT: static constexpr auto v10 = 1.q;
+  // CHECK-MESSAGES-NEXT: ^ ~
+  // CHECK-MESSAGES-NEXT: {{^ *}}Q{{$}}
+  // CHECK-FIXES: static constexpr auto v10 = 1.Q;
+  static_assert(is_same<decltype(v10), const __float128>::value, "");
+  static_assert(v10 == 1., "");
+
+  static constexpr auto v11 = 1.e0q;
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'q', which is not uppercase
+  // CHECK-MESSAGES-NEXT: static constexpr auto v11 = 1.e0q;
+  // CHECK-MESSAGES-NEXT: ^ ~
+  // CHECK-MESSAGES-NEXT: {{^ *}}Q{{$}}
+  // CHECK-FIXES: static constexpr auto v11 = 1.e0Q;
+  static_assert(is_same<decltype(v11), const __float128>::value, "");
+  static_assert(v11 == 1., "");
+
+  static constexpr auto v12 = 1.Q; // OK.
+  static_assert(is_same<decltype(v12), const __float128>::value, "");
+  static_assert(v12 == 1., "");
+
+  static constexpr auto v13 = 1.e0Q; // OK.
+  static_assert(is_same<decltype(v13), const __float128>::value, "");
+  static_assert(v13 == 1., "");
+
+  // _Float16
+
+  static constexpr auto v14 = 1.f16;
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'f16', which is not uppercase
+  // CHECK-MESSAGES-NEXT: static constexpr auto v14 = 1.f16;
+  // CHECK-MESSAGES-NEXT: ^ ~
+  // CHECK-MESSAGES-NEXT: {{^ *}}F16{{$}}
+  // CHECK-FIXES: static constexpr auto v14 = 1.F16;
+  static_assert(is_same<decltype(v14), const _Float16>::value, "");
+  static_assert(v14 == 1.F16, "");
+
+  static constexpr auto v15 = 1.e0f16;
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'f16', which is not uppercase
+  // CHECK-MESSAGES-NEXT: static constexpr auto v15 = 1.e0f16;
+  // CHECK-MESSAGES-NEXT: ^ ~
+  // CHECK-MESSAGES-NEXT: {{^ *}}F16{{$}}
+  // CHECK-FIXES: static constexpr auto v15 = 1.e0F16;
+  static_assert(is_same<decltype(v15), const _Float16>::value, "");
+  static_assert(v15 == 1.F16, "");
+
+  static constexpr auto v16 = 1.F16; // OK.
+  static_assert(is_same<decltype(v16), const _Float16>::value, "");
+  static_assert(v16 == 1.F16, "");
+
+  static constexpr auto v17 = 1.e0F16; // OK.
+  static_assert(is_same<decltype(v17), const _Float16>::value, "");
+  static_assert(v17 == 1.F16, "");
+}
+
+void floating_point_complex_suffix() {
+  // _Complex, I
+
+  static constexpr auto v14 = 1.i;
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'i', which is not uppercase
+  // CHECK-MESSAGES-NEXT: static constexpr auto v14 = 1.i;
+  // CHECK-MESSAGES-NEXT: ^ ~
+  // CHECK-MESSAGES-NEXT: {{^ *}}I{{$}}
+  // CHECK-FIXES: static constexpr auto v14 = 1.I;
+  static_assert(is_same<decltype(v14), const _Complex double>::value, "");
+  static_assert(v14 == 1.I, "");
+
+  static constexpr auto v15 = 1.e0i;
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'i', which is not uppercase
+  // CHECK-MESSAGES-NEXT: static constexpr auto v15 = 1.e0i;
+  // CHECK-MESSAGES-NEXT: ^ ~
+  // CHECK-MESSAGES-NEXT: {{^ *}}I{{$}}
+  // CHECK-FIXES: static constexpr auto v15 = 1.e0I;
+  static_assert(is_same<decltype(v15), const _Complex double>::value, "");
+  static_assert(v15 == 1.I, "");
+
+  static constexpr auto v16 = 1.I; // OK.
+  static_assert(is_same<decltype(v16), const _Complex double>::value, "");
+  static_assert(v16 == 1.I, "");
+
+  static constexpr auto v17 = 1.e0I; // OK.
+  static_assert(is_same<decltype(v17), const _Complex double>::value, "");
+  static_assert(v17 == 1.I, "");
+
+  // _Complex, J
+
+  static constexpr auto v18 = 1.j;
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'j', which is not uppercase
+  // CHECK-MESSAGES-NEXT: static constexpr auto v18 = 1.j;
+  // CHECK-MESSAGES-NEXT: ^ ~
+  // CHECK-MESSAGES-NEXT: {{^ *}}J{{$}}
+  // CHECK-FIXES: static constexpr auto v18 = 1.J;
+  static_assert(is_same<decltype(v18), const _Complex double>::value, "");
+  static_assert(v18 == 1.J, "");
+
+  static constexpr auto v19 = 1.e0j;
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'j', which is not uppercase
+  // CHECK-MESSAGES-NEXT: static constexpr auto v19 = 1.e0j;
+  // CHECK-MESSAGES-NEXT: ^ ~
+  // CHECK-MESSAGES-NEXT: {{^ *}}J{{$}}
+  // CHECK-FIXES: static constexpr auto v19 = 1.e0J;
+  static_assert(is_same<decltype(v19), const _Complex double>::value, "");
+  static_assert(v19 == 1.J, "");
+
+  static constexpr auto v20 = 1.J; // OK.
+  static_assert(is_same<decltype(v20), const _Complex double>::value, "");
+  static_assert(v20 == 1.J, "");
+
+  static constexpr auto v21 = 1.e0J; // OK.
+  static_assert(is_same<decltype(v21), const _Complex double>::value, "");
+  static_assert(v21 == 1.J, "");
+}
+
+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 uppercase
+  // 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, "");
+}

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

+// RUN: %check_clang_tidy %s readability-uppercase-literal-suffix %t -- -- -target x86_64-pc-linux-gnu -I %S
+// RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp
+// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -fix -- -target x86_64-pc-linux-gnu -I %S
+// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -warnings-as-errors='-*,readability-uppercase-literal-suffix' -- -target x86_64-pc-linux-gnu -I %S
+
+#include "readability-uppercase-literal-suffix.h"
+
+void floating_point_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 uppercase
+  // 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 uppercase
+  // 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 uppercase
+  // 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 uppercase
+  // 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, "");
+
+  // long double
+
+  static constexpr auto v9 = 0xfp0l;
+  // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'l', which is not uppercase
+  // CHECK-MESSAGES-NEXT: static constexpr auto v9 = 0xfp0l;
+  // CHECK-MESSAGES-NEXT: ^    ~
+  // CHECK-MESSAGES-NEXT: {{^ *}}L{{$}}
+  // CHECK-FIXES: static constexpr auto v9 = 0xfp0L;
+  static_assert(is_same<decltype(v9), const long double>::value, "");
+  static_assert(v9 == 0xfp0, "");
+
+  static constexpr auto v10 = 0xfp0L; // OK.
+  static_assert(is_same<decltype(v10), const long double>::value, "");
+  static_assert(v10 == 0xfp0, "");
+
+  // __float128
+
+  static constexpr auto v11 = 0xfp0q;
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'q', which is not uppercase
+  // CHECK-MESSAGES-NEXT: static constexpr auto v11 = 0xfp0q;
+  // CHECK-MESSAGES-NEXT: ^    ~
+  // CHECK-MESSAGES-NEXT: {{^ *}}Q{{$}}
+  // CHECK-FIXES: static constexpr auto v11 = 0xfp0Q;
+  static_assert(is_same<decltype(v11), const __float128>::value, "");
+  static_assert(v11 == 0xfp0, "");
+
+  static constexpr auto v12 = 0xfp0Q; // OK.
+  static_assert(is_same<decltype(v12), const __float128>::value, "");
+  static_assert(v12 == 0xfp0, "");
+
+  // _Float16
+
+  static constexpr auto v13 = 0xfp0f16;
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'f16', which is not uppercase
+  // CHECK-MESSAGES-NEXT: static constexpr auto v13 = 0xfp0f16;
+  // CHECK-MESSAGES-NEXT: ^    ~
+  // CHECK-MESSAGES-NEXT: {{^ *}}F16{{$}}
+  // CHECK-FIXES: static constexpr auto v13 = 0xfp0F16;
+  static_assert(is_same<decltype(v13), const _Float16>::value, "");
+  static_assert(v13 == 0xfp0F16, "");
+
+  static constexpr auto v14 = 0xfp0F16; // OK.
+  static_assert(is_same<decltype(v14), const _Float16>::value, "");
+  static_assert(v14 == 0xfp0F16, "");
+}
+
+void floating_point_complex_suffix() {
+  // _Complex, I
+
+  static constexpr auto v14 = 0xfp0i;
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'i', which is not uppercase
+  // CHECK-MESSAGES-NEXT: static constexpr auto v14 = 0xfp0i;
+  // CHECK-MESSAGES-NEXT: ^    ~
+  // CHECK-MESSAGES-NEXT: {{^ *}}I{{$}}
+  // CHECK-FIXES: static constexpr auto v14 = 0xfp0I;
+  static_assert(is_same<decltype(v14), const _Complex double>::value, "");
+  static_assert(v14 == 0xfp0I, "");
+
+  static constexpr auto v16 = 0xfp0I; // OK.
+  static_assert(is_same<decltype(v16), const _Complex double>::value, "");
+  static_assert(v16 == 0xfp0I, "");
+
+  // _Complex, J
+
+  static constexpr auto v18 = 0xfp0j;
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'j', which is not uppercase
+  // CHECK-MESSAGES-NEXT: static constexpr auto v18 = 0xfp0j;
+  // CHECK-MESSAGES-NEXT: ^    ~
+  // CHECK-MESSAGES-NEXT: {{^ *}}J{{$}}
+  // CHECK-FIXES: static constexpr auto v18 = 0xfp0J;
+  static_assert(is_same<decltype(v18), const _Complex double>::value, "");
+  static_assert(v18 == 0xfp0J, "");
+
+  static constexpr auto v20 = 0xfp0J; // OK.
+  static_assert(is_same<decltype(v20), const _Complex double>::value, "");
+  static_assert(v20 == 0xfp0J, "");
+}
+
+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 uppercase
+  // 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, "");
+}

clang-tools-extra/trunk/test/clang-tidy/readability-uppercase-literal-suffix-integer-custom-list.cpp

+// RUN: %check_clang_tidy %s readability-uppercase-literal-suffix %t -- -config="{CheckOptions: [{key: readability-uppercase-literal-suffix.NewSuffixes, value: 'L;uL'}]}" -- -I %S
+// RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp
+// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -fix -config="{CheckOptions: [{key: readability-uppercase-literal-suffix.NewSuffixes, value: 'L;uL'}]}" -- -I %S
+// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -warnings-as-errors='-*,readability-uppercase-literal-suffix' -config="{CheckOptions: [{key: readability-uppercase-literal-suffix.NewSuffixes, value: 'L;uL'}]}" -- -I %S
+
+#include "readability-uppercase-literal-suffix.h"
+
+void integer_suffix() {
+  // Unsigned
+
+  static constexpr auto v3 = 1u; // OK.
+  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 uppercase
+  // 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; // OK.
+  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 uppercase
+  // 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; // OK.
+  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 uppercase
+  // 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.
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'UL', which is not uppercase
+  // CHECK-MESSAGES-NEXT: static constexpr auto v12 = 1UL;
+  // CHECK-MESSAGES-NEXT: ^~~
+  // CHECK-MESSAGES-NEXT: {{^ *}}uL{{$}}
+  // CHECK-FIXES: static constexpr auto v12 = 1uL;
+  static_assert(is_same<decltype(v12), const unsigned long>::value, "");
+  static_assert(v12 == 1, "");
+
+  // Long Unsigned
+
+  static constexpr auto v13 = 1lu; // OK.
+  static_assert(is_same<decltype(v13), const unsigned long>::value, "");
+  static_assert(v13 == 1, "");
+
+  static constexpr auto v14 = 1Lu; // OK.
+  static_assert(is_same<decltype(v14), const unsigned long>::value, "");
+  static_assert(v14 == 1, "");
+
+  static constexpr auto v15 = 1lU; // OK.
+  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; // OK.
+  static_assert(is_same<decltype(v17), const unsigned long long>::value, "");
+  static_assert(v17 == 1, "");
+
+  static constexpr auto v18 = 1uLL; // OK.
+  static_assert(is_same<decltype(v18), const unsigned long long>::value, "");
+  static_assert(v18 == 1, "");
+
+  static constexpr auto v19 = 1Ull; // OK.
+  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; // OK.
+  static_assert(is_same<decltype(v21), const unsigned long long>::value, "");
+  static_assert(v21 == 1, "");
+
+  static constexpr auto v22 = 1LLu; // OK.
+  static_assert(is_same<decltype(v22), const unsigned long long>::value, "");
+  static_assert(v22 == 1, "");
+
+  static constexpr auto v23 = 1llU; // OK.
+  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, "");
+}

clang-tools-extra/trunk/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 uppercase
+  // 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 uppercase
+  // 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.
+}

clang-tools-extra/trunk/test/clang-tidy/readability-uppercase-literal-suffix-integer-ms.cpp

+// RUN: %check_clang_tidy %s readability-uppercase-literal-suffix %t -- -- -target x86_64-pc-linux-gnu -I %S -fms-extensions
+// RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp
+// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -fix -- -target x86_64-pc-linux-gnu -I %S -fms-extensions
+// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -warnings-as-errors='-*,readability-uppercase-literal-suffix' -- -target x86_64-pc-linux-gnu -I %S -fms-extensions
+
+#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, "");
+
+  // i32
+
+  static constexpr auto v3 = 1i32;
+  // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'i32', which is not uppercase
+  // CHECK-MESSAGES-NEXT: static constexpr auto v3 = 1i32;
+  // CHECK-MESSAGES-NEXT: ^~
+  // CHECK-MESSAGES-NEXT: {{^ *}}I32{{$}}
+  // CHECK-FIXES: static constexpr auto v3 = 1I32;
+  static_assert(is_same<decltype(v3), const int>::value, "");
+  static_assert(v3 == 1I32, "");
+
+  static constexpr auto v4 = 1I32; // OK.
+  static_assert(is_same<decltype(v4), const int>::value, "");
+  static_assert(v4 == 1I32, "");
+
+  // i64
+
+  static constexpr auto v5 = 1i64;
+  // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'i64', which is not uppercase
+  // CHECK-MESSAGES-NEXT: static constexpr auto v5 = 1i64;
+  // CHECK-MESSAGES-NEXT: ^~
+  // CHECK-MESSAGES-NEXT: {{^ *}}I64{{$}}
+  // CHECK-FIXES: static constexpr auto v5 = 1I64;
+  static_assert(is_same<decltype(v5), const long int>::value, "");
+  static_assert(v5 == 1I64, "");
+
+  static constexpr auto v6 = 1I64; // OK.
+  static_assert(is_same<decltype(v6), const long int>::value, "");
+  static_assert(v6 == 1I64, "");
+
+  // i16
+
+  static constexpr auto v7 = 1i16;
+  // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'i16', which is not uppercase
+  // CHECK-MESSAGES-NEXT: static constexpr auto v7 = 1i16;
+  // CHECK-MESSAGES-NEXT: ^~
+  // CHECK-MESSAGES-NEXT: {{^ *}}I16{{$}}
+  // CHECK-FIXES: static constexpr auto v7 = 1I16;
+  static_assert(is_same<decltype(v7), const short>::value, "");
+  static_assert(v7 == 1I16, "");
+
+  static constexpr auto v8 = 1I16; // OK.
+  static_assert(is_same<decltype(v8), const short>::value, "");
+  static_assert(v8 == 1I16, "");
+
+  // i8
+
+  static constexpr auto v9 = 1i8;
+  // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'i8', which is not uppercase
+  // CHECK-MESSAGES-NEXT: static constexpr auto v9 = 1i8;
+  // CHECK-MESSAGES-NEXT: ^~
+  // CHECK-MESSAGES-NEXT: {{^ *}}I8{{$}}
+  // CHECK-FIXES: static constexpr auto v9 = 1I8;
+  static_assert(is_same<decltype(v9), const char>::value, "");
+  static_assert(v9 == 1I8, "");
+
+  static constexpr auto v10 = 1I8; // OK.
+  static_assert(is_same<decltype(v10), const char>::value, "");
+  static_assert(v10 == 1I8, "");
+}

clang-tools-extra/trunk/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 uppercase
+  // 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 uppercase
+  // 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 uppercase
+  // 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 uppercase
+  // 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 uppercase
+  // 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 uppercase
+  // 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 uppercase
+  // 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 uppercase
+  // 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 uppercase
+  // 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 uppercase
+  // 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 uppercase
+  // 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 uppercase
+  // 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 uppercase
+  // 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 uppercase
+  // 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 uppercase
+  // 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 integer_complex_suffix() {
+  // _Complex, I
+
+  static constexpr auto v25 = 1i;
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'i', which is not uppercase
+  // CHECK-MESSAGES-NEXT: static constexpr auto v25 = 1i;
+  // CHECK-MESSAGES-NEXT: ^~
+  // CHECK-MESSAGES-NEXT: {{^ *}}I{{$}}
+  // CHECK-FIXES: static constexpr auto v25 = 1I;
+  static_assert(is_same<decltype(v25), const _Complex int>::value, "");
+  static_assert(v25 == 1I, "");
+
+  static constexpr auto v26 = 1I; // OK.
+  static_assert(is_same<decltype(v26), const _Complex int>::value, "");
+  static_assert(v26 == 1I, "");
+
+  // _Complex, J
+
+  static constexpr auto v27 = 1j;
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'j', which is not uppercase
+  // CHECK-MESSAGES-NEXT: static constexpr auto v27 = 1j;
+  // CHECK-MESSAGES-NEXT: ^~
+  // CHECK-MESSAGES-NEXT: {{^ *}}J{{$}}
+  // CHECK-FIXES: static constexpr auto v27 = 1J;
+  static_assert(is_same<decltype(v27), const _Complex int>::value, "");
+  static_assert(v27 == 1J, "");
+
+  static constexpr auto v28 = 1J; // OK.
+  static_assert(is_same<decltype(v28), const _Complex int>::value, "");
+  static_assert(v28 == 1J, "");
+}
+
+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 uppercase
+  // 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;
+}
+
+template <unsigned alignment>
+void template_test() {
+  static_assert(alignment, "");
+}
+void actual_template_test() {
+  template_test<4>();
+}
+
+const int table[6] = {};
+void read_test() {
+  for (auto i : table) {
+  }
+}
+
+namespace {
+enum a { b };
+constexpr bool operator&(a, a) { return int(); }
+template <a l>
+void c() { l &a(); }
+void d();
+void d() { c<b>(); }
+} // namespace

clang-tools-extra/trunk/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 {};