Singleton inference failure when used in same file

[valencik]

Compiler version

3.0.0-RC2

Minimized code

The following compiles fine on it's own:

package tuplefun
object Unpair {

  def pair[A, B](using a: ValueOf[A], b: ValueOf[B]): Tuple2[A, B] =
    (a.value, b.value)

  def unpair[X <: Tuple2[?, ?]](
      using a: ValueOf[Tuple.Head[X]],
            b: ValueOf[Tuple.Head[Tuple.Tail[X]]]
  ): Tuple2[Tuple.Head[X], Tuple.Head[Tuple.Tail[X]]] =
    type AA = Tuple.Head[X]
    type BB = Tuple.Head[Tuple.Tail[X]]
    pair[AA, BB](using a, b)
}

However, attempts to use unpair within the same file fail to compile, see the following scastie for an example:
https://scastie.scala-lang.org/wa8mgjM9TPOY2trROxRWXg

Everything compiles and works if we move UnpairApp, shown in above scastie link and below, to a new file.

object UnpairApp {
  import Unpair._

  type Tshape = ("msg", 42)

  // the following won't compile when in the same file as Unpair
  val p1: ("msg", 42) = unpair[Tshape] // error: No singleton value available for Any

  @main def pairHello: Unit =
    assert(p1 == ("msg", 42))
    println(p1)
}

Additionally if one loads the console in sbt and imports unpair things work:

scala> import tuplefun.Unpair.unpair

scala> type T = ("msg", 42)
// defined alias type T = ("msg", 42)

scala> unpair[T]                   
val res0: ("msg", 42) = (msg,42)

Expectation

UnpairApp and/or usage of unpair should compile whether defined in the same file or a separate file from Unpair

What are you doing?

If curious, the motivation that lead me here was trying to call a function of the form def func[A, B] when what I have is a type alias type T = Tuple2[A, B] and I do not want to spell out the types again.

[nicolasstucki]

Minimized

object Unpair {
  def unpair[X <: Tuple2[?, ?]](a: ValueOf[Tuple.Head[X]]): Unit = ???
  unpair[("msg", 42)](summon[ValueOf["msg"]])
}

[OlivierBlanvillain]

I'm not sure about the original example, but in Nico's minimization I don't think we can do better without existential types. If you give the first ? a name, things start to work as expected, but type inference won't do this on its own:

object Unpair {
  def unpair[A, X <: Tuple2[A, ?]](a: ValueOf[Tuple.Head[X]]): Unit = ???
  unpair["msg", ("msg", 42)](summon[ValueOf["msg"]])
}

[OlivierBlanvillain]

I couldn't reproduce the issue with same file vs different files:

Reproduced as follows: (works under separate compilation, but breaks when put in a single file)

$ cat tests/pos/11982/1.scala
package tuplefun

object Unpair {

 def pair[A, B](using a: ValueOf[A], b: ValueOf[B]): Tuple2[A, B] =
   (a.value, b.value)

 def unpair[X <: Tuple2[?, ?]](
     using a: ValueOf[Tuple.Head[X]],
           b: ValueOf[Tuple.Head[Tuple.Tail[X]]]
 ): Tuple2[Tuple.Head[X], Tuple.Head[Tuple.Tail[X]]] =
   type AA = Tuple.Head[X]
   type BB = Tuple.Head[Tuple.Tail[X]]
   pair[AA, BB](using a, b)
}

$ cat tests/pos/11982/2.scala
package tuplefun

object UnpairApp {
 import Unpair._

 type Tshape = ("msg", 42)
 val p1: ("msg", 42) = unpair[Tshape]

 @main def pairHello: Unit =
   assert(p1 == ("msg", 42))
   println(p1)
}

$ echo 11982 >> compiler/test/dotc/pos-test-pickling.blacklist

$ sbt "testCompilation 11982"
...
[success] Total time: 3 s, completed Aug 4, 2021 12:45:51 PM