Hello retains

Author: bracevac

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

@@ -0,0 +1,29 @@
+package dotty.tools.scaladoc.cc
+
+import scala.quoted._
+
+object CaptureDefs:
+  /** The name of the `retains` annotation. */
+  val RetainsName: String = "scala.annotation.retains"
+
+  /** The name of the `retainsCap` annotation. */
+  val RetainsCapName: String = "scala.annotation.retainsCap"
+
+  /** The name of the `retainsByName` annotation. */
+  val RetainsByNameName: String = "scala.annotation.retainsByName"
+
+  def retains(using qctx: Quotes) = qctx.reflect.Symbol.requiredClass(RetainsName)
+  def retainsCap(using qctx: Quotes) = qctx.reflect.Symbol.requiredClass(RetainsCapName)
+  def retainsByName(using qctx: Quotes) = qctx.reflect.Symbol.requiredClass(RetainsByNameName)
+end CaptureDefs
+
+extension (using qctx: Quotes)(term: qctx.reflect.Term)
+
+  /** Is this term a `retains`* annotations from capturing types?  */
+  def isRetains: Boolean =
+    val sym = term.tpe match
+      case qctx.reflect.AppliedType(base, _) => base.typeSymbol
+      case other                             => other.typeSymbol
+    sym == CaptureDefs.retains
+    || sym == CaptureDefs.retainsCap
+    || sym == CaptureDefs.retainsByName

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

@@ -6,6 +6,8 @@ import scala.jdk.CollectionConverters._
 import scala.quoted._
 import scala.util.control.NonFatal
 
+import dotty.tools.scaladoc.cc.*
+
 import NameNormalizer._
 import SyntheticsSupport._
 
@@ -112,34 +114,9 @@ trait TypesSupport:
         inner(tpe) :+ plain("*")
       case AppliedType(repeatedClass, Seq(tpe)) if isRepeated(repeatedClass) =>
         inner(tpe) :+ plain("*")
-      case tp @ AnnotatedType(tpe, annotTerm) =>
-        val retainsSym = Symbol.requiredClass("_root_.scala.annotation.retains")
-        val retainsCapSym = Symbol.requiredClass("_root_.scala.annotation.retainsCap")
-        val retainsByNameSym = Symbol.requiredClass("_root_.scala.annotation.retainsByName")
-        val retainsSym2 = Symbol.requiredClass("scala.annotation.retains")
-        val retainsCapSym2 = Symbol.requiredClass("scala.annotation.retainsCap")
-        val retainsByNameSym2 = Symbol.requiredClass("scala.annotation.retainsByName")
-        val sym = annotTerm.tpe match
-          case AppliedType(base, _) => base.typeSymbol
-          case other                => other.typeSymbol
-        if sym.name.contains("retains") then
-          println("Annot: " + sym)
-          println("name: " + sym.fullName)
-          println("id: " + System.identityHashCode(sym))
-          println("isClassDef: " + sym.isClassDef)
-          println("isRetains: " + sym == retainsSym)
-          println("isRetainsCap: " + sym == retainsCapSym)
-          println("isRetainsByName: " + sym == retainsByNameSym)
-          println("isRetains2: " + sym == retainsSym2)
-          println("isRetainsCap2: " + sym == retainsCapSym2)
-          println("isRetainsByName2: " + sym == retainsByNameSym2)
-          println("retainsSym " + retainsSym)
-          println("retainsSym2 " + retainsSym2)
-          println("retainsSym.isClassDef " + retainsSym.isClassDef)
-          println("retainsSym2.isClassDef " + retainsSym2.isClassDef)
-          println("retainsSym.id " + System.identityHashCode(retainsSym))
-          println("retainsSym2.id " + System.identityHashCode(retainsSym2))
-          println()
+      case AnnotatedType(tpe, annotTerm) if annotTerm.isRetains =>
+        inner(tpe) :+ plain(" @retains") // FIXME
+      case AnnotatedType(tpe, _) =>
         inner(tpe)
       case tl @ TypeLambda(params, paramBounds, AppliedType(tpe, args))
         if paramBounds.map(inner).forall(_.isEmpty) && params.zip(args.map(inner).flatten.map(_.name)).forall(_ == _) =>