Remove isVariable flag

Author: KacperFKorban

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

@@ -96,10 +96,10 @@ trait ClassLikeSupport:
 
     if summon[DocContext].args.generateInkuire then {
 
-      val classType = classDef.asInkuire(Set.empty, true)
+      val classType = classDef.asInkuire(Set.empty)
       val variableNames = classType.params.map(_.typ.name.name).toSet
 
-      val parents = classDef.parents.map(_.asInkuire(variableNames, false))
+      val parents = classDef.parents.map(_.asInkuire(variableNames))
 
       val isModule = classDef.symbol.flags.is(Flags.Module)
 
@@ -109,8 +109,8 @@ trait ClassLikeSupport:
         case typeSymbol: Symbol =>
           val typeDef = typeSymbol.tree.asInstanceOf[TypeDef]
           if typeDef.rhs.symbol.fullName.contains("java") then
-            val t = typeSymbol.tree.asInkuire(variableNames, false) // TODO [Inkuire] Hack until type aliases are supported
-            val tJava = typeDef.rhs.symbol.tree.asInkuire(variableNames, false)
+            val t = typeSymbol.tree.asInkuire(variableNames) // TODO [Inkuire] Hack until type aliases are supported
+            val tJava = typeDef.rhs.symbol.tree.asInkuire(variableNames)
             Inkuire.db = Inkuire.db.copy(types = Inkuire.db.types.updated(t.itid.get, (t, Seq.empty))) // TODO [Inkuire] Hack until type aliases are supported
             Inkuire.db = Inkuire.db.copy(types = Inkuire.db.types.updated(tJava.itid.get, (tJava, Seq.empty)))
       }
@@ -126,9 +126,9 @@ trait ClassLikeSupport:
                                           && classDef.symbol.flags.is(Flags.Module)
                                           && implicitConversion.owner.fullName == ("scala.Predef$") =>
             val defdef = implicitConversion.tree.asInstanceOf[DefDef]
-            val to = defdef.returnTpt.asInkuire(variableNames, false)
+            val to = defdef.returnTpt.asInkuire(variableNames)
             val from = defdef.paramss.flatMap(_.params).collectFirst {
-              case v: ValDef => v.tpt.asInkuire(variableNames, false)
+              case v: ValDef => v.tpt.asInkuire(variableNames)
             }
             from match
               case Some(from) => Inkuire.db = Inkuire.db.copy(implicitConversions = Inkuire.db.implicitConversions :+ (from.itid.get -> to))
@@ -143,14 +143,14 @@ trait ClassLikeSupport:
             val receiver: Option[Inkuire.Type] =
               Some(classType)
                 .filter(_ => !isModule)
-                .orElse(methodSymbol.extendedSymbol.flatMap(s => partialAsInkuire(vars, false).lift(s.tpt)))
+                .orElse(methodSymbol.extendedSymbol.flatMap(s => partialAsInkuire(vars).lift(s.tpt)))
             val sgn = Inkuire.ExternalSignature(
               signature = Inkuire.Signature(
                 receiver = receiver,
                 arguments = methodSymbol.nonExtensionParamLists.flatMap(_.params).collect {
-                  case ValDef(_, tpe, _) => tpe.asInkuire(vars, false)
+                  case ValDef(_, tpe, _) => tpe.asInkuire(vars)
                 },
-                result = defdef.returnTpt.asInkuire(vars, false),
+                result = defdef.returnTpt.asInkuire(vars),
                 context = Inkuire.SignatureContext(
                   vars = vars.toSet,
                   constraints = Map.empty //TODO [Inkuire] Type bounds

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

@@ -17,36 +17,36 @@ trait InkuireSupport:
 
   private given qctx.type = qctx
 
-  private def paramsForClass(classDef: ClassDef, vars: Set[String], isVariable: Boolean): Seq[Inkuire.Variance] =
-    classDef.getTypeParams.map(mkTypeArgumentInkuire(_, vars, isVariable))
+  private def paramsForClass(classDef: ClassDef, vars: Set[String]): Seq[Inkuire.Variance] =
+    classDef.getTypeParams.map(mkTypeArgumentInkuire(_, vars))
 
   given TreeSyntaxInkuire: AnyRef with
     extension (tpeTree: Tree)
-      def asInkuire(vars: Set[String], isVariable: Boolean): Inkuire.Type =
-        partialAsInkuire(vars, isVariable)(tpeTree)
+      def asInkuire(vars: Set[String]): Inkuire.Type =
+        partialAsInkuire(vars)(tpeTree)
 
-  def partialAsInkuire(vars: Set[String], isVariable: Boolean): PartialFunction[Tree, Inkuire.Type] = {
+  def partialAsInkuire(vars: Set[String]): PartialFunction[Tree, Inkuire.Type] = {
     case TypeBoundsTree(low, high) => inner(low.tpe, vars) //TODO [Inkuire] Type bounds
     case tpeTree: Applied =>
       inner(tpeTree.tpe, vars).copy(
-        params = tpeTree.args.map(p => Inkuire.Invariance(p.asInkuire(vars, isVariable)))
+        params = tpeTree.args.map(p => Inkuire.Invariance(p.asInkuire(vars)))
       )
     case tpeTree: TypeTree =>
       inner(tpeTree.tpe, vars)
     case term:  Term => inner(term.tpe, vars)
-    case classDef: ClassDef => mkTypeFromClassDef(classDef, vars, isVariable)
+    case classDef: ClassDef => mkTypeFromClassDef(classDef, vars)
     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 = {
+  def mkTypeFromClassDef(classDef: ClassDef, vars: Set[String]): Inkuire.Type = {
     Inkuire.Type(
       name = Inkuire.TypeName(classDef.name),
       itid = classDef.symbol.itid,
-      params = paramsForClass(classDef, vars, isVariable)
+      params = paramsForClass(classDef, vars)
     )
   }
 
@@ -58,13 +58,13 @@ trait InkuireSupport:
     extension (tpe: TypeRepr)
       def asInkuire(vars: Set[String]): Inkuire.Type = inner(tpe, vars)
 
-  def mkTypeArgumentInkuire(argument: TypeDef, vars: Set[String] = Set.empty, isVariable: Boolean = false): Inkuire.Variance =
+  def mkTypeArgumentInkuire(argument: TypeDef, vars: Set[String] = Set.empty): Inkuire.Variance =
     val name = argument.symbol.normalizedName
     val normalizedName = if name.matches("_\\$\\d*") then "_" else name
     val t = Inkuire.Type(
       name = Inkuire.TypeName(normalizedName),
       itid = argument.symbol.itid,
-      isVariable = vars.contains(normalizedName) || isVariable,
+      isVariable = true,
       params = Seq.empty //TODO [Inkuire] Type Lambdas
     )
     if argument.symbol.flags.is(Flags.Covariant) then Inkuire.Covariance(t)
@@ -141,7 +141,7 @@ trait InkuireSupport:
       Inkuire.Type.unresolved //TODO [Inkuire] <- should be handled by Singleton case, but didn't work
     case MatchType(bond, sc, cases) =>
       inner(sc, vars)
-    case ParamRef(TypeLambda(names, _, resType), i) =>
+    case ParamRef(TypeLambda(names, _, _), i) =>
       Inkuire.Type(
         name = Inkuire.TypeName(names(i)),
         itid = Some(Inkuire.ITID(s"external-itid-${names(i)}", isParsed = false)),