There two rules, one simple and one complex, together allow a my-type This to work.
Simple: In argument position, subclasses must overload the method to provide a child-class-specific variant.
Complex: This-typed returns are marked with their actual return type from the implementation. A subclass for which the actual return type is no longer consistent with the subtype must override the method to provide a consistent return type.
Example:
class Parent[+A](val a: A, val aa: A) {
def arg(me: This[A]): Unit = { println(a) }
def change: This[A] = new Parent[A](aa, a)
def twice: This[A] = change.change
}
class Child[+A <: Seq[Int]](val value: A) extends Parent(value, value)[Seq[A]] {}
// Compile error: method arg not overloaded with subclass Child
// Compile error: method change has incompatible return type in superclass implementation
// Found return type: Parent[A]
// Required return type: Child[A] (as This[A])
class Child(val value: Seq[Int]) extends Parent(value, value)[Seq[Int]] {
def arg(me: Child): Unit = arg(me: Parent[Seq[Int]])
def change: Child = new Child(value.reverse)
// method twice has true This[A] return type, so is okay
}
class Grandchild extends Child(Seq(1, 2, 3)) {}
// Compile error: method arg not overloaded with subclass Grandchild as required by inheritance from Parent
// Compile error: method change has incompatible return type from inheritance from Parent
// Found return type: Child
// Required return type: Grandchild
// Requirement for This return type from definition in Parent
This would let the compiler verify and help with a huge amount of the work of keeping self-types straight.