Add error message for companion and class/module name clash

compiler/src/dotty/tools/dotc/reporting/diagnostic/ErrorMessageID.java

@@ -103,6 +103,7 @@ public enum ErrorMessageID {
     ExtendFinalClassID,
     EnumCaseDefinitionInNonEnumOwnerID,
     ExpectedTypeBoundOrEqualsID,
+    ClassAndCompanionNameClashID,
     ;
 
     public int errorNumber() {

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

@@ -1804,4 +1804,17 @@ object messages {
            |refers to a subtype of type ${"A"}.
            |"""
   }
+
+  case class ClassAndCompanionNameClash(cls: Symbol, other: Symbol)(implicit ctx: Context)
+    extends Message(ClassAndCompanionNameClashID) {
+    val kind = "Naming"
+    val msg = hl"Name clash: both ${cls.owner} and its companion object defines ${cls.name}"
+    val explanation = {
+      val kind = if (cls.owner.is(Flags.Trait)) "trait" else "class"
+
+      hl"""|A $kind and its companion object cannot both define a ${"class"}, ${"trait"} or ${"object"} with the same name:
+           |  - ${cls.owner} defines ${cls}
+           |  - ${other.owner} defines ${other}"""
+      }
+  }
 }

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

@@ -113,11 +113,9 @@ object RefChecks {
    */
   private def checkCompanionNameClashes(cls: Symbol)(implicit ctx: Context): Unit =
     if (!(cls.owner is ModuleClass)) {
-      val other = cls.owner.linkedClass.info.decl(cls.name)
-      if (other.symbol.isClass)
-        ctx.error(s"name clash: ${cls.owner} defines $cls" + "\n" +
-          s"and its companion ${cls.owner.companionModule} also defines $other",
-          cls.pos)
+      val other = cls.owner.linkedClass.info.decl(cls.name).symbol
+      if (other.isClass)
+        ctx.error(ClassAndCompanionNameClash(cls, other), cls.pos)
     }
 
   // Override checking ------------------------------------------------------------

compiler/test/dotty/tools/dotc/reporting/ErrorMessagesTests.scala

@@ -1038,4 +1038,27 @@ class ErrorMessagesTests extends ErrorMessagesTest {
         val ExpectedTypeBoundOrEquals(found) :: Nil = messages
         assertEquals(Tokens.IDENTIFIER, found)
       }
+
+  @Test def classAndCompanionNameClash =
+    checkMessagesAfter("refchecks") {
+      """
+        |class T {
+        |  class G
+        |}
+        |object T {
+        |  trait G
+        |}
+      """.stripMargin
+    }.expect { (ictx, messages) =>
+      implicit val ctx: Context = ictx
+
+      assertMessageCount(1, messages)
+      val ClassAndCompanionNameClash(cls, other) :: Nil = messages
+
+      assertEquals("class T", cls.owner.show)
+      assertEquals("class G", cls.show)
+      assertEquals("object T", other.owner.show)
+      assertEquals("trait G", other.show)
+
+    }
 }