IDE: fix signature help for Java and Scala 2 methods

Asking for the signature of a method not defined in sources or in Tasty
used to throw an exception because the symbol passed to `defPath` must
have a span. The call to `defPath` was only used to determine which
parameters were implicit, but this can be done in an easier way by
checking `isImplicitMethod`, so we can get rid of it at no loss.

Author: smarter

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

@@ -80,27 +80,25 @@ object Signatures {
     val symbol = denot.symbol
     val docComment = ParsedComment.docOf(symbol)
     val classTree = symbol.topLevelClass.asClass.rootTree
-    val isImplicit: TermName => Boolean = tpd.defPath(symbol, classTree).lastOption match {
-      case Some(DefDef(_, _, paramss, _, _)) =>
-        val flatParams = paramss.flatten
-        name => flatParams.find(_.name == name).map(_.symbol.is(Implicit)).getOrElse(false)
-      case _ =>
-        _ => false
+
+    def toParamss(tp: MethodType)(implicit ctx: Context): List[List[Param]] = {
+      val rest = tp.resType match {
+        case res: MethodType =>
+          toParamss(res)
+        case _ =>
+          Nil
+      }
+      tp.paramNames.zip(tp.paramInfos).map { case (name, info) =>
+        Signatures.Param(name.show,
+          info.widenTermRefExpr.show,
+          docComment.flatMap(_.paramDoc(name)),
+          isImplicit = tp.isImplicitMethod)
+      } :: rest
     }
 
     denot.info.stripPoly match {
       case tpe: MethodType =>
-        val infos = {
-          tpe.paramInfoss.zip(tpe.paramNamess).map { case (infos, names) =>
-            infos.zip(names).map { case (info, name) =>
-              Signatures.Param(name.show,
-                               info.widenTermRefExpr.show,
-                               docComment.flatMap(_.paramDoc(name)),
-                               isImplicit = isImplicit(name))
-            }
-          }
-        }
-
+        val paramss = toParamss(tpe)
         val typeParams = denot.info match {
           case poly: PolyType =>
             poly.paramNames.zip(poly.paramInfos).map { case (x, y) => x.show + y.show }
@@ -115,7 +113,7 @@ object Signatures {
         val signature =
           Signatures.Signature(name,
                                typeParams,
-                               infos,
+                               paramss,
                                returnType,
                                docComment.map(_.mainDoc))
 

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

@@ -8,6 +8,24 @@ import dotty.tools.dotc.util.Signatures.{Param => P, Signature => S}
 
 class SignatureHelpTest {
 
+  @Test def javaParam: Unit = {
+    val signature =
+      S("codePointAt", Nil, List(List(P("x$0", "Int"))), Some("Int"))
+    code"""object O {
+             "hello".codePointAt($m1)
+           }""".withSource
+      .signatureHelp(m1, List(signature), Some(0), 0)
+  }
+
+  @Test def scala2Param: Unit = {
+    val signature =
+      S("apply[A]", Nil, List(List(P("xs", "A*"))), Some("List[A]"))
+    code"""object O {
+             List($m1)
+           }""".withSource
+      .signatureHelp(m1, List(signature), Some(0), 0)
+  }
+
   @Test def singleParam: Unit = {
     val signature =
       S("foo", Nil, List(List(P("param0", "Int"))), Some("Int"))