traverse annots once per definition symbol

Author: bishabosha

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

@@ -72,6 +72,8 @@ class ExtractSemanticDB extends Phase:
     /** The symbol occurrences generated so far, as a set */
     private val generated = new mutable.HashSet[SymbolOccurrence]
 
+    private val anotatedSymbols = new mutable.HashSet[Symbol]
+
     /** Definitions of this symbol should be excluded from semanticdb */
     private def excludeDef(sym: Symbol)(using Context): Boolean =
       !sym.exists
@@ -104,13 +106,15 @@ class ExtractSemanticDB extends Phase:
       || sym == defn.Any_typeCast
       || qualifier.exists(excludeQual)
 
-    private def traverseAnnotsOf(sym: Symbol)(using Context): Unit =
-      for annot <- sym.annotations do
-        if annot.tree.span.exists
-        && annot.tree.span.hasLength
-          annot.tree match
-            case tree: Typed => () // hack for inline code
-            case tree        => traverse(tree)
+    private def traverseAnnotsOfDefinition(sym: Symbol)(using Context): Unit =
+      if (!anotatedSymbols.contains(sym)) then
+        anotatedSymbols += sym
+        for annot <- sym.annotations do
+          if annot.tree.span.exists
+          && annot.tree.span.hasLength
+            annot.tree match
+              case tree: Typed => () // hack for inline code
+              case tree        => traverse(tree)
 
     override def traverse(tree: Tree)(using Context): Unit =
 
@@ -125,7 +129,11 @@ class ExtractSemanticDB extends Phase:
         else
           traverse(tpt)
 
-      traverseAnnotsOf(tree.symbol)
+      tree match
+        case tree: DefTree if tree.symbol.exists =>
+          traverseAnnotsOfDefinition(tree.symbol)
+        case _ =>
+          ()
 
       tree match
         case tree: PackageDef =>
@@ -182,6 +190,7 @@ class ExtractSemanticDB extends Phase:
         case tree: Template =>
           val ctorSym = tree.constr.symbol
           if !excludeDef(ctorSym)
+            traverseAnnotsOfDefinition(ctorSym)
             registerDefinition(ctorSym, tree.constr.span, Set.empty)
             ctorParams(tree.constr.vparamss, tree.body)(traverseCtorParamTpt(ctorSym, _))
           for parent <- tree.parentsOrDerived if parent.span.hasLength do
@@ -568,8 +577,8 @@ class ExtractSemanticDB extends Phase:
         vparams <- vparamss
         vparam  <- vparams
       do
-        traverseAnnotsOf(vparam.symbol)
         if !excludeSymbol(vparam.symbol)
+          traverseAnnotsOfDefinition(vparam.symbol)
           val symkinds =
             getters.get(vparam.name).fold(SymbolKind.emptySet)(getter =>
               if getter.mods.is(Mutable) then SymbolKind.VarSet else SymbolKind.ValSet)

compiler/test/dotty/tools/vulpix/TestConfiguration.scala

@@ -16,6 +16,7 @@ object TestConfiguration {
     "-Yno-deep-subtypes",
     "-Yno-double-bindings",
     "-Yforce-sbt-phases",
+    // "-Ysemanticdb",
     "-Xverify-signatures"
   )
 

tests/pos-custom-args/semanticdb/recursiveAnnotResolve.scala

@@ -0,0 +1,28 @@
+trait Reporter:
+  def report(m: String): Unit
+
+class Dummy extends Reporter:
+  def report(m: String) = ()
+
+  object ABug {
+    sealed trait Nat {
+      inline def ++ : Succ[this.type] = Succ(this)
+
+      transparent inline def +(inline that: Nat): Nat =
+        inline this match {
+          case Zero    => that
+          case Succ(p) => p + that.++
+      }
+    }
+
+    case object Zero extends Nat
+    case class Succ[N <: Nat](p: N) extends Nat
+
+    transparent inline def toIntg(inline n: Nat): Int =
+      inline n match {
+        case Zero    => 0
+        case Succ(p) => toIntg(p) + 1
+      }
+
+    val j31 = toIntg(Zero.++.++.++ + Zero.++)
+  }