REPL should report singleton type

[som-snytt]

Compiler version

3.3.1-RC1-bin-SNAPSHOT-git-0df5ae2

Minimized code

Welcome to Scala 3.3.1-RC1-bin-SNAPSHOT-git-0df5ae2 (19, Java OpenJDK 64-Bit Server VM).
Type in expressions for evaluation. Or try :help.

scala> import collection.mutable.ArrayBuffer

scala> val b = new ArrayBuffer[String]
val b: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer()

scala> b.addOne("hi")
val res0: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(hi)

Expectation

Welcome to Scala 2.13.10 (OpenJDK 64-Bit Server VM, Java 19).
Type in expressions for evaluation. Or try :help.

scala> import collection.mutable.ArrayBuffer
import collection.mutable.ArrayBuffer

scala> val b = new ArrayBuffer[String]
val b: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer()

def addOne(elem: String): b.type

scala> b.addOne("hi")
val res0: b.type = ArrayBuffer(hi)

[The additional output is from tab-complete help.]

Scala 3 res0 should also be b.type. Noticed while reviewing a Scala 2 bug about inferring singleton from overrides.

[som-snytt]

Probably a good candidate for Summer of Sprees.

[SethTisue]

is this REPL-specific?

[som-snytt]

Added area:51 label.

[Sporarum]

I believe this not to really be a bug, here is why:

An expression in the repl is equivalent to
val resN = <expr>
The compiler thus infers a type for the right hand side, and the displays the result

For example:

// Setup:
scala> val b = true
val b: Boolean = true

scala> def test: b.type = b
def test: b.type

// Experiment:
scala> test
val res3: Boolean = true

scala> val myVal = test
val myVal: Boolean = true // inferred type is Boolean, and not b.type

(Comments added for legibility)

The reason behind the discrepancy is that the inference between Scala 2 and Scala 3 has changed.
As inference is free to be changed at any time (as long as it is sound), this is not a problem in the grand scheme of things

Now, the question is:
Should there be a more precise inference mechanism used in the repl ?

I think it would be nice, but that seems way bigger than bug fixing

There have been multiple proposals of more precise or exact inference schemes, for example some of @mbovel 's work, or a recent sip

If one of these is added to the language, I think you have demonstrated that the repl is a place where it would be very valuable

[som-snytt]

The val presentation is not fundamental, and the REPL is free to wrap the expression arbitrarily.

So while I agree that these are choices, really I just want the REPL to be as useful as possible.

The "result" type that it reports ought to reflect the result type of the method I called. Maybe that should be (42: Int) style as seen in error messages.

Moreover, these types can be unusual or confusing for users, so the precision is warranted.

This issue is about what is displayed, not about special inference for REPL.

It looks like :type reports an inferred type, if that's the information I need.

This is also the periodic reminder that REPL does not emit pasteable code in general.

[Sporarum]

I totally agree with you, we should show the user the most precise type

The question is how, and I believe it to be a complicated problem to solve, but I might be wrong

My proposal was to use someone else's exact inference, but there might be a simpler way

In particular, what should be the type written in the repl of:

scala> if true then
  4
else
  "Hello"

Any, Matchable, Int, or 4 ?

[Sporarum]

I don't think this issue should be closed, on the contrary

On the other hand, I think the Spree label should be removed, as this is a very complicated issue to tackle