Lint dubious overload differs only in implicit

som-snytt · som-snytt · commit fc4e29e9fda6 · 2025-03-30T17:53:18.000-07:00
diff --git a/src/compiler/scala/tools/nsc/Reporting.scala b/src/compiler/scala/tools/nsc/Reporting.scala
@@ -661,6 +661,7 @@ object Reporting {
         LintIntDivToFloat,
         LintUniversalMethods,
         LintCloneable,
+        LintOverload,
         LintNumericMethods
       = lint()
 
diff --git a/src/compiler/scala/tools/nsc/settings/Warnings.scala b/src/compiler/scala/tools/nsc/settings/Warnings.scala
@@ -229,6 +229,7 @@ trait Warnings {
     val IntDivToFloat          = LintWarning("int-div-to-float",          "Warn when an integer division is converted (widened) to floating point: `(someInt / 2): Double`.")
     val PatternShadow          = LintWarning("pattern-shadow",            "Pattern variable id is also a term in scope.")
     val CloneableObject        = LintWarning("cloneable",                 "Modules (objects) should not be Cloneable.")
+    val DubiousOverload        = LintWarning("overload",                  "Overload differs only in an implicit parameter.")
 
     def allLintWarnings = values.toSeq.asInstanceOf[Seq[LintWarning]]
   }
@@ -267,6 +268,7 @@ trait Warnings {
   def lintIntDivToFloat          = lint.contains(IntDivToFloat)
   def warnPatternShadow          = lint.contains(PatternShadow)
   def warnCloneableObject        = lint.contains(CloneableObject)
+  def warnDubiousOverload        = lint.contains(DubiousOverload)
 
   // The Xlint warning group.
   val lint = MultiChoiceSetting(
diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
@@ -144,6 +144,20 @@ abstract class RefChecks extends Transform {
           }
         }
       }
+      if (settings.warnDubiousOverload) {
+        val members = clazz.info.members
+        val implicitMembers = members.filter(_.tpe match { case mt: MethodType => mt.isImplicit case _ => false })
+        implicitMembers.foreach { sym =>
+          val alts = clazz.info.decl(sym.name).filter(_.paramss.isEmpty).alternatives
+          alts.foreach { alt =>
+            val usage = if (alt.isMethod && !alt.isGetter) "Calls to parameterless" else "Usages of"
+            val impl = sym.defString
+            refchecksWarning(alt.pos,
+              s"$usage $alt will be easy to mistake for calls to $impl, which has a single implicit parameter list.",
+              WarningCategory.LintOverload)
+          }
+        }
+      }
 
       // Check for doomed attempt to overload applyDynamic
       if (clazz.isSubClass(DynamicClass))
diff --git a/test/files/neg/t7415.check b/test/files/neg/t7415.check
@@ -0,0 +1,12 @@
+t7415.scala:10: warning: Calls to parameterless method foo will be easy to mistake for calls to def foo(implicit a: T): Int, which has a single implicit parameter list.
+  def foo = 0
+      ^
+t7415.scala:14: warning: Usages of value foo will be easy to mistake for calls to def foo(implicit a: T): Int, which has a single implicit parameter list.
+  val foo = 0
+      ^
+t7415.scala:18: warning: Usages of value foo will be easy to mistake for calls to def foo(implicit a: T): Int, which has a single implicit parameter list.
+  private[this] val foo = 42
+                    ^
+error: No warnings can be incurred under -Werror.
+3 warnings
+1 error
diff --git a/test/files/neg/t7415.scala b/test/files/neg/t7415.scala
@@ -0,0 +1,19 @@
+//> using options -Werror -Xlint:overload
+
+trait T
+
+trait Base {
+  def foo(implicit a: T) = 0
+}
+
+trait Derived1 extends Base {
+  def foo = 0
+}
+
+trait Derived2 extends Base {
+  val foo = 0
+}
+
+class C extends Base {
+  private[this] val foo = 42
+}
