Also hide implicit parameter lists made of DummyImplicit

This is more legitimate than hiding CanBuildFrom since there's never any
reason to pass a DummyImplicit instance explicitly, and DummyImplicit is
used in the 2.13 standard library to avoid erased signature clashes
between overloads.

Author: smarter

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -355,12 +355,18 @@ class Definitions {
     lazy val Predef_undefinedR: TermRef = ScalaPredefModule.requiredMethodRef(nme.???)
     def Predef_undefined(implicit ctx: Context): Symbol = Predef_undefinedR.symbol
 
-  def SubTypeClass(implicit ctx: Context): Symbol =
+  def SubTypeClass(implicit ctx: Context): ClassSymbol =
     if (isNewCollections)
       ctx.requiredClass("scala.<:<")
     else
       ScalaPredefModule.requiredClass("<:<")
 
+  def DummyImplicitClass(implicit ctx: Context): ClassSymbol =
+    if (isNewCollections)
+      ctx.requiredClass("scala.DummyImplicit")
+    else
+      ScalaPredefModule.requiredClass("DummyImplicit")
+
   lazy val ScalaRuntimeModuleRef: TermRef = ctx.requiredModuleRef("scala.runtime.ScalaRunTime")
   def ScalaRuntimeModule(implicit ctx: Context): Symbol = ScalaRuntimeModuleRef.symbol
   def ScalaRuntimeClass(implicit ctx: Context): ClassSymbol = ScalaRuntimeModule.moduleClass.asClass

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

@@ -84,11 +84,13 @@ object Signatures {
     def toParamss(tp: MethodType)(implicit ctx: Context): List[List[Param]] = {
       val rest = tp.resType match {
         case res: MethodType =>
-          // HACK: Hide parameter lists consisting only of CanBuildFrom,
-          // remove this once we switch to the 2.13 standard library.
+          // Hide parameter lists consisting only of CanBuildFrom or DummyImplicit,
+          // we can remove the CanBuildFrom special-case once we switch to the 2.13 standard library.
           if (res.resultType.isParameterless &&
               res.isImplicitMethod &&
-              res.paramInfos.forall(_.classSymbol.fullName.toString == "scala.collection.generic.CanBuildFrom"))
+              res.paramInfos.forall(info =>
+                info.classSymbol.fullName.toString == "scala.collection.generic.CanBuildFrom" ||
+                info.classSymbol.derivesFrom(ctx.definitions.DummyImplicitClass)))
             Nil
           else
             toParamss(res)

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

@@ -30,6 +30,34 @@ class SignatureHelpTest {
       .signatureHelp(m2, List(mapSig), Some(0), 0)
   }
 
+  /** Implicit parameter lists consisting solely of DummyImplicits are hidden. */
+  @Test def hiddenDummyParams: Unit = {
+    val foo1Sig =
+      S("foo1", Nil, List(List(P("param0", "Int"))), Some("Int"))
+    val foo2Sig =
+      S("foo2", Nil, List(List(P("param0", "Int"))), Some("Int"))
+    val foo3Sig =
+      S("foo3", Nil, List(List(P("param0", "Int")),
+        List(P("dummy", "DummyImplicit"))), Some("Int"))
+    val foo4Sig =
+      S("foo4", Nil, List(List(P("param0", "Int")),
+        List(P("x", "Int", isImplicit = true), P("dummy", "DummyImplicit", isImplicit = true))), Some("Int"))
+    code"""object O {
+             def foo1(param0: Int)(implicit dummy: DummyImplicit): Int = ???
+             def foo2(param0: Int)(implicit dummy1: DummyImplicit, dummy2: DummyImplicit): Int = ???
+             def foo3(param0: Int)(dummy: DummyImplicit): Int = ???
+             def foo4(param0: Int)(implicit x: Int, dummy: DummyImplicit): Int = ???
+             foo1($m1)
+             foo2($m2)
+             foo3($m3)
+             foo4($m4)
+           }""".withSource
+      .signatureHelp(m1, List(foo1Sig), Some(0), 0)
+      .signatureHelp(m2, List(foo2Sig), Some(0), 0)
+      .signatureHelp(m3, List(foo3Sig), Some(0), 0)
+      .signatureHelp(m4, List(foo4Sig), Some(0), 0)
+  }
+
   @Test def singleParam: Unit = {
     val signature =
       S("foo", Nil, List(List(P("param0", "Int"))), Some("Int"))