Fix paramCount

Author: odersky

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

@@ -114,6 +114,22 @@ object Decorators {
         else x1 :: xs1
       }
 
+    /** Like `xs.lazyZip(xs.indices).map(f)`, but returns list `xs` itself
+     *  - instead of a copy - if function `f` maps all elements of
+     *  `xs` to themselves.
+     */
+    def mapWithIndexConserve[U](f: (T, Int) => T): List[T] =
+      def recur(xs: List[T], idx: Int): List[T] =
+        if xs.isEmpty then Nil
+        else
+          val x1 = f(xs.head, idx)
+          val xs1 = recur(xs.tail, idx + 1)
+          if (x1.asInstanceOf[AnyRef] eq xs.head.asInstanceOf[AnyRef])
+             && (xs1 eq xs.tail)
+          then xs
+          else x1 :: xs1
+      recur(xs, 0)
+
     final def hasSameLengthAs[U](ys: List[U]): Boolean = {
       @tailrec def loop(xs: List[T], ys: List[U]): Boolean =
         if (xs.isEmpty) ys.isEmpty

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

@@ -1656,27 +1656,39 @@ trait Applications extends Compatibility {
           alts.filter(sizeFits(_))
 
         def narrowByShapes(alts: List[TermRef]): List[TermRef] =
-        
+
           /** Normalization steps before shape-checking arguments:
            *
            *                 { expr }   -->   expr
            *    (x1, ..., xn) => expr   -->   ((x1, ..., xn)) => expr
-           *       if n > 1, no alternative takes `n` parameters,
-           *       and at least one alternative takes 1 parameter.
+           *       if n > 1, no alternative has a corresponding formal parameter that
+           *       is an n-ary function, and at least one alternative has a corresponding
+           *       formal parameter that is a unary function.
            */
-          def normArg(arg: untpd.Tree): untpd.Tree = arg match
-            case Block(Nil, expr) => normArg(expr)
-            case x @ untpd.Function(args, body) =>
+          def normArg(arg: untpd.Tree, idx: Int): untpd.Tree = arg match
+            case Block(Nil, expr) => normArg(expr, idx)
+            case untpd.Function(args, body) =>
+            
+              // If ref refers to a method whose parameter at index `idx` is a function type,
+              // the arity of that function, otherise 0.
+              def paramCount(ref: TermRef) =
+                val formals = ref.widen.firstParamTypes
+                if formals.length > idx then
+                  formals(idx) match
+                    case defn.FunctionOf(args, _, _, _) => args.length
+                    case _ => 0
+                else 0
+                
               val numArgs = args.length
-              def paramCount(ref: TermRef) = ref.widen.firstParamTypes.length
               if numArgs > 1
                  && !alts.exists(paramCount(_) == numArgs)
                  && alts.exists(paramCount(_) == 1)
               then untpd.Function(untpd.Tuple(args) :: Nil, body)
               else arg
             case _ => arg
-
-          val normArgs = args.mapConserve(normArg)
+          end normArg
+          
+          val normArgs = args.mapWithIndexConserve(normArg)
           if (normArgs exists untpd.isFunctionWithUnknownParamType)
             if (hasNamedArg(args)) narrowByTrees(alts, args map treeShape, resultType)
             else narrowByTypes(alts, normArgs map typeShape, resultType)