add new heuristic to better split extension methods with implicits

Author: rochala

scaladoc-testcases/src/tests/extensionParams.scala

@@ -1,22 +1,51 @@
 package tests.extensionParams
 
+trait Animal
+
 extension [A](thiz: A)
   def toTuple2[B](that: B): (A, B) = thiz -> that
 
 extension [A](a: A)(using Int)
-  def f[B](b: B): (A, B) = ???
+  def f1[B](b: B): (A, B) 
+  = ???
 
 extension [A](a: A)(using Int)
-  def ff(b: A): (A, A) = ???
+  def f2(b: A): (A, A) 
+  = ???
 
 extension [A](a: A)(using Int)
-  def fff(using String)(b: A): (A, A) = ???
+  def f3(using String)(b: A): (A, A) 
+  = ???
 
 extension (a: Char)(using Int)
-  def ffff(using String)(b: Int): Unit = ???
+  def f4(using String)(b: Int): Unit 
+  = ???
 
 extension (a: Char)(using Int)
-  def fffff[B](using String)(b: B): Unit = ???
+  def f5[B](using String)(b: B): Unit 
+  = ???
+
+extension [A <: List[Char]](a: Int)(using Int)
+  def f6[B](b: B): (A, B) 
+  = ???
+
+extension [A <: List[Char]](using String)(using Unit)(a: A)(using Int)(using Number)
+  def f7[B, C](b: B)(c: C): (A, B) 
+  = ???
+
+extension [A <: List[Char]](using String)(using Unit)(a: A)(using Int)(using Number)
+  def f8(b: Any)(c: Any): Any 
+  = ???
+
+extension [A <: List[Char]](using String)(using Unit)(a: A)(using Int)(using Number)
+  def f9[B, C](using Int)(b: B)(c: C): (A, B) 
+  = ???
+
+extension [A <: List[Char]](using String)(using Unit)(a: A)(using Int)(using Number)
+  def f10(using Int)(b: Any)(c: Any): Any = ???
+
+  def f12(using Int)(b: A)(c: String): Number = ???
 
-extension [A <: List[Char]](a: A)(using Int)
-  def ffffff[B](b: B): (A, B) = ???
+extension (using String)(using Unit)(a: Animal)(using Int)(using Number)
+  def f11(b: Any)(c: Any): Any 
+  = ???

scaladoc/resources/dotty_res/styles/scalastyle.css

@@ -964,6 +964,10 @@ footer .socials {
   color: var(--type);
 }
 
+.groupHeader *[t="t"]:not([href]) { /* Types without links in group headers */
+  color: var(--type);
+}
+
 .signature *[t="t"] { /* Types with links */
   color: var(--type-link);
 }

scaladoc/src/dotty/tools/scaladoc/api.scala

@@ -44,7 +44,7 @@ enum Modifier(val name: String, val prefix: Boolean):
   case Transparent extends Modifier("transparent", true)
   case Infix extends Modifier("infix", true)
 
-case class ExtensionTarget(name: String, typeParams: Seq[TypeParameter], argsLists: Seq[ParametersList], signature: Signature, dri: DRI, position: Long)
+case class ExtensionTarget(name: String, typeParams: Seq[TypeParameter], argsLists: Seq[ParametersList], dri: DRI, position: Long)
 case class ImplicitConversion(from: DRI, to: DRI)
 trait ImplicitConversionProvider { def conversion: Option[ImplicitConversion] }
 trait Classlike

scaladoc/src/dotty/tools/scaladoc/renderers/MemberRenderer.scala

@@ -287,9 +287,9 @@ class MemberRenderer(signatureRenderer: SignatureRenderer)(using DocContext) ext
           val argsSig = InlineSignatureBuilder()
             .functionParameters(on.argsLists)
             .asInstanceOf[InlineSignatureBuilder].names.reverse
-          val sig = typeSig ++ Signature(Plain(s"(${on.name}: ")) ++ on.signature ++ Signature(Plain(")")) ++ argsSig
-          MGroup(span(cls := "groupHeader")(sig.map(renderElement)), members.sortBy(_.name).toSeq, on.name)
-      }.toSeq
+          val sig = typeSig ++ argsSig
+          MGroup(span(cls := "groupHeader")(sig.map(renderElement)), members.sortBy(_.name).toSeq, on.name) -> on.position
+      }.toSeq.sortBy(_._2).map(_._1)
 
     div(cls := "membersList")(renderTabs(
       singleSelection = false,

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

@@ -134,14 +134,13 @@ trait ClassLikeSupport:
           val termParams = dd.symbol.extendedTermParamLists.zipWithIndex.flatMap { case (paramList, index) =>
             memberInfo.paramLists(index) match
               case EvidenceOnlyParameterList => Nil
-              case info: RegularParameterList =>
+              case info: RegularParameterList => 
                 Seq(ParametersList(paramList.params.map(mkParameter(_, memberInfo = info)), paramListModifier(paramList.params)))
           }
           val target = ExtensionTarget(
             extSym.symbol.normalizedName,
             typeParams,
             termParams,
-            extSym.tpt.asSignature,
             extSym.tpt.symbol.dri,
             extSym.symbol.pos.get.start
           )
@@ -495,14 +494,13 @@ trait ClassLikeSupport:
         // Documenting method slightly different then its definition is withing the 'undefiend behaviour'.
         symbol.paramSymss.flatten.find(_.name == name).exists(_.flags.is(Flags.Implicit))
 
-    def handlePolyType(polyType: PolyType): MemberInfo =
-      MemberInfo(polyType.paramNames.zip(polyType.paramBounds).toMap, List.empty, polyType.resType)
+    def handlePolyType(memberInfo: MemberInfo, polyType: PolyType): MemberInfo =
+      MemberInfo(polyType.paramNames.zip(polyType.paramBounds).toMap, memberInfo.paramLists, polyType.resType)
 
     def handleMethodType(memberInfo: MemberInfo, methodType: MethodType): MemberInfo =
       val rawParams = methodType.paramNames.zip(methodType.paramTypes).toMap
       val (evidences, notEvidences) = rawParams.partition(e => isSyntheticEvidence(e._1))
 
-
       def findParamRefs(t: TypeRepr): Seq[ParamRef] = t match
         case paramRef: ParamRef => Seq(paramRef)
         case AppliedType(_, args) => args.flatMap(findParamRefs)
@@ -539,7 +537,7 @@ trait ClassLikeSupport:
       MemberInfo(memberInfo.genericTypes, memberInfo.paramLists, byNameType.underlying)
 
     def recursivelyCalculateMemberInfo(memberInfo: MemberInfo): MemberInfo = memberInfo.res match
-      case p: PolyType => recursivelyCalculateMemberInfo(handlePolyType(p))
+      case p: PolyType => recursivelyCalculateMemberInfo(handlePolyType(memberInfo, p))
       case m: MethodType => recursivelyCalculateMemberInfo(handleMethodType(memberInfo, m))
       case b: ByNameType => handleByNameType(memberInfo, b)
       case _ => memberInfo
@@ -551,4 +549,4 @@ trait ClassLikeSupport:
       if parameters(0).symbol.flags.is(Flags.Given) then "using "
       else if parameters(0).symbol.flags.is(Flags.Implicit) then "implicit "
       else ""
-    else ""
+    else ""

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

@@ -146,11 +146,19 @@ object SymOps:
 
     def extendedSymbol: Option[reflect.ValDef] =
       import reflect.*
-      Option.when(sym.isExtensionMethod){
-        val termParamss = sym.tree.asInstanceOf[DefDef].termParamss
-        if sym.isLeftAssoc || termParamss.size == 1 then termParamss(0).params(0)
-        else termParamss(1).params(0)
-      }
+      if sym.isExtensionMethod then
+        sym.extendedTermParamLists.find(param => !param.isImplicit && !param.isGiven).flatMap(_.params.headOption)
+      else None
+
+    def splitExtensionParamList: (List[reflect.ParamClause], List[reflect.ParamClause]) =
+      import reflect.*
+      val method = sym.tree.asInstanceOf[DefDef]
+      (for {
+        defPosition <- method.symbol.pos
+        defStart <- scala.util.Try(defPosition.start).toOption
+      } yield {
+        method.paramss.partition(_.params.headOption.map(_.symbol.pos.get.start < defStart).getOrElse(false))
+      }).getOrElse(List.empty, List.empty)
 
     def extendedTypeParams: List[reflect.TypeDef] =
       import reflect.*
@@ -159,15 +167,9 @@ object SymOps:
 
     def extendedTermParamLists: List[reflect.TermParamClause] =
       import reflect.*
-      if sym.nonExtensionLeadingTypeParams.nonEmpty then
-        sym.nonExtensionParamLists.takeWhile {
-          case _: TypeParamClause => false
-          case _ => true
-        }.collect {
-          case tpc: TermParamClause => tpc
-        }
-      else
-        List.empty
+      sym.splitExtensionParamList._1.collect { 
+        case tpc: TermParamClause => tpc 
+      }
 
     def nonExtensionTermParamLists: List[reflect.TermParamClause] =
       import reflect.*
@@ -184,14 +186,7 @@ object SymOps:
         }
 
     def nonExtensionParamLists: List[reflect.ParamClause] =
-      import reflect.*
-      val method = sym.tree.asInstanceOf[DefDef]
-      if sym.isExtensionMethod then
-        val params = method.paramss
-        val toDrop = if method.leadingTypeParams.nonEmpty then 2 else 1
-        if sym.isLeftAssoc || params.size == 1 then params.drop(toDrop)
-        else params.head :: params.tail.drop(toDrop)
-      else method.paramss
+      sym.splitExtensionParamList._2
 
     def nonExtensionLeadingTypeParams: List[reflect.TypeDef] =
       import reflect.*

scaladoc/src/dotty/tools/scaladoc/transformers/ImplicitMembersExtensionTransformer.scala

@@ -26,7 +26,7 @@ class ImplicitMembersExtensionTransformer(using DocContext) extends(Module => Mo
 
       val MyDri = c.dri
       def collectApplicableMembers(source: Member): Seq[Member] = source.members.flatMap {
-        case m @ Member(_, _, _, Kind.Extension(ExtensionTarget(_, _, _, _, MyDri, _), _), Origin.RegularlyDefined) =>
+        case m @ Member(_, _, _, Kind.Extension(ExtensionTarget(_, _, _, MyDri, _), _), Origin.RegularlyDefined) =>
           val kind = m.kind match
             case d: Kind.Def => d
             case _ => Kind.Def(Nil, Nil)