Apply requested changes

Author: BarkingBad

scala3doc-testcases/src/tests/hkts.scala

@@ -337,9 +337,9 @@ trait ClassLikeSupport:
     val memberInfo = unwrapMemberInfo(c, methodSymbol)
 
     val basicKind: Kind.Def = Kind.Def(
-      genericTypes.map(mkTypeArgument(_, Some(memberInfo.genericTypes))),
+      genericTypes.map(mkTypeArgument(_, memberInfo.genericTypes)),
       paramLists.zipWithIndex.map { (pList, index) =>
-        ParametersList(pList.map(mkParameter(_, paramPrefix, memberInfo = Some(memberInfo.paramLists(index)))), if isUsingModifier(pList) then "using " else "")
+        ParametersList(pList.map(mkParameter(_, paramPrefix, memberInfo = memberInfo.paramLists(index))), if isUsingModifier(pList) then "using " else "")
       }
     )
 
@@ -380,7 +380,7 @@ trait ClassLikeSupport:
     prefix: Symbol => String = _ => "",
     isExtendedSymbol: Boolean = false,
     isGrouped: Boolean = false,
-    memberInfo: Option[Map[String, TypeRepr]] = None) =
+    memberInfo: Map[String, TypeRepr] = Map.empty) =
       val inlinePrefix = if argument.symbol.flags.is(Flags.Inline) then "inline " else ""
       val nameIfNotSynthetic = Option.when(!argument.symbol.flags.is(Flags.Synthetic))(argument.symbol.normalizedName)
       val name = argument.symbol.normalizedName
@@ -389,12 +389,12 @@ trait ClassLikeSupport:
         inlinePrefix + prefix(argument.symbol),
         nameIfNotSynthetic,
         argument.symbol.dri,
-        memberInfo.flatMap(_.get(name)).fold(argument.tpt.dokkaType.asSignature)(_.dokkaType.asSignature),
+        memberInfo.get(name).fold(argument.tpt.dokkaType.asSignature)(_.dokkaType.asSignature),
         isExtendedSymbol,
         isGrouped
       )
 
-  def mkTypeArgument(argument: TypeDef, memberInfo: Option[Map[String, TypeBounds]] = None): TypeParameter =
+  def mkTypeArgument(argument: TypeDef, memberInfo: Map[String, TypeBounds] = Map.empty): TypeParameter =
     val variancePrefix: "+" | "-" | "" =
       if  argument.symbol.flags.is(Flags.Covariant) then "+"
       else if argument.symbol.flags.is(Flags.Contravariant) then "-"
@@ -405,7 +405,7 @@ trait ClassLikeSupport:
       variancePrefix,
       name,
       argument.symbol.dri,
-      memberInfo.flatMap(_.get(name)).fold(argument.rhs.dokkaType.asSignature)(_.dokkaType.asSignature)
+      memberInfo.get(name).fold(argument.rhs.dokkaType.asSignature)(_.dokkaType.asSignature)
     )
 
   def parseTypeDef(typeDef: TypeDef): Member =

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

@@ -68,14 +68,19 @@ trait TypesSupport:
     case List(single) => single
     case other => other.reduce((r, e) => r ++ texts(", ") ++ e)
 
-  // weird name fot type-erasure purposes
-  private def isRepeatedTerm(term: Term) =
-    // For some reason annotation.tpe.typeSymbol != defn.RepeatedParamClass
-    // annotation.tpe.typeSymbol prints 'class Repeated' and defn.RepeatedParamClass prints 'class <repeated>'
-    term.tpe.typeSymbol.toString == "class Repeated"
-
-  private def isRepeatedTypeRepr(typeRepr: TypeRepr) =
-    typeRepr.typeSymbol.toString == "class <repeated>"
+  private def isRepeatedAnnotation(term: Term) =
+    term.tpe match
+      case t: TypeRef => t.name == "Repeated" && t.qualifier.match
+        case ThisType(tref: TypeRef) if tref.name == "internal" => true
+        case _ => false
+      case _ => false
+
+  private def isRepeated(typeRepr: TypeRepr) =
+    typeRepr match
+      case t: TypeRef => t.name == "<repeated>" && t.qualifier.match
+        case ThisType(tref: TypeRef) if tref.name == "scala" => true
+        case _ => false
+      case _ => false
 
   // TODO #23 add support for all types signatures that makes sense
   private def inner(tp: TypeRepr): List[JProjection] =
@@ -90,9 +95,9 @@ trait TypesSupport:
       case ConstantType(constant) =>
         texts(constant.show)
       case ThisType(tpe) => inner(tpe)
-      case AnnotatedType(AppliedType(_, Seq(tpe)), annotation) if isRepeatedTerm(annotation) =>
+      case AnnotatedType(AppliedType(_, Seq(tpe)), annotation) if isRepeatedAnnotation(annotation) =>
         inner(tpe) :+ text("*")
-      case AppliedType(repeatedClass, Seq(tpe)) if isRepeatedTypeRepr(repeatedClass) =>
+      case AppliedType(repeatedClass, Seq(tpe)) if isRepeated(repeatedClass) =>
         inner(tpe) :+ text("*")
       case AnnotatedType(tpe, _) =>
         inner(tpe)
@@ -174,10 +179,10 @@ trait TypesSupport:
             case Seq(rtpe) =>
               text("() => ") :: inner(rtpe)
             case Seq(arg, rtpe) =>
-              val ar = arg match
-                case a: ByNameType => texts("(") ++ inner(a) ++ texts(")")
-                case o => inner(o)
-              ar ++ texts(" => ") ++ inner(rtpe)
+              val partOfSignature = arg match
+                case byName: ByNameType => texts("(") ++ inner(byName) ++ texts(")")
+                case _ => inner(arg)
+              partOfSignature ++ texts(" => ") ++ inner(rtpe)
             case args =>
               texts("(") ++ commas(args.init.map(inner)) ++ texts(") => ") ++ inner(args.last)
         else if t.isTupleType then

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

@@ -98,7 +98,10 @@ abstract class SignatureTest(
           case unexpectedRegex(signature) => findName(signature, kinds).map(Unexpected(_))
           case expectedRegex(signature) => findName(signature, kinds).map(Expected(_, signature))
           case signature =>
-            findName(signature, kinds).map(Expected(_, commentRegex.replaceAllIn(signature, "").compactWhitespaces.reverse.dropWhile(List('{', ':').contains(_)).reverse))
+            findName(signature, kinds).map(
+              Expected(_, commentRegex.replaceAllIn(signature, "")
+                .compactWhitespaces.reverse.dropWhile(List('{', ':').contains(_)).reverse)
+            )
         }
 
   private def signaturesFromDocumentation(root: PageNode)(using DocContext): Seq[String] =