Remove dropLast from toFunctionType

If needed, use `derivedLambdaType` to drop the last parameters before
converting to a function type.

Author: nicolasstucki

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

@@ -1874,22 +1874,19 @@ object Types {
     /** Turn type into a function type.
      *  @pre this is a method type without parameter dependencies.
      *  @param isJava          translate repeated params as as java `Array`s?
-     *  @param dropLast        the number of trailing parameters that should be dropped
-     *                         when forming the function type.
      *  @param alwaysDependent if true, always create a dependent function type.
      */
-    def toFunctionType(isJava: Boolean = false, dropLast: Int = 0, alwaysDependent: Boolean = false)(using Context): Type = this match {
+    def toFunctionType(isJava: Boolean = false, alwaysDependent: Boolean = false)(using Context): Type = this match {
       case mt: MethodType =>
         assert(!mt.isParamDependent)
         def nonDependentFunType =
-          val formals1 = if (dropLast == 0) mt.paramInfos else mt.paramInfos dropRight dropLast
           val isContextual = mt.isContextualMethod && !ctx.erasedTypes
           val result1 = mt.nonDependentResultApprox match {
             case res: MethodType => res.toFunctionType(isJava)
             case res => res
           }
           defn.FunctionOf(
-            formals1 mapConserve (_.translateFromRepeated(toArray = isJava)),
+            mt.paramInfos.mapConserve(_.translateFromRepeated(toArray = isJava)),
             result1, isContextual)
         if mt.hasErasedParams then
           defn.PolyFunctionOf(mt)

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

@@ -405,7 +405,17 @@ trait TypeAssigner {
 
   def assignType(tree: untpd.Closure, meth: Tree, target: Tree)(using Context): Closure =
     tree.withType(
-      if (target.isEmpty) meth.tpe.widen.toFunctionType(isJava = meth.symbol.is(JavaDefined), tree.env.length)
+      if target.isEmpty then
+        def methTypeWithoutEnv(info: Type): Type = info match
+          case mt: MethodType =>
+            val dropLast = tree.env.length
+            val paramNames = mt.paramNames.dropRight(dropLast)
+            val paramInfos = mt.paramInfos.dropRight(dropLast)
+            mt.derivedLambdaType(paramNames, paramInfos)
+          case pt: PolyType =>
+            pt.derivedLambdaType(resType = methTypeWithoutEnv(pt.resType))
+        val methodicType = if tree.env.isEmpty then meth.tpe.widen else methTypeWithoutEnv(meth.tpe.widen)
+        methodicType.toFunctionType(isJava = meth.symbol.is(JavaDefined))
       else target.tpe)
 
   def assignType(tree: untpd.CaseDef, pat: Tree, body: Tree)(using Context): CaseDef = {