Resolve ParamRef by constructing SymbolTable

To construct symbol table before referring the ParamRef
it's required to traverse the child trees before registering the symbol.

Author: tanishiking

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

@@ -23,6 +23,7 @@ import scala.annotation.{ threadUnsafe => tu, tailrec }
 import scala.PartialFunction.condOpt
 
 import dotty.tools.dotc.semanticdb.SemanticSymbolBuilder
+import dotty.tools.dotc.semanticdb.{TypeOps => TOps}
 
 /** Extract symbol references and uses to semanticdb files.
  *  See https://scalameta.org/docs/semanticdb/specification.html#symbol-1
@@ -50,6 +51,7 @@ class ExtractSemanticDB extends Phase:
   /** Extractor of symbol occurrences from trees */
   class Extractor extends TreeTraverser:
     given builder: SemanticSymbolBuilder = SemanticSymbolBuilder()
+    given typeOps: TOps = TOps()
 
     /** The bodies of synthetic locals */
     private val localBodies = mutable.HashMap[Symbol, Tree]()
@@ -123,61 +125,52 @@ class ExtractSemanticDB extends Phase:
 
       tree match
         case tree: PackageDef =>
-          if !excludeDef(tree.pid.symbol)
-          && tree.pid.span.hasLength then
-            tree.pid match
-            case tree: Select =>
-              registerDefinition(tree.symbol, selectSpan(tree), Set.empty, tree.source)
-              traverse(tree.qualifier)
-            case tree => registerDefinition(tree.symbol, tree.span, Set.empty, tree.source)
           tree.stats.foreach(traverse)
+          if !excludeDef(tree.pid.symbol) && tree.pid.span.hasLength then
+            tree.pid match
+              case tree: Select =>
+                traverse(tree.qualifier)
+                registerDefinition(tree.symbol, selectSpan(tree), Set.empty, tree.source)
+              case tree => registerDefinition(tree.symbol, tree.span, Set.empty, tree.source)
         case tree: NamedDefTree =>
           if !tree.symbol.isAllOf(ModuleValCreationFlags) then
-            if !excludeDef(tree.symbol)
-            && tree.span.hasLength then
+            tree match {
+              case tree: ValDef if tree.symbol.isAllOf(EnumValue) =>
+                tree.rhs match
+                case Block(TypeDef(_, template: Template) :: _, _) => // simple case with specialised extends clause
+                  template.parents.filter(!_.span.isZeroExtent).foreach(traverse)
+                case _ => // calls $new
+              case tree: ValDef if tree.symbol.isSelfSym =>
+                if tree.tpt.span.hasLength then
+                  traverse(tree.tpt)
+              case tree: DefDef if tree.symbol.isConstructor => // ignore typeparams for secondary ctors
+                tree.trailingParamss.foreach(_.foreach(traverse))
+                traverse(tree.rhs)
+              case tree: (DefDef | ValDef) if tree.symbol.isSyntheticWithIdent =>
+                tree match
+                  case tree: DefDef =>
+                    tree.paramss.foreach(_.foreach(param => registerSymbolSimple(param.symbol)))
+                  case tree: ValDef if tree.symbol.is(Given) => traverse(tree.tpt)
+                  case _ =>
+                if !tree.symbol.isGlobal then
+                  localBodies(tree.symbol) = tree.rhs
+                // ignore rhs
+              case PatternValDef(pat, rhs) =>
+                traverse(rhs)
+                PatternValDef.collectPats(pat).foreach(traverse)
+              case tree =>
+                if !excludeChildren(tree.symbol) then
+                  traverseChildren(tree)
+            }
+            if !excludeDef(tree.symbol) && tree.span.hasLength then
               registerDefinition(tree.symbol, tree.nameSpan, symbolKinds(tree), tree.source)
               val privateWithin = tree.symbol.privateWithin
               if privateWithin.exists then
                 registerUseGuarded(None, privateWithin, spanOfSymbol(privateWithin, tree.span, tree.source), tree.source)
             else if !excludeSymbol(tree.symbol) then
               registerSymbol(tree.symbol, symbolKinds(tree))
-            tree match
-            case tree: ValDef
-            if tree.symbol.isAllOf(EnumValue) =>
-              tree.rhs match
-              case Block(TypeDef(_, template: Template) :: _, _) => // simple case with specialised extends clause
-                template.parents.filter(!_.span.isZeroExtent).foreach(traverse)
-              case _ => // calls $new
-            case tree: ValDef
-            if tree.symbol.isSelfSym =>
-              if tree.tpt.span.hasLength then
-                traverse(tree.tpt)
-            case tree: DefDef
-            if tree.symbol.isConstructor => // ignore typeparams for secondary ctors
-              tree.trailingParamss.foreach(_.foreach(traverse))
-              traverse(tree.rhs)
-            case tree: (DefDef | ValDef)
-            if tree.symbol.isSyntheticWithIdent =>
-              tree match
-                case tree: DefDef =>
-                  tree.paramss.foreach(_.foreach(param => registerSymbolSimple(param.symbol)))
-                case tree: ValDef if tree.symbol.is(Given) => traverse(tree.tpt)
-                case _ =>
-              if !tree.symbol.isGlobal then
-                localBodies(tree.symbol) = tree.rhs
-              // ignore rhs
-            case PatternValDef(pat, rhs) =>
-              traverse(rhs)
-              PatternValDef.collectPats(pat).foreach(traverse)
-            case tree =>
-              if !excludeChildren(tree.symbol) then
-                traverseChildren(tree)
         case tree: Template =>
           val ctorSym = tree.constr.symbol
-          if !excludeDef(ctorSym) then
-            traverseAnnotsOfDefinition(ctorSym)
-            registerDefinition(ctorSym, tree.constr.nameSpan.startPos, Set.empty, tree.source)
-            ctorParams(tree.constr.termParamss, tree.body)
           for parent <- tree.parentsOrDerived if parent.span.hasLength do
             traverse(parent)
           val selfSpan = tree.self.span
@@ -187,14 +180,18 @@ class ExtractSemanticDB extends Phase:
             tree.body.foreachUntilImport(traverse).foreach(traverse) // the first import statement
           else
             tree.body.foreach(traverse)
+          if !excludeDef(ctorSym) then
+            traverseAnnotsOfDefinition(ctorSym)
+            ctorParams(tree.constr.termParamss, tree.body)
+            registerDefinition(ctorSym, tree.constr.nameSpan.startPos, Set.empty, tree.source)
         case tree: Apply =>
           @tu lazy val genParamSymbol: Name => String = tree.fun.symbol.funParamSymbol
           traverse(tree.fun)
           for arg <- tree.args do
             arg match
               case tree @ NamedArg(name, arg) =>
-                registerUse(genParamSymbol(name), tree.span.startPos.withEnd(tree.span.start + name.toString.length), tree.source)
                 traverse(localBodies.get(arg.symbol).getOrElse(arg))
+                registerUse(genParamSymbol(name), tree.span.startPos.withEnd(tree.span.start + name.toString.length), tree.source)
               case _ => traverse(arg)
         case tree: Assign =>
           val qualSym = condOpt(tree.lhs) { case Select(qual, _) if qual.symbol.exists => qual.symbol }
@@ -214,19 +211,19 @@ class ExtractSemanticDB extends Phase:
           val qual = tree.qualifier
           val qualSpan = qual.span
           val sym = tree.symbol.adjustIfCtorTyparam
-          registerUseGuarded(qual.symbol.ifExists, sym, selectSpan(tree), tree.source)
           if qualSpan.exists && qualSpan.hasLength then
             traverse(qual)
+          registerUseGuarded(qual.symbol.ifExists, sym, selectSpan(tree), tree.source)
         case tree: Import =>
           if tree.span.exists && tree.span.hasLength then
+            traverseChildren(tree)
             for sel <- tree.selectors do
               val imported = sel.imported.name
               if imported != nme.WILDCARD then
                 for alt <- tree.expr.tpe.member(imported).alternatives do
                   registerUseGuarded(None, alt.symbol, sel.imported.span, tree.source)
                   if (alt.symbol.companionClass.exists)
                     registerUseGuarded(None, alt.symbol.companionClass, sel.imported.span, tree.source)
-            traverseChildren(tree)
         case tree: Inlined =>
           traverse(tree.call)
         case _ =>
@@ -416,13 +413,13 @@ class ExtractSemanticDB extends Phase:
         vparams <- vparamss
         vparam  <- vparams
       do
+        traverse(vparam.tpt)
         if !excludeSymbol(vparam.symbol) then
           traverseAnnotsOfDefinition(vparam.symbol)
           val symkinds =
             getters.get(vparam.name).fold(SymbolKind.emptySet)(getter =>
               if getter.mods.is(Mutable) then SymbolKind.VarSet else SymbolKind.ValSet)
           registerSymbol(vparam.symbol, symkinds)
-        traverse(vparam.tpt)
 
 object ExtractSemanticDB:
   import java.nio.file.Path

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

@@ -126,8 +126,7 @@ object Scala3:
       def isSyntheticWithIdent(using Context): Boolean =
         sym.is(Synthetic) && !sym.isAnonymous && !sym.name.isEmptyNumbered
 
-      def symbolInfo(symkinds: Set[SymbolKind])(using LinkMode, Context, SemanticSymbolBuilder): SymbolInformation =
-        import TypeOps._
+      def symbolInfo(symkinds: Set[SymbolKind])(using LinkMode, Context, SemanticSymbolBuilder, TypeOps): SymbolInformation =
         val sname = sym.symbolName
         val signature = sym.info.toSemanticSig(sym)
         SymbolInformation(

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

@@ -7,14 +7,39 @@ import core.Contexts.Context
 import core.Types._
 import core.Annotations.Annotation
 import core.Flags
+import core.Names.Name
 import ast.tpd._
 
+import collection.mutable
+
 import dotty.tools.dotc.{semanticdb => s}
 
-object TypeOps:
+class TypeOps:
   import SymbolScopeOps._
+  private val symtab = mutable.Map[(LambdaType, Name), Symbol]()
+  given typeOps: TypeOps = this
   extension (tpe: Type)
     def toSemanticSig(using LinkMode, Context, SemanticSymbolBuilder)(sym: Symbol): s.Signature =
+
+      def enter(keyTpe: Type): Unit =
+        keyTpe match {
+          case lam: LambdaType =>
+            symtab((lam, sym.name)) = sym
+
+          // for class constructor
+          case cls: ClassInfo if sym.info.isInstanceOf[LambdaType] =>
+            val lam = sym.info.asInstanceOf[LambdaType]
+            cls.cls.typeParams.foreach { param =>
+              symtab((lam, param.name)) = param
+            }
+
+          case tb: TypeBounds =>
+            enter(tb.lo)
+            enter(tb.hi)
+          case _ => ()
+        }
+      enter(sym.owner.info)
+
       def loop(tpe: Type): s.Signature = tpe match {
         case mt: MethodType =>
           val stparams = Some(s.Scope())
@@ -41,8 +66,9 @@ object TypeOps:
           // for `type X[T] = T` is equivalent to `[T] =>> T`
           def tparams(tpe: Type): (Type, List[Symbol]) = tpe match {
             case lambda: HKTypeLambda =>
-              val paramSyms = lambda.paramNames.zip(lambda.paramInfos).map { (nme, info) =>
-                newSymbol(sym, nme, Flags.TypeParam, info)
+              val paramSyms = lambda.paramNames.flatMap { paramName =>
+                val key = (lambda, paramName)
+                symtab.get(key)
               }
               (lambda.resType, paramSyms)
             case _ => (tpe, Nil)
@@ -97,11 +123,8 @@ object TypeOps:
           s.SingleType(spre, ssym)
 
         case tref: ParamRef =>
-          val paramref = sym.rawParamss.flatMap { params =>
-            if (params.length > tref.paramNum) Some(params(tref.paramNum))
-            else None
-          }.find(p => p.name == tref.paramName)
-          paramref match {
+          val key = (tref.binder, tref.paramName)
+          symtab.get(key) match {
             case Some(ref) =>
               val ssym = ref.symbolName
               tref match {
@@ -233,7 +256,7 @@ object TypeOps:
 object SymbolScopeOps:
   import Scala3.given
   extension (syms: List[Symbol])
-    def sscope(using linkMode: LinkMode)(using SemanticSymbolBuilder, Context): s.Scope =
+    def sscope(using linkMode: LinkMode)(using SemanticSymbolBuilder, TypeOps, Context): s.Scope =
       linkMode match {
         case LinkMode.SymlinkChildren =>
           s.Scope(symlinks = syms.map(_.symbolName))

tests/semanticdb/expect/Advanced.expect.scala

@@ -10,9 +10,9 @@ class C/*<-advanced::C#*/[T/*<-advanced::C#[T]*/] {
 }
 
 class Structural/*<-advanced::Structural#*/ {
-  def s1/*<-advanced::Structural#s1().*/: { val x/*<-local1*/: Int/*->scala::Int#*/ } = ???/*->scala::Predef.`???`().*/
-  def s2/*<-advanced::Structural#s2().*/: { val x/*<-local3*/: Int/*->scala::Int#*/ } = new { val x/*<-local6*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ }
-  def s3/*<-advanced::Structural#s3().*/: { def m/*<-local9*/(x/*<-local10*/: Int/*->scala::Int#*/): Int/*->scala::Int#*/ } = new { def m/*<-local13*/(x/*<-local14*/: Int/*->scala::Int#*/): Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ }
+  def s1/*<-advanced::Structural#s1().*/: { val x/*<-local0*/: Int/*->scala::Int#*/ } = ???/*->scala::Predef.`???`().*/
+  def s2/*<-advanced::Structural#s2().*/: { val x/*<-local2*/: Int/*->scala::Int#*/ } = new { val x/*<-local3*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ }
+  def s3/*<-advanced::Structural#s3().*/: { def m/*<-local8*/(x/*<-local7*/: Int/*->scala::Int#*/): Int/*->scala::Int#*/ } = new { def m/*<-local10*/(x/*<-local9*/: Int/*->scala::Int#*/): Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ }
 }
 
 class Wildcards/*<-advanced::Wildcards#*/ {

tests/semanticdb/expect/Classes.expect.scala

@@ -47,7 +47,7 @@ class C12/*<-classes::C12#*/ {
 
 object N/*<-classes::N.*/ {
   val anonClass/*<-classes::N.anonClass.*/ = new C7/*->classes::C7#*/(42) {
-    val local/*<-local2*/ = ???/*->scala::Predef.`???`().*/
+    val local/*<-local0*/ = ???/*->scala::Predef.`???`().*/
   }
   val anonFun/*<-classes::N.anonFun.*/ = List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1).map/*->scala::collection::immutable::List#map().*/ { i/*<-local3*/ =>
     val local/*<-local4*/ = 2

tests/semanticdb/expect/ForComprehension.expect.scala

@@ -17,7 +17,7 @@ class ForComprehension/*<-example::ForComprehension#*/ {
     /*->local6*//*->scala::Tuple2.unapply().*/(
       /*->scala::Tuple2.unapply().*/c/*<-local7*/,
       d/*<-local8*/
-    ) <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/((/*->scala::Tuple2.apply().*/a/*->local4*/, b/*->local5*/))/*->scala::collection::WithFilter#withFilter().*//*->scala::collection::IterableOps#withFilter().*/
+    ) <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/((/*->scala::Tuple2.apply().*/a/*->local4*/, b/*->local5*/))/*->scala::collection::IterableOps#withFilter().*//*->scala::collection::WithFilter#withFilter().*/
     if (
       /*->scala::Tuple4.apply().*/a/*->local4*/,
       b/*->local5*/,

tests/semanticdb/expect/Givens.expect.scala

@@ -18,7 +18,7 @@ object Givens/*<-a::b::Givens.*/:
     def empty/*<-a::b::Givens.Monoid#empty().*/: A/*->a::b::Givens.Monoid#[A]*/
     extension (x/*<-a::b::Givens.Monoid#combine().(x)*/: A/*->a::b::Givens.Monoid#[A]*/) def combine/*<-a::b::Givens.Monoid#combine().*/(y/*<-a::b::Givens.Monoid#combine().(y)*/: A/*->a::b::Givens.Monoid#[A]*/): A/*->a::b::Givens.Monoid#[A]*/
 
-  given Monoid[String] with/*<-a::b::Givens.given_Monoid_String.*//*->a::b::Givens.Monoid#*//*->scala::Predef.String#*/
+  given Monoid/*->a::b::Givens.Monoid#*/[String] with/*<-a::b::Givens.given_Monoid_String.*//*->scala::Predef.String#*/
     def empty/*<-a::b::Givens.given_Monoid_String.empty().*/ = ""
     extension (x/*<-a::b::Givens.given_Monoid_String.combine().(x)*/: String/*->scala::Predef.String#*/) def combine/*<-a::b::Givens.given_Monoid_String.combine().*/(y/*<-a::b::Givens.given_Monoid_String.combine().(y)*/: String/*->scala::Predef.String#*/) = x/*->a::b::Givens.given_Monoid_String.combine().(x)*/ +/*->java::lang::String#`+`().*/ y/*->a::b::Givens.given_Monoid_String.combine().(y)*/
 

tests/semanticdb/expect/InventedNames.expect.scala

@@ -12,15 +12,15 @@ trait Z/*<-givens::Z#*/[T/*<-givens::Z#[T]*/]:
 
 
 given intValue/*<-givens::InventedNames$package.intValue.*/: Int/*->scala::Int#*/ = 4
-given /*<-givens::InventedNames$package.given_String.*/String/*->scala::Predef.String#*/ = "str"
+given String/*->scala::Predef.String#*//*<-givens::InventedNames$package.given_String.*/ = "str"
 given /*<-givens::InventedNames$package.given_Double().*/(using Int/*->scala::Int#*/): Double/*->scala::Double#*/ = 4.0
 given /*<-givens::InventedNames$package.given_List_T().*/[T/*<-givens::InventedNames$package.given_List_T().[T]*/]: List/*->scala::package.List#*/[T/*->givens::InventedNames$package.given_List_T().[T]*/] = Nil/*->scala::package.Nil.*/
 given given_Char/*<-givens::InventedNames$package.given_Char.*/: Char/*->scala::Char#*/ = '?'
 given `given_Float/*<-givens::InventedNames$package.given_Float.*/`: Float/*->scala::Float#*/ = 3.0
 given `* */*<-givens::InventedNames$package.`* *`.*/`: Long/*->scala::Long#*/ = 5
 
-given X with
-/*<-givens::InventedNames$package.given_X.*//*->givens::X#*/  def doX/*<-givens::InventedNames$package.given_X.doX().*/ = 7
+given X/*->givens::X#*/ with
+/*<-givens::InventedNames$package.given_X.*/  def doX/*<-givens::InventedNames$package.given_X.doX().*/ = 7
 
 given (using X/*->givens::X#*/): Y/*->givens::Y#*/ with
   def doY/*<-givens::InventedNames$package.given_Y#doY().*/ = "7"

tests/semanticdb/expect/Local.expect.scala

@@ -2,7 +2,7 @@ package example
 
 class Local/*<-example::Local#*/ {
   def a/*<-example::Local#a().*/() = {
-    def id/*<-local0*/[A/*<-local1*/](a/*<-local2*/: A/*->local1*/): A/*->local1*/ = a/*->local2*/
-    id/*->local0*/(1)
+    def id/*<-local2*/[A/*<-local0*/](a/*<-local1*/: A/*->local0*/): A/*->local0*/ = a/*->local1*/
+    id/*->local2*/(1)
   }
 }

tests/semanticdb/expect/Methods.expect.scala

@@ -23,7 +23,7 @@ class Methods/*<-example::Methods#*/[T/*<-example::Methods#[T]*/] {
   def m11/*<-example::Methods#m11().*/(x/*<-example::Methods#m11().(x)*/: Predef/*->scala::Predef.*/.type) = ???/*->scala::Predef.`???`().*/
   def m11/*<-example::Methods#m11(+1).*/(x/*<-example::Methods#m11(+1).(x)*/: Example/*->example::Example.*/.type) = ???/*->scala::Predef.`???`().*/
   def m12a/*<-example::Methods#m12a().*/(x/*<-example::Methods#m12a().(x)*/: {}) = ???/*->scala::Predef.`???`().*/
-  def m12b/*<-example::Methods#m12b().*/(x/*<-example::Methods#m12b().(x)*/: { val x/*<-local1*/: Int/*->scala::Int#*/ }) = ???/*->scala::Predef.`???`().*/
+  def m12b/*<-example::Methods#m12b().*/(x/*<-example::Methods#m12b().(x)*/: { val x/*<-local0*/: Int/*->scala::Int#*/ }) = ???/*->scala::Predef.`???`().*/
   def m13/*<-example::Methods#m13().*/(x/*<-example::Methods#m13().(x)*/: Int/*->scala::Int#*/ @unchecked/*->scala::unchecked#*/) = ???/*->scala::Predef.`???`().*/
   def m15/*<-example::Methods#m15().*/(x/*<-example::Methods#m15().(x)*/: => Int/*->scala::Int#*/) = ???/*->scala::Predef.`???`().*/
   def m16/*<-example::Methods#m16().*/(x/*<-example::Methods#m16().(x)*/: Int/*->scala::Int#*/*) = ???/*->scala::Predef.`???`().*/

tests/semanticdb/expect/Synthetic.expect.scala

@@ -44,7 +44,7 @@ class Synthetic/*<-example::Synthetic#*/ {
   for {
     a/*<-local8*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(1)/*->scala::concurrent::Future#flatMap().*/
     b/*<-local9*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(2)/*->scala::concurrent::Future#withFilter().*/
-    if a/*->local8*/ </*->scala::Int#`<`(+3).*/ b/*->local9*//*->scala::concurrent::Future#map().*//*->scala::concurrent::ExecutionContext.Implicits.global().*/
+    if a/*->local8*/ </*->scala::Int#`<`(+3).*/ b/*->local9*//*->scala::concurrent::ExecutionContext.Implicits.global().*//*->scala::concurrent::Future#map().*/
   } yield a/*->local8*//*->scala::concurrent::ExecutionContext.Implicits.global().*/
 
 }