Make Term Lambda parameters distribute into bounds

Analogous to type lambda parameters

Author: odersky

compiler/src/dotty/tools/dotc/config/Config.scala

@@ -97,9 +97,9 @@ object Config {
    */
   final val checkHKApplications = false
 
-  /** If this flag is set, method types are checked for valid parameter references
+  /** If this flag is set, term lambda types are checked for valid parameter references
    */
-  final val checkMethodTypes = false
+  final val checkTermLambdas = false
 
   /** If this flag is set, it is checked that TypeRefs don't refer directly
    *  to themselves.

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

@@ -3131,30 +3131,15 @@ object Types {
     protected def prefixString = "PolyType"
   }
 
-  object HKTypeLambda extends TypeLambdaCompanion[HKTypeLambda] {
-    def apply(paramNames: List[TypeName])(
-        paramInfosExp: HKTypeLambda => List[TypeBounds],
-        resultTypeExp: HKTypeLambda => Type)(implicit ctx: Context): HKTypeLambda = {
-      unique(new HKTypeLambda(paramNames)(paramInfosExp, resultTypeExp))
-    }
-
-    def unapply(tl: HKTypeLambda): Some[(List[LambdaParam], Type)] =
-      Some((tl.typeParams, tl.resType))
-
-    def any(n: Int)(implicit ctx: Context) =
-      apply(syntheticParamNames(n))(
-        pt => List.fill(n)(TypeBounds.empty), pt => defn.AnyType)
-
-    override def paramName(param: ParamInfo.Of[TypeName])(implicit ctx: Context): TypeName =
-      param.paramName.withVariance(param.paramVariance)
+  trait HKCompanion[N <: Name, PInfo <: Type, LT <: LambdaType] extends LambdaTypeCompanion[N, PInfo, LT] {
 
     /** 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 = {
+    override def fromParams[PI <: ParamInfo.Of[N]](params: List[PI], resultType: Type)(implicit ctx: Context): Type = {
       def expand(tp: Type) = super.fromParams(params, tp)
       resultType match {
         case rt: TypeAlias =>
@@ -3168,7 +3153,25 @@ object Types {
     }
   }
 
-  object HKTermLambda extends TermLambdaCompanion[HKTermLambda] {
+  object HKTypeLambda extends TypeLambdaCompanion[HKTypeLambda] with HKCompanion[TypeName, TypeBounds, HKTypeLambda] {
+    def apply(paramNames: List[TypeName])(
+        paramInfosExp: HKTypeLambda => List[TypeBounds],
+        resultTypeExp: HKTypeLambda => Type)(implicit ctx: Context): HKTypeLambda = {
+      unique(new HKTypeLambda(paramNames)(paramInfosExp, resultTypeExp))
+    }
+
+    def unapply(tl: HKTypeLambda): Some[(List[LambdaParam], Type)] =
+      Some((tl.typeParams, tl.resType))
+
+    def any(n: Int)(implicit ctx: Context) =
+      apply(syntheticParamNames(n))(
+        pt => List.fill(n)(TypeBounds.empty), pt => defn.AnyType)
+
+    override def paramName(param: ParamInfo.Of[TypeName])(implicit ctx: Context): TypeName =
+      param.paramName.withVariance(param.paramVariance)
+  }
+
+  object HKTermLambda extends TermLambdaCompanion[HKTermLambda] with HKCompanion[TermName, Type, HKTermLambda] {
     def apply(paramNames: List[TermName])(
         paramInfosExp: HKTermLambda => List[Type],
         resultTypeExp: HKTermLambda => Type)(implicit ctx: Context): HKTermLambda = {