Type parameter inference is too eager to widen union types

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.

[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 https://github.com/lampepfl/dotty/issues/4742, but it’s not super easy either)

[odersky]

This works by now.