Store GADT constraints until PostTyper

In some cases, the attachment can get dropped. We have a lot of such cases. Most
seem to happen for tuple patterns.

Author: abgruszecki

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

@@ -257,6 +257,14 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
 
     override def transform(tree: Tree)(using Context): Tree =
       try tree match {
+        case CaseDef(pat, _, _) =>
+          val gadtCtx =
+           pat.getAttachment(typer.Typer.InferredGadtConstraints) match
+             case Some(gadt) => ctx.fresh.setGadt(gadt)
+             case None =>
+               typr.println(i"Pattern has no associated GADT constraints: $pat")
+               ctx
+          super.transform(tree)(using gadtCtx)
         case tree: Ident if !tree.isType =>
           if tree.symbol.is(Inline) && !Inliner.inInlineMethod then
             ctx.compilationUnit.needsInlining = true
@@ -438,4 +446,4 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
     private def normalizeErasedRhs(rhs: Tree, sym: Symbol)(using Context) =
       if (sym.isEffectivelyErased) dropInlines.transform(rhs) else rhs
   }
-}
+}

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

@@ -66,6 +66,9 @@ object Typer {
     if (!tree.isEmpty && !tree.isInstanceOf[untpd.TypedSplice] && ctx.typerState.isGlobalCommittable)
       assert(tree.span.exists, i"position not set for $tree # ${tree.uniqueId} of ${tree.getClass} in ${tree.source}")
 
+  /** An attachment for GADT constraints that were inferred for a pattern. */
+  val InferredGadtConstraints = new Property.Key[core.GadtConstraint]
+
   /** A context property that indicates the owner of any expressions to be typed in the context
    *  if that owner is different from the context's owner. Typically, a context with a class
    *  as owner would have a local dummy as ExprOwner value.
@@ -1598,9 +1601,12 @@ class Typer extends Namer
       val pat1 = indexPattern(tree).transform(pat)
       val guard1 = typedExpr(tree.guard, defn.BooleanType)
       var body1 = ensureNoLocalRefs(typedExpr(tree.body, pt1), pt1, ctx.scope.toList)
+      pat1.putAttachment(InferredGadtConstraints, ctx.gadt)
       if (pt1.isValueType) // insert a cast if body does not conform to expected type if we disregard gadt bounds
         body1 = body1.ensureConforms(pt1)(using originalCtx)
-      assignType(cpy.CaseDef(tree)(pat1, guard1, body1), pat1, body1)
+      val res =
+        assignType(cpy.CaseDef(tree)(pat1, guard1, body1), pat1, body1)
+      res
     }
 
     val pat1 = typedPattern(tree.pat, wideSelType)(using gadtCtx)

tests/pos/i12226.scala

@@ -0,0 +1,16 @@
+object Test extends App {
+  sealed trait P[T]
+  case class C1[T <: String](c1: T) extends P[T]
+  case class C2[T](c2: T) extends P[T]
+
+  def test[T](p: P[T], t: T): Unit = p match {
+    case C1(_) =>
+      // T <: String
+      val t : T = ???
+      val s : String = t
+      def test = new C1[T](t)
+      println(1)
+
+    case C2(_) => println(2)
+  }
+}