Fix rendering of capture variables in paramlists

Author: bracevac

local/project/dummy/capturevars.scala

@@ -10,15 +10,18 @@ trait Test:
     type Ordinary2 >: Int <: String
     type T[-C^ >: {a,b}]
     type U[+C^]
+    type Foo = [C^ >: {a,b} <: {a,b,cap}] =>> AnyRef^{C}
     type C^
     type D^ >: {C} <: {a,b}
     type E^ <: C
     type F^ <: {D,E}
     type G^ = C
+    type H^ = {C}
     def foo[C^ >: {a,b}](x: T[C]): Unit
     def bar(x: T[{a,b}]): Unit
     def baz(x: T[{a,b,caps.cap}]): Unit
     def foo2[C^](x: U[C]): Unit
     def bar2(x: U[{a,b,cap}]): Unit
     def baz2(x: U[{caps.cap}]): Unit
-    def test[E^, F^ >: {caps.cap} <: {}](x: T[{E,a,b}], y: U[F]): Unit
+    def test[E^, F^ >: {caps.cap} <: {}, G <: [C^ >: {a,b} <: {a,b}] =>> AnyRef^{C}](x: T[{E,a,b}], y: U[F]): Unit
+    val poly: [C^ >: {a,b}] => (f: () ->{C} Unit) -> Int ->{C} Unit

scaladoc/src/dotty/tools/scaladoc/api.scala

@@ -121,7 +121,8 @@ case class TypeParameter(
   variance: "" | "+" | "-",
   name: String,
   dri: DRI,
-  signature: Signature
+  signature: Signature,
+  isCaptureVar: Boolean = false // under capture checking
 )
 
 case class Link(name: String, dri: DRI)

scaladoc/src/dotty/tools/scaladoc/cc/CaptureOps.scala

@@ -107,6 +107,15 @@ extension (using qctx: Quotes)(tpe: qctx.reflect.TypeRepr) // FIXME clean up and
       case _ => false
 end extension
 
+extension (using qctx: Quotes)(typedef: qctx.reflect.TypeDef)
+  def derivesFromCapSet: Boolean =
+    import qctx.reflect.*
+    typedef.rhs.match
+      case t: TypeTree => t.tpe.derivesFrom(CaptureDefs.Caps_CapSet)
+      case t: TypeBoundsTree => t.tpe.derivesFrom(CaptureDefs.Caps_CapSet)
+      case _ => false
+end extension
+
 /** Matches `import scala.language.experimental.captureChecking` */
 object CCImport:
   def unapply(using qctx: Quotes)(tree: qctx.reflect.Tree): Boolean =

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

@@ -5,7 +5,7 @@ import dotty.tools.scaladoc._
 import dotty.tools.scaladoc.{Signature => DSignature}
 import dotty.tools.scaladoc.Inkuire
 
-import dotty.tools.scaladoc.cc.CaptureDefs
+import dotty.tools.scaladoc.cc.*
 
 import scala.quoted._
 
@@ -466,6 +466,8 @@ trait ClassLikeSupport:
       else if argument.symbol.flags.is(Flags.Contravariant) then "-"
       else ""
 
+    val isCaptureVar = ccEnabled && argument.derivesFromCapSet
+
     val name = argument.symbol.normalizedName
     val normalizedName = if name.matches("_\\$\\d*") then "_" else name
     val boundsSignature = memberInfo.get(name).fold(argument.rhs.asSignature(classDef))(_.asSignature(classDef))
@@ -479,7 +481,8 @@ trait ClassLikeSupport:
       variancePrefix,
       normalizedName,
       argument.symbol.dri,
-      signature
+      signature,
+      isCaptureVar,
     )
 
   def parseTypeDef(typeDef: TypeDef, classDef: ClassDef): Member =
@@ -488,15 +491,13 @@ trait ClassLikeSupport:
       case LambdaTypeTree(params, body) => isTreeAbstract(body)
       case _ => false
     }
+
+    val isCaptureVar = ccEnabled && typeDef.derivesFromCapSet
+
     val (generics, tpeTree) = typeDef.rhs match
       case LambdaTypeTree(params, body) => (params.map(mkTypeArgument(_, classDef)), body)
       case tpe => (Nil, tpe)
 
-    val isCaptureVar = ccEnabled && typeDef.rhs.match
-      case t: TypeTree => t.tpe.derivesFrom(CaptureDefs.Caps_CapSet)
-      case t: TypeBoundsTree => t.tpe.derivesFrom(CaptureDefs.Caps_CapSet)
-      case _ => false
-
     val defaultKind = Kind.Type(!isTreeAbstract(typeDef.rhs), typeDef.symbol.isOpaque, generics, isCaptureVar).asInstanceOf[Kind.Type]
     val kind = if typeDef.symbol.flags.is(Flags.Enum) then Kind.EnumCase(defaultKind)
       else defaultKind

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

@@ -146,7 +146,8 @@ trait TypesSupport:
       case tl @ TypeLambda(params, paramBounds, resType) =>
         plain("[").l ++ commas(params.zip(paramBounds).map { (name, typ) =>
           val normalizedName = if name.matches("_\\$\\d*") then "_" else name
-          tpe(normalizedName).l ++ inner(typ)
+          val suffix = if ccEnabled && typ.derivesFrom(CaptureDefs.Caps_CapSet) then List(Keyword("^")) else Nil
+          tpe(normalizedName).l ++ suffix ++ inner(typ)
         }) ++ plain("]").l
         ++ keyword(" =>> ").l
         ++ inner(resType)
@@ -164,8 +165,11 @@ trait TypesSupport:
         }
 
         def getParamBounds(t: PolyType): SSignature = commas(
-          t.paramNames.zip(t.paramBounds.map(inner(_)))
-            .map(b => tpe(b(0)).l ++ b(1))
+          t.paramNames.zip(t.paramBounds.map(inner(_))).zipWithIndex
+            .map { case ((name, bound), idx) =>
+              val suffix = if ccEnabled && t.param(idx).derivesFrom(CaptureDefs.Caps_CapSet) then List(Keyword("^")) else Nil
+              tpe(name).l ++ suffix ++ bound
+            }
         )
 
         def getParamList(m: MethodType): SSignature =

scaladoc/src/dotty/tools/scaladoc/translators/ScalaSignatureUtils.scala

@@ -6,7 +6,9 @@ case class SignatureBuilder(content: Signature = Nil) extends ScalaSignatureUtil
   def name(str: String, dri: DRI, isCaptureVar: Boolean = false/*under CC*/): SignatureBuilder =
     val suffix = if isCaptureVar then List(Keyword("^")) else Nil
     copy(content = content ++ (Name(str, dri) :: suffix))
-  def tpe(text: String, dri: Option[DRI]): SignatureBuilder = copy(content = content :+ Type(text, dri))
+  def tpe(text: String, dri: Option[DRI], isCaptureVar: Boolean = false/*under CC*/): SignatureBuilder =
+    val suffix = if isCaptureVar then List(Keyword("^")) else Nil
+    copy(content = content ++ (Type(text, dri) :: suffix))
   def keyword(str: String): SignatureBuilder = copy(content = content :+ Keyword(str))
   def tpe(text: String, dri: DRI): SignatureBuilder = copy(content = content :+ Type(text, Some(dri)))
   def signature(s: Signature): SignatureBuilder = copy(content = content ++ s)
@@ -92,7 +94,7 @@ case class SignatureBuilder(content: Signature = Nil) extends ScalaSignatureUtil
     }
 
   def typeParamList(on: TypeParameterList) = list(on.toList, List(Plain("[")), List(Plain("]"))){ (bdr, e) =>
-    bdr.annotationsInline(e).keyword(e.variance).tpe(e.name, Some(e.dri)).signature(e.signature)
+    bdr.annotationsInline(e).keyword(e.variance).tpe(e.name, Some(e.dri), e.isCaptureVar).signature(e.signature)
   }
 
   def functionTermParameters(paramss: Seq[TermParameterList]) =