Support named arguments

Author: bishabosha

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

@@ -53,6 +53,9 @@ class ExtractSemanticDB extends Phase with
     /** The index of a local symbol */
     private val locals = mutable.HashMap[Symbol, Int]()
 
+    /** The bodies of synthetic localså */
+    private val localBodies = mutable.HashMap[Symbol, Tree]()
+
     /** The local symbol(s) starting at given offset */
     private val symsAtOffset = new mutable.HashMap[Int, Set[Symbol]]() with
       override def default(key: Int) = Set[Symbol]()
@@ -162,6 +165,8 @@ class ExtractSemanticDB extends Phase with
                 tree.tparams.foreach(tparam => registerSymbolSimple(tparam.symbol))
                 tree.vparamss.foreach(_.foreach(vparam => registerSymbolSimple(vparam.symbol)))
               case _ =>
+            if !tree.symbol.isGlobal
+              localBodies(tree.symbol) = tree.rhs
             // ignore rhs
           case PatternValDef(pat, rhs) =>
             traverse(rhs)
@@ -183,6 +188,15 @@ class ExtractSemanticDB extends Phase with
             tree.body.foreachUntilImport(traverse).foreach(traverse) // the first import statement
           else
             tree.body.foreach(traverse)
+        case tree: Apply =>
+          @tu lazy val genParamSymbol: Name => String = funParamSymbol(tree.fun.symbol)
+          traverse(tree.fun)
+          for arg <- tree.args do
+            arg match
+              case arg @ NamedArg(name, value) =>
+                registerUse(genParamSymbol(name), arg.span.startPos.withEnd(arg.span.start + name.toString.length))
+                traverse(localBodies.get(value.symbol).getOrElse(value))
+              case _ => traverse(arg)
         case tree: Assign =>
           val qualSym = condOpt(tree.lhs) { case Select(qual, _) if qual.symbol.exists => qual.symbol }
           if !excludeUse(qualSym, tree.lhs.symbol)
@@ -222,6 +236,14 @@ class ExtractSemanticDB extends Phase with
 
     end traverse
 
+    private def funParamSymbol(funSym: Symbol)(given Context): Name => String =
+      if funSym.isGlobal then
+        val funSymbol = symbolName(funSym)
+        name => s"$funSymbol($name)"
+      else
+        name => locals.keys.find(local => local.isTerm && local.owner == funSym && local.name == name)
+                      .fold("<?>")(Symbols.LocalPrefix + _)
+
     private object PatternValDef with
 
       def unapply(tree: ValDef)(given Context): Option[(Tree, Tree)] = tree.rhs match
@@ -442,8 +464,11 @@ class ExtractSemanticDB extends Phase with
       if !excludeUse(qualSym, sym) then
         registerUse(sym, span)
 
-    private def registerUse(sym: Symbol, span: Span)(given Context) =
-      registerOccurrence(symbolName(sym), span, SymbolOccurrence.Role.REFERENCE)
+    private def registerUse(sym: Symbol, span: Span)(given Context): Unit =
+      registerUse(symbolName(sym), span)
+
+    private def registerUse(symbol: String, span: Span)(given Context): Unit =
+      registerOccurrence(symbol, span, SymbolOccurrence.Role.REFERENCE)
 
     private def registerDefinition(sym: Symbol, span: Span, symkinds: Set[SymbolKind])(given Context) =
       val symbol = symbolName(sym)

tests/semanticdb/expect/NamedApplyBlock.expect.scala

@@ -3,12 +3,12 @@ package example
 object NamedApplyBlockMethods/*<-example::NamedApplyBlockMethods.*/ {
   val local/*<-example::NamedApplyBlockMethods.local.*/ = 1
   def foo/*<-example::NamedApplyBlockMethods.foo().*/(a/*<-example::NamedApplyBlockMethods.foo().(a)*/: Int/*->scala::Int#*/ = 1, b/*<-example::NamedApplyBlockMethods.foo().(b)*/: Int/*->scala::Int#*/ = 2, c/*<-example::NamedApplyBlockMethods.foo().(c)*/: Int/*->scala::Int#*/ = 3): Int/*->scala::Int#*/ = a/*->example::NamedApplyBlockMethods.foo().(a)*/ +/*->scala::Int#`+`(+4).*/ b/*->example::NamedApplyBlockMethods.foo().(b)*/ +/*->scala::Int#`+`(+4).*/ c/*->example::NamedApplyBlockMethods.foo().(c)*/
-  def baseCase/*<-example::NamedApplyBlockMethods.baseCase().*/ = foo/*->example::NamedApplyBlockMethods.foo().*//*->local0*/(local/*->example::NamedApplyBlockMethods.local.*/, c = 3) // as named apply is desugared, it would take more work to inspect within the body of the setter
-  def recursive/*<-example::NamedApplyBlockMethods.recursive().*/ = foo/*->example::NamedApplyBlockMethods.foo().*//*->local2*/(local/*->example::NamedApplyBlockMethods.local.*/, c = /*->local1*/foo(local, c = 3)) // as named apply is desugared, it would take more work to inspect within the body of the setter
+  def baseCase/*<-example::NamedApplyBlockMethods.baseCase().*/ = foo/*->example::NamedApplyBlockMethods.foo().*//*->local0*/(local/*->example::NamedApplyBlockMethods.local.*/, c/*->example::NamedApplyBlockMethods.foo().(c)*/ = 3)
+  def recursive/*<-example::NamedApplyBlockMethods.recursive().*/ = foo/*->example::NamedApplyBlockMethods.foo().*//*->local2*/(local/*->example::NamedApplyBlockMethods.local.*/, c/*->example::NamedApplyBlockMethods.foo().(c)*/ = foo/*->example::NamedApplyBlockMethods.foo().*//*->local3*/(local/*->example::NamedApplyBlockMethods.local.*/, c/*->example::NamedApplyBlockMethods.foo().(c)*/ = 3))
 }
 
 object NamedApplyBlockCaseClassConstruction/*<-example::NamedApplyBlockCaseClassConstruction.*/ {
   case class Msg/*<-example::NamedApplyBlockCaseClassConstruction.Msg#*/(body/*<-example::NamedApplyBlockCaseClassConstruction.Msg#body.*/: String/*->scala::Predef.String#*/, head/*<-example::NamedApplyBlockCaseClassConstruction.Msg#head.*/: String/*->scala::Predef.String#*/ = "default", tail/*<-example::NamedApplyBlockCaseClassConstruction.Msg#tail.*/: String/*->scala::Predef.String#*/)
   val bodyText/*<-example::NamedApplyBlockCaseClassConstruction.bodyText.*/ = "body"
-  val msg/*<-example::NamedApplyBlockCaseClassConstruction.msg.*/ = Msg/*->example::NamedApplyBlockCaseClassConstruction.Msg.*//*->local3*//*->example::NamedApplyBlockCaseClassConstruction.Msg.apply().*/(bodyText/*->example::NamedApplyBlockCaseClassConstruction.bodyText.*/, tail = "tail")
+  val msg/*<-example::NamedApplyBlockCaseClassConstruction.msg.*/ = Msg/*->example::NamedApplyBlockCaseClassConstruction.Msg.*//*->local4*//*->example::NamedApplyBlockCaseClassConstruction.Msg.apply().*/(bodyText/*->example::NamedApplyBlockCaseClassConstruction.bodyText.*/, tail/*->example::NamedApplyBlockCaseClassConstruction.Msg.apply().(tail)*/ = "tail")
 }

tests/semanticdb/expect/NamedApplyBlock.scala

@@ -3,8 +3,8 @@ package example
 object NamedApplyBlockMethods {
   val local = 1
   def foo(a: Int = 1, b: Int = 2, c: Int = 3): Int = a + b + c
-  def baseCase = foo(local, c = 3) // as named apply is desugared, it would take more work to inspect within the body of the setter
-  def recursive = foo(local, c = foo(local, c = 3)) // as named apply is desugared, it would take more work to inspect within the body of the setter
+  def baseCase = foo(local, c = 3)
+  def recursive = foo(local, c = foo(local, c = 3))
 }
 
 object NamedApplyBlockCaseClassConstruction {

tests/semanticdb/expect/NamedArguments.expect.scala

@@ -2,6 +2,6 @@ package example
 
 class NamedArguments/*<-example::NamedArguments#*/ {
   case class User/*<-example::NamedArguments#User#*/(name/*<-example::NamedArguments#User#name.*/: String/*->scala::Predef.String#*/)
-  User/*->example::NamedArguments#User.*//*->example::NamedArguments#User.apply().*/(name = "John") // as there is no API to get the symbols of method arguments, this proposes a problem for how to generate references from a NamedArg
-  User/*->example::NamedArguments#User.*/.apply/*->example::NamedArguments#User.apply().*/(name = "John") // as there is no API to get the symbols of method arguments, this proposes a problem for how to generate references from a NamedArg
+  User/*->example::NamedArguments#User.*//*->example::NamedArguments#User.apply().*/(name/*->example::NamedArguments#User.apply().(name)*/ = "John")
+  User/*->example::NamedArguments#User.*/.apply/*->example::NamedArguments#User.apply().*/(name/*->example::NamedArguments#User.apply().(name)*/ = "John")
 }

tests/semanticdb/expect/NamedArguments.scala

@@ -2,6 +2,6 @@ package example
 
 class NamedArguments {
   case class User(name: String)
-  User(name = "John") // as there is no API to get the symbols of method arguments, this proposes a problem for how to generate references from a NamedArg
-  User.apply(name = "John") // as there is no API to get the symbols of method arguments, this proposes a problem for how to generate references from a NamedArg
+  User(name = "John")
+  User.apply(name = "John")
 }

tests/semanticdb/metac.expect

@@ -2106,8 +2106,8 @@ Schema => SemanticDB v4
 Uri => NamedApplyBlock.scala
 Text => empty
 Language => Scala
-Symbols => 44 entries
-Occurrences => 40 entries
+Symbols => 45 entries
+Occurrences => 46 entries
 
 Symbols:
 example/NamedApplyBlockCaseClassConstruction. => final object NamedApplyBlockCaseClassConstruction
@@ -2153,7 +2153,8 @@ example/NamedApplyBlockMethods.recursive(). => method recursive
 local0 => val local b$1
 local1 => val local c$1
 local2 => val local b$3
-local3 => val local head$1
+local3 => val local b$2
+local4 => val local head$1
 
 Occurrences:
 [0:8..0:15): example <- example/
@@ -2176,11 +2177,16 @@ Occurrences:
 [5:17..5:20): foo -> example/NamedApplyBlockMethods.foo().
 [5:17..5:17): -> local0
 [5:21..5:26): local -> example/NamedApplyBlockMethods.local.
+[5:28..5:29): c -> example/NamedApplyBlockMethods.foo().(c)
 [6:6..6:15): recursive <- example/NamedApplyBlockMethods.recursive().
 [6:18..6:21): foo -> example/NamedApplyBlockMethods.foo().
 [6:18..6:18): -> local2
 [6:22..6:27): local -> example/NamedApplyBlockMethods.local.
-[6:33..6:33): -> local1
+[6:29..6:30): c -> example/NamedApplyBlockMethods.foo().(c)
+[6:33..6:36): foo -> example/NamedApplyBlockMethods.foo().
+[6:33..6:33): -> local3
+[6:37..6:42): local -> example/NamedApplyBlockMethods.local.
+[6:44..6:45): c -> example/NamedApplyBlockMethods.foo().(c)
 [9:7..9:43): NamedApplyBlockCaseClassConstruction <- example/NamedApplyBlockCaseClassConstruction.
 [10:13..10:16): Msg <- example/NamedApplyBlockCaseClassConstruction.Msg#
 [10:16..10:70): <- example/NamedApplyBlockCaseClassConstruction.Msg#`<init>`().
@@ -2193,9 +2199,10 @@ Occurrences:
 [11:6..11:14): bodyText <- example/NamedApplyBlockCaseClassConstruction.bodyText.
 [12:6..12:9): msg <- example/NamedApplyBlockCaseClassConstruction.msg.
 [12:12..12:15): Msg -> example/NamedApplyBlockCaseClassConstruction.Msg.
-[12:12..12:12): -> local3
+[12:12..12:12): -> local4
 [12:15..12:15): -> example/NamedApplyBlockCaseClassConstruction.Msg.apply().
 [12:16..12:24): bodyText -> example/NamedApplyBlockCaseClassConstruction.bodyText.
+[12:26..12:30): tail -> example/NamedApplyBlockCaseClassConstruction.Msg.apply().(tail)
 
 expect/NamedArguments.scala
 ---------------------------
@@ -2206,7 +2213,7 @@ Uri => NamedArguments.scala
 Text => empty
 Language => Scala
 Symbols => 15 entries
-Occurrences => 11 entries
+Occurrences => 13 entries
 
 Symbols:
 example/NamedArguments# => class NamedArguments
@@ -2235,8 +2242,10 @@ Occurrences:
 [3:24..3:30): String -> scala/Predef.String#
 [4:2..4:6): User -> example/NamedArguments#User.
 [4:6..4:6): -> example/NamedArguments#User.apply().
+[4:7..4:11): name -> example/NamedArguments#User.apply().(name)
 [5:2..5:6): User -> example/NamedArguments#User.
 [5:7..5:12): apply -> example/NamedArguments#User.apply().
+[5:13..5:17): name -> example/NamedArguments#User.apply().(name)
 
 expect/NewModifiers.scala
 -------------------------

tests/semanticdb/todo.md

@@ -11,6 +11,7 @@ Differences between scalameta implementation and dotc.
 
 ## Completed
 
+- [x] Recognise named arguments and traverse their bodies.
 - [x] Recognise pattern val definitions.
 - [x] Recognise anonymous functions.
 - [x] Recognise specialised constant enum values.