Extract unapply types like typedUnApply

Inside typedUnApply, argTypes depend on the result of applying the
unapply function (unapplyFn) on a "dummy arg", which results in calling
"safeSubstParams" (while constructing the tpd.Apply) instead of just
calling MethodType#instantiate.

Not doing the same thing in SpaceEngine#signature results in different
types that don't cancel each other, so we make SpaceEngine follow
Typer/Applications/TypeAssigner.

Author: dwijnand

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -556,7 +556,7 @@ class SpaceEngine(using Context) extends SpaceLogic {
     // Case unapplySeq:
     // 1. return the type `List[T]` where `T` is the element type of the unapplySeq return type `Seq[T]`
 
-    val resTp = mt.instantiate(scrutineeTp :: Nil).finalResultType
+    val resTp = ctx.typeAssigner.safeSubstMethodParams(mt, scrutineeTp :: Nil).finalResultType
 
     val sig =
       if (resTp.isRef(defn.BooleanClass))

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

@@ -279,12 +279,15 @@ trait TypeAssigner {
       tp
   }
 
+  def safeSubstMethodParams(mt: MethodType, argTypes: List[Type])(using Context): Type =
+    if mt.isResultDependent then safeSubstParams(mt.resultType, mt.paramRefs, argTypes)
+    else mt.resultType
+
   def assignType(tree: untpd.Apply, fn: Tree, args: List[Tree])(using Context): Apply = {
     val ownType = fn.tpe.widen match {
       case fntpe: MethodType =>
         if (sameLength(fntpe.paramInfos, args) || ctx.phase.prev.relaxedTyping)
-          if (fntpe.isResultDependent) safeSubstParams(fntpe.resultType, fntpe.paramRefs, args.tpes)
-          else fntpe.resultType
+          safeSubstMethodParams(fntpe, args.tpes)
         else
           errorType(i"wrong number of arguments at ${ctx.phase.prev} for $fntpe: ${fn.tpe}, expected: ${fntpe.paramInfos.length}, found: ${args.length}", tree.srcPos)
       case t =>

tests/pos/i15226.scala

@@ -0,0 +1,12 @@
+// scalac: -Werror
+class Proj { type State = String }
+
+sealed trait ProjState:
+  val a: Proj
+  val b: a.State
+
+object ProjState:
+  def unapply(pj: ProjState): Some[(pj.a.type, pj.b.type)] = Some((pj.a, pj.b))
+
+def test(pj: ProjState) = pj match
+  case ProjState(p, s) =>