Possible RC2 regression - compilation error: method parameter types must match exactly

Compiler version

I am using 3.0.0-RC2. Code compiled in RC1 but not in RC2. Maybe a bug in RC1? (see i10666.scala and i10666.check)

Minimized code

Compiled in RC1:

  class BaseToCompare
  class IsA extends BaseToCompare

  trait UseBase:
    type TT <: BaseToCompare

    def do1[T <: BaseToCompare](t:T): Unit 
    def do2(t:TT): Unit 
  
  object UseBaseA extends UseBase :
    type TT = IsA

    def do1[T <: IsA](t:T): Unit = ()
    def do2(t:TT): Unit = ()

  UseBaseA.do1(IsA())

Output

But now generates the error with RC2:

[error] 633 |  object UseBaseA extends UseBase :
[error]     |         ^
[error]     |object creation impossible, since def do1: [T <: examples.djl.autoencoder.experiments.BaseToCompare](t: T): Unit in trait UseBase in object experiments is not defined 
[error]     |(Note that
[error]     | parameter T in def do1: [T <: examples.djl.autoencoder.experiments.BaseToCompare](t: T): Unit in trait UseBase in object experiments does not match
[error]     | parameter T in def do1: [T <: examples.djl.autoencoder.experiments.IsA](t: T): Unit in object UseBaseA in object experiments
[error]     | class IsA in object experiments is a subclass of class BaseToCompare in object experiments, but method parameter types must match exactly.)

Expectation

I am assuming that since:

    summon[ IsA <:< BaseToCompare]

it should compile. Maybe an issue with variance I don’t understand? I was thinking it is equivalent to:

  trait UseBase:
    type TT <: BaseToCompare

    def do1[T <: TT](t:T): Unit 
    def do2(t:TT): Unit 
  
  object UseBaseA extends UseBase :
    type TT = IsA

    def do1[T <: TT](t:T): Unit = ()
    def do2(t:TT): Unit = ()

which does compile in RC2.

TIA

[smarter]

This is intentional, overrides allow result types to vary covariantly but not parameter types to vary contravariantly, it happened to work in some situations before but that wasn’t intentional, your initial example also fails in Scala 2.13.

Your second example fails because you wrote type TT <: IsA, so IsA can’t be passed where TT is expected, the following works:

class BaseToCompare
class IsA extends BaseToCompare

trait UseBase {
  type TT <: BaseToCompare

  def do1[T <: TT](t:T): Unit 
  def do2(t:TT): Unit
}

object UseBaseA extends UseBase {
  type TT = IsA 

  def do1[T <: TT](t:T): Unit = ()
  def do2(t:TT): Unit = ()
}

UseBaseA.do1(IsA())

[smarter]

No, type TT <: IsA does not mean that you can use any type which is a subtype of IsA where TT is expected, it means that TT is some abstract type which is known to be a subtype of IsA.