Port validateBaseTypes from Scala 2

Author: b-studios

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

@@ -782,34 +782,53 @@ object RefChecks {
         report.error(problem(), clazz.srcPos)
       }
 
-      // check that basetype and subtype agree on types of trait parameters
+      // Checks base types of the current clazz against each other
       //
-      // I.e. trait and class parameters not only need to conform to the expected
-      // type of the corresponding base-trait, but also to the type as seen by the
-      // inheriting subtype.
-      def checkTraitParametersOK() = for {
-        parent <- clazz.info.parents
-        parentSym = parent.classSymbol
-        if parentSym.isClass
-        cls = parentSym.asClass
-        if cls.paramAccessors.nonEmpty
-        param <- cls.paramAccessors
-      } {
-        val tpeFromParent = parent.memberInfo(param)
-        val tpeFromClazz = clazz.thisType.memberInfo(param)
-        if (!(tpeFromParent <:< tpeFromClazz)) {
-          val msg =
-            em"""illegal parameter: The types of $param do not match.
-                |
-                |  $param in $cls has type: $tpeFromParent
-                |  but $clazz expects $param to have type: $tpeFromClazz"""
-
-          report.error(msg, clazz.srcPos)
+      // In particular, it checks that there are no two base classes with
+      // different type instantiations.
+      //
+      // ported from Scala 2:
+      //   https://github.com/scala/scala/blob/9bb659e62a9239c01aec14c171f8598bb1a576fe/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala#L834-L883
+      def validateBaseTypes(): Unit = {
+        val tpe = clazz.thisType // in Scala 2 this was clazz.tpe
+        val seenParents = mutable.HashSet[Type]()
+        val baseClasses: List[ClassSymbol] = clazz.info.baseClasses
+
+        // tracks types that we have seen for a particular base class in baseClasses
+        val seenTypes = mutable.Map.empty[Symbol, List[Type]]
+
+        // validate all base types of a class in reverse linear order.
+        def register(tp: Type): Unit = {
+          val baseClass = tp.typeSymbol
+          if (baseClasses contains baseClass) {
+            val alreadySeen = seenTypes.getOrElse(baseClass, Nil)
+            if (alreadySeen.forall { tp1 => !(tp1 <:< tp) })
+              seenTypes.update(baseClass, tp :: alreadySeen.filter { tp1 => !(tp <:< tp1) })
+          }
+          val remaining = tp.parents filterNot seenParents
+          seenParents ++= remaining
+          remaining foreach register
+        }
+        register(tpe)
+
+        seenTypes.foreach {
+          case (cls, Nil) =>
+            assert(false) // this case should not be reachable
+          case (cls, _ :: Nil) =>
+            () // Ok
+          case (cls, tp1 :: tp2 :: _) =>
+            val msg =
+              em"""illegal inheritance;
+                  |
+                  |  $clazz inherits different type instances of $cls:
+                  |  $tp1 and $tp2"""
+
+            report.error(msg, clazz.srcPos)
         }
       }
 
       checkParameterizedTraitsOK()
-      checkTraitParametersOK()
+      validateBaseTypes()
     }
 
     /** Check that `site` does not inherit conflicting generic instances of `baseCls`,

tests/neg/i3989f.scala

@@ -3,7 +3,7 @@ object Test extends App {
   class B[+X](val y: X) extends A[X](y)
   class C extends B(5) with A[String] // error: illegal inheritance
 
-  class D extends B(5) with A[Any] // error: illegal parameter
+  class D extends B(5) with A[Any] // ok
 
   def f(a: A[Int]): String = a match {
     case c: C => c.x