False positive compile `type mismatch` error for 2.13.x and 2.12.x

[geny200]

Reproduction steps

Scala version: 2.13.x and 2.12.x (for scala 3 - it's OK)

Scastie snippet - https://scastie.scala-lang.org/LMQAZoz8SWqdVxy9DTrP3w

//> using scala 2.13.18

object Main {
  trait Capability

  object Capability {
    object Cap1 extends Capability
    object Cap2 extends Capability
  }

  type Cap1 = Capability.Cap1.type
  type Cap2 = Capability.Cap2.type

  trait Bar[BarCap <: Capability]

  trait Foo[FooCap] {
    def add[Cap <: Capability](bar: Bar[Cap]): Foo[Cap with FooCap] = ???
  }

  def t1: Bar[Cap1] = ???
  def t2: Bar[Cap2] = ???

  def base: Foo[Any] = ???

  // Compiles - OK
  val result1: Foo[Cap2 with Cap1 with Any] = {
    val inner = base
      .add(t1)
      .add(t2)
    inner
  }

  //Compile error: type mismatch;
  //found   : Bar[Cap2]
  //    (which expands to)  Bar[Capability.Cap2.type]
  // required: Bar[Capability.Cap1.type with Capability.Cap2.type]
  //Note: Cap2 >: Capability.Cap1.type with Capability.Cap2.type, but trait Bar is invariant in type BarCap.
  //You may wish to define BarCap as -BarCap instead. (SLS 4.5)
  val result2: Foo[Cap2 with Cap1 with Any] = {
    base
      .add(t1)
      .add(t2)
  }
}

Problem

I believe that result2 should compile too. In short, we get the case - this compiles:

val foo: SomeType = {
  val bar = expr
  bar
}

But that not

val foo: SomeType =
  expr

[lrytz]

This might be a limitation due to the way inference works in Scala 2 vs Scala 3. See #10838 for example for anyone interested. Or it might be a bug that can be fixed.

[geny200]

See #10838

I think this is a different problem, because types is exactly the same in both cases (result1, inner, result2: they all are Foo[Cap2 with Cap1 with Any]).