replace derived{Method,Poly}Type with derivedLambdaType

6 files changed, 18 insertions, 29 deletions

diff --git a/compiler/src/dotty/tools/dotc/core/Denotations.scala b/compiler/src/dotty/tools/dotc/core/Denotations.scala
index 1d7b3c94c..7e552eda9 100644
--- a/compiler/src/dotty/tools/dotc/core/Denotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/Denotations.scala
@@ -312,7 +312,7 @@ object Denotations {
             tp2 match {
               case tp2: MethodType if ctx.typeComparer.matchingParams(tp1.paramInfos, tp2.paramInfos, tp1.isJava, tp2.isJava) &&
                 tp1.isImplicit == tp2.isImplicit =>
-                tp1.derivedMethodType(
+                tp1.derivedLambdaType(
                   mergeNames(tp1.paramNames, tp2.paramNames, nme.syntheticParamName),
                   tp1.paramInfos,
                   infoMeet(tp1.resultType, tp2.resultType.subst(tp2, tp1)))
@@ -322,7 +322,7 @@ object Denotations {
           case tp1: PolyType if isTerm =>
             tp2 match {
               case tp2: PolyType if ctx.typeComparer.matchingTypeParams(tp1, tp2) =>
-                tp1.derivedPolyType(
+                tp1.derivedLambdaType(
                   mergeNames(tp1.paramNames, tp2.paramNames, tpnme.syntheticTypeParamName),
                   tp1.paramInfos,
                   infoMeet(tp1.resultType, tp2.resultType.subst(tp2, tp1)))
@@ -476,7 +476,7 @@ object Denotations {
             case tp2: MethodType
             if ctx.typeComparer.matchingParams(tp1.paramInfos, tp2.paramInfos, tp1.isJava, tp2.isJava) &&
               tp1.isImplicit == tp2.isImplicit =>
-              tp1.derivedMethodType(
+              tp1.derivedLambdaType(
                 mergeNames(tp1.paramNames, tp2.paramNames, nme.syntheticParamName),
                 tp1.paramInfos, tp1.resultType | tp2.resultType.subst(tp2, tp1))
             case _ =>
@@ -485,7 +485,7 @@ object Denotations {
         case tp1: PolyType =>
           tp2 match {
             case tp2: PolyType if ctx.typeComparer.matchingTypeParams(tp1, tp2) =>
-              tp1.derivedPolyType(
+              tp1.derivedLambdaType(
                 mergeNames(tp1.paramNames, tp2.paramNames, tpnme.syntheticTypeParamName),
                 tp1.paramInfos, tp1.resultType | tp2.resultType.subst(tp2, tp1))
             case _ =>
diff --git a/compiler/src/dotty/tools/dotc/core/TypeApplications.scala b/compiler/src/dotty/tools/dotc/core/TypeApplications.scala
index 77767a38c..3a63c16db 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeApplications.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeApplications.scala
@@ -429,7 +429,7 @@ class TypeApplications(val self: Type) extends AnyVal {
               // In this case we should always dealias since we cannot handle
               // higher-kinded applications to wildcard arguments.
               dealiased
-                .derivedPolyType(resType = tycon.safeDealias.appliedTo(args1))
+                .derivedLambdaType(resType = tycon.safeDealias.appliedTo(args1))
                 .appliedTo(args)
             case _ =>
               val reducer = new Reducer(dealiased, args)
diff --git a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
index 07d613c57..8ff0be9d7 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
@@ -176,7 +176,7 @@ object TypeErasure {
     val erase = erasureFn(isJava, semiEraseVCs, sym.isConstructor, wildcardOK = false)
 
     def eraseParamBounds(tp: PolyType): Type =
-      tp.derivedPolyType(
+      tp.derivedLambdaType(
         tp.paramNames, tp.paramNames map (Function.const(TypeBounds.upper(defn.ObjectType))), tp.resultType)
 
     if (defn.isPolymorphicAfterErasure(sym)) eraseParamBounds(sym.info.asInstanceOf[PolyType])
@@ -385,9 +385,9 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
       val formals = tp.paramInfos.mapConserve(paramErasure)
       eraseResult(tp.resultType) match {
         case rt: MethodType =>
-          tp.derivedMethodType(tp.paramNames ++ rt.paramNames, formals ++ rt.paramInfos, rt.resultType)
+          tp.derivedLambdaType(tp.paramNames ++ rt.paramNames, formals ++ rt.paramInfos, rt.resultType)
         case rt =>
-          tp.derivedMethodType(tp.paramNames, formals, rt)
+          tp.derivedLambdaType(tp.paramNames, formals, rt)
       }
     case tp @ ClassInfo(pre, cls, classParents, decls, _) =>
       if (cls is Package) tp
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index 49fc825ca..074d2e1fb 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -2524,11 +2524,6 @@ object Types {
     override def computeSignature(implicit ctx: Context): Signature =
       resultSignature.prepend(paramInfos, isJava)
 
-    def derivedMethodType(paramNames: List[TermName] = this.paramNames,
-                          paramInfos: List[Type] = this.paramInfos,
-                          resType: Type = this.resType)(implicit ctx: Context) =
-      derivedLambdaType(paramNames, paramInfos, resType)
-
     protected def prefixString = "MethodType"
   }
 
@@ -2697,11 +2692,6 @@ object Types {
 
     override def underlying(implicit ctx: Context) = resType
 
-    def derivedPolyType(paramNames: List[TypeName] = this.paramNames,
-                        paramInfos: List[TypeBounds] = this.paramInfos,
-                        resType: Type = this.resType)(implicit ctx: Context) =
-      derivedLambdaType(paramNames, paramInfos, resType)
-
     /** Merge nested polytypes into one polytype. nested polytypes are normally not supported
      *  but can arise as temporary data structures.
      */
@@ -3467,12 +3457,11 @@ object Types {
       tp.derivedClassInfo(pre)
     protected def derivedJavaArrayType(tp: JavaArrayType, elemtp: Type): Type =
       tp.derivedJavaArrayType(elemtp)
-    protected def derivedMethodType(tp: MethodType, formals: List[Type], restpe: Type): Type =
-      tp.derivedMethodType(tp.paramNames, formals, restpe)
     protected def derivedExprType(tp: ExprType, restpe: Type): Type =
       tp.derivedExprType(restpe)
-    protected def derivedPolyType(tp: PolyType, pbounds: List[TypeBounds], restpe: Type): Type =
-      tp.derivedPolyType(tp.paramNames, pbounds, restpe)
+    // note: currying needed  because Scala2 does not support param-dependencies
+    protected def derivedLambdaType(tp: LambdaType)(formals: List[tp.PInfo], restpe: Type): Type =
+      tp.derivedLambdaType(tp.paramNames, formals, restpe)
 
     /** Map this function over given type */
     def mapOver(tp: Type): Type = {
@@ -3507,7 +3496,7 @@ object Types {
             variance = -variance
             val ptypes1 = tp.paramInfos mapConserve this
             variance = -variance
-            derivedMethodType(tp, ptypes1, this(tp.resultType))
+            derivedLambdaType(tp)(ptypes1, this(tp.resultType))
           }
           mapOverMethod
 
@@ -3519,7 +3508,7 @@ object Types {
             variance = -variance
             val bounds1 = tp.paramInfos.mapConserve(this).asInstanceOf[List[TypeBounds]]
             variance = -variance
-            derivedPolyType(tp, bounds1, this(tp.resultType))
+            derivedLambdaType(tp)(bounds1, this(tp.resultType))
           }
           mapOverPoly
 
diff --git a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
index 2bb929bf3..da875c906 100644
--- a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
+++ b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
@@ -199,7 +199,7 @@ class ClassfileParser(
         def stripOuterParamFromConstructor() = innerClasses.get(currentClassName) match {
           case Some(entry) if !isStatic(entry.jflags) =>
             val mt @ MethodTpe(paramNames, paramTypes, resultType) = denot.info
-            denot.info = mt.derivedMethodType(paramNames.tail, paramTypes.tail, resultType)
+            denot.info = mt.derivedLambdaType(paramNames.tail, paramTypes.tail, resultType)
           case _ =>
         }
 
@@ -209,7 +209,7 @@ class ClassfileParser(
         def normalizeConstructorInfo() = {
           val mt @ MethodType(paramNames) = denot.info
           val rt = classRoot.typeRef appliedTo (classRoot.typeParams map (_.typeRef))
-          denot.info = mt.derivedMethodType(paramNames, mt.paramInfos, rt)
+          denot.info = mt.derivedLambdaType(paramNames, mt.paramInfos, rt)
           addConstructorTypeParams(denot)
         }
 
@@ -975,7 +975,7 @@ class ClassfileParser(
         if (name == nme.CONSTRUCTOR)
           tpe match {
             case tp: MethodType =>
-              tp.derivedMethodType(tp.paramNames, tp.paramInfos, ownerTpe)
+              tp.derivedLambdaType(tp.paramNames, tp.paramInfos, ownerTpe)
           }
         p = (name, tpe)
         values(index) = p
diff --git a/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala b/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
index fad516da7..d34bc240f 100644
--- a/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
@@ -65,12 +65,12 @@ object Scala2Unpickler {
         case _ =>
           elemtp0
       }
-      tp.derivedMethodType(
+      tp.derivedLambdaType(
         tp.paramNames,
         tp.paramInfos.init :+ defn.RepeatedParamType.appliedTo(elemtp),
         tp.resultType)
     case tp: PolyType =>
-      tp.derivedPolyType(tp.paramNames, tp.paramInfos, arrayToRepeated(tp.resultType))
+      tp.derivedLambdaType(tp.paramNames, tp.paramInfos, arrayToRepeated(tp.resultType))
   }
 
   def ensureConstructor(cls: ClassSymbol, scope: Scope)(implicit ctx: Context) =