Handle exports presenting in scala3doc

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/Extractors.scala

@@ -29,6 +29,7 @@ object Extractors {
     if (flags.is(Flags.Enum)) flagList += "Flags.Enum"
     if (flags.is(Flags.Erased)) flagList += "Flags.Erased"
     if (flags.is(Flags.ExtensionMethod)) flagList += "Flags.ExtensionMethod"
+    if (flags.is(Flags.Exported)) flagList += "Flags.Exported"
     if (flags.is(Flags.FieldAccessor)) flagList += "Flags.FieldAccessor"
     if (flags.is(Flags.Final)) flagList += "Flags.Final"
     if (flags.is(Flags.HasDefault)) flagList += "Flags.HasDefault"

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-testcases/src/tests/exports.scala

@@ -0,0 +1,23 @@
+package tests
+package exports 
+
+class A:
+  def aDefInt: Int = 1
+  def aDef1: 1 = 1
+  val aValInt: Int = 1
+  val aVal1: 1 = 1
+  var aVarInt: Int = 1
+  var aVar1: 1 = 1
+
+object X:
+  def xDefInt: Int = 1
+  def xDef1: 1 = 1
+  val xValInt: Int = 1
+  val xVal1: 1 = 1
+  var xVarInt: Int = 1
+  var xVar1: 1 = 1
+
+class B:
+  val a = new A
+  export a._
+  export X._

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: Option[DRI])
   case DefinedWithin
 
 case class Annotation(val dri: DRI, val params: List[Annotation.AnnotationParameter])

scala3doc/src/dotty/dokka/site/PartiallyRenderedContent.scala

@@ -40,3 +40,23 @@ case class PartiallyRenderedContent(
       }
     }// forrach does not work here
     document.outerHtml()
+
+
+class A:
+  def defInt: Int = 1
+  def def1: 1 = 1
+  val valInt: Int = 1
+  val val1: 1 = 1
+  var varInt: Int = 1
+  var var1: 1 = 1
+
+object X:
+  def x: Int = 1
+  val x2: 1 = 1
+  var x3: Int = 1
+
+class B:
+  val a = new A
+  export a._
+  export X._
+

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

@@ -123,6 +123,21 @@ 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.collect { 
+          case a: Apply => a.fun.asInstanceOf[Select]
+          case s: Select => s
+        }
+        val functionName = exportedTarget.fold("function")(_.name)
+        val instanceName = exportedTarget.collect {
+          case Select(qualifier: Select, _) => qualifier.name
+          case Select(qualifier: Ident, _) => qualifier.tpe.typeSymbol.normalizedName
+        }.getOrElse("instance")
+        val dri = dd.rhs.collect {
+          case s: Select if s.symbol.isDefDef => s.symbol.dri 
+        }.orElse(exportedTarget.map(_.qualifier.tpe.typeSymbol.dri))
+        Some(parseMethod(dd.symbol, kind = Kind.Exported).withOrigin(Origin.ExportedFrom(s"$instanceName.$functionName", dri)))
 
       case dd: DefDef if !dd.symbol.isHiddenByVisibility && !dd.symbol.isGiven && !dd.symbol.isSyntheticFunc && !dd.symbol.isExtensionMethod =>
         Some(parseMethod(dd.symbol))
@@ -184,7 +199,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/tasty/TypesSupport.scala

@@ -215,9 +215,12 @@ trait TypesSupport:
         //     case _ =>
         //     throw Exception("Match error in TypeRef. This should not happen, please open an issue. " + convertTypeOrBoundsToReference(reflect)(qual))
         // }
-      case tr @ TermRef(qual, typeName) => qual match {
-        case _ => link(tr.termSymbol)
-      }
+      case tr @ TermRef(qual, typeName) => 
+        tr.termSymbol.tree match
+          case vd: ValDef => inner(vd.tpt.tpe)
+          case _          => link(tr.termSymbol)
+
+
         // convertTypeOrBoundsToReference(reflect)(qual) match {
         //     case TypeReference(label, link, xs, _) => TypeReference(typeName + "$", link + "/" + label, xs)
         //     case EmptyReference => TypeReference(typeName, "", Nil)

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"from $name")
         case _ => Map.empty
     case null =>
       Map.empty

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

@@ -489,6 +489,11 @@ 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) => 
+            val signatureName: String | dotty.dokka.model.api.Link = dri match
+              case Some(dri: DRI) => SLink(name, dri)
+              case None => name
+            Signature("Exported from ", signatureName)
           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