[Experiment] Do not widen singletons in hard unions

[mbovel]

This PR disables widening of union types if they are "hard". A "hard" union type—a union type that is not soft—is a union explicitly written by the user, as opposed to being created by the compiler (for example as the result of condition or a match).

Before:

val x: 2 | 3 = 2
val y /*: Int */ = x

After:

val x: 2 | 3 = 2
val y /*: 2 | 3 */ = x

In both cases, soft unions are widened:

val c /*: Int */  = if b then 2 else 3

[mbovel]

So with my current changes, soft unions inside hard unions would be left untouched. Is that a problem?

If yes, I can probably do something more fine-grained by adding an isSoft parameter to widenSingletons indicating if the inner-most parent union is soft or not. If it is the case, then encountered singletons should be widened, otherwise they should not.

[dwijnand]

Might be worth flipping the order with your change:

if isSoft then
  if myUnionPeriod != ctx.period then
    ...
  myUnion
else this

[dwijnand]

So with my current changes, soft unions inside hard unions would be left untouched. Is that a problem?

Is that even possible? Do you have an example? How does the user get their hands on a type that is a soft union in such a way they can explicitly write a hard union with it?

[mbovel]

Is that even possible? Do you have an example? How does the user get their hands on a type that is a soft union in such a way they can explicitly write a hard union with it?

With my current changes:

def f(x: String): x.type | 3 = ???

val x /* : String */ = if b then "a" else "b"

val b: Boolean = ???
val y /* : "a" | "b" | 3 */ = f(if b then "a" else "b")
// Should it be : String | 3 ?

[dwijnand]

Interesting, thank you. I would have thought that, unless x were an inline perhaps, that it could never be as narrow as "a" | "b". I would have thought you at least would have needed a [S <: String](x: S) for that. But that's just going off of memory and intuition, so either that behaviour is wrong or TIL. 😄

[mbovel]

Yes we already have these precise types, but we rarely see them because they are often widened away. They are currently only preserved when the expected type is itself precise.

scala> def id(x: Any): x.type = x
def id(x: Any): x.type
                                                                                
scala> val b: Boolean = true
val b: Boolean = true
                                                                                
scala> val y: 2 | 3 = id(if b then 2 else 3)
val y: 2 | 3 = 2

scala> val z = id(if b then 2 else 3)
val z: Int = 2

scala> def id2[T](x: T): T = x
def id2[T](x: T): T
                                                                                
scala> val y2: 2 | 3 = id2(if b then 2 else 3)
val y2: 2 | 3 = 2

[dwijnand]

scala> val y: 2 | 3 = id(if b then 2 else 3)
val y: 2 | 3 = 2

scala> val z = id(if b then 2 else 3)
val z: Int = 2

Given this I'd say, yeah, we should change it. I'm thinking ideally to:

scala> val y = f(if b then "a" else "b")
val y: String | 3 = f(if b then "a" else "b")

scala> val y: "a" | "b" | 3 = f(if b then "a" else "b")
val y: "a" | "b" | 3 = f(if b then "a" else "b")

[odersky]

Yes, I think that's a net improvement for type inference!

[odersky]

Consider adding a test where the union is the result type of a def.

[mbovel]

Closing in favor of #14360.