Page MenuHomePhabricator

flx (Felix Berger)
User

Projects

User does not belong to any projects.

User Details

User Since
Sep 14 2015, 7:53 AM (300 w, 6 d)

Recent Activity

Fri, Jun 18

flx committed rGbdd5da9dec61: [clang-tidy] performance-unnecessary-copy-initialization: Directly examine the… (authored by flx).
[clang-tidy] performance-unnecessary-copy-initialization: Directly examine the…
Fri, Jun 18, 12:27 PM
flx closed D103021: [clang-tidy] performance-unnecessary-copy-initialization: Search whole function body for variable initializations..
Fri, Jun 18, 12:27 PM · Restricted Project
flx updated the diff for D103021: [clang-tidy] performance-unnecessary-copy-initialization: Search whole function body for variable initializations..

Renamed initializer matcher.

Fri, Jun 18, 11:26 AM · Restricted Project

Tue, Jun 15

flx added inline comments to D103021: [clang-tidy] performance-unnecessary-copy-initialization: Search whole function body for variable initializations..
Tue, Jun 15, 1:40 PM · Restricted Project
flx updated the diff for D103021: [clang-tidy] performance-unnecessary-copy-initialization: Search whole function body for variable initializations..

Remove now unnecessary FunctionDecl.

Tue, Jun 15, 1:37 PM · Restricted Project
flx updated the diff for D103021: [clang-tidy] performance-unnecessary-copy-initialization: Search whole function body for variable initializations..

Directly examine initializer.

Tue, Jun 15, 1:34 PM · Restricted Project

Fri, Jun 11

flx added a comment to D103087: [clang-tidy] performances-unnecessary-* checks: Extend isOnlyUsedAsConst to expressions and catch const methods returning non-const references/pointers..

I have some concerns about the cost of this checks as it used matching over entire contexts quite extensively. At this point, the facilities involved seem quite close to doing dataflow analysis and I wonder if you might be better off with a very different implementation. Regardless, have you done any perfomance testing to see the impact on real code?

Fri, Jun 11, 11:21 AM · Restricted Project
flx added inline comments to D103021: [clang-tidy] performance-unnecessary-copy-initialization: Search whole function body for variable initializations..
Fri, Jun 11, 6:00 AM · Restricted Project
flx updated the diff for D103021: [clang-tidy] performance-unnecessary-copy-initialization: Search whole function body for variable initializations..

Use more efficient method to check for local variable declaration.

Fri, Jun 11, 5:55 AM · Restricted Project

Wed, Jun 9

flx added inline comments to D103021: [clang-tidy] performance-unnecessary-copy-initialization: Search whole function body for variable initializations..
Wed, Jun 9, 2:13 PM · Restricted Project
flx updated the diff for D103021: [clang-tidy] performance-unnecessary-copy-initialization: Search whole function body for variable initializations..

Addressed first round of comments.

Wed, Jun 9, 2:13 PM · Restricted Project
flx committed rGefa4dbc32ca9: [clang-tidy] performance-unnecessary-copy-initialization: Look at the canonical… (authored by flx).
[clang-tidy] performance-unnecessary-copy-initialization: Look at the canonical…
Wed, Jun 9, 1:37 PM
flx closed D103018: [clang-tidy] performance-unnecessary-copy-initialization: Look at the canonical type when checking for aliases..
Wed, Jun 9, 1:37 PM · Restricted Project
flx committed rG5dbe3bf4b8db: [clang-tidy] performance-unnecessary-copy-initialization: Remove the complete… (authored by flx).
[clang-tidy] performance-unnecessary-copy-initialization: Remove the complete…
Wed, Jun 9, 12:54 PM
flx closed D102175: [clang-tidy] performance-unnecessary-copy-initialization: Remove the complete statement when the copied variable is unused..
Wed, Jun 9, 12:54 PM · Restricted Project
flx added a comment to D102175: [clang-tidy] performance-unnecessary-copy-initialization: Remove the complete statement when the copied variable is unused..

Thank you for the review, Yitzhak!

Wed, Jun 9, 12:51 PM · Restricted Project

Tue, May 25

flx requested review of D103087: [clang-tidy] performances-unnecessary-* checks: Extend isOnlyUsedAsConst to expressions and catch const methods returning non-const references/pointers..
Tue, May 25, 7:34 AM · Restricted Project

Mon, May 24

flx requested review of D103021: [clang-tidy] performance-unnecessary-copy-initialization: Search whole function body for variable initializations..
Mon, May 24, 6:50 AM · Restricted Project
flx requested review of D103018: [clang-tidy] performance-unnecessary-copy-initialization: Look at the canonical type when checking for aliases..
Mon, May 24, 6:27 AM · Restricted Project

May 14 2021

flx added a comment to D102175: [clang-tidy] performance-unnecessary-copy-initialization: Remove the complete statement when the copied variable is unused..

Hi Felix,
Can you clarify your concern over the warning? Is it the case that the warning is not present before the fix and is only triggered after the fix? I'm concerned that removing the call may have unintended side effects and I would think it might better to leave the check for usage separate. However, if the fix is causing the warning then I can understand better why you want to make this change. That said, have considered replacing the var binding with (void), rather than deleting the statement?

May 14 2021, 10:28 AM · Restricted Project

May 12 2021

flx added a comment to D97567: [clang-tidy] performance-* checks: Also allow allow member expressions to be used in a const manner..

Could someone take a look at this patch? Thank you!

May 12 2021, 7:00 AM · Restricted Project, Restricted Project

May 10 2021

flx updated the diff for D102175: [clang-tidy] performance-unnecessary-copy-initialization: Remove the complete statement when the copied variable is unused..

Fix test case.

May 10 2021, 12:31 PM · Restricted Project
flx requested review of D102175: [clang-tidy] performance-unnecessary-copy-initialization: Remove the complete statement when the copied variable is unused..
May 10 2021, 8:46 AM · Restricted Project

Apr 6 2021

flx committed rGddebed8e9742: [clang-tidy] performance-* checks: Match AllowedTypes against qualified type… (authored by flx).
[clang-tidy] performance-* checks: Match AllowedTypes against qualified type…
Apr 6 2021, 12:42 PM
flx closed D98738: [clang-tidy] performance-* checks: Match AllowedTypes against qualified type names when they contain "::"..
Apr 6 2021, 12:42 PM · Restricted Project

Apr 5 2021

flx added a comment to D97567: [clang-tidy] performance-* checks: Also allow allow member expressions to be used in a const manner..

Could someone take a look at this change?

Apr 5 2021, 10:56 AM · Restricted Project, Restricted Project
flx added a comment to D98738: [clang-tidy] performance-* checks: Match AllowedTypes against qualified type names when they contain "::"..

Thanks for the comments, PTAL!

Apr 5 2021, 8:54 AM · Restricted Project
flx updated the diff for D98738: [clang-tidy] performance-* checks: Match AllowedTypes against qualified type names when they contain "::"..

Create a NameMatcher class that handles matching against the best name variant
(unqualified, qualified, fully qualified) of the NamedDecl.

Apr 5 2021, 8:53 AM · Restricted Project

Mar 19 2021

flx added inline comments to D98738: [clang-tidy] performance-* checks: Match AllowedTypes against qualified type names when they contain "::"..
Mar 19 2021, 11:12 AM · Restricted Project
flx updated the diff for D98738: [clang-tidy] performance-* checks: Match AllowedTypes against qualified type names when they contain "::"..

Applied changes suggested by ymandel, thanks!

Mar 19 2021, 11:01 AM · Restricted Project

Mar 17 2021

flx added inline comments to D98738: [clang-tidy] performance-* checks: Match AllowedTypes against qualified type names when they contain "::"..
Mar 17 2021, 8:38 AM · Restricted Project
flx added inline comments to D98738: [clang-tidy] performance-* checks: Match AllowedTypes against qualified type names when they contain "::"..
Mar 17 2021, 7:05 AM · Restricted Project

Mar 16 2021

flx updated subscribers of D98738: [clang-tidy] performance-* checks: Match AllowedTypes against qualified type names when they contain "::"..
Mar 16 2021, 1:14 PM · Restricted Project
flx requested review of D98738: [clang-tidy] performance-* checks: Match AllowedTypes against qualified type names when they contain "::"..
Mar 16 2021, 1:13 PM · Restricted Project

Mar 15 2021

flx added a comment to D97567: [clang-tidy] performance-* checks: Also allow allow member expressions to be used in a const manner..

could someone please take a look at this? Thanks!

Mar 15 2021, 1:21 PM · Restricted Project, Restricted Project

Mar 2 2021

flx committed rGa189b3b9e8bb: [clang-tidy] performance-for-range-copy: Don't trigger on implicit type… (authored by flx).
[clang-tidy] performance-for-range-copy: Don't trigger on implicit type…
Mar 2 2021, 5:04 PM
flx closed D97577: [clang-tidy] performance-for-range-copy: Don't trigger on implicit type conversions..
Mar 2 2021, 5:04 PM · Restricted Project, Restricted Project
flx added a comment to D97577: [clang-tidy] performance-for-range-copy: Don't trigger on implicit type conversions..

Thank you for the review!

Mar 2 2021, 5:01 PM · Restricted Project, Restricted Project

Feb 28 2021

flx added a comment to D97577: [clang-tidy] performance-for-range-copy: Don't trigger on implicit type conversions..

It is best not to change existing tests, but add new ones.

Feb 28 2021, 8:10 AM · Restricted Project, Restricted Project

Feb 26 2021

flx updated the diff for D97567: [clang-tidy] performance-* checks: Also allow allow member expressions to be used in a const manner..

Add tests for PerformanceUnnecssaryCopyInitialization check which actually uses
decl_ref_expr::isOnlyUsedAsConst().

Feb 26 2021, 2:03 PM · Restricted Project, Restricted Project
flx updated the diff for D97577: [clang-tidy] performance-for-range-copy: Don't trigger on implicit type conversions..

Remove include.

Feb 26 2021, 1:38 PM · Restricted Project, Restricted Project
flx updated the diff for D97577: [clang-tidy] performance-for-range-copy: Don't trigger on implicit type conversions..

Remove include.

Feb 26 2021, 1:37 PM · Restricted Project, Restricted Project
flx requested review of D97577: [clang-tidy] performance-for-range-copy: Don't trigger on implicit type conversions..
Feb 26 2021, 1:36 PM · Restricted Project, Restricted Project
flx requested review of D97567: [clang-tidy] performance-* checks: Also allow allow member expressions to be used in a const manner..
Feb 26 2021, 11:13 AM · Restricted Project, Restricted Project

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