Allow qualified types with implicit argument name in patterns

Author: mbovel

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -234,6 +234,14 @@ object desugar {
     else vdef1
   end valDef
 
+  def caseDef(cdef: CaseDef)(using Context): CaseDef =
+    if Feature.qualifiedTypesEnabled then
+      val CaseDef(pat, guard, body) = cdef
+      val pat1 = DesugarQualifiedTypesInPatternMap().transform(pat)
+      cpy.CaseDef(cdef)(pat1, guard, body)
+    else
+      cdef
+
   def mapParamss(paramss: List[ParamClause])
                 (mapTypeParam: TypeDef => TypeDef)
                 (mapTermParam: ValDef => ValDef)(using Context): List[ParamClause] =
@@ -2487,6 +2495,14 @@ object desugar {
     else
       tpt
 
+  private class DesugarQualifiedTypesInPatternMap extends UntypedTreeMap:
+    override def transform(tree: Tree)(using Context): Tree =
+      tree match
+        case Typed(ident @ Ident(name: TermName), tpt) =>
+          cpy.Typed(tree)(ident, desugarQualifiedTypes(tpt, name))
+        case _ =>
+          super.transform(tree)
+
   /** Returns the annotated type used to represent the qualified type with the
    *  given components:
    *  `parent @qualified[parent]((paramName: parent) => qualifier)`.

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

@@ -2267,9 +2267,10 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   }
 
   /** Type a case. */
-  def typedCase(tree: untpd.CaseDef, sel: Tree, wideSelType: Type, pt: Type)(using Context): CaseDef = {
+  def typedCase(tree0: untpd.CaseDef, sel: Tree, wideSelType: Type, pt: Type)(using Context): CaseDef = {
     val originalCtx = ctx
     val gadtCtx: Context = ctx.fresh.setFreshGADTBounds
+    val tree = desugar.caseDef(tree0)
 
     def caseRest(pat: Tree)(using Context) = {
       val pt1 = instantiateMatchTypeProto(pat, pt) match {

tests/printing/qualified-types.check

@@ -79,7 +79,32 @@ package example {
             Int @qualified[Int]((x8: Int) => x8 > 0)]((
             x8: Int @qualified[Int]((x8: Int) => x8 > 0)) => x7 < 10)
          = ???
-        ()
+        val x9: Any = 42
+        x9 match
+          {
+            case y @ _:Int @qualified[Int]((y: Int) => y > 0) =>
+              println(
+                _root_.scala.StringContext.apply(
+                  [""," is Int with x > 0" : String]*).s([y : Any]*)
+              )
+            case _ =>
+              ()
+          }
+        x9 match
+          {
+            case
+              Tuple2.unapply[Any, Any](
+                y @ _:Int @qualified[Int]((y: Int) => y > 0),
+                z @ _:Int @qualified[Int]((z: Int) => z > 0)):(Any, Any)
+             =>
+              println(
+                _root_.scala.StringContext.apply(
+                  [""," is Int with y > 0 and "," is Int with z > 0" : String]*)
+                  .s([y,z : Any]*)
+              )
+            case _ =>
+              ()
+          }
       }
     def bar(x: Int @qualified[Int]((x: Int) => x > 0)): Nothing = ???
     def secondGreater1(x: Int, y: Int)(z: Int @qualified[Int]((w: Int) => x > y)

tests/printing/qualified-types.scala

@@ -49,6 +49,17 @@ def implicitArgumentName() =
   val x7: (Int with x7 > 0) with x6 < 10 = ???
   val x8: ((Int with x8 > 0) with x7 < 10) = ???
 
+  val x9: Any = 42
+  x9 match
+    case y: Int with y > 0 =>
+      println(s"$y is Int with x > 0")
+    case _ => ()
+
+  x9 match
+    case (y: Int with y > 0, z: Int with z > 0) =>
+      println(s"$y is Int with y > 0 and $z is Int with z > 0")
+    case _ => ()
+
 def bar(x: Int with x > 0) = ???
 def secondGreater1(x: Int, y: Int)(z: {w: Int with x > y}) = ???
 def secondGreater2(x: Int, y: Int)(z: Int with x > y) = ???