Scaladoc: type rendering fixes and improvements (#17213)

This PR introduces multiple fixes and improvements to type rendering in
Scaladoc

- Fixed rendering of TypeRefs (`A#B`) and TermRefs (`a.b.type`)
- Fixed rendering of `Tuple1[T]` (previously `(T)`)
- Fixed rendering of `this.type` (except for type bounds, see below)
- Types with `@showAsInfix` are rendered infix
- Correct parenthesizing around infix types, `&` types, `|` types and
function types
- Type parameters of superclasses in inherited methods are substituted
with actual types from inheriting class/trait (see
`scaladoc-testcases/src/tests/supertypeParamsSubstitution.scala`)

https://github.com/lampepfl/dotty/pull/17213/files#diff-93a78912075a9fdb34fefa437d191be59888cb723ccb244374e77033d9eca779R12-R20
- `this` and `type` are highlighted as keywords

fixes #16024
fixes #16143
fixed #16057
fixes #16084 (partially) - fixed rendering of `Int` instead of `n.type`
and `(This, n.type)` instead of `Split[This, n.type]`. `this.type` in
type bounds remains unfixed. I created separate issue for that #17226

Documentation with those changes has been deployed to
https://scala3doc.virtuslab.com/pr-types-rendering-fixes/scala3/api/index.html

Author: Florian3k

scaladoc-testcases/src/tests/exports1.scala

@@ -14,18 +14,18 @@ class A: //unexpected
    = 1
   var aVar1: 1
    = 1
-  type HKT[T[_], X] //expected: final type HKT = [T[_], X] =>> HKT[T, X]
+  type HKT[T[_], X] //expected: final type HKT = [T[_], X] =>> a.HKT[T, X]
    = T[X]
-  type SomeRandomType = (List[_] | Seq[_]) & String //expected: final type SomeRandomType = SomeRandomType
-  def x[T[_], X](x: X): HKT[T, X]
+  type SomeRandomType = (List[_] | Seq[_]) & String //expected: final type SomeRandomType = a.SomeRandomType
+  def x[T[_], X](x: X): HKT[T, X] //expected: def x[T[_], X](x: X): A.this.HKT[T, X]
    = ???
   def fn[T, U]: T => U
    = ???
   object Object //expected: val Obj: Object.type
-  val x: HKT[List, Int]
+  val x: HKT[List, Int] //expected: val x: A.this.HKT[List, Int]
    = ???
-  class Class(val a: Int, val b: Int) extends Serializable //expected: final type Class = Class
-  enum Enum: //expected: final type Enum = Enum
+  class Class(val a: Int, val b: Int) extends Serializable //expected: final type Class = a.Class
+  enum Enum: //expected: final type Enum = a.Enum
     case A
     case B(i: Int)
     case C[T]() extends Enum

scaladoc-testcases/src/tests/functionTypeSignatures.scala

@@ -4,7 +4,13 @@ type A = ((Int, Int)) => Int
 
 type B = (Int | String) => Int
 
+type B1 = Int | String => Int //expected: type B1 = (Int | String) => Int
+
 type C = (Int & String) => Int
 
+type C1 = Int & String => Int //expected: type C1 = (Int & String) => Int
+
+type D = Int | (String => Int)
+
 type E = (A => B) => B
 

scaladoc-testcases/src/tests/infixTypes.scala

@@ -0,0 +1,141 @@
+package tests
+package infixTypes
+
+import annotation.showAsInfix
+
+@showAsInfix
+trait SomeTrait[A, B]
+
+trait SomeTrait2[A, B]
+
+def someTrait1[C, D]: C SomeTrait D
+  = ???
+
+def someTrait2[E, F]: SomeTrait[E, F] //expected: def someTrait2[E, F]: E SomeTrait F
+  = ???
+
+def someTrait3[G, H]: G SomeTrait2 H //expected: def someTrait3[G, H]: SomeTrait2[G, H]
+  = ???
+
+trait +++[A, B]
+
+trait ++*[A, B]
+
+trait ++:[A, B]
+
+trait +*:[A, B]
+
+trait ***[A, B]
+
+trait **:[A, B]
+
+def foo[A, B, C, D]: (A SomeTrait B) +++ (C SomeTrait2 D) //expected: def foo[A, B, C, D]: (A SomeTrait B) +++ SomeTrait2[C, D]
+  = ???
+
+// left-associative, same precedence
+
+def a0[X, Y, Z]: X +++ Y +++ Z
+  = a1
+
+def a1[X, Y, Z]: (X +++ Y) +++ Z //expected: def a1[X, Y, Z]: X +++ Y +++ Z
+  = a0
+
+def a2[X, Y, Z]: X +++ (Y +++ Z)
+  = ???
+
+def a0x[X, Y, Z]: X +++ Y ++* Z //expected: def a0x[X, Y, Z]: (X +++ Y) ++* Z
+  = a1x
+
+def a1x[X, Y, Z]: (X +++ Y) ++* Z
+  = a0x
+
+def a2x[X, Y, Z]: X +++ (Y ++* Z)
+  = ???
+
+// right-associative, same precedence
+
+def a3[X, Y, Z]: X ++: Y ++: Z
+  = a5
+
+def a4[X, Y, Z]: (X ++: Y) ++: Z
+  = ???
+
+def a5[X, Y, Z]: X ++: (Y ++: Z) //expected: def a5[X, Y, Z]: X ++: Y ++: Z
+  = a3
+
+def a3x[X, Y, Z]: X ++: Y +*: Z  //expected: def a3x[X, Y, Z]: X ++: (Y +*: Z)
+  = a5x
+
+def a4x[X, Y, Z]: (X ++: Y) +*: Z
+  = ???
+
+def a5x[X, Y, Z]: X ++: (Y +*: Z)
+  = a3x
+
+// left and right associative, same precedence
+
+def a6[X, Y, Z]: (X +++ Y) ++: Z
+  = ???
+
+def a7[X, Y, Z]: X +++ (Y ++: Z)
+  = ???
+
+// left-associative, mixed precedence
+
+def b0[X, Y, Z]: X +++ Y *** Z //expected: def b0[X, Y, Z]: X +++ (Y *** Z)
+  = ???
+
+def b1[X, Y, Z]: (X +++ Y) *** Z
+  = ???
+
+def b2[X, Y, Z]: X +++ (Y *** Z)
+  = ???
+
+def b3[X, Y, Z]: X *** Y +++ Z //expected: def b3[X, Y, Z]: (X *** Y) +++ Z
+  = ???
+
+def b4[X, Y, Z]: (X *** Y) +++ Z
+  = ???
+
+def b5[X, Y, Z]: X *** (Y +++ Z)
+  = ???
+
+// right-associative, mixed precedence
+
+def c0[X, Y, Z]: X ++: Y **: Z //expected: def c0[X, Y, Z]: X ++: (Y **: Z)
+  = ???
+
+def c1[X, Y, Z]: (X ++: Y) **: Z
+  = ???
+
+def c2[X, Y, Z]: X ++: (Y **: Z)
+  = ???
+
+def c3[X, Y, Z]: X **: Y ++: Z //expected: def c3[X, Y, Z]: (X **: Y) ++: Z
+  = ???
+
+def c4[X, Y, Z]: (X **: Y) ++: Z
+  = ???
+
+def c5[X, Y, Z]: X **: (Y ++: Z)
+  = ???
+
+// left and right associative, mixed precedence
+
+def d0[X, Y, Z]: X +++ Y **: Z //expected: def d0[X, Y, Z]: X +++ (Y **: Z)
+  = ???
+
+def d1[X, Y, Z]: (X +++ Y) **: Z
+  = ???
+
+def d2[X, Y, Z]: X +++ (Y **: Z)
+  = ???
+
+def d3[X, Y, Z]: X *** Y ++: Z //expected: def d3[X, Y, Z]: (X *** Y) ++: Z
+  = ???
+
+def d4[X, Y, Z]: (X *** Y) ++: Z
+  = ???
+
+def d5[X, Y, Z]: X *** (Y ++: Z)
+  = ???

scaladoc-testcases/src/tests/matchTypeTuple.scala

@@ -0,0 +1,10 @@
+package tests
+package matchTypeTuple
+
+// issue 16084
+
+sealed trait TupleTest[Take[_, _], Drop[_, _]]:
+  type Split[T <: Tuple, N <: Int] = (Take[T, N], Drop[T, N])
+
+  inline def splitAt[This <: Tuple](n: Int): Split[This, n.type]
+    = ???

scaladoc-testcases/src/tests/pathDependentTypes.scala

@@ -0,0 +1,20 @@
+package tests
+package pathDependentTypes
+
+import deriving.Mirror.ProductOf
+
+// issue 16143
+
+trait Foo[A]:
+  type Out
+
+trait Bar[A]:
+  type Out
+
+def foo[A](using f: Foo[A])(using b: Bar[f.Out]): b.Out
+  = ???
+
+// issue 16057
+
+def fromProductTyped[P <: Product](p: P)(using m: ProductOf[P]): m.MirroredElemTypes
+  = ???

scaladoc-testcases/src/tests/supertypeParamsSubstitution.scala

@@ -0,0 +1,20 @@
+package tests
+package supertypeParamsSubstitution
+
+class MyIter[A, CC[_], C]:
+  def foo: A
+    = ???
+  def bar: CC[CC[A]]
+    = ???
+  def baz: C
+    = ???
+
+class MyList[T] extends MyIter[T, MyList, MyList[T]]
+//expected: def foo: T
+//expected: def bar: MyList[MyList[T]]
+//expected: def baz: MyList[T]
+
+class MyListInt extends MyList[Int]
+//expected: def foo: Int
+//expected: def bar: MyList[MyList[Int]]
+//expected: def baz: MyList[Int]

scaladoc-testcases/src/tests/thisType.scala

@@ -0,0 +1,8 @@
+package tests
+package thisType
+
+// issue 16024
+
+class X[Map[_, _[_]]]:
+  inline def map[F[_]](f: [t] => t => F[t]): Map[this.type, F] = //expected: inline def map[F[_]](f: [t] => (x$1: t) => F[t]): Map[this.type, F]
+    ???