Type parameter inference is too eager to widen union types

[smarter]

From https://stackoverflow.com/questions/51575183/dotty-seq-mapping-to-union:

object UnionMapping {
  private def parse(string: String): Int | Double = {
    if(string.contains("."))
      string.toDouble
    else
      string.toInt
  }

  def test_number = {
    val strings: Seq[String] = Seq("123", "2.0", "42")
    // Works
    val asdf: Seq[AnyVal] = strings.map(parse(_))
    // Fails to compile
    val union: Seq[Int | Double] = strings.map(parse(_))
  }
}

There's enough hints here that type inference should be able to do the right thing and not widen Int | Double to AnyVal.

[abeln]

@smarter I'd be interested in learning a bit about the type parameter inference. If this bug seems somewhat accessible, can you point me to where in the code I should be looking at for this change? Thanks!

[smarter]

The current logic is here: https://github.com/lampepfl/dotty/blob/34baac4b69ef9bc764c8a6d0d4c8cd458759a5e4/compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala#L297-L301

To give some context: we avoid inferring union types for the same reason we avoid inferring singleton types, because sometimes they're "too precise". E.g.:

scala> List(1, "")
val res0: List[Any] = List(1, )

scala> List(if (true) 1 else "")
val res1: List[Any] = List(1)

The problem is that we do not distinguish between an inferred union type and a union type actually written down by the user:

scala> val x: Int | String = 1
val x: Int | String = 1

scala> List(x)                                                                                                                                                                                                                               
val res2: List[Any] = List(1)

This is tricky to fix since we'd need to have a way to distinguish | written down by the user from | made up by the compiler (maybe using an annotation?).

(If you're looking for issues related to type inference, I've left a sketch of how to fix things in #4742, but it's not super easy either)

[abeln]

Thanks! I'll take a look at #4742

[nicolasstucki]

I fell into a similar case with quoted.Expr

class Expr[+T]
def foo(): Char | String = bar/*[Char | String]*/(impl())
def bar[T](expr: Expr[T]): T = ???
def impl(): Expr[Char | String] = ???

Which fails with

8 |  def foo(): Char | String = bar/*[Char | String]*/(impl())
  |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |                             Found:    Any
  |                             Required: Char | String

[Baccata]

I'm encountering this issue as well : https://scastie.scala-lang.org/GW8xTsFARp22lzpTI7nb5Q