Prohibit the creation of extension methods with the same signatures from the underlying type

[danicheg]

Compiler version

3.1.1-RC1 and earlier

Proposal

As far as I can see, if we create an extension method with the same signature, that already exists on the underlying type, then:

1. it's never will be used;
2. will be no compilation errors (or warnings);
3. if we try to override it then we get a bit odd compilation error: "method XXX has a different signature than the overridden declaration".

It'd be more clear if the creation of that methods will be prohibited (or at least warnings would be supplied).

Example 1

opaque type CIString = String

object CIString:
  def apply(s: String): CIString = s.asInstanceOf[CIString]

extension (x: CIString)
  def equals(that: Any): Boolean = false // compiles well, no warnings/errors

println(CIString("Foo").equals(CIString("Foo"))) // true

Example 2

opaque type CIString = String

object CIString:
  def apply(s: String): CIString = s.asInstanceOf[CIString]

extension (x: CIString)
  override def equals(that: Any): Boolean = false // compilation error "method equals has a different signature than the overridden declaration"

[smarter]

that already exists on the underlying type

the problem is not that it exists on the underlying type, it's that it exists on the upper-bound of the opaque type, which when left unspecified is Any which does define equals.

[smarter]

Oh, I thought you meant "underlying type of the opaque type", but if you meant "type on which the extension is defined" then nevermind my comment.

[som-snytt]

The feature ticket was #16743

I don't remember this exclusion mentioned on the PR:

Excludes opaque types (for defining forwarders to a public API) and other alias types (where the type member may override an abstract type member).

I think the equals example should warn. Also extension on Scala String alias should warn.

Here is the example using a MyString which has a === member but we want an extension for clients outside this scope.

extension (s: java.lang.String) def length = 42
//extension (s: String) def length = 42 // should warn but does not

trait T:
  def t = 42

extension (_t: T) def t = 27

object CIS:
  case class MyString(s: String) {
    def ===(that: Any): Boolean = that match
      case MyString(`s`) => true
      case _ => false
  }

  opaque type CIString = MyString

  object CIString:
    def apply(s: String): CIString = MyString(s)
    //def apply(s: String): CIString = s
    // compiles well, no warnings/errors
    extension (x: CIString)
      def ===(that: Any): Boolean = x == that && x.s.length > 5
      //def equals(that: Any): Boolean = x == that && x.length > 5 // should warn but does not

@main def test() = println:
  import CIS.*
  (
  MyString("Foo").===(MyString("Foo")),
  CIString("Foo").===(CIString("Foo")),
  CIString("FooBar").===(CIString("FooBar")),
  )

The original use case (FWIW) was that you write an extension for a 3rd party type but the 3rd party updates with the member. That was detected with JDK API and Dotty code.

What's really wanted is a more expensive use site check: if my x.f doesn't use an available extension, tell me so. (Maybe that only sounds expensive.)