top level extension method dealiases opaque type in result type

[artembakhanov]

Compiler version

3.3.0

Minimized code

opaque type PositiveNumber = Double

object PositiveNumber:
  extension (x: PositiveNumber)
    def mult1(other: PositiveNumber): PositiveNumber =
      x * other

extension (x: PositiveNumber)
  def mult2(other: PositiveNumber): PositiveNumber =
    x * other

object Test:
  def multMap1[A](x: Map[A, PositiveNumber], num: PositiveNumber): Map[A, PositiveNumber] = x.map((key, value) => key -> value.mult1(num)).toMap

  def multMap2[A](x: Map[A, PositiveNumber], num: PositiveNumber): Map[A, PositiveNumber] = x.map((key, value) => key -> value.mult2(num)).toMap
  def multMap2_2[A](x: Map[A, PositiveNumber], num: PositiveNumber): Map[A, PositiveNumber] = x.map((key, value) => key -> mult2(value)(num)).toMap

Output

[error] ./foo.scala:15:145
[error] Cannot prove that (A, Double) <:< (A, V2).
[error] 
[error] where:    V2 is a type variable with constraint <: PositiveNumber
[error]   def multMap2[A](x: Map[A, PositiveNumber], num: PositiveNumber): Map[A, PositiveNumber] = x.map((key, value) => key -> value.mult2(num)).toMap
[error]

Expectation

I would expect both functions be defined without type error. For some reason, when an opaque type is not a top-level definition, there is no type error when defining these functions.

[bishabosha]

so for some reason PositiveNumber is being de-aliased to Double when mult2 is used in another scope, and no problem for when mult2 is called directly and not as an extension method

def multMap2[A >: Nothing <: Any](x: Map[A, PositiveNumber],
  num: PositiveNumber): Map[A, PositiveNumber] =
  x.map[A, Double](
    {
      def $anonfun(x$1: (A, PositiveNumber)): (A, Double) =
        {
          val key: A = x$1._1
          val value: PositiveNumber = x$1._2
          ArrowAssoc[A](key).->[Double](mult2(value)(num))
        }
      closure($anonfun)
    }
  ).toMap[A, PositiveNumber](
    /* missing */summon[(A, Double) <:< (A, PositiveNumber)])
def multMap2_2[A >: Nothing <: Any](x: Map[A, PositiveNumber],
  num: PositiveNumber): Map[A, PositiveNumber] =
  x.map[A, PositiveNumber](
    {
      def $anonfun(x$1: (A, PositiveNumber)): (A, PositiveNumber) =
        {
          val key: A = x$1._1
          val value: PositiveNumber = x$1._2
          ArrowAssoc[A](key).->[PositiveNumber](mult2(value)(num))
        }
      closure($anonfun)
    }
  ).toMap[A, PositiveNumber](<:<.refl[(A, PositiveNumber)])

[odersky]

This needs a minimization to be sure, right now there is way too much type inference going on for a good diagnosis.

[ghostbuster91]

I think I have a simpler reproducer for the same issue: https://scastie.scala-lang.org/YRmAX35aTyO8mEoIM1kgRw this only happens if the extensions method has the same name as native method on the wrapped type.

Everything works fine if we move it to the Main object: https://scastie.scala-lang.org/R8zww6x4TtKm6roSNyvOyg

[warjort]

I am also seeing this problem with 3.3.1, 3.3.2-RC2, 3.4.0-RC1

This is my minimization.

Opaque class:

package test

type Foo = Unit
val bar: Foo = ()

//object Foo {
opaque type Opaque = Unit

extension (foo: Foo)
  def go: Option[Opaque] = ???
//}

Test class:

package test

//import Foo.*

final case class Test(value: Opaque)

def test: Test =
  //go(bar) match
  bar.go match
    case Some(value) => Test(value)
    case _           => ???

Incorrect compiler error:

Found:    (value : Unit)
Required: test.Opaque

The above includes 2 different (commented out) workarounds:

• Put the opaque type and the extension method in a non top level scope
• Call the extension method as a function instead of using selector syntax