fix scala/bug#12420: complete LambdaType param symbols lazily

Author: bishabosha

src/compiler/scala/tools/nsc/tasty/TreeUnpickler.scala

@@ -21,6 +21,7 @@ import scala.collection.mutable
 import scala.reflect.io.AbstractFile
 import scala.reflect.internal.Variance
 import scala.util.chaining._
+import scala.collection.immutable.ArraySeq
 
 /**`TreeUnpickler` is responsible for traversing all trees in the "ASTs" section of a TASTy file, which represent the
  * definitions inside the classfile associated with the root class/module. `TreeUnpickler` will enter the public api
@@ -220,7 +221,7 @@ class TreeUnpickler[Tasty <: TastyUniverse](
     /** Read names in an interleaved sequence of types/bounds and (parameter) names,
       *  possibly followed by a sequence of modifiers.
       */
-    def readParamNamesAndMods(end: Addr): (List[TastyName], TastyFlagSet) = {
+    def readParamNamesAndMods(end: Addr): (ArraySeq[TastyName], TastyFlagSet) = {
       val names =
         collectWhile(currentAddr != end && !isModifierTag(nextByte)) {
           skipTree()
@@ -234,7 +235,7 @@ class TreeUnpickler[Tasty <: TastyUniverse](
           case GIVEN    => mods |= Given
         }
       }
-      (names, mods)
+      (names.to(ArraySeq), mods)
     }
 
     /** Read `n` parameter types or bounds which are interleaved with names */
@@ -332,18 +333,26 @@ class TreeUnpickler[Tasty <: TastyUniverse](
       def readLengthType(): Type = {
         val end = readEnd()
 
-        def readMethodic[N <: TastyName]
-            (companionOp: TastyFlagSet => LambdaTypeCompanion[N], nameMap: TastyName => N)(implicit ctx: Context): Type = {
+        def readMethodic[N <: TastyName](
+            factory: LambdaFactory[N],
+            parseFlags: FlagSets.FlagParser,
+            nameMap: TastyName => N
+        )(implicit ctx: Context): Type = {
           val result = typeAtAddr.getOrElse(start, {
+            // TODO [tasty]: can we share LambdaTypes/RecType/RefinedType safely
+            // under a new context owner? (aka when referenced by a `SHAREDtype`).
+            // Perhaps we should redesign so that when one of these is retrieved
+            // from the cache, and the context owner does not match, all its parameters
+            // are subtituted for fresh symbols within the new context owner.
             val nameReader = fork
             nameReader.skipTree() // skip result
             val paramReader = nameReader.fork
             val (paramNames, mods) = nameReader.readParamNamesAndMods(end)
-            companionOp(mods)(paramNames.map(nameMap))(
-              pt => typeAtAddr(start) = pt,
-              () => paramReader.readParamTypes(paramNames.length),
-              () => readType()
-            ).tap(typeAtAddr(start) = _)
+            LambdaFactory.parse(factory, paramNames.map(nameMap), parseFlags(mods)(ctx))(
+              () => paramReader.readParamTypes(paramNames.length).to(ArraySeq),
+              () => readType(),
+              pt => typeAtAddr(start) = pt, // register the lambda so that we can access its parameters
+            )
           })
           goto(end)
           result
@@ -382,18 +391,10 @@ class TreeUnpickler[Tasty <: TastyUniverse](
             case ORtype => unionIsUnsupported
             case SUPERtype => defn.SuperType(readType(), readType())
             case MATCHtype | MATCHCASEtype => matchTypeIsUnsupported
-            case POLYtype => readMethodic(Function.const(PolyType), _.toTypeName)
-            case METHODtype =>
-              def companion(mods0: TastyFlagSet) = {
-                var mods = EmptyTastyFlags
-                if (mods0.is(Erased)) erasedRefinementIsUnsupported[Unit]
-                if (mods0.isOneOf(Given | Implicit)) mods |= Implicit
-                methodTypeCompanion(mods)
-              }
-              readMethodic(companion, id)
-            case TYPELAMBDAtype => readMethodic(Function.const(HKTypeLambda), _.toTypeName)
-            case PARAMtype => // reference to a type parameter within a LambdaType
-              readTypeRef().typeParams(readNat()).ref
+            case POLYtype => readMethodic(PolyTypeLambda, FlagSets.addDeferred, _.toTypeName)
+            case METHODtype => readMethodic(MethodTermLambda, FlagSets.parseMethod, id)
+            case TYPELAMBDAtype => readMethodic(HKTypeLambda, FlagSets.addDeferred, _.toTypeName)
+            case PARAMtype => defn.ParamRef(readTypeRef(), readNat()) // reference to a parameter within a LambdaType
           }
         assert(currentAddr === end, s"$start $currentAddr $end ${astTagToString(tag)}")
         result

src/compiler/scala/tools/nsc/tasty/bridge/ContextOps.scala

@@ -156,6 +156,11 @@ trait ContextOps { self: TastyUniverse =>
 
   final case class TraceInfo[-T](query: String, qual: String, res: T => String, modifiers: List[String] = Nil)
 
+  trait TraceFrame {
+    def parent: TraceFrame
+    def id: String
+  }
+
   /**Maintains state through traversal of a TASTy file, such as the outer scope of the defintion being traversed, the
    * traversal mode, and the root owners and source path for the TASTy file.
    * It also provides all operations for manipulation of the symbol table, such as creating/updating symbols and
@@ -205,17 +210,17 @@ trait ContextOps { self: TastyUniverse =>
 
     @inline final def trace[T](info: => TraceInfo[T])(op: => T): T = {
 
-      def withTrace(info: => TraceInfo[T], op: => T)(traceId: String): T = {
-        val i = info
+      def addInfo(i: TraceInfo[T], op: => T)(frame: TraceFrame): T = {
+        val id0 = frame.id
         val modStr = (
           if (i.modifiers.isEmpty) ""
           else " " + green(i.modifiers.mkString("[", ",", "]"))
         )
-        logImpl(s"${yellow(s"$traceId")} ${cyan(s"<<< ${i.query}:")} ${magenta(i.qual)}$modStr")
-        op.tap(eval => logImpl(s"${yellow(s"$traceId")} ${cyan(s">>>")} ${magenta(i.res(eval))}$modStr"))
+        logImpl(s"${yellow(id0)} ${cyan(s"<<< ${i.query}:")} ${magenta(i.qual)}$modStr")
+        op.tap(eval => logImpl(s"${yellow(id0)} ${cyan(s">>>")} ${magenta(i.res(eval))}$modStr"))
       }
 
-      if (u.settings.YdebugTasty) initialContext.addFrame(withTrace(info, op))
+      if (u.settings.YdebugTasty) initialContext.subTrace(addInfo(info, op))
       else op
     }
 
@@ -282,6 +287,16 @@ trait ContextOps { self: TastyUniverse =>
       )
     }
 
+    final def newLambdaParameter(tname: TastyName, flags: TastyFlagSet, idx: Int, infoDb: Int => Type): Symbol = {
+      val flags1 = flags | Param
+      unsafeNewSymbol(
+        owner = owner,
+        name  = tname,
+        flags = flags1,
+        info  = defn.LambdaParamInfo(flags1, idx, infoDb)
+      )
+    }
+
     final def findRootSymbol(roots: Set[Symbol], name: TastyName): Option[Symbol] = {
       import TastyName.TypeName
 
@@ -594,32 +609,32 @@ trait ContextOps { self: TastyUniverse =>
     def mode: TastyMode = EmptyTastyMode
     def owner: Symbol = topLevelClass.owner
 
-    private class TraceFrame(val id: Int, val next: TraceFrame) {
+    private class TraceFrameImpl(val worker: Int, val parent: TraceFrameImpl) extends TraceFrame {
 
       var nextChild: Int = 0
 
-      def show: String = {
-        val buf = mutable.ArrayDeque.empty[String]
+      val id: String = {
+        val buf = mutable.ArrayDeque.empty[Int]
         var cur = this
-        while (cur.id != -1) {
-          buf.prepend(cur.id.toString)
-          cur = cur.next
+        while (cur.worker != -1) {
+          buf.prepend(cur.worker)
+          cur = cur.parent
         }
         buf.mkString("[", " ", ")")
       }
 
     }
 
-    private[this] var _trace: TraceFrame = new TraceFrame(id = -1, next = null)
+    private[this] var _trace: TraceFrameImpl = new TraceFrameImpl(worker = -1, parent = null)
 
-    private[ContextOps] def addFrame[T](op: String => T): T = {
-      val oldFrame  = _trace
-      val newFrame = new TraceFrame(id = oldFrame.nextChild, next = oldFrame)
-      _trace = newFrame
-      try op(newFrame.show)
+    private[ContextOps] def subTrace[T](op: TraceFrame => T): T = {
+      val parent = _trace
+      val child = new TraceFrameImpl(worker = parent.nextChild, parent)
+      _trace = child
+      try op(child)
       finally {
-        _trace = oldFrame
-        _trace.nextChild += 1
+        parent.nextChild += 1
+        _trace = parent
       }
     }
 

src/compiler/scala/tools/nsc/tasty/bridge/FlagOps.scala

@@ -29,11 +29,20 @@ trait FlagOps { self: TastyUniverse =>
         | Enum | Infix | Open | ParamAlias | Invisible
     )
 
+    type FlagParser = TastyFlagSet => Context => TastyFlagSet
+
+    val addDeferred: FlagParser = flags => _ => flags | Deferred
+    val parseMethod: FlagParser = { mods0 => implicit ctx =>
+      var mods = EmptyTastyFlags
+      if (mods0.is(Erased)) erasedRefinementIsUnsupported[Unit]
+      if (mods0.isOneOf(Given | Implicit)) mods |= Implicit
+      mods
+    }
+
     object Creation {
       val ObjectDef: TastyFlagSet = Object | Lazy | Final | Stable
       val ObjectClassDef: TastyFlagSet = Object | Final
       val Default: u.FlagSet = newSymbolFlagSet(EmptyTastyFlags)
-      val BoundedType: u.FlagSet = newSymbolFlagSet(Deferred)
     }
     def withAccess(flags: TastyFlagSet, inheritedAccess: TastyFlagSet): TastyFlagSet =
       flags | (inheritedAccess & (Private | Local | Protected))

src/compiler/scala/tools/nsc/tasty/bridge/TastyCore.scala

@@ -34,6 +34,5 @@ abstract class TastyCore { self: TastyUniverse =>
   private val Identity = (x: Any) => x
 
   def id[T]: T => T = Identity.asInstanceOf[T => T]
-  def map[T, U](ts: List[T], f: T => U): List[U] = if (f `eq` Identity) ts.asInstanceOf[List[U]] else ts.map(f)
 
 }