Fix #2473: Check self for inner class redefinitions

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 reasonMessage: 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} -- """ + reasonMessage
     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

@@ -1316,12 +1316,30 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         result
       }
 
+    /** Checks if one of the decls is a type with the same name as class type member in selfType */
+    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) {
+            val msg = CannotHaveSameNameAs(decl, other, CannotHaveSameNameAs.DefinedInSelf(self))
+            ctx.error(msg, decl.pos)
+          }
+          foundRedef || other.exists
+        }
+      }
+    }
+
     completeAnnotations(cdef, cls)
     val constr1 = typed(constr).asInstanceOf[DefDef]
     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) {
+    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

@@ -0,0 +1,7 @@
+trait Foo { trait Inner }
+trait Bar { foo: Foo =>
+  type Inner <: foo.Inner // error
+}
+trait Baz { baz: Foo =>
+  class Inner // error
+}