Scaladoc: Detect if CC was imported

Author: natsukagami

local/project/dummy/arrows.scala

@@ -1,6 +1,7 @@
 package dummy
 
 import language.experimental.captureChecking
+import language.experimental.pureFunctions
 import caps.*
 
 trait Nested:

local/project/dummy/nocc.scala

@@ -0,0 +1,6 @@
+package dummy
+
+trait NoCaptureChecking:
+  def byName(f: => Int): Int
+  def impure(f: Int => Int): Int
+  def context(f: Int ?=> Int): Int

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

@@ -44,6 +44,7 @@ enum Modifier(val name: String, val prefix: Boolean):
   case Transparent extends Modifier("transparent", true)
   case Infix extends Modifier("infix", true)
   case AbsOverride extends Modifier("abstract override", true)
+  case Mut extends Modifier("mut", true)
 
 case class ExtensionTarget(name: String, typeParams: Seq[TypeParameter], argsLists: Seq[TermParameterList], signature: Signature, dri: DRI, position: Long)
 case class ImplicitConversion(from: DRI, to: DRI)

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

@@ -36,6 +36,20 @@ object CaptureDefs:
     qctx.reflect.Symbol.requiredClass("scala.annotation.internal.readOnlyCapability")
   def RequiresCapabilityAnnot(using qctx: Quotes) =
     qctx.reflect.Symbol.requiredClass("scala.annotation.internal.requiresCapability")
+
+  def LanguageExperimental(using qctx: Quotes) =
+    qctx.reflect.Symbol.requiredPackage("scala.language.experimental")
+
+  def ImpureFunction1(using qctx: Quotes) =
+    qctx.reflect.Symbol.requiredClass("scala.ImpureFunction1")
+
+  def ImpureContextFunction1(using qctx: Quotes) =
+    qctx.reflect.Symbol.requiredClass("scala.ImpureContextFunction1")
+
+  def Function1(using qctx: Quotes) =
+    qctx.reflect.Symbol.requiredClass("scala.Function1")
+
+  val ccImportSelector = "captureChecking"
 end CaptureDefs
 
 extension (using qctx: Quotes)(ann: qctx.reflect.Symbol)
@@ -53,8 +67,28 @@ end extension
 
 extension (using qctx: Quotes)(tpe: qctx.reflect.TypeRepr)
   def isCaptureRoot: Boolean = tpe.termSymbol == CaptureDefs.captureRoot
+
+  def isImpureFunction1: Boolean = tpe.derivesFrom(CaptureDefs.ImpureFunction1)
+
+  def isImpureContextFunction1: Boolean = tpe.derivesFrom(CaptureDefs.ImpureContextFunction1)
+
+  def isFunction1: Boolean = tpe.derivesFrom(CaptureDefs.Function1)
 end extension
 
+/** Matches `import scala.language.experimental.captureChecking` */
+object CCImport:
+  def unapply(using qctx: Quotes)(tree: qctx.reflect.Tree): Boolean =
+    import qctx.reflect._
+    tree match
+      case imprt: Import if imprt.expr.tpe.termSymbol == CaptureDefs.LanguageExperimental =>
+        imprt.selectors.exists {
+          case SimpleSelector(s) if s == CaptureDefs.ccImportSelector => true
+          case _ => false
+        }
+      case _ => false
+  end unapply
+end CCImport
+
 object ReachCapability:
   def unapply(using qctx: Quotes)(ty: qctx.reflect.TypeRepr): Option[qctx.reflect.TypeRepr] =
     import qctx.reflect._

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

@@ -5,6 +5,8 @@ import scala.jdk.CollectionConverters._
 
 import SymOps._
 
+import dotty.tools.scaladoc.cc.CCImport
+
 trait PackageSupport:
     self: TastyParser =>
     import qctx.reflect._
@@ -13,6 +15,11 @@ trait PackageSupport:
 
     def parsePackage(pck: PackageClause): (String, Member) =
       val name = pck.symbol.fullName
+      ccFlag = false // FIXME: would be better if we had access to the tasty attribute
+      pck.stats.foreach {
+          case CCImport() => ccFlag = true
+          case _ =>
+      }
       (name, Member(name, "", pck.symbol.dri, Kind.Package))
 
     def parsePackageObject(pckObj: ClassDef): (String, Member) =

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

@@ -187,6 +187,9 @@ case class TastyParser(
 
   private given qctx.type = qctx
 
+  protected var ccFlag: Boolean = false
+  def ccEnabled: Boolean = ccFlag
+
   val intrinsicClassDefs = Set(
     defn.AnyClass,
     defn.MatchableClass,

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

@@ -11,6 +11,8 @@ import dotty.tools.scaladoc.cc.*
 import NameNormalizer._
 import SyntheticsSupport._
 
+private case class FunKind(isPure: Boolean, isImplicit: Boolean)
+
 trait TypesSupport:
   self: TastyParser =>
 
@@ -122,10 +124,9 @@ trait TypesSupport:
         ++ keyword(" & ").l
         ++ inParens(inner(right, skipThisTypePrefix), shouldWrapInParens(right, tp, false))
       case ByNameType(CapturingType(tpe, refs)) =>
-        renderCaptureArrow(using q)(refs, false, skipThisTypePrefix) ++ (plain(" ") :: inner(tpe, skipThisTypePrefix))
+        renderFunctionArrow(using q)(refs, FunKind(true, false), skipThisTypePrefix) ++ (plain(" ") :: inner(tpe, skipThisTypePrefix))
       case ByNameType(tpe) =>
-        tpe.typeSymbol.pos.map(p => report.warning(s"Pure ByNameType at ${p}"))
-        keyword("-> ") :: inner(tpe, skipThisTypePrefix) // FIXME need to check if cc is enabled in current file first!!!
+        (if ccEnabled then keyword("-> ") else keyword("=> ")):: inner(tpe, skipThisTypePrefix)
       case ConstantType(constant) =>
         plain(constant.show).l
       case ThisType(tpe) =>
@@ -256,7 +257,8 @@ trait TypesSupport:
         ++ plain(" ").l
         ++ inParens(inner(rhs, skipThisTypePrefix), shouldWrapInParens(rhs, t, false))
 
-      case t @ AppliedType(tpe, args) if t.isFunctionType => functionType(t, tpe, args, skipThisTypePrefix)
+      case t @ AppliedType(tpe, args) if t.isFunctionType =>
+        functionType(t, tpe, args, skipThisTypePrefix)
 
       case t @ AppliedType(tpe, typeList) =>
         inner(tpe, skipThisTypePrefix) ++ plain("[").l ++ commas(typeList.map { t => t match
@@ -356,7 +358,7 @@ trait TypesSupport:
       Some(List(CaptureDefs.captureRoot.termRef))
     else
       inCC
-    val arrow = plain(" ") :: (renderCaptureArrow(using q)(refs, t.isContextFunctionType, skipThisTypePrefix) ++ plain(" ").l)
+    val arrow = plain(" ") :: (renderFunctionArrow(using q)(refs, FunKind(isPure = t.isFunction1, isImplicit = t.isContextFunctionType), skipThisTypePrefix) ++ plain(" ").l)
     given Option[List[TypeRepr]] = None // FIXME: this is ugly
     args match
       case Nil => Nil
@@ -505,21 +507,27 @@ trait TypesSupport:
     import reflect._
     Keyword("^") :: renderCaptureSet(refs, skipThisTypePrefix)
 
-  private def renderCaptureArrow(using q: Quotes)(refs: List[reflect.TypeRepr], isImplicitFun: Boolean, skipThisTypePrefix: Boolean)(
+  private def renderFunctionArrow(using q: Quotes)(refs: List[reflect.TypeRepr], fun: FunKind, skipThisTypePrefix: Boolean)(
     using elideThis: reflect.ClassDef, originalOwner: reflect.Symbol
   ): SSignature =
     import reflect._
-    val prefix = if isImplicitFun then "?" else ""
-    refs match
-      case Nil => List(Keyword(prefix + "->")) // FIXME need to check if cc is enabled in current file first!!!
-      case List(ref) if ref.isCaptureRoot => List(Keyword(prefix + "=>"))
-      case refs => Keyword(prefix + "->") :: renderCaptureSet(using q)(refs, skipThisTypePrefix)
+    val prefix = if fun.isImplicit then "?" else ""
+    if !ccEnabled then
+      List(Keyword(prefix + "=>"))
+    else
+      refs match
+        case Nil => if fun.isPure then List(Keyword(prefix + "->")) else List(Keyword(prefix + "=>"))
+        case List(ref) if ref.isCaptureRoot => List(Keyword(prefix + "=>"))
+        case refs => Keyword(prefix + "->") :: renderCaptureSet(using q)(refs, skipThisTypePrefix)
 
-  private def renderCaptureArrow(using q: Quotes)(refs: Option[List[reflect.TypeRepr]], isImplicitFun: Boolean, skipThisTypePrefix: Boolean)(
+  private def renderFunctionArrow(using q: Quotes)(refs: Option[List[reflect.TypeRepr]], fun: FunKind, skipThisTypePrefix: Boolean)(
     using elideThis: reflect.ClassDef, originalOwner: reflect.Symbol
   ): SSignature =
     import reflect._
-    val prefix = if isImplicitFun then "?" else ""
-    refs match
-      case None => List(Keyword(prefix + "->")) // FIXME need to check if cc is enabled in current file first!!!
-      case Some(refs) => renderCaptureArrow(using q)(refs, isImplicitFun, skipThisTypePrefix)
+    val prefix = if fun.isImplicit then "?" else ""
+    if !ccEnabled then
+      List(Keyword(prefix + "=>"))
+    else
+      refs match
+        case None => if fun.isPure then List(Keyword(prefix + "->")) else List(Keyword(prefix + "=>"))
+        case Some(refs) => renderFunctionArrow(using q)(refs, fun, skipThisTypePrefix)