Autofix applicability

[not-my-profile]

Like categorization (#1774) this is another very useful concept we can steal from Rust, see rustc_errors::Applicability.

Ideally users would be able to choose how much they want to risk when applying lints.

I think for rule applicability is even more relevant for Python than for Rust since pretty much all of the behavior of Python types can be overriden by implementing custom __dunder__ methods.

[sbrugman]

Referenced this in a couple of issues that could use this functionality

[charliermarsh]

Thank you!

[charliermarsh]

Would this primarily be for autofix risk, or also, flagging violations in the first place?

[not-my-profile]

What do you mean with "flagging violations in the first place"?

I think there are different factors we could possibly differentiate:

1. How accurate is the violation detection? e.g. can false positives / false negatives occur? how likely is that?
2. How safe is the suggested autofix? Can it be wrong? Can it break the program? Could it have side-effects?

[charliermarsh]

Right -- those are the two factors that I was trying to tease apart, though I think I was just tired and missed that the issue title is about autofixing, so any analogous concept for "How accurate is the violation detection?" would probably go by a different name.

[not-my-profile]

I think it makes sense to raise this question here. I think rules that will have many false positives should just be disabled by default and categorized (#1774) accordingly.

[zanieb]

I think this work is better captured by #4181 now, should we close this issue in favor of that one?

As an additional xref, here's the pull request that added applicability levels #4303

[charliermarsh]

Yeah, good call -- closing in favor of #4181.