Generalise SymOps to more than one def type clause

Author: Sporarum

library/src/scala/quoted/Quotes.scala

@@ -3119,7 +3119,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     /** Extension methods of `MethodType` */
     trait MethodTypeMethods:
       extension (self: MethodType)
-        /** Is this the type of given parameter clause `(implicit X1, ..., Xn)`, `(given X1, ..., Xn)` or `(given x1: X1, ..., xn: Xn)` */
+        /** Is this the type of using parameter clause `(implicit X1, ..., Xn)`, `(using X1, ..., Xn)` or `(using x1: X1, ..., xn: Xn)` */
         def isImplicit: Boolean
         def isErased: Boolean
         def param(idx: Int): TypeRepr

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

@@ -143,7 +143,9 @@ object SymOps:
       import reflect._
       sym.flags.is(Flags.Artifact)
 
-    def isLeftAssoc: Boolean = !sym.name.endsWith(":")
+    def isRightAssoc: Boolean = sym.name.endsWith(":")
+
+    def isLeftAssoc: Boolean = !sym.isRightAssoc
 
     def extendedSymbol: Option[reflect.ValDef] =
       import reflect.*
@@ -172,41 +174,36 @@ object SymOps:
           )
         case _ => Nil -> Nil
 
+    def extendedParamLists: List[reflect.ParamClause] = sym.splitExtensionParamList._1
+
+    def extendedTypeParamLists: List[reflect.TypeParamClause] =
+      sym.extendedParamLists.collect {
+        case typeClause: reflect.TypeParamClause => typeClause
+      }
+
     def extendedTypeParams: List[reflect.TypeDef] =
-      import reflect.*
-      sym.tree match
-        case tree: DefDef =>
-          tree.leadingTypeParams
-        case _ => Nil
+      sym.extendedTypeParamLists.headOption.map(_.params).getOrElse(List())
 
     def extendedTermParamLists: List[reflect.TermParamClause] =
-      import reflect.*
-      sym.splitExtensionParamList._1.collect {
-        case tpc: TermParamClause => tpc
+      sym.extendedParamLists.collect {
+        case tpc: reflect.TermParamClause => tpc
       }
 
-    def nonExtensionTermParamLists: List[reflect.TermParamClause] =
-      import reflect.*
-      if sym.nonExtensionLeadingTypeParams.nonEmpty then
-        sym.nonExtensionParamLists.dropWhile {
-          case _: TypeParamClause => false
-          case _ => true
-        }.drop(1).collect {
-          case tpc: TermParamClause => tpc
-        }
-      else
-        sym.nonExtensionParamLists.collect {
-          case tpc: TermParamClause => tpc
-        }
-
     def nonExtensionParamLists: List[reflect.ParamClause] =
       sym.splitExtensionParamList._2
 
+    def nonExtensionTermParamLists: List[reflect.TermParamClause] =
+      sym.nonExtensionParamLists.collect {
+        case tpc: reflect.TermParamClause => tpc
+      }
+
+    def nonExtensionTypeParamLists: List[reflect.TypeParamClause] =
+      sym.nonExtensionParamLists.collect {
+        case typeClause: reflect.TypeParamClause => typeClause
+      }
+
     def nonExtensionLeadingTypeParams: List[reflect.TypeDef] =
-      import reflect.*
-      sym.nonExtensionParamLists.collectFirst {
-        case TypeParamClause(params) => params
-      }.toList.flatten
+      sym.nonExtensionTypeParamLists.headOption.map(_.params).getOrElse(List())
 
   end extension