Page MenuHomePhabricator

flx (Felix Berger)
User

Projects

User does not belong to any projects.

User Details

User Since
Sep 14 2015, 7:53 AM (279 w, 1 d)

Recent Activity

Dec 10 2020

flx committed rG671ad580610a: [clang-tidy] performance-unnecessary-copy-initialization: Prevent false… (authored by flx).
[clang-tidy] performance-unnecessary-copy-initialization: Prevent false…
Dec 10 2020, 1:59 PM
flx closed D91893: [clang-tidy] performance-unnecessary-copy-initialization: Prevent false positives when dependent variable is modified..
Dec 10 2020, 1:58 PM · Restricted Project, Restricted Project
flx updated the diff for D91893: [clang-tidy] performance-unnecessary-copy-initialization: Prevent false positives when dependent variable is modified..

Shortened isa<> expression.

Dec 10 2020, 12:56 PM · Restricted Project, Restricted Project
flx added inline comments to D91893: [clang-tidy] performance-unnecessary-copy-initialization: Prevent false positives when dependent variable is modified..
Dec 10 2020, 7:40 AM · Restricted Project, Restricted Project
flx updated the diff for D91893: [clang-tidy] performance-unnecessary-copy-initialization: Prevent false positives when dependent variable is modified..

Added positive variants of new tests.

Dec 10 2020, 7:37 AM · Restricted Project, Restricted Project

Dec 8 2020

flx added a comment to D91893: [clang-tidy] performance-unnecessary-copy-initialization: Prevent false positives when dependent variable is modified..

Thanks for the review, Aaron! I appreciate it. Please let me know if you have any questions about the test cases.

Dec 8 2020, 10:53 AM · Restricted Project, Restricted Project
flx updated the diff for D91893: [clang-tidy] performance-unnecessary-copy-initialization: Prevent false positives when dependent variable is modified..

Address review comments.

Dec 8 2020, 10:50 AM · Restricted Project, Restricted Project

Dec 7 2020

flx added a comment to D91893: [clang-tidy] performance-unnecessary-copy-initialization: Prevent false positives when dependent variable is modified..

Could someone take a first pass at this change? It would be great progress on this as this is the last currently known case that generates false positives.

Dec 7 2020, 6:16 AM · Restricted Project, Restricted Project

Dec 3 2020

flx updated the diff for D91893: [clang-tidy] performance-unnecessary-copy-initialization: Prevent false positives when dependent variable is modified..

Fixed clang tidy warnings.

Dec 3 2020, 2:02 PM · Restricted Project, Restricted Project

Nov 20 2020

flx added a reviewer for D91893: [clang-tidy] performance-unnecessary-copy-initialization: Prevent false positives when dependent variable is modified.: ckennelly.
Nov 20 2020, 7:52 PM · Restricted Project, Restricted Project
flx updated the diff for D91893: [clang-tidy] performance-unnecessary-copy-initialization: Prevent false positives when dependent variable is modified..

Fix formatting and comments.

Nov 20 2020, 1:44 PM · Restricted Project, Restricted Project
flx requested review of D91893: [clang-tidy] performance-unnecessary-copy-initialization: Prevent false positives when dependent variable is modified..
Nov 20 2020, 1:38 PM · Restricted Project, Restricted Project

Nov 16 2020

flx committed rGace9653c11c6: [clang-tidy] performance-unnecessary-copy-initialization: Check for const… (authored by flx).
[clang-tidy] performance-unnecessary-copy-initialization: Check for const…
Nov 16 2020, 2:09 PM
flx closed D90042: [clang-tidy] performance-unnecessary-copy-initialization: Check for const reference arguments that are replaced template parameter type..
Nov 16 2020, 2:09 PM · Restricted Project, Restricted Project
flx added a comment to D90042: [clang-tidy] performance-unnecessary-copy-initialization: Check for const reference arguments that are replaced template parameter type..

LGTM, thank you for the fix!

Nov 16 2020, 12:35 PM · Restricted Project, Restricted Project

Nov 12 2020

flx updated the summary of D90042: [clang-tidy] performance-unnecessary-copy-initialization: Check for const reference arguments that are replaced template parameter type..
Nov 12 2020, 7:31 AM · Restricted Project, Restricted Project
flx updated the diff for D90042: [clang-tidy] performance-unnecessary-copy-initialization: Check for const reference arguments that are replaced template parameter type..

Updated change description.

Nov 12 2020, 7:30 AM · Restricted Project, Restricted Project
flx added a comment to D90042: [clang-tidy] performance-unnecessary-copy-initialization: Check for const reference arguments that are replaced template parameter type..
In D90042#2390203, @flx wrote:

Thanks for the suggestion, I had never hear of creduce!

Glad to have introduced you to it -- it's a great tool!

After a bit of trial an error I seem to have found a more minimal example:

namespace std {                                                                                                              
template <typename> class function;                                                                                          
template <typename a, typename... b> class function<a(b...)> {                                                               
public:                                                                                                                      
  void operator()(b...);                                                                                                     
};                                                                                                                           
} // namespace std                                                                                                           
struct c {                                                                                                                   
  c();                                                                                                                       
  c(const c &);                                                                                                              
};                                                                                                                           
std::function<void(c &)> f;                                                                                                  
void d() {                                                                                                                   
  c Orig;                                                                                                                    
  c Copy = Orig;                                                                                                             
  f(Copy);                                                                                                                   
}

To be frank I can't spot a meaningful difference to the std::function copy we already have.

Aha, I may have spotted it. The call operators have subtly different signatures and the signature we have in our test file is wrong. Note the && in our test file compared to what the standard defines: http://eel.is/c++draft/func.wrap.func#inv which is what's causing the difference here: https://godbolt.org/z/hxfM7P

Nov 12 2020, 7:28 AM · Restricted Project, Restricted Project
flx updated the diff for D90042: [clang-tidy] performance-unnecessary-copy-initialization: Check for const reference arguments that are replaced template parameter type..

Remove unnecessary test code that is not needed.

Nov 12 2020, 7:27 AM · Restricted Project, Restricted Project
flx updated the diff for D90042: [clang-tidy] performance-unnecessary-copy-initialization: Check for const reference arguments that are replaced template parameter type..

Fixed definition of fake std::function which now makes the bug fixed by this change reproducible.

Nov 12 2020, 7:20 AM · Restricted Project, Restricted Project

Nov 11 2020

flx added a comment to D90042: [clang-tidy] performance-unnecessary-copy-initialization: Check for const reference arguments that are replaced template parameter type..
In D90042#2360042, @flx wrote:
In D90042#2356265, @flx wrote:
In D90042#2350035, @flx wrote:

I should note that I was only able to reproduce the false positive with the actual implementation std::function and not our fake version here.

Any reason not to lift enough of the actual definition to be able to reproduce the issue in your test cases? Does the change in definitions break other tests?

I poured over the actual definition and couldn't find any difference wrt the call operator that would explain it. I would also think that:

template <typename T>
void foo(T&& t) {
  std::forward<T>(t).modify();
}

would be a simpler case that should trigger replacement, but it doesn't. Do you have any idea what I could be missing?

Perhaps silly question, but are you instantiating foo()?

I think I added a full implementation of foo now, reverted the change, but am still not getting the negative case to fail. Can you spot an issue with the code?

I can't, but to be honest, I'm not certain I understand how that false positive could happen in the first place. That's why I was hoping to see the original case -- one thing you could try is with the original code, pass -E to preprocess to a file, and then try reducing the test case from that output (either by hand or by using a tool like creduce), or did you already give that a shot?

Nov 11 2020, 5:38 PM · Restricted Project, Restricted Project

Oct 28 2020

flx added a comment to D90042: [clang-tidy] performance-unnecessary-copy-initialization: Check for const reference arguments that are replaced template parameter type..
In D90042#2356265, @flx wrote:
In D90042#2350035, @flx wrote:

I should note that I was only able to reproduce the false positive with the actual implementation std::function and not our fake version here.

Any reason not to lift enough of the actual definition to be able to reproduce the issue in your test cases? Does the change in definitions break other tests?

I poured over the actual definition and couldn't find any difference wrt the call operator that would explain it. I would also think that:

template <typename T>
void foo(T&& t) {
  std::forward<T>(t).modify();
}

would be a simpler case that should trigger replacement, but it doesn't. Do you have any idea what I could be missing?

Perhaps silly question, but are you instantiating foo()?

Oct 28 2020, 12:42 PM · Restricted Project, Restricted Project
flx updated the diff for D90042: [clang-tidy] performance-unnecessary-copy-initialization: Check for const reference arguments that are replaced template parameter type..

Comment out replaced parameter.

Oct 28 2020, 12:40 PM · Restricted Project, Restricted Project
flx updated the diff for D90042: [clang-tidy] performance-unnecessary-copy-initialization: Check for const reference arguments that are replaced template parameter type..

Add instantiated template method.

Oct 28 2020, 12:34 PM · Restricted Project, Restricted Project

Oct 27 2020

flx added a comment to D90042: [clang-tidy] performance-unnecessary-copy-initialization: Check for const reference arguments that are replaced template parameter type..
In D90042#2350035, @flx wrote:

I should note that I was only able to reproduce the false positive with the actual implementation std::function and not our fake version here.

Any reason not to lift enough of the actual definition to be able to reproduce the issue in your test cases? Does the change in definitions break other tests?

Oct 27 2020, 6:20 AM · Restricted Project, Restricted Project

Oct 23 2020

flx added a comment to D90042: [clang-tidy] performance-unnecessary-copy-initialization: Check for const reference arguments that are replaced template parameter type..

I should note that I was only able to reproduce the false positive with the actual implementation std::function and not our fake version here.

Oct 23 2020, 6:57 AM · Restricted Project, Restricted Project
flx updated the diff for D90042: [clang-tidy] performance-unnecessary-copy-initialization: Check for const reference arguments that are replaced template parameter type..

Revert -std=c++17 change.

Oct 23 2020, 6:55 AM · Restricted Project, Restricted Project
flx updated the diff for D90042: [clang-tidy] performance-unnecessary-copy-initialization: Check for const reference arguments that are replaced template parameter type..

Remove code comment.

Oct 23 2020, 6:49 AM · Restricted Project, Restricted Project
flx requested review of D90042: [clang-tidy] performance-unnecessary-copy-initialization: Check for const reference arguments that are replaced template parameter type..
Oct 23 2020, 6:48 AM · Restricted Project, Restricted Project

Oct 21 2020

flx committed rG1c1f794c2b64: Always allow std::function to be copied. (authored by flx).
Always allow std::function to be copied.
Oct 21 2020, 2:23 PM
flx closed D89332: [clang-tidy] performance-unnecessary-copy-initialization: Always allow std::function to be copied..
Oct 21 2020, 2:23 PM · Restricted Project
flx added a comment to D89332: [clang-tidy] performance-unnecessary-copy-initialization: Always allow std::function to be copied..

Added a fake std function that still triggers the check.

Oct 21 2020, 1:37 PM · Restricted Project
flx updated the diff for D89332: [clang-tidy] performance-unnecessary-copy-initialization: Always allow std::function to be copied..

Add fake std function to ensure it is still matched.

Oct 21 2020, 1:28 PM · Restricted Project
flx updated the diff for D89332: [clang-tidy] performance-unnecessary-copy-initialization: Always allow std::function to be copied..

Fix compile errors.

Oct 21 2020, 7:39 AM · Restricted Project

Oct 20 2020

flx added a comment to D89332: [clang-tidy] performance-unnecessary-copy-initialization: Always allow std::function to be copied..

Thank you all for the input!

Oct 20 2020, 2:29 PM · Restricted Project
flx updated the diff for D89332: [clang-tidy] performance-unnecessary-copy-initialization: Always allow std::function to be copied..

Use hasName matcher on the declaration of the canonical type.

Oct 20 2020, 2:21 PM · Restricted Project

Oct 16 2020

flx added inline comments to D89332: [clang-tidy] performance-unnecessary-copy-initialization: Always allow std::function to be copied..
Oct 16 2020, 1:47 PM · Restricted Project
flx updated the diff for D89332: [clang-tidy] performance-unnecessary-copy-initialization: Always allow std::function to be copied..

Add more complete fake version of std::function.

Oct 16 2020, 1:46 PM · Restricted Project

Oct 15 2020

flx added reviewers for D89332: [clang-tidy] performance-unnecessary-copy-initialization: Always allow std::function to be copied.: gribozavr2, ymandel.
Oct 15 2020, 8:33 AM · Restricted Project

Oct 13 2020

flx added inline comments to D89332: [clang-tidy] performance-unnecessary-copy-initialization: Always allow std::function to be copied..
Oct 13 2020, 11:09 AM · Restricted Project
flx retitled D89332: [clang-tidy] performance-unnecessary-copy-initialization: Always allow std::function to be copied. from Always allow std::function to be copied. to [clang-tidy] performance-unnecessary-copy-initialization: Always allow std::function to be copied..
Oct 13 2020, 10:40 AM · Restricted Project
flx requested review of D89332: [clang-tidy] performance-unnecessary-copy-initialization: Always allow std::function to be copied..
Oct 13 2020, 10:39 AM · Restricted Project

Sep 14 2020

flx added a comment to D87455: [clang-tidy] performance-unnecessary-copy-initialization: Restrict UnnecessaryCopyInitialization check to variables initialized from free functions without arguments .

Thank you for the review, Aaron!

Sep 14 2020, 10:53 AM · Restricted Project, Restricted Project
flx updated the diff for D87455: [clang-tidy] performance-unnecessary-copy-initialization: Restrict UnnecessaryCopyInitialization check to variables initialized from free functions without arguments .
Sep 14 2020, 10:43 AM · Restricted Project, Restricted Project
flx added inline comments to D87455: [clang-tidy] performance-unnecessary-copy-initialization: Restrict UnnecessaryCopyInitialization check to variables initialized from free functions without arguments .
Sep 14 2020, 8:56 AM · Restricted Project, Restricted Project
flx updated the diff for D87455: [clang-tidy] performance-unnecessary-copy-initialization: Restrict UnnecessaryCopyInitialization check to variables initialized from free functions without arguments .
Sep 14 2020, 8:55 AM · Restricted Project, Restricted Project
flx added inline comments to D87455: [clang-tidy] performance-unnecessary-copy-initialization: Restrict UnnecessaryCopyInitialization check to variables initialized from free functions without arguments .
Sep 14 2020, 8:21 AM · Restricted Project, Restricted Project

Sep 10 2020

flx updated the diff for D87455: [clang-tidy] performance-unnecessary-copy-initialization: Restrict UnnecessaryCopyInitialization check to variables initialized from free functions without arguments .
Sep 10 2020, 10:56 AM · Restricted Project, Restricted Project
flx added a comment to D87455: [clang-tidy] performance-unnecessary-copy-initialization: Restrict UnnecessaryCopyInitialization check to variables initialized from free functions without arguments .

The motivating false positive was the free functions std::min. To not limit the usefulness of the check I'll only disable arguments for free functions for now. Updated change coming.

Sep 10 2020, 10:40 AM · Restricted Project, Restricted Project
flx requested review of D87455: [clang-tidy] performance-unnecessary-copy-initialization: Restrict UnnecessaryCopyInitialization check to variables initialized from free functions without arguments .
Sep 10 2020, 7:56 AM · Restricted Project, Restricted Project

May 5 2020

flx created D79440: Fix ForRangeCopyCheck not triggering on iterators returning elements by value in C++17..
May 5 2020, 1:30 PM · Restricted Project

Sep 26 2018

flx added a comment to D52360: [clang-tidy] Fix for performance-unnecessary-value-param, performance-unnecessary-copy-initialization and performance-for-range-copy.

Would that also skip checks for something like shared_ptr?

Yes, everything ending on pointer, ptr, reference or ref, first letter case insensitive.

Sep 26 2018, 7:10 AM · Restricted Project

Sep 20 2018

flx added inline comments to D52315: [clang-tidy] Fix for performance-unnecessary-value-param, performance-unnecessary-copy-initialization and performance-for-range-copy.
Sep 20 2018, 10:41 AM · Restricted Project

Jul 25 2017

flx committed rL309067: [clang-tidy] Do not issue fixit for explicit template specializations.
[clang-tidy] Do not issue fixit for explicit template specializations
Jul 25 2017, 5:46 PM
flx closed D35718: [clang-tidy] Do not issue fixit for explicit template specializations by committing rL309067: [clang-tidy] Do not issue fixit for explicit template specializations.
Jul 25 2017, 5:46 PM

Jul 22 2017

flx updated the diff for D35718: [clang-tidy] Do not issue fixit for explicit template specializations.
Jul 22 2017, 7:08 AM

Jul 20 2017

flx created D35718: [clang-tidy] Do not issue fixit for explicit template specializations.
Jul 20 2017, 9:36 PM

Jan 19 2017

flx committed rL292491: [clang-tidy] Do not trigger move fix for non-copy assignment operators in….
[clang-tidy] Do not trigger move fix for non-copy assignment operators in…
Jan 19 2017, 8:02 AM
flx closed D28899: [clang-tidy] Do not trigger move fix for non-copy assignment operators in performance-unnecessary-value-param check by committing rL292491: [clang-tidy] Do not trigger move fix for non-copy assignment operators in….
Jan 19 2017, 8:02 AM
flx created D28899: [clang-tidy] Do not trigger move fix for non-copy assignment operators in performance-unnecessary-value-param check.
Jan 19 2017, 6:06 AM

Dec 15 2016

flx committed rL289912: [clang-tidy] Do not move parameter if only DeclRefExpr occurs inside of a loop.
[clang-tidy] Do not move parameter if only DeclRefExpr occurs inside of a loop
Dec 15 2016, 6:58 PM
flx closed D27187: [clang-tidy] Do not move parameter if only DeclRefExpr occurs inside of a loop by committing rL289912: [clang-tidy] Do not move parameter if only DeclRefExpr occurs inside of a loop.
Dec 15 2016, 6:58 PM · Restricted Project
flx updated the diff for D27187: [clang-tidy] Do not move parameter if only DeclRefExpr occurs inside of a loop.
Dec 15 2016, 5:12 PM · Restricted Project

Dec 2 2016

flx committed rL288502: [clang-tidy] Do not trigger unnecessary-value-param check on methods marked as….
[clang-tidy] Do not trigger unnecessary-value-param check on methods marked as…
Dec 2 2016, 6:54 AM
flx closed D27248: [clang-tidy] Do not trigger unnecessary-value-param check on methods marked as final by committing rL288502: [clang-tidy] Do not trigger unnecessary-value-param check on methods marked as….
Dec 2 2016, 6:54 AM · Restricted Project
flx added inline comments to D27248: [clang-tidy] Do not trigger unnecessary-value-param check on methods marked as final.
Dec 2 2016, 6:42 AM · Restricted Project

Dec 1 2016

flx added a comment to D27187: [clang-tidy] Do not move parameter if only DeclRefExpr occurs inside of a loop.

Do you have any more comments, Alex?

Dec 1 2016, 7:51 PM · Restricted Project

Nov 30 2016

flx added inline comments to D27248: [clang-tidy] Do not trigger unnecessary-value-param check on methods marked as final.
Nov 30 2016, 6:44 AM · Restricted Project
flx updated the diff for D27248: [clang-tidy] Do not trigger unnecessary-value-param check on methods marked as final.
Nov 30 2016, 6:44 AM · Restricted Project

Nov 29 2016

flx retitled D27248: [clang-tidy] Do not trigger unnecessary-value-param check on methods marked as final from to [clang-tidy] Do not trigger unnecessary-value-param check on methods marked as final.
Nov 29 2016, 8:34 PM · Restricted Project
flx added inline comments to D27187: [clang-tidy] Do not move parameter if only DeclRefExpr occurs inside of a loop.
Nov 29 2016, 7:46 AM · Restricted Project
flx added inline comments to D27187: [clang-tidy] Do not move parameter if only DeclRefExpr occurs inside of a loop.
Nov 29 2016, 5:51 AM · Restricted Project
flx updated the diff for D27187: [clang-tidy] Do not move parameter if only DeclRefExpr occurs inside of a loop.
Nov 29 2016, 5:48 AM · Restricted Project

Nov 28 2016

flx retitled D27187: [clang-tidy] Do not move parameter if only DeclRefExpr occurs inside of a loop from to [clang-tidy] Do not move parameter if only DeclRefExpr occurs inside of a loop.
Nov 28 2016, 6:45 PM · Restricted Project

Nov 11 2016

flx added a comment to D26453: [clang-tidy] Remove duplicated check from move-constructor-init.

Add ValuesOnly option to modernize-pass-by-value.

Nov 11 2016, 9:14 AM

Nov 9 2016

flx committed rL286424: [clang-tidy] Do not issue fix for functions that are referenced outside of….
[clang-tidy] Do not issue fix for functions that are referenced outside of…
Nov 9 2016, 5:38 PM
flx closed D26203: [ClangTidy - performance-unnecessary-value-param]: Do not issue fix for functions that are referenced outside of callExpr by committing rL286424: [clang-tidy] Do not issue fix for functions that are referenced outside of….
Nov 9 2016, 5:38 PM
flx added a comment to D26453: [clang-tidy] Remove duplicated check from move-constructor-init.

Is the modernize-pass-by-value check configurable in a way to only trigger when copied constructor arguments are not moved?

Nov 9 2016, 8:42 AM
flx added a comment to D26203: [ClangTidy - performance-unnecessary-value-param]: Do not issue fix for functions that are referenced outside of callExpr.

Thanks for the review!

Nov 9 2016, 6:42 AM
flx updated the diff for D26203: [ClangTidy - performance-unnecessary-value-param]: Do not issue fix for functions that are referenced outside of callExpr.
Nov 9 2016, 6:42 AM

Nov 7 2016

flx committed rL286155: [clang-tidy] Move incomplete type test into separate test file.
[clang-tidy] Move incomplete type test into separate test file
Nov 7 2016, 1:55 PM
flx closed D26369: [ClangTidy] Move incomplete type test into separate test file by committing rL286155: [clang-tidy] Move incomplete type test into separate test file.
Nov 7 2016, 1:55 PM
flx added inline comments to D26369: [ClangTidy] Move incomplete type test into separate test file.
Nov 7 2016, 1:52 PM
flx added inline comments to D26369: [ClangTidy] Move incomplete type test into separate test file.
Nov 7 2016, 1:47 PM
flx updated the diff for D26369: [ClangTidy] Move incomplete type test into separate test file.
Nov 7 2016, 1:46 PM
flx added a reviewer for D26203: [ClangTidy - performance-unnecessary-value-param]: Do not issue fix for functions that are referenced outside of callExpr: aaron.ballman.
Nov 7 2016, 1:42 PM
flx added a comment to D26195: Ignore incomplete types when determining whether they are expensive to copy.
Nov 7 2016, 1:20 PM
flx retitled D26369: [ClangTidy] Move incomplete type test into separate test file from to [ClangTidy] Move incomplete type test into separate test file.
Nov 7 2016, 1:19 PM

Nov 4 2016

flx committed rL286010: [ClangTidy - performance-unnecessary-value-param] Only add "const" when current….
[ClangTidy - performance-unnecessary-value-param] Only add "const" when current…
Nov 4 2016, 2:01 PM
flx closed D26207: [ClangTidy - performance-unnecessary-value-param] Only add "const" when current parameter is not already const qualified by committing rL286010: [ClangTidy - performance-unnecessary-value-param] Only add "const" when current….
Nov 4 2016, 2:01 PM
flx committed rL286008: [clang-tidy] Ignore incomplete types when determining whether they are….
[clang-tidy] Ignore incomplete types when determining whether they are…
Nov 4 2016, 1:39 PM
flx closed D26195: Ignore incomplete types when determining whether they are expensive to copy by committing rL286008: [clang-tidy] Ignore incomplete types when determining whether they are….
Nov 4 2016, 1:38 PM
flx updated the diff for D26195: Ignore incomplete types when determining whether they are expensive to copy.
Nov 4 2016, 1:23 PM
flx added a comment to D26195: Ignore incomplete types when determining whether they are expensive to copy.
In D26195#585198, @flx wrote:
In D26195#584958, @flx wrote:
In D26195#584724, @flx wrote:

Please add a test case with an incomplete type that would exercise this code path, otherwise, LGTM.

Hi Aaron,

do you have any advise on how to add an incomplete type? When debugging this I had a compilation unit that failed to compile causing it, but I'm not sure this is a good way to add a test case.

A type like class C; is an incomplete type, as is void, so perhaps you can find a check that would let such a construct call through to isExpensiveToCopy().

Great, this works and I was able to see the check produce a false positive without the proposed change here, but the test code introduces a compile error now due to the incomplete type used in the function definition. Is there a way to suppress that?

Unlikely -- fixing the compile error likely makes the type not expensive to copy by using a pointer (or reference). This may be tricky to test because the times when you would call isExpensiveToCopy() is with types that are going to be logically required to be complete. I am not certain the compile error is actually a problem though -- I would imagine your existing false-positives (that you mentioned in the patch summary) are cases where there is a compile error *and* a clang-tidy diagnostic, so the test may simply be "check that there's only a compile error and no clang-tidy diagnostic where there used to be a false-positive one."

That's exactly the case, my question here is how can I make the test succeed in the face of a compile error, i.e. by expecting the error as well?

Doesn't // CHECK-MESSAGES: :[[@LINE-1]]:3: error: blah blah blah work?

Nov 4 2016, 12:12 PM
flx added a reviewer for D26195: Ignore incomplete types when determining whether they are expensive to copy: aaron.ballman.
Nov 4 2016, 12:11 PM
flx updated the diff for D26195: Ignore incomplete types when determining whether they are expensive to copy.
Nov 4 2016, 12:10 PM
flx added a comment to D26207: [ClangTidy - performance-unnecessary-value-param] Only add "const" when current parameter is not already const qualified.

Aaron, do you have any other comments or does the patch look good to you?

Nov 4 2016, 11:07 AM

Nov 3 2016

flx added inline comments to D26207: [ClangTidy - performance-unnecessary-value-param] Only add "const" when current parameter is not already const qualified.
Nov 3 2016, 12:11 PM
flx updated the diff for D26207: [ClangTidy - performance-unnecessary-value-param] Only add "const" when current parameter is not already const qualified.
Nov 3 2016, 12:11 PM

Nov 2 2016

flx added inline comments to D26207: [ClangTidy - performance-unnecessary-value-param] Only add "const" when current parameter is not already const qualified.
Nov 2 2016, 2:59 PM