Inkuire Implicit conversions WIP

Author: KacperFKorban

scaladoc/resources/dotty_res/scripts/inkuire-config.json

@@ -1,5 +1,5 @@
 {
   "inkuirePaths": [
-    {"path" : "../inkuire-db.json"}
+    "../inkuire-db.json"
   ]
 }

scaladoc/resources/dotty_res/scripts/inkuire.js

@@ -5,29 +5,12 @@ import scala.collection.mutable.{ Map => MMap}
 
 object Inkuire {
 
-  var db = InkuireDb(Seq.empty, Map.empty)
-
-  var postTransformations: MMap[String, Option[Inkuire.Contravariance]] = MMap.empty
-
-  def postTransform(): Unit = //TODO doesn't append. Dunno why
-    postTransformations.foreach {
-      case (name, t) =>
-        if(name == "RichByte") {
-          println(t)
-        }
-    }
-    val newFunctions = Inkuire.db.functions.flatMap { eSgn =>
-      postTransformations.get(eSgn.signature.receiver.map(_.typ.name.name).getOrElse("")) match
-        case Some(receiver) =>
-          List(eSgn.copy(signature = eSgn.signature.copy(receiver = receiver)))
-        case _ =>
-          List.empty
-    }
-    Inkuire.db = Inkuire.db.copy(functions = Inkuire.db.functions ++ newFunctions)
+  var db = InkuireDb(Seq.empty, Map.empty, Seq.empty)
 
   case class InkuireDb(
-    functions: Seq[ExternalSignature],
-    types:     Map[ITID, (Type, Seq[Type])]
+    functions:           Seq[ExternalSignature],
+    types:               Map[ITID, (Type, Seq[Type])],
+    implicitConversions: Seq[(ITID, Type)]
   )
 
   case class ITID(uuid: String, isParsed: Boolean)
@@ -107,7 +90,17 @@ object Inkuire {
     def serialize(db: InkuireDb): JSON = {
       jsonObject(
         ("types", serialize(db.types)),
-        ("functions", jsonList(db.functions.map(serialize)))
+        ("functions", jsonList(db.functions.map(serialize))),
+        ("implicitConversions", jsonList(db.implicitConversions.map(serializeConversion)))
+      )
+    }
+
+    private def serializeConversion(conversion: (ITID, Type)): JSON = {
+      jsonList(
+        Seq(
+          serialize(conversion._1),
+          serialize(conversion._2)
+        )
       )
     }
 

scaladoc/src/dotty/tools/scaladoc/Inkuire.scala

@@ -88,7 +88,6 @@ object Scaladoc:
     ctx.reporter
 
   def dumpInkuireDB(output: String) = {
-    Inkuire.postTransform()
     val path = Paths.get(output, "inkuire-db.json")
     println("InkuireDB created successfully!")
     println(s"Types: ${Inkuire.db.types.size}")

scaladoc/src/dotty/tools/scaladoc/Scaladoc.scala

@@ -96,15 +96,6 @@ trait ClassLikeSupport:
 
     if summon[DocContext].args.generateInkuire then {
 
-      /**
-       * Stuff the doesn't work yet:
-       * - Type parameters work in types but don't work in parents and in types that are arguments or results of functions
-       * - Extension functions
-       * - Inheritance of special types (Any, AnyVal, AnyRef, Nothing, ...)
-       * - SYNTAX!!! <- that's in Inkuire e.g. tuples, different arrows, different parentheses with type params, different constraint syntax
-       * - Type param constraints
-       */
-
       val classType = classDef.asInkuire(Set.empty, true)
       val variableNames = classType.params.map(_.typ.name.name).toSet
 
@@ -115,13 +106,17 @@ trait ClassLikeSupport:
       if !isModule then Inkuire.db = Inkuire.db.copy(types = Inkuire.db.types.updated(classType.itid.get, (classType, parents)))
 
       classDef.symbol.declaredMethods.foreach {
-        case implicitConversion: Symbol if implicitConversion.flags.is(Flags.Implicit) || implicitConversion.isGiven =>
+        case implicitConversion: Symbol if implicitConversion.flags.is(Flags.Implicit)
+                                        && !implicitConversion.flags.is(Flags.Private)
+                                        && classDef.symbol.flags.is(Flags.Module) =>
           val defdef = implicitConversion.tree.asInstanceOf[DefDef]
-          val name = defdef.returnTpt.tpe.typeSymbol.name
-          val receiver = defdef.paramss.flatMap(_.params).collectFirst {
-            case v: ValDef => Inkuire.Contravariance(v.tpt.asInkuire(variableNames, false))
+          val from = defdef.returnTpt.asInkuire(variableNames, false)
+          val to = defdef.paramss.flatMap(_.params).collectFirst {
+            case v: ValDef => v.tpt.asInkuire(variableNames, false)
           }
-          Inkuire.postTransformations.addOne(name -> receiver)
+          to match
+            case Some(to) => Inkuire.db = Inkuire.db.copy(implicitConversions = Inkuire.db.implicitConversions :+ (from.itid.get -> to))
+            case None =>
         case methodSymbol: Symbol =>
           val defdef = methodSymbol.tree.asInstanceOf[DefDef]
           val methodVars = defdef.paramss.flatMap(_.params).collect {

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

@@ -35,6 +35,11 @@ trait InkuireSupport:
       inner(tpeTree.tpe, vars)
     case term:  Term => inner(term.tpe, vars)
     case classDef: ClassDef => mkTypeFromClassDef(classDef, vars, isVariable)
+    case typeDef: TypeDef =>
+      Inkuire.Type(
+        name = Inkuire.TypeName(typeDef.name),
+        itid = typeDef.symbol.itid
+      )
   }
 
   def mkTypeFromClassDef(classDef: ClassDef, vars: Set[String], isVariable: Boolean): Inkuire.Type = {