don't show error about signatures when a var/val and a def are clashing

Author: Jendrik Wenke

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -2083,11 +2083,14 @@ object messages {
   case class DoubleDeclaration(decl: Symbol, previousSymbol: Symbol)(implicit ctx: Context) extends Message(DoubleDeclarationID) {
     val kind = "Duplicate Symbol"
     val msg = {
-      val details = decl.asTerm.signature.matchDegree(previousSymbol.asTerm.signature) match {
-        case Signature.NoMatch => "" // matchDegree also returns NoMatch if one of the terms is not a method
-        case Signature.ParamMatch => "\nOverloads with equal parameter types but different return types are not allowed."
-        case Signature.FullMatch => "\nThe definitions have the same signature after erasure."
-      }
+      val details = if (decl.isRealMethod && previousSymbol.isRealMethod) {
+        // compare the signatures when both symbols represent methods
+        decl.asTerm.signature.matchDegree(previousSymbol.asTerm.signature) match {
+          case Signature.NoMatch => ""
+          case Signature.ParamMatch => "\nOverloads with equal parameter types but different return types are not allowed."
+          case Signature.FullMatch => "\nThe definitions have the same signature after erasure."
+        }
+      } else ""
       hl"${decl.showLocated} is already defined as ${previousSymbol.showDcl} in line ${previousSymbol.pos.line + 1}." + details
     }
     val explanation = ""

tests/neg/doubleDefinition.scala

@@ -1,22 +1,126 @@
 trait A
 trait B
 
+// test with classes
+
 class Test1 {
 	def foo(x: List[A]): Function1[A, A] = ???
 	def foo(x: List[B]): Function2[B, B, B] = ???
 	// ok, different jvm signature
 }
 
-
 class Test2 {
 	def foo(x: List[A]): Function1[A, A] = ???
 	def foo(x: List[B]): Function1[B, B] = ??? // error: same jvm signature
 	// scalac calls this "have same type after erasure"
 }
 
-
 class Test3 {
 	// overload with same argument type, but different return types
 	def foo(x: List[A]): Function1[A, A] = ???
 	def foo(x: List[A]): Function2[B, B, B] = ??? // error
 }
+
+class Test4 {
+	val foo = 1
+	def foo = 2 // error
+}
+
+class Test4b {
+	def foo = 2
+	val foo = 1 // error
+}
+
+class Test4c {
+	def foo = 2
+	var foo = 1 // error
+}
+
+class Test4d {
+	var foo = 1
+	def foo = 2 // error
+}
+
+
+// test with traits
+
+trait Test5 {
+	def foo(x: List[A]): Function1[A, A] = ???
+	def foo(x: List[B]): Function2[B, B, B] = ???
+	// ok, different jvm signature
+}
+
+trait Test6 {
+	def foo(x: List[A]): Function1[A, A] = ???
+	def foo(x: List[B]): Function1[B, B] = ??? // error: same jvm signature
+	// scalac calls this "have same type after erasure"
+}
+
+trait Test7 {
+	// overload with same argument type, but different return types
+	def foo(x: List[A]): Function1[A, A] = ???
+	def foo(x: List[A]): Function2[B, B, B] = ??? // error
+}
+
+class Test8 {
+	val foo = 1
+	def foo = 2 // error
+}
+
+class Test8b {
+	def foo = 2
+	val foo = 1 // error
+}
+
+class Test8c {
+	def foo = 2
+	var foo = 1 // error
+}
+
+class Test8d {
+	var foo = 1
+	def foo = 2 // error
+}
+
+// test method and contructor argument clashing
+
+class Test9(val foo: Int) {
+	def foo: String // error
+}
+
+class Test10(val foo: Int) {
+	def foo: Int // error
+}
+
+abstract class Test11(val foo: Int) {
+	def foo: String // error
+}
+
+abstract class Test12(val foo: Int) {
+	def foo: Int // error
+}
+
+class Test13(var foo: Int) {
+	def foo: String // error
+}
+
+class Test14(var foo: Int) {
+	def foo: Int // error
+}
+
+abstract class Test15(var foo: Int) {
+	def foo: String // error
+}
+
+abstract class Test16(var foo: Int) {
+	def foo: Int // error
+}
+
+// don't error when shadowing
+
+class Test17 {
+	val foo = 1
+	def bar() = {
+		val foo = ""
+	}
+}