replace derived{Method,Poly}Type with derivedLambdaType

17 files changed, 34 insertions, 45 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) =
diff --git a/compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala b/compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala
index 25c01c1f7..48be02fa1 100644
--- a/compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala
@@ -46,7 +46,7 @@ class ElimErasedValueType extends MiniPhaseTransform with InfoTransformer {
     case tp: MethodType =>
       val paramTypes = tp.paramInfos.mapConserve(elimEVT)
       val retType = elimEVT(tp.resultType)
-      tp.derivedMethodType(tp.paramNames, paramTypes, retType)
+      tp.derivedLambdaType(tp.paramNames, paramTypes, retType)
     case _ =>
       tp
   }
diff --git a/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala b/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala
index bc2674a77..683c8ac38 100644
--- a/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala
@@ -55,9 +55,9 @@ class ElimRepeated extends MiniPhaseTransform with InfoTransformer with Annotati
           val last = paramTypes.last.underlyingIfRepeated(tp.isJava)
           paramTypes.init :+ last
         } else paramTypes
-      tp.derivedMethodType(paramNames, paramTypes1, resultType1)
+      tp.derivedLambdaType(paramNames, paramTypes1, resultType1)
     case tp: PolyType =>
-      tp.derivedPolyType(tp.paramNames, tp.paramInfos, elimRepeated(tp.resultType))
+      tp.derivedLambdaType(tp.paramNames, tp.paramInfos, elimRepeated(tp.resultType))
     case tp =>
       tp
   }
@@ -139,10 +139,10 @@ class ElimRepeated extends MiniPhaseTransform with InfoTransformer with Annotati
   /** Convert type from Scala to Java varargs method */
   private def toJavaVarArgs(tp: Type)(implicit ctx: Context): Type = tp match {
     case tp: PolyType =>
-      tp.derivedPolyType(tp.paramNames, tp.paramInfos, toJavaVarArgs(tp.resultType))
+      tp.derivedLambdaType(tp.paramNames, tp.paramInfos, toJavaVarArgs(tp.resultType))
     case tp: MethodType =>
       val inits :+ last = tp.paramInfos
       val last1 = last.underlyingIfRepeated(isJava = true)
-      tp.derivedMethodType(tp.paramNames, inits :+ last1, tp.resultType)
+      tp.derivedLambdaType(tp.paramNames, inits :+ last1, tp.resultType)
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala b/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala
index f17808e62..a6e643992 100644
--- a/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala
@@ -331,7 +331,7 @@ object ExplicitOuter {
     def addParam(cls: ClassSymbol, tp: Type): Type =
       if (hasOuterParam(cls)) {
         val mt @ MethodTpe(pnames, ptypes, restpe) = tp
-        mt.derivedMethodType(
+        mt.derivedLambdaType(
           nme.OUTER :: pnames, cls.owner.enclosingClass.typeRef :: ptypes, restpe)
       } else tp
 
diff --git a/compiler/src/dotty/tools/dotc/transform/FullParameterization.scala b/compiler/src/dotty/tools/dotc/transform/FullParameterization.scala
index 0b9ec9085..d76a41946 100644
--- a/compiler/src/dotty/tools/dotc/transform/FullParameterization.scala
+++ b/compiler/src/dotty/tools/dotc/transform/FullParameterization.scala
@@ -256,7 +256,7 @@ object FullParameterization {
     case MethodTpe(nme.SELF :: Nil, _, restpe) =>
       restpe.ensureMethodic.signature
     case info @ MethodTpe(nme.SELF :: otherNames, thisType :: otherTypes, restpe) =>
-      info.derivedMethodType(otherNames, otherTypes, restpe).signature
+      info.derivedLambdaType(otherNames, otherTypes, restpe).signature
     case _ =>
       Signature.NotAMethod
   }
diff --git a/compiler/src/dotty/tools/dotc/transform/ShortcutImplicits.scala b/compiler/src/dotty/tools/dotc/transform/ShortcutImplicits.scala
index b5469610f..1a530b95c 100644
--- a/compiler/src/dotty/tools/dotc/transform/ShortcutImplicits.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ShortcutImplicits.scala
@@ -82,8 +82,8 @@ class ShortcutImplicits extends MiniPhase with IdentityDenotTransformer { thisTr
      *  @return The type of the `apply` member of `implicit Ts => R`.
      */
     private def directInfo(info: Type)(implicit ctx: Context): Type = info match {
-      case info: PolyType   => info.derivedPolyType(resType = directInfo(info.resultType))
-      case info: MethodType => info.derivedMethodType(resType = directInfo(info.resultType))
+      case info: PolyType   => info.derivedLambdaType(resType = directInfo(info.resultType))
+      case info: MethodType => info.derivedLambdaType(resType = directInfo(info.resultType))
       case info: ExprType   => directInfo(info.resultType)
       case info             => info.member(nme.apply).info
     }
diff --git a/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala b/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala
index 102b492a8..728c1696b 100644
--- a/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala
+++ b/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala
@@ -178,7 +178,7 @@ class SuperAccessors(thisTransformer: DenotTransformer) {
       val accType = {
         def accTypeOf(tpe: Type): Type = tpe match {
           case tpe: PolyType =>
-            tpe.derivedPolyType(tpe.paramNames, tpe.paramInfos, accTypeOf(tpe.resultType))
+            tpe.derivedLambdaType(tpe.paramNames, tpe.paramInfos, accTypeOf(tpe.resultType))
           case _ =>
             MethodType(receiverType :: Nil)(mt => tpe.substThis(sym.owner.asClass, mt.newParamRef(0)))
         }
@@ -230,7 +230,7 @@ class SuperAccessors(thisTransformer: DenotTransformer) {
         else clazz.classInfo.selfType
       def accTypeOf(tpe: Type): Type = tpe match {
         case tpe: PolyType =>
-          tpe.derivedPolyType(tpe.paramNames, tpe.paramInfos, accTypeOf(tpe.resultType))
+          tpe.derivedLambdaType(tpe.paramNames, tpe.paramInfos, accTypeOf(tpe.resultType))
         case _ =>
           MethodType(receiverType :: Nil)(mt => tpe.substThis(sym.owner.asClass, mt.newParamRef(0)))
       }
diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
index ceaf3471a..236bc051e 100644
--- a/compiler/src/dotty/tools/dotc/typer/Applications.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -1125,7 +1125,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
       case mt: ImplicitMethodType =>
         resultTypeApprox(mt)
       case pt: PolyType =>
-        pt.derivedPolyType(pt.paramNames, pt.paramInfos, stripImplicit(pt.resultType))
+        pt.derivedLambdaType(pt.paramNames, pt.paramInfos, stripImplicit(pt.resultType))
       case _ =>
         tp
     }
diff --git a/compiler/src/dotty/tools/dotc/typer/ErrorReporting.scala b/compiler/src/dotty/tools/dotc/typer/ErrorReporting.scala
index 5f9eae3da..5063a111c 100644
--- a/compiler/src/dotty/tools/dotc/typer/ErrorReporting.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ErrorReporting.scala
@@ -105,7 +105,7 @@ object ErrorReporting {
     def whyNoMatchStr(found: Type, expected: Type) = {
       def dropJavaMethod(tp: Type): Type = tp match {
         case tp: PolyType =>
-          tp.derivedPolyType(resType = dropJavaMethod(tp.resultType))
+          tp.derivedLambdaType(resType = dropJavaMethod(tp.resultType))
         case tp: JavaMethodType =>
           MethodType(tp.paramNames, tp.paramInfos, dropJavaMethod(tp.resultType))
         case tp => tp
diff --git a/compiler/src/dotty/tools/dotc/typer/Inliner.scala b/compiler/src/dotty/tools/dotc/typer/Inliner.scala
index cf3076fce..6ef6c12cc 100644
--- a/compiler/src/dotty/tools/dotc/typer/Inliner.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Inliner.scala
@@ -108,7 +108,7 @@ object Inliner {
 
             // Add qualifier type as leading method argument to argument `tp`
             def addQualType(tp: Type): Type = tp match {
-              case tp: PolyType => tp.derivedPolyType(tp.paramNames, tp.paramInfos, addQualType(tp.resultType))
+              case tp: PolyType => tp.derivedLambdaType(tp.paramNames, tp.paramInfos, addQualType(tp.resultType))
               case tp: ExprType => addQualType(tp.resultType)
               case tp => MethodType(qualType :: Nil, tp)
             }
diff --git a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
index 2dccbbcc1..a27175abd 100644
--- a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
@@ -444,7 +444,7 @@ object ProtoTypes {
           val rt = normalize(mt.resultType, pt)
           pt match {
             case pt: IgnoredProto  => mt
-            case pt: ApplyingProto => mt.derivedMethodType(mt.paramNames, mt.paramInfos, rt)
+            case pt: ApplyingProto => mt.derivedLambdaType(mt.paramNames, mt.paramInfos, rt)
             case _ =>
               val ft = defn.FunctionOf(mt.paramInfos, rt)
               if (mt.paramInfos.nonEmpty || ft <:< pt) ft else rt
diff --git a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
index ed71f2239..14d4f315d 100644
--- a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
+++ b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
@@ -366,7 +366,7 @@ trait TypeAssigner {
           if (gapBuf.isEmpty) resultType1
           else {
             val gaps = gapBuf.toList
-            pt.derivedPolyType(
+            pt.derivedLambdaType(
               gaps.map(paramNames),
               gaps.map(idx => transform(pt.paramInfos(idx)).bounds),
               resultType1)