Allow pattern matching anonymous functions of arity > 1

src/dotty/tools/dotc/ast/Desugar.scala

@@ -556,14 +556,20 @@ object desugar {
       DefDef(nme.ANON_FUN, Nil, params :: Nil, tpt, body).withMods(synthetic),
       Closure(Nil, Ident(nme.ANON_FUN), EmptyTree))
 
-  /** Expand partial function
+  /** If `nparams` == 1, expand partial function
+   *
    *       { cases }
    *  ==>
-   *       x$0 => x$0 match { cases }
+   *       x$1 => x$1 match { cases }
+   *
+   *  If `nparams` != 1, expand instead to
+   *
+   *       (x$1, ..., x$n) => (x$0, ..., x${n-1}) match { cases }
    */
-  def makeCaseLambda(cases: List[CaseDef])(implicit ctx: Context) = {
-    val param = makeSyntheticParameter()
-    Function(param :: Nil, Match(Ident(param.name), cases))
+  def makeCaseLambda(cases: List[CaseDef], nparams: Int = 1)(implicit ctx: Context) = {
+    val params = (1 to nparams).toList.map(makeSyntheticParameter(_))
+    val selector = makeTuple(params.map(p => Ident(p.name)))
+    Function(params, Match(selector, cases))
   }
 
   /** Add annotation with class `cls` to tree:

src/dotty/tools/dotc/typer/Typer.scala

@@ -502,22 +502,24 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     assignType(cpy.If(tree)(cond1, thenp2, elsep2), thenp2, elsep2)
   }
 
+  private def decomposeProtoFunction(pt: Type, defaultArity: Int)(implicit ctx: Context): (List[Type], Type) = pt match {
+    case _ if defn.isFunctionType(pt) =>
+      (pt.dealias.argInfos.init, pt.dealias.argInfos.last)
+    case SAMType(meth) =>
+      val mt @ MethodType(_, paramTypes) = meth.info
+      (paramTypes, mt.resultType)
+    case _ =>
+      (List.range(0, defaultArity) map alwaysWildcardType, WildcardType)
+  }
+
   def typedFunction(tree: untpd.Function, pt: Type)(implicit ctx: Context) = track("typedFunction") {
     val untpd.Function(args, body) = tree
     if (ctx.mode is Mode.Type)
       typed(cpy.AppliedTypeTree(tree)(
         untpd.TypeTree(defn.FunctionClass(args.length).typeRef), args :+ body), pt)
     else {
       val params = args.asInstanceOf[List[untpd.ValDef]]
-      val (protoFormals, protoResult): (List[Type], Type) = pt match {
-        case _ if defn.isFunctionType(pt) =>
-          (pt.dealias.argInfos.init, pt.dealias.argInfos.last)
-        case SAMType(meth) =>
-          val mt @ MethodType(_, paramTypes) = meth.info
-          (paramTypes, mt.resultType)
-        case _ =>
-          (params map alwaysWildcardType, WildcardType)
-      }
+      val (protoFormals, protoResult) = decomposeProtoFunction(pt, params.length)
 
       def refersTo(arg: untpd.Tree, param: untpd.ValDef): Boolean = arg match {
         case Ident(name) => name == param.name
@@ -629,7 +631,8 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   def typedMatch(tree: untpd.Match, pt: Type)(implicit ctx: Context) = track("typedMatch") {
     tree.selector match {
       case EmptyTree =>
-        typed(desugar.makeCaseLambda(tree.cases) withPos tree.pos, pt)
+        val (protoFormals, _) = decomposeProtoFunction(pt, 1)
+        typed(desugar.makeCaseLambda(tree.cases, protoFormals.length) withPos tree.pos, pt)
       case _ =>
         val sel1 = typedExpr(tree.selector)
         val selType = widenForMatchSelector(

tests/pos/i873.scala

@@ -0,0 +1,10 @@
+object Test {
+  def call(k: (Int, Int) => Unit): Unit = ???
+  def test = call({ case (x, y) => ()})
+
+  trait X extends Function1[Int, String]
+  implicit def f2x(f: Function1[Int, String]): X = ???
+  ({case _ if "".isEmpty => ""} : X) // allowed, implicit view used to adapt
+
+  // ({case _ if "".isEmpty => 0} : X) // expected String, found Int
+}