Invalid union types

[pribor]

Compiler version

scala-3.3.0-RC6

Minimized code

// this fail
type ValueVector = Vector[String] | Vector[Double]
val v1: ValueVector = Vector("a", "b")
val v2: ValueVector = v1.tail 

// this works
type ValueVector = Vector[String] | Set[Double]
val v1: ValueVector = Vector("a", "b")
val v2: ValueVector = v1.tail

Output

Found:    Vector[String | Double]
Required: ValueVector
  val v2: ValueVector = v1.tail

Expectation

It shouldn't expect Vector[String | Double] at all.

[WojciechMazur]

It was never possible to do with any previous version of Scala 3

Vector is a covariant type, so narrowing Vector[String] | Vector[Double] to Vector[String | Double] should be sound.
A union type of 2 types can never expose methods of any of it's component types, so there simply does not exist method tail for type Vector[String] | Vector[Double], similarly like it would not be possible in the snippet below:

trait A: 
  def foo = 42

trait B:
  def foo = 42

val v: A | B = ???
val x = v.foo // error:  value foo is not a member of A | B

unless there exists a common intersection type between A and B:

trait O:
  def foo = 42
trait A extends O
trait B extends O

val v: A | B = ???
val x = v.foo // ok

I guess that compiler tries to narrow to type to the point where it could find a matching method. In case of Vector[+T] we should be able to convert Vector[String] | Vector[Double] to Vector[String | Double] which is still would be sound.

On the other hand, the if we try to combine Vector[Double] | Set[String] the common denominator would be Iterable[?] which can be confirmed by checking the AST after erasure: def v1(): scala.collection.immutable.Iterable = ???()

I'm not sure what should be the expected behaviour in that case

[smarter]

The reason why we get the more precise result type for tail with Vector[String] | Set[Double] is a bit subtle: the method tail we call in this case is:

trait IterableOps[+A, +CC[_], +C] {
  // ...
  def tail: C = ...
}

to compute the result type, the compiler needs to upcast Vector[String] | Set[Double] to IterableOps[...] which gives us IterableOps[String | Double, [X] =>> Vector[X] | Set[X], Vector[String] | Set[Double]], so C = Vector[String] | Set[Double].
On the other hand when the type we're calling tail on is Vector[String] | Vector[Double], the method tail we call is the override defined in Vector:

sealed abstract class Vector[+A] ... {
  // ...
  override def tail: Vector[A] = ...
}

In this case, we upcast Vector[String] | Vector[Double] to Vector[...] which gives us Vector[String | Double], hence the less precise result type!

You can actually force the selection of the tail from IterableOps with an intersection, so the result type will come from the intersection of the result types of Vector#tail and IterableOps#tail:

type ValueVector = (Vector[String] | Vector[Double]) & scala.collection.IterableOps[String | Double, Vector, Vector[String] | Vector[Double]]

Maybe we could tweak the logic for widening unions to make this work by default. The logic lives in https://github.com/lampepfl/dotty/blob/4ffe5af859aef155132cb1da5f8af47874db7c59/compiler/src/dotty/tools/dotc/core/TypeOps.scala#L211-L227
Right now it will widen Vector[Int] | Vector[String] to Vector[Int | String] because of the special case at https://github.com/lampepfl/dotty/blob/4ffe5af859aef155132cb1da5f8af47874db7c59/compiler/src/dotty/tools/dotc/core/TypeOps.scala#L391-L393 but even if we remove this special case, it still drops the intersection with IterableOps because Vector is a subclass of IterableOps and it doesn't take the more precise type parameters into consideration: https://github.com/lampepfl/dotty/blob/4ffe5af859aef155132cb1da5f8af47874db7c59/compiler/src/dotty/tools/dotc/core/TypeOps.scala#L382 (commonBaseClasses doesn't include type parameters)

/cc @sjrd since this is something the scala 3 spec should clarify either way.

[smarter]

Another way to phrase this is that as much as possible, we would like tp1 <:< tp2 to imply orDominator(tp1) <:< orDominator(tp2) to preserve the Liskov substitution principle. Currently this is violated if we take for example tp1 = Vector[Int] | Vector[String] and tp2 = Iterable[Int] | Iterable[String].