[clang-tidy] implement new check 'misc-const-correctness' to add 'const' to unmodified variables

[JonasToth]

Summary

This patch connects the check for const-correctness with the new general
utility to add const to variables.
The code-transformation is only done, if the detected variable for const-ness
is not part of a group-declaration.

The check allows to control multiple facets of adding const, e.g. if pointers themself should be
marked as const if they are not used.

[JonasToth]

• add reproducer for '__unaligned' bug

[JonasToth]

I analyzed the false positive and its probably not so simple to fix.

'NoOp' is always used to add qualifiers. This is true for const and __unaligned, but there seems to be no further information to disambiguate those.
Maybe this requires even something in the front-end to change. WDYT @aaron.ballman ?

Edit: All qualifiers would trigger this problem: const, volatile, restrict and __unaligned (MS extension).
It is likely not a simple as checking 'isConst-Before/After', because pointers are casted a bit more complicated. But something along those lines might be a fix.

[JonasToth]

ping

[0x8000-0000]

In D54943#3048763, @JonasToth wrote:

ping

Hi Jonas,

Using patch32 in production (on top of "release/13.x" branch) ever since it was made available. No crashes.

Only one false positive reported, which I'm not sure even is a false positive, is when I used std::visit and passed in a reference to an object as the first argument, the checker recommended I annotate the variable as const, even though std::visit takes the argument by &&, and changing it to const would have resulted in a miscompile. I think there's also some difference in how std::visit is implemented between various standard C++ libraries, so not sure if that's a special case or something more general.

Quoting from memory:

 std::variant<Foo, Bar, Baz> theThing;

 class Parameter
 {
    int operator()(const Foo& foo)
    {
     ...
    }
    int operator()(const Bar& bar)
    {
     ...
    }
 } param;  // cannot be const, but the checker warns that it could be const

std::visit(param, theThing)

I'm hoping to have some time next week to distill a minimal test case.

Thank you,
florin

[JonasToth]

@aaron.ballman ping for review :)

I do not intend to fix the raised issues with this revision. I think it is more valuable to get this check in and get more user-feedback. But the found bugs are on the todo-list!

[aaron.ballman]

Thanks for pinging on this, it had fallen off my radar! @JonasToth -- did you ever get the chance to talk with @cjdb about the overlap mentioned in https://reviews.llvm.org/D54943#2950100? (The other review also seems to have stalled out, so I'm not certain where things are at.)

[JonasToth]

In D54943#3194643, @aaron.ballman wrote:

Thanks for pinging on this, it had fallen off my radar! @JonasToth -- did you ever get the chance to talk with @cjdb about the overlap mentioned in https://reviews.llvm.org/D54943#2950100? (The other review also seems to have stalled out, so I'm not certain where things are at.)

We talked only short in the review, but I am not sure if there is such a big overlap between the checks. The other check looks at arguments, which is something this check currently skips completely.
I think, this check should continue to avoid this analysis, too.

The underlying ExprMutAnalyzer is reusable (I think so, if not that should be fixed). But my current understanding is, that the argument checker already knows the values are const, because it matches on const & parameters.
IMHO keeping the checks independent would be better. Otherwise a future combined check can be aliased with specific configurations.

[aaron.ballman]

In D54943#3194647, @JonasToth wrote:

In D54943#3194643, @aaron.ballman wrote:

Thanks for pinging on this, it had fallen off my radar! @JonasToth -- did you ever get the chance to talk with @cjdb about the overlap mentioned in https://reviews.llvm.org/D54943#2950100? (The other review also seems to have stalled out, so I'm not certain where things are at.)

We talked only short in the review, but I am not sure if there is such a big overlap between the checks. The other check looks at arguments, which is something this check currently skips completely.
I think, this check should continue to avoid this analysis, too.

That's what sort of worries me though -- a function parameter is notionally a local variable, so the fact that one check tries to solve one half of the problem and the other check tries to solve the other half feels unclean to me. I'm fine with this check ignoring parameters for now, but I think there should only be one check for "make this const if it can be made so".

The underlying ExprMutAnalyzer is reusable (I think so, if not that should be fixed). But my current understanding is, that the argument checker already knows the values are const, because it matches on const & parameters.
IMHO keeping the checks independent would be better. Otherwise a future combined check can be aliased with specific configurations.

I think surfacing the checks as separate checks makes a lot of sense (once is about C++ Core Guideline conformance and the other is about performance), but I'm not sure I understand why the implementations should be different yet.

That said, I think this particular check is more mature and closer to landing than the other one. Based on the amount of effort in this patch already, unless there are strong objections, I think we should base the "make this const if it can be made so" checks on this one.

clang-tools-extra/clang-tidy/cppcoreguidelines/ConstCorrectnessCheck.cpp

50–52

The new-fangled way to do this is to implement an override for isLanguageVersionSupported() (as in https://github.com/llvm/llvm-project/blob/main/clang-tools-extra/clang-tidy/abseil/DurationDivisionCheck.h#L26)

112–117

169

That's the correct approach -- we don't try to apply style choices to fixes in clang-tidy unless they're uncontentious (removing extra whitespace kinda stuff); we expect the user to run clang-format to fix those sort of things up.

clang-tools-extra/clang-tidy/cppcoreguidelines/ConstCorrectnessCheck.h

32

Are we still intending to be conservative here? This defaults some of the Transform to 1 instead of 0, but that's different than what the documentation currently reads.

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-const-correctness-transform-values.cpp

40 ↗

(On Diff #370813)

Are we being conservative here about the diagnostic? It seems like the instantiations in the TU would mean that this could be declared const.

107–108 ↗

(On Diff #370813)

This is a false positive. Making np_local3 be const will break the code: https://godbolt.org/z/EExKfsW4G

114 ↗

(On Diff #370813)

The test really doesn't have anything to do with casts, does it?

120 ↗

(On Diff #370813)

This is a problem -- I see no license on that site, but I do see "All rights reserved". I don't think we should copy from there.

164–167 ↗

(On Diff #370813)

Can you also add a test:

TMPClass<double> p_local2; // Don't attempt to make this const
p_local2.sometimesConst();

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-const-correctness-values.cpp

13 ↗

(On Diff #370813)

It'd be handy to show how we handle a static global, which can be known to be const technically.

17 ↗

(On Diff #370813)

Similarly, showing anonymous namespace variables would help, as those are like a static global and can also theoretically known to be const. (Note, I don't insist on catching those cases! Just would like test coverage with some comments on what to expect + docs if it seems important to tell users.)

555–574 ↗

(On Diff #370813)

Same comments here as above.

[JonasToth]

clang-tools-extra/clang-tidy/cppcoreguidelines/ConstCorrectnessCheck.h

32

good question. given the current result of it being quiet solid we might have it on? But I am fine with it being off.
I am not sure if it would induce too much transformations to handle. I am unsure.

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-const-correctness-transform-values.cpp

40 ↗

(On Diff #370813)

Yes, the check ignores templates when matching. The reasoning behind this was: too much at once. TU-local templates should be transformable, but it must be ensured that all instantiations can be const. Probably the best solution would be that the template uses concepts and the concepts allow const at this place.
This is hopefully follow-up :)

120 ↗

(On Diff #370813)

True. I will try to copy&paste from libc++ instead and remove the reference :)

[aaron.ballman]

clang-tools-extra/clang-tidy/cppcoreguidelines/ConstCorrectnessCheck.h

32

Based on the test coverage we have, I think I'd be fine with it being on by default, but I do think the most conservative approach would be to be off by default. I don't have a strong opinion either way aside from "the documentation should match the code."

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-const-correctness-transform-values.cpp

40 ↗

(On Diff #370813)

Okay, that sounds good to me!

120 ↗

(On Diff #370813)

Thank you. :-)

[cjdb]

That said, I think this particular check is more mature and closer to landing than the other one. Based on the amount of effort in this patch already, unless there are strong objections, I think we should base the "make this const if it can be made so" checks on this one.

Ack. How about we worry about D107873 once this patch lands, and once I've had a chance to rebase it on top of this?

[0x8000-0000]

+1

Let's get this in :)

[JonasToth]

• Merge branch 'main' into feature_rebase_const_transform_20210808
• fix: fixes for most review comments

clang-tools-extra/clang-tidy/cppcoreguidelines/ConstCorrectnessCheck.h

32

I matched the documentation to that its on by default. It is kinda what the check promises, so I think having it off is not user-friendly.
I removed the Experimental note for it as well. It seems to be "good enough" that it does not interfere with everyday programming and even complex things.
The different validation runs seem to agree somewhat (even though there are still issues).

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-const-correctness-transform-values.cpp

40 ↗

(On Diff #370813)

Yes we are conservative. Once its a templated variable the analysis bails out. Non-templated variables in a template are analyzed though.

The 'check all instantiations' are not implemented, but there is already something that goes a little bit in that direction.
Line 118: TemplateDiagnosticsCache.contains(Variable->getBeginLoc())), which is necessary to deduplicate emitted diagnostics in templates.
Similarly, TU-local templates could be checked all-together and if the variable could be const every single time, the diagnostic can be emitted.

But I feel that checking the concepts would be a much better approach to this. This would include the non-local templates as well. At the same time, most templates don't use them yet.

114 ↗

(On Diff #370813)

Thats correct :D Renamed

[JonasToth]

• Merge branch 'main' into feature_rebase_const_transform_20210808
• fix: address other review comments
• remove one false positive with pointers in a range-based for loop on arrays

[JonasToth]

addressed all outstanding review comments.

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-const-correctness-transform-values.cpp

107–108 ↗

(On Diff #370813)

Thanks for spotting this!
The analyzer did not consider the int * non_const_ptr: np_local3 to be a mutation, as its not a reference type.

444   // The range variable is a reference to a builtin array. In that case the
  1   // array is considered **modified if the loop-variable is a non-const reference**.
  2   const auto DeclStmtToNonRefToArray = declStmt(hasSingleDecl(varDecl(hasType(
  3       hasUnqualifiedDesugaredType(referenceType(pointee(arrayType())))))));
  4   const auto RefToArrayRefToElements = match(
  5       findAll(stmt(cxxForRangeStmt(
  6                        hasLoopVariable(varDecl(hasType(nonConstReferenceType()))
  7                                            .bind(NodeID<Decl>::value)),
  8                        hasRangeStmt(DeclStmtToNonRefToArray),
  9                        hasRangeInit(canResolveToExpr(equalsNode(Exp)))))
 10                   .bind("stmt")),
 11       Stm, Context);

Added the fix to the patch, is that ok with you?

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-const-correctness-values.cpp

17 ↗

(On Diff #370813)

Globals are not matched in any way. But there is cppcoreguidelines-avoid-non-const-global-variables which warns for non-const globals already.

The docs say This check implements detection of local variables which could be declared as, so its implicit that globals are not caught. I think that its enough. I will add a reference to cppcoreguidelines-avoid-non-const-global-variables though.

[JonasToth]

• improve documentation a bit

[JonasToth]

• fix release note ordering

[JonasToth]

• fix: adjust unit test for new array-pointer condition in range-based for loops

[njames93]

clang-tools-extra/clang-tidy/cppcoreguidelines/ConstCorrectnessCheck.h

30

Can all these options be defaulted to Boolean values, as the options parser has special parsing logic for bool

[JonasToth]

• use boolean for option parsing

[JonasToth]

• use boolean for options
• fix snafoo on arc usage

[JonasToth]

ping @aaron.ballman just in case the patch is now down on the list, I am sorry for my high latency :(

clang-tools-extra/clang-tidy/cppcoreguidelines/ConstCorrectnessCheck.h

30

you are right. I updated it.

[LegalizeAdulthood]

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-const-correctness-templates.cpp

16 ↗

(On Diff #404297)

CHECK-FIXES?

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-const-correctness-transform-pointer-as-values.cpp

12 ↗

(On Diff #404297)

Shouldn't this validate that the const was placed in the correct position?
e.g. const double * is a different meaning from double *const

Apply to all the other CHECK-FIXES as well

[0x8000-0000]

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-const-correctness-transform-pointer-as-values.cpp

12 ↗

(On Diff #404297)

Can we have the checker merged in first, then we can worry about the automatic fixer?

[JonasToth]

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-const-correctness-templates.cpp

16 ↗

(On Diff #404297)

see my comment in the other test.

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-const-correctness-transform-pointer-as-values.cpp

12 ↗

(On Diff #404297)

the checker is its own utility with its own tests and proper test coverage.
yes const double* and double* const are different and are correctly inserted, but that is not tested here, but here: https://github.com/llvm/llvm-project/blob/main/clang-tools-extra/unittests/clang-tidy/AddConstTest.cpp

Similar to the actual const analysis. That has its own test-suite (https://github.com/llvm/llvm-project/blob/main/clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp)

The tests here are concerned with the diagnostics and "real" code. Afterall, this functionality is too complex to have all of it checked with these kind of tests.
I think the separate testing in specialized unit-tests (as is now) for the specialized functions is the right approach and the CHECK-FIXES are not necessary in this instance, maybe even bad, because it makes the tests unclearer.

[JonasToth]

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-const-correctness-transform-pointer-as-values.cpp

12 ↗

(On Diff #404297)

sry: The _fixer_ is its own utility ...

Additionally: The test is run on big projects with transformation (LLVM, some Qt Stuff).
First everything is transformed and then recompiled. The compiler tells what was incorrectly inserted :)

Thats part of the testing too.

[LegalizeAdulthood]

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-const-correctness-transform-pointer-as-values.cpp

12 ↗

(On Diff #404297)

The tests here are concerned with the diagnostics and "real" code.

OK, great! I didn't realize it was covered by unit tests,
which is perfectly fine with me :)

[JonasToth]

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-const-correctness-transform-pointer-as-values.cpp

12 ↗

(On Diff #404297)

Perfect!

Yeah, the check and patches here are a bit all over the place, which is another reason why a merge would be really great :D

[0x8000-0000]

@aaron.ballman - can this land for Clang14, or does it have wait for 15?

Are there any other reviewers that can approve this?

[JonasToth]

In D54943#3292552, @0x8000-0000 wrote:

@aaron.ballman - can this land for Clang14, or does it have wait for 15?

Are there any other reviewers that can approve this?

Sadly, cherry-picking to 14 is very unlikely, as this is not a bugfix. :/
On the other hand, it missed so many releases so lets stay positive :)

Aaron did the review and I think he should accept too.

[njames93]

In D54943#3296191, @JonasToth wrote:

In D54943#3292552, @0x8000-0000 wrote:

@aaron.ballman - can this land for Clang14, or does it have wait for 15?

Are there any other reviewers that can approve this?

Sadly, cherry-picking to 14 is very unlikely, as this is not a bugfix. :/
On the other hand, it missed so many releases so lets stay positive :)

Aaron did the review and I think he should accept too.

This won't get backported now, besides giving it a few months to test(and potentially iron out) on the dev branch isn't such a bad thing.

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

27

Will this work under clangd as I don't think that links in the clangAnalysis libraries @sammccall?

clang-tools-extra/clang-tidy/cppcoreguidelines/ConstCorrectnessCheck.cpp

28

nit

85

allOf is unnecessary here as declStmt is implicitly an allOf matcher.
Also findAll isn't the right matcher in this case, you likely want forEachDescendant. findAll will try and match on the CompoundStmt which is always going to fail.

103–106

This sounds like a bug that should be raised with ASTMatchers, if its reproducible.

161

This is unnecessary, llvm::Optional already has an alias inside the clang namespace.

163–169

DiagnosticBuilders accept optional fixits as syntactic sugar.
Same goes for below.

clang-tools-extra/docs/ReleaseNotes.rst

116–120

This'll need rebasing after branching.

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-const-correctness-templates.cpp

3–6 ↗

(On Diff #404297)

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-const-correctness-transform-pointer-as-values.cpp

3–5 ↗

(On Diff #404297)

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-const-correctness-transform-values.cpp

3–5 ↗

(On Diff #404297)

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-const-correctness-unaligned.cpp

3–5 ↗

(On Diff #404297)

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-const-correctness-values.cpp

3–5 ↗

(On Diff #404297)

[JonasToth]

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

27

I did not check if it works and clangd does not explicitly link to Analysis, but only to the checks.
Doesn't the LINK_LIBS induce transitive dependency resolution for linking?

clang-tools-extra/clang-tidy/cppcoreguidelines/ConstCorrectnessCheck.cpp

103–106

I found no way to reproduce it (yet).
The crashes occured during verification on big projects and run-clang-tidy kind of obfuscated where the crash happened.

This is something for the iron out part of the check I think.

[sammccall]

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

27

I don't know whether you need to add it everywhere, I suspect transitive is OK.

In any case this isn't a new dependency, Sema depends on Analysis and clangd depends on Sema.

clang-tools-extra/clang-tidy/cppcoreguidelines/ConstCorrectnessCheck.cpp

30

This returns an iterator (i.e. a pointer), which is being converted to a boolean.

i.e. it's always returning true. I think this is why you're seeing nullptr crashes on Variable.

30

this is depending on ::internal details, which doesn't seem OK.
I think you'd need to find another way to do it, or move this to ASTMatchers (in a separate patch).

103–106

This is a bug in a helper added in this patch, I've added a comment above.

[njames93]

clang-tools-extra/clang-tidy/cppcoreguidelines/ConstCorrectnessCheck.cpp

103–106

Ahh, hopefully once D118520 lands it should be easier to track down these bugs and create reproducers

[JonasToth]

• address reviews comments, part 1
• Merge branch 'main' into feature_rebase_const_transform_20210808
• fixing iterator-to-bool conversion and addressing other more review comments

[JonasToth]

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

27

i verified that the check works with clangd without any additional build settings.

clang-tools-extra/clang-tidy/cppcoreguidelines/ConstCorrectnessCheck.cpp

30

it is common to write custom matchers in clang-tidy first and use the internal matcher apis as well in clang-tidy.

$ cd llvm-project/clang-tools-extra/clang-tidy
$ git grep "internal::" | wc -l
86

Usually, they are extracted once they are generally useful. And many checks introduce custom matchers for better readability.
I can extract this matcher later if you want, but right now with the longevity of the patch and it being common practice in clang-tidy I am opposed to it.

30

thank you for that hint! that would explain the issues indeed. I try to verify your proposed fix by re-transforming LLVM.
some other subscribers checked their own codebases as well. this would give us more confidence too.

if the crash is still there, I would like to keep the 'safety-if' in check and try to find the issue with the matcher.
The path @njames93 linked seemed like it would help there a lot.

85

switching to forEachDescendant, both seem to work.
I am unsure why I used findAll, but I know that I started out with forEachDescendant for some bits of the check and it was insufficent.
But it could very well be, that these pieces are now in the ExprMutAnalyzer.

103–106

I am rerunning the whole analysis on LLVM to see if the crash is still there after the proposed fix of sam (thanks!).
I will remove the code completely if the crash is gone. Otherwise I'd rather keep the safety in and try to fix the underlying issue afterwards.

[JonasToth]

Another full run on LLVM with:

$ ./clang-tools-extra/clang-tidy/tool/run-clang-tidy.py \
      -clang-tidy-binary ~/software/llvm-project/build_clang_tidy/bin/clang-tidy \
      -checks="-*,cppcoreguidelines-const-correctness" \
      -config "{CheckOptions: [{key: 'cppcoreguidelines-const-correctness.TransformValues', value: 1}, {key: 'cppcoreguidelines-const-correctness.TransformReferences', value: 1}, {key: 'cppcoreguidelines-const-correctness.WarnPointersAsValues', value: true}, {key: 'cppcoreguidelines-const-correctness.TransformPointersAsValues', value: true}]}" \
      -fix 2>&1 | tee ../transformation.log

Yields to this: 3822 files changed, 159256 insertions(+), 159256 deletions(-)
and requires manual changes:

to_fix.patch19 KBDownload

23 files changed, 45 insertions(+), 45 deletions(-)

the issues were:

• missing {} initialization after a variable became const if a destructor was missing
• the analysis got confused for some insert(llvm::Function* f) calls and made the objects const. Those are false positives, but with a really low rate

after applying the patch ninja check-all is successfull.

Branch Compare

[JonasToth]

ping @aaron.ballman @njames93 :)

[aaron.ballman]

In D54943#3394827, @JonasToth wrote:

ping @aaron.ballman @njames93 :)

Sorry, for my own sanity, I've stopped reviewing C++ Core Guideline reviews for their diagnostic behavior until the guideline authors put effort into specifying realistic enforcement guidance.

[JonasToth]

Sorry, for my own sanity, I've stopped reviewing C++ Core Guideline reviews for their diagnostic behavior until the guideline authors put effort into specifying realistic enforcement guidance.

And how can we continue now? I fear that this is effectively the death of this check. :/
Isn't the "make this const" good enough?

[aaron.ballman]

In D54943#3407789, @JonasToth wrote:

Sorry, for my own sanity, I've stopped reviewing C++ Core Guideline reviews for their diagnostic behavior until the guideline authors put effort into specifying realistic enforcement guidance.

And how can we continue now? I fear that this is effectively the death of this check. :/
Isn't the "make this const" good enough?

Our rule of thumb in clang-tidy when checking against a coding standard is that the coding standard is the law as to how the check should work (what it diagnoses, what it doesn't diagnose). When the coding standard gives guidance that can reasonably be handled another way, we give config options so that users can pick the behavior they need to enforce. The trouble is: the C++ Core Guidelines rarely have a useful enforcement to suggest and the rules themselves are often not sufficiently precise to tease out what to enforce. This puts the onus on *us* to decide what the behavior should be, which is inappropriate unless the guideline authors are involved in the discussions and reflect the decisions in the guidelines. To date, that has (almost?) never happened with any C++ Core Guideline checks.

In this specific case, the guideline being checked is https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#es25-declare-an-object-const-or-constexpr-unless-you-want-to-modify-its-value-later-on and its enforcement guidance is:

Look to see if a variable is actually mutated, and flag it if not. Unfortunately, it might be impossible to detect when a non-const was not intended to vary (vs when it merely did not vary).

This is not useful enforcement guidance, so as a code reviewer, I have to spend *considerable* time trying to figure out what's reasonable and what's not. I've gone through this with basically each C++ Core Guideline check (many of them don't even TRY to give enforcement, like this: https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#enforcement-345), so this is not at all specific to you or something that's your fault. But that's why I no longer am willing to review C++ Core Guideline checks; they're a burden to support without the guideline authors active engagement, which has never materialized.

So how can we continue now is definitely a good question. I think there's plenty of utility in this check already, and so my recommendation would be to pull out all mentions of the C++ Core Guidelines (so we don't have to stick specifically to what they recommend) and AUTOSAR (see https://reviews.llvm.org/D112730#3332366 for details) and move the check to misc- (I don't see a better module for it at the moment as it's not really bugprone and it's not really readability, but I'm not strongly tied to which module it lives in). From there, I hope we can converge on the check MUCH faster because I think the "make this const" is good enough (and SUPER USEFUL). However, I don't know what your goals or requirements are (if you need this to adhere to the C++ Core Guidelines specifically), so another option is for the other reviewers to sign off on it; I won't actively block the addition of new C++ Core Guideline checks.

(Personally, I'm of the opinion we should pull the C++ Core Guidelines modules out of clang-tidy and distribute the existing checks amongst the other modules. Then we no longer have to worry about what the guidelines say, we can use them purely as inspiration for things we feel may be useful to check, but without tying ourselves to supporting their document. However, that's a decision which requires a far wider audience and is way outside the scope of this check.)

[njames93]

I share @aaron.ballman option that given the flakiness of the guidelines, the check shouldn't mention that it addresses the c++core guidelines. Instead moving the check into another module(misc) would still provide immense value, with the side effect that it is still able to help teams enforce parts of the core guidelines.

[JonasToth]

ok. then i will continue under misc-const-correctness. thank you for the clarifications!

[JonasToth]

• refactor: rename check to 'misc-const-correctness' and adjust the tests accordingly
• docs: adjust release notes and adjust check docs slightly

[JonasToth]

• fix: remove clangAnalysis link in cppcoreguidelines and add it in misc

[njames93]

clang-tools-extra/clang-tidy/misc/ConstCorrectnessCheck.cpp

103 ↗

(On Diff #424788)

Hasn't this already been addressed, if so can this block just be removed.

clang-tools-extra/docs/ReleaseNotes.rst

107

Unrelated change.

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

6–7

This should be committed separately.

clang-tools-extra/test/clang-tidy/checkers/misc-const-correctness-transform-values.cpp

27 ↗

(On Diff #424788)

This check directive isn't going to be effective.
Try CHECK-FIXES: const int p_local0 = 2;
Same goes for all the ones below.

[JonasToth]

• addressing review comments and remove unrelated changes

[JonasToth]

Thank you for the review! I adjusted the patch.

[JonasToth]

clang-tools-extra/clang-tidy/misc/ConstCorrectnessCheck.h

24 ↗

(On Diff #427423)

missing change to new docs

[JonasToth]

• fix documentation reference

[JonasToth]

friendly ping :) (maybe @njames93 ?)

[njames93]

Pretty much good to go, just a few nits with the tests.
Can you add CHECK-FIXES directives for all warnings if there should be a fixit.
If there shouldn't be one could you either add a comment saying there shouldn't be one, or put a CHECK-FIXES-NOT directive.

[JonasToth]

• addded CHECK-FIXES in clang-tidy tests
• merged latest main into branch

[JonasToth]

ping :)
@njames93 I added more CHECK-FIXES and CHECK-FIXES-NOT statements in the tests.

[njames93]

LGTM, just a couple points but not essential.

clang-tools-extra/clang-tidy/misc/ConstCorrectnessCheck.cpp

184–187 ↗

(On Diff #432774)

clang-tools-extra/clang-tidy/misc/ConstCorrectnessCheck.h

35 ↗

(On Diff #432774)

It may be worth adding some validation to these. If AnalyzeValues, AnalyzeReferences and WarnPointersAsValues are all false, this whole check is basically a no-op.

[JonasToth]

clang-tools-extra/clang-tidy/misc/ConstCorrectnessCheck.h

35 ↗

(On Diff #432774)

Whats the proper way to react? Short-circuit the registerMatchers, similar to language support?
I think thats the way I would go about this.

[njames93]

clang-tools-extra/clang-tidy/misc/ConstCorrectnessCheck.h

35 ↗

(On Diff #432774)

ClangTidyCheck::configurationDiag is the way to warn about issues with config.

[LegalizeAdulthood]

Clang-tidy tests and docs have been moved to subdirectories by module, please rebase to main:HEAD

[carlosgalvezp]

clang-tools-extra/docs/clang-tidy/checks/misc-const-correctness.rst

10 ↗

(On Diff #432774)

AUTOSAR mentions should be removed as per previous comment from @aaron.ballman

[JonasToth]

• test: move tests into group specific directory
• refactor: use more idiomatic c++ for scope-based analyzer creation/access
• feat: provide config validation if analysis if completely configured off
• refactor: move documentation as well
• test: add test for incorrect configurations

[JonasToth]

clang-tools-extra/docs/clang-tidy/checks/misc-const-correctness.rst

10 ↗

(On Diff #432774)

Why? I dont think its wrong to hint that there are coding standards that require const to be used consistently.
The check does not run under cppcoreguidelines- because the guidelines are not exact on their requirements. But "the spirit" is still the same. I would like to keep the references.

[JonasToth]

In D54943#3619333, @LegalizeAdulthood wrote:

Clang-tidy tests and docs have been moved to subdirectories by module, please rebase to main:HEAD

I moved the tests and the documentation as well.
tests + documentation do build/pass

[JonasToth]

• fix: doc list and release-notes reference

[JonasToth]

• refactor: adjust warning message for mis-configuration to show which check is configured wrong

[JonasToth]

@njames93 @LegalizeAdulthood I did integrate the requested changes regarding warning for bad configs, refactoring of map-access and the directory structure of test-files and documentation.

given the high interest in the patch and the need to iron out potential false-positives that will only be spotted on diverse code bases, i would like to commit now and address outstanding issues in follow ups, that are much smaller and easier to manage.

[njames93]

LGTM with those changes.

[JonasToth]

Thank you very much for all you patience, reviews and tests!
I hope that the following improvements are now simpler to integrate and that the test matures well. :)

[sammccall]

This check is enabled by default in LLVM (Checks: misc-* in llvm-project/.clang-tidy)

The warning on mutable non-ref local variables is pretty noisy: a *lot* of existing code does not do this, for defensible reasons (some of us think that the ratio of extra safety to extra syntactic noise for locals is too low). The LLVM style guide doesn't take a position on this.

Should this check

• be disabled for LLVM? (i.e. this is opt-in for codebases with strong const-correctness rules, LLVM does not, it was unintentionally enabled by misc-*)
• be configured only to warn on references? (i.e. we expect that is de-facto LLVM style and so uncontroversial)

[JonasToth]

In D54943#3681527, @sammccall wrote:

This check is enabled by default in LLVM (Checks: misc-* in llvm-project/.clang-tidy)

The warning on mutable non-ref local variables is pretty noisy: a *lot* of existing code does not do this, for defensible reasons (some of us think that the ratio of extra safety to extra syntactic noise for locals is too low). The LLVM style guide doesn't take a position on this.

Should this check

• be disabled for LLVM? (i.e. this is opt-in for codebases with strong const-correctness rules, LLVM does not, it was unintentionally enabled by misc-*)
• be configured only to warn on references? (i.e. we expect that is de-facto LLVM style and so uncontroversial)

IMHO just enable for references in LLVM, thats still enough warnings to take a while to process and the guide is clear on that.
If the community wants it for values as well, that can be done later anyway.

Do you think the defaults for this check should change? Originally, it was "default on" because cppcoreguidelines state so.

[kadircet]

I agree with Sam on this one, especially on big files it just floods and hides non-stylistic diagnostics (you even hit max diagnostics exceeded errors).

I believe unless someone takes the extra mile to fix all the value types in LLVM to be const-correct, this is harmful then being useful. I can't speak for the projects out in the wild for the overall default (i have a personal preference for having everything const-correct, but it's mostly for stylistic reasons ...), but i think the default of diagnosing values for LLVM should definitely be off. Do you mind performing that change for .clang-tidy configs if others are not objecting on this either?

[aaron.ballman]

In D54943#3687827, @JonasToth wrote:

In D54943#3681527, @sammccall wrote:

This check is enabled by default in LLVM (Checks: misc-* in llvm-project/.clang-tidy)

The warning on mutable non-ref local variables is pretty noisy: a *lot* of existing code does not do this, for defensible reasons (some of us think that the ratio of extra safety to extra syntactic noise for locals is too low). The LLVM style guide doesn't take a position on this.

Should this check

• be disabled for LLVM? (i.e. this is opt-in for codebases with strong const-correctness rules, LLVM does not, it was unintentionally enabled by misc-*)
• be configured only to warn on references? (i.e. we expect that is de-facto LLVM style and so uncontroversial)

IMHO just enable for references in LLVM, thats still enough warnings to take a while to process and the guide is clear on that.
If the community wants it for values as well, that can be done later anyway.

Do you think the defaults for this check should change? Originally, it was "default on" because cppcoreguidelines state so.

I agree with Sam that this definitely needs to be disabled for LLVM -- we don't have anywhere near enough const correctness to get significant value out of this check yet, even if it was limited to just references. As for whether we should default to only warn on references by default -- I think that might be a better approach now that this is no longer tied directly to the C++ Core Guidelines.

[sammccall]

FYI I've sent D135829 to block this check from running in clangd, after tracking it down as the cause of a >10x regression in reparse times in a project that inadvertently enabled it (misc-*).

Looking at the implementation, this check seems to be expensive by design rather than some bug: it's matching many nodes, and then doing expensive nested analysis for each in the callback.

It's reasonable to want checks like that, OTOH it would be nice to have some way to distinguish them from the "classic" checks that aim to run in roughly linear time.
(It's not just clangd: we've had issues with a batch clang-tidy run over our codebase not finishing due to slow checks, and takes a lot of investigation before you can tell if this is a bug or not)

[sammccall]

In D54943#3854279, @sammccall wrote:

FYI I've sent D135829 to block this check from running in clangd, after tracking it down as the cause of a >10x regression in reparse times in a project that inadvertently enabled it (misc-*).

Looking at the implementation, this check seems to be expensive by design rather than some bug: it's matching many nodes, and then doing expensive nested analysis for each in the callback.

It's reasonable to want checks like that, OTOH it would be nice to have some way to distinguish them from the "classic" checks that aim to run in roughly linear time.
(It's not just clangd: we've had issues with a batch clang-tidy run over our codebase not finishing due to slow checks, and takes a lot of investigation before you can tell if this is a bug or not)

To quantify this: wanting to be a bit more systematic, I measured the performance overhead of each check in clangd by having it parse SemaExpr.cpp with 0 checks and then each check in isolation.

This check added 1600% overhead, the next highest had <30%.

Unfortunately the detailed numbers aren't reliable as it looks like some kind of throttling kicked in towards the end, but here they are anyway...

I[14:53:46.703] Built preamble of size 53505060 for file /usr/local/google/home/sammccall/src/llvm-project/clang/lib/Sema/SemaExpr.cpp version null in 5.70 seconds
I[14:53:46.708] Building AST...
I[14:53:48.945] Indexing AST...
I[14:53:49.049] Timing AST build with individual clang-tidy checks
I[14:53:54.958]   Baseline = 1968848738 ns
I[14:54:00.873]   abseil-cleanup-ctad = 0.16%
I[14:54:06.707]   abseil-duration-addition = -1.45%
I[14:54:12.527]   abseil-duration-comparison = -1.69%
I[14:54:18.422]   abseil-duration-conversion-cast = -0.32%
I[14:54:24.281]   abseil-duration-division = -0.93%
I[14:54:30.186]   abseil-duration-factory-float = -0.06%
I[14:54:36.107]   abseil-duration-factory-scale = 0.15%
I[14:54:42.344]   abseil-duration-subtraction = 5.31%
I[14:54:48.646]   abseil-duration-unnecessary-conversion = 4.86%
I[14:54:54.617]   abseil-faster-strsplit-delimiter = 0.77%
I[14:55:00.460]   abseil-no-internal-dependencies = -1.21%
I[14:55:06.280]   abseil-no-namespace = -1.61%
I[14:55:12.221]   abseil-redundant-strcat-calls = 0.04%
I[14:55:18.138]   abseil-str-cat-append = 0.05%
I[14:55:23.972]   abseil-string-find-startswith = -1.23%
I[14:55:29.847]   abseil-string-find-str-contains = -0.47%
I[14:55:35.676]   abseil-time-comparison = -1.49%
I[14:55:41.798]   abseil-time-subtraction = 3.43%
I[14:55:47.911]   abseil-upgrade-duration-conversions = 3.52%
I[14:55:55.547]   altera-id-dependent-backward-branch = 29.26%
I[14:56:01.362]   altera-kernel-name-restriction = -1.51%
I[14:56:07.195]   altera-single-work-item-barrier = -1.38%
I[14:56:13.013]   altera-struct-pack-align = -1.60%
I[14:56:19.057]   altera-unroll-loops = 2.21%
I[14:56:24.935]   android-cloexec-accept = -0.85%
I[14:56:30.802]   android-cloexec-accept4 = -0.61%
I[14:56:36.663]   android-cloexec-creat = -0.77%
I[14:56:42.556]   android-cloexec-dup = -0.19%
I[14:56:48.498]   android-cloexec-epoll-create = 0.49%
I[14:56:54.439]   android-cloexec-epoll-create1 = 0.38%
I[14:57:00.388]   android-cloexec-fopen = 0.67%
I[14:57:06.329]   android-cloexec-inotify-init = 0.56%
I[14:57:12.280]   android-cloexec-inotify-init1 = 0.25%
I[14:57:18.201]   android-cloexec-memfd-create = 0.14%
I[14:57:24.180]   android-cloexec-open = 1.10%
I[14:57:30.128]   android-cloexec-pipe = 0.33%
I[14:57:36.072]   android-cloexec-pipe2 = 0.48%
I[14:57:41.991]   android-cloexec-socket = 0.11%
I[14:57:47.902]   android-comparison-in-temp-failure-retry = -0.11%
I[14:57:53.827]   boost-use-to-string = 0.23%
I[14:57:59.841]   bugprone-argument-comment = 1.73%
I[14:58:05.870]   bugprone-assert-side-effect = 1.98%
I[14:58:11.787]   bugprone-assignment-in-if-condition = -0.06%
I[14:58:17.759]   bugprone-bad-signal-to-kill-thread = 0.88%
I[14:58:23.800]   bugprone-bool-pointer-implicit-conversion = 2.28%
I[14:58:29.827]   bugprone-branch-clone = 1.85%
I[14:58:35.748]   bugprone-copy-constructor-init = 0.11%
I[14:58:41.752]   bugprone-dangling-handle = 1.61%
I[14:58:47.659]   bugprone-dynamic-static-initializers = -0.13%
I[14:58:53.849]   bugprone-easily-swappable-parameters = 4.48%
I[14:58:59.756]   bugprone-exception-escape = -0.15%
I[14:59:05.881]   bugprone-fold-init-type = 3.61%
I[14:59:11.851]   bugprone-forward-declaration-namespace = 1.15%
I[14:59:17.776]   bugprone-forwarding-reference-overload = 0.18%
I[14:59:24.046]   bugprone-implicit-widening-of-multiplication-result = 6.05%
I[14:59:29.984]   bugprone-inaccurate-erase = 0.46%
I[14:59:35.922]   bugprone-incorrect-roundings = 0.42%
I[14:59:42.053]   bugprone-infinite-loop = 3.53%
I[14:59:47.972]   bugprone-integer-division = 0.07%
I[14:59:53.980]   bugprone-lambda-function-name = 1.90%
I[14:59:59.896]   bugprone-macro-parentheses = -0.14%
I[15:00:05.809]   bugprone-macro-repeated-side-effects = -0.14%
I[15:00:11.849]   bugprone-misplaced-operator-in-strlen-in-alloc = 2.08%
I[15:00:17.760]   bugprone-misplaced-pointer-arithmetic-in-alloc = -0.07%
I[15:00:23.719]   bugprone-misplaced-widening-cast = 0.78%
I[15:00:29.638]   bugprone-move-forwarding-reference = 0.11%
I[15:00:35.721]   bugprone-multiple-statement-macro = 2.92%
I[15:00:41.793]   bugprone-narrowing-conversions = 2.74%
I[15:00:47.723]   bugprone-no-escape = 0.17%
I[15:00:54.142]   bugprone-not-null-terminated-result = 8.33%
I[15:01:00.152]   bugprone-parent-virtual-call = 1.57%
I[15:01:06.077]   bugprone-posix-return = 0.19%
I[15:01:11.943]   bugprone-redundant-branch-condition = -0.80%
I[15:01:18.014]   bugprone-reserved-identifier = 2.77%
I[15:01:23.873]   bugprone-shared-ptr-array-mismatch = -0.81%
I[15:01:29.728]   bugprone-signal-handler = -1.62%
I[15:01:35.608]   bugprone-signed-char-misuse = -0.55%
I[15:01:41.477]   bugprone-sizeof-container = -0.74%
I[15:01:47.433]   bugprone-sizeof-expression = 0.77%
I[15:01:53.557]   bugprone-spuriously-wake-up-functions = 3.48%
I[15:01:59.452]   bugprone-string-constructor = -0.50%
I[15:02:05.316]   bugprone-string-integer-assignment = -0.90%
I[15:02:11.184]   bugprone-string-literal-with-embedded-nul = -0.65%
I[15:02:17.286]   bugprone-stringview-nullptr = 3.27%
I[15:02:23.129]   bugprone-suspicious-enum-usage = -1.21%
I[15:02:28.970]   bugprone-suspicious-include = -1.22%
I[15:02:34.921]   bugprone-suspicious-memory-comparison = 0.74%
I[15:02:40.972]   bugprone-suspicious-memset-usage = 2.39%
I[15:02:46.816]   bugprone-suspicious-missing-comma = -1.37%
I[15:02:52.638]   bugprone-suspicious-realloc-usage = -1.58%
I[15:02:58.624]   bugprone-suspicious-semicolon = 1.01%
I[15:03:04.720]   bugprone-suspicious-string-compare = 3.07%
I[15:03:10.584]   bugprone-swapped-arguments = -0.95%
I[15:03:16.537]   bugprone-terminating-continue = 0.57%
I[15:03:22.416]   bugprone-throw-keyword-missing = -0.45%
I[15:03:28.288]   bugprone-too-small-loop-variable = -0.99%
I[15:03:34.217]   bugprone-unchecked-optional-access = 0.19%
I[15:03:40.179]   bugprone-undefined-memory-manipulation = 0.95%
I[15:03:46.123]   bugprone-undelegated-constructor = 0.50%
I[15:03:51.955]   bugprone-unhandled-exception-at-new = -1.36%
I[15:03:57.833]   bugprone-unhandled-self-assignment = -0.68%
I[15:04:03.855]   bugprone-unused-raii = 1.75%
I[15:04:09.925]   bugprone-unused-return-value = 2.59%
I[15:04:16.410]   bugprone-use-after-move = 9.53%
I[15:04:22.345]   bugprone-virtual-near-miss = 0.41%
I[15:04:28.518]   cert-con36-c = 3.37%
I[15:04:34.631]   cert-con54-cpp = 3.24%
I[15:04:40.624]   cert-dcl03-c = 1.32%
I[15:04:46.722]   cert-dcl16-c = 3.02%
I[15:04:52.583]   cert-dcl21-cpp = -1.00%
I[15:04:58.671]   cert-dcl37-c = 3.26%
I[15:05:04.517]   cert-dcl50-cpp = -1.29%
I[15:05:10.595]   cert-dcl51-cpp = 2.76%
I[15:05:16.415]   cert-dcl54-cpp = -1.54%
I[15:05:22.273]   cert-dcl58-cpp = -0.83%
I[15:05:28.121]   cert-dcl59-cpp = -1.09%
I[15:05:34.035]   cert-env33-c = 0.20%
I[15:05:39.921]   cert-err09-cpp = -0.64%
I[15:05:46.038]   cert-err33-c = 3.53%
I[15:05:51.971]   cert-err34-c = 0.20%
I[15:05:57.935]   cert-err52-cpp = 1.09%
I[15:06:03.781]   cert-err58-cpp = -1.11%
I[15:06:09.710]   cert-err60-cpp = 0.42%
I[15:06:15.689]   cert-err61-cpp = 1.16%
I[15:06:21.769]   cert-exp42-c = 2.86%
I[15:06:27.781]   cert-fio38-c = 1.71%
I[15:06:33.780]   cert-flp30-c = 1.39%
I[15:06:39.859]   cert-flp37-c = 2.86%
I[15:06:45.827]   cert-mem57-cpp = 0.93%
I[15:06:51.845]   cert-msc30-c = 1.59%
I[15:06:57.956]   cert-msc32-c = 3.32%
I[15:07:03.990]   cert-msc50-cpp = 2.06%
I[15:07:10.077]   cert-msc51-cpp = 2.83%
I[15:07:16.002]   cert-msc54-cpp = 0.17%
I[15:07:21.984]   cert-oop11-cpp = 1.25%
I[15:07:27.964]   cert-oop54-cpp = 1.14%
I[15:07:34.096]   cert-oop57-cpp = 3.71%
I[15:07:40.056]   cert-oop58-cpp = 0.77%
I[15:07:46.069]   cert-pos44-c = 1.75%
I[15:07:52.088]   cert-pos47-c = 1.69%
I[15:07:58.084]   cert-sig30-c = 1.25%
I[15:08:04.044]   cert-str34-c = 0.76%
I[15:08:10.870]   concurrency-mt-unsafe = 15.72%
I[15:08:16.897]   concurrency-thread-canceltype-asynchronous = 1.95%
I[15:08:22.952]   cppcoreguidelines-avoid-c-arrays = 2.35%
I[15:08:28.912]   cppcoreguidelines-avoid-const-or-ref-data-members = 0.72%
I[15:08:34.871]   cppcoreguidelines-avoid-do-while = 0.79%
I[15:08:40.889]   cppcoreguidelines-avoid-goto = 1.90%
I[15:08:46.949]   cppcoreguidelines-avoid-magic-numbers = 2.41%
I[15:08:52.913]   cppcoreguidelines-avoid-non-const-global-variables = 0.83%
I[15:08:58.996]   cppcoreguidelines-c-copy-assignment-signature = 3.04%
I[15:09:04.961]   cppcoreguidelines-explicit-virtual-functions = 0.96%
I[15:09:11.048]   cppcoreguidelines-init-variables = 3.01%
I[15:09:17.007]   cppcoreguidelines-interfaces-global-init = 0.70%
I[15:09:23.009]   cppcoreguidelines-macro-usage = 1.53%
I[15:09:29.126]   cppcoreguidelines-narrowing-conversions = 3.59%
I[15:09:35.228]   cppcoreguidelines-no-malloc = 3.36%
I[15:09:41.192]   cppcoreguidelines-non-private-member-variables-in-classes = 0.78%
I[15:09:47.503]   cppcoreguidelines-owning-memory = 6.59%
I[15:09:53.591]   cppcoreguidelines-prefer-member-initializer = 2.34%
I[15:10:00.060]   cppcoreguidelines-pro-bounds-array-to-pointer-decay = 9.07%
I[15:10:06.096]   cppcoreguidelines-pro-bounds-constant-array-index = 2.29%
I[15:10:12.050]   cppcoreguidelines-pro-bounds-pointer-arithmetic = 0.73%
I[15:10:18.007]   cppcoreguidelines-pro-type-const-cast = 0.80%
I[15:10:24.057]   cppcoreguidelines-pro-type-cstyle-cast = 2.29%
I[15:10:30.115]   cppcoreguidelines-pro-type-member-init = 2.41%
I[15:10:36.067]   cppcoreguidelines-pro-type-reinterpret-cast = 0.64%
I[15:10:42.112]   cppcoreguidelines-pro-type-static-cast-downcast = 1.88%
I[15:10:48.093]   cppcoreguidelines-pro-type-union-access = 1.14%
I[15:10:54.092]   cppcoreguidelines-pro-type-vararg = 1.31%
I[15:11:00.273]   cppcoreguidelines-slicing = 4.66%
I[15:11:06.235]   cppcoreguidelines-special-member-functions = 0.68%
I[15:11:12.207]   cppcoreguidelines-virtual-class-destructor = 1.03%
I[15:11:18.242]   darwin-avoid-spinlock = 2.00%
I[15:11:24.189]   darwin-dispatch-once-nonstatic = 0.51%
I[15:11:30.167]   fuchsia-default-arguments-calls = 1.33%
I[15:11:36.106]   fuchsia-default-arguments-declarations = 0.43%
I[15:11:42.022]   fuchsia-header-anon-namespaces = 0.21%
I[15:11:47.980]   fuchsia-multiple-inheritance = 0.91%
I[15:11:53.934]   fuchsia-overloaded-operator = 0.70%
I[15:11:59.892]   fuchsia-statically-constructed-objects = 0.56%
I[15:12:05.919]   fuchsia-trailing-return = 1.92%
I[15:12:11.864]   fuchsia-virtual-inheritance = 0.55%
I[15:12:18.022]   google-build-explicit-make-pair = 4.03%
I[15:12:23.980]   google-build-namespaces = 0.76%
I[15:12:29.939]   google-build-using-namespace = 0.73%
I[15:12:35.903]   google-default-arguments = 0.96%
I[15:12:41.914]   google-explicit-constructor = 1.65%
I[15:12:47.887]   google-global-names-in-headers = 0.95%
I[15:12:53.835]   google-objc-avoid-nsobject-new = 0.44%
I[15:12:59.781]   google-objc-avoid-throwing-exception = 0.49%
I[15:13:05.739]   google-objc-function-naming = 0.72%
I[15:13:11.690]   google-objc-global-variable-declaration = 0.76%
I[15:13:17.658]   google-readability-avoid-underscore-in-googletest-name = 0.83%
I[15:13:23.663]   google-readability-braces-around-statements = 1.32%
I[15:13:29.711]   google-readability-casting = 2.32%
I[15:13:35.758]   google-readability-function-size = 2.29%
I[15:13:41.719]   google-readability-namespace-comments = 0.78%
I[15:13:47.679]   google-readability-todo = 0.60%
I[15:13:53.669]   google-runtime-int = 1.72%
I[15:13:59.520]   google-runtime-operator = -0.82%
I[15:14:05.676]   google-upgrade-googletest-case = 4.10%
I[15:14:11.587]   hicpp-avoid-c-arrays = -0.16%
I[15:14:17.513]   hicpp-avoid-goto = 0.19%
I[15:14:23.400]   hicpp-braces-around-statements = -0.49%
I[15:14:29.237]   hicpp-deprecated-headers = -1.44%
I[15:14:35.076]   hicpp-exception-baseclass = -1.18%
I[15:14:41.036]   hicpp-explicit-conversions = 0.94%
I[15:14:47.058]   hicpp-function-size = 1.90%
I[15:14:53.634]   hicpp-invalid-access-moved = 11.37%
I[15:14:59.670]   hicpp-member-init = 1.99%
I[15:15:05.802]   hicpp-move-const-arg = 3.62%
I[15:15:11.718]   hicpp-multiway-paths-covered = 0.08%
I[15:15:17.653]   hicpp-named-parameter = 0.48%
I[15:15:23.618]   hicpp-new-delete-operators = 0.86%
I[15:15:30.027]   hicpp-no-array-decay = 8.34%
I[15:15:35.953]   hicpp-no-assembler = 0.30%
I[15:15:42.011]   hicpp-no-malloc = 2.68%
I[15:15:47.936]   hicpp-noexcept-move = 0.38%
I[15:15:53.877]   hicpp-signed-bitwise = 0.70%
I[15:15:59.810]   hicpp-special-member-functions = 0.59%
I[15:16:05.912]   hicpp-static-assert = 3.17%
I[15:16:11.907]   hicpp-undelegated-constructor = 1.37%
I[15:16:18.067]   hicpp-uppercase-literal-suffix = 4.34%
I[15:16:24.067]   hicpp-use-auto = 1.45%
I[15:16:30.259]   hicpp-use-emplace = 4.81%
I[15:16:36.259]   hicpp-use-equals-default = 1.45%
I[15:16:42.178]   hicpp-use-equals-delete = 0.14%
I[15:16:48.092]   hicpp-use-noexcept = -0.07%
I[15:16:54.148]   hicpp-use-nullptr = 2.27%
I[15:17:00.092]   hicpp-use-override = 0.52%
I[15:17:06.064]   hicpp-vararg = 1.01%
I[15:17:12.164]   linuxkernel-must-check-errs = 3.20%
I[15:17:18.158]   llvm-else-after-return = 1.68%
I[15:17:24.094]   llvm-header-guard = 0.52%
I[15:17:29.968]   llvm-include-order = -0.16%
I[15:17:35.809]   llvm-namespace-comment = -1.05%
I[15:17:41.799]   llvm-prefer-isa-or-dyn-cast-in-conditionals = 1.33%
I[15:17:47.642]   llvm-prefer-register-over-unsigned = -1.30%
I[15:17:53.578]   llvm-qualified-auto = 0.38%
I[15:17:59.450]   llvm-twine-local = -0.74%
I[15:18:05.442]   llvmlibc-callee-namespace = 1.33%
I[15:18:11.395]   llvmlibc-implementation-in-namespace = 0.96%
I[15:18:17.250]   llvmlibc-restrict-system-libc-headers = -0.91%
I[15:18:23.136]   misc-confusable-identifiers = -0.39%
I[15:20:04.112]   misc-const-correctness = 1609.95%
I[15:20:10.079]   misc-definitions-in-headers = 0.88%
I[15:20:16.024]   misc-misleading-bidirectional = 0.72%
I[15:20:21.992]   misc-misleading-identifier = 0.88%
I[15:20:27.944]   misc-misplaced-const = 0.60%
I[15:20:33.888]   misc-new-delete-overloads = 0.56%
I[15:20:39.933]   misc-no-recursion = 1.85%
I[15:20:45.844]   misc-non-copyable-objects = -0.14%
I[15:20:51.786]   misc-non-private-member-variables-in-classes = 0.59%
I[15:20:57.895]   misc-redundant-expression = 3.19%
I[15:21:03.999]   misc-static-assert = 3.17%
I[15:21:09.943]   misc-throw-by-value-catch-by-reference = 0.71%
I[15:21:15.966]   misc-unconventional-assign-operator = 1.86%
I[15:21:21.954]   misc-uniqueptr-reset-release = 1.36%
I[15:21:27.892]   misc-unused-alias-decls = 0.58%
I[15:21:33.825]   misc-unused-parameters = 0.41%
I[15:21:39.783]   misc-unused-using-decls = 0.77%
I[15:21:45.757]   modernize-avoid-bind = 1.12%
I[15:21:51.786]   modernize-avoid-c-arrays = 1.95%
I[15:21:57.694]   modernize-concat-nested-namespaces = -0.29%
I[15:22:03.548]   modernize-deprecated-headers = -0.92%
I[15:22:09.452]   modernize-deprecated-ios-base-aliases = -0.01%
I[15:22:15.479]   modernize-loop-convert = 2.01%
I[15:22:21.410]   modernize-macro-to-enum = 0.28%
I[15:22:27.297]   modernize-make-shared = -0.39%
I[15:22:33.163]   modernize-make-unique = -0.64%
I[15:22:39.015]   modernize-pass-by-value = -1.22%
I[15:22:44.959]   modernize-raw-string-literal = 0.56%
I[15:22:50.901]   modernize-redundant-void-arg = 0.40%
I[15:22:56.817]   modernize-replace-auto-ptr = 0.35%
I[15:23:02.697]   modernize-replace-disallow-copy-and-assign-macro = -0.38%
I[15:23:08.621]   modernize-replace-random-shuffle = 0.08%
I[15:23:14.599]   modernize-return-braced-init-list = 1.19%
I[15:23:20.493]   modernize-shrink-to-fit = -0.36%
I[15:23:26.337]   modernize-unary-static-assert = -1.23%
I[15:23:32.239]   modernize-use-auto = -0.17%
I[15:23:38.260]   modernize-use-bool-literals = 1.78%
I[15:23:44.142]   modernize-use-default-member-init = -0.50%
I[15:23:50.232]   modernize-use-emplace = 2.78%
I[15:23:56.190]   modernize-use-equals-default = 0.64%
I[15:24:02.048]   modernize-use-equals-delete = -0.98%
I[15:24:07.905]   modernize-use-nodiscard = -1.01%
I[15:24:13.802]   modernize-use-noexcept = -0.28%
I[15:24:19.805]   modernize-use-nullptr = 1.74%
I[15:24:25.658]   modernize-use-override = -0.99%
I[15:24:31.529]   modernize-use-trailing-return-type = -0.55%
I[15:24:37.430]   modernize-use-transparent-functors = -0.01%
I[15:24:43.380]   modernize-use-uncaught-exceptions = 0.64%
I[15:24:49.327]   modernize-use-using = 0.50%
I[15:24:55.208]   objc-assert-equals = -1.02%
I[15:25:01.027]   objc-avoid-nserror-init = -1.76%
I[15:25:06.837]   objc-dealloc-in-category = -1.88%
I[15:25:12.695]   objc-forbidden-subclassing = -0.81%
I[15:25:18.502]   objc-missing-hash = -1.62%
I[15:25:24.328]   objc-nsdate-formatter = -1.46%
I[15:25:30.161]   objc-nsinvocation-argument-lifetime = -1.34%
I[15:25:35.988]   objc-property-declaration = -1.43%
I[15:25:41.790]   objc-super-self = -1.94%
I[15:25:47.602]   openmp-exception-escape = -1.76%
I[15:25:53.433]   openmp-use-default-none = -1.36%
I[15:25:59.359]   performance-faster-string-find = -0.12%
I[15:26:05.195]   performance-for-range-copy = -1.31%
I[15:26:11.018]   performance-implicit-conversion-in-loop = -1.48%
I[15:26:16.917]   performance-inefficient-algorithm = -0.07%
I[15:26:22.843]   performance-inefficient-string-concatenation = 0.38%
I[15:26:28.693]   performance-inefficient-vector-operation = -1.03%
I[15:26:34.693]   performance-move-const-arg = 1.54%
I[15:26:40.509]   performance-move-constructor-init = -1.56%
I[15:26:46.339]   performance-no-automatic-move = -1.52%
I[15:26:52.171]   performance-no-int-to-ptr = -1.28%
I[15:26:58.034]   performance-noexcept-move-constructor = -0.74%
I[15:27:03.880]   performance-trivially-destructible = -0.95%
I[15:27:10.202]   performance-type-promotion-in-math-fn = 7.07%
I[15:27:16.262]   performance-unnecessary-copy-initialization = 2.65%
I[15:27:22.114]   performance-unnecessary-value-param = -0.94%
I[15:27:27.981]   portability-restrict-system-includes = -1.09%
I[15:27:34.000]   portability-simd-intrinsics = 1.84%
I[15:27:39.835]   portability-std-allocator-const = -1.29%
I[15:27:45.667]   readability-avoid-const-params-in-decls = -1.41%
I[15:27:51.582]   readability-braces-around-statements = 0.19%
I[15:27:57.475]   readability-const-return-type = -0.61%
I[15:28:03.314]   readability-container-contains = -1.38%
I[15:28:09.179]   readability-container-data-pointer = -0.80%
I[15:28:15.832]   readability-container-size-empty = 12.57%
I[15:28:21.814]   readability-convert-member-functions-to-static = -1.06%

[it looks like we got somehow throttled from here, as *everything* is ~10% slower]

I[15:28:28.358]   readability-delete-null-pointer = 10.63%
I[15:28:34.883]   readability-duplicate-include = 10.66%
I[15:28:41.466]   readability-else-after-return = 11.32%
I[15:28:48.054]   readability-function-cognitive-complexity = 11.38%
I[15:28:54.690]   readability-function-size = 12.32%
I[15:29:01.325]   readability-identifier-length = 12.55%
I[15:29:08.081]   readability-identifier-naming = 14.38%
I[15:29:14.875]   readability-implicit-bool-conversion = 14.85%
I[15:29:21.419]   readability-inconsistent-declaration-parameter-name = 10.82%
I[15:29:28.028]   readability-isolate-declaration = 11.83%
I[15:29:34.667]   readability-magic-numbers = 12.21%
I[15:29:41.272]   readability-make-member-function-const = 11.79%
I[15:29:47.908]   readability-misleading-indentation = 12.32%
I[15:29:54.455]   readability-misplaced-array-index = 10.67%
I[15:30:00.987]   readability-named-parameter = 10.59%
I[15:30:07.655]   readability-non-const-parameter = 12.98%
I[15:30:14.270]   readability-qualified-auto = 12.06%
I[15:30:20.814]   readability-redundant-access-specifiers = 10.62%
I[15:30:27.458]   readability-redundant-control-flow = 12.43%
I[15:30:34.063]   readability-redundant-declaration = 11.83%
I[15:30:40.574]   readability-redundant-function-ptr-dereference = 10.10%
I[15:30:47.078]   readability-redundant-member-init = 10.08%
I[15:30:53.562]   readability-redundant-preprocessor = 9.60%
I[15:31:00.520]   readability-redundant-smartptr-get = 17.26%
I[15:31:07.190]   readability-redundant-string-cstr = 12.80%
I[15:31:13.807]   readability-redundant-string-init = 12.20%
I[15:31:20.418]   readability-simplify-boolean-expr = 11.01%
I[15:31:26.926]   readability-simplify-subscript-expr = 10.07%
I[15:31:33.442]   readability-static-accessed-through-instance = 10.18%
I[15:31:39.969]   readability-static-definition-in-anonymous-namespace = 10.39%
I[15:31:46.528]   readability-string-compare = 11.01%
I[15:31:53.143]   readability-suspicious-call-argument = 11.94%
I[15:31:59.772]   readability-uniqueptr-delete-release = 11.98%
I[15:32:06.531]   readability-uppercase-literal-suffix = 14.46%
I[15:32:13.167]   readability-use-anyofallof = 12.40%
I[15:32:19.781]   zircon-temporary-objects = 12.10%
I[15:32:26.324]   Final baseline = 2179632621 ns
E[15:32:26.324] Warning: initial/final baseline differs by >2%, throttling?

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

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangTidyCppCoreGuidelinesModule
   AvoidGotoCheck.cpp
+  ConstCorrectnessCheck.cpp
   CppCoreGuidelinesTidyModule.cpp
   InitVariablesCheck.cpp
   InterfacesGlobalInitCheck.cpp
   MacroUsageCheck.cpp
   NarrowingConversionsCheck.cpp
   NoMallocCheck.cpp
   OwningMemoryCheck.cpp
   ProBoundsArrayToPointerDecayCheck.cpp
   ProBoundsConstantArrayIndexCheck.cpp
   ProBoundsPointerArithmeticCheck.cpp
   ProTypeConstCastCheck.cpp
   ProTypeCstyleCastCheck.cpp
   ProTypeMemberInitCheck.cpp
   ProTypeReinterpretCastCheck.cpp
   ProTypeStaticCastDowncastCheck.cpp
   ProTypeUnionAccessCheck.cpp
   ProTypeVarargCheck.cpp
   SlicingCheck.cpp
   SpecialMemberFunctionsCheck.cpp
 
   LINK_LIBS
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   clangSerialization
   clangTidy
   clangTidyMiscModule
   clangTidyModernizeModule
   clangTidyReadabilityModule
   clangTidyUtils
   clangTooling
   )

clang-tools-extra/clang-tidy/cppcoreguidelines/ConstCorrectnessCheck.h

+//===--- ConstCorrectnessCheck.h - clang-tidy -------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_CONSTCORRECTNESSCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_CONSTCORRECTNESSCHECK_H
+
+#include "../ClangTidy.h"
+#include "clang/Analysis/Analyses/ExprMutationAnalyzer.h"
+
+namespace clang {
+namespace tidy {
+
+namespace cppcoreguidelines {
+
+/// This check warns on variables which could be declared const but are not.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-const.html
+class ConstCorrectnessCheck : public ClangTidyCheck {
+public:
+  ConstCorrectnessCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context),
+        AnalyzeValues(Options.get("AnalyzeValues", 1)),
+        AnalyzeReferences(Options.get("AnalyzeReferences", 1)),
+        WarnPointersAsValues(Options.get("WarnPointersAsValues", 0)),
+        TransformValues(Options.get("TransformValues", 1)),
+        TransformReferences(Options.get("TransformReferences", 1)),
+        // TransformPointees(Options.get("TransformPointees", 0)),
+        TransformPointersAsValues(Options.get("TransformPointersAsValues", 0)) {}
+
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+
+private:
+  void registerScope(const CompoundStmt *LocalScope, ASTContext *Context);
+
+  using MutationAnalyzer = std::unique_ptr<ExprMutationAnalyzer>;
+  llvm::DenseMap<const CompoundStmt *, MutationAnalyzer> ScopesCache;
+
+  const bool AnalyzeValues;
+  const bool AnalyzeReferences;
+  const bool WarnPointersAsValues;
+
+  const bool TransformValues;
+  const bool TransformReferences;
+  const bool TransformPointees = false;
+  const bool TransformPointersAsValues;
+};
+
+} // namespace cppcoreguidelines
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_CONSTCORRECTNESSCHECK_H

clang-tools-extra/clang-tidy/cppcoreguidelines/ConstCorrectnessCheck.cpp

+//===--- ConstCorrectnessCheck.cpp - clang-tidy -----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "ConstCorrectnessCheck.h"
+#include "../utils/FixItHintUtils.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace cppcoreguidelines {
+
+namespace {
+// FIXME: This matcher exists in some other code-review as well.
+// It should probably move to ASTMatchers.
+AST_MATCHER(VarDecl, isLocal) { return Node.isLocalVarDecl(); }
+AST_MATCHER_P(DeclStmt, containsDeclaration2,
+              ast_matchers::internal::Matcher<Decl>, InnerMatcher) {
+  return ast_matchers::internal::matchesFirstInPointerRange(
+      InnerMatcher, Node.decl_begin(), Node.decl_end(), Finder, Builder);
+}
+AST_MATCHER(ReferenceType, isSpelledAsLValue) {
+  return Node.isSpelledAsLValue();
+}
+} // namespace
+
+void ConstCorrectnessCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "AnalyzeValues", AnalyzeValues);
+  Options.store(Opts, "AnalyzeReferences", AnalyzeReferences);
+  Options.store(Opts, "WarnPointersAsValues", WarnPointersAsValues);
+
+  Options.store(Opts, "TransformValues", TransformValues);
+  Options.store(Opts, "TransformReferences", TransformReferences);
+  // FIXME: Pointee analysis not proper yet?
+  // Options.store(Opts, "TransformPointees", TransformPointees);
+  Options.store(Opts, "TransformPointersAsValues", TransformPointersAsValues);
+}
+
+void ConstCorrectnessCheck::registerMatchers(MatchFinder *Finder) {
+  const auto ConstType = hasType(isConstQualified());
+  const auto ConstReference = hasType(references(isConstQualified()));
+  const auto RValueReference = hasType(
+      referenceType(anyOf(rValueReferenceType(), unless(isSpelledAsLValue()))));
+  const auto TemplateType = anyOf(hasType(templateTypeParmType()),
+                                  hasType(substTemplateTypeParmType()));
+
+  // Match local variables which could be 'const' if not modified later.
+  // Example: `int i = 10` would match `int i`.
+  const auto LocalValDecl = varDecl(allOf(
+      isLocal(), hasInitializer(anything()),
+      unless(anyOf(ConstType, ConstReference, TemplateType, RValueReference,
+                   hasType(cxxRecordDecl(isLambda())), isImplicit()))));
+
+  // Match the function scope for which the analysis of all local variables
+  // shall be run.
+  const auto FunctionScope = functionDecl(hasBody(
+      compoundStmt(findAll(declStmt(containsDeclaration2(
+                                        LocalValDecl.bind("new-local-value")))
+                               .bind("decl-stmt")))
+          .bind("scope")));
+
+  Finder->addMatcher(FunctionScope, this);
+}
+
+/// Classify for a variable in what the Const-Check is interested.
+enum class VariableCategory { Value, Reference, Pointer };
+
+void ConstCorrectnessCheck::check(const MatchFinder::MatchResult &Result) {
+  const auto *LocalScope = Result.Nodes.getNodeAs<CompoundStmt>("scope");
+  assert(LocalScope && "Did not match scope for local variable");
+  registerScope(LocalScope, Result.Context);
+
+  const auto *Variable = Result.Nodes.getNodeAs<VarDecl>("new-local-value");
+  assert(Variable && "Did not match local variable definition");
+
+  VariableCategory VC = VariableCategory::Value;
+  if (Variable->getType()->isReferenceType())
+    VC = VariableCategory::Reference;
+  if (Variable->getType()->isPointerType())
+    VC = VariableCategory::Pointer;
+
+  // Each variable can only in one category: Value, Pointer, Reference.
+  // Analysis can be controlled for every category.
+  if (VC == VariableCategory::Reference && !AnalyzeReferences)
+    return;
+
+  if (VC == VariableCategory::Pointer && !WarnPointersAsValues)
+    return;
+
+  if (VC == VariableCategory::Value && !AnalyzeValues)
+    return;
+
+  // Offload const-analysis to utility function.
+  if (ScopesCache[LocalScope]->isMutated(Variable))
+    return;
+
+  auto Diag = diag(Variable->getBeginLoc(),
+                   "variable %0 of type %1 can be declared 'const'")
+              << Variable << Variable->getType();
+
+  const auto *VarDeclStmt = Result.Nodes.getNodeAs<DeclStmt>("decl-stmt");
+
+  // It can not be guaranteed that the variable is declared isolated, therefore
+  // a transformation might effect the other variables as well and be incorrect.
+  if (VarDeclStmt == nullptr || !VarDeclStmt->isSingleDecl())
+    return;
+
+  using namespace utils::fixit;
+  using llvm::Optional;
+  if (VC == VariableCategory::Value && TransformValues) {
+    if (Optional<FixItHint> Fix = addQualifierToVarDecl(
+            *Variable, DeclSpec::TQ_const, QualifierTarget::Value,
+            QualifierPolicy::Right, Result.Context))
+      Diag << *Fix;
+    return;
+  }
+
+  if (VC == VariableCategory::Reference && TransformReferences) {
+    if (Optional<FixItHint> Fix = addQualifierToVarDecl(
+            *Variable, DeclSpec::TQ_const, QualifierTarget::Value,
+            QualifierPolicy::Right, Result.Context))
+      Diag << *Fix;
+    return;
+  }
+
+  if (VC == VariableCategory::Pointer) {
+    if (WarnPointersAsValues && TransformPointersAsValues) {
+      if (Optional<FixItHint> Fix = addQualifierToVarDecl(
+              *Variable, DeclSpec::TQ_const, QualifierTarget::Value,
+              QualifierPolicy::Right, Result.Context))
+        Diag << *Fix;
+    }
+    if (TransformPointees) {
+      if (Optional<FixItHint> Fix = addQualifierToVarDecl(
+              *Variable, DeclSpec::TQ_const, QualifierTarget::Pointee,
+              QualifierPolicy::Right, Result.Context))
+        Diag << *Fix;
+    }
+    return;
+  }
+}
+
+void ConstCorrectnessCheck::registerScope(const CompoundStmt *LocalScope,
+                                          ASTContext *Context) {
+  if (ScopesCache.find(LocalScope) == ScopesCache.end())
+    ScopesCache.insert(std::make_pair(
+        LocalScope,
+        std::make_unique<ExprMutationAnalyzer>(*LocalScope, *Context)));
+}
+
+} // namespace cppcoreguidelines
+} // namespace tidy
+} // namespace clang

clang-tools-extra/clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp

 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
 #include "../misc/NonPrivateMemberVariablesInClassesCheck.h"
 #include "../misc/UnconventionalAssignOperatorCheck.h"
 #include "../modernize/AvoidCArraysCheck.h"
 #include "../modernize/UseOverrideCheck.h"
 #include "../readability/MagicNumbersCheck.h"
 #include "AvoidGotoCheck.h"
+#include "ConstCorrectnessCheck.h"
 #include "InitVariablesCheck.h"
 #include "InterfacesGlobalInitCheck.h"
 #include "MacroUsageCheck.h"
 #include "NarrowingConversionsCheck.h"
 #include "NoMallocCheck.h"
 #include "OwningMemoryCheck.h"
 #include "ProBoundsArrayToPointerDecayCheck.h"
 #include "ProBoundsConstantArrayIndexCheck.h"

 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<modernize::AvoidCArraysCheck>(
         "cppcoreguidelines-avoid-c-arrays");
     CheckFactories.registerCheck<AvoidGotoCheck>(
         "cppcoreguidelines-avoid-goto");
     CheckFactories.registerCheck<readability::MagicNumbersCheck>(
         "cppcoreguidelines-avoid-magic-numbers");
+    CheckFactories.registerCheck<ConstCorrectnessCheck>(
+        "cppcoreguidelines-const-correctness");
     CheckFactories.registerCheck<modernize::UseOverrideCheck>(
         "cppcoreguidelines-explicit-virtual-functions");
     CheckFactories.registerCheck<InitVariablesCheck>(
         "cppcoreguidelines-init-variables");
     CheckFactories.registerCheck<InterfacesGlobalInitCheck>(
         "cppcoreguidelines-interfaces-global-init");
     CheckFactories.registerCheck<MacroUsageCheck>(
         "cppcoreguidelines-macro-usage");

clang-tools-extra/clang-tidy/performance/ForRangeCopyCheck.cpp

bool ForRangeCopyCheck::handleConstValueCopy(const VarDecl &LoopVar,
   if (!Expensive || !*Expensive)
     return false;
   auto Diagnostic =
       diag(LoopVar.getLocation(),
            "the loop variable's type is not a reference type; this creates a "
            "copy in each iteration; consider making this a reference")
       << utils::fixit::changeVarDeclToReference(LoopVar, Context);
   if (!LoopVar.getType().isConstQualified())
-    Diagnostic << utils::fixit::changeVarDeclToConst(LoopVar);
+    Diagnostic << *utils::fixit::addQualifierToVarDecl(LoopVar, DeclSpec::TQ::TQ_const);
   return true;
 }
 
 bool ForRangeCopyCheck::handleCopyIsOnlyConstReferenced(
     const VarDecl &LoopVar, const CXXForRangeStmt &ForRange,
     ASTContext &Context) {
   llvm::Optional<bool> Expensive =
       utils::type_traits::isExpensiveToCopy(LoopVar.getType(), Context);
bool ForRangeCopyCheck::handleCopyIsOnlyConstReferenced(
   // Since this case is very rare, it is safe to ignore it.
   if (!ExprMutationAnalyzer(*ForRange.getBody(), Context).isMutated(&LoopVar) &&
       !utils::decl_ref_expr::allDeclRefExprs(LoopVar, *ForRange.getBody(),
                                              Context)
            .empty()) {
     diag(LoopVar.getLocation(),
          "loop variable is copied but only used as const reference; consider "
          "making it a const reference")
-        << utils::fixit::changeVarDeclToConst(LoopVar)
+        << *utils::fixit::addQualifierToVarDecl(LoopVar, DeclSpec::TQ::TQ_const)
         << utils::fixit::changeVarDeclToReference(LoopVar, Context);
     return true;
   }
   return false;
 }
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/performance/UnnecessaryCopyInitialization.cpp

 namespace tidy {
 namespace performance {
 namespace {
 
 void recordFixes(const VarDecl &Var, ASTContext &Context,
                  DiagnosticBuilder &Diagnostic) {
   Diagnostic << utils::fixit::changeVarDeclToReference(Var, Context);
   if (!Var.getType().isLocalConstQualified())
-    Diagnostic << utils::fixit::changeVarDeclToConst(Var);
+    Diagnostic << *utils::fixit::addQualifierToVarDecl(Var, DeclSpec::TQ::TQ_const);
 }
 
 } // namespace
 
 using namespace ::clang::ast_matchers;
 using utils::decl_ref_expr::isOnlyUsedAsConst;
 
 UnnecessaryCopyInitialization::UnnecessaryCopyInitialization(

clang-tools-extra/clang-tidy/performance/UnnecessaryValueParamCheck.cpp

for (const auto *FunctionDecl = Function; FunctionDecl != nullptr;
        FunctionDecl = FunctionDecl->getPreviousDecl()) {
     const auto &CurrentParam = *FunctionDecl->getParamDecl(Index);
     Diag << utils::fixit::changeVarDeclToReference(CurrentParam,
                                                    *Result.Context);
     // The parameter of each declaration needs to be checked individually as to
     // whether it is const or not as constness can differ between definition and
     // declaration.
     if (!CurrentParam.getType().getCanonicalType().isConstQualified())
-      Diag << utils::fixit::changeVarDeclToConst(CurrentParam);
+      Diag << *utils::fixit::addQualifierToVarDecl(CurrentParam,
+                                                   DeclSpec::TQ::TQ_const);
   }
 }
 
 void UnnecessaryValueParamCheck::registerPPCallbacks(
     const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
-  Inserter = std::make_unique<utils::IncludeInserter>(SM, getLangOpts(),
-                                                       IncludeStyle);
+  Inserter =
+      std::make_unique<utils::IncludeInserter>(SM, getLangOpts(), IncludeStyle);
   PP->addPPCallbacks(Inserter->CreatePPCallbacks());
 }
 
 void UnnecessaryValueParamCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "IncludeStyle",
                 utils::IncludeSorter::toString(IncludeStyle));
   Options.store(Opts, "AllowedTypes",

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

 //===--- FixItHintUtils.h - clang-tidy---------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_FIXITHINTUTILS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_FIXITHINTUTILS_H
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
+#include "clang/Sema/DeclSpec.h"
 
 namespace clang {
 namespace tidy {
 namespace utils {
 namespace fixit {
 
 /// Creates fix to make ``VarDecl`` a reference by adding ``&``.
 FixItHint changeVarDeclToReference(const VarDecl &Var, ASTContext &Context);
 
 /// Creates fix to make ``VarDecl`` const qualified.
 FixItHint changeVarDeclToConst(const VarDecl &Var);
 
+/// This enum defines where the 'const' shall be preferably added.
+enum class QualifierPolicy {
+  Left,  // Add the `const` always to the left side, if that is possible.
+  Right, // Add the `const` always to the right side.
+};
+
+/// This enum defines which entity is the target for adding the 'const'. This
+/// makes only a difference for pointer-types. Other types behave identical
+/// for either value of \c ConstTarget.
+enum class QualifierTarget {
+  Pointee, /// Transforming a pointer goes for the pointee and not the pointer
+           /// itself. For references and normal values this option has no
+           /// effect.
+           /// `int * p = &i;` -> `const int * p = &i` or `int const * p = &i`.
+  Value,   /// Transforming pointers will consider the pointer itself.
+           /// `int * p = &i;` -> `int * const = &i`
+};
+
+/// \brief Creates fix to make ``VarDecl`` const qualified. Only valid if
+/// `Var` is isolated in written code. `int foo = 42;`
+///
+/// If the 'FixItHint' would be applied inside a macro or at an invalid
+/// \c SourceLocation it is not returned.
+Optional<FixItHint>
+addQualifierToVarDecl(const VarDecl &Var, DeclSpec::TQ Qualifier,
+                      QualifierTarget CT = QualifierTarget::Pointee,
+                      QualifierPolicy CP = QualifierPolicy::Left,
+                      const ASTContext *Context = nullptr);
+
 } // namespace fixit
 } // namespace utils
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_FIXITHINTUTILS_H

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

auto Token = utils::lexer::getPreviousToken(
       AmpLocation, Context.getSourceManager(), Context.getLangOpts());
   if (!Token.is(tok::unknown))
     AmpLocation = Lexer::getLocForEndOfToken(Token.getLocation(), 0,
                                              Context.getSourceManager(),
                                              Context.getLangOpts());
   return FixItHint::CreateInsertion(AmpLocation, "&");
 }
 
-FixItHint changeVarDeclToConst(const VarDecl &Var) {
-  return FixItHint::CreateInsertion(Var.getTypeSpecStartLoc(), "const ");
+static bool isValueType(const Type *T) {
+  return !(isa<PointerType>(T) || isa<ReferenceType>(T) || isa<ArrayType>(T) ||
+           isa<MemberPointerType>(T));
 }
+static bool isValueType(QualType QT) { return isValueType(QT.getTypePtr()); }
+static bool isArrayType(QualType QT) { return isa<ArrayType>(QT.getTypePtr()); }
+static bool isReferenceType(QualType QT) {
+  return isa<ReferenceType>(QT.getTypePtr());
+}
+static bool isPointerType(const Type *T) { return isa<PointerType>(T); }
+static bool isPointerType(QualType QT) {
+  return isPointerType(QT.getTypePtr());
+}
+static bool isMemberOrFunctionPointer(QualType QT) {
+  return (isPointerType(QT) && QT->isFunctionPointerType()) ||
+         isa<MemberPointerType>(QT.getTypePtr());
+}
+static bool locDangerous(SourceLocation S) {
+  return S.isInvalid() || S.isMacroID();
+}
+
+static Optional<SourceLocation>
+skipLParensBackwards(SourceLocation Start, const ASTContext &Context) {
+  Token T;
+  auto PreviousTokenLParen = [&]() {
+    T = lexer::getPreviousToken(Start, Context.getSourceManager(),
+                                Context.getLangOpts());
+    return T.is(tok::l_paren);
+  };
+  while (PreviousTokenLParen()) {
+    if (locDangerous(Start))
+      return None;
+    Start = lexer::findPreviousTokenStart(Start, Context.getSourceManager(),
+                                          Context.getLangOpts());
+  }
+  if (locDangerous(Start))
+    return None;
+  return Start;
+}
+
+static Optional<FixItHint> fixIfNotDangerous(SourceLocation Loc,
+                                             StringRef Text) {
+  if (locDangerous(Loc))
+    return None;
+  return FixItHint::CreateInsertion(Loc, Text);
+}
+
+// Build a string that can be emitted as FixIt with either a space in before
+// or after the qualifier, either ' const' or 'const '.
+static std::string buildQualifier(DeclSpec::TQ Qualifier,
+                                  bool WhitespaceBefore = false) {
+  if (WhitespaceBefore)
+    return (llvm::Twine(' ') + DeclSpec::getSpecifierName(Qualifier)).str();
+  return (llvm::Twine(DeclSpec::getSpecifierName(Qualifier)) + llvm::Twine(' '))
+      .str();
+}
+
+static Optional<FixItHint> changeValue(const VarDecl &Var,
+                                       DeclSpec::TQ Qualifier,
+                                       QualifierTarget QualTarget,
+                                       QualifierPolicy QualPolicy,
+                                       const ASTContext &Context) {
+  switch (QualPolicy) {
+  case QualifierPolicy::Left:
+    return fixIfNotDangerous(Var.getTypeSpecStartLoc(),
+                             buildQualifier(Qualifier));
+  case QualifierPolicy::Right:
+    Optional<SourceLocation> IgnoredParens =
+        skipLParensBackwards(Var.getLocation(), Context);
+
+    if (IgnoredParens)
+      return fixIfNotDangerous(*IgnoredParens, buildQualifier(Qualifier));
+    return None;
+  }
+}
+
+static Optional<FixItHint> changePointerItself(const VarDecl &Var,
+                                               DeclSpec::TQ Qualifier,
+                                               const ASTContext &Context) {
+  if (locDangerous(Var.getLocation()))
+    return None;
+
+  Optional<SourceLocation> IgnoredParens =
+      skipLParensBackwards(Var.getLocation(), Context);
+  if (IgnoredParens)
+    return fixIfNotDangerous(*IgnoredParens, buildQualifier(Qualifier));
+  return None;
+}
+
+static Optional<FixItHint>
+changePointer(const VarDecl &Var, DeclSpec::TQ Qualifier, const Type *Pointee,
+              QualifierTarget QualTarget, QualifierPolicy QualPolicy,
+              const ASTContext &Context) {
+  // The pointer itself shall be marked as `const`. This is always to the right
+  // of the '*' or in front of the identifier.
+  if (QualTarget == QualifierTarget::Value)
+    return changePointerItself(Var, Qualifier, Context);
+
+  // Mark the pointee `const` that is a normal value (`int* p = nullptr;`).
+  if (QualTarget == QualifierTarget::Pointee && isValueType(Pointee)) {
+    // Adding the `const` on the left side is just the beginning of the type
+    // specification. (`const int* p = nullptr;`)
+    if (QualPolicy == QualifierPolicy::Left)
+      return fixIfNotDangerous(Var.getTypeSpecStartLoc(),
+                               buildQualifier(Qualifier));
+
+    // Adding the `const` on the right side of the value type requires finding
+    // the `*` token and placing the `const` left of it.
+    // (`int const* p = nullptr;`)
+    if (QualPolicy == QualifierPolicy::Right) {
+      SourceLocation BeforeStar = lexer::findPreviousTokenKind(
+          Var.getLocation(), Context.getSourceManager(), Context.getLangOpts(),
+          tok::star);
+      if (locDangerous(BeforeStar))
+        return None;
 
+      Optional<SourceLocation> IgnoredParens =
+          skipLParensBackwards(BeforeStar, Context);
+
+      if (IgnoredParens)
+        return fixIfNotDangerous(*IgnoredParens,
+                                 buildQualifier(Qualifier, true));
+      return None;
+    }
+  }
+
+  if (QualTarget == QualifierTarget::Pointee && isPointerType(Pointee)) {
+    // Adding the `const` to the pointee if the pointee is a pointer
+    // is the same as 'QualPolicy == Right && isValueType(Pointee)'.
+    // The `const` must be left of the last `*` token.
+    // (`int * const* p = nullptr;`)
+    SourceLocation BeforeStar = lexer::findPreviousTokenKind(
+        Var.getLocation(), Context.getSourceManager(), Context.getLangOpts(),
+        tok::star);
+    return fixIfNotDangerous(BeforeStar, buildQualifier(Qualifier, true));
+  }
+
+  llvm_unreachable("All paths should have been handled");
+}
+
+static Optional<FixItHint>
+changeReferencee(const VarDecl &Var, DeclSpec::TQ Qualifier, QualType Pointee,
+                 QualifierTarget QualTarget, QualifierPolicy QualPolicy,
+                 const ASTContext &Context) {
+  if (QualPolicy == QualifierPolicy::Left && isValueType(Pointee))
+    return fixIfNotDangerous(Var.getTypeSpecStartLoc(),
+                             buildQualifier(Qualifier));
+
+  SourceLocation BeforeRef = lexer::findPreviousAnyTokenKind(
+      Var.getLocation(), Context.getSourceManager(), Context.getLangOpts(),
+      tok::amp, tok::ampamp);
+  Optional<SourceLocation> IgnoredParens =
+      skipLParensBackwards(BeforeRef, Context);
+  if (IgnoredParens)
+    return fixIfNotDangerous(*IgnoredParens, buildQualifier(Qualifier, true));
+
+  return None;
+}
+
+Optional<FixItHint> addQualifierToVarDecl(const VarDecl &Var,
+                                          DeclSpec::TQ Qualifier,
+                                          QualifierTarget QualTarget,
+                                          QualifierPolicy QualPolicy,
+                                          const ASTContext *Context) {
+  assert((QualPolicy == QualifierPolicy::Left ||
+          QualPolicy == QualifierPolicy::Right) &&
+         "Unexpected Insertion Policy");
+  assert((QualTarget == QualifierTarget::Pointee ||
+          QualTarget == QualifierTarget::Value) &&
+         "Unexpected Target");
+
+  QualType ParenStrippedType = Var.getType().IgnoreParens();
+  if (isValueType(ParenStrippedType))
+    return changeValue(Var, Qualifier, QualTarget, QualPolicy, *Context);
+
+  if (isReferenceType(ParenStrippedType))
+    return changeReferencee(Var, Qualifier, Var.getType()->getPointeeType(),
+                            QualTarget, QualPolicy, *Context);
+
+  if (isMemberOrFunctionPointer(ParenStrippedType))
+    return changePointerItself(Var, Qualifier, *Context);
+
+  if (isPointerType(ParenStrippedType))
+    return changePointer(Var, Qualifier,
+                         ParenStrippedType->getPointeeType().getTypePtr(),
+                         QualTarget, QualPolicy, *Context);
+
+  if (isArrayType(ParenStrippedType)) {
+    const Type *AT = ParenStrippedType->getBaseElementTypeUnsafe();
+    assert(AT && "Did not retrieve array element type for an array.");
+
+    if (isValueType(AT))
+      return changeValue(Var, Qualifier, QualTarget, QualPolicy, *Context);
+
+    if (isPointerType(AT))
+      return changePointer(Var, Qualifier, AT->getPointeeType().getTypePtr(),
+                           QualTarget, QualPolicy, *Context);
+  }
+
+  return {};
+  llvm_unreachable(
+      "All possible combinations should have been handled already");
+}
 } // namespace fixit
 } // namespace utils
 } // namespace tidy
 } // namespace clang

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

 SourceLocation findNextTerminator(SourceLocation Start, const SourceManager &SM,
                                   const LangOptions &LangOpts);
 
 template <typename TokenKind, typename... TokenKinds>
 SourceLocation findPreviousAnyTokenKind(SourceLocation Start,
                                         const SourceManager &SM,
                                         const LangOptions &LangOpts,
                                         TokenKind TK, TokenKinds... TKs) {
+  if (Start.isInvalid() || Start.isMacroID())
+    return SourceLocation();
   while (true) {
     SourceLocation L = findPreviousTokenStart(Start, SM, LangOpts);
     if (L.isInvalid() || L.isMacroID())
       return SourceLocation();
 
     Token T;
     // Returning 'true' is used to signal failure to retrieve the token.
-    if (Lexer::getRawToken(L, T, SM, LangOpts))
+    if (Lexer::getRawToken(L, T, SM, LangOpts, /*IgnoreWhiteSpace=*/true))
       return SourceLocation();
 
     if (T.isOneOf(TK, TKs...))
       return T.getLocation();
 
     Start = L;
   }
 }

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

SourceLocation findPreviousTokenStart(SourceLocation Start,
 
   return Lexer::GetBeginningOfToken(BeforeStart, SM, LangOpts);
 }
 
 SourceLocation findPreviousTokenKind(SourceLocation Start,
                                      const SourceManager &SM,
                                      const LangOptions &LangOpts,
                                      tok::TokenKind TK) {
+  if (Start.isInvalid() || Start.isMacroID())
+    return SourceLocation();
+
   while (true) {
     SourceLocation L = findPreviousTokenStart(Start, SM, LangOpts);
     if (L.isInvalid() || L.isMacroID())
       return SourceLocation();
 
     Token T;
     if (Lexer::getRawToken(L, T, SM, LangOpts, /*IgnoreWhiteSpace=*/true))
       return SourceLocation();

clang-tools-extra/docs/ReleaseNotes.rst

 - New alias :doc:`cert-pos44-c
   <clang-tidy/checks/cert-pos44-c>` to
   :doc:`bugprone-bad-signal-to-kill-thread
   <clang-tidy/checks/bugprone-bad-signal-to-kill-thread>` was added.
 
 - New :doc:`cppcoreguidelines-init-variables
   <clang-tidy/checks/cppcoreguidelines-init-variables>` check.
 
+- New :doc:`cppcoreguidelines-const-correctness
+  <clang-tidy/checks/cppcoreguidelines-const-correctness>` check.
+
+  Suggest adding ``const`` to unmodified local variables.
+
 - New :doc:`darwin-dispatch-once-nonstatic
   <clang-tidy/checks/darwin-dispatch-once-nonstatic>` check.
 
   Finds declarations of ``dispatch_once_t`` variables without static or global
   storage.
 
 - New :doc:`google-upgrade-googletest-case
   <clang-tidy/checks/google-upgrade-googletest-case>` check.
 
   Finds uses of deprecated Googletest APIs with names containing ``case`` and
   replaces them with equivalent APIs with ``suite``.
 
 - Improved :doc:`hicpp-signed-bitwise
   <clang-tidy/checks/hicpp-signed-bitwise>` check.
 
   The check now supports the ``IgnorePositiveIntegerLiterals`` option.
 
 - New :doc:`linuxkernel-must-use-errs
   <clang-tidy/checks/linuxkernel-must-use-errs>` check.
 
   Checks Linux kernel code to see if it uses the results from the functions in
   ``linux/err.h``.
 
 - New :doc:`llvm-prefer-register-over-unsigned
   <clang-tidy/checks/llvm-prefer-register-over-unsigned>` check.
 
   Finds historical use of ``unsigned`` to hold vregs and physregs and rewrites
   them to use ``Register``
 
 - New :doc:`objc-missing-hash
   <clang-tidy/checks/objc-missing-hash>` check.
 
   Finds Objective-C implementations that implement ``-isEqual:`` without also
   appropriately implementing ``-hash``.
 
 - New :doc:`performance-trivially-destructible
   <clang-tidy/checks/performance-trivially-destructible>` check.
 
   Finds types that could be made trivially-destructible by removing out-of-line
   defaulted destructor declarations.
 
 - Improved :doc:`bugprone-posix-return
   <clang-tidy/checks/bugprone-posix-return>` check.
 
   Now also checks if any calls to ``pthread_*`` functions expect negative return
   values.

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines-const-correctness.rst

+.. title:: clang-tidy - cppcoreguidelines-const-correctness
+
+cppcoreguidelines-const-correctness
+===================================
+
+This check implements detection of local variables which could be declared as
+``const``, but are not. Declaring variables as ``const`` is required by many
+coding guidelines, such as:
+`CppCoreGuidelines ES.25 <https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#es25-declare-an-object-const-or-constexpr-unless-you-want-to-modify-its-value-later-on>`_
+and `High Integrity C++ 7.1.2 <http://www.codingstandard.com/rule/7-1-2-use-const-whenever-possible/>`_.
+
+Please note that this analysis is type-based only. Variables that are not modified
+but non-const handles might escape out of the scope are not diagnosed as potential
+``const``.
+
+.. code-block:: c++
+  
+  // Declare a variable, which is not ``const`` ...
+  int i = 42;
+  // but use it as read-only. This means that `i` can be declared ``const``.
+  int result = i * i;
+
+The check analyzes values, pointers and references (if configured that way).
+For better understanding some code samples:
+
+.. code-block:: c++
+
+  // Normal values like built-ins or objects.
+  int potential_const_int = 42;
+  int copy_of_value = potential_const_int;
+
+  MyClass could_be_const;
+  could_be_const.const_qualified_method();
+
+  // References can be declared const as well.
+  int &reference_value = potential_const_int;
+  int another_copy = reference_value;
+
+  // Similar behaviour for pointers.
+  int *pointer_variable = &potential_const_int;
+  int last_copy = *pointer_variable;
+
+
+Options
+-------
+
+.. option:: AnalyzeValues (default = 1)
+
+  Enable or disable the analysis of ordinary value variables, like ``int i = 42;``
+
+.. option:: AnalyzeReferences (default = 1)
+
+  Enable or disable the analysis of reference variables, like ``int &ref = i;``
+
+.. option:: WarnPointersAsValues (default = 0)
+
+  This option enables the suggestion for ``const`` of the pointer itself.
+  Pointer values have two possibilities to be ``const``, the pointer itself
+  and the value pointing to. 
+
+  .. code-block:: c++
+
+    const int value = 42;
+    const int * const pointer_variable = &value;
+    
+    // The following operations are forbidden for `pointer_variable`.
+    // *pointer_variable = 44;
+    // pointer_variable = nullptr;

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

 .. title:: clang-tidy - Clang-Tidy Checks
 
 Clang-Tidy Checks
 =================
 
 .. toctree::
    abseil-duration-addition
    abseil-duration-comparison
    abseil-duration-conversion-cast
    abseil-duration-division
    abseil-duration-factory-float
    abseil-duration-factory-scale
    abseil-duration-subtraction
    abseil-duration-unnecessary-conversion
    abseil-faster-strsplit-delimiter
.. toctree::
    clang-analyzer-unix.cstring.NullArg (redirects to https://clang.llvm.org/docs/analyzer/checkers) <clang-analyzer-unix.cstring.NullArg>
    clang-analyzer-valist.CopyToSelf
    clang-analyzer-valist.Uninitialized
    clang-analyzer-valist.Unterminated
    cppcoreguidelines-avoid-c-arrays (redirects to modernize-avoid-c-arrays) <cppcoreguidelines-avoid-c-arrays>
    cppcoreguidelines-avoid-goto
    cppcoreguidelines-avoid-magic-numbers (redirects to readability-magic-numbers) <cppcoreguidelines-avoid-magic-numbers>
    cppcoreguidelines-c-copy-assignment-signature (redirects to misc-unconventional-assign-operator) <cppcoreguidelines-c-copy-assignment-signature>
+   cppcoreguidelines-const-correctness
    cppcoreguidelines-explicit-virtual-functions (redirects to modernize-use-override) <cppcoreguidelines-explicit-virtual-functions>
    cppcoreguidelines-init-variables
    cppcoreguidelines-interfaces-global-init
    cppcoreguidelines-macro-usage
    cppcoreguidelines-narrowing-conversions
    cppcoreguidelines-no-malloc
    cppcoreguidelines-non-private-member-variables-in-classes (redirects to misc-non-private-member-variables-in-classes) <cppcoreguidelines-non-private-member-variables-in-classes>
    cppcoreguidelines-owning-memory

clang-tools-extra/test/clang-tidy/cppcoreguidelines-const-correctness-pointer-as-values.cpp

+// RUN: %check_clang_tidy %s cppcoreguidelines-const-correctness %t \
+// RUN: -config='{CheckOptions: \
+// RUN:  [{key: "cppcoreguidelines-const-correctness.AnalyzeValues", value: 1},\
+// RUN:   {key: "cppcoreguidelines-const-correctness.WarnPointersAsValues", value: 1}]}' \
+// RUN: --
+
+void potential_const_pointer() {
+  double np_local0[10] = {0., 1., 2., 3., 4., 5., 6., 7., 8., 9.};
+  double *p_local0 = &np_local0[1];
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'double *' can be declared 'const'
+}

clang-tools-extra/test/clang-tidy/cppcoreguidelines-const-correctness-transform-pointer-as-values.cpp

+// RUN: %check_clang_tidy %s cppcoreguidelines-const-correctness %t \
+// RUN: -config='{CheckOptions: \
+// RUN:  [{key: "cppcoreguidelines-const-correctness.AnalyzeValues", value: 1},\
+// RUN:   {key: "cppcoreguidelines-const-correctness.WarnPointersAsValues", value: 1}, \
+// RUN:   {key: "cppcoreguidelines-const-correctness.TransformPointersAsValues", value: 1},\
+// RUN:  ]}' --
+
+void potential_const_pointer() {
+  double np_local0[10] = {0., 1., 2., 3., 4., 5., 6., 7., 8., 9.};
+  double *p_local0 = &np_local0[1];
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'double *' can be declared 'const'
+  // CHECK-FIXES: const
+}

clang-tools-extra/test/clang-tidy/cppcoreguidelines-const-correctness-transform-values.cpp

+// RUN: %check_clang_tidy %s cppcoreguidelines-const-correctness %t -- \
+// RUN:   -config="{CheckOptions: [\
+// RUN:   {key: 'cppcoreguidelines-const-correctness.TransformValues', value: 1},\
+// RUN:   ]}" --
+
+bool global;
+char np_global = 0; // globals can't be known to be const
+
+namespace foo {
+int scoped;
+float np_scoped = 1; // namespace variables are like globals
+} // namespace foo
+
+// Lambdas should be ignored, because they do not follow the normal variable
+// semantic (e.g. the type is only known to the compiler).
+void lambdas() {
+  auto Lambda = [](int i) { return i < 0; };
+}
+
+void some_function(double, wchar_t);
+
+void some_function(double np_arg0, wchar_t np_arg1) {
+  int p_local0 = 2;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'int' can be declared 'const'
+  // CHECK-FIXES: const
+}
+
+void nested_scopes() {
+  {
+    int p_local1 = 42;
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: variable 'p_local1' of type 'int' can be declared 'const'
+    // CHECK-FIXES: const
+  }
+}
+
+template <typename T>
+void define_locals(T np_arg0, T &np_arg1, int np_arg2) {
+  T p_local0 = 0;
+  int p_local1 = 42;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local1' of type 'int' can be declared 'const'
+  // CHECK-FIXES: const
+}
+
+void template_instantiation() {
+  const int np_local0 = 42;
+  int np_local1 = 42;
+
+  define_locals(np_local0, np_local1, np_local0);
+  define_locals(np_local1, np_local1, np_local1);
+}
+
+struct ConstNonConstClass {
+  ConstNonConstClass();
+  ConstNonConstClass(double &np_local0);
+  double nonConstMethod() {}
+  double constMethod() const {}
+  double modifyingMethod(double &np_arg0) const;
+
+  double NonConstMember;
+  const double ConstMember;
+
+  double &NonConstMemberRef;
+  const double &ConstMemberRef;
+
+  double *NonConstMemberPtr;
+  const double *ConstMemberPtr;
+};
+
+void direct_class_access() {
+  ConstNonConstClass p_local0;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'ConstNonConstClass' can be declared 'const'
+  // CHECK-FIXES: const
+  p_local0.constMethod();
+}
+
+void class_access_array() {
+  ConstNonConstClass p_local0[2];
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'ConstNonConstClass [2]' can be declared 'const'
+  // CHECK-FIXES: const
+  p_local0[0].constMethod();
+}
+
+struct MyVector {
+  double *begin();
+  const double *begin() const;
+
+  double *end();
+  const double *end() const;
+
+  double &operator[](int index);
+  double operator[](int index) const;
+
+  double values[100];
+};
+
+void vector_usage() {
+  double p_local0[10] = {0., 1., 2., 3., 4., 5., 6., 7., 8., 9.};
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'double [10]' can be declared 'const'
+  // CHECK-FIXES: const
+}
+
+void range_for() {
+  int np_local0[2] = {1, 2};
+  int *np_local3[2] = {&np_local0[0], &np_local0[1]};
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'np_local3' of type 'int *[2]' can be declared 'const'
+  // CHECK-FIXES: const
+  for (int *non_const_ptr : np_local3) {
+    *non_const_ptr = 45;
+  }
+}
+
+void casts() {
+  decltype(sizeof(void *)) p_local0 = 42;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'decltype(sizeof(void *))' (aka 'unsigned long') can be declared 'const'
+  // CHECK-FIXES: const
+}
+
+// taken from http://www.cplusplus.com/reference/type_traits/integral_constant/
+template <typename T, T v>
+struct integral_constant {
+  static constexpr T value = v;
+  using value_type = T;
+  using type = integral_constant<T, v>;
+  constexpr operator T() { return v; }
+};
+
+template <typename T>
+struct is_integral : integral_constant<bool, false> {};
+template <>
+struct is_integral<int> : integral_constant<bool, true> {};
+
+template <typename T>
+struct not_integral : integral_constant<bool, false> {};
+template <>
+struct not_integral<double> : integral_constant<bool, true> {};
+
+// taken from http://www.cplusplus.com/reference/type_traits/enable_if/
+template <bool Cond, typename T = void>
+struct enable_if {};
+
+template <typename T>
+struct enable_if<true, T> { using type = T; };
+
+template <typename T>
+struct TMPClass {
+  T alwaysConst() const { return T{}; }
+
+  template <typename T2 = T, typename = typename enable_if<is_integral<T2>::value>::type>
+  T sometimesConst() const { return T{}; }
+
+  template <typename T2 = T, typename = typename enable_if<not_integral<T2>::value>::type>
+  T sometimesConst() { return T{}; }
+};
+
+void meta_type() {
+  TMPClass<int> p_local0;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'TMPClass<int>' can be declared 'const'
+  // CHECK-FIXES: const
+  p_local0.alwaysConst();
+  p_local0.sometimesConst();
+
+  TMPClass<double> p_local1;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local1' of type 'TMPClass<double>' can be declared 'const'
+  // CHECK-FIXES: const
+  p_local1.alwaysConst();
+}

clang-tools-extra/test/clang-tidy/cppcoreguidelines-const-correctness-values.cpp

+// RUN: %check_clang_tidy %s cppcoreguidelines-const-correctness %t
+
+// ------- Provide test samples for primitive builtins ---------
+// - every 'p_*' variable is a 'potential_const_*' variable
+// - every 'np_*' variable is a 'non_potential_const_*' variable
+
+bool global;
+char np_global = 0; // globals can't be known to be const
+
+namespace foo {
+int scoped;
+float np_scoped = 1; // namespace variables are like globals
+} // namespace foo
+
+// Lambdas should be ignored, because they do not follow the normal variable
+// semantic (e.g. the type is only known to the compiler).
+void lambdas() {
+  auto Lambda = [](int i) { return i < 0; };
+}
+
+void some_function(double, wchar_t);
+
+void some_function(double np_arg0, wchar_t np_arg1) {
+  int p_local0 = 2;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'int' can be declared 'const'
+
+  int np_local0;
+  const int np_local1 = 42;
+
+  unsigned int np_local2 = 3;
+  np_local2 <<= 4;
+
+  int np_local3 = 4;
+  ++np_local3;
+  int np_local4 = 4;
+  np_local4++;
+
+  int np_local5 = 4;
+  --np_local5;
+  int np_local6 = 4;
+  np_local6--;
+}
+
+void nested_scopes() {
+  int p_local0 = 2;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'int' can be declared 'const'
+  int np_local0 = 42;
+
+  {
+    int p_local1 = 42;
+    // CHECK-MESSAGES: [[@LINE-1]]:5: warning: variable 'p_local1' of type 'int' can be declared 'const'
+    np_local0 *= 2;
+  }
+}
+
+void some_lambda_environment_capture_all_by_reference(double np_arg0) {
+  int np_local0 = 0;
+  int p_local0 = 1;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'int' can be declared 'const'
+
+  int np_local2;
+  const int np_local3 = 2;
+
+  // Capturing all variables by reference prohibits making them const.
+  [&]() { ++np_local0; };
+
+  int p_local1 = 0;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local1' of type 'int' can be declared 'const'
+}
+
+void some_lambda_environment_capture_all_by_value(double np_arg0) {
+  int np_local0 = 0;
+  int p_local0 = 1;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'int' can be declared 'const'
+
+  int np_local1;
+  const int np_local2 = 2;
+
+  // Capturing by value has no influence on them.
+  [=]() { (void)p_local0; };
+
+  np_local0 += 10;
+}
+
+void function_inout_pointer(int *inout);
+void function_in_pointer(const int *in);
+
+void some_pointer_taking(int *out) {
+  int np_local0 = 42;
+  const int *const p0_np_local0 = &np_local0;
+  int *const p1_np_local0 = &np_local0;
+
+  int np_local1 = 42;
+  const int *const p0_np_local1 = &np_local1;
+  int *const p1_np_local1 = &np_local1;
+  *p1_np_local0 = 43;
+
+  int np_local2 = 42;
+  function_inout_pointer(&np_local2);
+
+  // Prevents const.
+  int np_local3 = 42;
+  out = &np_local3; // This returns and invalid address, its just about the AST
+
+  int p_local1 = 42;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local1' of type 'int' can be declared 'const'
+  const int *const p0_p_local1 = &p_local1;
+
+  int p_local2 = 42;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local2' of type 'int' can be declared 'const'
+  function_in_pointer(&p_local2);
+}
+
+void function_inout_ref(int &inout);
+void function_in_ref(const int &in);
+
+void some_reference_taking() {
+  int np_local0 = 42;
+  const int &r0_np_local0 = np_local0;
+  int &r1_np_local0 = np_local0;
+  r1_np_local0 = 43;
+  const int &r2_np_local0 = r1_np_local0;
+
+  int np_local1 = 42;
+  function_inout_ref(np_local1);
+
+  int p_local0 = 42;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'int' can be declared 'const'
+  const int &r0_p_local0 = p_local0;
+
+  int p_local1 = 42;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local1' of type 'int' can be declared 'const'
+  function_in_ref(p_local1);
+}
+
+double *non_const_pointer_return() {
+  double p_local0 = 0.0;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'double' can be declared 'const'
+  double np_local0 = 24.4;
+
+  return &np_local0;
+}
+
+const double *const_pointer_return() {
+  double p_local0 = 0.0;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'double' can be declared 'const'
+  double p_local1 = 24.4;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local1' of type 'double' can be declared 'const'
+  return &p_local1;
+}
+
+double &non_const_ref_return() {
+  double p_local0 = 0.0;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'double' can be declared 'const'
+  double np_local0 = 42.42;
+  return np_local0;
+}
+
+const double &const_ref_return() {
+  double p_local0 = 0.0;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'double' can be declared 'const'
+  double p_local1 = 24.4;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local1' of type 'double' can be declared 'const'
+  return p_local1;
+}
+
+double *&return_non_const_pointer_ref() {
+  double *np_local0 = nullptr;
+  return np_local0;
+}
+
+void overloaded_arguments(const int &in);
+void overloaded_arguments(int &inout);
+void overloaded_arguments(const int *in);
+void overloaded_arguments(int *inout);
+
+void function_calling() {
+  int np_local0 = 42;
+  overloaded_arguments(np_local0);
+
+  const int np_local1 = 42;
+  overloaded_arguments(np_local1);
+
+  int np_local2 = 42;
+  overloaded_arguments(&np_local2);
+
+  const int np_local3 = 42;
+  overloaded_arguments(&np_local3);
+}
+
+template <typename T>
+void define_locals(T np_arg0, T &np_arg1, int np_arg2) {
+  T np_local0 = 0;
+  np_local0 += np_arg0 * np_arg1;
+
+  T np_local1 = 42;
+  np_local0 += np_local1;
+
+  // Used as argument to an overloaded function with const and non-const.
+  T np_local2 = 42;
+  overloaded_arguments(np_local2);
+
+  int np_local4 = 42;
+  // non-template values are ok still.
+  int p_local0 = 42;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'int' can be declared 'const'
+  np_local4 += p_local0;
+}
+
+void template_instantiation() {
+  const int np_local0 = 42;
+  int np_local1 = 42;
+
+  define_locals(np_local0, np_local1, np_local0);
+  define_locals(np_local1, np_local1, np_local1);
+}
+
+struct ConstNonConstClass {
+  ConstNonConstClass();
+  ConstNonConstClass(double &np_local0);
+  double nonConstMethod() {}
+  double constMethod() const {}
+  double modifyingMethod(double &np_arg0) const;
+
+  double NonConstMember;
+  const double ConstMember;
+
+  double &NonConstMemberRef;
+  const double &ConstMemberRef;
+
+  double *NonConstMemberPtr;
+  const double *ConstMemberPtr;
+};
+
+void direct_class_access() {
+  ConstNonConstClass np_local0;
+
+  np_local0.constMethod();
+  np_local0.nonConstMethod();
+
+  ConstNonConstClass p_local0;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'ConstNonConstClass' can be declared 'const'
+  p_local0.constMethod();
+
+  ConstNonConstClass p_local1;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local1' of type 'ConstNonConstClass' can be declared 'const'
+  double np_local1;
+  p_local1.modifyingMethod(np_local1);
+
+  double np_local2;
+  ConstNonConstClass p_local2(np_local2);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local2' of type 'ConstNonConstClass' can be declared 'const'
+
+  ConstNonConstClass np_local3;
+  np_local3.NonConstMember = 42.;
+
+  ConstNonConstClass np_local4;
+  np_local4.NonConstMemberRef = 42.;
+
+  ConstNonConstClass p_local3;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local3' of type 'ConstNonConstClass' can be declared 'const'
+  const double val0 = p_local3.NonConstMember;
+  const double val1 = p_local3.NonConstMemberRef;
+  const double val2 = *p_local3.NonConstMemberPtr;
+
+  ConstNonConstClass p_local4;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local4' of type 'ConstNonConstClass' can be declared 'const'
+  *np_local4.NonConstMemberPtr = 42.;
+}
+
+void class_access_array() {
+  ConstNonConstClass np_local0[2];
+  np_local0[0].constMethod();
+  np_local0[1].constMethod();
+  np_local0[1].nonConstMethod();
+
+  ConstNonConstClass p_local0[2];
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'ConstNonConstClass [2]' can be declared 'const'
+  p_local0[0].constMethod();
+  np_local0[1].constMethod();
+}
+
+struct OperatorsAsConstAsPossible {
+  OperatorsAsConstAsPossible &operator+=(const OperatorsAsConstAsPossible &rhs);
+  OperatorsAsConstAsPossible operator+(const OperatorsAsConstAsPossible &rhs) const;
+};
+
+struct NonConstOperators {
+};
+NonConstOperators operator+(NonConstOperators &lhs, NonConstOperators &rhs);
+NonConstOperators operator-(NonConstOperators lhs, NonConstOperators rhs);
+
+void internal_operator_calls() {
+  OperatorsAsConstAsPossible np_local0;
+  OperatorsAsConstAsPossible np_local1;
+  OperatorsAsConstAsPossible p_local0;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'OperatorsAsConstAsPossible' can be declared 'const'
+  OperatorsAsConstAsPossible p_local1;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local1' of type 'OperatorsAsConstAsPossible' can be declared 'const'
+
+  np_local0 += p_local0;
+  np_local1 = p_local0 + p_local1;
+
+  NonConstOperators np_local2;
+  NonConstOperators np_local3;
+  NonConstOperators np_local4;
+
+  np_local2 = np_local3 + np_local4;
+
+  NonConstOperators p_local2;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local2' of type 'NonConstOperators' can be declared 'const'
+  NonConstOperators p_local3 = p_local2 - p_local2;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local3' of type 'NonConstOperators' can be declared 'const'
+}
+
+struct MyVector {
+  double *begin();
+  const double *begin() const;
+
+  double *end();
+  const double *end() const;
+
+  double &operator[](int index);
+  double operator[](int index) const;
+
+  double values[100];
+};
+
+void vector_usage() {
+  double np_local0[10];
+  np_local0[5] = 42.;
+
+  MyVector np_local1;
+  np_local1[5] = 42.;
+
+  double p_local0[10] = {0., 1., 2., 3., 4., 5., 6., 7., 8., 9.};
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'double [10]' can be declared 'const'
+  double p_local1 = p_local0[5];
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local1' of type 'double' can be declared 'const'
+
+  // The following subscript calls suprisingly choose the non-const operator
+  // version.
+  MyVector np_local2;
+  double p_local2 = np_local2[42];
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local2' of type 'double' can be declared 'const'
+
+  MyVector np_local3;
+  const double np_local4 = np_local3[42];
+
+  // This subscript results in const overloaded operator.
+  const MyVector np_local5{};
+  double p_local3 = np_local5[42];
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local3' of type 'double' can be declared 'const'
+}
+
+void const_handle(const double &np_local0);
+void const_handle(const double *np_local0);
+
+void non_const_handle(double &np_local0);
+void non_const_handle(double *np_local0);
+
+void handle_from_array() {
+  // Non-const handle from non-const array forbids declaring the array as const
+  double np_local0[10] = {0., 1., 2., 3., 4., 5., 6., 7., 8., 9.};
+  double *p_local0 = &np_local0[1]; // Could be `double *const`, but warning deactivated by default
+
+  double np_local1[10] = {0., 1., 2., 3., 4., 5., 6., 7., 8., 9.};
+  double &non_const_ref = np_local1[1];
+  non_const_ref = 42.;
+
+  double np_local2[10] = {0., 1., 2., 3., 4., 5., 6., 7., 8., 9.};
+  double *np_local3;
+  np_local3 = &np_local2[5];
+
+  double np_local4[10] = {0., 1., 2., 3., 4., 5., 6., 7., 8., 9.};
+  non_const_handle(np_local4[2]);
+  double np_local5[10] = {0., 1., 2., 3., 4., 5., 6., 7., 8., 9.};
+  non_const_handle(&np_local5[2]);
+
+  // Constant handles are ok
+  double p_local1[10] = {0., 1., 2., 3., 4., 5., 6., 7., 8., 9.};
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local1' of type 'double [10]' can be declared 'const'
+  const double *p_local2 = &p_local1[2]; // Could be `const double *const`, but warning deactivated by default
+
+  double p_local3[10] = {0., 1., 2., 3., 4., 5., 6., 7., 8., 9.};
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local3' of type 'double [10]' can be declared 'const'
+  const double &const_ref = p_local3[2];
+
+  double p_local4[10] = {0., 1., 2., 3., 4., 5., 6., 7., 8., 9.};
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local4' of type 'double [10]' can be declared 'const'
+  const double *const_ptr;
+  const_ptr = &p_local4[2];
+
+  double p_local5[10] = {0., 1., 2., 3., 4., 5., 6., 7., 8., 9.};
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local5' of type 'double [10]' can be declared 'const'
+  const_handle(p_local5[2]);
+  double p_local6[10] = {0., 1., 2., 3., 4., 5., 6., 7., 8., 9.};
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local6' of type 'double [10]' can be declared 'const'
+  const_handle(&p_local6[2]);
+}
+
+void range_for() {
+  int np_local0[2] = {1, 2};
+  for (int &non_const_ref : np_local0) {
+    non_const_ref = 42;
+  }
+
+  int np_local1[2] = {1, 2};
+  for (auto &non_const_ref : np_local1) {
+    non_const_ref = 43;
+  }
+
+  int np_local2[2] = {1, 2};
+  for (auto &&non_const_ref : np_local2) {
+    non_const_ref = 44;
+  }
+
+  // FIXME the warning message is suboptimal. It could be defined as
+  // `int *const np_local3[2]` because the pointers are not reseated.
+  // But this is not easily deducable from the warning.
+  int *np_local3[2] = {&np_local0[0], &np_local0[1]};
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'np_local3' of type 'int *[2]' can be declared 'const'
+  for (int *non_const_ptr : np_local3) {
+    *non_const_ptr = 45;
+  }
+
+  // FIXME same as above, but silenced
+  int *const np_local4[2] = {&np_local0[0], &np_local0[1]};
+  for (auto *non_const_ptr : np_local4) {
+    *non_const_ptr = 46;
+  }
+
+  int p_local0[2] = {1, 2};
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'int [2]' can be declared 'const'
+  for (int value : p_local0) {
+    // CHECK-MESSAGES: [[@LINE-1]]:8: warning: variable 'value' of type 'int' can be declared 'const'
+  }
+
+  int p_local1[2] = {1, 2};
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local1' of type 'int [2]' can be declared 'const'
+  for (const int &const_ref : p_local1) {
+  }
+
+  int *p_local2[2] = {&np_local0[0], &np_local0[1]};
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local2' of type 'int *[2]' can be declared 'const'
+  for (const int *con_ptr : p_local2) {
+  }
+
+  int *p_local3[2] = {nullptr, nullptr};
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local3' of type 'int *[2]' can be declared 'const'
+  for (const auto *con_ptr : p_local3) {
+  }
+}
+
+inline void *operator new(decltype(sizeof(void *)), void *p) { return p; }
+
+struct Value {
+};
+void placement_new() {
+  Value Mem;
+  Value *V = new (&Mem) Value;
+}
+
+struct ModifyingConversion {
+  operator int() { return 15; }
+};
+struct NonModifyingConversion {
+  operator int() const { return 15; }
+};
+void conversion_operators() {
+  ModifyingConversion np_local0;
+  NonModifyingConversion p_local0;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'NonModifyingConversion' can be declared 'const'
+
+  int np_local1 = np_local0;
+  np_local1 = p_local0;
+}
+
+void casts() {
+  decltype(sizeof(void *)) p_local0 = 42;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'decltype(sizeof(void *))' (aka 'unsigned long') can be declared 'const'
+  auto np_local0 = reinterpret_cast<void *>(p_local0);
+  np_local0 = nullptr;
+
+  int p_local1 = 43;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local1' of type 'int' can be declared 'const'
+  short p_local2 = static_cast<short>(p_local1);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local2' of type 'short' can be declared 'const'
+
+  int np_local1 = p_local2;
+  int &np_local2 = static_cast<int &>(np_local1);
+  np_local2 = 5;
+}
+
+void ternary_operator() {
+  int np_local0 = 1, np_local1 = 2;
+  int &np_local2 = true ? np_local0 : np_local1;
+  np_local2 = 2;
+
+  int p_local0 = 3, np_local3 = 5;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'int' can be declared 'const'
+  const int &np_local4 = true ? p_local0 : ++np_local3;
+
+  int np_local5[3] = {1, 2, 3};
+  int &np_local6 = np_local5[1] < np_local5[2] ? np_local5[0] : np_local5[2];
+  np_local6 = 42;
+
+  int np_local7[3] = {1, 2, 3};
+  int *np_local8 = np_local7[1] < np_local7[2] ? &np_local7[0] : &np_local7[2];
+  *np_local8 = 42;
+}
+
+// taken from http://www.cplusplus.com/reference/type_traits/integral_constant/
+template <typename T, T v>
+struct integral_constant {
+  static constexpr T value = v;
+  using value_type = T;
+  using type = integral_constant<T, v>;
+  constexpr operator T() { return v; }
+};
+
+template <typename T>
+struct is_integral : integral_constant<bool, false> {};
+template <>
+struct is_integral<int> : integral_constant<bool, true> {};
+
+template <typename T>
+struct not_integral : integral_constant<bool, false> {};
+template <>
+struct not_integral<double> : integral_constant<bool, true> {};
+
+// taken from http://www.cplusplus.com/reference/type_traits/enable_if/
+template <bool Cond, typename T = void>
+struct enable_if {};
+
+template <typename T>
+struct enable_if<true, T> { using type = T; };
+
+template <typename T>
+struct TMPClass {
+  T alwaysConst() const { return T{}; }
+
+  template <typename T2 = T, typename = typename enable_if<is_integral<T2>::value>::type>
+  T sometimesConst() const { return T{}; }
+
+  template <typename T2 = T, typename = typename enable_if<not_integral<T2>::value>::type>
+  T sometimesConst() { return T{}; }
+};
+
+void meta_type() {
+  TMPClass<int> p_local0;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'TMPClass<int>' can be declared 'const'
+  p_local0.alwaysConst();
+  p_local0.sometimesConst();
+
+  TMPClass<double> p_local1;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local1' of type 'TMPClass<double>' can be declared 'const'
+  p_local1.alwaysConst();
+
+  TMPClass<double> np_local0;
+  np_local0.alwaysConst();
+  np_local0.sometimesConst();
+}

clang-tools-extra/unittests/clang-tidy/AddConstTest.cpp

+#include "../clang-tidy/utils/FixItHintUtils.h"
+#include "ClangTidyTest.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/Tooling/Tooling.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace tidy {
+
+namespace {
+using namespace clang::ast_matchers;
+using namespace utils::fixit;
+
+template <QualifierTarget CT, QualifierPolicy CP>
+class ConstTransform : public ClangTidyCheck {
+public:
+  ConstTransform(StringRef CheckName, ClangTidyContext *Context)
+      : ClangTidyCheck(CheckName, Context) {}
+
+  void registerMatchers(MatchFinder *Finder) override {
+    Finder->addMatcher(varDecl(hasName("target")).bind("var"), this);
+  }
+
+  void check(const MatchFinder::MatchResult &Result) override {
+    const auto *D = Result.Nodes.getNodeAs<VarDecl>("var");
+    using utils::fixit::addQualifierToVarDecl;
+    Optional<FixItHint> Fix = addQualifierToVarDecl(*D, DeclSpec::TQ::TQ_const,
+                                                    CT, CP, Result.Context);
+    auto Diag = diag(D->getBeginLoc(), "doing const transformation");
+    if (Fix)
+      Diag << *Fix;
+  }
+};
+} // namespace
+
+namespace test {
+using PointeeLTransform =
+    ConstTransform<QualifierTarget::Pointee, QualifierPolicy::Left>;
+using PointeeRTransform =
+    ConstTransform<QualifierTarget::Pointee, QualifierPolicy::Right>;
+
+using ValueLTransform =
+    ConstTransform<QualifierTarget::Value, QualifierPolicy::Left>;
+using ValueRTransform =
+    ConstTransform<QualifierTarget::Value, QualifierPolicy::Right>;
+
+// ----------------------------------------------------------------------------
+// Test Value-like types. Everything with indirection is done later.
+// ----------------------------------------------------------------------------
+
+TEST(Values, Builtin) {
+  StringRef Snippet = "int target = 0;";
+
+  EXPECT_EQ("const int target = 0;", runCheckOnCode<ValueLTransform>(Snippet));
+  EXPECT_EQ("const int target = 0;",
+            runCheckOnCode<PointeeLTransform>(Snippet));
+
+  EXPECT_EQ("int const target = 0;", runCheckOnCode<ValueRTransform>(Snippet));
+  EXPECT_EQ("int const target = 0;",
+            runCheckOnCode<PointeeRTransform>(Snippet));
+}
+TEST(Values, TypedefBuiltin) {
+  StringRef T = "typedef int MyInt;";
+  StringRef S = "MyInt target = 0;";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("const MyInt target = 0;"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("const MyInt target = 0;"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("MyInt const target = 0;"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+  EXPECT_EQ(Cat("MyInt const target = 0;"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(Values, TypedefBuiltinPointer) {
+  StringRef T = "typedef int* MyInt;";
+  StringRef S = "MyInt target = nullptr;";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("const MyInt target = nullptr;"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("const MyInt target = nullptr;"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("MyInt const target = nullptr;"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+  EXPECT_EQ(Cat("MyInt const target = nullptr;"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(Values, UsingBuiltin) {
+  StringRef T = "using MyInt = int;";
+  StringRef S = "MyInt target = 0;";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("const MyInt target = 0;"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("const MyInt target = 0;"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("MyInt const target = 0;"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+  EXPECT_EQ(Cat("MyInt const target = 0;"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(Values, UsingBuiltinPointer) {
+  StringRef T = "using MyInt = int*;";
+  StringRef S = "MyInt target = nullptr;";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("const MyInt target = nullptr;"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("const MyInt target = nullptr;"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("MyInt const target = nullptr;"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+  EXPECT_EQ(Cat("MyInt const target = nullptr;"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(Values, AutoValue) {
+  StringRef T = "int f() { return 42; }\n";
+  StringRef S = "auto target = f();";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("const auto target = f();"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("const auto target = f();"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("auto const target = f();"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+  EXPECT_EQ(Cat("auto const target = f();"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(Values, AutoPointer) {
+  StringRef T = "int* f() { return nullptr; }\n";
+  StringRef S = "auto target = f();";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("const auto target = f();"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("const auto target = f();"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("auto const target = f();"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+  EXPECT_EQ(Cat("auto const target = f();"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(Values, AutoReference) {
+  StringRef T = "static int global = 42; int& f() { return global; }\n";
+  StringRef S = "auto target = f();";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("const auto target = f();"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("const auto target = f();"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("auto const target = f();"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+  EXPECT_EQ(Cat("auto const target = f();"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(Values, DeclTypeValue) {
+  StringRef T = "int f() { return 42; }\n";
+  StringRef S = "decltype(f()) target = f();";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("const decltype(f()) target = f();"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("const decltype(f()) target = f();"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("decltype(f()) const target = f();"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+  EXPECT_EQ(Cat("decltype(f()) const target = f();"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(Values, DeclTypePointer) {
+  // The pointer itself will be changed to 'const'. There is no
+  // way to make the pointee 'const' with this syntax.
+  StringRef T = "int* f() { return nullptr; }\n";
+  StringRef S = "decltype(f()) target = f();";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("const decltype(f()) target = f();"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("const decltype(f()) target = f();"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("decltype(f()) const target = f();"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+  EXPECT_EQ(Cat("decltype(f()) const target = f();"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(Values, DeclTypeReference) {
+  // Same as pointer, but the reference itself will be marked 'const'.
+  // This has no effect and will result in a warning afterwards. The
+  // transformation itself is still correct.
+  StringRef T = "static int global = 42; int& f() { return global; }\n";
+  StringRef S = "decltype(f()) target = f();";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("const decltype(f()) target = f();"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("const decltype(f()) target = f();"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("decltype(f()) const target = f();"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+  EXPECT_EQ(Cat("decltype(f()) const target = f();"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(Values, Parens) {
+  StringRef Snippet = "int ((target)) = 0;";
+
+  EXPECT_EQ("const int ((target)) = 0;",
+            runCheckOnCode<ValueLTransform>(Snippet));
+  EXPECT_EQ("const int ((target)) = 0;",
+            runCheckOnCode<PointeeLTransform>(Snippet));
+
+  EXPECT_EQ("int const ((target)) = 0;",
+            runCheckOnCode<ValueRTransform>(Snippet));
+  EXPECT_EQ("int const ((target)) = 0;",
+            runCheckOnCode<PointeeRTransform>(Snippet));
+}
+
+// ----------------------------------------------------------------------------
+// Test builtin-arrays
+// ----------------------------------------------------------------------------
+
+TEST(Arrays, Builtin) {
+  StringRef Snippet = "int target[][1] = {{1}, {2}, {3}};";
+
+  EXPECT_EQ("const int target[][1] = {{1}, {2}, {3}};",
+            runCheckOnCode<PointeeLTransform>(Snippet));
+  EXPECT_EQ("const int target[][1] = {{1}, {2}, {3}};",
+            runCheckOnCode<ValueLTransform>(Snippet));
+
+  EXPECT_EQ("int const target[][1] = {{1}, {2}, {3}};",
+            runCheckOnCode<PointeeRTransform>(Snippet));
+  EXPECT_EQ("int const target[][1] = {{1}, {2}, {3}};",
+            runCheckOnCode<ValueRTransform>(Snippet));
+}
+TEST(Arrays, BuiltinParens) {
+  StringRef Snippet = "int ((target))[][1] = {{1}, {2}, {3}};";
+
+  EXPECT_EQ("const int ((target))[][1] = {{1}, {2}, {3}};",
+            runCheckOnCode<PointeeLTransform>(Snippet));
+  EXPECT_EQ("const int ((target))[][1] = {{1}, {2}, {3}};",
+            runCheckOnCode<ValueLTransform>(Snippet));
+
+  EXPECT_EQ("int const ((target))[][1] = {{1}, {2}, {3}};",
+            runCheckOnCode<PointeeRTransform>(Snippet));
+  EXPECT_EQ("int const ((target))[][1] = {{1}, {2}, {3}};",
+            runCheckOnCode<ValueRTransform>(Snippet));
+}
+TEST(Arrays, Pointers) {
+  StringRef Snippet = "int x; int* target[] = {&x, &x, &x};";
+
+  EXPECT_EQ("int x; const int* target[] = {&x, &x, &x};",
+            runCheckOnCode<PointeeLTransform>(Snippet));
+  EXPECT_EQ("int x; int const* target[] = {&x, &x, &x};",
+            runCheckOnCode<PointeeRTransform>(Snippet));
+
+  EXPECT_EQ("int x; int* const target[] = {&x, &x, &x};",
+            runCheckOnCode<ValueLTransform>(Snippet));
+  EXPECT_EQ("int x; int* const target[] = {&x, &x, &x};",
+            runCheckOnCode<ValueRTransform>(Snippet));
+}
+TEST(Arrays, PointerPointers) {
+  StringRef Snippet = "int* x = nullptr; int** target[] = {&x, &x, &x};";
+
+  EXPECT_EQ("int* x = nullptr; int* const* target[] = {&x, &x, &x};",
+            runCheckOnCode<PointeeLTransform>(Snippet));
+  EXPECT_EQ("int* x = nullptr; int** const target[] = {&x, &x, &x};",
+            runCheckOnCode<ValueLTransform>(Snippet));
+
+  EXPECT_EQ("int* x = nullptr; int* const* target[] = {&x, &x, &x};",
+            runCheckOnCode<PointeeRTransform>(Snippet));
+  EXPECT_EQ("int* x = nullptr; int** const target[] = {&x, &x, &x};",
+            runCheckOnCode<ValueRTransform>(Snippet));
+}
+TEST(Arrays, PointersParens) {
+  StringRef Snippet = "int x; int* (target)[] = {&x, &x, &x};";
+
+  EXPECT_EQ("int x; const int* (target)[] = {&x, &x, &x};",
+            runCheckOnCode<PointeeLTransform>(Snippet));
+  EXPECT_EQ("int x; int const* (target)[] = {&x, &x, &x};",
+            runCheckOnCode<PointeeRTransform>(Snippet));
+
+  EXPECT_EQ("int x; int* const (target)[] = {&x, &x, &x};",
+            runCheckOnCode<ValueLTransform>(Snippet));
+  EXPECT_EQ("int x; int* const (target)[] = {&x, &x, &x};",
+            runCheckOnCode<ValueRTransform>(Snippet));
+}
+
+// ----------------------------------------------------------------------------
+// Test reference types. This does not include pointers and arrays.
+// ----------------------------------------------------------------------------
+
+TEST(Reference, LValueBuiltin) {
+  StringRef Snippet = "int x = 42; int& target = x;";
+
+  EXPECT_EQ("int x = 42; const int& target = x;",
+            runCheckOnCode<ValueLTransform>(Snippet));
+  EXPECT_EQ("int x = 42; const int& target = x;",
+            runCheckOnCode<PointeeLTransform>(Snippet));
+
+  EXPECT_EQ("int x = 42; int const& target = x;",
+            runCheckOnCode<ValueRTransform>(Snippet));
+  EXPECT_EQ("int x = 42; int const& target = x;",
+            runCheckOnCode<PointeeRTransform>(Snippet));
+}
+TEST(Reference, RValueBuiltin) {
+  StringRef Snippet = "int&& target = 42;";
+  EXPECT_EQ("const int&& target = 42;",
+            runCheckOnCode<ValueLTransform>(Snippet));
+  EXPECT_EQ("const int&& target = 42;",
+            runCheckOnCode<PointeeLTransform>(Snippet));
+
+  EXPECT_EQ("int const&& target = 42;",
+            runCheckOnCode<ValueRTransform>(Snippet));
+  EXPECT_EQ("int const&& target = 42;",
+            runCheckOnCode<PointeeRTransform>(Snippet));
+}
+TEST(Reference, LValueToPointer) {
+  StringRef Snippet = "int* p; int *& target = p;";
+  EXPECT_EQ("int* p; int * const& target = p;",
+            runCheckOnCode<ValueLTransform>(Snippet));
+  EXPECT_EQ("int* p; int * const& target = p;",
+            runCheckOnCode<PointeeLTransform>(Snippet));
+
+  EXPECT_EQ("int* p; int * const& target = p;",
+            runCheckOnCode<ValueRTransform>(Snippet));
+  EXPECT_EQ("int* p; int * const& target = p;",
+            runCheckOnCode<PointeeRTransform>(Snippet));
+}
+TEST(Reference, LValueParens) {
+  StringRef Snippet = "int x = 42; int ((& target)) = x;";
+
+  EXPECT_EQ("int x = 42; const int ((& target)) = x;",
+            runCheckOnCode<ValueLTransform>(Snippet));
+  EXPECT_EQ("int x = 42; const int ((& target)) = x;",
+            runCheckOnCode<PointeeLTransform>(Snippet));
+
+  EXPECT_EQ("int x = 42; int  const((& target)) = x;",
+            runCheckOnCode<ValueRTransform>(Snippet));
+  EXPECT_EQ("int x = 42; int  const((& target)) = x;",
+            runCheckOnCode<PointeeRTransform>(Snippet));
+}
+TEST(Reference, ToArray) {
+  StringRef ArraySnippet = "int a[4] = {1, 2, 3, 4};";
+  StringRef Snippet = "int (&target)[4] = a;";
+  auto Cat = [&ArraySnippet](StringRef S) { return (ArraySnippet + S).str(); };
+
+  EXPECT_EQ(Cat("const int (&target)[4] = a;"),
+            runCheckOnCode<ValueLTransform>(Cat(Snippet)));
+  EXPECT_EQ(Cat("const int (&target)[4] = a;"),
+            runCheckOnCode<PointeeLTransform>(Cat(Snippet)));
+
+  EXPECT_EQ(Cat("int  const(&target)[4] = a;"),
+            runCheckOnCode<ValueRTransform>(Cat(Snippet)));
+  EXPECT_EQ(Cat("int  const(&target)[4] = a;"),
+            runCheckOnCode<PointeeRTransform>(Cat(Snippet)));
+}
+TEST(Reference, Auto) {
+  StringRef T = "static int global = 42; int& f() { return global; }\n";
+  StringRef S = "auto& target = f();";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("const auto& target = f();"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("auto const& target = f();"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("const auto& target = f();"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("auto const& target = f();"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+
+// ----------------------------------------------------------------------------
+// Test pointers types.
+// ----------------------------------------------------------------------------
+
+TEST(Pointers, SingleBuiltin) {
+  StringRef Snippet = "int* target = nullptr;";
+
+  EXPECT_EQ("int* const target = nullptr;",
+            runCheckOnCode<ValueLTransform>(Snippet));
+  EXPECT_EQ("int* const target = nullptr;",
+            runCheckOnCode<ValueRTransform>(Snippet));
+
+  EXPECT_EQ("const int* target = nullptr;",
+            runCheckOnCode<PointeeLTransform>(Snippet));
+  EXPECT_EQ("int const* target = nullptr;",
+            runCheckOnCode<PointeeRTransform>(Snippet));
+}
+TEST(Pointers, MultiBuiltin) {
+  StringRef Snippet = "int** target = nullptr;";
+
+  EXPECT_EQ("int** const target = nullptr;",
+            runCheckOnCode<ValueLTransform>(Snippet));
+  EXPECT_EQ("int** const target = nullptr;",
+            runCheckOnCode<ValueRTransform>(Snippet));
+
+  EXPECT_EQ("int* const* target = nullptr;",
+            runCheckOnCode<PointeeLTransform>(Snippet));
+  EXPECT_EQ("int* const* target = nullptr;",
+            runCheckOnCode<PointeeRTransform>(Snippet));
+}
+TEST(Pointers, ToArray) {
+  StringRef ArraySnippet = "int a[4] = {1, 2, 3, 4};";
+  StringRef Snippet = "int (*target)[4] = &a;";
+  auto Cat = [&ArraySnippet](StringRef S) { return (ArraySnippet + S).str(); };
+
+  EXPECT_EQ(Cat("int (*const target)[4] = &a;"),
+            runCheckOnCode<ValueLTransform>(Cat(Snippet)));
+  EXPECT_EQ(Cat("const int (*target)[4] = &a;"),
+            runCheckOnCode<PointeeLTransform>(Cat(Snippet)));
+
+  EXPECT_EQ(Cat("int (*const target)[4] = &a;"),
+            runCheckOnCode<ValueRTransform>(Cat(Snippet)));
+  EXPECT_EQ(Cat("int  const(*target)[4] = &a;"),
+            runCheckOnCode<PointeeRTransform>(Cat(Snippet)));
+}
+TEST(Pointers, Parens) {
+  StringRef Snippet = "int ((**target)) = nullptr;";
+
+  EXPECT_EQ("int ((**const target)) = nullptr;",
+            runCheckOnCode<ValueLTransform>(Snippet));
+  EXPECT_EQ("int ((**const target)) = nullptr;",
+            runCheckOnCode<ValueRTransform>(Snippet));
+
+  EXPECT_EQ("int ((* const*target)) = nullptr;",
+            runCheckOnCode<PointeeLTransform>(Snippet));
+  EXPECT_EQ("int ((* const*target)) = nullptr;",
+            runCheckOnCode<PointeeRTransform>(Snippet));
+}
+TEST(Pointers, Auto) {
+  StringRef T = "int* f() { return nullptr; }\n";
+  StringRef S = "auto* target = f();";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("auto* const target = f();"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("auto* const target = f();"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("const auto* target = f();"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("auto const* target = f();"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(Pointers, AutoParens) {
+  StringRef T = "int* f() { return nullptr; }\n";
+  StringRef S = "auto (((* target))) = f();";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("auto (((* const target))) = f();"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("auto (((* const target))) = f();"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("const auto (((* target))) = f();"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("auto  const(((* target))) = f();"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(Pointers, FunctionPointer) {
+  StringRef S = "int (*target)(float, int, double) = nullptr;";
+
+  EXPECT_EQ("int (*const target)(float, int, double) = nullptr;",
+            runCheckOnCode<ValueLTransform>(S));
+  EXPECT_EQ("int (*const target)(float, int, double) = nullptr;",
+            runCheckOnCode<ValueRTransform>(S));
+
+  EXPECT_EQ("int (*const target)(float, int, double) = nullptr;",
+            runCheckOnCode<PointeeLTransform>(S));
+  EXPECT_EQ("int (*const target)(float, int, double) = nullptr;",
+            runCheckOnCode<PointeeRTransform>(S));
+
+  S = "int (((*target)))(float, int, double) = nullptr;";
+  EXPECT_EQ("int (((*const target)))(float, int, double) = nullptr;",
+            runCheckOnCode<PointeeRTransform>(S));
+}
+TEST(Pointers, MemberFunctionPointer) {
+  StringRef T = "struct A { int f() { return 1; } };";
+  StringRef S = "int (A::*target)() = &A::f;";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("int (A::*const target)() = &A::f;"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("int (A::*const target)() = &A::f;"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("int (A::*const target)() = &A::f;"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("int (A::*const target)() = &A::f;"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+
+  S = "int (A::*((target)))() = &A::f;";
+  EXPECT_EQ(Cat("int (A::*const ((target)))() = &A::f;"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+}
+TEST(Pointers, MemberDataPointer) {
+  StringRef T = "struct A { int member = 0; };";
+  StringRef S = "int A::*target = &A::member;";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("int A::*const target = &A::member;"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("int A::*const target = &A::member;"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("int A::*const target = &A::member;"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("int A::*const target = &A::member;"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+
+  S = "int A::*((target)) = &A::member;";
+  EXPECT_EQ(Cat("int A::*const ((target)) = &A::member;"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+
+// ----------------------------------------------------------------------------
+// Test TagTypes (struct, class, unions, enums)
+// ----------------------------------------------------------------------------
+
+TEST(TagTypes, Struct) {
+  StringRef T = "struct Foo { int data; int method(); };\n";
+  StringRef S = "struct Foo target{0};";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("const struct Foo target{0};"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("const struct Foo target{0};"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("struct Foo const target{0};"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+  EXPECT_EQ(Cat("struct Foo const target{0};"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+
+  S = "Foo target{0};";
+  EXPECT_EQ(Cat("const Foo target{0};"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("const Foo target{0};"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("Foo const target{0};"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+  EXPECT_EQ(Cat("Foo const target{0};"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+
+  S = "Foo (target){0};";
+  EXPECT_EQ(Cat("const Foo (target){0};"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("const Foo (target){0};"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("Foo const (target){0};"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+  EXPECT_EQ(Cat("Foo const (target){0};"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(TagTypes, Class) {
+  StringRef T = "class Foo { int data; int method(); };\n";
+  StringRef S = "class Foo target;";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("const class Foo target;"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("const class Foo target;"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("class Foo const target;"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+  EXPECT_EQ(Cat("class Foo const target;"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+
+  S = "Foo target;";
+  EXPECT_EQ(Cat("const Foo target;"), runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("const Foo target;"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("Foo const target;"), runCheckOnCode<ValueRTransform>(Cat(S)));
+  EXPECT_EQ(Cat("Foo const target;"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+
+  S = "Foo (target);";
+  EXPECT_EQ(Cat("const Foo (target);"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("const Foo (target);"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("Foo const (target);"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+  EXPECT_EQ(Cat("Foo const (target);"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(TagTypes, Enum) {
+  StringRef T = "enum Foo { N_ONE, N_TWO, N_THREE };\n";
+  StringRef S = "enum Foo target;";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("const enum Foo target;"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("const enum Foo target;"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("enum Foo const target;"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+  EXPECT_EQ(Cat("enum Foo const target;"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+
+  S = "Foo target;";
+  EXPECT_EQ(Cat("const Foo target;"), runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("const Foo target;"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("Foo const target;"), runCheckOnCode<ValueRTransform>(Cat(S)));
+  EXPECT_EQ(Cat("Foo const target;"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+
+  S = "Foo (target);";
+  EXPECT_EQ(Cat("const Foo (target);"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("const Foo (target);"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("Foo const (target);"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+  EXPECT_EQ(Cat("Foo const (target);"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(TagTypes, Union) {
+  StringRef T = "union Foo { int yay; float nej; };\n";
+  StringRef S = "union Foo target;";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("const union Foo target;"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("const union Foo target;"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("union Foo const target;"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+  EXPECT_EQ(Cat("union Foo const target;"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+
+  S = "Foo target;";
+  EXPECT_EQ(Cat("const Foo target;"), runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("const Foo target;"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("Foo const target;"), runCheckOnCode<ValueRTransform>(Cat(S)));
+  EXPECT_EQ(Cat("Foo const target;"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+
+  S = "Foo (target);";
+  EXPECT_EQ(Cat("const Foo (target);"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("const Foo (target);"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("Foo const (target);"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+  EXPECT_EQ(Cat("Foo const (target);"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+
+// ----------------------------------------------------------------------------
+// Test Macro expansions.
+// ----------------------------------------------------------------------------
+
+TEST(Macro, AllInMacro) {
+  StringRef T = "#define DEFINE_VARIABLE int target = 42\n";
+  StringRef S = "DEFINE_VARIABLE;";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("DEFINE_VARIABLE;"), runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("DEFINE_VARIABLE;"), runCheckOnCode<ValueRTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("DEFINE_VARIABLE;"), runCheckOnCode<PointeeLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("DEFINE_VARIABLE;"), runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(Macro, MacroParameter) {
+  StringRef T = "#define DEFINE_VARIABLE(X) int X = 42\n";
+  StringRef S = "DEFINE_VARIABLE(target);";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("DEFINE_VARIABLE(target);"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("DEFINE_VARIABLE(target);"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("DEFINE_VARIABLE(target);"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("DEFINE_VARIABLE(target);"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(Macro, MacroTypeValue) {
+  StringRef T = "#define BAD_TYPEDEF int\n";
+  StringRef S = "BAD_TYPEDEF target = 42;";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("BAD_TYPEDEF target = 42;"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("BAD_TYPEDEF target = 42;"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("BAD_TYPEDEF const target = 42;"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+  EXPECT_EQ(Cat("BAD_TYPEDEF const target = 42;"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+}
+TEST(Macro, MacroTypePointer) {
+  StringRef T = "#define BAD_TYPEDEF int *\n";
+  StringRef S = "BAD_TYPEDEF target = nullptr;";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("BAD_TYPEDEF const target = nullptr;"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("BAD_TYPEDEF const target = nullptr;"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+
+  // FIXME: Failing even all parts seem to bail-out in for isMacroID()
+  EXPECT_NE(Cat("BAD_TYPEDEF target = nullptr;"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+  EXPECT_EQ(Cat("BAD_TYPEDEF target = nullptr;"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+}
+TEST(Macro, MacroTypeReference) {
+  StringRef T = "static int g = 42;\n#define BAD_TYPEDEF int&\n";
+  StringRef S = "BAD_TYPEDEF target = g;";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("BAD_TYPEDEF target = g;"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  // FIXME: Failing even all parts seem to bail-out in for isMacroID()
+  EXPECT_NE(Cat("BAD_TYPEDEF target = g;"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("BAD_TYPEDEF target = g;"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+  // FIXME: Failing even all parts seem to bail-out in for isMacroID()
+  EXPECT_NE(Cat("BAD_TYPEDEF target = g;"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+
+// ----------------------------------------------------------------------------
+// Test template code.
+// ----------------------------------------------------------------------------
+
+TEST(Template, TemplateVariable) {
+  StringRef T = "template <typename T> T target = 3.1415;";
+
+  EXPECT_EQ("template <typename T> const T target = 3.1415;",
+            runCheckOnCode<ValueLTransform>(T));
+  EXPECT_EQ("template <typename T> T const target = 3.1415;",
+            runCheckOnCode<ValueRTransform>(T));
+
+  EXPECT_EQ("template <typename T> const T target = 3.1415;",
+            runCheckOnCode<PointeeLTransform>(T));
+  EXPECT_EQ("template <typename T> T const target = 3.1415;",
+            runCheckOnCode<PointeeRTransform>(T));
+}
+TEST(Template, FunctionValue) {
+  StringRef T = "template <typename T> void f(T v) \n";
+  StringRef S = "{ T target = v; }";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("{ const T target = v; }"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("{ T const target = v; }"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("{ const T target = v; }"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("{ T const target = v; }"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(Template, FunctionPointer) {
+  StringRef T = "template <typename T> void f(T* v) \n";
+  StringRef S = "{ T* target = v; }";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("{ T* const target = v; }"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("{ T* const target = v; }"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("{ const T* target = v; }"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("{ T const* target = v; }"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(Template, FunctionReference) {
+  StringRef T = "template <typename T> void f(T& v) \n";
+  StringRef S = "{ T& target = v; }";
+  auto Cat = [&T](StringRef S) { return (T + S).str(); };
+
+  EXPECT_EQ(Cat("{ const T& target = v; }"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("{ T const& target = v; }"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("{ const T& target = v; }"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("{ T const& target = v; }"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(Template, MultiInstantiationsFunction) {
+  StringRef T = "template <typename T> void f(T v) \n";
+  StringRef S = "{ T target = v; }";
+  StringRef InstantStart = "void calls() {\n";
+  StringRef InstValue = "f<int>(42);\n";
+  StringRef InstConstValue = "f<const int>(42);\n";
+  StringRef InstPointer = "f<int*>(nullptr);\n";
+  StringRef InstPointerConst = "f<int* const>(nullptr);\n";
+  StringRef InstConstPointer = "f<const int*>(nullptr);\n";
+  StringRef InstConstPointerConst = "f<const int* const>(nullptr);\n";
+  StringRef InstRef = "int i = 42;\nf<int&>(i);\n";
+  StringRef InstConstRef = "f<const int&>(i);\n";
+  StringRef InstantEnd = "}";
+  auto Cat = [&](StringRef Target) {
+    return (T + Target + InstantStart + InstValue + InstConstValue +
+            InstPointer + InstPointerConst + InstConstPointer +
+            InstConstPointerConst + InstRef + InstConstRef + InstantEnd)
+        .str();
+  };
+
+  EXPECT_EQ(Cat("{ const T target = v; }"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("{ T const target = v; }"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("{ const T target = v; }"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("{ T const target = v; }"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+
+TEST(Template, StructValue) {
+  StringRef T = "template <typename T> struct S { void f(T& v) \n";
+  StringRef S = "{ T target = v; }";
+  StringRef End = "\n};";
+  auto Cat = [&T, &End](StringRef S) { return (T + S + End).str(); };
+
+  EXPECT_EQ(Cat("{ const T target = v; }"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("{ T const target = v; }"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("{ const T target = v; }"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("{ T const target = v; }"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(Template, StructPointer) {
+  StringRef T = "template <typename T> struct S { void f(T* v) \n";
+  StringRef S = "{ T* target = v; }";
+  StringRef End = "\n};";
+  auto Cat = [&T, &End](StringRef S) { return (T + S + End).str(); };
+
+  EXPECT_EQ(Cat("{ T* const target = v; }"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("{ T* const target = v; }"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("{ const T* target = v; }"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("{ T const* target = v; }"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(Template, StructReference) {
+  StringRef T = "template <typename T> struct S { void f(T& v) \n";
+  StringRef S = "{ T& target = v; }";
+  StringRef End = "\n};";
+  auto Cat = [&T, &End](StringRef S) { return (T + S + End).str(); };
+
+  EXPECT_EQ(Cat("{ const T& target = v; }"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("{ T const& target = v; }"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("{ const T& target = v; }"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("{ T const& target = v; }"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(Template, DependentReturnFunction) {
+  StringRef TS = "template <typename T> struct TS { using value_type = T; };";
+  StringRef T = "template <typename T> void foo() ";
+  StringRef S = "{ typename T::value_type target; }";
+  auto Cat = [&TS, &T](StringRef S) { return (TS + T + S).str(); };
+
+  EXPECT_EQ(Cat("{ const typename T::value_type target; }"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("{ typename T::value_type const target; }"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("{ const typename T::value_type target; }"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("{ typename T::value_type const target; }"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(Template, DependentReturnPointerFunction) {
+  StringRef TS = "template <typename T> struct TS { using value_type = T; };";
+  StringRef T = "template <typename T> void foo() ";
+  StringRef S = "{ typename T::value_type *target; }";
+  auto Cat = [&TS, &T](StringRef S) { return (TS + T + S).str(); };
+
+  EXPECT_EQ(Cat("{ typename T::value_type *const target; }"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("{ typename T::value_type *const target; }"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("{ const typename T::value_type *target; }"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("{ typename T::value_type  const*target; }"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(Template, DependentReturnReferenceFunction) {
+  StringRef TS = "template <typename T> struct TS { using value_type = T; };";
+  StringRef T = "template <typename T> void foo(T& f) ";
+  StringRef S = "{ typename T::value_type &target = f; }";
+  auto Cat = [&TS, &T](StringRef S) { return (TS + T + S).str(); };
+
+  EXPECT_EQ(Cat("{ const typename T::value_type &target = f; }"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("{ typename T::value_type  const&target = f; }"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("{ const typename T::value_type &target = f; }"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("{ typename T::value_type  const&target = f; }"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(Template, VectorLikeType) {
+  StringRef TS = "template <typename T> struct TS { TS(const T&) {} }; ";
+  StringRef T = "void foo() ";
+  StringRef S = "{ TS<int> target(42); }";
+  auto Cat = [&TS, &T](StringRef S) { return (TS + T + S).str(); };
+
+  EXPECT_EQ(Cat("{ const TS<int> target(42); }"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("{ TS<int> const target(42); }"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("{ const TS<int> target(42); }"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("{ TS<int> const target(42); }"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+TEST(Template, SpecializedTemplate) {
+  StringRef TS = "template <typename T = int> struct TS { TS(const T&) {} }; ";
+  StringRef TS2 = "template <> struct TS<double> { TS(const double&) {} }; ";
+  StringRef T = "void foo() ";
+  StringRef S = "{ TS<double> target(42.42); }";
+  auto Cat = [&](StringRef S) { return (TS + TS2 + T + S).str(); };
+
+  EXPECT_EQ(Cat("{ const TS<double> target(42.42); }"),
+            runCheckOnCode<ValueLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("{ TS<double> const target(42.42); }"),
+            runCheckOnCode<ValueRTransform>(Cat(S)));
+
+  EXPECT_EQ(Cat("{ const TS<double> target(42.42); }"),
+            runCheckOnCode<PointeeLTransform>(Cat(S)));
+  EXPECT_EQ(Cat("{ TS<double> const target(42.42); }"),
+            runCheckOnCode<PointeeRTransform>(Cat(S)));
+}
+
+} // namespace test
+} // namespace tidy
+} // namespace clang

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

 set(LLVM_LINK_COMPONENTS
   support
   )
 
 get_filename_component(CLANG_LINT_SOURCE_DIR
   ${CMAKE_CURRENT_SOURCE_DIR}/../../clang-tidy REALPATH)
 include_directories(${CLANG_LINT_SOURCE_DIR})
 
 add_extra_unittest(ClangTidyTests
+  AddConstTest.cpp
   ClangTidyDiagnosticConsumerTest.cpp
   ClangTidyOptionsTest.cpp
   IncludeInserterTest.cpp
   GlobListTest.cpp
   GoogleModuleTest.cpp
   LLVMModuleTest.cpp
   NamespaceAliaserTest.cpp
   ObjCModuleTest.cpp