CRs. Change logic to use definitions instead of show

Author: pikinier20

scaladoc/src/dotty/tools/scaladoc/tasty/JavadocAnchorCreator.scala

@@ -11,24 +11,27 @@ trait JavadocAnchorCreator:
   import self.q.reflect._
 
   private val javadocPrimitivesMap = Map(
-    "scala.Int" -> "int",
-    "scala.Float" -> "float",
-    "scala.Double" -> "double",
-    "scala.Long" -> "long",
-    "scala.Byte" -> "byte",
-    "scala.Boolean" -> "boolean",
-    "scala.Char" -> "char",
-    "scala.Short" -> "short",
-    "<special-ops>.<FromJavaObject>" -> "java.lang.Object"
+    defn.IntClass -> "int",
+    defn.FloatClass -> "float",
+    defn.DoubleClass -> "double",
+    defn.LongClass -> "long",
+    defn.ByteClass -> "byte",
+    defn.BooleanClass -> "boolean",
+    defn.CharClass -> "char",
+    defn.ShortClass -> "short",
+    defn.ObjectClass -> "java.lang.Object"
   )
 
-  private def transformPrimitiveType(s: String): String = javadocPrimitivesMap.getOrElse(s, s)
+  private def transformPrimitiveType(tpe: TypeRepr): String = tpe.classSymbol
+    .flatMap(javadocPrimitivesMap.get)
+    .filter(_ => !tpe.typeSymbol.isTypeParam)
+    .getOrElse(tpe.show)
 
   private def transformType(tpe: TypeRepr): String = tpe.simplified match {
-    case AppliedType(tpe, typeList) if tpe.show == "scala.Array" =>  transformType(typeList.head) + ":A"
-    case AppliedType(tpe, typeList) if tpe.show == "scala.<repeated>" => transformType(typeList.head) + "..."
-    case AppliedType(tpe, typeList) => transformPrimitiveType(tpe.show)
-    case other => transformPrimitiveType(other.show)
+    case AppliedType(tpe, typeList) if tpe.classSymbol.fold(false)(_ == defn.ArrayClass) => transformType(typeList.head) + ":A"
+    case AppliedType(tpe, typeList) if tpe.classSymbol.fold(false)(_ == defn.RepeatedParamClass) => transformType(typeList.head) + "..."
+    case AppliedType(tpe, typeList) => transformPrimitiveType(tpe)
+    case other => transformPrimitiveType(other)
   }
 
   def getJavadocType(s: TypeRepr) = transformType(s)

scaladoc/src/dotty/tools/scaladoc/tasty/PackageSupport.scala

@@ -8,13 +8,8 @@ trait PackageSupport:
     import qctx.reflect._
 
     def parsePackage(pck: PackageClause): (String, Member) =
-      val name = extractPackageName(pck.pid.show)
+      val name = pck.symbol.fullName
       (name, Member(name, pck.symbol.dri, Kind.Package))
 
     def parsePackageObject(pckObj: ClassDef): (String, Member) =
       pckObj.symbol.packageName -> parseClasslike(pckObj).withKind(Kind.Package)
-
-    private def extractPackageName(pidShowNoColor: String): String = {
-        val pidSplit = pidShowNoColor.split("\\.")
-        pidSplit.mkString("",".","")
-    }

scaladoc/src/dotty/tools/scaladoc/tasty/SymOps.scala

@@ -3,17 +3,25 @@ package tasty
 
 import scala.quoted._
 import dotty.tools.scaladoc.util.Escape._
+import scala.collection.mutable.{ Map => MMap }
+import dotty.tools.io.AbstractFile
 
 class SymOps[Q <: Quotes](val q: Q) extends JavadocAnchorCreator with Scaladoc2AnchorCreator:
   import q.reflect._
 
   given Q = q
+
+  private val externalLinkCache: scala.collection.mutable.Map[AbstractFile, Option[ExternalDocLink]] = MMap()
+
   extension (sym: Symbol)
     def packageName: String = (
       if (sym.isPackageDef) sym.fullName
       else sym.maybeOwner.packageName
     )
 
+    def packageNameSplitted: Seq[String] =
+      sym.packageName.split('.').toList
+
     def className: Option[String] =
       if (sym.isClassDef && !sym.flags.is(Flags.Package)) Some(
         Some(sym.maybeOwner).filter(s => s.exists).flatMap(_.className).fold("")(cn => cn + "$") + sym.name
@@ -110,11 +118,11 @@ class SymOps[Q <: Quotes](val q: Q) extends JavadocAnchorCreator with Scaladoc2A
         else termParamss(1).params(0)
       }
 
-    private def constructPath(location: String, anchor: Option[String], link: ExternalDocLink): String =
+    private def constructPath(location: Seq[String], anchor: Option[String], link: ExternalDocLink): String =
       val extension = ".html"
       val docURL = link.documentationUrl.toString
       def constructPathForJavadoc: String =
-        val l = "\\$+".r.replaceAllIn(location.replace(".","/"), _ => ".")
+        val l = "\\$+".r.replaceAllIn(location.mkString("/"), _ => ".")
         val javadocAnchor = if anchor.isDefined then {
           val paramSigs = sym.paramSymss.flatten.map(_.tree).collect {
             case v: ValDef => v.tpt.tpe
@@ -125,15 +133,15 @@ class SymOps[Q <: Quotes](val q: Q) extends JavadocAnchorCreator with Scaladoc2A
 
       //TODO #263: Add anchor support
       def constructPathForScaladoc2: String =
-        val l = escapeUrl(location).replace(".", "/")
+        val l = escapeUrl(location.mkString("/"))
         val scaladoc2Anchor = if anchor.isDefined then {
           "#" + getScaladoc2Type(sym.tree)
         } else ""
         docURL + l + extension + scaladoc2Anchor
 
       // TODO Add tests for it!
       def constructPathForScaladoc3: String =
-        val base = docURL + escapeUrl(location).replace(".", "/") + extension
+        val base = docURL + escapeUrl(location.mkString("/")) + extension
         anchor.fold(base)(a => base + "#" + a)
 
       link.kind match {
@@ -154,7 +162,7 @@ class SymOps[Q <: Quotes](val q: Q) extends JavadocAnchorCreator with Scaladoc2A
 
         val className = sym.className
 
-        val location = className.fold(sym.packageName)(cn => s"${sym.packageName}.${cn}")
+        val location = sym.packageNameSplitted ++ className
 
         val anchor = sym.anchor
 
@@ -163,13 +171,18 @@ class SymOps[Q <: Quotes](val q: Q) extends JavadocAnchorCreator with Scaladoc2A
             import dotty.tools.dotc
             given ctx: dotc.core.Contexts.Context = q.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx
             val csym = sym.asInstanceOf[dotc.core.Symbols.Symbol]
-            Option(csym.associatedFile).map(_.path).flatMap( path =>
-              dctx.externalDocumentationLinks.find(_.originRegexes.exists(r => r.matches(path)))
-            ).map(link => constructPath(location, anchor, link))
+            val extLink = if externalLinkCache.contains(csym.associatedFile) then externalLinkCache(csym.associatedFile)
+            else {
+              val calculatedLink = Option(csym.associatedFile).map(_.path).flatMap( path =>
+               dctx.externalDocumentationLinks.find(_.originRegexes.exists(r => r.matches(path))))
+              externalLinkCache += (csym.associatedFile -> calculatedLink)
+              calculatedLink
+            }
+            extLink.map(link => constructPath(location, anchor, link))
         }
 
         DRI(
-          location,
+          location.mkString("."),
           anchor.getOrElse(""),
           externalLink = externalLink,
           // sym.show returns the same signature for def << = 1 and def >> = 2.