Fix scala#1750: Handle illegal class overrides better

Illegal class overrides are fundamentally at odds with the way dotty
represents types and therefore can cause lots of low-level problems.

Two measures in this commit

First, we detect direct illegal class overrides on completion instead of
during RefChecks. Break the override by making the previously
overriding type private.

This fixes i1750.scala, but still fails for indirect overrides between
two unrelated outer traits/classes that are inherited by the same class or trait.
We fix this by catching the previously thrown ClassCastException.
Test case for indirect overrides is in i1750a.scala.

Author: odersky

compiler/src/dotty/tools/dotc/transform/OverridingPairs.scala

@@ -6,6 +6,7 @@ import Flags._, Symbols._, Contexts._, Types._, Scopes._, Decorators._
 import util.HashSet
 import collection.mutable
 import collection.immutable.BitSet
+import typer.ErrorReporting.cyclicErrorMsg
 import scala.annotation.tailrec
 
 /** A module that can produce a kind of iterator (`Cursor`),
@@ -122,10 +123,18 @@ object OverridingPairs {
       if (nextEntry ne null) {
         nextEntry = decls.lookupNextEntry(nextEntry)
         if (nextEntry ne null) {
-          overridden = nextEntry.sym
-          if (overriding.owner != overridden.owner && matches(overriding, overridden)) {
-            visited += overridden
-            if (!hasCommonParentAsSubclass(overriding.owner, overridden.owner)) return
+          try {
+            overridden = nextEntry.sym
+            if (overriding.owner != overridden.owner && matches(overriding, overridden)) {
+              visited += overridden
+              if (!hasCommonParentAsSubclass(overriding.owner, overridden.owner)) return
+            }
+          }
+          catch {
+            case ex: CyclicReference =>
+              // See neg/i1750a for an example where a cyclic error can arise.
+              // The root cause in this example is an illegal "override" of an inner trait
+              ctx.error(cyclicErrorMsg(ex), base.pos)
           }
         } else {
           curEntry = curEntry.prev

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

@@ -338,6 +338,11 @@ object Checking {
     checkNoConflict(Final, Sealed)
     checkNoConflict(Private, Protected)
     checkNoConflict(Abstract, Override)
+    if (sym.isType && !sym.is(Deferred))
+      for (cls <- sym.allOverriddenSymbols.filter(_.isClass)) {
+        fail(i"$sym cannot have the same name as ${cls.showLocated} -- class definitions cannot be overridden")
+        sym.setFlag(Private) // break the overriding relationship by making sym Private
+      }
   }
 
   /** Check the type signature of the symbol `M` defined by `tree` does not refer

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

@@ -289,6 +289,8 @@ object RefChecks {
       if (!isOverrideAccessOK) {
         overrideAccessError()
       } else if (other.isClass) {
+        // direct overrides were already checked on completion (see Checking.chckWellFormed)
+        // the test here catches indirect overriddes between two inherited base types.
         overrideError("cannot be used here - class definitions cannot be overridden")
       } else if (!other.is(Deferred) && member.isClass) {
         overrideError("cannot be used here - classes can only override abstract types")

tests/neg/customArgs/overrideClass.scala

@@ -8,8 +8,7 @@
   }
   trait FooB extends FooA {
     type A <: Ax;
-    trait Ax extends super.Ax { def xxx : Int; } // error: cyclic inheritance: trait Ax extends itself
-                                                 // (Note that inheriting a class of the same name is no longer allowed)
+    trait Ax extends super.Ax { def xxx : Int; } // error: cyclic inheritance: trait Ax extends itself) // error: class definitions cannot be overridden
     abstract class InnerB extends InnerA {
       // type B <: A;
       val a : A = doB;

tests/neg/i1750.scala

@@ -0,0 +1,12 @@
+trait Lang1 {
+  trait Exp
+  trait Visitor { def f(left: Exp): Unit }
+  class Eval1 extends Visitor { self =>
+    def f(left: Exp) = ()
+  }
+}
+trait Lang2 extends Lang1 {
+  class Visitor extends Eval1 { Visitor => // error: classes cannot be overridden
+  }
+}
+

tests/neg/i1750a.scala

@@ -0,0 +1,13 @@
+trait Lang1 {
+  trait Exp
+  trait Visitor { def f(left: Exp): Unit }
+  class Eval1 extends Visitor { self =>
+    def f(left: Exp) = ()
+  }
+}
+trait Lang3 { self: Lang1 =>
+  class Visitor extends Eval1 { Visitor => // error: classes cannot be overridden
+  }
+}
+trait Lang4 extends Lang1 with Lang3
+

tests/neg/i1806.scala

@@ -2,6 +2,6 @@ trait A {
   class Inner
  }
 trait B extends A {
-  class Inner extends super.Inner // error
+  class Inner extends super.Inner // error // error
 }