Macro pickling causes unresolved symbols due to type parameter dependency on parameter

[andrzejressel]

Compiler version

3.1.3-RC5

Minimized code

// A.scala
package x

def hello = {
  xtransform {
    val a: Seq[Generic[?]] = null
    a
      .foreach { to =>
        to.mthd()
      }
  }
}

trait Generic[+T] {
  def mthd(): Generic[T] = this
}

// X.scala
package x

import scala.quoted.*


transparent inline def xtransform[T](inline expr:T) = ${
   X.transform('expr)
}

object X {

   def transform[T:Type](x: Expr[T])(using Quotes):Expr[T] = {
      import quotes.reflect.*
      x
   }

}

Output (click arrow to expand)

Exception in thread "main" java.lang.AssertionError: assertion failed: unresolved symbols: parameter to (line 6) #22672 when pickling A.scala while compiling A.scala, X.scala
java.lang.AssertionError: assertion failed: unresolved symbols: parameter to (line 6) #22672 when pickling A.scala
        at scala.runtime.Scala3RunTime$.assertFailed(Scala3RunTime.scala:8)
        at dotty.tools.dotc.core.tasty.TreePickler.pickle(TreePickler.scala:770)
        at dotty.tools.dotc.transform.Pickler.run$$anonfun$1$$anonfun$1(Pickler.scala:72)
        at scala.runtime.function.JProcedure1.apply(JProcedure1.java:15)
        at scala.runtime.function.JProcedure1.apply(JProcedure1.java:10)
        at scala.collection.immutable.List.foreach(List.scala:333)
        at dotty.tools.dotc.transform.Pickler.run$$anonfun$1(Pickler.scala:109)
        at scala.runtime.function.JProcedure1.apply(JProcedure1.java:15)
        at scala.runtime.function.JProcedure1.apply(JProcedure1.java:10)
        at scala.collection.immutable.List.foreach(List.scala:333)
        at dotty.tools.dotc.transform.Pickler.run(Pickler.scala:109)
        at dotty.tools.dotc.core.Phases$Phase.runOn$$anonfun$1(Phases.scala:311)
        at scala.collection.immutable.List.map(List.scala:246)
        at dotty.tools.dotc.core.Phases$Phase.runOn(Phases.scala:312)
        at dotty.tools.dotc.transform.Pickler.runOn(Pickler.scala:114)
        at dotty.tools.dotc.Run.runPhases$1$$anonfun$1(Run.scala:225)
        at scala.runtime.function.JProcedure1.apply(JProcedure1.java:15)
        at scala.runtime.function.JProcedure1.apply(JProcedure1.java:10)
        at scala.collection.ArrayOps$.foreach$extension(ArrayOps.scala:1328)
        at dotty.tools.dotc.Run.runPhases$1(Run.scala:236)
        at dotty.tools.dotc.Run.compileUnits$$anonfun$1(Run.scala:244)
        at dotty.tools.dotc.Run.compileUnits$$anonfun$adapted$1(Run.scala:253)
        at dotty.tools.dotc.util.Stats$.maybeMonitored(Stats.scala:68)
        at dotty.tools.dotc.Run.compileUnits(Run.scala:253)
        at dotty.tools.dotc.Run.compileUnits(Run.scala:192)
        at dotty.tools.dotc.Driver.finish(Driver.scala:56)
        at dotty.tools.dotc.Driver.doCompile(Driver.scala:36)
        at dotty.tools.dotc.Driver.process(Driver.scala:195)
        at dotty.tools.dotc.Driver.process(Driver.scala:163)
        at dotty.tools.dotc.Driver.process(Driver.scala:175)
        at dotty.tools.dotc.Driver.main(Driver.scala:205)
        at dotty.tools.dotc.Main.main(Main.scala)

Discussion in dotty-cps-async about this bug: dotty-cps-async/dotty-cps-async#58 (comment)

Regression starts here: 2317859

Example project: https://github.com/andrzejressel/scala-3-unresolved-symbols

[odersky]

I think further minimizing would be nice, but in principle the existing test case should be workable.

[KacperFKorban]

I managed to minimize it into a single file:

//> using scala "3.1.3-RC5"

def test =
  transform {
    val a: Seq[Generic[?]] = ???
    a.foreach { to =>
      to.mthd()
    }
  }

transparent inline def transform[T](expr: T): T = ??? // if we add inline to param, it doesn't crash

trait Generic[+T] { // both covariance and contravariance cause a crash (invariance doesn't)
  def mthd(): Generic[T] = ??? // has to have a parameter list to crash
}

[prolativ]

Additionally the crash in the snippet above doesn't occur if one of the following is true:

• we get rid o ? in val a: Seq[Generic[?]] = ???, e.g. val a: Seq[Generic[Int]] = ???
• we don't refer to T in the result type of mthd, e.g. def mthd(): Generic[Int] = ???