Merge pull request #11245 from BarkingBad/scala3doc/missing-wildcard-in-hkts

Fix presentation of HKT and TypeLambdas in Scala3doc

Author: BarkingBad

scaladoc-testcases/src/tests/hkts.scala

@@ -0,0 +1,62 @@
+package tests
+package hkts
+
+
+class Case1Variant1[List[_]]
+class Case1Variant2[List <: ([_] =>> Any)]
+
+type Case2Variant1 = [A, _] =>> List[A]
+type Case2Variant2[A, _] = List[A]
+
+type Case3Variant1 = [_] =>> Int
+type Case3Variant2[_] = Int
+
+class A1[X]
+class A2[X] extends A1[X]
+type Case4Variant1 >: ([X] =>> A2[X]) <: ([X] =>> A1[X])
+type Case4Variant2[X] >: A2[X] <: A1[X]
+
+type Case5Variant1 = [X] =>> [Y] =>> (X, Y)
+type Case5Variant2[X, Y] = (X, Y)
+
+type Case6Variant1 = [A, B] =>> A => B
+type Case6Variant2[A, B] = A => B
+
+class Case7Variant1[List[_] <: Number]
+class Case7Variant2[List <: ([_] =>> Number)]
+
+class Case8Variant1[A, List[A] <: Number]
+class Case8Variant2[A, List <: ([A] =>> Number)]
+
+type Case9Variant1 <: [X] =>> Option[X]
+type Case9Variant2[+X] <: Option[X]
+
+class Case10Variant1[List[_ >: Number]]
+class Case10Variant2[List <: ([_ >: Number] =>> Any)]
+
+class Case11Variant1[Map[_, _]]
+class Case11Variant2[Map <: ([_, _] =>> Any)]
+
+class Case12Variant1[List[A >: Number]]
+class Case12Variant2[List <: ([A >: Number] =>> Any)]
+
+class Case13[List[List[_]]]
+
+trait Case14[C[_]]
+class SomeClass extends Case14[List]
+
+
+def method1[E, T](value: List[_ >: E]): Int = 0
+def method2[F[+X] <: Option[X], A](fa: F[A]): A = fa.get
+
+import scala.collection.immutable.ArraySeq
+trait SomeTraitWithHKTs[A[_], B[_], C[_], D[_], E[_]]
+abstract class Foo[Z]
+trait SomeTrait extends SomeTraitWithHKTs[Foo, scala.collection.immutable.ArraySeq, ArraySeq, List, [B] =>> List[B]]
+
+trait A[X] {
+  type SomeType[X]
+  def x: SomeType[X]
+}
+
+trait B[D] extends A[D]

scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala

@@ -144,7 +144,7 @@ trait ClassLikeSupport:
         Some(parseMethod(c, dd.symbol))
 
       case td: TypeDef if !td.symbol.flags.is(Flags.Synthetic) && (!td.symbol.flags.is(Flags.Case) || !td.symbol.flags.is(Flags.Enum)) =>
-        Some(parseTypeDef(td))
+        Some(parseTypeDef(c, td))
 
       case vd: ValDef if !isSyntheticField(vd.symbol)
         && (!vd.symbol.flags.is(Flags.Case) || !vd.symbol.flags.is(Flags.Enum))
@@ -292,7 +292,7 @@ trait ClassLikeSupport:
 
     val enumTypes = companion.membersToDocument.collect {
       case td: TypeDef if !td.symbol.flags.is(Flags.Synthetic) && td.symbol.flags.is(Flags.Enum) && td.symbol.flags.is(Flags.Case) => td
-    }.toList.map(parseTypeDef)
+    }.toList.map(parseTypeDef(classDef, _))
 
     val enumNested = companion.membersToDocument.collect {
       case c: ClassDef if c.symbol.flags.is(Flags.Case) && c.symbol.flags.is(Flags.Enum) => processTree(c)(parseClasslike(c))
@@ -378,22 +378,23 @@ trait ClassLikeSupport:
       if  argument.symbol.flags.is(Flags.Covariant) then "+"
       else if argument.symbol.flags.is(Flags.Contravariant) then "-"
       else ""
+
     val name = argument.symbol.normalizedName
+    val normalizedName = if name.matches("_\\$\\d*") then "_" else name
     TypeParameter(
       argument.symbol.getAnnotations(),
       variancePrefix,
-      name,
+      normalizedName,
       argument.symbol.dri,
       memberInfo.get(name).fold(argument.rhs.asSignature)(_.asSignature)
     )
 
-  def parseTypeDef(typeDef: TypeDef): Member =
+  def parseTypeDef(c: ClassDef, typeDef: TypeDef): Member =
     def isTreeAbstract(typ: Tree): Boolean = typ match {
       case TypeBoundsTree(_, _) => true
       case LambdaTypeTree(params, body) => isTreeAbstract(body)
       case _ => false
     }
-
     val (generics, tpeTree) = typeDef.rhs match
       case LambdaTypeTree(params, body) => (params.map(mkTypeArgument(_)), body)
       case tpe => (Nil, tpe)

scaladoc/src/dotty/tools/scaladoc/tasty/TypesSupport.scala

@@ -40,8 +40,8 @@ trait TypesSupport:
     extension (tpeTree: Tree)
       def asSignature: DocSignature =
         tpeTree match
-          case TypeBoundsTree(low, high) => typeBound(low.tpe, low = true) ++ typeBound(high.tpe, low = false)
-          case tpeTree: TypeTree =>  inner(tpeTree.tpe)
+          case TypeBoundsTree(low, high) => typeBoundsTreeOfHigherKindedType(low.tpe, high.tpe)
+          case tpeTree: TypeTree => inner(tpeTree.tpe)
           case term:  Term => inner(term.tpe)
 
   given TypeSyntax: AnyRef with
@@ -95,9 +95,10 @@ trait TypesSupport:
       case AnnotatedType(tpe, _) =>
         inner(tpe)
       case tl @ TypeLambda(params, paramBounds, resType) =>
-        // println(params)
-        // println(paramBounds)
-        texts("[") ++ commas(params.zip(paramBounds).map( (name, typ) => texts(s"${name}") ++ inner(typ) )) ++ texts("]")
+        texts("[") ++ commas(params.zip(paramBounds).map { (name, typ) =>
+          val normalizedName = if name.matches("_\\$\\d*") then "_" else name
+          texts(normalizedName) ++ inner(typ)
+        }) ++ texts("]")
         ++ texts(" =>> ")
         ++ inner(resType)
 
@@ -184,7 +185,10 @@ trait TypesSupport:
               Nil
             case args =>
               texts("(") ++ commas(args.map(inner)) ++ texts(")")
-        else inner(tpe) ++ texts("[") ++ commas(typeList.map(inner)) ++ texts("]")
+        else inner(tpe) ++ texts("[") ++ commas(typeList.map { t => t match
+          case _: TypeBounds => texts("_") ++ inner(t)
+          case _ => inner(t)
+        }) ++ texts("]")
 
       case tp @ TypeRef(qual, typeName) =>
         qual match {
@@ -238,7 +242,7 @@ trait TypesSupport:
       // case _ => throw Exception("No match for type in conversion to Reference. This should not happen, please open an issue. " + tp)
       case TypeBounds(low, hi) =>
         if(low == hi) texts(" = ") ++ inner(low)
-        else typeBound(low, low = true) ++ typeBound(hi, low = false)
+        else typeBoundsTreeOfHigherKindedType(low, hi)
 
       case NoPrefix() => Nil
 
@@ -267,3 +271,16 @@ trait TypesSupport:
       case _ => Nil
     }
 
+  private def typeBoundsTreeOfHigherKindedType(low: TypeRepr, high: TypeRepr) =
+    def regularTypeBounds(low: TypeRepr, high: TypeRepr) =
+      typeBound(low, low = true) ++ typeBound(high, low = false)
+    high.match
+      case TypeLambda(params, paramBounds, resType) =>
+        if resType.typeSymbol == defn.AnyClass then
+          texts("[") ++ commas(params.zip(paramBounds).map { (name, typ) =>
+            val normalizedName = if name.matches("_\\$\\d*") then "_" else name
+            texts(normalizedName) ++ inner(typ)
+          }) ++ texts("]")
+        else
+          regularTypeBounds(low, high)
+      case _ => regularTypeBounds(low, high)