Test shows which error currently has a quick fix.

scala> '\060'
        ^
       error: octal escape literals are unsupported: use \u0030 instead

scala> def foo() { }
                 ^
       warning: procedure syntax is deprecated: instead, add `: Unit =` to explicitly declare `foo`'s return type

quick> def foo(): Unit = { } // procedure syntax (defn)
def foo(): Unit

Rust underlines the modification.

  |
2 |     let guess = "42".parse().expect("Not a number!");
  |         ^^^^^
  |
help: consider giving `guess` an explicit type
  |
2 |     let guess: _ = "42".parse().expect("Not a number!");
  |              +++

An alternative 5-character prompt:

help!> def foo(): Unit = { } // procedure syntax (defn)

It should obey -quickfix, which REPL should default to -quickfix:any.

I, too, thought of putting the edit in history; I'm glad you like my bad idea. That is easier than cut/paste.

I deferred handling multi-line, but the goal is probably to do something nicer.

I didn't test multi-warn, but the goal was one quick prompt with a long comment.

Thanks for trying it out. I'll make an effort to finish it up, given your feedback.

@som-snytt ready to return this? this is one I'm especially eager to see land

@SethTisue since you added the prio:hi label, can you take a look?

Oh wait, they removed prio: hi, the pressure is totally off.

After I get the previous effort to green check, I would prefer that the REPL emit the amended line just once, when all reporting is done. Adding the amended line to history would require all edits.

I recall from last summer that finish is not used since my version of reporting was scrapped. There must be an obvious mechanism for "emit your summary" since -Wconf filtering happens after the run. Maybe that's because you need msg A to hide msg B even if A is suppressed later?

Since I'm not very motivated, maybe the current solution suffices.

@SethTisue is going to take a look right after reviewing that other PR.

Marking RFR so I don't forget.

Code changes seem fine. I'm less sure about the UX.

Let's start by recalling the existing behavior (in 2.13.12), for comparison:

Here the new behavior with the same all-in-one-line example

and I think this what Som means by "I deferred handling multi-line, but the goal is probably to do something nicer" :

because the fix isn't on the first line, we don't get the fixed> thing showing us the fix.

The one-line example above seems pretty confusing to me. If a beginner saw this and didn't know anything about any of this, I think there's a good chance they'd be somewhat bewildered.

The multi-line screen shot is less featureful, but perhaps also less confusing. It fixed it for me without printing a bunch of potentially confusing extra stuff.

@som-snytt how attached are you to this fixed> thing in its current form? You have given this more thought than I have, but my first reaction is that it might actually be better to ship this without that stuff, so the UX is the same regardless of first-line vs multi-line.

The placement of [rewritten by -quickfix] seems confusing to me. It's telling me it rewrote something, but it hasn't even showed me the warning yet! If I could ask for one small change to this, it would be to put that later:

scala> def foo() { () }
                 ^
       warning: procedure syntax is deprecated: instead, ... [quickfixable]

applying quickfix. new code is:
def foo(): Unit = { () } // replace procedure syntax

def foo(): Unit

In the multiline case, it would be annoying to repeat an entire long piece of code just to show a one-line change. A slightly more ambitious change that would scale well to multiple lines and multiple quickfixes would be to use diff markers, like this:

scala> def foo()
     | {
     |   ()
     | }
       {
       ^
On line 2: warning: procedure syntax is deprecated: instead, ... [quickfixable]

applying quickfix:
- def foo()
+ def foo(): Unit =

def foo(): Unit

Wdyt?

Separate question: not sure it's desirable to always simply apply the fix. Have you considered a (y/n) type interaction, perhaps:

scala> def foo() { () }
                 ^
       warning: procedure syntax is deprecated: instead, ... [quickfixable]

- def foo()
+ def foo(): Unit =

Apply quickfix (y/n)? y

def foo(): Unit

For 2.13.13, I'm not sure whether to just say (as Adriaan used to) "let's book the progress". We don't know how much time we have (since we are waiting on 3.4.0), and also @som-snytt I don't know how much appetite you have for tinkering with this further, and or your opinions on my suggestions above. Thoughts?

I'll close this because I won't be researching the text presentation.

I'll look at whether the tweak to how edits are applied is worth using.

The goal was naive users get to see their mistakes auto-corrected in REPL.

A year later, it looks like a neat idea.