Clean up some old code

Author: romanowski

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

@@ -29,13 +29,7 @@ trait BasicSupport:
     Annotation(dri, params)
 
   extension (sym: Symbol)
-    def documentation = sym.docstring match
-      case Some(docstring) =>
-          Map(ctx.sourceSet -> parseComment(docstring, sym.tree))
-      case None =>
-          Map.empty
-
-    def documentation2 = sym.docstring.map(preparseComment(_, sym.tree))
+    def documentation = sym.docstring.map(parseComment(_, sym.tree))
 
     def source(using Quotes) =
       val path = sym.pos.filter(isValidPos(_)).map(_.sourceFile.jpath).filter(_ != null).map(_.toAbsolutePath).map(_.toString)

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

@@ -465,7 +465,7 @@ trait ClassLikeSupport:
         placeholderModifier,
         ctx.sourceSet.toSet,
         /*isExpectActual =*/ false,
-        PropertyContainer.Companion.empty().plus(member.copy(rawDoc = symbol.documentation2)).plus(compositeExt)
+        PropertyContainer.Companion.empty().plus(member.copy(rawDoc = symbol.documentation)).plus(compositeExt)
     )
 
   private def isUsingModifier(parameters: Seq[ValDef]): Boolean =

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

@@ -12,10 +12,7 @@ import dotty.dokka.tasty.comments.Comment
 trait ScaladocSupport { self: TastyParser =>
   import qctx.reflect._
 
-  def preparseComment(
-    docstring: String,
-    tree: Tree
-  ): Comment =
+  def parseComment(docstring: String,  tree: Tree): Comment =
     val commentString: String =
       if tree.symbol.isClassDef || tree.symbol.owner.isClassDef then
         import dotty.tools.dotc
@@ -50,92 +47,4 @@ trait ScaladocSupport { self: TastyParser =>
         comments.MarkdownCommentParser(comments.Repr(qctx)(tree.symbol))
     }
     parser.parse(preparsed)
-
-  def parseComment(
-    docstring: String,
-    tree: Tree
-  ): dkkd.DocumentationNode = {
-    val commentString: String =
-      if tree.symbol.isClassDef || tree.symbol.owner.isClassDef then
-        import dotty.tools.dotc
-        given ctx: dotc.core.Contexts.Context = qctx.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx
-
-        val sym = tree.symbol.asInstanceOf[dotc.core.Symbols.Symbol]
-
-        comments.CommentExpander.cookComment(sym)(using ctx)
-          .get.expanded.get
-      else
-        docstring
-
-    val preparsed =
-      comments.Preparser.preparse(comments.Cleaner.clean(commentString))
-
-    val commentSyntax =
-      preparsed.syntax.headOption match {
-        case Some(commentSetting) =>
-          CommentSyntax.parse(commentSetting).getOrElse {
-            val msg = s"not a valid comment syntax: $commentSetting, defaulting to Markdown syntax."
-            // we should update pos with span from documentation
-            report.warning(msg, tree.pos)
-            CommentSyntax.default
-          }
-        case None => ctx.args.defaultSyntax
-      }
-
-    val parser = commentSyntax match {
-      case CommentSyntax.Wiki =>
-        comments.WikiCommentParser(comments.Repr(qctx)(tree.symbol))
-      case CommentSyntax.Markdown =>
-        comments.MarkdownCommentParser(comments.Repr(qctx)(tree.symbol))
-    }
-    val parsed = parser.parse(preparsed)
-
-    import kotlin.collections.builders.{ListBuilder => KtListBuilder}
-    val bld = new KtListBuilder[dkkd.TagWrapper]
-    parsed.short match {
-      case Some(tag) => bld.add(dkkd.Description(tag))
-      case None => bld.add(dkkd.Description(dkk.text("")))
-    }
-    bld.add(dkkd.Description(parsed.body))
-
-    inline def addOpt(opt: Option[dkkd.DocTag])(wrap: dkkd.DocTag => dkkd.TagWrapper) =
-      opt.foreach { t => bld.add(wrap(t)) }
-
-    inline def addSeq[T](seq: Iterable[T])(wrap: T => dkkd.TagWrapper) =
-      seq.foreach { t => bld.add(wrap(t)) }
-
-    // this is a total kludge, this should be done in a deeper layer but we'd
-    // need to refactor code there first
-    def correctParagraphTags(tag: dkkd.DocTag): dkkd.DocTag =
-      tag match {
-        case tag: dkkd.P =>
-          // NOTE we recurse once, since both the top-level element and its children can be P
-          // (there is no special root DocTag)
-          dkkd.Span(tag.getChildren.iterator.asScala.map(correctParagraphTags).toSeq.asJava, tag.getParams)
-        case tag => tag
-      }
-
-    addSeq(parsed.authors)(dkkd.Author(_))
-    addOpt(parsed.version)(dkkd.Version(_))
-    addOpt(parsed.since)(dkkd.Since(_))
-    addOpt(parsed.deprecated)(dkkd.Deprecated(_))
-    addSeq(parsed.todo)(ScalaTagWrapper.Todo.apply)
-    addSeq(parsed.see)(ScalaTagWrapper.See.apply)
-    addSeq(parsed.note)(ScalaTagWrapper.Note.apply)
-    addSeq(parsed.example)(ScalaTagWrapper.Example.apply)
-
-    addOpt(parsed.constructor)(dkkd.Constructor(_))
-    addSeq(parsed.valueParams){ case (name, tag) =>
-      ScalaTagWrapper.NestedNamedTag("Param", name, dkk.text(name), correctParagraphTags(tag))
-    }
-    addSeq(parsed.typeParams){ case (name, tag) =>
-      ScalaTagWrapper.NestedNamedTag("Type param", name, dkk.text(name), correctParagraphTags(tag))
-    }
-    addSeq(parsed.throws){ case (key, (exc, desc)) =>
-      ScalaTagWrapper.NestedNamedTag("Throws", key, exc, correctParagraphTags(desc))
-    }
-    addOpt(parsed.result)(dkkd.Return(_))
-
-    new dkkd.DocumentationNode(bld.build())
-  }
 }