Packages are are now represenet as Members

romanowski · romanowski · commit 06ea1888c643 · 2020-12-15T03:00:19.000+01:00
Top level package now has all features as any other one.
diff --git a/scala3doc/src/dotty/dokka/ScalaModuleCreator.scala b/scala3doc/src/dotty/dokka/ScalaModuleCreator.scala
@@ -7,7 +7,7 @@ import org.jetbrains.dokka.model.DModule
 import org.jetbrains.dokka.transformers.sources.SourceToDocumentableTranslator
 
 import dotty.dokka.tasty.DokkaTastyInspector
-import org.jetbrains.dokka.pages._
+import org.jetbrains.dokka.pages.{Kind => _, _}
 import dotty.dokka.model.api._
 import org.jetbrains.dokka.model._
 import org.jetbrains.dokka.base.parsers.MarkdownParser
@@ -17,12 +17,25 @@ import kotlin.coroutines.Continuation
 class ScalaModuleProvider(using ctx: DocContext) extends SourceToDocumentableTranslator:
    override def invoke(sourceSet: DokkaSourceSet, cxt: DokkaContext, unused: Continuation[? >: DModule]) =
     val result = DokkaTastyInspector(new MarkdownParser(_ => null)).result()
+    val (rootPck, rest) = result.partition(_.name == "<empty>")
 
     def flattenMember(m: Member): Seq[(DRI, Member)] = (m.dri -> m) +: m.allMembers.flatMap(flattenMember)
 
+    val topLevelPackage = new DPackage(
+      DRI(location = "<empty>"),
+      JNil,
+      JNil,
+      JNil,
+      JNil,
+      JMap(),
+      null,
+      JSet(ctx.sourceSet),
+      PropertyContainer.Companion.empty()
+    ).withNewMembers(rest ++ rootPck.flatMap(_.allMembers)).withKind(Kind.RootPackage).asInstanceOf[DPackage]
+
     new DModule(
       sourceSet.getDisplayName,
-      result.asJava,
+      JList(topLevelPackage),
       JMap(),
       null,
       sourceSet.toSet,
diff --git a/scala3doc/src/dotty/dokka/model/api/api.scala b/scala3doc/src/dotty/dokka/model/api/api.scala
@@ -54,6 +54,7 @@ trait ImplicitConversionProvider { def conversion: Option[ImplicitConversion] }
 trait Classlike
 
 enum Kind(val name: String){
+  case RootPackage extends Kind("")
   case Package extends Kind("package")
   case Class(typeParams: Seq[TypeParameter], argsLists: Seq[Seq[Parameter]])
     extends Kind("class") with Classlike
diff --git a/scala3doc/src/dotty/dokka/model/api/internalExtensions.scala b/scala3doc/src/dotty/dokka/model/api/internalExtensions.scala
@@ -99,7 +99,9 @@ extension (member: Member)
     val newExt = oldExt.copy(graph = oldExt.graph ++ edges)
     putInMember(newExt)
 
-  def updateRecusivly(op: Member => Member) = op(member).withMembers(member.allMembers.map(op))
+  def updateRecusivly(op: Member => Member): Member =
+    val newMembers = member.allMembers.map(_.updateRecusivly(op))
+    op(member).withMembers(newMembers)
 
 extension (bound: Bound)
   def asSignature: Signature = bound match
@@ -111,14 +113,18 @@ extension (bound: Bound)
       }
 
 extension (m: DModule)
-  def updatePackages(op: Seq[DPackage] => Seq[DPackage]): DModule =
+  def updatePackages(op: Seq[Member] => Seq[Member]): DModule =
+    val topLevelPck = m.getPackages.get(0)
+    val newRoot = topLevelPck.withMembers(op(topLevelPck.allMembers))
+
     m.copy(
-            m.getName,
-            op(m.getPackages.asScala.toSeq).asJava,
-            m.getDocumentation,
-            m.getExpectPresentInSet,
-            m.getSourceSets,
-            m.getExtra
-        )
-
-  def updateMembers(op: Member => Member): DModule = updatePackages(_.map(p => p.updateRecusivly(op).asInstanceOf[DPackage]))
+        m.getName,
+        JList(newRoot.asInstanceOf[DPackage]),
+        m.getDocumentation,
+        m.getExpectPresentInSet,
+        m.getSourceSets,
+        m.getExtra
+    )
+
+  def updateMembers(op: Member => Member): DModule =
+     updatePackages(_.map(p => p.updateRecusivly(op)))
diff --git a/scala3doc/src/dotty/dokka/site/NavigationCreator.scala b/scala3doc/src/dotty/dokka/site/NavigationCreator.scala
@@ -2,10 +2,10 @@ package dotty.dokka
 package site
 
 import org.jetbrains.dokka.base.renderers.html.{NavigationNode, NavigationPage}
-import org.jetbrains.dokka.model.DPackage
 import org.jetbrains.dokka.model.DModule
-import org.jetbrains.dokka.pages._
+import org.jetbrains.dokka.pages.{Kind => _, _}
 import org.jetbrains.dokka.transformers.pages.PageTransformer
+import dotty.dokka.model.api._
 
 import scala.collection.JavaConverters._
 
@@ -18,12 +18,9 @@ class NavigationCreator(using ctx: DocContext) extends PageTransformer:
         case cp: ContentPage => cp.getDocumentable match
           case null =>
             processChildren
-          // Left over package from dokka
-          case p: DPackage if p.getName == "<empty>" && p.getChildren.isEmpty =>
-            Nil
-          case p: DPackage =>
-            val ss = p.getSourceSets.asScala.toSet.toDisplay
-            List(new NavigationNode(p.getName, p.getDri, ss, JList())) ++ processChildren
+          case m: Member if m.kind == Kind.Package =>
+            val ss = m.getSourceSets.asScala.toSet.toDisplay
+            List(new NavigationNode(m.name, m.dri, ss, JNil)) ++ processChildren
           case _: DModule =>
             processChildren
           case _ =>
diff --git a/scala3doc/src/dotty/dokka/tasty/ClassLikeSupport.scala b/scala3doc/src/dotty/dokka/tasty/ClassLikeSupport.scala
@@ -445,10 +445,12 @@ trait ClassLikeSupport:
   def mkMember[T <: Kind](
     symbol: Symbol,
     member: MemberExtension,
-    compositeExt: CompositeMemberExtension = CompositeMemberExtension.empty): Member =
+    compositeExt: CompositeMemberExtension = CompositeMemberExtension.empty,
+    nameOverride: Symbol => String = _.normalizedName
+    ): Member =
       new DClass(
         symbol.dri,
-        symbol.normalizedName,
+        nameOverride(symbol),
         JNil,
         JNil,
         JNil,
diff --git a/scala3doc/src/dotty/dokka/tasty/PackageSupport.scala b/scala3doc/src/dotty/dokka/tasty/PackageSupport.scala
@@ -6,47 +6,21 @@ import org.jetbrains.dokka.links.PointingToDeclaration
 import org.jetbrains.dokka.model.properties._
 import org.jetbrains.dokka.model.doc.DocumentationNode
 import dotty.dokka._
-import dotty.dokka.model.api.CompositeMemberExtension
+import dotty.dokka.model.api._
 
 import collection.JavaConverters._
 
 trait PackageSupport:
     self: TastyParser =>
     import qctx.reflect._
 
-    def parsePackage(pck: PackageClause): DPackage = {
-        val name = extractPackageName(pck.pid.show)
-        val documentation = pck.symbol.documentation
-        DPackage(
-          new DRI(name, null, null, PointingToDeclaration.INSTANCE, null),
-          JList(),
-          JList(),
-          JList(),
-          JList(),
-          documentation.asJava,
-          null,
-          ctx.sourceSet.toSet,
-          PropertyContainer.Companion.empty()
-        )
-    }
-
-    def parsePackageObject(pckObj: ClassDef): DPackage =
-        parseClasslike(pckObj) match {
-          case clazz: DClass =>
-            DPackage(
-              new DRI(pckObj.symbol.packageName, null, null, PointingToDeclaration.INSTANCE, null),
-              clazz.getFunctions,
-              clazz.getProperties,
-              JList(),
-              JList(),
-              pckObj.symbol.documentation.asJava,
-              null,
-              ctx.sourceSet.toSet,
-              PropertyContainer.Companion.empty()
-                .plus(clazz.get(CompositeMemberExtension))
-            )
-        }
+    def parsePackage(pck: PackageClause): (String, Member) =
+      val name = extractPackageName(pck.pid.show)
+      val mExt = MemberExtension.empty.copy(kind = Kind.Package)
+      name -> mkMember(pck.symbol, mExt, nameOverride = _ => name)
 
+    def parsePackageObject(pckObj: ClassDef): (String, Member) =
+      pckObj.symbol.packageName -> parseClasslike(pckObj).withKind(Kind.Package)
 
     private def extractPackageName(pidShowNoColor: String): String = {
         val pidSplit = pidShowNoColor.split("\\.")
diff --git a/scala3doc/src/dotty/dokka/tasty/TastyParser.scala b/scala3doc/src/dotty/dokka/tasty/TastyParser.scala
@@ -28,7 +28,7 @@ import dotty.dokka.model.api._
   */
 case class DokkaTastyInspector(parser: Parser)(using ctx: DocContext) extends DocTastyInspector:
 
-  private val topLevels = Seq.newBuilder[Documentable]
+  private val topLevels = Seq.newBuilder[(String, Member)]
 
   def processCompilationUnit(using q: Quotes)(root: q.reflect.Tree): Unit =
     // NOTE we avoid documenting definitions in the magical stdLibPatches directory;
@@ -48,72 +48,21 @@ case class DokkaTastyInspector(parser: Parser)(using ctx: DocContext) extends Do
       topLevels ++= parser.parseRootTree(root.asInstanceOf[parser.qctx.reflect.Tree])
   end processCompilationUnit
 
-  def result(): List[DPackage] =
+  def result(): List[Member] =
     topLevels.clear()
     val filePaths = ctx.args.tastyFiles.map(_.getAbsolutePath).toList
     val classpath = ctx.args.classpath.split(java.io.File.pathSeparator).toList
 
     inspectFilesInContext(classpath, filePaths)
 
     val all = topLevels.result()
-    val packages = all
-      .filter(_.isInstanceOf[DPackage])
-      .map(_.asInstanceOf[DPackage])
-      .groupBy(_.getDri)
-      .map((dri, pckgs) =>
-        pckgs.reduce(_.mergeWith(_))
-      )
-      .toList
-      .sortBy( pckg => pckg.dri.location.size )
-      .reverse
-
-
-    val byPackage = all.filter(_.dri != null).groupBy( p =>
-      packages.find(d => p.dri.location.contains(d.dri.location)).getOrElse(throw IllegalStateException("No package for entries found"))
-    )
-
-    byPackage
-      .map {
-        case (f, entries) => {
-          val pck = new DPackage(
-              f.getDri,
-              f.getFunctions,
-              f.getProperties,
-              JList(),
-              JList(),
-              f.getDocumentation,
-              null,
-              JSet(ctx.sourceSet),
-              f.getExtra
-            )
-            .withNewMembers(entries.filterNot(_.isInstanceOf[DPackage]).toList)
-            .withKind(Kind.Package)
-
-          pck.asInstanceOf[DPackage]
-        }
+    all.groupBy(_._1).map { case (pckName, members) =>
+      val (pcks, rest) = members.map(_._2).partition(_.kind == Kind.Package)
+      pcks.reduce( (p1, p2) =>
+        p1.withNewMembers(p2.allMembers) // TODO add doc
+      ).withNewMembers(rest)
     }.toList
 
-  extension (self: DPackage) def mergeWith(other: DPackage): DPackage =
-    def nodes(p: DPackage): JList[TagWrapper] = p.getDocumentation.get(ctx.sourceSet) match
-      case null => JList[TagWrapper]()
-      case node => node.getChildren
-
-    mergeExtras(
-      DPackage(
-        self.getDri,
-        (self.getFunctions.asScala ++ other.getFunctions.asScala).asJava,
-        (self.getProperties.asScala ++ other.getProperties.asScala).asJava,
-        JList(), // WARNING Merging is done before collecting classlikes, if it changes it needs to be refactored
-        JList(),
-        ctx.sourceSet.toMap(DocumentationNode(nodes(self) ++ nodes(other))),
-        null,
-        ctx.sourceSet.toSet,
-        PropertyContainer.Companion.empty()
-      ),
-      self,
-      other
-    )
-
 /** Parses a single Tasty compilation unit. */
 case class TastyParser(qctx: Quotes, inspector: DokkaTastyInspector)(using val ctx: DocContext)
     extends ScaladocSupport with BasicSupport with TypesSupport with ClassLikeSupport with SyntheticsSupport with PackageSupport with NameNormalizer:
@@ -135,8 +84,8 @@ case class TastyParser(qctx: Quotes, inspector: DokkaTastyInspector)(using val c
           report.warning(s"Failed to process ${sym.fullName}:\n${throwableToString(t)}")
       None
 
-  def parseRootTree(root: Tree): Seq[Documentable] =
-    val docs = Seq.newBuilder[Documentable]
+  def parseRootTree(root: Tree): Seq[(String, Member)] =
+    val docs = Seq.newBuilder[(String, Member)]
     object Traverser extends TreeTraverser:
       var seen: List[Tree] = Nil
 
@@ -149,7 +98,7 @@ case class TastyParser(qctx: Quotes, inspector: DokkaTastyInspector)(using val c
           case packageObject: ClassDef if(packageObject.symbol.name.contains("package$")) =>
             docs += parsePackageObject(packageObject)
           case clazz: ClassDef if clazz.symbol.shouldDocumentClasslike =>
-            docs += parseClasslike(clazz)
+            docs += clazz.symbol.packageName -> parseClasslike(clazz)
           case _ =>
         }
         seen = seen.tail
diff --git a/scala3doc/src/dotty/dokka/transformers/ImplicitMembersExtensionTransformer.scala b/scala3doc/src/dotty/dokka/transformers/ImplicitMembersExtensionTransformer.scala
@@ -62,4 +62,4 @@ class ImplicitMembersExtensionTransformer(using DocContext) extends Documentable
       val expandedMembers = c.allMembers.map(expandMember(newImplicitMembers ++ Seq(c)))
       c.withMembers(newImplicitMembers ++ expandedMembers)
 
-    original.updatePackages(_.map(expandMember(Nil)(_).asInstanceOf[DPackage]))
+    original.updatePackages(_.map(expandMember(Nil)(_)))
diff --git a/scala3doc/src/dotty/dokka/transformers/InheritanceInformationTransformer.scala b/scala3doc/src/dotty/dokka/transformers/InheritanceInformationTransformer.scala
@@ -12,14 +12,14 @@ import dotty.dokka.model.api._
 
 class InheritanceInformationTransformer(val ctx: DokkaContext) extends DocumentableTransformer:
   override def invoke(original: DModule, context: DokkaContext): DModule =
-    val subtypes = getSupertypes(original).groupBy(_._1).transform((k, v) => v.map(_._2))
+    val subtypes = getSupertypes(original.getPackages.get(0)).groupBy(_._1).transform((k, v) => v.map(_._2))
     original.updateMembers { m =>
       val st: Seq[LinkToType] = subtypes.getOrElse(m.dri, Nil)
       m.withKnownChildren(st).withNewGraphEdges(st.map(_ -> m.asLink))
     }
 
-  private def getSupertypes(d: Documentable): Seq[(DRI, LinkToType)] = d match
-    case m: DModule => m.getPackages.asScala.toList.flatMap(p => getSupertypes(p))
-    case c: Member  =>
-      val selfMapping = if !c.kind.isInstanceOf[Classlike] then Nil else c.parents.map(_._2 -> c.asLink)
-      c.allMembers.flatMap(getSupertypes) ++ selfMapping
+  private def getSupertypes(c: Member): Seq[(DRI, LinkToType)] =
+    val selfMapping =
+      if !c.kind.isInstanceOf[Classlike] then Nil
+      else c.parents.map(_._2 -> c.asLink)
+    c.allMembers.flatMap(getSupertypes) ++ selfMapping
diff --git a/scala3doc/src/dotty/dokka/translators/ScalaPageCreator.scala b/scala3doc/src/dotty/dokka/translators/ScalaPageCreator.scala
@@ -32,24 +32,22 @@ class ScalaPageCreator(
   private val contentBuilder =
     ScalaPageContentBuilder(commentsToContentConverter, signatureProvider)
 
-  override def pageForModule(m: DModule): ModulePageNode = super.pageForModule(m)
+  override def pageForModule(m: DModule): ModulePageNode =
+    val rootPackage = m.getPackages.get(0)
+    new ModulePageNode(
+      m.getName,
+      contentBuilder.mkMemberInfo(rootPackage),
+      m,
+      pagesForMembers(rootPackage),
+      JNil
+    )
 
   private def pagesForMembers(member: Member): JList[PageNode] =
     val all = member
-      .membersBy(_.kind.isInstanceOf[Classlike])
+      .membersBy(m => m.kind == Kind.Package || m.kind.isInstanceOf[Classlike])
       .filter(m => m.origin == Origin.RegularlyDefined && m.inheritedFrom.isEmpty)
     all.map(pageForMember(_)).asJava
 
-  override def pageForPackage(p: DPackage): PackagePageNode =
-    PackagePageNode(
-      p.name,
-      contentBuilder.mkMemberInfo(p),
-      JSet(p.dri),
-      p,
-      pagesForMembers(p),
-      JNil
-    )
-
   def pageForMember(c: Member): ClasslikePageNode = {
     val name =
       if c.kind == Kind.Object && c.companion.isDefined then
@@ -66,38 +64,3 @@ class ScalaPageCreator(
       JNil,
     ).modified(name, pagesForMembers(c)) // We need override default page
   }
-
-  override def contentForModule(m: DModule) = {
-    def buildBlock = (builder: DocBuilder) => builder
-      .group(kind = ContentKind.Cover) { gbuilder => gbuilder
-        .cover(m.getName)()
-        .descriptionIfNotEmpty(m)
-      }
-      .addChildren(contentForComments(m).asScala.toSeq)
-      .groupingBlock(
-        "Packages",
-        List("" -> m.getPackages.asScala.toList.filter(_.allMembers.nonEmpty)),
-        kind = ContentKind.Packages,
-        sourceSets = m.getSourceSets.asScala.toSet
-      )(
-        (bdr, elem) => bdr
-      ) { (bdr, elem) => bdr
-        .driLink(elem.getName, elem.getDri)
-      }
-
-    contentBuilder.contentForDocumentable(m, buildBlock = buildBlock)
-  }
-  extension (b: DocBuilder)
-    def descriptionIfNotEmpty(d: Documentable): DocBuilder = {
-      val desc = this.contentForDescription(d).asScala.toSeq
-      val res = if desc.isEmpty then b else b
-        .sourceSetDependentHint(
-          Set(d.getDri),
-          d.getSourceSets.asScala.toSet,
-          kind = ContentKind.SourceSetDependentHint,
-          styles = Set(TextStyle.UnderCoverText)
-        ) { sourceSetBuilder => sourceSetBuilder
-            .addChildren(desc)
-        }
-      res
-    }
diff --git a/scala3doc/src/dotty/dokka/translators/ScalaSignatureProvider.scala b/scala3doc/src/dotty/dokka/translators/ScalaSignatureProvider.scala
diff --git a/scala3doc/src/dotty/renderers/MemberRenderer.scala b/scala3doc/src/dotty/renderers/MemberRenderer.scala
