Refactor ClassLikeSupports' parseMethod

Author: BarkingBad

scala3doc-js/src/ux/ux.scala

@@ -2,9 +2,10 @@ package tests
 package typeAppliance
 
 trait AClass[A, B]:
-  def fun[C]: AClass[A, C]
+  def funASD[C, D](f: B => C): AClass[A, C]
 
 trait BClass[A, B] extends AClass[A, B]:
-  override def fun[C]: BClass[A, C]
+  override def funASD[X, D](f: B => X): BClass[A, X]
 
-abstract class CClass[B] extends BClass[Int, B]
+abstract class CClass[U] extends BClass[Int, U]:
+  def xdxdkk(n: Int)(b: Int): Int = 1

scala3doc-testcases/src/tests/typeAppliance.scala

@@ -27,7 +27,7 @@ trait ClassLikeSupport:
         else Kind.Class(Nil, Nil)
 
   private def kindForClasslike(classDef: ClassDef): Kind =
-    def typeArgs = classDef.getTypeParams.map(mkTypeArgument)
+    def typeArgs = classDef.getTypeParams.map(mkTypeArgument(_))
 
     def parameterModifier(parameter: Symbol): String =
       val fieldSymbol = classDef.symbol.declaredField(parameter.normalizedName)
@@ -334,9 +334,33 @@ trait ClassLikeSupport:
       else method.paramss
     val genericTypes = if (methodSymbol.isClassConstructor) Nil else method.typeParams
 
+    case class MemberInfo(genericTypes: Map[String, TypeBounds], paramLists: List[Map[String, TypeRepr]], res: TypeRepr)
+
+    def unwrapMemberInfo(c: ClassDef, methodSymbol: Symbol): MemberInfo =
+      val baseTypeRepr = typeForClass(c).asInstanceOf[dotty.tools.dotc.core.Types.Type]
+        .memberInfo(methodSymbol.asInstanceOf[dotty.tools.dotc.core.Symbols.Symbol])(using qctx.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx)
+        .asInstanceOf[TypeRepr]
+
+      def handlePolyType(polyType: PolyType): MemberInfo =
+        MemberInfo(polyType.paramNames.zip(polyType.paramBounds).toMap, List.empty, polyType.resType)
+
+      def handleMethodType(memberInfo: MemberInfo, methodType: MethodType): MemberInfo =
+        MemberInfo(memberInfo.genericTypes, memberInfo.paramLists ++ List(methodType.paramNames.zip(methodType.paramTypes).toMap), methodType.resType)
+
+      def recursivelyCalculateMemberInfo(memberInfo: MemberInfo): MemberInfo = memberInfo.res match
+        case p: PolyType => recursivelyCalculateMemberInfo(handlePolyType(p))
+        case m: MethodType => recursivelyCalculateMemberInfo(handleMethodType(memberInfo, m))
+        case _ => memberInfo
+
+      recursivelyCalculateMemberInfo(MemberInfo(Map.empty, List.empty, baseTypeRepr))
+
+    val memberInfo = unwrapMemberInfo(c, methodSymbol)
+
     val basicKind: Kind.Def = Kind.Def(
-      genericTypes.map(mkTypeArgument),
-      paramLists.map(pList => ParametersList(pList.map(mkParameter(_, paramPrefix)), if isUsingModifier(pList) then "using " else ""))
+      genericTypes.map(mkTypeArgument(_, Some(memberInfo.genericTypes))),
+      paramLists.zipWithIndex.map { (pList, index) =>
+        ParametersList(pList.map(mkParameter(_, paramPrefix, memberInfo = Some(memberInfo.paramLists(index)))), if isUsingModifier(pList) then "using " else "")
+      }
     )
 
     val methodKind =
@@ -358,12 +382,6 @@ trait ClassLikeSupport:
     val origin = if !methodSymbol.isOverriden then Origin.RegularlyDefined else
       val overridenSyms = methodSymbol.allOverriddenSymbols.map(_.owner)
       Origin.Overrides(overridenSyms.map(s => Overriden(s.name, s.dri)).toSeq)
-    if(methodSymbol.normalizedName == "fun" && c.symbol.normalizedName == "CClass")
-      println(method.returnTpt)
-      println(typeForClass(c).asInstanceOf[dotty.tools.dotc.core.Types.Type]
-        .memberInfo(methodSymbol.asInstanceOf[dotty.tools.dotc.core.Symbols.Symbol])(using qctx.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx)
-      )
-
 
     mkMember(
       method.symbol,
@@ -372,7 +390,7 @@ trait ClassLikeSupport:
         methodSymbol.getExtraModifiers(),
         methodKind,
         methodSymbol.getAnnotations(),
-        method.returnTpt.dokkaType.asSignature,
+        memberInfo.res.dokkaType.asSignature,
         methodSymbol.source(using qctx),
         origin
       )
@@ -381,32 +399,33 @@ trait ClassLikeSupport:
   def mkParameter(argument: ValDef,
     prefix: Symbol => String = _ => "",
     isExtendedSymbol: Boolean = false,
-    isGrouped: Boolean = false) =
+    isGrouped: Boolean = false,
+    memberInfo: Option[Map[String, TypeRepr]] = None) =
       val inlinePrefix = if argument.symbol.flags.is(Flags.Inline) then "inline " else ""
-      val name = Option.when(!argument.symbol.flags.is(Flags.Synthetic))(argument.symbol.normalizedName)
-
+      val nameIfNotSynthetic = Option.when(!argument.symbol.flags.is(Flags.Synthetic))(argument.symbol.normalizedName)
+      val name = argument.symbol.normalizedName
       Parameter(
         argument.symbol.getAnnotations(),
         inlinePrefix + prefix(argument.symbol),
-        name,
+        nameIfNotSynthetic,
         argument.symbol.dri,
-        argument.tpt.dokkaType.asSignature,
+        memberInfo.flatMap(_.get(name).map(_.dokkaType.asSignature)).getOrElse(argument.tpt.dokkaType.asSignature),
         isExtendedSymbol,
         isGrouped
       )
 
-  def mkTypeArgument(argument: TypeDef): TypeParameter =
+  def mkTypeArgument(argument: TypeDef, memberInfo: Option[Map[String, TypeBounds]] = None): TypeParameter =
     val variancePrefix: "+" | "-" | "" =
       if  argument.symbol.flags.is(Flags.Covariant) then "+"
       else if argument.symbol.flags.is(Flags.Contravariant) then "-"
       else ""
-
+    val name = argument.symbol.normalizedName
     TypeParameter(
       argument.symbol.getAnnotations(),
       variancePrefix,
-      argument.symbol.normalizedName,
+      name,
       argument.symbol.dri,
-      argument.rhs.dokkaType.asSignature
+      memberInfo.flatMap(_.get(name).map(_.dokkaType.asSignature)).getOrElse(argument.rhs.dokkaType.asSignature)
     )
 
   def parseTypeDef(typeDef: TypeDef): Member =
@@ -417,7 +436,7 @@ trait ClassLikeSupport:
     }
 
     val (generics, tpeTree) = typeDef.rhs match
-      case LambdaTypeTree(params, body) => (params.map(mkTypeArgument), body)
+      case LambdaTypeTree(params, body) => (params.map(mkTypeArgument(_)), body)
       case tpe => (Nil, tpe)
 
     mkMember(