Clean up unused code

Author: romanowski

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

@@ -26,6 +26,13 @@ class ScalaPageContentBuilder(
   val signatureProvider: SignatureProvider
 )(using DocContext) {
 
+  def mkMemberInfo(m: Member) = MemberInfo(m, ContentNodeParams(
+      new DCI(JSet(m.dri), ContentKind.Main),
+      m.getSourceSets.asScala.toSet.toDisplay,
+      Set(),
+      PropertyContainer.Companion.empty()
+    ))
+
   def contentForDRI(
     dri: DRI,
     sourceSets: Set[DokkaConfiguration$DokkaSourceSet],

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

@@ -43,7 +43,7 @@ class ScalaPageCreator(
   override def pageForPackage(p: DPackage): PackagePageNode =
     PackagePageNode(
       p.name,
-      contentForPackage(p),
+      contentBuilder.mkMemberInfo(p),
       JSet(p.dri),
       p,
       pagesForMembers(p),
@@ -59,16 +59,14 @@ class ScalaPageCreator(
     // Hack, need our own page!
     ClasslikePageNode(
       name,
-      contentForClass(c.asInstanceOf[DClass]),
+      contentBuilder.mkMemberInfo(c),
       JSet(c.getDri),
       c.asInstanceOf[DClass],
       JNil,
       JNil,
     ).modified(name, pagesForMembers(c)) // We need override default page
   }
 
-  override def pageForFunction(f: DFunction) = super.pageForFunction(f)
-
   override def contentForModule(m: DModule) = {
     def buildBlock = (builder: DocBuilder) => builder
       .group(kind = ContentKind.Cover) { gbuilder => gbuilder
@@ -89,16 +87,6 @@ class ScalaPageCreator(
 
     contentBuilder.contentForDocumentable(m, buildBlock = buildBlock)
   }
-
-  override def contentForPackage(p: DPackage) =
-    contentBuilder.contentForDocumentable(p, buildBlock = _.contentForDescription(p))
-
-  override def contentForClasslike(c: DClasslike) = throw UnsupportedOperationException(
-      s"Unable to generate DClasslike using default dokka method for $c!")
-
-  def contentForClass(c: DClass) =
-    contentBuilder.contentForDocumentable(c, buildBlock = _.contentForDescription(c))
-
   extension (b: DocBuilder)
     def descriptionIfNotEmpty(d: Documentable): DocBuilder = {
       val desc = this.contentForDescription(d).asScala.toSeq
@@ -113,103 +101,3 @@ class ScalaPageCreator(
         }
       res
     }
-
-    def contentForDescription(m: Member) = b.memberInfo(m)
-
-    def contentForScope(s: Documentable & WithScope & WithExtraProperties[_]) =
-      def groupExtensions(extensions: Seq[Member]): Seq[DocumentableSubGroup] =
-        extensions.groupBy(_.kind).map {
-          case (Kind.Extension(on, _), members) =>
-            val signature = Signature(s"extension (${on.name}: ") join on.signature join Signature(")")
-            DocumentableSubGroup(signature, members.toSeq)
-          case other => sys.error(s"unexpected value: $other")
-        }.toSeq
-
-      val (definedMethods, inheritedMethods) = s.membersBy(_.kind.isInstanceOf[Kind.Def]).byInheritance
-      val (definedFields, inheritedFiles) = s.membersBy(m => m.kind == Kind.Val || m.kind == Kind.Var).byInheritance
-      val (definedClasslikes, inheritedClasslikes) = s.membersBy(m => m.kind.isInstanceOf[Classlike]).byInheritance
-      val (definedTypes, inheritedTypes) = s.membersBy(_.kind.isInstanceOf[Kind.Type]).byInheritance
-      val (definedGivens, inheritedGives) = s.membersBy(_.kind.isInstanceOf[Kind.Given]).byInheritance
-      val (definedExtensions, inheritedExtensions) = s.membersBy(_.kind.isInstanceOf[Kind.Extension]).byInheritance
-      val (definedExports, inheritedExports) = s.membersBy(_.kind.isInstanceOf[Kind.Exported]).byInheritance
-      val (definedImplicits, inheritedImplicits) = s.membersBy(_.kind.isInstanceOf[Kind.Implicit]).byInheritance
-
-      b
-        .documentableTab("Type members")(
-          DocumentableGroup(Some("Types"), definedTypes),
-          DocumentableGroup(Some("Classlikes"), definedClasslikes),
-          DocumentableGroup(Some("Inherited types"), inheritedTypes),
-          DocumentableGroup(Some("Inherited classlikes"), inheritedClasslikes)
-        )
-        .documentableTab("Methods")(
-          DocumentableGroup(Some("Defined methods"), definedMethods),
-          DocumentableGroup(Some("Inherited methods"),  inheritedMethods),
-        )
-        .documentableTab("Value members")(
-          DocumentableGroup(Some("Defined value members"), definedFields),
-          DocumentableGroup(Some("Inherited value members"), inheritedFiles)
-        )
-        .documentableTab("Givens")(
-          DocumentableGroup(Some("Defined givens"), definedGivens),
-          DocumentableGroup(Some("Inherited givens"), inheritedGives)
-        )
-        .documentableTab("Extensions")(
-          DocumentableGroup(Some("Defined extensions"), groupExtensions(definedExtensions)),
-          DocumentableGroup(Some("Inherited extensions"), groupExtensions(inheritedExtensions))
-        )
-        .documentableTab("Implicits")(
-          DocumentableGroup(Some("Defined implicits"), definedImplicits),
-          DocumentableGroup(Some("Inherited implicits"), inheritedImplicits)
-        )
-        .documentableTab("Exports")(
-          DocumentableGroup(Some("Defined exports"), definedExports),
-          DocumentableGroup(Some("Inherited exports"), inheritedExports),
-        )
-
-
-    def contentForEnum(c: DClass) =
-      b.documentableTab("Enum entries")(
-        DocumentableGroup(None, c.membersBy(_.kind == Kind.EnumCase)) // Enum entries cannot be inherited
-      )
-
-
-    def contentForConstructors(c: DClass) =
-       b.documentableTab("Constructors")(
-        DocumentableGroup(None, c.membersBy(_.kind.isInstanceOf[Kind.Constructor]))
-      )
-
-
-    def contentForTypesInfo(c: DClass) =
-      val supertypes = c.parents
-      val subtypes = c.knownChildren
-
-      def contentForTypeLink(builder: DocBuilder, link: LinkToType): DocBuilder =
-        builder.group(styles = Set(TextStyle.Paragraph)) { builder =>
-          link.signature.foldLeft(builder.text(link.kind.name).text(" ")){ (builder, sigElement) => sigElement match
-            case Link(name, dri) => builder.driLink(name, dri)
-            case str: String => builder.text(str)
-          }
-        }
-
-      val withSupertypes = if supertypes.isEmpty then b else
-        b.header(2, "Linear supertypes")()
-          .group(
-            kind = ContentKind.Comment,
-            styles = Set(ContentStyle.WithExtraAttributes),
-            extra = PropertyContainer.Companion.empty plus SimpleAttr.Companion.header("Linear supertypes")
-        ){ gbdr => gbdr
-            .group(kind = ContentKind.Symbol, styles = Set(TextStyle.Monospace)){ grbdr => grbdr
-              .list(supertypes.toList, separator = "")(contentForTypeLink)
-            }
-          }
-
-      val withSubtypes = if (subtypes.isEmpty) withSupertypes else
-        withSupertypes.header(2, "Known subtypes")()
-          .group(
-            kind = ContentKind.Comment,
-            styles = Set(ContentStyle.WithExtraAttributes),
-            extra = PropertyContainer.Companion.empty plus SimpleAttr.Companion.header("Known subtypes")
-          ) { _.group(kind = ContentKind.Symbol, styles = Set(TextStyle.Monospace)) {
-              _.list(subtypes.toList, separator="")(contentForTypeLink)
-            }
-          }

scala3doc/src/dotty/renderers/MemberRenderer.scala

@@ -267,6 +267,7 @@ class MemberRenderer(signatureRenderer: SignatureRenderer, buildNode: ContentNod
       buildGroup("Type members", Seq(
         ("Classlikes", rest.filter(m => m.kind.isInstanceOf[Classlike])),
         ("Types", rest.filter(_.kind.isInstanceOf[Kind.Type])),
+        ("Enum entries", rest.filter(_.kind == Kind.EnumCase)),
       )),
       buildGroup("Value members", Seq(
         ("Constructors", rest.filter(_.kind.isInstanceOf[Kind.Constructor])),

scala3doc/src/dotty/renderers/ScalaHtmlRenderer.scala

@@ -112,69 +112,6 @@ class ScalaHtmlRenderer(using ctx: DokkaContext) extends HtmlRenderer(ctx) {
     val renderer = SignatureRenderer(pageContext, sourceSets, getLocationProvider)
     (renderer, new MemberRenderer(renderer, buildWithKotlinx(_, pageContext, null)))
 
-  private def buildDocumentableList(n: DocumentableList, pageContext: ContentPage, sourceSetRestriciton: JSet[DisplaySourceSet]) =
-    def render(n: ContentNode) = raw(buildWithKotlinx(n, pageContext, null))
-
-    val (renderer, memberRenderer) = renderers(pageContext)
-    import renderer._
-
-    def buildDocumentable(element: DocumentableElement) =
-      def topLevelAttr = Seq(cls := "documentableElement")
-        ++ element.params.dri.anchor.map(id := _)
-        ++ element.attributes.map{ case (n, v) => Attr(s"data-f-$n") := v }
-      val kind = element.modifiers.takeRight(1)
-      val otherModifiers = element.modifiers.dropRight(1)
-
-      val nameStyles = element.nameWithStyles.styles.map(_.toString.toLowerCase).mkString(" ")
-      val nameClasses = cls := s"documentableName monospace ${nameStyles.mkString(" ")}"
-
-      div(topLevelAttr:_*)(
-        a(href:=link(element.params.dri).getOrElse("#"), cls := "documentableAnchor"),
-        div(span(cls := "annotations monospace")(element.annotations.map(renderElement))),
-        div(cls := "header")(
-          span(cls := "modifiers monospace")(
-            span(cls := "other-modifiers")(otherModifiers.map(renderElement)),
-            span(cls := "kind")(kind.map(renderElement)),
-          ),
-          renderLink(element.nameWithStyles.name, element.params.dri, nameClasses),
-          span(cls := "signature monospace")(element.signature.map(renderElement)),
-        ),
-        div(cls := "docs")(
-          span(cls := "modifiers monospace"),
-          div(
-            div(cls := "originInfo")(element.originInfo.map(renderElement)),
-            div(cls := "documentableBrief")(memberRenderer.memberInfo(element.member)),
-          )
-        )
-      )
-
-    div(cls := "documentableList", testId := "definitionList")(
-      if(n.groupName.isEmpty) raw("") else h3(cls := "documentableHeader")(n.groupName.map(renderElement)),
-      n.elements.flatMap {
-        case element: DocumentableElement =>
-          Seq(buildDocumentable(element))
-        case group: DocumentableElementGroup =>
-          h4(cls := "documentable-extension-target")(
-            group.header.map(renderElement)
-          ) +: group.elements.map(buildDocumentable)
-    }
-    )
-
-  private def buildDocumentableFilter = div(cls := "documentableFilter")(
-    div(cls := "filterUpperContainer")(
-      button(cls := "filterToggleButton", testId := "filterToggleButton")(
-        raw("""
-          <svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24">
-            <path d="M0 0h24v24H0z" fill="none"/>
-            <path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"/>
-          </svg>
-        """)
-      ),
-      input(cls := "filterableInput", placeholder := "Filter all members", testId := "filterBarInput")
-    ),
-    div(cls := "filterLowerContainer")()
-  )
-
   def buildDescriptionList(node: ContentTable, pageContext: ContentPage, sourceSetRestriciton: JSet[DisplaySourceSet]) = {
     val children = node.getChildren.asScala.toList.zipWithIndex
     val nodeStyles = node.getStyle.asScala.toSet