fix literal type in ctor, move tests

Author: bishabosha

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

@@ -72,8 +72,6 @@ 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
@@ -107,28 +105,15 @@ class ExtractSemanticDB extends Phase:
       || qualifier.exists(excludeQual)
 
     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)
+      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 =
 
-      def traverseCtorParamTpt(ctorSym: Symbol, tpt: Tree)(using Context): Unit =
-        val tptSym = tpt match
-          case ByNameTypeTree(tpt) => tpt.symbol
-          case tpt                 => tpt.symbol
-        if tptSym.owner == ctorSym
-          val found = matchingMemberType(tptSym, ctorSym.owner)
-          if tpt.span.hasLength
-            registerUseGuarded(None, found, tpt.span)
-        else
-          traverse(tpt)
-
       tree match
         case tree: DefTree if tree.symbol.exists =>
           traverseAnnotsOfDefinition(tree.symbol)
@@ -192,7 +177,7 @@ class ExtractSemanticDB extends Phase:
           if !excludeDef(ctorSym)
             traverseAnnotsOfDefinition(ctorSym)
             registerDefinition(ctorSym, tree.constr.span, Set.empty)
-            ctorParams(tree.constr.vparamss, tree.body)(traverseCtorParamTpt(ctorSym, _))
+            ctorParams(tree.constr.vparamss, tree.body)
           for parent <- tree.parentsOrDerived if parent.span.hasLength do
             traverse(parent)
           val selfSpan = tree.self.span
@@ -571,7 +556,7 @@ class ExtractSemanticDB extends Phase:
         symkinds.toSet
 
     private def ctorParams(
-      vparamss: List[List[ValDef]], body: List[Tree])(traverseTpt: Tree => Unit)(using Context): Unit =
+      vparamss: List[List[ValDef]], body: List[Tree])(using Context): Unit =
       @tu lazy val getters = findGetters(vparamss.flatMap(_.map(_.name)).toSet, body)
       for
         vparams <- vparamss
@@ -583,7 +568,7 @@ class ExtractSemanticDB extends Phase:
             getters.get(vparam.name).fold(SymbolKind.emptySet)(getter =>
               if getter.mods.is(Mutable) then SymbolKind.VarSet else SymbolKind.ValSet)
           registerSymbol(vparam.symbol, symbolName(vparam.symbol), symkinds)
-        traverseTpt(vparam.tpt)
+        traverse(vparam.tpt)
 
 object ExtractSemanticDB:
   import java.nio.file.Path

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

@@ -22,6 +22,8 @@ class C8/*<-classes::C8#*/(private[this] val x/*<-classes::C8#x.*/: Int/*->scala
 
 class C9/*<-classes::C9#*/(private[this] var x/*<-classes::C9#x().*/: Int/*->scala::Int#*/)
 
+class C10/*<-classes::C10#*/(s/*<-classes::C10#s.*/: => String/*->scala::Predef.String#*/)
+
 object N/*<-classes::N.*/ {
   val anonClass/*<-classes::N.anonClass.*/ = new C7/*->classes::C7#*/(42) {
     val local/*<-local1*/ = ???/*->scala::Predef.`???`().*/

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

@@ -22,6 +22,8 @@ class C8(private[this] val x: Int)
 
 class C9(private[this] var x: Int)
 
+class C10(s: => String)
+
 object N {
   val anonClass = new C7(42) {
     val local = ???

tests/semanticdb/expect/Classes.expect.scala

@@ -16,8 +16,8 @@ object Enums/*<-_empty_::Enums.*/:
       suit/*->_empty_::Enums.Suits.isRed().(suit)*/ ==/*->scala::Any#`==`().*/ Hearts/*->_empty_::Enums.Suits.Hearts.*/ ||/*->scala::Boolean#`||`().*/ suit/*->_empty_::Enums.Suits.isRed().(suit)*/ ==/*->scala::Any#`==`().*/ Diamonds/*->_empty_::Enums.Suits.Diamonds.*/
 
     def (suit: /*<-_empty_::Enums.Suits.isBlack().*//*<-_empty_::Enums.Suits.isBlack().(suit)*/Suits/*->_empty_::Enums.Suits#*/).isBlack: Boolean/*->scala::Boolean#*/ = suit/*->_empty_::Enums.Suits.isBlack().(suit)*/ match
-      case Spades/*->_empty_::Enums.Suits.Spades.*/ | Diamonds/*->_empty_::Enums.Suits.Diamonds.*/ => true
-      case _                 => false
+      case Spades/*->_empty_::Enums.Suits.Spades.*/ | Clubs/*->_empty_::Enums.Suits.Clubs.*/ => true
+      case _              => false
 
   enum WeekDays/*<-_empty_::Enums.WeekDays#*/:
     case Monday/*<-_empty_::Enums.WeekDays.Monday.*/

tests/semanticdb/expect/Classes.scala

@@ -16,8 +16,8 @@ object Enums:
       suit == Hearts || suit == Diamonds
 
     def (suit: Suits).isBlack: Boolean = suit match
-      case Spades | Diamonds => true
-      case _                 => false
+      case Spades | Clubs => true
+      case _              => false
 
   enum WeekDays:
     case Monday

tests/semanticdb/expect/Enums.expect.scala

@@ -0,0 +1,25 @@
+// semanticdb traversal of annotations of Nat caused an infinite loop
+package recursion
+
+object Nats/*<-recursion::Nats.*/ {
+  sealed trait Nat/*<-recursion::Nats.Nat#*/ {
+    inline def ++/*<-recursion::Nats.Nat#`++`().*/ : Succ/*->recursion::Nats.Succ#*/[this.type] = Succ/*->recursion::Nats.Succ.*//*->recursion::Nats.Succ.apply().*/(this)
+
+    transparent inline def +/*<-recursion::Nats.Nat#`+`().*/(inline that/*<-recursion::Nats.Nat#`+`().(that)*/: Nat/*->recursion::Nats.Nat#*/): Nat/*->recursion::Nats.Nat#*/ =
+      inline this match {
+        case Zero/*->recursion::Nats.Zero.*/    => that/*->recursion::Nats.Nat#`+`().(that)*/
+        case Succ/*->recursion::Nats.Succ.*//*->recursion::Nats.Succ.unapply().*//*->local0*/(p/*<-local1*/) => p/*->local1*/ +/*->recursion::Nats.Nat#`+`().*/ that/*->recursion::Nats.Nat#`+`().(that)*/.++/*->recursion::Nats.Nat#`++`().*/
+    }
+  }
+
+  case object Zero/*<-recursion::Nats.Zero.*/ extends Nat/*->recursion::Nats.Nat#*/
+  case class Succ/*<-recursion::Nats.Succ#*/[N/*<-recursion::Nats.Succ#[N]*/ <: Nat](p/*<-recursion::Nats.Succ#p.*/: N/*->recursion::Nats.Succ#[N]*/) extends Nat/*->recursion::Nats.Nat#*/
+
+  transparent inline def toIntg/*<-recursion::Nats.toIntg().*/(inline n/*<-recursion::Nats.toIntg().(n)*/: Nat/*->recursion::Nats.Nat#*/): Int/*->scala::Int#*/ =
+    inline n/*->recursion::Nats.toIntg().(n)*/ match {
+      case Zero/*->recursion::Nats.Zero.*/    => 0
+      case Succ/*->recursion::Nats.Succ.*//*->recursion::Nats.Succ.unapply().*//*->local2*/(p/*<-local3*/) => toIntg/*->recursion::Nats.toIntg().*/(p/*->local3*/) +/*->scala::Int#`+`(+4).*/ 1
+    }
+
+  val j31/*<-recursion::Nats.j31.*/ = toIntg/*->recursion::Nats.toIntg().*/(Zero/*->recursion::Nats.Zero.*/.++.++.++/*<-local4*//*->recursion::Nats.Zero.*//*->recursion::Nats.Nat#`++`().*/ + /*<-local5*//*->recursion::Nats.Nat#`++`().*/Zer/*<-local6*//*->recursion::Nats.Nat#`++`().*//*->recursion::Nats.Nat#`+`().*/o/*->recursion::Nats.Zero.*/.++/*->recursion::Nats.Nat#`++`().*/)
+}

tests/semanticdb/expect/Enums.scala

@@ -0,0 +1,25 @@
+// semanticdb traversal of annotations of Nat caused an infinite loop
+package recursion
+
+object Nats {
+  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.++)
+}

tests/semanticdb/expect/recursion.expect.scala

@@ -23,6 +23,13 @@ class T/*<-types::T#*/ {
   val x/*<-types::T#x.*/ = new X/*->types::T#X#*/
 }
 
+case class Foo/*<-types::Foo#*/(s/*<-types::Foo#s.*/: "abc")
+
+object Foo/*<-types::Foo.*/ {
+  val x/*<-types::Foo.x.*/: "abc" @deprecated/*->scala::deprecated#*/ = "abc"
+  val y/*<-types::Foo.y.*/: "abc" = x/*->types::Foo.x.*/
+}
+
 object Test/*<-types::Test.*/ {
   class M/*<-types::Test.M#*/ {
     def m/*<-types::Test.M#m().*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/

tests/semanticdb/expect/recursion.scala

@@ -23,6 +23,13 @@ class T {
   val x = new X
 }
 
+case class Foo(s: "abc")
+
+object Foo {
+  val x: "abc" @deprecated = "abc"
+  val y: "abc" = x
+}
+
 object Test {
   class M {
     def m: Int = ???