Eliminate LambdaAbstract

Use fromParams instead.

Author: odersky

compiler/src/dotty/tools/dotc/core/TypeApplications.scala

@@ -271,25 +271,6 @@ class TypeApplications(val self: Type) extends AnyVal {
       self
   }
 
-  /** Lambda abstract `self` with given type parameters. Examples:
-   *
-   *      type T[X] = U        becomes    type T = [X] -> U
-   *      type T[X] >: L <: U  becomes    type T >: L <: ([X] -> U)
-   */
-  def LambdaAbstract(tparams: List[TypeParamInfo])(implicit ctx: Context): Type = {
-    def expand(tp: Type) = PolyType/*HKTypeLambda*/.fromParams(tparams, tp)
-    if (tparams.isEmpty) self
-    else self match {
-      case self: TypeAlias =>
-        self.derivedTypeAlias(expand(self.alias))
-      case self @ TypeBounds(lo, hi) =>
-        self.derivedTypeBounds(
-          if (lo.isRef(defn.NothingClass)) lo else expand(lo),
-          expand(hi))
-      case _ => expand(self)
-    }
-  }
-
   /** Convert a type constructor `TC` which has type parameters `T1, ..., Tn`
    *  in a context where type parameters `U1,...,Un` are expected to
    *
@@ -302,7 +283,7 @@ class TypeApplications(val self: Type) extends AnyVal {
    */
   def EtaExpand(tparams: List[TypeSymbol])(implicit ctx: Context): Type = {
     val tparamsToUse = if (variancesConform(typeParams, tparams)) tparams else typeParamSymbols
-    self.appliedTo(tparams map (_.typeRef)).LambdaAbstract(tparamsToUse)
+    HKTypeLambda.fromParams(tparamsToUse, self.appliedTo(tparams map (_.typeRef)))
       //.ensuring(res => res.EtaReduce =:= self, s"res = $res, core = ${res.EtaReduce}, self = $self, hc = ${res.hashCode}")
   }
 

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -2562,12 +2562,11 @@ object Types {
 
     protected def paramName(param: ParamInfo.Of[N])(implicit ctx: Context): N =
       param.paramName
-    protected def paramInfo(param: ParamInfo.Of[N])(implicit ctx: Context): Type =
-      param.paramInfo
 
-    def fromParams[PI <: ParamInfo.Of[N]](params: List[PI], resultType: Type)(implicit ctx: Context): LT =
-      apply(params.map(paramName))(
-        tl => params.map(param => tl.integrate(params, paramInfo(param)).asInstanceOf[PInfo]),
+    def fromParams[PI <: ParamInfo.Of[N]](params: List[PI], resultType: Type)(implicit ctx: Context): Type =
+      if (params.isEmpty) resultType
+      else apply(params.map(paramName))(
+        tl => params.map(param => tl.integrate(params, param.paramInfo).asInstanceOf[PInfo]),
         tl => tl.integrate(params, resultType))
   }
 
@@ -2751,6 +2750,25 @@ object Types {
 
     override def paramName(param: ParamInfo.Of[TypeName])(implicit ctx: Context): TypeName =
       param.paramName.withVariance(param.paramVariance)
+
+    /** Distributes Lambda inside type bounds. Examples:
+  	 *
+   	 *      type T[X] = U        becomes    type T = [X] -> U
+   	 *      type T[X] <: U       becomes    type T >: Nothign <: ([X] -> U)
+     *      type T[X] >: L <: U  becomes    type T >: ([X] -> L) <: ([X] -> U)
+     */
+    override def fromParams[PI <: ParamInfo.Of[TypeName]](params: List[PI], resultType: Type)(implicit ctx: Context): Type = {
+      def expand(tp: Type) = PolyType.fromParams(params, tp) //###
+      resultType match {
+        case rt: TypeAlias =>
+          rt.derivedTypeAlias(expand(rt.alias))
+        case rt @ TypeBounds(lo, hi) =>
+          rt.derivedTypeBounds(
+            if (lo.isRef(defn.NothingClass)) lo else expand(lo), expand(hi))
+        case rt =>
+          expand(rt)
+      }
+    }
   }
 
   object PolyType extends TypeLambdaCompanion[PolyType] {

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -42,13 +42,15 @@ object Scala2Unpickler {
 
   /** Convert temp poly type to poly type and leave other types alone. */
   def translateTempPoly(tp: Type)(implicit ctx: Context): Type = tp match {
-    case TempPolyType(tparams, restpe) => restpe.LambdaAbstract(tparams) // PolyType.fromParams(tparams, restpe)
+    case TempPolyType(tparams, restpe) =>
+      (if (tparams.head.owner.isTerm) PolyType else HKTypeLambda)
+        .fromParams(tparams, restpe)
     case tp => tp
   }
 
   def addConstructorTypeParams(denot: SymDenotation)(implicit ctx: Context) = {
     assert(denot.isConstructor)
-    denot.info = denot.info.LambdaAbstract(denot.owner.typeParams)
+    denot.info = PolyType.fromParams(denot.owner.typeParams, denot.info)
   }
 
   /** Convert array parameters denoting a repeated parameter of a Java method

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -76,7 +76,7 @@ object Checking {
     val orderedArgs = if (hasNamedArg(args)) tparams.map(argNamed) else args
     val bounds = tparams.map(_.paramInfoAsSeenFrom(tycon.tpe).bounds)
     def instantiate(bound: Type, args: List[Type]) =
-      bound.LambdaAbstract(tparams).appliedTo(args)
+      HKTypeLambda.fromParams(tparams, bound).appliedTo(args)
     checkBounds(orderedArgs, bounds, instantiate)
 
     def checkWildcardHKApply(tp: Type, pos: Position): Unit = tp match {

compiler/src/dotty/tools/dotc/typer/Inliner.scala

@@ -120,7 +120,8 @@ object Inliner {
             // Abstract accessed type over local refs
             def abstractQualType(mtpe: Type): Type =
               if (localRefs.isEmpty) mtpe
-              else PolyType.fromParams(localRefs.map(_.symbol.asType), mtpe).flatten
+              else PolyType.fromParams(localRefs.map(_.symbol.asType), mtpe)
+                .asInstanceOf[PolyType].flatten
 
             val accessorType = abstractQualType(addQualType(dealiasMap(accessedType)))
             val accessor = accessorSymbol(tree, accessorType).asTerm

compiler/src/dotty/tools/dotc/typer/Namer.scala

@@ -115,7 +115,7 @@ trait NamerContextOps { this: Context =>
             if (param.info.isDirectRef(defn.ObjectClass)) param.info = defn.AnyType
         make.fromSymbols(params.asInstanceOf[List[TermSymbol]], resultType)
       }
-    if (typeParams.nonEmpty) monotpe.LambdaAbstract(typeParams.asInstanceOf[List[TypeSymbol]])
+    if (typeParams.nonEmpty) PolyType.fromParams(typeParams.asInstanceOf[List[TypeSymbol]], monotpe)
     else if (valueParamss.isEmpty) ExprType(monotpe)
     else monotpe
   }
@@ -1122,9 +1122,7 @@ class Namer { typer: Typer =>
   }
 
   def typeDefSig(tdef: TypeDef, sym: Symbol, tparamSyms: List[TypeSymbol])(implicit ctx: Context): Type = {
-    def abstracted(tp: Type): Type =
-      if (tparamSyms.nonEmpty) tp.LambdaAbstract(tparamSyms) else tp
-
+    def abstracted(tp: Type): Type = HKTypeLambda.fromParams(tparamSyms, tp)
     val dummyInfo = abstracted(TypeBounds.empty)
     sym.info = dummyInfo
       // Temporarily set info of defined type T to ` >: Nothing <: Any.

compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala

@@ -458,7 +458,7 @@ trait TypeAssigner {
   }
 
   def assignType(tree: untpd.LambdaTypeTree, tparamDefs: List[TypeDef], body: Tree)(implicit ctx: Context) =
-    tree.withType(body.tpe.LambdaAbstract(tparamDefs.map(_.symbol.asType)))
+    tree.withType(HKTypeLambda.fromParams(tparamDefs.map(_.symbol.asType), body.tpe))
 
   def assignType(tree: untpd.ByNameTypeTree, result: Tree)(implicit ctx: Context) =
     tree.withType(ExprType(result.tpe))