Expose GadtExpr/Constraint in Quotes?

Seems like a test around Exactors requires it?
Can/should we leave out the GadtConstraint part?
Unsure, never been here before.

Author: dwijnand

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -776,6 +776,23 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       end extension
     end BlockMethods
 
+    type GadtExpr = tpd.GadtExpr
+    object GadtExprTypeTest extends TypeTest[Tree, GadtExpr]:
+      def unapply(x: Tree): Option[GadtExpr & x.type] = x match
+        case x: (tpd.GadtExpr & x.type) => Some(x)
+        case _ => None
+    object GadtExpr extends GadtExprModule:
+      def apply(gadt: GadtConstraint, expr: Term): GadtExpr =
+        withDefaultPos(tpd.GadtExpr(gadt, expr))
+      def copy(original: Tree)(gadt: GadtConstraint, expr: Term): GadtExpr =
+        tpd.cpy.GadtExpr(original)(gadt, expr)
+      def unapply(x: GadtExpr): (GadtConstraint, Term) =
+        (x.gadt, x.expr)
+    given GadtExprMethods: GadtExprMethods with
+      extension (self: GadtExpr)
+        def gadt: GadtConstraint = self.gadt
+        def expr: Term = self.expr
+
     type Closure = tpd.Closure
 
     object ClosureTypeTest extends TypeTest[Tree, Closure]:
@@ -2668,6 +2685,13 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         sym.isTerm && !sym.is(dotc.core.Flags.Method)
     end SymbolMethods
 
+    type GadtConstraint = dotc.core.GadtConstraint
+
+    given GadtConstraintMethods: GadtConstraintMethods with
+      extension (self: GadtConstraint)
+        def symbols: List[Symbol] = self.symbols
+        def fullBounds(sym: Symbol): TypeBounds | Null = self.fullBounds(sym)
+
     type Signature = dotc.core.Signature
 
     object Signature extends SignatureModule:

compiler/src/scala/quoted/runtime/impl/printers/Extractors.scala

@@ -100,6 +100,8 @@ object Extractors {
         this += "Assign(" += lhs += ", " += rhs += ")"
       case Block(stats, expr) =>
         this += "Block(" ++= stats += ", " += expr += ")"
+      case GadtExpr(gadt, expr) =>
+        this += "GadtExpr(" += gadt += ", " += expr += ")"
       case If(cond, thenp, elsep) =>
         this += "If(" += cond += ", " += thenp += ", " += elsep += ")"
       case Closure(meth, tpt) =>
@@ -316,6 +318,17 @@ object Extractors {
       def ++=(x: List[ParamClause]): self.type = { visitList(x, visitParamClause); buff }
     }
 
+    private implicit class GadtConstraintOps(buff: self.type) {
+      def +=(x: GadtConstraint): self.type =
+        visitList(for sym <- x.symbols yield (sym, x.fullBounds(sym).nn), (sym, bounds) => {
+          buff += "("
+          visitSymbol(sym)
+          buff += ", "
+          visitType(bounds)
+          buff += ")"
+        })
+    }
+
     private def visitOption[U](opt: Option[U], visit: U => this.type): this.type = opt match {
       case Some(x) =>
         this += "Some("

library/src/scala/quoted/Quotes.scala

@@ -1297,6 +1297,20 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       end extension
     end BlockMethods
 
+    type GadtExpr <: Term
+    given GadtExprTypeTest: TypeTest[Tree, GadtExpr]
+    val GadtExpr: GadtExprModule
+    trait GadtExprModule:
+      this: GadtExpr.type =>
+      def apply(gadt: GadtConstraint, expr: Term): GadtExpr
+      def copy(original: Tree)(gadt: GadtConstraint, expr: Term): GadtExpr
+      def unapply(x: GadtExpr): (GadtConstraint, Term)
+    given GadtExprMethods: GadtExprMethods
+    trait GadtExprMethods:
+      extension (self: GadtExpr)
+        def gadt: GadtConstraint
+        def expr: Term
+
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `Closure` */
     given ClosureTypeTest: TypeTest[Tree, Closure]
 
@@ -3985,6 +3999,17 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       end extension
     }
 
+    /////////////////////
+    // GADT CONSTRAINT //
+    /////////////////////
+
+    type GadtConstraint <: AnyRef
+    given GadtConstraintMethods: GadtConstraintMethods
+    trait GadtConstraintMethods:
+      extension (self: GadtConstraint)
+        def symbols: List[Symbol]
+        def fullBounds(sym: Symbol): TypeBounds | Null
+
     ////////////////
     // SIGNATURES //
     ////////////////
@@ -4581,6 +4606,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
             foldTree(foldTree(x, lhs)(owner), rhs)(owner)
           case Block(stats, expr) =>
             foldTree(foldTrees(x, stats)(owner), expr)(owner)
+          case GadtExpr(gadt, expr) =>
+            foldTree(x, expr)(owner)
           case If(cond, thenp, elsep) =>
             foldTree(foldTree(foldTree(x, cond)(owner), thenp)(owner), elsep)(owner)
           case While(cond, body) =>

project/MiMaFilters.scala

@@ -29,6 +29,14 @@ object MiMaFilters {
     ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.quoted.Quotes#reflectModule#SymbolMethods.termRef"),
     ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.quoted.Quotes#reflectModule#TypeTreeModule.ref"),
 
+    ProblemFilters.exclude[MissingClassProblem]("scala.quoted.Quotes$reflectModule$GadtExprMethods"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.quoted.Quotes$reflectModule$GadtExprModule"),
+    ProblemFilters.exclude[MissingMethodProblem]("scala.quoted.Quotes#reflectModule.GadtExpr"),
+    ProblemFilters.exclude[MissingMethodProblem]("scala.quoted.Quotes#reflectModule.GadtExprMethods"),
+    ProblemFilters.exclude[MissingMethodProblem]("scala.quoted.Quotes#reflectModule.GadtExprTypeTest"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.quoted.Quotes$reflectModule$GadtConstraintMethods"),
+    ProblemFilters.exclude[MissingMethodProblem]("scala.quoted.Quotes#reflectModule.GadtConstraintMethods"),
+
     ProblemFilters.exclude[MissingClassProblem]("scala.annotation.since"),
   )