Fix #8997: Support multiple contextual parameter blocks on unapply

Author: nicolasstucki

compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala

@@ -378,9 +378,16 @@ object PatternMatcher {
             // This plan will never execute because it'll be guarded by a `NonNullTest`.
             ResultPlan(tpd.Throw(tpd.nullLiteral))
           else {
+            def applyImplicits(acc: Tree, implicits: List[Tree], mt: Type): Tree = mt match {
+              case mt: MethodType =>
+                assert(mt.isImplicitMethod || mt.isContextualMethod)
+                val (args, rest) = implicits.splitAt(mt.paramNames.size)
+                applyImplicits(acc.appliedToArgs(args), rest, mt.resultType)
+              case _ => acc
+            }
             val mt @ MethodType(_) = extractor.tpe.widen
-            var unapp = extractor.appliedTo(ref(scrutinee).ensureConforms(mt.paramInfos.head))
-            if (implicits.nonEmpty) unapp = unapp.appliedToArgs(implicits)
+            val unapp0 = extractor.appliedTo(ref(scrutinee).ensureConforms(mt.paramInfos.head))
+            val unapp = applyImplicits(unapp0, implicits, mt.resultType)
             unapplyPlan(unapp, args)
           }
           if (scrutinee.info.isNotNull || nonNull(scrutinee)) unappPlan

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

@@ -1226,14 +1226,18 @@ trait Applications extends Compatibility {
           }
         val dummyArg = dummyTreeOfType(ownType)
         val unapplyApp = typedExpr(untpd.TypedSplice(Apply(unapplyFn, dummyArg :: Nil)))
-        def unapplyImplicits(unapp: Tree): List[Tree] = unapp match {
-          case Apply(Apply(unapply, `dummyArg` :: Nil), args2) => assert(args2.nonEmpty); args2
-          case Apply(unapply, `dummyArg` :: Nil) => Nil
-          case Inlined(u, _, _) => unapplyImplicits(u)
-          case DynamicUnapply(_) =>
-            ctx.error("Structural unapply is not supported", unapplyFn.sourcePos)
-            Nil
-          case _ => Nil.assertingErrorsReported
+        def unapplyImplicits(unapp: Tree): List[List[Tree]] = {
+          val res = List.newBuilder[List[Tree]]
+          def loop(unapp: Tree): Unit = unapp match {
+            case Apply(Apply(unapply, `dummyArg` :: Nil), args2) => assert(args2.nonEmpty); res += args2
+            case Apply(unapply, `dummyArg` :: Nil) =>
+            case Inlined(u, _, _) => loop(u)
+            case DynamicUnapply(_) => ctx.error("Structural unapply is not supported", unapplyFn.sourcePos)
+            case Apply(fn, args) => assert(args.nonEmpty); loop(fn); res += args
+            case _ => ().assertingErrorsReported
+          }
+          loop(unapp)
+          res.result()
         }
 
         var argTypes = unapplyArgs(unapplyApp.tpe, unapplyFn, args, tree.sourcePos)
@@ -1250,7 +1254,7 @@ trait Applications extends Compatibility {
             List.fill(argTypes.length - args.length)(WildcardType)
         }
         val unapplyPatterns = bunchedArgs.lazyZip(argTypes) map (typed(_, _))
-        val result = assignType(cpy.UnApply(tree)(unapplyFn, unapplyImplicits(unapplyApp), unapplyPatterns), ownType)
+        val result = assignType(cpy.UnApply(tree)(unapplyFn, unapplyImplicits(unapplyApp).flatten, unapplyPatterns), ownType)
         unapp.println(s"unapply patterns = $unapplyPatterns")
         if ((ownType eq selType) || ownType.isError) result
         else tryWithClassTag(Typed(result, TypeTree(ownType)), selType)

tests/pos/i8997.scala

@@ -0,0 +1,7 @@
+object Foo:
+  def unapply(n: Int)(using x: DummyImplicit)(using y: Int): Option[Int] = ???
+
+def test =
+  given Int = 3
+  1 match
+    case Foo(_) =>