Merge pull request #15119 from rochala/signature-help-enclosing-apply-fix

Fix signatureHelp to show enclosing apply instead of closest one.

Author: rochala

compiler/src/dotty/tools/dotc/interactive/Interactive.scala

@@ -79,7 +79,7 @@ object Interactive {
  def enclosingTree(trees: List[SourceTree], pos: SourcePosition)(using Context): Tree =
  enclosingTree(pathTo(trees, pos))
 
- /** The closes enclosing tree with a symbol, or the `EmptyTree`.
+ /** The closest enclosing tree with a symbol, or the `EmptyTree`.
  */
  def enclosingTree(path: List[Tree])(using Context): Tree =
  path.dropWhile(!_.symbol.exists).headOption.getOrElse(tpd.EmptyTree)

compiler/src/dotty/tools/dotc/util/Signatures.scala

@@ -48,19 +48,21 @@ object Signatures {
  * being called, the list of overloads of this function).
  */
  def callInfo(path: List[tpd.Tree], span: Span)(using Context): (Int, Int, List[SingleDenotation]) =
- path match {
- case UnApply(fun, _, patterns) :: _ =>
- callInfo(span, patterns, fun, Signatures.countParams(fun))
- case Apply(fun, params) :: _ =>
- callInfo(span, params, fun, Signatures.countParams(fun))
- case _ =>
- (0, 0, Nil)
+ val enclosingApply = path.find {
+ case Apply(fun, _) => !fun.span.contains(span)
+ case UnApply(fun, _, _) => !fun.span.contains(span)
+ case _ => false
  }
 
+ enclosingApply.map {
+ case UnApply(fun, _, patterns) => callInfo(span, patterns, fun, Signatures.countParams(fun))
+ case Apply(fun, params) => callInfo(span, params, fun, Signatures.countParams(fun))
+ }.getOrElse((0, 0, Nil))
+
  def callInfo(
  span: Span,
- params: List[Tree[Type]], 
- fun: Tree[Type], 
+ params: List[Tree[Type]],
+ fun: Tree[Type],
  alreadyAppliedCount : Int
  )(using Context): (Int, Int, List[SingleDenotation]) =
  val paramIndex = params.indexWhere(_.span.contains(span)) match {

language-server/src/dotty/tools/languageserver/DottyLanguageServer.scala

@@ -556,7 +556,7 @@ class DottyLanguageServer extends LanguageServer
 
  val pos = sourcePosition(driver, uri, params.getPosition)
  val trees = driver.openedTrees(uri)
- val path = Interactive.pathTo(trees, pos).dropWhile(t => !t.isInstanceOf[Apply | UnApply])
+ val path = Interactive.pathTo(trees, pos)
  val (paramN, callableN, alternatives) = Signatures.callInfo(path, pos.span)
  val signatureInfos = alternatives.flatMap(Signatures.toSignature)
 

language-server/test/dotty/tools/languageserver/SignatureHelpTest.scala

@@ -433,4 +433,63 @@ class SignatureHelpTest {
  Some("Option[A]"), None)
  ), None, 2)
  }
+
+ @Test def nestedApplySignatures: Unit = {
+ val signatures = (1 to 5).map { i =>
+ S(s"foo$i", Nil, List(List(P("x", "Int"))), Some("Int"))
+ }
+ val booSignature = S(s"boo", Nil, List(List(P("x", "Int"), P("y", "Int"))), Some("Int"))
+ code"""|object O:
+ | def foo1(x: Int): Int = ???
+ | def foo2(x: Int): Int = ???
+ | def foo3(x: Int): Int = ???
+ | def foo4(x: Int): Int = ???
+ | def foo5(x: Int): Int = ???
+ | def boo(x: Int, y: Int): Int = ???
+ | boo(${m1}, fo${m2}o1(fo${m3}o2(fo${m4}o3(fo${m5}o4(fo${m6}o5(${m7}))))))"""
+ .signatureHelp(m1, List(booSignature), None, 0)
+ .signatureHelp(m2, List(booSignature), None, 1)
+ .signatureHelp(m3, List(signatures(0)), None, 0)
+ .signatureHelp(m4, List(signatures(1)), None, 0)
+ .signatureHelp(m5, List(signatures(2)), None, 0)
+ .signatureHelp(m6, List(signatures(3)), None, 0)
+ .signatureHelp(m7, List(signatures(4)), None, 0)
+ }
+
+ @Test def multipleNestedApplySignatures: Unit = {
+ val simpleSignature = S(s"simpleFoo", Nil, List(List(P("x", "Int"))), Some("Int"))
+ val complicatedSignature = S(s"complicatedFoo", Nil, List(List(P("x", "Int"), P("y", "Int"), P("z", "Int"))), Some("Int"))
+ code"""|object O:
+ | def simpleFoo(x: Int): Int = ???
+ | def complicatedFoo(x: Int, y: Int, z: Int): Int = ???
+ | simpleFoo(
+ | complicated${m1}Foo(
+ | simp${m2}leFoo(${m3}),
+ | complic${m4}atedFoo(
+ | 2,
+ | ${m5},
+ | simpleF${m6}oo(${m7})),
+ | complicated${m8}Foo(5,${m9},7)
+ | )
+ | )"""
+ .signatureHelp(m1, List(simpleSignature), None, 0)
+ .signatureHelp(m2, List(complicatedSignature), None, 0)
+ .signatureHelp(m3, List(simpleSignature), None, 0)
+ .signatureHelp(m4, List(complicatedSignature), None, 1)
+ .signatureHelp(m5, List(complicatedSignature), None, 1)
+ .signatureHelp(m6, List(complicatedSignature), None, 2)
+ .signatureHelp(m7, List(simpleSignature), None, 0)
+ .signatureHelp(m8, List(complicatedSignature), None, 2)
+ .signatureHelp(m9, List(complicatedSignature), None, 1)
+ }
+
+ @Test def noHelpSignatureWithPositionedOnName: Unit = {
+ val signature = S(s"foo", Nil, List(List(P("x", "Int"))), Some("Int"))
+ code"""|object O:
+ | def foo(x: Int): Int = ???
+ | f${m1}oo(${m2})"""
+ .signatureHelp(m1, Nil, None, 0)
+ .signatureHelp(m2, List(signature), None, 0)
+ }
+
 }