Fix presentation of HKT and TypeLambdas in Scala3doc

Author: BarkingBad

scala3doc-testcases/src/tests/hkts.scala

@@ -0,0 +1,44 @@
+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)]
+
+def method1[E, T](value: List[_ >: E]): Int = 0
+def method2[F[+X] <: Option[X], A](fa: F[A]): A = fa.get

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,7 +378,7 @@ 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 name = argument.symbol.normalizedName.takeWhile(_ != '$')
     TypeParameter(
       argument.symbol.getAnnotations(),
       variancePrefix,
@@ -387,15 +387,17 @@ trait ClassLikeSupport:
       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 memberInfo = unwrapMemberInfo(c, typeDef.symbol)
     val (generics, tpeTree) = typeDef.rhs match
-      case LambdaTypeTree(params, body) => (params.map(mkTypeArgument(_)), body)
+      case LambdaTypeTree(params, body) =>
+        (params.map(mkTypeArgument(_)), body)
       case tpe => (Nil, tpe)
 
     val kind = Kind.Type(!isTreeAbstract(typeDef.rhs), typeDef.symbol.isOpaque, generics)

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

@@ -40,7 +40,7 @@ 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 TypeBoundsTree(low, high) => typeBoundsTreeOfHigherKindedType(low, high)
           case tpeTree: TypeTree =>  inner(tpeTree.tpe)
           case term:  Term => inner(term.tpe)
 
@@ -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 = name.takeWhile(_ != '$')
+          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 {
@@ -267,3 +271,17 @@ trait TypesSupport:
       case _ => Nil
     }
 
+  private def typeBoundsTreeOfHigherKindedType(low: TypeTree, high: TypeTree) =
+    def regularTypeBounds(low: TypeTree, high: TypeTree) =
+      typeBound(low.tpe, low = true) ++ typeBound(high.tpe, low = false)
+    high.tpe.match
+      case t: TypeLambda => t.match
+        case TypeLambda(params, paramBounds, resType) =>
+          if resType.typeSymbol == defn.AnyClass && params.foldLeft(true)((acc,e) => acc && e.contains("$")) then
+            texts("[") ++ commas(paramBounds.map { typ =>
+              texts("_") ++ inner(typ)
+            }) ++ texts("]")
+          else
+            regularTypeBounds(low, high)
+        case _ => regularTypeBounds(low, high)
+      case _ => regularTypeBounds(low, high)