Add missing double definition checks

In 668a637, `Denotation#matches` was
refined to not return true for types that cannot override each other
from Scala's point of view, however this method was also used to detect
methods that override each other from the JVM point of view, i.e.
methods which will end up with the same signature in bytecode. This
commit refines `checkNoDoubleDeclaration` to also explicitly check for
clashing signatures.

Author: smarter

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

@@ -82,6 +82,10 @@ case class Signature(paramsSig: List[TypeName], resSig: TypeName) {
       else NoMatch
     else NoMatch
 
+  /** Does this signature potentially clash with `that` ? */
+  def clashes(that: Signature)(implicit ctx: Context): Boolean =
+    matchDegree(that) == FullMatch
+
   /** name.toString == "" or name.toString == "_" */
   private def isWildcard(name: TypeName) = name.isEmpty || name == tpnme.WILDCARD
 

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -752,7 +752,7 @@ trait Checking {
         def javaFieldMethodPair =
           decl.is(JavaDefined) && other.is(JavaDefined) &&
           decl.is(Method) != other.is(Method)
-        if (decl.matches(other) && !javaFieldMethodPair) {
+        if ((decl.signature.clashes(other.signature) || decl.matches(other)) && !javaFieldMethodPair) {
           def doubleDefError(decl: Symbol, other: Symbol): Unit =
             if (!decl.info.isErroneous && !other.info.isErroneous)
               ctx.error(DoubleDefinition(decl, other, cls), decl.sourcePos)

tests/neg/doubleDefinition.check

@@ -1,3 +1,13 @@
+<2471..2471> in doubleDefinition.scala
+Double definition:
+def foo: [T <: Int](x: T): T in class Test20 at line 143 and
+def foo: [S <: Int, T <: Int](x: S): T in class Test20 at line 144
+have the same type after erasure.
+<2338..2338> in doubleDefinition.scala
+Double definition:
+def foo: [T <: Int](x: T): T in class Test19 at line 137 and
+def foo(x: Int): Int in class Test19 at line 138
+have the same type after erasure.
 <2016..2016> in doubleDefinition.scala
 Double definition:
 var foo: Int in class Test16 at line 115 and

tests/neg/doubleDefinition.scala

@@ -131,3 +131,15 @@ class Test18 {
 	def foo(a: A) = 1
 	def foo(b: B) = 1
 }
+
+// Error when overloading polymorphic and non-polymorphic methods
+class Test19 {
+  def foo[T <: Int](x: T): T = x
+  def foo(x: Int): Int = x // error
+}
+
+// Error when overloading polymorphic methods
+class Test20 {
+  def foo[T <: Int](x: T): T = x
+  def foo[S <: Int, T <: Int](x: S): T = ??? // error
+}