unhelpful warning for unsupported Scala 2 existential types

[adampauls]

Compiler version

3.1.0

Minimized code

Not sure, but I have a Scala 3 sbt project that depends on a Scala 2.13 project.

Output

[error] An existential type that came from a Scala-2 classfile cannot be
[error] mapped accurately to to a Scala-3 equivalent.
[error] original type    : x forSome type x
[error] reduces to       : x
[error] type used instead: Any
[error] This choice can cause follow-on type errors or hide type errors.
[error] Proceed at own risk.
[error] one error found
[error] one error found

Expectation

The error message would ideally tell me which Scala-2 classfile the symbol came from, or which Scala-3 compilation unit the reference is happening in (or both). We use x forSome type x dozens of times in our Scala code so I can't narrow down where the error is coming from.

[bishabosha]

here is a reproducer:

compile with Scala 2 to out:

import language.existentials

abstract class Box[T]

object Box {
  def foo(b: Box[x forSome { type x }]) = ???
}

compile with Scala 3 with out on classpath:

@main def Test =
  Box.foo(???)

producing the uninformative error:

An existential type that came from a Scala-2 classfile cannot be
mapped accurately to to a Scala-3 equivalent.
original type    : x forSome x
reduces to       : x
type used instead: Any
This choice can cause follow-on type errors or hide type errors.
Proceed at own risk.

longer explanation available when compiling with `-explain`
1 warning found

[bishabosha]

if you are migrating perhaps it will work to replace all x forSome { type x } with _

[bishabosha]

Also I would assume that we should be able to treat x forSome { type x } as a wildcard?

[odersky]

x forSome { type x } looks strange. It would be a type that is equivalent to

• Any if used in covariant position,
• Nothing if used in contravariant position,
• and would generate an inaccessible field when used in invariant position.

What's the use case for this, I wonder?

[odersky]

Note it's not equivalent to a wildcard.

Array[?] corresponds to Array[x] forSome { type x}, not Array[x forSome { type x }]

[adampauls]

We used this pattern a lot. It was the way we would get code like this to compile:

def compare(x: Comparable[_], y: Comparable[_]): Int = {
  type T = x forSome { type x }
  x.asInstanceOf[Comparable[T]].compareTo(y.asInstanceOf[Comparable[T]])
}

Without the casts, you get

found   : y.type (with underlying type Comparable[_])
[error]  required: _$4

I know you can also do

x.asInstanceOf[Comparable[Any]].compareTo(y.asInstanceOf[Comparable[Any]])

in this case, but I'm pretty sure that doesn't work if there are type bounds on the type parameter. Declaring an explicit type variable also just seems less like a hack. Is there a better way?