support GADT reasoning on aliases for nested pattern

Author: Linyxus

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

@@ -677,11 +677,15 @@ final class ProperGadtConstraint private(
 
       updateMappings()
       updateUnionFind()
+      myPatternSkolem = null
   end supplyPatternPath
 
   override def createPatternSkolem(pat: Type): SkolemType =
-    myPatternSkolem = SkolemType(pat)
-    myPatternSkolem.nn
+    if myPatternSkolem ne null then
+      SkolemType(pat)
+    else
+      myPatternSkolem = SkolemType(pat)
+      myPatternSkolem.nn
   end createPatternSkolem
 
   override def withScrutineePath[T](path: TermRef | Null)(op: => T): T =

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

@@ -1754,10 +1754,10 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       sel.tpe match {
         case p: TermRef =>
           tree.pat match {
-            case _: Trees.Typed[_] => p
-            case _: Trees.Ident[_] => p
-            case _: Trees.Apply[_] => p
-            case _ => null
+            case _: (Trees.Typed[_] | Trees.Ident[_] | Trees.Apply[_] | Trees.Bind[_]) =>
+              p
+            case _ =>
+              null
           }
         case _ => null
       }

tests/neg/pdgadt-nested-pat-alias.scala

@@ -0,0 +1,12 @@
+trait Expr { type T }
+case class B(b: Int) extends Expr { type T = Int }
+case class C(c: Boolean) extends Expr { type T = Boolean }
+case class A(a: Expr, b: Expr) extends Expr { type T = (a.T, b.T) }
+
+def foo(e: Expr) = e match
+  case e1 @ A(b1 @ B(b), c1 @ C(c)) =>
+    val t1: e1.type = e
+    val t2: e.type = e1
+
+    val t3: b1.type = e  // error
+    val t4: c1.type = e  // error