Extension methods with recursive implicit resolution do not work

[anatoliykmetyuk]

import Tuple.{ Head, Tail }

trait Idnt[T1 <: Tuple] {
  type Res <: Tuple
  extension (t1: T1) def idnt: Res
}

type Aux[T1 <: Tuple, Res0] = Idnt[T1] { type Res = Res0 }

given [T1 <: NonEmptyTuple, TZ <: Tuple](using Aux[Tail[T1], TZ]) : Aux[T1, Head[T1] *: TZ] = new Idnt[T1] {
  type Res = Head[T1] *: TZ
  extension (t1: T1) def idnt: Res = t1.head *: t1.tail.idnt
}

given Aux[Unit, Unit] = new Idnt[Unit] {
  type Res = Unit
  extension (t1: Unit) def idnt: Unit = ()
}

val x: (1, 2, 3) = (1, 2, 3)
val z: (1, 2, 3) = x.idnt

Says:

-- [E008] Member Not Found Error: ../pg/Main.scala:23:21 -----------------------
23 |val z: (1, 2, 3) = x.idnt
   |                   ^^^^^^
   |value idnt is not a member of (Int(1), Int(2), Int(3)) - did you mean x._1?.
   |An extension method was tried, but could not be fully constructed:
   |
   |    Main$package.Aux_T1_Head_given[(Int(1), Int(2), Int(3)), Tuple](
   |      Main$package.Aux_T1_Head_given[T1, TZ]
   |    ).idnt()
one error found

But:

import Tuple.{ Head, Tail }

trait Idnt[T1 <: Tuple] {
  type Res <: Tuple
  def (t1: T1) idnt: Res
}

type Aux[T1 <: Tuple, Res0] = Idnt[T1] { type Res = Res0 }

given [T1 <: NonEmptyTuple] as Aux[T1, Head[T1] *: Tail[T1]]
  = new Idnt[T1] {
  type Res = Head[T1] *: Tail[T1]
  def (t1: T1) idnt: Res = t1.head *: t1.tail
}

given as Aux[Unit, Unit] = new Idnt[Unit] {
  type Res = Unit
  def (t1: Unit) idnt: Unit = ()
}

val x: (1, 2, 3) = (1, 2, 3)
val z: (1, 2, 3) = x.idnt

Works. My gut feeling tells me it is related to #7049 and #7050.

[odersky]

We'd need a better minimization here. What extension method call should have been synthesized?

[anatoliykmetyuk]

@odersky I minimized this as follows:

type A
type B <: A

type PartialId[X] = X match {
  case B => X
}

trait T1[T] {
  extension (t1: T) def idnt1: Any
}

given [T <: A](using PartialId[T]): T1[T] = new T1[T] {
  extension (t1: T) def idnt1: Any = ???
}

given PartialId[B] = ???

val x: B = ???
val z = x.idnt1

Out:

-- [E008] Member Not Found Error: ../pg/i7056/Main.scala:19:10 -----------------
19 |val z = x.idnt1
   |        ^^^^^^^
   |      value idnt1 is not a member of B.
   |      An extension method was tried, but could not be fully constructed:
   |
   |          Main$package.T1_T_given[A](PartialId_B_given).idnt1()
one errors found

To make it work, define PartialId as follows:

type PartialId[X] = X match {
  case _ => X
}

Also, if you leave PartialId as it is and replace the last two lines as follows, it will compile:

// val x: B = ???
// val z = x.idnt1
val a = the[T1[B]]

Note what the error message says:

Main$package.T1_T_given[A]

The argument to T1_T_given is A (the specified upper bound for that argument) and not B (the actual argument).

My guess is that the match type that matches against a non-wildcard pattern messes up the precision of the type inference. And it does so only for the extension methods, as demonstrated by the the[T1[B]] example.

Related to #7078?

[anatoliykmetyuk]

Another way to make the example work is to define the second given as:

given as PartialId[A] = ???

Which supports the hypothesis that the inference happens for the upper bound and not for the actual type argument.

[bishabosha]

I believe this is a duplicate of #8311

[odersky]

Since #8311 is closed, we should do the same here.