refactor lambdaTypeCompanion

bishabosha · bishabosha · commit 8cf7ae504133 · 2020-02-21T15:16:06.000+01:00
diff --git a/src/compiler/scala/tools/nsc/tasty/TreeUnpickler.scala b/src/compiler/scala/tools/nsc/tasty/TreeUnpickler.scala
@@ -297,40 +297,27 @@ class TreeUnpickler[Tasty <: TastyUniverse](
       val tag = readByte()
       ctx.log(s"reading type ${astTagToString(tag)} at $start")
 
-      def registeringType[T](tp: Type, op: => T): T = {
+      def registeringTypeWith[T](tp: Type, op: => T): T = {
         typeAtAddr(start) = tp
         op
       }
 
       def readLengthType(): Type = {
         val end = readEnd()
 
-        def readMethodic[N <: Name, PInfo <: Type, LT <: LambdaType]
-            (companion: LambdaTypeCompanion[N, PInfo, LT], nameMap: TastyName => N, varianceMap: TastyName => Variance)(implicit ctx: Context): Type = {
-          val complete = typeAtAddr.contains(start)
-          val stored = typeAtAddr.getOrElse(start, {
+        def readMethodic[N <: Name, PInfo <: Type, LT <: LambdaType, Res <: Type]
+            (companion: LambdaTypeCompanion[N, PInfo, LT, Res], nameMap: TastyName => N)(implicit ctx: Context): Res = {
+          val result = typeAtAddr.getOrElse(start, {
             val nameReader = fork
             nameReader.skipTree() // skip result
             val paramReader = nameReader.fork
             val paramNames = nameReader.readParamNames(end)
-            val encodedNames = paramNames.map(nameMap)
-            val nameVariances = paramNames.map(varianceMap)
-            companion(encodedNames, nameVariances)(
-              pt => registeringType(pt, paramReader.readParamTypes[PInfo](end)),
-              pt => readType())
+            companion(paramNames)(nameMap,
+              pt => registeringTypeWith(pt, paramReader.readParamTypes[PInfo](end)),
+              pt => readType()).tap(typeAtAddr(start) = _)
           })
           goto(end)
-          val canonical = {
-            if (complete) {
-              stored
-            }
-            else {
-              val canonical = stored.asInstanceOf[LT].canonicalForm
-              typeAtAddr.update(start, canonical)
-              canonical
-            }
-          }
-          canonical
+          result.asInstanceOf[Res]
         }
 
         val result =
@@ -390,9 +377,9 @@ class TreeUnpickler[Tasty <: TastyUniverse](
             // case IMPLICITMETHODtype =>
             //   readMethodic(ImplicitMethodType, _.toTermName)
             case TYPELAMBDAtype =>
-              readMethodic(HKTypeLambda, _.toEncodedTermName.toTypeName, _.variance)
+              readMethodic(HKTypeLambda, _.toEncodedTermName.toTypeName)
             case PARAMtype =>
-              readTypeRef().asInstanceOf[LambdaType].typeParams(readNat()).ref
+              readTypeRef().typeParams(readNat()).ref
           }
         assert(currentAddr === end, s"$start $currentAddr $end ${astTagToString(tag)}")
         result
@@ -1467,7 +1454,7 @@ class TreeUnpickler[Tasty <: TastyUniverse](
             case LAMBDAtpt =>
               val tparams = readParams[NoCycle](TYPEPARAM)
               val body    = readTpt()
-              TypeTree(TypeParamLambda(tparams.map(symFromNoCycle), body.tpe).canonicalForm) //LambdaTypeTree(tparams, body)
+              TypeTree(mkLambdaFromParams(tparams.map(symFromNoCycle), body.tpe)) //LambdaTypeTree(tparams, body)
 //            case MATCHtpt =>
 //              val fst = readTpt()
 //              val (bound, scrut) =
diff --git a/src/compiler/scala/tools/nsc/tasty/bridge/TastyKernel.scala b/src/compiler/scala/tools/nsc/tasty/bridge/TastyKernel.scala
@@ -57,10 +57,6 @@ trait TastyKernel { self: TastyUniverse =>
     def empty: TypeBounds = symbolTable.TypeBounds.empty
     def upper(hi: Type): TypeBounds = symbolTable.TypeBounds.upper(hi)
     def lower(lo: Type): TypeBounds = symbolTable.TypeBounds.lower(lo)
-    def addLower(tpe: Type): TypeBounds = tpe match {
-      case tpe: TypeBounds => tpe
-      case tpe             => upper(tpe)
-    }
     def bounded(lo: Type, hi: Type): TypeBounds = symbolTable.TypeBounds.apply(lo, hi)
   }
 
diff --git a/src/compiler/scala/tools/nsc/tasty/bridge/TypeOps.scala b/src/compiler/scala/tools/nsc/tasty/bridge/TypeOps.scala
@@ -50,7 +50,7 @@ trait TypeOps extends TastyKernel { self: TastyUniverse =>
         mkPolyType(hi.typeParams, TypeBounds.bounded(nuLo, hi.resultType.upperBound))
       }
       else bounds match {
-        case TypeBounds(lo: LambdaEncoding, hi: LambdaEncoding) => TypeBounds.bounded(lo.toNested,hi.toNested)
+        case TypeBounds(lo: LambdaPolyType, hi: LambdaPolyType) => TypeBounds.bounded(lo.toNested,hi.toNested)
         case _                                                  => bounds
       }
     }
@@ -73,11 +73,11 @@ trait TypeOps extends TastyKernel { self: TastyUniverse =>
         mkAppliedType(tycon, args)
     }
 
-    if (args.exists(tpe => tpe.isInstanceOf[TypeBounds] | tpe.isInstanceOf[LambdaEncoding])) {
+    if (args.exists(tpe => tpe.isInstanceOf[TypeBounds] | tpe.isInstanceOf[LambdaPolyType])) {
       val syms = mutable.ListBuffer.empty[Symbol]
       def bindWildcards(tpe: Type) = tpe match {
         case tpe: TypeBounds     => ctx.newWildcardSym(tpe).tap(syms += _).pipe(_.ref)
-        case tpe: LambdaEncoding => tpe.toNested
+        case tpe: LambdaPolyType => tpe.toNested
         case tpe                 => tpe
       }
       val args1 = args.map(bindWildcards)
@@ -221,114 +221,90 @@ trait TypeOps extends TastyKernel { self: TastyUniverse =>
     tpeOrErr.fold(reportThenErrorTpe, identity)
   }
 
-  abstract class LambdaTypeCompanion[N <: Name, PInfo <: Type, LT <: LambdaType] {
-    def apply(paramNames: List[N], paramVariances: List[Variance])(paramInfosExp: LT => List[PInfo], resultTypeExp: LT => Type)(implicit ctx: Context): LT
+  def lambdaResultType(resType: Type): Type = resType match {
+    case res: LambdaPolyType => res.toNested
+    case res                 => res
   }
 
-  final class LambdaEncoding(override val typeParams: List[Symbol], val resTpe: Type) extends PolyType(typeParams, TypeBounds.addLower(resTpe)) {
-    def toNested: PolyType = resTpe match {
+  abstract class LambdaTypeCompanion[N <: Name, PInfo <: Type, LT <: LambdaType, Res <: Type] {
+    def apply(paramNames: List[TastyName])(nameMap: TastyName => N, paramInfosExp: LT => List[PInfo], resultTypeExp: LT => Type)(implicit ctx: Context): Res
+  }
+
+  final class LambdaPolyType(typeParams: List[Symbol], resType: Type) extends PolyType(typeParams, LambdaPolyType.addLower(resType)) {
+    def toNested: PolyType = resType match {
       case _: TypeBounds => this
-      case _             => mkPolyType(typeParams, resTpe)
+      case _             => mkPolyType(typeParams, resType)
     }
   }
 
-  def mkLambdaEncoding(typeParams: List[Symbol], resTpe: Type) = new LambdaEncoding(typeParams, resTpe)
-
-  object TypeParamLambda {
-    def apply(typeParams: List[Symbol], ret: Type): LambdaType = new TypeParamLambda(typeParams, ret)
+  object LambdaPolyType {
+    private def addLower(tpe: Type): TypeBounds = tpe match {
+      case tpe: TypeBounds => tpe
+      case tpe             => TypeBounds.upper(tpe)
+    }
   }
 
-  final class TypeParamLambda(override val typeParams: List[Symbol], val resType: Type) extends LambdaType {
-    type ThisName = TypeName
-    type PInfo    = TypeBounds
+  def mkLambdaPolyType(typeParams: List[Symbol], resTpe: Type): LambdaPolyType = new LambdaPolyType(typeParams, resTpe)
+  def mkLambdaFromParams(typeParams: List[Symbol], ret: Type): PolyType = mkPolyType(typeParams, lambdaResultType(ret))
 
-    val paramVariances: List[Variance] = typeParams.map(_.variance)
-    val paramNames: List[TypeName]     = typeParams.map(_.name.toTypeName)
-    val paramInfos: List[TypeBounds]   = typeParams.map(_.tpe.bounds)
+  type LambdaType = Type with Lambda
 
-    validateThisLambda()
-
-    override val productPrefix                = "TypeParamLambda"
-    override def canEqual(that: Any): Boolean = that.isInstanceOf[TypeParamLambda]
-  }
-
-  abstract class LambdaType extends Type with Product { lambdaTpe =>
+  trait Lambda extends Product with Serializable {
+    self: Type =>
     type ThisName <: Name
     type PInfo <: Type
 
     val paramNames: List[ThisName]
-    val paramVariances: List[Variance]
     val paramInfos: List[PInfo]
     val resType: Type
 
-    override final def safeToString: String = {
-      val args = paramNames.zip(paramInfos).map {
-        case (name, info) => s"${name}$info"
-      }.mkString("[", ", ", "]")
-      s"$args =>> $resType"
-    }
-
     def typeParams: List[Symbol] // deferred to final implementation
 
     final protected def validateThisLambda(): Unit = {
-      assert(resType.isComplete, this)
-      assert(paramNames.nonEmpty, this)
-      assert(paramInfos.length == paramNames.length, this)
+      assert(resType.isComplete, self)
+      assert(paramNames.nonEmpty, self)
+      assert(paramInfos.length == paramNames.length, self)
     }
 
-    /**Best effort to transform this to an equivalent canonical representation in scalac.
-     */
-    final def canonicalForm(implicit ctx: Context): Type = {
-      val res = resType match {
-        case res: LambdaEncoding => res.toNested
-        case res                 => res
-      }
-      lambdaTpe match {
-        case _: HKTypeLambda    => mkLambdaEncoding(typeParams, res)
-        case _: TypeParamLambda => mkPolyType(typeParams, res)
-      }
-    }.tap(res => ctx.log(s"""|canonical form of ${lambdaTpe.productPrefix}:
-                             |  TASTy         = $lambdaTpe
-                             |  scala.reflect = $res""".stripMargin))
+    override final def productArity: Int = 2
 
-    final def productArity: Int = 2
-    final def productElement(n: Int): Any = n match {
+    override final def productElement(n: Int): Any = n match {
       case 0 => paramNames
       case 1 => resType
       case _ => throw new IndexOutOfBoundsException(n.toString)
     }
-    def canEqual(that: Any): Boolean = that.isInstanceOf[LambdaType]
+
+    def canEqual(that: Any): Boolean = that.isInstanceOf[Lambda]
+
     override final def equals(that: Any): Boolean = that match {
-      case lambdaType: LambdaType =>
-        (lambdaType.canEqual(this)
-          && lambdaType.paramNames == paramNames
-          && lambdaType.resType == resType)
+      case that: Lambda =>
+        (that.canEqual(self)
+          && that.paramNames == paramNames
+          && that.resType    == resType)
       case _ => false
     }
   }
 
-  object HKTypeLambda extends LambdaTypeCompanion[TypeName, TypeBounds, HKTypeLambda] {
-    def apply(paramNames: List[TypeName], paramVariances: List[Variance])(
-        paramInfosExp: HKTypeLambda => List[TypeBounds], resultTypeExp: HKTypeLambda => Type)(implicit ctx: Context): HKTypeLambda =
-      new HKTypeLambda(paramNames, paramVariances)(paramInfosExp, resultTypeExp)
+  object HKTypeLambda extends LambdaTypeCompanion[TypeName, TypeBounds, HKTypeLambda, LambdaPolyType] {
+    def apply(paramNames: List[TastyName])(nameMap: TastyName => TypeName,
+        paramInfosExp: HKTypeLambda => List[TypeBounds], resultTypeExp: HKTypeLambda => Type)(implicit ctx: Context): LambdaPolyType =
+      new HKTypeLambda(paramNames)(nameMap, paramInfosExp, resultTypeExp).toPolyType
   }
 
-  final class HKTypeLambda(val paramNames: List[TypeName], val paramVariances: List[Variance])(
+  final class HKTypeLambda(params: List[TastyName])(nameMap: TastyName => TypeName,
       paramInfosExp: HKTypeLambda => List[TypeBounds], resultTypeExp: HKTypeLambda => Type)(implicit ctx: Context)
-  extends LambdaType {
+  extends Type with Lambda { hkLambda =>
     type ThisName = TypeName
     type PInfo = TypeBounds
 
     private[this] var myTypeParams: List[Symbol] = _
 
     override val productPrefix       = "HKTypeLambda"
-    val paramInfos: List[TypeBounds] = paramInfosExp(this)
-    val resType: Type                = resultTypeExp(this)
-
-    validateThisLambda()
+    val paramNames: List[TypeName]   = params.map(nameMap)
+    val paramInfos: List[TypeBounds] = paramInfosExp(hkLambda)
 
-    override def typeParams: List[Symbol] = {
-      if (myTypeParams `eq` null) myTypeParams = paramNames.lazyZip(paramInfos).lazyZip(paramVariances).map {
+    override val typeParams: List[Symbol] = {
+      paramNames.lazyZip(paramInfos).lazyZip(params.map(_.variance)).map {
         case (name, bounds, variance) =>
           val flags0 = Param | Deferred
           val flags  = variance match {
@@ -339,9 +315,14 @@ trait TypeOps extends TastyKernel { self: TastyUniverse =>
           val argInfo = normaliseBounds(bounds)
           ctx.owner.newTypeParameter(name, noPosition, flags).setInfo(argInfo)
       }
-      myTypeParams
     }
 
+    val resType: Type = lambdaResultType(resultTypeExp(hkLambda))
+
+    validateThisLambda()
+
+    final def toPolyType: LambdaPolyType = mkLambdaPolyType(typeParams, resType)
+
     override def canEqual(that: Any): Boolean = that.isInstanceOf[HKTypeLambda]
   }
 
