Improve CannotHaveSameNameAs msg when is defined in self

Author: nicolasstucki

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

@@ -1472,12 +1472,26 @@ object messages {
           |"""
   }
 
-  case class CannotHaveSameNameAs(sym: Symbol, cls: Symbol)(implicit ctx: Context)
+  case class CannotHaveSameNameAs(sym: Symbol, cls: Symbol, reason: CannotHaveSameNameAs.Reason)(implicit ctx: Context)
     extends Message(CannotHaveSameNameAsID) {
-    val msg = hl"""$sym cannot have the same name as ${cls.showLocated} -- class definitions cannot be overridden"""
+    import CannotHaveSameNameAs._
+    def resonMessage: String = reason match {
+      case CannotBeOverridden => "class definitions cannot be overridden"
+      case DefinedInSelf(self) =>
+        s"""cannot define ${sym.showKind} member with the same name as a ${cls.showKind} member in self reference ${self.name}.
+           |(Note: this can be resolved by using another name)
+           |""".stripMargin
+    }
+
+    val msg = hl"""$sym cannot have the same name as ${cls.showLocated} -- """ + resonMessage
     val kind = "Syntax"
     val explanation = ""
   }
+  object CannotHaveSameNameAs {
+    sealed trait Reason
+    case object CannotBeOverridden extends Reason
+    case class DefinedInSelf(self: tpd.ValDef) extends Reason
+  }
 
   case class ValueClassesMayNotDefineInner(valueClass: Symbol, inner: Symbol)(implicit ctx: Context)
     extends Message(ValueClassesMayNotDefineInnerID) {

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

@@ -347,7 +347,7 @@ object Checking {
     checkNoConflict(Abstract, Override)
     if (sym.isType && !sym.is(Deferred))
       for (cls <- sym.allOverriddenSymbols.filter(_.isClass)) {
-        fail(CannotHaveSameNameAs(sym, cls))
+        fail(CannotHaveSameNameAs(sym, cls, CannotHaveSameNameAs.CannotBeOverridden))
         sym.setFlag(Private) // break the overriding relationship by making sym Private
       }
   }

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

@@ -1317,15 +1317,18 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       }
 
     /** Checks if one of the decls is a type with the same name as class type member in selfType */
-    def classExistsOnSelf(decls: Scope, selfType: Type): Boolean = {
+    def classExistsOnSelf(decls: Scope, self: tpd.ValDef): Boolean = {
+      val selfType = self.tpt.tpe
       if (!selfType.exists || (selfType.classSymbol eq cls)) false
       else {
         def memberInSelfButNotThis(decl: Symbol) =
           selfType.member(decl.name).symbol.filter(other => other.isClass && other.owner != cls)
         decls.iterator.filter(_.isType).foldLeft(false) { (foundRedef, decl) =>
           val other = memberInSelfButNotThis(decl)
-          if (other.exists)
-            ctx.error(CannotHaveSameNameAs(decl, other), decl.pos)
+          if (other.exists) {
+            val msg = CannotHaveSameNameAs(decl, other, CannotHaveSameNameAs.DefinedInSelf(self))
+            ctx.error(msg, decl.pos)
+          }
           foundRedef || other.exists
         }
       }
@@ -1336,7 +1339,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     val parentsWithClass = ensureFirstIsClass(parents mapconserve typedParent, cdef.namePos)
     val parents1 = ensureConstrCall(cls, parentsWithClass)(superCtx)
     val self1 = typed(self)(ctx.outer).asInstanceOf[ValDef] // outer context where class members are not visible
-    if (self1.tpt.tpe.isError || classExistsOnSelf(cls.unforcedDecls, self1.tpt.tpe)) {
+    if (self1.tpt.tpe.isError || classExistsOnSelf(cls.unforcedDecls, self1)) {
       // fail fast to avoid typing the body with an error type
       cdef.withType(UnspecifiedErrorType)
     } else {

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

@@ -669,7 +669,7 @@ class ErrorMessagesTests extends ErrorMessagesTest {
       .expect { (ictx, messages) =>
         implicit val ctx: Context = ictx
         assertMessageCount(1, messages)
-        val CannotHaveSameNameAs(symbol, cls) :: Nil = messages
+        val CannotHaveSameNameAs(symbol, cls, _) :: Nil = messages
         assertEquals("class A", symbol.show)
         assertEquals("class A", cls.show)
       }

tests/neg/i2473.scala

@@ -1,7 +1,7 @@
 trait Foo { trait Inner }
 trait Bar { foo: Foo =>
-  type Inner <: foo.Inner // error: type Inner cannot have the same name as trait Inner in trait Foo -- class definitions cannot be overridden
+  type Inner <: foo.Inner // error
 }
 trait Baz { baz: Foo =>
-  class Inner // error: class Inner cannot have the same name as trait Inner in trait Foo -- class definitions cannot be overridden
+  class Inner // error
 }