Support implicit classes

Author: KacperFKorban

scaladoc-testcases/src/tests/anImplicitClass.scala

@@ -0,0 +1,4 @@
+package tests.anImplicitClass
+
+implicit class AddingOps(n: Int):
+  def inc: Int = n + 1

scaladoc-testcases/src/tests/justmethods.scala

@@ -0,0 +1,5 @@
+package tests.justmethods
+
+trait Animal
+
+def whatSoundDoIMake(animal: Animal): String = "IoIo"

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

@@ -72,20 +72,20 @@ trait InkuireSupport:
           !s.flags.is(Flags.Override) &&
           !s.flags.is(Flags.Synthetic)
 
+      if classDef.symbol.isImplicitClass then // Implicit classes
+        classDef.symbol.maybeOwner.declarations
+          .filter { methodSymbol =>
+            methodSymbol.name == classDef.symbol.name && methodSymbol.flags.is(Flags.Implicit) && methodSymbol.flags.is(Flags.Method)
+          }
+          .foreach(handleImplicitConversion(_, variableNames))
+
       classDef.symbol.declaredMethods
         .filter(viableSymbol)
         .tap { _.foreach { // Loop for implicit conversions
           case implicitConversion: Symbol if implicitConversion.flags.is(Flags.Implicit)
                                           && classDef.symbol.flags.is(Flags.Module)
                                           && implicitConversion.owner.fullName == ("scala.Predef$") =>
-            val defdef = implicitConversion.tree.asInstanceOf[DefDef]
-            val to = defdef.returnTpt.asInkuire(variableNames)
-            val from = defdef.paramss.flatMap(_.params).collectFirst {
-              case v: ValDef => v.tpt.asInkuire(variableNames)
-            }
-            (from, to) match
-              case (Some(from: Inkuire.Type), to: Inkuire.Type) => Inkuire.db = Inkuire.db.copy(implicitConversions = Inkuire.db.implicitConversions :+ (from.itid.get -> to))
-              case _ =>
+            handleImplicitConversion(implicitConversion, variableNames)
           case _ =>
         }}
         .tap { _.foreach { // Loop for functions and vals
@@ -150,6 +150,17 @@ trait InkuireSupport:
         }
   }
 
+  private def handleImplicitConversion(implicitConversion: Symbol, variableNames: Set[String]) = {
+    val defdef = implicitConversion.tree.asInstanceOf[DefDef]
+    val to = defdef.returnTpt.asInkuire(variableNames)
+    val from = defdef.paramss.flatMap(_.params).collectFirst {
+      case v: ValDef => v.tpt.asInkuire(variableNames)
+    }
+    (from, to) match
+      case (Some(from: Inkuire.Type), to: Inkuire.Type) => Inkuire.db = Inkuire.db.copy(implicitConversions = Inkuire.db.implicitConversions :+ (from.itid.get -> to))
+      case _ =>
+  }
+
   private def nameAndOwnerName(classDef: ClassDef, symbol: Symbol): (String, String) =
     if classDef.symbol.flags.is(Flags.Module)
       && (classDef.symbol.companionClass != Symbol.noSymbol || (Seq("apply", "unapply").contains(symbol.name))) then
@@ -168,6 +179,7 @@ trait InkuireSupport:
     else if sym == defn.EmptyPackageClass then List.empty
     else if sym == defn.RootPackage then List.empty
     else if sym == defn.RootClass then List.empty
+    else if sym.normalizedName.contains("$package") then ownerNameChain(sym.owner)
     else ownerNameChain(sym.owner) :+ sym.normalizedName
 
   private def paramsForClass(classDef: ClassDef, vars: Set[String]): Seq[Inkuire.Variance] =

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

@@ -12,6 +12,13 @@ object SymOps:
 
   extension (using Quotes)(sym: reflect.Symbol)
 
+    def isImplicitClass: Boolean =
+      import reflect._
+      sym.maybeOwner != Symbol.noSymbol
+        && sym.maybeOwner.declaredMethods.exists { methodSymbol =>
+          methodSymbol.name == sym.name && methodSymbol.flags.is(Flags.Implicit) && methodSymbol.flags.is(Flags.Method)
+        }
+
     def packageName: String =
       if (sym.isPackageDef) sym.fullName
       else sym.maybeOwner.packageName
@@ -91,7 +98,9 @@ object SymOps:
         Flags.Open -> Modifier.Open,
         Flags.Override -> Modifier.Override,
         Flags.Case -> Modifier.Case,
-      ).collect { case (flag, mod) if sym.flags.is(flag) => mod }
+      ).collect {
+        case (flag, mod) if sym.flags.is(flag) => mod
+      } ++ Seq(Modifier.Implicit).filter(_ => sym.isImplicitClass)
 
     def isHiddenByVisibility(using dctx: DocContext): Boolean =
       import VisibilityScope._