Handle exports presenting in scala3doc

Author: BarkingBad

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -2436,6 +2436,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       def EmptyFlags = dotc.core.Flags.EmptyFlags
       def Enum: Flags = dotc.core.Flags.Enum
       def Erased: Flags = dotc.core.Flags.Erased
+      def Exported: Flags = dotc.core.Flags.Exported
       def ExtensionMethod: Flags = dotc.core.Flags.ExtensionMethod
       def FieldAccessor: Flags = dotc.core.Flags.Accessor
       def Final: Flags = dotc.core.Flags.Final

compiler/src/scala/quoted/runtime/impl/printers/SourceCode.scala

@@ -30,6 +30,7 @@ object SourceCode {
     if (flags.is(Flags.Enum)) flagList += "enum"
     if (flags.is(Flags.Erased)) flagList += "erased"
     if (flags.is(Flags.ExtensionMethod)) flagList += "extension"
+    if (flags.is(Flags.Exported)) flagList += "exported"
     if (flags.is(Flags.FieldAccessor)) flagList += "accessor"
     if (flags.is(Flags.Final)) flagList += "final"
     if (flags.is(Flags.HasDefault)) flagList += "hasDefault"

library/src/scala/quoted/Quotes.scala

@@ -3154,6 +3154,9 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       /** Is this symbol `erased` */
       def Erased: Flags
 
+      /** Is this symbol exported from provided instance */
+      def Exported: Flags
+
       /** Is this symbol a `def` defined in an `extension` */
       def ExtensionMethod: Flags
 

scala3doc/src/dotty/dokka/model/api/api.scala

@@ -63,6 +63,7 @@ enum Kind(val name: String){
   case Constructor extends Kind("def")
   case Var extends Kind("var")
   case Val extends Kind("val")
+  case Exported extends Kind("export")
   case Type(concreate: Boolean, opaque: Boolean) extends Kind("Type") // should we handle opaque as modifier?
   case Given(as: Option[Signature], conversion: Option[ImplicitConversion]) extends Kind("Given") with ImplicitConversionProvider
   case Implicit(kind: Kind, conversion: Option[ImplicitConversion]) extends Kind(kind.name)  with ImplicitConversionProvider
@@ -73,6 +74,7 @@ enum Origin:
   case InheritedFrom(name: String, dri: DRI)
   case ImplicitlyAddedBy(name: String, dri: DRI)
   case ExtensionFrom(name: String, dri: DRI)
+  case ExportedFrom(name: String, dri: DRI)
   case DefinedWithin
 
 case class Annotation(val dri: DRI, val params: List[Annotation.AnnotationParameter])

scala3doc/src/dotty/dokka/tasty/ClassLikeSupport.scala

@@ -123,6 +123,17 @@ trait ClassLikeSupport:
           .map { _ =>
             parseMethod(dd.symbol, kind = Kind.Given(getGivenInstance(dd).map(_.asSignature), None))
           }
+          
+      case dd: DefDef if !dd.symbol.isHiddenByVisibility && dd.symbol.isExported =>
+        val exportedTarget = dd.rhs.flatMap { 
+          case a: Apply => Some(a.fun)
+          case _ => None
+        }.map { 
+          case s: Select => s
+        } 
+        val functionName = exportedTarget.fold("instance")(_.name)
+        val instanceName = exportedTarget.fold("function")(_.qualifier.asInstanceOf[Select].name)
+        Some(parseMethod(dd.symbol, kind = Kind.Exported).withOrigin(Origin.ExportedFrom(s"$instanceName.$functionName", dd.symbol.dri)))
 
       case dd: DefDef if !dd.symbol.isHiddenByVisibility && !dd.symbol.isGiven && !dd.symbol.isSyntheticFunc && !dd.symbol.isExtensionMethod =>
         Some(parseMethod(dd.symbol))
@@ -184,7 +195,6 @@ trait ClassLikeSupport:
         case dd: DefDef if !dd.symbol.isClassConstructor && !(dd.symbol.isSuperBridgeMethod || dd.symbol.isDefaultHelperMethod) => dd
         case other => other
       }
-
       c.membersToDocument.flatMap(parseMember) ++
         inherited.flatMap(s => parseInheritedMember(s))
     }

scala3doc/src/dotty/dokka/tasty/SymOps.scala

@@ -82,6 +82,8 @@ class SymOps[Q <: Quotes](val q: Q):
 
     def isGiven: Boolean = sym.flags.is(Flags.Given)
 
+    def isExported: Boolean = sym.flags.is(Flags.Exported)
+
     def isExtensionMethod: Boolean = sym.flags.is(Flags.ExtensionMethod)
 
     def isLeftAssoc(d: Symbol): Boolean = !d.name.endsWith(":")

scala3doc/src/dotty/dokka/translators/FilterAttributes.scala

@@ -43,6 +43,7 @@ object FilterAttributes:
         case Origin.InheritedFrom(name, _) => Map("inherited" -> name)
         case Origin.ImplicitlyAddedBy(name, _) => Map("implicitly" -> s"by $name")
         case Origin.ExtensionFrom(name, _) => Map("extension" -> s"from $name")
+        case Origin.ExportedFrom(name, _) => Map("export" -> s"Exported from $name")
         case _ => Map.empty
     case null =>
       Map.empty

scala3doc/src/dotty/dokka/translators/ScalaContentBuilder.scala

@@ -489,6 +489,7 @@ class ScalaPageContentBuilder(
         val originInfo = documentable.origin match {
           case Origin.ImplicitlyAddedBy(name, dri) => Signature("Implicitly added by ", SLink(name, dri))
           case Origin.ExtensionFrom(name, dri) => Signature("Extension method from ", SLink(name, dri))
+          case Origin.ExportedFrom(name, dri) => Signature("Exported from ", SLink(name, dri))
           case _ => Nil
         }
 

scala3doc/src/dotty/dokka/translators/ScalaPageCreator.scala

@@ -351,6 +351,7 @@ class ScalaPageCreator(
       val (definedTypes, inheritedTypes) = s.membersBy(_.kind.isInstanceOf[Kind.Type])
       val (definedGivens, inheritedGives) = s.membersBy(_.kind.isInstanceOf[Kind.Given])
       val (definedExtensions, inheritedExtensions) = s.membersBy(_.kind.isInstanceOf[Kind.Extension])
+      val exports = s.allMembers.filter(_.kind == Kind.Exported)
       val (definedImplicits, inheritedImplicits) = s.membersBy(_.kind.isInstanceOf[Kind.Implicit])
 
       b
@@ -381,6 +382,9 @@ class ScalaPageCreator(
           DocumentableGroup(Some("Defined implicits"), definedImplicits),
           DocumentableGroup(Some("Inherited implicits"), inheritedImplicits)
         )
+        .documentableTab("Exports")(
+          DocumentableGroup(Some("Defined exports"), exports)
+        )
 
 
     def contentForEnum(c: DClass) =

scala3doc/src/dotty/dokka/translators/ScalaSignatureProvider.scala

@@ -49,6 +49,8 @@ object ScalaSignatureProvider:
         extensionSignature(extension, builder)
       case method: DFunction if method.kind.isInstanceOf[Kind.Given] =>
         givenMethodSignature(method, builder)
+      case exprt: DFunction if exprt.kind == Kind.Exported =>
+        exportedMethodSignature(exprt, builder)
       case method: DFunction =>
         methodSignature(method, builder)
       case enumEntry: DClass if enumEntry.kind == Kind.EnumCase =>
@@ -138,14 +140,14 @@ object ScalaSignatureProvider:
     } else {
       extension.getParameters.asScala(0)
     }
-    val withSinature = builder
+    val withSignature = builder
       .modifiersAndVisibility(extension, "def")
       .name(extension.getName, extension.getDri)
       .generics(extension)
       .functionParameters(extension)
 
-    if extension.isConstructor then withSinature
-    else withSinature.text(":").text(" ").typeSignature(extension.getType)
+    if extension.isConstructor then withSignature
+    else withSignature.text(":").text(" ").typeSignature(extension.getType)
 
   private def givenMethodSignature(method: DFunction, builder: SignatureBuilder): SignatureBuilder = method.kind match
     case Kind.Given(Some(instance), _) =>
@@ -156,6 +158,8 @@ object ScalaSignatureProvider:
     case _ =>
       builder.text("given ").name(method.getName, method.getDri)
 
+  private def exportedMethodSignature(method: DFunction, builder: SignatureBuilder): SignatureBuilder = 
+    methodSignature(method, builder)
 
   private def methodSignature(method: DFunction, builder: SignatureBuilder): SignatureBuilder =
     val bdr = builder