class M[_]
trait T {
  def foo(m: M[_ >: String]) = 42
}

// class C extends T {
//   def foo(m: M[_ >: Any]) = 0 // gives "same type after erasure error"
// }

object Test {
  def t: T = new T {
    def foo(m: M[_ >: Any]) = 0
  }
  def main(args: Array[String]): Unit = {
    val m: M[String] = null
    t.foo(m) // VeriyError: Duplicate method name&signature
  }
}

import java.util.PrimitiveIterator
import java.util.function.Consumer

class Bar {
  def pi: PrimitiveIterator.OfLong = new PrimitiveIterator.OfLong {
    // Adding override modifier offers: "method forEachRemaining overrides nothing"
    // The compiler should disallow this under the "double definition after erasure" rule.
    def forEachRemaining(c: Consumer[_ >: scala.Long]) { ??? }

    def hasNext: Boolean = false
    def nextLong: Long = ???
  }
}

object Test {
  def main(args: Array[String]): Unit = {
    val consumer: Consumer[java.lang.Long] = null
    new Bar().pi.forEachRemaining(consumer) // IllegalAccessError: Bar$$anon$1.forEachRemaining(Ljava/util/function/Consumer;)V
  }
}

class T {
  def foo(o: Tuple1[String]) = ()
}

class U extends T {
  private def foo(o: Tuple1[Any]) = ()
}
 
object Test {
  def main(args: Array[String]): Unit = {
    new U().foo(null) // IllegalAccessError:  tried to access method U.foo(Lscala/Tuple1;)V from class Test$
  }
}

scala> class C { def foo = 0 }; class D extends C { private def foo[A] = 0 }
defined class C
defined class D

scala> new D().foo
java.lang.IllegalAccessError: tried to access method D.foo()I from class
  ... 33 elided

scala> (new D() : C).foo
res1: Int = 0