Reverting decision what constitutes a double def.

test case t0273. Was positive in Scala 2, is now deemed to be negative.
Two two definitions

    def a = () => ()
    def a[T] = (p:A) => ()

do have matching signatures, so should constitute a double definition.
I previously thought that we can get away if the two definitions have
different result types, but then you immediately have a problem because
the denotations have matching signatures for the pruposes of "&" yet
cannot be merged. Which of the two definitions would override
a definition in a base class is then an arbitrary decision.

Author: odersky

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

@@ -124,7 +124,7 @@ trait Checking extends NoChecking {
     for (decl <- cls.info.decls) {
       for (other <- seen(decl.name)) {
         typr.println(i"conflict? $decl $other")
-        if (decl.signature == other.signature) {
+        if (decl.signature matches other.signature) {
           def doubleDefError(decl: Symbol, other: Symbol): Unit = {
             def ofType = if (decl.isType) "" else i": ${other.info}"
             def explanation =

test/dotc/tests.scala

@@ -53,15 +53,16 @@ class tests extends CompilerTest {
   @Test def neg_typedapply() = compileFile(negDir, "typedapply", xerrors = 4)
   @Test def neg_typedidents() = compileFile(negDir, "typedIdents", xerrors = 2)
   @Test def neg_assignments() = compileFile(negDir, "assignments", xerrors = 3)
-  @Test def neg_typers() = compileFile(negDir, "typers", xerrors = 6)
+  @Test def neg_typers() = compileFile(negDir, "typers", xerrors = 10)
   @Test def neg_privates() = compileFile(negDir, "privates", xerrors = 2)
   @Test def neg_rootImports = compileFile(negDir, "rootImplicits", xerrors = 2)
   @Test def neg_templateParents() = compileFile(negDir, "templateParents", xerrors = 3)
-  @Test def neg_i39 = compileFile(negDir, "i39", xerrors = 1)
-  @Test def neg_i50_volatile = compileFile(negDir, "i50-volatile", xerrors = 4)
-  @Test def neg_companions = compileFile(negDir, "companions", xerrors = 1)
   @Test def neg_autoTupling = compileFile(posDir, "autoTuplingTest", "-language:noAutoTupling" :: Nil, xerrors = 3)
   @Test def neg_autoTupling2 = compileFile(negDir, "autoTuplingTest", xerrors = 3)
+  @Test def neg_companions = compileFile(negDir, "companions", xerrors = 1)
+  @Test def neg_i39 = compileFile(negDir, "i39", xerrors = 1)
+  @Test def neg_i50_volatile = compileFile(negDir, "i50-volatile", xerrors = 4)
+  @Test def neg_t0273_doubledefs = compileFile(negDir, "t0273", xerrors = 1)
   @Test def neg_t0654_polyalias = compileFile(negDir, "t0654", xerrors = 2)
   @Test def neg_t1192_legalPrefix = compileFile(negDir, "t1192", xerrors = 1)
 

tests/pos/t0273.scala renamed to tests/neg/t0273.scala

@@ -2,23 +2,23 @@ object overloaded {
 
   def f(x: String): String = x
   def f[T >: Null](x: T): Int = 1
-  
+
   val x1 = f("abc")
   val x2 = f(new Integer(1))
   val x3 = f(null)
-  
+
   val x4: String => String = f
   val x5: String => Any = f
   val x6: Any = f _
-  
+
   def g(): Int = 1
   def g(x: Int): Int = 2
-  
+
   val y1: Int => Int = g
-  val y2: Any = g _ 
-  
+  val y2: Any = g _
+
   println(g)
-  
+
   val xs = List("a", "b")
   xs.mkString
 }