Autofix EM101, EM102, EM103 if possible

[dhruvmanila]

Summary

Generate an autofix for EM101, EM102, EM103 if possible. This will avoid the autofix if the msg variable is bound in the current scope or the parent scope. Otherwise, it'll produce 2 edits for the fix:

1. Insert the exception argument into a variable assignment before the raise statement. The variable name is msg.
2. Replace the exception argument with the variable name.

Indentation is taken care using the helper function ruff_python_ast::whitespace::indentation
Newline is taken from checker.stylist.line_ending

fixes: #4103

[charliermarsh]

Looks great, just one question below.

[dhruvmanila]

Ecosystem checks can be found here: https://github.com/charliermarsh/ruff/actions/runs/4820598417/attempts/1#summary-13071431799

They're just addition of the [*] prefix before the message.

[charliermarsh]

As a stretch, it would be nice to parenthesize expressions in cases like this (imagine the expression is actually multi-line):

+            msg = "Some very long message"
             raise Exception(
-                "Some very long "
-                "message"
+                msg
             )

[charliermarsh]

@dhruvmanila - I'm not convinced that the change I made here is clearer, but it does mean that we avoid the "invalid" state of fixable = false with indentation = "".

[dhruvmanila]

Ah, right. Yes, it would seem that the fixable property is dependent on whether the indentation is present or not. Maybe two variables might help but not the way I did it. 🤔

diff --git a/crates/ruff/src/rules/flake8_errmsg/rules.rs b/crates/ruff/src/rules/flake8_errmsg/rules.rs
index ac30f0d7..e828e416 100644
--- a/crates/ruff/src/rules/flake8_errmsg/rules.rs
+++ b/crates/ruff/src/rules/flake8_errmsg/rules.rs
@@ -229,20 +229,11 @@ pub fn string_in_exception(checker: &mut Checker, stmt: &Stmt, exc: &Expr) {
                 } => {
                     if checker.settings.rules.enabled(Rule::RawStringInException) {
                         if string.len() > checker.settings.flake8_errmsg.max_string_length {
-                            let indentation = whitespace::indentation(checker.locator, stmt)
-                                .and_then(|indentation| {
-                                    if checker.ctx.find_binding("msg").is_none() {
-                                        Some(indentation)
-                                    } else {
-                                        None
-                                    }
-                                });
-                            let mut diagnostic = Diagnostic::new(
-                                RawStringInException {
-                                    fixable: indentation.is_some(),
-                                },
-                                first.range(),
-                            );
+                            let indentation = whitespace::indentation(checker.locator, stmt);
+                            let fixable = indentation
+                                .map_or(false, |_| checker.ctx.find_binding("msg").is_none());
+                            let mut diagnostic =
+                                Diagnostic::new(RawStringInException { fixable }, first.range());
                             if let Some(indentation) = indentation {
                                 if checker.patch(diagnostic.kind.rule()) {
                                     diagnostic.set_fix(generate_fix(

[dhruvmanila]

As a stretch, it would be nice to parenthesize expressions in cases like this (imagine the expression is actually multi-line):

Do you mean to autofix it like so?

+msg = (
+    "This is an example exception. "
+    "This message is very long "
+    "and spans multiple lines."
+)
 raise Exception(
-    "This is an example exception. "
-    "This message is very long "
-    "and spans multiple lines."
+    msg
 )

It could be but not with the help of AST. I think slicing the source code would work with msg = {content} as the replacement string.