Scaladoc: Detect if CC was imported

Author: bracevac

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

@@ -115,10 +115,9 @@ trait TypesSupport:
         ++ keyword(" & ").l
         ++ inParens(inner(right), shouldWrapInParens(right, tp, false))
       case ByNameType(CapturingType(tpe, refs)) =>
-        renderCaptureArrow(using qctx)(refs, false) ++ (plain(" ") :: inner(tpe))
+        renderFunctionArrow(using qctx)(refs, true, false) ++ (plain(" ") :: inner(tpe))
       case ByNameType(tpe) =>
-        tpe.typeSymbol.pos.map(p => report.warning(s"Pure ByNameType at ${p}"))
-        keyword("-> ") :: inner(tpe) // FIXME need to check if cc is enabled in current file first!!!
+        (if ccEnabled then keyword("-> ") else keyword("=> ")):: inner(tpe)
       case ConstantType(constant) =>
         plain(constant.show).l
       case ThisType(tpe) =>
@@ -248,7 +247,8 @@ trait TypesSupport:
         ++ plain(" ").l
         ++ inParens(inner(rhs), shouldWrapInParens(rhs, t, false))
 
-      case t @ AppliedType(tpe, args) if t.isFunctionType => functionType(t, tpe, args)
+      case t @ AppliedType(tpe, args) if t.isFunctionType =>
+        functionType(t, tpe, args)
 
       case t @ AppliedType(tpe, typeList) =>
         inner(tpe) ++ plain("[").l ++ commas(typeList.map { t => t match
@@ -346,7 +346,7 @@ trait TypesSupport:
       Some(List(CaptureDefs.captureRoot.termRef))
     else
       inCC
-    val arrow = plain(" ") :: (renderCaptureArrow(using qctx)(refs, t.isContextFunctionType) ++ plain(" ").l)
+    val arrow = plain(" ") :: (renderFunctionArrow(using qctx)(refs, t.isFunction1, t.isContextFunctionType) ++ plain(" ").l)
     given Option[List[TypeRepr]] = None // FIXME: this is ugly
     args match
       case Nil => Nil
@@ -485,17 +485,23 @@ trait TypesSupport:
     import reflect._
     Keyword("^") :: renderCaptureSet(refs)
 
-  private def renderCaptureArrow(using Quotes)(refs: List[reflect.TypeRepr], isImplicitFun: Boolean)(using elideThis: reflect.ClassDef): SSignature =
+  private def renderFunctionArrow(using Quotes)(refs: List[reflect.TypeRepr], isPureFun: Boolean, isImplicitFun: Boolean)(using elideThis: reflect.ClassDef): 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(refs)
+    if !ccEnabled then
+      List(Keyword(prefix + "=>"))
+    else
+      refs match
+        case Nil => if isPureFun then List(Keyword(prefix + "->")) else List(Keyword(prefix + "=>"))
+        case List(ref) if ref.isCaptureRoot => List(Keyword(prefix + "=>"))
+        case refs => Keyword(prefix + "->") :: renderCaptureSet(refs)
 
-  private def renderCaptureArrow(using qctx: Quotes)(refs: Option[List[reflect.TypeRepr]], isImplicitFun: Boolean)(using elideThis: reflect.ClassDef): SSignature =
+  private def renderFunctionArrow(using qctx: Quotes)(refs: Option[List[reflect.TypeRepr]], isPureFun: Boolean, isImplicitFun: Boolean)(using elideThis: reflect.ClassDef): 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 qctx)(refs, isImplicitFun)
+    if !ccEnabled then
+      List(Keyword(prefix + "=>"))
+    else
+      refs match
+        case None => if isPureFun then List(Keyword(prefix + "->")) else List(Keyword(prefix + "=>"))
+        case Some(refs) => renderFunctionArrow(using qctx)(refs, isPureFun, isImplicitFun)