Do not create newSymbol for wildcard type symbol

instead, create a proxy data that will be converted to semanticdb symbol
who represents wildcard symbol

Author: tanishiking

compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala

@@ -5,7 +5,7 @@ import core.Symbols.{ Symbol , defn, NoSymbol }
 import core.Contexts._
 import core.Names
 import core.Names.Name
-import core.Types.Type
+import core.Types.{Type, TypeBounds}
 import core.Flags._
 import core.NameKinds
 import core.StdNames.nme
@@ -26,6 +26,42 @@ object Scala3:
 
   private val WILDCARDTypeName = nme.WILDCARD.toTypeName
 
+  /** Fake symbol that represents wildcard symbol which will be converted to
+    * semanticdb symbol with
+    * - name: local...
+    * - SymbolInformation with signature TypeSignature of given type bound.
+    */
+  case class WildcardTypeSymbol(bounds: TypeBounds) {
+    private[Scala3] var sname: Option[String] = None
+  }
+  type SemanticSymbol = Symbol | WildcardTypeSymbol
+  extension (sym: SemanticSymbol)
+    def name(using Context): Name = sym match
+      case s: Symbol => s.name
+      case s: WildcardTypeSymbol => nme.WILDCARD
+
+    def symbolName(using builder: SemanticSymbolBuilder)(using Context): String =
+      sym match
+        case s: Symbol => SymbolOps.symbolName(s)
+        case s: WildcardTypeSymbol =>
+          s.sname.getOrElse {
+            val sname = builder.symbolName(s)
+            s.sname = Some(sname)
+            sname
+          }
+
+    def symbolInfo(symkinds: Set[SymbolKind])(using LinkMode, TypeOps, SemanticSymbolBuilder, Context): SymbolInformation =
+      sym match
+        case s: Symbol => SymbolOps.symbolInfo(s)(symkinds)
+        case s: WildcardTypeSymbol =>
+          SymbolInformation(
+            symbol = symbolName,
+            language = Language.SCALA,
+            kind = SymbolInformation.Kind.TYPE,
+            displayName = nme.WILDCARD.toString,
+            signature = s.bounds.toSemanticSig(NoSymbol),
+          )
+
   enum SymbolKind derives CanEqual:
     kind =>
 

compiler/src/dotty/tools/dotc/semanticdb/SemanticSymbolBuilder.scala

@@ -23,10 +23,15 @@ class SemanticSymbolBuilder:
   private val symsAtOffset = new mutable.HashMap[Int, Set[Symbol]]():
     override def default(key: Int) = Set[Symbol]()
 
+
   def symbolName(sym: Symbol)(using Context): String =
     val b = StringBuilder(20)
     addSymName(b, sym)
     b.toString
+  def symbolName(sym: WildcardTypeSymbol): String =
+    val idx = nextLocalIdx
+    nextLocalIdx += 1
+    s"${Symbols.LocalPrefix}${idx}"
 
   def funParamSymbol(sym: Symbol)(using Context): Name => String =
     if sym.isGlobal then

compiler/src/dotty/tools/dotc/semanticdb/TypeOps.scala

@@ -14,6 +14,7 @@ import ast.tpd._
 import collection.mutable
 
 import dotty.tools.dotc.{semanticdb => s}
+import Scala3.{SemanticSymbol, WildcardTypeSymbol}
 
 class TypeOps:
   import SymbolScopeOps._
@@ -38,9 +39,9 @@ class TypeOps:
           // e.g. `class HKClass[F <: [T] =>> [U] =>> (U, T)]`
           // and if the binder is HKTypeLambda, fallback to create fake symbol
           case lam: HKTypeLambda =>
-            lam.paramNames.zip(lam.paramInfos).toMap.get(name) match
+            lam.paramNames.zip(lam.paramInfos).find(t => t._1 == name) match
               case Some(info) =>
-                Some(newSymbol(parent, name, Flags.TypeParam, info))
+                Some(newSymbol(parent, name, Flags.TypeParam, info._2))
               case None =>
                 symbolNotFound(binder, name, parent)
                 None
@@ -131,8 +132,9 @@ class TypeOps:
             enterRefined(m.resType)
           case _ => ()
         }
-      enterParamRef(sym.owner.info)
-      enterRefined(sym.owner.info)
+      if sym.exists && sym.owner.exists then
+        enterParamRef(sym.owner.info)
+        enterRefined(sym.owner.info)
 
       def loop(tpe: Type): s.Signature = tpe match {
         case mp: MethodOrPoly =>
@@ -173,13 +175,12 @@ class TypeOps:
 
         case TypeBounds(lo, hi) =>
           // for `type X[T] = T` is equivalent to `[T] =>> T`
-          def tparams(tpe: Type): (Type, List[Symbol]) = tpe match {
+          def tparams(tpe: Type): (Type, List[SemanticSymbol]) = tpe match {
             case lambda: HKTypeLambda =>
-              val paramSyms = lambda.paramNames.zip(lambda.paramInfos).flatMap { (paramName, bounds) =>
+              val paramSyms: List[SemanticSymbol] = lambda.paramNames.zip(lambda.paramInfos).flatMap { (paramName, bounds) =>
                 // def x[T[_]] = ???
                 if paramName.isWildcard then
-                  val wildcardSym = newSymbol(NoSymbol, tpnme.WILDCARD, Flags.EmptyFlags, bounds)
-                  Some(wildcardSym)
+                  Some(WildcardTypeSymbol(bounds))
                 else
                   paramRefSymtab.getOrErr(lambda, paramName, sym)
               }
@@ -188,10 +189,9 @@ class TypeOps:
           }
           val (loRes, loParams) = tparams(lo)
           val (hiRes, hiParams) = tparams(hi)
-          val params = (loParams ++ hiParams).distinctBy(_.name)
+          val stparams = (loParams ++ hiParams).distinctBy(_.name).sscopeOpt
           val slo = loRes.toSemanticType(sym)
           val shi = hiRes.toSemanticType(sym)
-          val stparams = params.sscopeOpt
           s.TypeSignature(stparams, slo, shi)
 
         case other =>
@@ -320,7 +320,7 @@ class TypeOps:
               // display_name: "_" and,
               // signature: type_signature(..., lo = <Nothing>, hi = <T>)
               case bounds: TypeBounds =>
-                val wildcardSym = newSymbol(NoSymbol, tpnme.WILDCARD, Flags.EmptyFlags, bounds)
+                val wildcardSym = WildcardTypeSymbol(bounds)
                 val ssym = wildcardSym.symbolName
                 (Some(wildcardSym), s.TypeRef(s.Type.Empty, ssym, Seq.empty))
               case other =>
@@ -379,8 +379,8 @@ class TypeOps:
 
 
 object SymbolScopeOps:
-  import Scala3.given
-  extension (syms: List[Symbol])
+  import Scala3.{_, given}
+  extension (syms: List[SemanticSymbol])
     def sscope(using linkMode: LinkMode)(using SemanticSymbolBuilder, TypeOps, Context): s.Scope =
       linkMode match {
         case LinkMode.SymlinkChildren =>