fix tests, active parameter position and simplify code

Author: rochala

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

@@ -49,9 +49,8 @@ object Signatures {
    */
   def callInfo(path: List[tpd.Tree], span: Span)(using Context): (Int, Int, List[SingleDenotation]) =
     val enclosingApply = path.dropWhile {
-      case Apply(fun, _) => fun.span.contains(span)
-      case unapply @ UnApply(fun, _, _) =>
-        fun.span.contains(span) || ctx.definitions.isTupleClass(unapply.fun.symbol.owner.companionClass)
+      case apply @ Apply(fun, _) => fun.span.contains(span) || apply.span.end == span.end
+      case unapply @ UnApply(fun, _, _) => fun.span.contains(span) || unapply.span.end == span.end || isTuple(unapply)
       case _ => true
     }.headOption
 
@@ -92,16 +91,17 @@ object Signatures {
   )(using Context): (Int, Int, List[SingleDenotation]) =
     val patternPosition = patterns.indexWhere(_.span.contains(span))
     val activeParameter = extractParamTypess(fun.tpe.finalResultType.widen).headOption.map { params =>
-      if patternPosition == -1 then
-        if patterns.length > 0 then
-          (params.size - 1)
-        else
-          0
-      else
-        (params.size - 1) min patternPosition
-    }.getOrElse(patternPosition)
+      (patternPosition, patterns.length) match
+        case (-1, 0) => 0 // there are no patterns yet so it must be first one
+        case (-1, pos) => -1 // there are patterns, we must be outside range so we set no active parameter
+        case _ => (params.size - 1) min patternPosition max 0 // handle unapplySeq to always highlight Seq[A] on elements
+    }.getOrElse(-1)
+
+    val appliedDenot = fun.symbol.asSingleDenotation.mapInfo(_ => fun.tpe) :: Nil
+    (activeParameter, 0, appliedDenot)
 
-    (activeParameter, 0, fun.symbol.asSingleDenotation.mapInfo(_ => fun.tpe) :: Nil)
+  private def isTuple(tree: tpd.Tree)(using Context): Boolean =
+    ctx.definitions.isTupleClass(tree.symbol.owner.companionClass)
 
   private def extractParamTypess(resultType: Type)(using Context): List[List[Type]] =
     resultType match {

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

@@ -40,7 +40,7 @@ class SignatureHelpTest {
           |    case s @ Even(${m1}) => println(s"s has an even number of characters")
           |    case s               => println(s"s has an odd number of characters")
           """
-      .signatureHelp(m1, Nil, Some(0), 0)
+      .signatureHelp(m1, Nil, Some(0), -1)
   }
 
   @Test def unapplyCustomClass: Unit = {
@@ -78,6 +78,46 @@ class SignatureHelpTest {
       .signatureHelp(m2, List(signature), Some(0), 1)
   }
 
+  @Test def nestedUnapplySignature: Unit = {
+    val signatureOneTwo = S("", Nil, List(List(P("a", "One"), P("b", "Two"))), None)
+    val signatureOne = S("", Nil, List(List(P("c", "Int"))), None)
+    val signatureTwo = S("", Nil, List(List(P("d", "Int"))), None)
+
+    code"""case class One(c: Int)
+          |case class Two(d: Int)
+          |case class OneTwo[A, B](a: A, b: B)
+          |
+          |object Main {
+          |  val tp = new OneTwo(One(1), Two(5))
+          |  tp match {
+          |    case OneTwo(x${m1}, ${m2}) =>
+          |    case OneTwo(One(x${m4})${m3}, T${m5}wo(${m6})${m8})${m7} =>
+          |  }
+          |}"""
+      .signatureHelp(m1, List(signatureOneTwo), Some(0), 0)
+      .signatureHelp(m2, List(signatureOneTwo), Some(0), 1)
+      .signatureHelp(m3, List(signatureOneTwo), Some(0), 0)
+      .signatureHelp(m4, List(signatureOne), Some(0), 0)
+      .signatureHelp(m5, List(signatureOneTwo), Some(0), 1)
+      .signatureHelp(m6, List(signatureTwo), Some(0), 0)
+  }
+
+  @Test def properParameterIndexTest: Unit = {
+    val signature = S("", Nil, List(List(P("a", "Int"), P("b", "String"))), None)
+    code"""case class Two(a: Int, b: String)
+          |
+          |object Main {
+          |  val tp = new Two(1, "")
+          |  tp match {
+          |    case Two(x${m1}, y  ${m2}, d${m3})${m4} =>
+          |  }
+          |}"""
+      .signatureHelp(m1, List(signature), Some(0), 0)
+      .signatureHelp(m2, List(signature), Some(0), -1)
+      .signatureHelp(m3, List(signature), Some(0), -1)
+      .signatureHelp(m4, Nil, Some(0), 0)
+  }
+
   @Test def unapplyClass: Unit = {
     val signature = S("", Nil, List(List(P("", "Int"), P("", "String"))), None)