[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

41

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

108–109

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

115

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

121

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.

165–168

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

14

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

18

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

556–575

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

41

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 :)

121

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

41

Okay, that sounds good to me!

121

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

41

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.

115

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

108–109

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

18

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

13

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

13

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

13

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

13

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

13

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

13

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

32

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

82–86

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

4–6

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

4–6

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

4–6

[JonasToth]

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

32

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

32

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

32

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

84

Unrelated change.

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

87 ↗

(On Diff #424788)

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
   FrontendOpenMP
   Support
   )
 
 add_clang_library(clangTidyCppCoreGuidelinesModule
   AvoidGotoCheck.cpp
   AvoidNonConstGlobalVariablesCheck.cpp
+  ConstCorrectnessCheck.cpp
   CppCoreGuidelinesTidyModule.cpp
   InitVariablesCheck.cpp
   InterfacesGlobalInitCheck.cpp
   MacroUsageCheck.cpp
   NarrowingConversionsCheck.cpp
   NoMallocCheck.cpp
   OwningMemoryCheck.cpp
   PreferMemberInitializerCheck.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
+  clangAnalysis
+  clangAST
+  clangASTMatchers
+  clangBasic
+  clangLex
+  clangSerialization
   clangTidy
   clangTidyMiscModule
   clangTidyModernizeModule
   clangTidyReadabilityModule
   clangTidyUtils
 
   DEPENDS
   omp_gen

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)),
+        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 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"
+#include "clang/ASTMatchers/ASTMatchers.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();
+}
+AST_MATCHER(Type, isDependentType) { return Node.isDependentType(); }
+} // 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);
+  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(hasCanonicalType(templateTypeParmType())),
+      hasType(substTemplateTypeParmType()), hasType(isDependentType()),
+      // References to template types, their substitutions or typedefs to
+      // template types need to be considered as well.
+      hasType(referenceType(pointee(hasCanonicalType(templateTypeParmType())))),
+      hasType(referenceType(pointee(substTemplateTypeParmType()))));
+
+  const auto AutoTemplateType = varDecl(
+      anyOf(hasType(autoType()), hasType(referenceType(pointee(autoType()))),
+            hasType(pointerType(pointee(autoType())))),
+      hasInitializer(isInstantiationDependent()));
+
+  const auto FunctionPointerRef =
+      hasType(hasCanonicalType(referenceType(pointee(functionType()))));
+
+  // 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,
+                         AutoTemplateType, RValueReference, FunctionPointerRef,
+                         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(allOf(containsDeclaration2(
+                                              LocalValDecl.bind("local-value")),
+                                          unless(has(decompositionDecl()))))
+                               .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>("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::Reference &&
+      Variable->getType()->getPointeeType()->isPointerType() &&
+      !WarnPointersAsValues)
+    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, *Result.Context, DeclSpec::TQ_const,
+            QualifierTarget::Value, QualifierPolicy::Right)) {
+      Diag << *Fix;
+      // FIXME: Add '{}' for default initialization if no user-defined default
+      // constructor exists and there is no initializer.
+    }
+    return;
+  }
+
+  if (VC == VariableCategory::Reference && TransformReferences) {
+    if (Optional<FixItHint> Fix = addQualifierToVarDecl(
+            *Variable, *Result.Context, DeclSpec::TQ_const,
+            QualifierTarget::Value, QualifierPolicy::Right))
+      Diag << *Fix;
+    return;
+  }
+
+  if (VC == VariableCategory::Pointer) {
+    if (WarnPointersAsValues && TransformPointersAsValues) {
+      if (Optional<FixItHint> Fix = addQualifierToVarDecl(
+              *Variable, *Result.Context, DeclSpec::TQ_const,
+              QualifierTarget::Value, QualifierPolicy::Right))
+        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 "../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 "AvoidNonConstGlobalVariablesCheck.h"
+#include "ConstCorrectnessCheck.h"
 #include "InitVariablesCheck.h"
 #include "InterfacesGlobalInitCheck.h"
 #include "MacroUsageCheck.h"
 #include "NarrowingConversionsCheck.h"
 #include "NoMallocCheck.h"
 #include "OwningMemoryCheck.h"
 #include "PreferMemberInitializerCheck.h"
 #include "ProBoundsArrayToPointerDecayCheck.h"
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<AvoidNonConstGlobalVariablesCheck>(
         "cppcoreguidelines-avoid-non-const-global-variables");
+    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/docs/ReleaseNotes.rst

- New ``altera`` module.
 
   Includes checks related to OpenCL for FPGA coding guidelines, based on the
   `Altera SDK for OpenCL: Best Practices Guide
   <https://www.altera.com/en_US/pdfs/literature/hb/opencl-sdk/aocl_optimization_guide.pdf>`_.
 
 New checks
 ^^^^^^^^^^
 
 - New :doc:`altera-struct-pack-align
   <clang-tidy/checks/altera-struct-pack-align>` check.
 
   Finds structs that are inefficiently packed or aligned, and recommends
   packing and/or aligning of said structs as needed.
 
 - New :doc:`cppcoreguidelines-prefer-member-initializer
   <clang-tidy/checks/cppcoreguidelines-prefer-member-initializer>` check.
 
   Finds member initializations in the constructor body which can be placed into
   the initialization list instead.
 
 - New :doc:`bugprone-misplaced-pointer-arithmetic-in-alloc
   <clang-tidy/checks/bugprone-misplaced-pointer-arithmetic-in-alloc>` check.
 
 - New :doc:`bugprone-redundant-branch-condition
   <clang-tidy/checks/bugprone-redundant-branch-condition>` check.
 
   Finds condition variables in nested ``if`` statements that were also checked
   in the outer ``if`` statement and were not changed.
 
+- New :doc:`cppcoreguidelines-const-correctness
+  <clang-tidy/checks/cppcoreguidelines-const-correctness>` check.
+
+  Suggest adding ``const`` to unmodified local variables.
+
+New check aliases
+^^^^^^^^^^^^^^^^^
+
 Changes in existing checks
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 - Improved :doc:`readability-identifier-naming
   <clang-tidy/checks/readability-identifier-naming>` check.
 
   Added an option `GetConfigPerFile` to support including files which use
   different naming styles.

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/test/clang-tidy/checkers/cppcoreguidelines-const-correctness-cxx17.cpp

+// RUN: %check_clang_tidy %s cppcoreguidelines-const-correctness %t -- -- -std=c++17
+
+template <typename L, typename R>
+struct MyPair {
+  L left;
+  R right;
+  MyPair(const L &ll, const R &rr) : left{ll}, right{rr} {}
+};
+
+void f() {
+  // FIXME: Decomposition Decls need special treatment, because they require to use 'auto'
+  // and the 'const' should only be added if all elements can be const.
+  // The issue is similar to multiple declarations in one statement.
+  // Simply bail for now.
+  auto [np_local0, np_local1] = MyPair<int, int>(42, 42);
+  np_local0++;
+  np_local1++;
+
+  auto [np_local2, p_local0] = MyPair<double, double>(42., 42.);
+  np_local2++;
+
+  auto [p_local1, np_local3] = MyPair<double, double>(42., 42.);
+  np_local3++;
+
+  auto [p_local2, p_local3] = MyPair<double, double>(42., 42.);
+}
+
+void g() {
+  int p_local0 = 42;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'int' can be declared 'const'
+}
+
+template <typename SomeValue>
+struct DoGooder {
+  DoGooder(void *accessor, SomeValue value) {
+  }
+};
+struct Bingus {
+  static constexpr auto someRandomConstant = 99;
+};
+template <typename Foo>
+struct HardWorker {
+  HardWorker() {
+    const DoGooder<int> anInstanceOf(nullptr, Foo::someRandomConstant);
+  }
+};
+struct TheContainer {
+  HardWorker<Bingus> m_theOtherInstance;
+};

clang-tools-extra/test/clang-tidy/checkers/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/checkers/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/checkers/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:   {key: 'cppcoreguidelines-const-correctness.WarnPointersAsValues', value: 0}, \
+// RUN:   {key: 'cppcoreguidelines-const-correctness.TransformPointersAsValues', value: 0}, \
+// 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 np_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/checkers/cppcoreguidelines-const-correctness-values.cpp

+// RUN: %check_clang_tidy %s cppcoreguidelines-const-correctness %t -- \
+// RUN:   -config="{CheckOptions: [\
+// RUN:   {key: 'cppcoreguidelines-const-correctness.TransformValues', value: 1}, \
+// RUN:   {key: 'cppcoreguidelines-const-correctness.WarnPointersAsValues', value: 0}, \
+// RUN:   {key: 'cppcoreguidelines-const-correctness.TransformPointersAsValues', value: 0}, \
+// RUN:   ]}" --
+
+// ------- 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 ignore_reference_to_pointers() {
+  int *np_local0 = nullptr;
+  int *&np_local1 = np_local0;
+}
+
+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;
+}
+
+template <typename T>
+void more_template_locals() {
+  const T np_local0 = {};
+  auto np_local1 = T{};
+  T &np_local2 = np_local1;
+  T *np_local_ptr = &np_local1;
+
+  const auto np_local3 = T{};
+  // FIXME: False positive, the reference points to a template type and needs
+  // to be excluded from analysis, but somehow isn't (matchers don't work)
+  auto &np_local4 = np_local3;
+
+  const auto *np_local5 = &np_local3;
+  auto *np_local6 = &np_local1;
+
+  using TypedefToTemplate = T;
+  TypedefToTemplate np_local7{};
+  // FIXME: False positive, the reference points to a template type and needs
+  // to be excluded from analysis, but somehow isn't (matchers don't work)
+  // auto &np_local8 = np_local7;
+  const auto &np_local9 = np_local7;
+  auto np_local10 = np_local7;
+  auto *np_local11 = &np_local10;
+  const auto *const np_local12 = &np_local10;
+
+  // FIXME: False positive, the reference points to a template type and needs
+  // to be excluded from analysis, but somehow isn't (matchers don't work)
+  // TypedefToTemplate &np_local13 = np_local7;
+  TypedefToTemplate *np_local14 = &np_local7;
+}
+
+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);
+  more_template_locals<int>();
+}
+
+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();
+}
+
+// This test is the essence from llvm/lib/Support/MemoryBuffer.cpp at line 450
+template <typename T>
+struct to_construct : T {
+  to_construct(int &j) {}
+};
+template <typename T>
+void placement_new_in_unique_ptr() {
+  int p_local0 = 42;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'int' can be declared 'const'
+  int np_local0 = p_local0;
+  new to_construct<T>(np_local0);
+}
+
+struct stream_obj {};
+stream_obj &operator>>(stream_obj &o, unsigned &foo);
+void input_operator() {
+  stream_obj np_local0;
+  unsigned np_local1 = 42;
+  np_local0 >> np_local1;
+}
+
+struct stream_obj_template {};
+template <typename IStream>
+IStream &operator>>(IStream &o, unsigned &foo);
+
+template <typename Stream>
+void input_operator_template() {
+  Stream np_local0;
+  unsigned np_local1 = 42;
+  np_local0 >> np_local1;
+}
+
+// Test bit fields
+struct HardwareRegister {
+  unsigned field : 5;
+  unsigned : 7;
+  unsigned another : 20;
+};
+
+void TestRegisters() {
+  HardwareRegister np_reg0;
+  np_reg0.field = 3;
+
+  HardwareRegister p_reg1{3, 22};
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_reg1' of type 'HardwareRegister' can be declared 'const'
+  const unsigned p_val = p_reg1.another;
+}
+
+struct IntWrapper {
+  IntWrapper &operator=(unsigned value) { return *this; }
+  template <typename Istream>
+  friend Istream &operator>>(Istream &is, IntWrapper &rhs);
+};
+struct IntMaker {
+  friend IntMaker &operator>>(IntMaker &, unsigned &);
+};
+template <typename Istream>
+Istream &operator>>(Istream &is, IntWrapper &rhs) {
+  unsigned np_local0 = 0;
+  is >> np_local0;
+  return is;
+}
+
+struct Actuator {
+  int actuations;
+};
+struct Sensor {
+  int observations;
+};
+struct System : public Actuator, public Sensor {
+};
+int some_computation(int arg);
+int test_inheritance() {
+  System np_sys;
+  np_sys.actuations = 5;
+  return some_computation(np_sys.actuations);
+}
+struct AnotherActuator : Actuator {
+};
+Actuator &test_return_polymorphic() {
+  static AnotherActuator np_local0;
+  return np_local0;
+}
+
+using f_signature = int *(*)(int &);
+int *my_alloc(int &size) { return new int[size]; }
+struct A {
+  int f(int &i) { return i + 1; }
+  int (A::*x)(int &);
+};
+void f() {
+  int p_local0 = 42;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'int' can be declared 'const'
+  int np_local0 = 42;
+  f_signature action = my_alloc;
+  action(np_local0);
+  my_alloc(np_local0);
+
+  int np_local1 = 42;
+  A a;
+  a.x = &A::f;
+  (a.*(a.x))(np_local1);
+}
+
+struct nested_data {
+  int more_data;
+};
+struct repro_assignment_to_reference {
+  int my_data;
+  nested_data nested;
+};
+void assignment_reference() {
+  repro_assignment_to_reference np_local0{42};
+  int &np_local1 = np_local0.my_data;
+  np_local1++;
+
+  repro_assignment_to_reference np_local2;
+  int &np_local3 = np_local2.nested.more_data;
+  np_local3++;
+}
+
+struct non_const_iterator {
+  int data[42];
+
+  int *begin() { return &data[0]; }
+  int *end() { return &data[41]; }
+};
+
+// The problem is, that 'begin()' and 'end()' are not const overloaded, so
+// they are always a mutation. If 'np_local1' is fixed to const it results in
+// a compilation error.
+void for_bad_iterators() {
+  non_const_iterator np_local0;
+  non_const_iterator &np_local1 = np_local0;
+
+  for (int np_local2 : np_local1) {
+    np_local2++;
+  }
+
+  non_const_iterator np_local3;
+  for (int p_local0 : np_local3)
+    // CHECK-MESSAGES: [[@LINE-1]]:8: warning: variable 'p_local0' of type 'int' can be declared 'const'
+    ;
+
+  // Horrible code constructs...
+  {
+    non_const_iterator np_local4;
+    np_local4.data[0]++;
+    non_const_iterator np_local5;
+    for (int p_local1 : np_local4, np_local5)
+      // CHECK-MESSAGES: [[@LINE-1]]:10: warning: variable 'p_local1' of type 'int' can be declared 'const'
+      ;
+
+    non_const_iterator np_local6;
+    non_const_iterator np_local7;
+    for (int p_local2 : 1 > 2 ? np_local6 : np_local7)
+      // CHECK-MESSAGES: [[@LINE-1]]:10: warning: variable 'p_local2' of type 'int' can be declared 'const'
+      ;
+
+    non_const_iterator np_local8;
+    non_const_iterator np_local9;
+    for (int p_local3 : 2 > 1 ? np_local8 : (np_local8, np_local9))
+      // CHECK-MESSAGES: [[@LINE-1]]:10: warning: variable 'p_local3' of type 'int' can be declared 'const'
+      ;
+  }
+}
+
+struct good_iterator {
+  int data[3] = {1, 2, 3};
+
+  int *begin() { return &data[0]; }
+  int *end() { return &data[2]; }
+  const int *begin() const { return &data[0]; }
+  const int *end() const { return &data[2]; }
+};
+
+void good_iterators() {
+  good_iterator p_local0;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'good_iterator' can be declared 'const'
+  good_iterator &p_local1 = p_local0;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local1' of type 'good_iterator &' can be declared 'const'
+
+  for (int p_local2 : p_local1) {
+    // CHECK-MESSAGES: [[@LINE-1]]:8: warning: variable 'p_local2' of type 'int' can be declared 'const'
+    (void)p_local2;
+  }
+
+  good_iterator p_local3;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local3' of type 'good_iterator' can be declared 'const'
+  for (int p_local4 : p_local3)
+    // CHECK-MESSAGES: [[@LINE-1]]:8: warning: variable 'p_local4' of type 'int' can be declared 'const'
+    ;
+  good_iterator np_local1;
+  for (int &np_local2 : np_local1)
+    np_local2++;
+}
+
+void for_bad_iterators_array() {
+  int np_local0[42];
+  int(&np_local1)[42] = np_local0;
+
+  for (int &np_local2 : np_local1) {
+    np_local2++;
+  }
+}
+void for_ok_iterators_array() {
+  int np_local0[42];
+  int(&p_local0)[42] = np_local0;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'int (&)[42]' can be declared 'const'
+
+  for (int p_local1 : p_local0) {
+    // CHECK-MESSAGES: [[@LINE-1]]:8: warning: variable 'p_local1' of type 'int' can be declared 'const'
+    (void)p_local1;
+  }
+}
+
+void take_ref(int &);
+void ternary_reference() {
+  int np_local0 = 42;
+  int np_local1 = 43;
+  take_ref((np_local0 > np_local1 ? np_local0 : (np_local0, np_local1)));
+}
+
+void complex_usage() {
+  int np_local0 = 42;
+  int p_local0 = 42;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'int' can be declared 'const'
+  int np_local1 = 42;
+  (np_local0 == p_local0 ? np_local0 : (p_local0, np_local1))++;
+}
+
+template <typename T>
+struct SmallVectorBase {
+  T data[4];
+  void push_back(const T &el) {}
+  int size() const { return 4; }
+  T *begin() { return data; }
+  const T *begin() const { return data; }
+  T *end() { return data + 4; }
+  const T *end() const { return data + 4; }
+};
+
+template <typename T>
+struct SmallVector : SmallVectorBase<T> {};
+
+template <class T>
+void EmitProtocolMethodList(T &&Methods) {
+  // Note: If the template is uninstantiated the analysis does not figure out,
+  // that p_local0 could be const. Not sure why, but probably bails because
+  // some expressions are type-dependant.
+  SmallVector<const int *> p_local0;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'SmallVector<const int *>' can be declared 'const'
+  SmallVector<const int *> np_local0;
+  for (const auto *I : Methods) {
+    if (I == nullptr)
+      np_local0.push_back(I);
+  }
+  p_local0.size();
+}
+void instantiate() {
+  int *p_local0[4] = {nullptr, nullptr, nullptr, nullptr};
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p_local0' of type 'int *[4]' can be declared 'const'
+  EmitProtocolMethodList(p_local0);
+}
+struct base {
+  int member;
+};
+struct derived : base {};
+struct another_struct {
+  derived member;
+};
+void another_struct_f() {
+  another_struct np_local0{};
+  base &np_local1 = np_local0.member;
+  np_local1.member++;
+}
+struct list_init {
+  int &member;
+};
+void create_false_positive() {
+  int np_local0 = 42;
+  list_init p_local0 = {np_local0};
+  // CHECK-MESSAGES:[[@LINE-1]]:3: warning: variable 'p_local0' of type 'list_init' can be declared 'const'
+}
+struct list_init_derived {
+  base &member;
+};
+void list_init_derived_func() {
+  derived np_local0;
+  list_init_derived p_local0 = {np_local0};
+  // CHECK-MESSAGES:[[@LINE-1]]:3: warning: variable 'p_local0' of type 'list_init_derived' can be declared 'const'
+}
+template <typename L, typename R>
+struct ref_pair {
+  L &first;
+  R &second;
+};
+template <typename T>
+void list_init_template() {
+  T np_local0{};
+  ref_pair<T, T> p_local0 = {np_local0, np_local0};
+}
+void cast_in_class_hierarchy() {
+  derived np_local0;
+  base p_local1 = static_cast<base &>(np_local0);
+  // CHECK-MESSAGES:[[@LINE-1]]:3: warning: variable 'p_local1' of type 'base' can be declared 'const'
+}
+
+void function_ref_target(int);
+using my_function_type = void (&)(int);
+void func_references() {
+  // Could be const, because the reference is not adjusted but adding that
+  // has no effect and creates a compiler warning.
+  my_function_type ptr = function_ref_target;
+}
+
+#if 0
+template <typename T>
+T &return_ref() {
+  static T global;
+  return global;
+}
+template <typename T>
+T *return_ptr() { return &return_ref<T>(); }
+
+template <typename T>
+void auto_usage_variants() {
+  // FIXME: Currently all 'auto's that deduce to a reference are not ignored
+  // for the analysis. That results in bad transformations.
+  auto auto_val0 = T{};
+  auto &auto_val1 = auto_val0; // Bad
+  auto *auto_val2 = &auto_val0;
+
+  auto auto_ref0 = return_ref<T>();  // Bad
+  auto &auto_ref1 = return_ref<T>(); // Bad
+  auto *auto_ref2 = return_ptr<T>();
+
+  auto auto_ptr0 = return_ptr<T>();
+  auto &auto_ptr1 = auto_ptr0;
+  auto *auto_ptr2 = return_ptr<T>();
+
+  using MyTypedef = T;
+  auto auto_td0 = MyTypedef{};
+  auto &auto_td1 = auto_td0; // Bad
+  auto *auto_td2 = &auto_td0;
+}
+void instantiate_auto_cases() {
+  auto_usage_variants<int>();
+  auto_usage_variants<System>();
+}
+#endif

clang/lib/Analysis/ExprMutationAnalyzer.cpp

 //===---------- ExprMutationAnalyzer.cpp ----------------------------------===//
 //
 // 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 "clang/Analysis/Analyses/ExprMutationAnalyzer.h"
+#include "clang/AST/Expr.h"
+#include "clang/AST/OperationKinds.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
 #include "llvm/ADT/STLExtras.h"
 
 namespace clang {
 using namespace ast_matchers;
 
 namespace {
 
 AST_MATCHER_P(LambdaExpr, hasCaptureInit, const Expr *, E) {
   return llvm::is_contained(Node.capture_inits(), E);
 }
 
 AST_MATCHER_P(CXXForRangeStmt, hasRangeStmt,
               ast_matchers::internal::Matcher<DeclStmt>, InnerMatcher) {
   const DeclStmt *const Range = Node.getRangeStmt();
   return InnerMatcher.matches(*Range, Finder, Builder);
 }
 
-AST_MATCHER_P(Expr, maybeEvalCommaExpr,
-             ast_matchers::internal::Matcher<Expr>, InnerMatcher) {
-  const Expr* Result = &Node;
+AST_MATCHER_P(Expr, maybeEvalCommaExpr, ast_matchers::internal::Matcher<Expr>,
+              InnerMatcher) {
+  const Expr *Result = &Node;
   while (const auto *BOComma =
-               dyn_cast_or_null<BinaryOperator>(Result->IgnoreParens())) {
     if (!BOComma->isCommaOp())
       break;
     Result = BOComma->getRHS();
   }
   return InnerMatcher.matches(*Result, Finder, Builder);
 }
 
+AST_MATCHER_P(Expr, canResolveToExpr, ast_matchers::internal::Matcher<Expr>,
+              InnerMatcher) {
+  // Unless the value is a derived class and is assigned to a
+  // reference to the base class. Other implicit casts should not
+  // happen.
+  const auto IgnoreDerivedToBase = ignoringParens(
+      expr(anyOf(implicitCastExpr(anyOf(hasCastKind(CK_DerivedToBase),
+                                        hasCastKind(CK_UncheckedDerivedToBase)),
+                                  hasSourceExpression(InnerMatcher)),
+                 InnerMatcher)));
+
+  auto const ComplexMatcher = ignoringParens(
+      expr(anyOf(maybeEvalCommaExpr(IgnoreDerivedToBase),
+                 conditionalOperator(
+                     anyOf(hasTrueExpression(ignoringParens(
+                               maybeEvalCommaExpr(IgnoreDerivedToBase))),
+                           hasFalseExpression(ignoringParens(
+                               maybeEvalCommaExpr(IgnoreDerivedToBase))))))));
+  return ComplexMatcher.matches(Node, Finder, Builder);
+}
+
+// Similar to 'hasAnyArgument', but does not work because 'InitListExpr' does
+// not have the 'arguments()' method.
+AST_MATCHER_P(InitListExpr, hasAnyArgumentExpr,
+              ast_matchers::internal::Matcher<Expr>, InnerMatcher) {
+  for (const Expr *Arg : Node.inits()) {
+    ast_matchers::internal::BoundNodesTreeBuilder Result(*Builder);
+    if (InnerMatcher.matches(*Arg, Finder, &Result)) {
+      *Builder = std::move(Result);
+      return true;
+    }
+  }
+  return false;
+}
+
 const ast_matchers::internal::VariadicDynCastAllOfMatcher<Stmt, CXXTypeidExpr>
     cxxTypeidExpr;
 
 AST_MATCHER(CXXTypeidExpr, isPotentiallyEvaluated) {
   return Node.isPotentiallyEvaluated();
 }
 
 const ast_matchers::internal::VariadicDynCastAllOfMatcher<Stmt,
const Stmt *ExprMutationAnalyzer::tryEachDeclRef(const Decl *Dec,
   return nullptr;
 }
 
 bool ExprMutationAnalyzer::isUnevaluated(const Expr *Exp) {
   return selectFirst<Expr>(
              NodeID<Expr>::value,
              match(
                  findAll(
-                     expr(equalsNode(Exp),
+                     expr(canResolveToExpr(equalsNode(Exp)),
                           anyOf(
                               // `Exp` is part of the underlying expression of
                               // decltype/typeof if it has an ancestor of
                               // typeLoc.
                               hasAncestor(typeLoc(unless(
                                   hasAncestor(unaryExprOrTypeTraitExpr())))),
                               hasAncestor(expr(anyOf(
                                   // `UnaryExprOrTypeTraitExpr` is unevaluated
const Stmt *ExprMutationAnalyzer::findDeclPointeeMutation(
     ArrayRef<ast_matchers::BoundNodes> Matches) {
   return tryEachMatch<Decl>(Matches, this,
                             &ExprMutationAnalyzer::findPointeeMutation);
 }
 
 const Stmt *ExprMutationAnalyzer::findDirectMutation(const Expr *Exp) {
   // LHS of any assignment operators.
   const auto AsAssignmentLhs = binaryOperator(
-      isAssignmentOperator(),
-      hasLHS(maybeEvalCommaExpr(ignoringParenImpCasts(equalsNode(Exp)))));
+      isAssignmentOperator(), hasLHS(canResolveToExpr(equalsNode(Exp))));
 
   // Operand of increment/decrement operators.
   const auto AsIncDecOperand =
       unaryOperator(anyOf(hasOperatorName("++"), hasOperatorName("--")),
-                    hasUnaryOperand(maybeEvalCommaExpr(
-                        ignoringParenImpCasts(equalsNode(Exp)))));
+                    hasUnaryOperand(canResolveToExpr(equalsNode(Exp))));
 
+  const auto NotInstantiated = unless(hasDeclaration(isInstantiated()));
   // Invoking non-const member function.
   // A member function is assumed to be non-const when it is unresolved.
   const auto NonConstMethod = cxxMethodDecl(unless(isConst()));
-  const auto AsNonConstThis =
-      expr(anyOf(cxxMemberCallExpr(callee(NonConstMethod),
-                                   on(maybeEvalCommaExpr(equalsNode(Exp)))),
-                 cxxOperatorCallExpr(callee(NonConstMethod),
-                                     hasArgument(0,
-                                                 maybeEvalCommaExpr(equalsNode(Exp)))),
-                 callExpr(callee(expr(anyOf(
-                     unresolvedMemberExpr(
-                       hasObjectExpression(maybeEvalCommaExpr(equalsNode(Exp)))),
-                     cxxDependentScopeMemberExpr(
-                         hasObjectExpression(maybeEvalCommaExpr(equalsNode(Exp))))))))));
+
+  const auto AsNonConstThis = expr(anyOf(
+      cxxMemberCallExpr(
+          callee(NonConstMethod),
+          on(ignoringImpCasts(canResolveToExpr(equalsNode(Exp))))),
+      cxxOperatorCallExpr(
+          callee(NonConstMethod),
+          hasArgument(0, ignoringImpCasts(canResolveToExpr(equalsNode(Exp))))),
+      // operator call expression might be unresolved as well. If that is
+      // the case and the operator is called on the 'Exp' itself, this is
+      // considered a moditication.
+      cxxOperatorCallExpr(
+          callee(expr(anyOf(unresolvedLookupExpr(), unresolvedMemberExpr(),
+                            cxxDependentScopeMemberExpr(),
+                            hasType(templateTypeParmType())))),
+          hasArgument(0, canResolveToExpr(equalsNode(Exp)))),
+      callExpr(callee(expr(
+          anyOf(unresolvedMemberExpr(hasObjectExpression(
+                    ignoringImpCasts(canResolveToExpr(equalsNode(Exp))))),
+                cxxDependentScopeMemberExpr(hasObjectExpression(
+                    ignoringImpCasts(canResolveToExpr(equalsNode(Exp))))))))),
+      callExpr(allOf(isTypeDependent(),
+                     callee(memberExpr(
+                         hasDeclaration(cxxMethodDecl(unless(isConst())))))))));
 
   // Taking address of 'Exp'.
   // We're assuming 'Exp' is mutated as soon as its address is taken, though in
   // theory we can follow the pointer and see whether it escaped `Stm` or is
   // dereferenced and then mutated. This is left for future improvements.
   const auto AsAmpersandOperand =
       unaryOperator(hasOperatorName("&"),
                     // A NoOp implicit cast is adding const.
                     unless(hasParent(implicitCastExpr(hasCastKind(CK_NoOp)))),
-                    hasUnaryOperand(maybeEvalCommaExpr(equalsNode(Exp))));
+                    hasUnaryOperand(canResolveToExpr(equalsNode(Exp))));
   const auto AsPointerFromArrayDecay =
       castExpr(hasCastKind(CK_ArrayToPointerDecay),
                unless(hasParent(arraySubscriptExpr())),
-               has(maybeEvalCommaExpr(equalsNode(Exp))));
+               has(canResolveToExpr(equalsNode(Exp))));
   // Treat calling `operator->()` of move-only classes as taking address.
   // These are typically smart pointers with unique ownership so we treat
   // mutation of pointee as mutation of the smart pointer itself.
-  const auto AsOperatorArrowThis =
-      cxxOperatorCallExpr(hasOverloadedOperatorName("->"),
-                          callee(cxxMethodDecl(ofClass(isMoveOnly()),
-                                               returns(nonConstPointerType()))),
-                          argumentCountIs(1),
-                          hasArgument(0, maybeEvalCommaExpr(equalsNode(Exp))));
+  const auto AsOperatorArrowThis = cxxOperatorCallExpr(
+      hasOverloadedOperatorName("->"),
+      callee(
+          cxxMethodDecl(ofClass(isMoveOnly()), returns(nonConstPointerType()))),
+      argumentCountIs(1), hasArgument(0, canResolveToExpr(equalsNode(Exp))));
 
   // Used as non-const-ref argument when calling a function.
   // An argument is assumed to be non-const-ref when the function is unresolved.
   // Instantiated template functions are not handled here but in
   // findFunctionArgMutation which has additional smarts for handling forwarding
   // references.
-  const auto NonConstRefParam = forEachArgumentWithParam(
-      maybeEvalCommaExpr(equalsNode(Exp)),
-      parmVarDecl(hasType(nonConstReferenceType())));
-  const auto NotInstantiated = unless(hasDeclaration(isInstantiated()));
+  const auto NonConstRefParam = forEachArgumentWithParamType(
+      anyOf(canResolveToExpr(equalsNode(Exp)),
+            memberExpr(hasObjectExpression(canResolveToExpr(equalsNode(Exp))))),
+      nonConstReferenceType());
   const auto AsNonConstRefArg = anyOf(
       callExpr(NonConstRefParam, NotInstantiated),
       cxxConstructExpr(NonConstRefParam, NotInstantiated),
       callExpr(callee(expr(anyOf(unresolvedLookupExpr(), unresolvedMemberExpr(),
                                  cxxDependentScopeMemberExpr(),
                                  hasType(templateTypeParmType())))),
-               hasAnyArgument(maybeEvalCommaExpr(equalsNode(Exp)))),
-      cxxUnresolvedConstructExpr(hasAnyArgument(maybeEvalCommaExpr(equalsNode(Exp)))));
+               hasAnyArgument(canResolveToExpr(equalsNode(Exp)))),
+      cxxUnresolvedConstructExpr(
+          hasAnyArgument(canResolveToExpr(equalsNode(Exp)))),
+      // Previous False Positive in the following Code:
+      // `template <typename T> void f() { int i = 42; new Type<T>(i); }`
+      // Where the constructor of `Type` takes its argument as reference.
+      // The AST does not resolve in a `cxxConstructExpr` because it is
+      // type-dependent.
+      parenListExpr(hasDescendant(expr(canResolveToExpr(equalsNode(Exp))))),
+      // If the initializer is for a reference type, there is no cast for
+      // the variable. Values are casted to RValue first.
+      initListExpr(
+          hasAnyArgumentExpr(expr(canResolveToExpr(equalsNode(Exp))))));
 
   // Captured by a lambda by reference.
   // If we're initializing a capture with 'Exp' directly then we're initializing
   // a reference capture.
   // For value captures there will be an ImplicitCastExpr <LValueToRValue>.
   const auto AsLambdaRefCaptureInit = lambdaExpr(hasCaptureInit(Exp));
 
   // Returned as non-const-ref.
   // If we're returning 'Exp' directly then it's returned as non-const-ref.
   // For returning by value there will be an ImplicitCastExpr <LValueToRValue>.
   // For returning by const-ref there will be an ImplicitCastExpr <NoOp> (for
   // adding const.)
   const auto AsNonConstRefReturn = returnStmt(hasReturnValue(
-                                                maybeEvalCommaExpr(equalsNode(Exp))));
+      anyOf(canResolveToExpr(equalsNode(Exp)),
+            castExpr(allOf(
+                hasCastKind(CK_DerivedToBase),
+                hasSourceExpression(canResolveToExpr(equalsNode(Exp))))))));
+
+  // It is used as a non-const-reference for initalizing a range-for loop.
+  const auto AsNonConstRefRangeInit = cxxForRangeStmt(
+      hasRangeInit(declRefExpr(allOf(canResolveToExpr(equalsNode(Exp)),
+                                     hasType(nonConstReferenceType())))));
 
   const auto Matches = match(
       traverse(
           ast_type_traits::TK_AsIs,
           findAll(stmt(anyOf(AsAssignmentLhs, AsIncDecOperand, AsNonConstThis,
                              AsAmpersandOperand, AsPointerFromArrayDecay,
                              AsOperatorArrowThis, AsNonConstRefArg,
                              AsLambdaRefCaptureInit, AsNonConstRefReturn))
                       .bind("stmt"))),
       Stm, Context);
   return selectFirst<Stmt>("stmt", Matches);
 }
 
 const Stmt *ExprMutationAnalyzer::findMemberMutation(const Expr *Exp) {
   // Check whether any member of 'Exp' is mutated.
   const auto MemberExprs =
-      match(findAll(expr(anyOf(memberExpr(hasObjectExpression(equalsNode(Exp))),
-                               cxxDependentScopeMemberExpr(
-                                   hasObjectExpression(equalsNode(Exp)))))
+      match(findAll(expr(anyOf(memberExpr(hasObjectExpression(
+                                   canResolveToExpr(equalsNode(Exp)))),
+                               cxxDependentScopeMemberExpr(hasObjectExpression(
+                                   canResolveToExpr(equalsNode(Exp))))))
                         .bind(NodeID<Expr>::value)),
             Stm, Context);
   return findExprMutation(MemberExprs);
 }
 
 const Stmt *ExprMutationAnalyzer::findArrayElementMutation(const Expr *Exp) {
   // Check whether any element of an array is mutated.
-  const auto SubscriptExprs = match(
-      findAll(arraySubscriptExpr(hasBase(ignoringImpCasts(equalsNode(Exp))))
+  const auto SubscriptExprs =
+      match(findAll(arraySubscriptExpr(
+                        anyOf(hasBase(canResolveToExpr(equalsNode(Exp))),
+                              hasBase(implicitCastExpr(
+                                  allOf(hasCastKind(CK_ArrayToPointerDecay),
+                                        hasSourceExpression(canResolveToExpr(
+                                            equalsNode(Exp))))))))
                         .bind(NodeID<Expr>::value)),
             Stm, Context);
   return findExprMutation(SubscriptExprs);
 }
 
 const Stmt *ExprMutationAnalyzer::findCastMutation(const Expr *Exp) {
+  // If the 'Exp' is explicitly casted to a non-const reference type the
+  // 'Exp' is considered to be modified.
+  const auto ExplicitCast = match(
+      findAll(
+          stmt(castExpr(hasSourceExpression(canResolveToExpr(equalsNode(Exp))),
+                        explicitCastExpr(
+                            hasDestinationType(nonConstReferenceType()))))
+              .bind("stmt")),
+      Stm, Context);
+
+  if (const auto *CastStmt = selectFirst<Stmt>("stmt", ExplicitCast))
+    return CastStmt;
+
   // If 'Exp' is casted to any non-const reference type, check the castExpr.
-  const auto Casts =
-      match(findAll(castExpr(hasSourceExpression(equalsNode(Exp)),
-                             anyOf(explicitCastExpr(hasDestinationType(
-                                       nonConstReferenceType())),
-                                   implicitCastExpr(hasImplicitDestinationType(
-                                       nonConstReferenceType()))))
-                        .bind(NodeID<Expr>::value)),
-            Stm, Context);
+  const auto Casts = match(
+      findAll(
+          expr(castExpr(hasSourceExpression(canResolveToExpr(equalsNode(Exp))),
+                        anyOf(explicitCastExpr(
+                                  hasDestinationType(nonConstReferenceType())),
+                                  nonConstReferenceType())))))
+
   if (const Stmt *S = findExprMutation(Casts))
     return S;
   // Treat std::{move,forward} as cast.
   const auto Calls =
       match(findAll(callExpr(callee(namedDecl(
                                  hasAnyName("::std::move", "::std::forward"))),
-                             hasArgument(0, equalsNode(Exp)))
+                             hasArgument(0, canResolveToExpr(equalsNode(Exp))))
                         .bind("expr")),
             Stm, Context);
   return findExprMutation(Calls);
 }
 
 const Stmt *ExprMutationAnalyzer::findRangeLoopMutation(const Expr *Exp) {
+  // Keep the ordering for the specific initialization matches to happen first,
+  // because it is cheaper to match then all potential modifications of the
+  // loop variable.
+
+  // The range variable is a reference to a builtin array. In that case the
+  // array is considered modified if the loop-variable is a non-const reference.
+  const auto DeclStmtToNonRefToArray = declStmt(hasSingleDecl(varDecl(hasType(
+      hasUnqualifiedDesugaredType(referenceType(pointee(arrayType())))))));
+  const auto RefToArrayRefToElements = match(
+      findAll(stmt(cxxForRangeStmt(
+                       hasLoopVariable(varDecl(hasType(nonConstReferenceType()))
+                                           .bind(NodeID<Decl>::value)),
+                       hasRangeStmt(DeclStmtToNonRefToArray),
+                       hasRangeInit(canResolveToExpr(equalsNode(Exp)))))
+                  .bind("stmt")),
+      Stm, Context);
+
+  if (const auto *BadRangeInitFromArray =
+          selectFirst<Stmt>("stmt", RefToArrayRefToElements))
+    return BadRangeInitFromArray;
+
+  // It is possible, that containers do not provide a const-overload for their
+  // iterator accessors. If this is the case, the variable is used non-const
+  // no matter what happens in the loop. This requires special detection as it
+  // is faster to find then all mutations of the loop variable.
+  // It aims at a different modification as well.
+  const auto HasAnyNonConstIterator =
+      anyOf(allOf(hasMethod(allOf(hasName("begin"), unless(isConst()))),
+                  unless(hasMethod(allOf(hasName("begin"), isConst())))),
+            allOf(hasMethod(allOf(hasName("end"), unless(isConst()))),
+                  unless(hasMethod(allOf(hasName("end"), isConst())))));
+
+  const auto DeclStmtToNonConstIteratorContainer = declStmt(
+      hasSingleDecl(varDecl(hasType(hasUnqualifiedDesugaredType(referenceType(
+          pointee(hasDeclaration(cxxRecordDecl(HasAnyNonConstIterator)))))))));
+
+  const auto RefToContainerBadIterators =
+      match(findAll(stmt(cxxForRangeStmt(allOf(
+                             hasRangeStmt(DeclStmtToNonConstIteratorContainer),
+                             hasRangeInit(canResolveToExpr(equalsNode(Exp))))))
+                        .bind("stmt")),
+            Stm, Context);
+
+  if (const auto *BadIteratorsContainer =
+          selectFirst<Stmt>("stmt", RefToContainerBadIterators))
+    return BadIteratorsContainer;
+
   // If range for looping over 'Exp' with a non-const reference loop variable,
   // check all declRefExpr of the loop variable.
   const auto LoopVars =
       match(findAll(cxxForRangeStmt(
                 hasLoopVariable(varDecl(hasType(nonConstReferenceType()))
                                     .bind(NodeID<Decl>::value)),
-                hasRangeInit(equalsNode(Exp)))),
+                hasRangeInit(canResolveToExpr(equalsNode(Exp))))),
             Stm, Context);
   return findDeclMutation(LoopVars);
 }
 
 const Stmt *ExprMutationAnalyzer::findReferenceMutation(const Expr *Exp) {
   // Follow non-const reference returned by `operator*()` of move-only classes.
   // These are typically smart pointers with unique ownership so we treat
   // mutation of pointee as mutation of the smart pointer itself.
   const auto Ref =
       match(findAll(cxxOperatorCallExpr(
                         hasOverloadedOperatorName("*"),
                         callee(cxxMethodDecl(ofClass(isMoveOnly()),
                                              returns(nonConstReferenceType()))),
-                        argumentCountIs(1), hasArgument(0, equalsNode(Exp)))
+                        argumentCountIs(1),
+                        hasArgument(0, canResolveToExpr(equalsNode(Exp))))
                         .bind(NodeID<Expr>::value)),
             Stm, Context);
   if (const Stmt *S = findExprMutation(Ref))
     return S;
 
   // If 'Exp' is bound to a non-const reference, check all declRefExpr to that.
   const auto Refs = match(
       stmt(forEachDescendant(
           varDecl(
               hasType(nonConstReferenceType()),
-              hasInitializer(anyOf(equalsNode(Exp),
-                                   conditionalOperator(anyOf(
-                                       hasTrueExpression(equalsNode(Exp)),
-                                       hasFalseExpression(equalsNode(Exp)))))),
+              hasInitializer(anyOf(canResolveToExpr(equalsNode(Exp)),
+                                   memberExpr(hasObjectExpression(
+                                       canResolveToExpr(equalsNode(Exp)))))),
               hasParent(declStmt().bind("stmt")),
-              // Don't follow the reference in range statement, we've handled
-              // that separately.
+              // Don't follow the reference in range statement, we've
+              // handled that separately.
               unless(hasParent(declStmt(hasParent(
                   cxxForRangeStmt(hasRangeStmt(equalsBoundNode("stmt"))))))))
               .bind(NodeID<Decl>::value))),
       Stm, Context);
   return findDeclMutation(Refs);
 }
 
 const Stmt *ExprMutationAnalyzer::findFunctionArgMutation(const Expr *Exp) {
   const auto NonConstRefParam = forEachArgumentWithParam(
-      equalsNode(Exp),
+      canResolveToExpr(equalsNode(Exp)),
       parmVarDecl(hasType(nonConstReferenceType())).bind("parm"));
   const auto IsInstantiated = hasDeclaration(isInstantiated());
   const auto FuncDecl = hasDeclaration(functionDecl().bind("func"));
   const auto Matches = match(
       traverse(
           ast_type_traits::TK_AsIs,
           findAll(
               expr(anyOf(callExpr(NonConstRefParam, IsInstantiated, FuncDecl,

clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp

 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <cctype>
 
 namespace clang {
 
 using namespace clang::ast_matchers;
 using ::testing::ElementsAre;
-using ::testing::IsEmpty;
 using ::testing::ResultOf;
-using ::testing::StartsWith;
 using ::testing::Values;
 
 namespace {
 
 using ExprMatcher = internal::Matcher<Expr>;
 using StmtMatcher = internal::Matcher<Stmt>;
 
 std::unique_ptr<ASTUnit>
bool isMutated(const SmallVectorImpl<BoundNodes> &Results, ASTUnit *AST) {
   return ExprMutationAnalyzer(*S, AST->getASTContext()).isMutated(E);
 }
 
 SmallVector<std::string, 1>
 mutatedBy(const SmallVectorImpl<BoundNodes> &Results, ASTUnit *AST) {
   const auto *const S = selectFirst<Stmt>("stmt", Results);
   SmallVector<std::string, 1> Chain;
   ExprMutationAnalyzer Analyzer(*S, AST->getASTContext());
+
+  std::string buffer;
   for (const auto *E = selectFirst<Expr>("expr", Results); E != nullptr;) {
     const Stmt *By = Analyzer.findMutation(E);
-    std::string buffer;
+    if (!By)
+      break;
+
     llvm::raw_string_ostream stream(buffer);
     By->printPretty(stream, nullptr, AST->getASTContext().getPrintingPolicy());
-    Chain.push_back(StringRef(stream.str()).trim().str());
+    Chain.emplace_back(StringRef(stream.str()).trim().str());
     E = dyn_cast<DeclRefExpr>(By);
+    buffer.clear();
   }
   return Chain;
 }
 
 std::string removeSpace(std::string s) {
   s.erase(std::remove_if(s.begin(), s.end(),
                          [](char c) { return llvm::isSpace(c); }),
           s.end());
EXPECT_THAT(mutatedBy(Results, AST.get()),
               ElementsAre("static_cast<A &&>(x)"));
 }
 
 TEST(ExprMutationAnalyzerTest, ByConstRRefArgument) {
   auto AST = buildASTFromCode(
       "void g(const int&&); void f() { int x; g(static_cast<int&&>(x)); }");
   auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
-  EXPECT_FALSE(isMutated(Results, AST.get()));
+  EXPECT_THAT(mutatedBy(Results, AST.get()),
+              ElementsAre("static_cast<int &&>(x)"));
 
   AST = buildASTFromCode("struct A {}; A operator+(const A&&, int);"
                          "void f() { A x; static_cast<A&&>(x) + 1; }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
-  EXPECT_FALSE(isMutated(Results, AST.get()));
+  EXPECT_THAT(mutatedBy(Results, AST.get()),
+              ElementsAre("static_cast<A &&>(x)"));
 
   AST = buildASTFromCode("void f() { struct A { A(const int&&); }; "
                          "int x; A y(static_cast<int&&>(x)); }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
-  EXPECT_FALSE(isMutated(Results, AST.get()));
+  EXPECT_THAT(mutatedBy(Results, AST.get()),
+              ElementsAre("static_cast<int &&>(x)"));
 
   AST = buildASTFromCode("void f() { struct A { A(); A(const A&&); }; "
                          "A x; A y(static_cast<A&&>(x)); }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
-  EXPECT_FALSE(isMutated(Results, AST.get()));
+  EXPECT_THAT(mutatedBy(Results, AST.get()),
+              ElementsAre("static_cast<A &&>(x)"));
 }
 
 TEST(ExprMutationAnalyzerTest, Move) {
   auto AST = buildASTFromCode(StdRemoveReference + StdMove +
                               "void f() { struct A {}; A x; std::move(x); }");
   auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));

 }
 
 TEST(ExprMutationAnalyzerTest, ReturnAsNonConstRRef) {
   const auto AST =
       buildASTFromCode("int&& f() { int x; return static_cast<int &&>(x); }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()),
-              ElementsAre("return static_cast<int &&>(x);"));
+              ElementsAre("static_cast<int &&>(x)"));
 }
 
 TEST(ExprMutationAnalyzerTest, ReturnAsConstRRef) {
   const auto AST = buildASTFromCode(
       "const int&& f() { int x; return static_cast<int&&>(x); }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
-  EXPECT_FALSE(isMutated(Results, AST.get()));
+  EXPECT_THAT(mutatedBy(Results, AST.get()),
+              ElementsAre("static_cast<int &&>(x)"));
 }
 
 TEST(ExprMutationAnalyzerTest, TakeAddress) {
   const auto AST = buildASTFromCode("void g(int*); void f() { int x; g(&x); }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("&x"));
 }

 }
 
 TEST(ExprMutationAnalyzerTest, CastToRefModified) {
   auto AST =
       buildASTFromCode("void f() { int x; static_cast<int &>(x) = 10; }");
   auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()),
-              ElementsAre("static_cast<int &>(x) = 10"));
+              ElementsAre("static_cast<int &>(x)"));
 
   AST = buildASTFromCode("typedef int& IntRef;"
                          "void f() { int x; static_cast<IntRef>(x) = 10; }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()),
-              ElementsAre("static_cast<IntRef>(x) = 10"));
+              ElementsAre("static_cast<IntRef>(x)"));
 }
 
 TEST(ExprMutationAnalyzerTest, CastToRefNotModified) {
   const auto AST =
       buildASTFromCode("void f() { int x; static_cast<int&>(x); }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
-  EXPECT_FALSE(isMutated(Results, AST.get()));
+  EXPECT_THAT(mutatedBy(Results, AST.get()),
+              ElementsAre("static_cast<int &>(x)"));
 }
 
 TEST(ExprMutationAnalyzerTest, CastToConstRef) {
   auto AST =
       buildASTFromCode("void f() { int x; static_cast<const int&>(x); }");
   auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
EXPECT_THAT(mutatedBy(Results, AST.get()),
               ElementsAre(ResultOf(removeSpace, "[&x](){x=10;}")));
 }
 
 TEST(ExprMutationAnalyzerTest, RangeForArrayByRefModified) {
   auto AST =
       buildASTFromCode("void f() { int x[2]; for (int& e : x) e = 10; }");
   auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
-  EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("e", "e = 10"));
+  EXPECT_THAT(mutatedBy(Results, AST.get()),
+              ElementsAre("for (int &e : x)\n    e = 10;"));
 
   AST = buildASTFromCode("typedef int& IntRef;"
                          "void f() { int x[2]; for (IntRef e : x) e = 10; }");
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
-  EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("e", "e = 10"));
+  EXPECT_THAT(mutatedBy(Results, AST.get()),
+              ElementsAre("for (IntRef e : x)\n    e = 10;"));
 }
 
-TEST(ExprMutationAnalyzerTest, RangeForArrayByRefNotModified) {
+TEST(ExprMutationAnalyzerTest, RangeForArrayByRefModifiedByImplicitInit) {
   const auto AST =
       buildASTFromCode("void f() { int x[2]; for (int& e : x) e; }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
-  EXPECT_FALSE(isMutated(Results, AST.get()));
+  EXPECT_TRUE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, RangeForArrayByValue) {
   auto AST = buildASTFromCode("void f() { int x[2]; for (int e : x) e = 10; }");
   auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_FALSE(isMutated(Results, AST.get()));
 

 }
 
 TEST(ExprMutationAnalyzerTest, RangeForNonArrayByRefModified) {
   const auto AST =
       buildASTFromCode("struct V { int* begin(); int* end(); };"
                        "void f() { V x; for (int& e : x) e = 10; }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
-  EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("e", "e = 10"));
+  EXPECT_THAT(mutatedBy(Results, AST.get()),
+              ElementsAre("for (int &e : x)\n    e = 10;"));
 }
 
 TEST(ExprMutationAnalyzerTest, RangeForNonArrayByRefNotModified) {
   const auto AST = buildASTFromCode("struct V { int* begin(); int* end(); };"
                                     "void f() { V x; for (int& e : x) e; }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
-  EXPECT_FALSE(isMutated(Results, AST.get()));
+  EXPECT_TRUE(isMutated(Results, AST.get()));
 }
 
 TEST(ExprMutationAnalyzerTest, RangeForNonArrayByValue) {
   const auto AST = buildASTFromCode(
       "struct V { const int* begin() const; const int* end() const; };"
       "void f() { V x; for (int e : x) e; }");
   const auto Results =
       match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
TEST(ExprMutationAnalyzerTest, UniquePtr) {
 
   AST = buildASTFromCodeWithArgs(
       UniquePtrDef + "template <class T> void f() { UniquePtr<T> x; x->mf(); }",
       {"-fno-delayed-template-parsing"});
   Results = match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
   EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("x->mf()"));
 }
 
+TEST(ExprMutationAnalyzerTest, UnevaluatedContext) {
+  const std::string Example =
+      "template <typename T>"
+      "struct to_construct : T { to_construct(int &j) {} };"
+      "template <typename T>"
+      "void placement_new_in_unique_ptr() { int x = 0;"
+      "  new to_construct<T>(x);"
+      "}";
+  auto AST =
+      buildASTFromCodeWithArgs(Example, {"-fno-delayed-template-parsing"});
+  auto Results =
+      match(withEnclosingCompound(declRefTo("x")), AST->getASTContext());
+  EXPECT_TRUE(isMutated(Results, AST.get()));
+  EXPECT_THAT(mutatedBy(Results, AST.get()), ElementsAre("(x)"));
+}
+
 TEST(ExprMutationAnalyzerTest, ReproduceFailureMinimal) {
   const std::string Reproducer =
       "namespace std {"
       "template <class T> T forward(T & A) { return static_cast<T&&>(A); }"
       "template <class T> struct __bind {"
       "  T f;"
       "  template <class V> __bind(T v, V &&) : f(forward(v)) {}"
       "};"