Type checking error when mixing inline defs, match types, and applied type constructors

[mpilquist]

minimized code

scala> inline def concat[A <: Tuple, B <: Tuple](a: Option[A], b: Option[B]): Option[Tuple.Concat[A, B]] =
     |   a.zip(b).map(_ ++ _)
def concat
  [A <: Tuple, B <: Tuple]
    (a: Option[A], b: Option[B]): Option[Tuple.Concat[A, B]]

scala> concat(Some(1, 2), Some(3, 4)) // This should work
1 |concat(Some(1, 2), Some(3, 4))
  |^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |Found:    Int *: Int *: scala.Tuple.Concat[Unit, (Int, Int)]
  |Required: Int *: scala.Tuple.Concat[Int *: Unit, Singleton & (Int, Int)]
  | This location contains code that was inlined from rs$line$12:2

scala> inline def concat2[A <: Tuple, B <: Tuple](a: Option[A], b: Option[B]): Option[Tuple.Concat[A, B]] =
     |   a.zip(b).map((a, b) => (a ++ b).asInstanceOf[Tuple.Concat[A, B]])
def concat2
  [A <: Tuple, B <: Tuple]
    (a: Option[A], b: Option[B]): Option[Tuple.Concat[A, B]]

scala> concat2(Some(1, 2), Some(3, 4))
val res5: Option[(Int, Int, Int, Int)] = Some((1,2,3,4))

scala> inline def concat3[A <: Tuple, B <: Tuple](a: A, b: B): Tuple.Concat[A, B] =
     |   a ++ b
def concat3[A <: Tuple, B <: Tuple](a: A, b: B): Tuple.Concat[A, B]

scala> concat3((1, 2), (3, 4))
val res7: (Int, Int, Int, Int) = (1,2,3,4)

Both concat2 and concat3 work. Removing inline from concat also works.

[smarter]

  |Found:    Int *: Int *: scala.Tuple.Concat[Unit, (Int, Int)]
  |Required: Int *: scala.Tuple.Concat[Int *: Unit, Singleton & (Int, Int)]

When _ ++ _ gets inlined, its result is typed as Tuple.Concat[(Int, Int), that.type], which is a subtype of the expected type here, but TypeAssigner then widens that type (because that is a local binding of the inlined tree) to Tuple.Concat[(Int, Int), (Int, Int)] which no longer conforms to the expected type.

To fix that we need to:

• Propagate the expected type into the inline call. This used to be done before bf28a48 got rid of it to avoid having to deal with a special case related to extension methods, this needs to be reverted and handled in some other way.
• Take into account the expected type when doing type avoidance. We already do this for blocks when typing, so it's a matter of reusing that code: https://github.com/lampepfl/dotty/blob/63343d281e44d29e9db6a895d9ccf3c0daaa9cce/compiler/src/dotty/tools/dotc/typer/Typer.scala#L836-L839

[OlivierBlanvillain]

I could reproduce the bug without match types by changing the return type of ++ to a covariant trait:

trait Concat1[X <: Tuple, +Y <: Tuple]