Domain checking for named type parameters

Now verifies that the named type parameters of an overriding
type or class are the same as the named type parameters of
an overridden type.

Author: odersky

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

@@ -246,6 +246,8 @@ object RefChecks {
           isDefaultGetter(member.name) || // default getters are not checked for compatibility
           memberTp.overrides(otherTp)
 
+      def domain(sym: Symbol): Set[Name] = sym.info.namedTypeParams.map(_.name)
+
       //Console.println(infoString(member) + " overrides " + infoString(other) + " in " + clazz);//DEBUG
 
       // return if we already checked this combination elsewhere
@@ -342,6 +344,9 @@ object RefChecks {
         overrideError("cannot be used here - only term macros can override term macros")
       } else if (!compatibleTypes) {
         overrideError("has incompatible type" + err.whyNoMatchStr(memberTp, otherTp))
+      } else if (member.isType && domain(member) != domain(other)) {
+        overrideError("has different named type parameters: "+
+             i"[${domain(member).toList}%, %] instead of [${domain(other).toList}%, %]")
       } else {
         checkOverrideDeprecated()
       }

tests/neg/named-params.scala

@@ -32,3 +32,6 @@ object Test {
   val z5 = d2[Elem = Int][Value = String](1) //error // error
 
 }
+
+
+

tests/pos/CollectionStrawMan3.scala

@@ -114,13 +114,13 @@ object CollectionStrawMan1 {
   /* --------- Concrete collection types ------------------------------- */
 
   /** Concrete collection type: List */
-  sealed trait List[+A] extends Seq[A] with FromIterator[List] {
+  sealed trait List[type +Elem] extends Seq[Elem] with FromIterator[List] {
     def isEmpty: Boolean
-    def head: A
-    def tail: List[A]
-    def iterator = new ListIterator[A](this)
+    def head: Elem
+    def tail: List[Elem]
+    def iterator = new ListIterator[Elem](this)
     def fromIterator[B](it: Iterator[B]): List[B] = List.fromIterator(it)
-    def apply(i: Int): A = {
+    def apply(i: Int): Elem = {
       require(!isEmpty)
       if (i == 0) head else tail.apply(i - 1)
     }
@@ -155,17 +155,17 @@ object CollectionStrawMan1 {
   }
 
   /** Concrete collection type: ArrayBuffer */
-  class ArrayBuffer[A] private (initElems: Array[AnyRef], initLength: Int) extends Seq[A] with FromIterator[ArrayBuffer] {
+  class ArrayBuffer[type Elem] private (initElems: Array[AnyRef], initLength: Int) extends Seq[Elem] with FromIterator[ArrayBuffer] {
     def this() = this(new Array[AnyRef](16), 0)
     private var elems: Array[AnyRef] = initElems
     private var start = 0
     private var limit = initLength
-    def apply(i: Int) = elems(start + i).asInstanceOf[A]
+    def apply(i: Int) = elems(start + i).asInstanceOf[Elem]
     def length = limit - start
-    def iterator = new ArrayBufferIterator[A](elems, start, length)
+    def iterator = new ArrayBufferIterator[Elem](elems, start, length)
     def fromIterator[B](it: Iterator[B]): ArrayBuffer[B] =
       ArrayBuffer.fromIterator(it)
-    def +=(elem: A): this.type = {
+    def +=(elem: Elem): this.type = {
       if (limit == elems.length) {
         if (start > 0) {
           Array.copy(elems, start, elems, 0, length)
@@ -213,7 +213,7 @@ object CollectionStrawMan1 {
   }
 
   /** Concrete collection type: View */
-  class View[+A](it: => Iterator[A]) extends CanIterate[A] {
+  class View[type +Elem](it: => Iterator[Elem]) extends CanIterate[Elem] {
     def iterator = it
   }