Allow nested qualified types with implicit argument name

Author: mbovel

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

@@ -214,7 +214,7 @@ object desugar {
   def valDef(vdef0: ValDef)(using Context): Tree =
     val vdef @ ValDef(_, tpt, rhs) = vdef0
     val valName = normalizeName(vdef, tpt).asTermName
-    val tpt1 = qualifiedType(tpt, valName)
+    val tpt1 = desugarQualifiedTypes(tpt, valName)
     var mods1 = vdef.mods
 
     val vdef1 = cpy.ValDef(vdef)(name = valName, tpt = tpt1).withMods(mods1)
@@ -2463,12 +2463,31 @@ object desugar {
     buf.toList
   }
 
-  /** If `tree` is a `QualifiedTypeTree`, then desugars it using `paramName` as
-   *  the qualified parameter name. Otherwise, returns `tree` unchanged.
+  /** Desugar subtrees that are `QualifiedTypeTree`s using `outerParamName` as
+   *  the qualified parameter name.
    */
-  def qualifiedType(tree: Tree, paramName: TermName)(using Context): Tree = tree match
-    case QualifiedTypeTree(parent, None, qualifier) => qualifiedType(parent, paramName, qualifier, tree.span)
-    case _ => tree
+  private def desugarQualifiedTypes(tpt: Tree, outerParamName: TermName)(using Context): Tree =
+    def transform(tree: Tree): Tree =
+      tree match
+        case QualifiedTypeTree(parent, None, qualifier) =>
+          qualifiedType(transform(parent), outerParamName, qualifier, tree.span)
+        case QualifiedTypeTree(parent, paramName, qualifier) =>
+          cpy.QualifiedTypeTree(tree)(transform(parent), paramName, qualifier)
+        case TypeApply(fn, args) =>
+          cpy.TypeApply(tree)(transform(fn), args)
+        case AppliedTypeTree(fn, args) =>
+          cpy.AppliedTypeTree(tree)(transform(fn), args)
+        case InfixOp(left, op, right) =>
+          cpy.InfixOp(tree)(transform(left), op, transform(right))
+        case Parens(arg) =>
+          cpy.Parens(tree)(transform(arg))
+        case _ =>
+          tree
+
+    if Feature.qualifiedTypesEnabled then
+      transform(tpt)
+    else
+      tpt
 
   /** Returns the annotated type used to represent the qualified type with the
    *  given components:

tests/pos-custom-args/qualified-types/syntax_unnamed.scala

@@ -0,0 +1,10 @@
+@main def Test =
+  val v0: (Int with v0 > 0) | (String with v0 == "foo") = ???
+  val v1: Int with v1 > 0 = ???
+  val v2: (Int with v2 > 0) = ???
+  val v3: (Int with v3 > 0) & (Int with v3 < 10) = ???
+  val v4: (Int with v4 > 0) & Int with v4 < 10 = ???
+  val v5: Int & String with false = ???
+  val v6: ((Int with v5 > 0) & Int) with v5 < 10 = ???
+  val v7: (Int with v6 > 0) with v6 < 10 = ???
+  val v8: ((Int with v7 > 0) with v7 < 10) = ???

tests/printing/qualified-types.check

@@ -46,6 +46,40 @@ package example {
             example.id[example.Neg](-1)
         ()
       }
+    def implicitArgumentName(): Unit =
+      {
+        val x0:
+          Int @qualified[Int]((x0: Int) => x0 > 0) |
+            String @qualified[String]((x0: String) => x0 == "foo")
+         = ???
+        val x1: Int @qualified[Int]((x1: Int) => x1 > 0) = ???
+        val x2: Int @qualified[Int]((x2: Int) => x2 > 0) = ???
+        val x3:
+          Int @qualified[Int]((x3: Int) => x3 > 0) &
+            Int @qualified[Int]((x3: Int) => x3 < 10)
+         = ???
+        val x4:
+          Int @qualified[Int]((x4: Int) => x4 > 0) &
+            Int @qualified[Int]((x4: Int) => x4 < 10)
+         = ???
+        val x5: Int & String @qualified[String]((x5: String) => false) = ???
+        val x6:
+          (Int @qualified[Int]((x6: Int) => x6 > 0) & Int) @qualified[
+            Int @qualified[Int]((x6: Int) => x6 > 0) & Int]((
+            x6: Int @qualified[Int]((x6: Int) => x6 > 0) & Int) => x5 < 10)
+         = ???
+        val x7:
+          Int @qualified[Int]((x7: Int) => x7 > 0) @qualified[
+            Int @qualified[Int]((x7: Int) => x7 > 0)]((
+            x7: Int @qualified[Int]((x7: Int) => x7 > 0)) => x6 < 10)
+         = ???
+        val x8:
+          Int @qualified[Int]((x8: Int) => x8 > 0) @qualified[
+            Int @qualified[Int]((x8: Int) => x8 > 0)]((
+            x8: Int @qualified[Int]((x8: Int) => x8 > 0)) => x7 < 10)
+         = ???
+        ()
+      }
     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)
       ): Nothing = ???

tests/printing/qualified-types.scala

@@ -33,6 +33,20 @@ def test() =
   val x5: Int with x > 0 = 1
   val x6: Int = id[{x: Int with x < 0}](1) + id[Neg](-1)
 
+// `val x: Int with x > 0` is desugared to `val x: {x: Int with x > 0}`: if the
+// name of a qaulifier argument is not specified, it assumed the same as the
+// parent `val` definition.
+def implicitArgumentName() =
+  val x0: (Int with x0 > 0) | (String with x0 == "foo") = ???
+  val x1: Int with x1 > 0 = ???
+  val x2: (Int with x2 > 0) = ???
+  val x3: (Int with x3 > 0) & (Int with x3 < 10) = ???
+  val x4: (Int with x4 > 0) & Int with x4 < 10 = ???
+  val x5: Int & String with false = ???
+  val x6: ((Int with x6 > 0) & Int) with x5 < 10 = ???
+  val x7: (Int with x7 > 0) with x6 < 10 = ???
+  val x8: ((Int with x8 > 0) with x7 < 10) = ???
+
 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) = ???