Type infers widens union of applied abstract covariant types F[A] | F[B] into Any instead of F[A | B]

[japgolly]

Compiler version

3.0.0-RC3

Minimized code

object Html {
  final opaque type Tag[+N] = String
  def apply[N](name: String): Tag[N] = name
}

object HtmlTags {
  final def br: Html.Tag[Int] = Html("br")
  final def p = Html[Long]("p")
}

object Test {
  type Expect = Html.Tag[Any]

  val x = List[Expect](HtmlTags.br, HtmlTags.p) // ok

  val y = List(HtmlTags.br, HtmlTags.p)
  y: List[Expect] // error
}

Output

[error] 17 |  y: List[Expect] // error
[error]    |  ^
[error]    |  Found:    (Test.y : List[Any])
[error]    |  Required: List[Test.Expect]

Expectation

Success.

Without opaque types

If we replace the opaque type with a case class and type alias, everything compiles successfully.

case class Html[+N](name: String)
object Html {
  type Tag[+N] = Html[N]
}

// object Html {
//   final opaque type Tag[+N] = String
//   def apply[N](name: String): Tag[N] = name
// }

// Code below is unchanged

object HtmlTags {
  final def br: Html.Tag[Int] = Html("br")
  final def p = Html[Long]("p")
}

object Test {
  type Expect = Html.Tag[Any]

  val x = List[Expect](HtmlTags.br, HtmlTags.p) // ok

  val y = List(HtmlTags.br, HtmlTags.p)
  y: List[Expect] // ok now
}

[b-studios]

For completeness: type inference also works, if we replace the opaque type with a sealed trait:

object Html {
  sealed trait Tag[+N] // <<<<<
  def apply[N](name: String): Tag[N] = ???
}

[smarter]

This isn't specific to opaque types, it also happens with regular abstract types:

object Test {
  type Tag[+N]
  def br: Tag[Int] = ???
  def p: Tag[Long] = ???
  val y = List(br, p) // infers List[Any] instead of List[Tag[AnyVal]]
}

[smarter]

The current logic for widening union is based around finding base classes, which means abstract types don't get preserved: https://github.com/lampepfl/dotty/blob/4e8ca785d5e92a0ff2fafb19deb4e6b75b74d8fc/compiler/src/dotty/tools/dotc/core/TypeOps.scala#L183-L199

@odersky do you think this logic could be adapted to allow Tag[Int] | Tag[Long] to be widened to Tag[Int | Long] where Tag is a covariant abstract type?

[odersky]

Yes, I think that can work.