Compiler creates Infinite loop when define extension of opaque type which references to other opaque type

[kazzna]

Compiler version

3.6.2

If you're not sure what version you're using, run print scalaVersion from sbt
(if you're running scalac manually, use scalac -version instead).

Minimized code

A.scala

case class A[AA](a: AA) {
  def map[B](f: AA => B): A[B] = A(f(a))
}

B.scala

opaque type B[X] = A[X]

object B {
  def apply[X](x: X): B[X] = A(x)
  
  extension [X](b: B[X])
    def map[C](f: X => C): B[C] = b.map(f)
}

C.scala

opaque type C[A] = B[A]

object C {
  def apply[A](a: A): C[A] = B(a)
  
  extension [A](c: C[A])
    def map[B](f: A => B): C[B] = c.map(f)
}

Output

[warn] 7 |    def map[B](f: A => B): C[B] = c.map(f)
[warn]   |                                  ^^^^^^^^
[warn]   |                                  Infinite loop in function body
[warn]   |                                  C.map[A](c)[B](f)

Expectation

Wish to be compiled as type B.

[kazzna]

In my project, types are defined for almost all trivial things, such as LastName type for last name, etc.
Some types are referenced to a type in shared library, and recently shared library team decided to
change that type to opaque type for another type.
Then, this warn happens everywhere.

Is there any workarounds there?