Support implicit arguments before extractor method (#18671)

Currently the global object initialization checker crashes when
encountering implicit arguments in extractor methods that are before
scrutinee. This PR fixes the issue and adds tests with implicit
arguments before scrutinee for `unapply` and `unapplySeq` respectively.

compiler/src/dotty/tools/dotc/transform/init/Objects.scala

@@ -1305,9 +1305,14 @@ object Objects:
           case select: Select =>
             eval(select.qualifier, thisV, klass)
 
-        val implicitValues = evalArgs(implicits.map(Arg.apply), thisV, klass)
-        // TODO: implicit values may appear before and/or after the scrutinee parameter.
-        val unapplyRes = call(receiver, funRef.symbol, TraceValue(scrutinee, summon[Trace]) :: implicitValues, funRef.prefix, superType = NoType, needResolve = true)
+        def implicitArgsBeforeScrutinee(fun: Tree): Contextual[List[ArgInfo]] = fun match
+          case Apply(f, implicitArgs) =>
+            implicitArgsBeforeScrutinee(f) ++ evalArgs(implicitArgs.map(Arg.apply), thisV, klass)
+          case _ => List()
+
+        val implicitArgsAfterScrutinee = evalArgs(implicits.map(Arg.apply), thisV, klass)
+        val args = implicitArgsBeforeScrutinee(fun) ++ (TraceValue(scrutinee, summon[Trace]) :: implicitArgsAfterScrutinee)
+        val unapplyRes = call(receiver, funRef.symbol, args, funRef.prefix, superType = NoType, needResolve = true)
 
         if fun.symbol.name == nme.unapplySeq then
           var resultTp = unapplyResTp

tests/init-global/neg/unapply-implicit-arg.scala

@@ -0,0 +1,14 @@
+object Bar {
+  class Foo {
+    def m1(i: Int) = i+1
+    def m2(i: Int) = i+2
+  }
+  def unapply(using f1: Foo)(i: Int): Option[Int] =
+    if i == 0 then Some(f1.m1(i)) else Some(f1.m2(i))
+
+  given Foo = new Foo
+  val i1: Int = 0
+  val i2: Int = i2 match // error
+    case Bar(i) => i
+    case _ => 0
+}

tests/init-global/neg/unapply-implicit-arg2.scala

@@ -0,0 +1,14 @@
+object Bar {
+  class Foo {
+    def m1(i: Int) = i+1
+    def m2(i: Int) = i+2
+  }
+  def unapply(using f1: Foo)(i: Int): Option[Int] =
+    if i == 0 then Some(f1.m1(i1)) else Some(f1.m2(i2)) // error
+
+  given Foo = new Foo
+  val i1: Int = 0
+  val i2: Int = i1 match
+    case Bar(i) => i
+    case _ => 0
+}

tests/init-global/neg/unapply-implicit-arg3.scala

@@ -0,0 +1,14 @@
+object Bar {
+  class Foo {
+    def m1(i: Int) = i + i1
+    def m2(i: Int) = i + i2 // error
+  }
+  def unapply(using f1: Foo)(i: Int): Option[Int] =
+    if i == 0 then Some(f1.m1(i)) else Some(f1.m2(i))
+
+  given Foo = new Foo
+  val i1: Int = 0
+  val i2: Int = i1 match
+    case Bar(i) => i
+    case _ => 0
+}

tests/init-global/neg/unapplySeq-implicit-arg.scala

@@ -0,0 +1,14 @@
+object Bar {
+  class Foo {
+    def m1(seq: Seq[Int]) = 1 +: seq
+    def m2(seq: Seq[Int]) = 2 +: seq
+  }
+  def unapplySeq(using f1: Foo)(seqi: Seq[Int]): Option[Seq[Int]] =
+    if seqi(0) == 0 then Some(f1.m1(seqi)) else Some(f1.m2(seqi))
+
+  given Foo = new Foo
+  val i1: Int = 0
+  val i2: Int = Seq(i2) match // error
+    case Bar(i) => i
+    case _ => 0
+}

tests/init-global/neg/unapplySeq-implicit-arg2.scala

@@ -0,0 +1,10 @@
+object Bar {
+  class Foo
+  def unapplySeq(using f1: Foo)(using f2: Foo)(seqi: Seq[Int])(using Foo): Option[Seq[Int]] =
+    Some(i1 +: seqi) // error
+  given Foo = new Foo
+  val i1: Int = Seq(0) match {
+    case Bar(i) => i
+    case _ => 0
+  }
+}

tests/init-global/neg/unapplySeq-implicit-arg3.scala

@@ -0,0 +1,12 @@
+object Bar {
+  class Foo {
+    def m(seq: Seq[Int]) = i1 +: seq // error
+  }
+  def unapplySeq(using f1: Foo)(seqi: Seq[Int])(using Foo): Option[Seq[Int]] =
+    Some(f1.m(seqi))
+  given Foo = new Foo
+  val i1: Int = Seq(0) match {
+    case Bar(i, _) => i
+    case _ => 0
+  }
+}

tests/init-global/pos/unapply-implicit-arg-pos.scala

@@ -0,0 +1,14 @@
+object Bar {
+  class Foo {
+    def m1(i: Int) = i + i1
+    def m2(i: Int) = i + 2
+  }
+  def unapply(using f1: Foo)(using f2: Foo)(i: Int)(using f3: Foo): Option[Int] =
+    if i == 0 then Some(f1.m1(i1) + f3.m1(i1)) else Some(f2.m2(i) + f3.m2(i))
+
+  given Foo = new Foo
+  val i1: Int = 0
+  val i2: Int = i1 match
+    case Bar(i) => i
+    case _ => 0
+}

tests/init-global/pos/unapplySeq-implicit-arg-pos.scala

@@ -0,0 +1,14 @@
+object Bar {
+  class Foo {
+    def m1(seq: Seq[Int]) = 0 +: seq
+    def m2(seq: Seq[Int]) = i1 +: seq
+  }
+  def unapplySeq(using f1: Foo)(using f2: Foo)(seqi: Seq[Int])(using f3: Foo): Option[Seq[Int]] =
+    if seqi(0) == 0 then Some(f1.m1(seqi)) else Some(f2.m2(seqi))
+
+  given Foo = new Foo
+  val i1: Int = 0
+  val i2: Int = Seq(i1) match
+    case Bar(i) => i
+    case _ => 0
+}