Inconsistency in self-based type classes

Scala Improvement Process
1

While I was experimenting with self-based type classes, I found an inconsistency. Givens cannot be written in “the shortest form”. The code will be more verbose

trait A[T]:
  extension(t: T) def foo: T

trait B:
  type Self
  extension(t: Self) def foo: Self

given A[Int] = x => x

given Int is B = x => x

The first given compiles as intended, but the second one returns

error overriding method foo in trait B of type (t: Self): Self;
  method foo of type (x: Int): Int is a normal method, cannot override an extension method

This error message doesn’t seem to be true, since the first one compile

2

For some reason

    @experimental("Added by -experimental") final lazy given val given_A_Int:
      A[Int] =
      {
        def $anonfun(x: Int): Int = x
        {
          final class $anon() extends Object(), A[Int] {
            extension (x: Int) final def foo: Int = $anonfun(x)
          }
          new Object with A[Int] {...}()
        }
      }
    @experimental("Added by -experimental") final lazy given val given_is_Int_B
      : Int is B =
      {
        def $anonfun(x: Int): Int = x
        {
          final class $anon() extends Object(), B {
            final def foo(x: Int): Int = $anonfun(x)
            type Self = Int
          }
          new Object with B {...}()
        }
      }