Fix baseClasses computation of AndTypes

List union is clearly wrong, as it is simply the same as ++.

Author: odersky

compiler/src/dotty/tools/dotc/core/SymDenotations.scala

@@ -1407,32 +1407,13 @@ object SymDenotations {
       baseData._2
 
     def computeBaseData(implicit onBehalf: BaseData, ctx: Context): (List[ClassSymbol], BaseClassSet) = {
-      val seen = new BaseClassSetBuilder
-      def addBaseClasses(bcs: List[ClassSymbol], to: List[ClassSymbol])
-          : List[ClassSymbol] = bcs match {
-        case bc :: bcs1 =>
-          val bcs1added = addBaseClasses(bcs1, to)
-          if (seen contains bc) bcs1added
-          else {
-            seen.add(bc)
-            bc :: bcs1added
-          }
-        case nil =>
-          to
-      }
-      def addParentBaseClasses(ps: List[TypeRef], to: List[ClassSymbol]): List[ClassSymbol] = ps match {
-        case p :: ps1 =>
-          addParentBaseClasses(ps1,
-              addBaseClasses(p.symbol.asClass.baseClasses, to))
-        case nil =>
-          to
-      }
       def emptyParentsExpected =
         is(Package) || (symbol == defn.AnyClass) || ctx.erasedTypes && (symbol == defn.ObjectClass)
       if (classParents.isEmpty && !emptyParentsExpected)
         onBehalf.signalProvisional()
-      (classSymbol :: addParentBaseClasses(classParents, Nil),
-       seen.result)
+      val builder = new BaseDataBuilder
+      for (p <- classParents) builder.addAll(p.symbol.asClass.baseClasses)
+      (classSymbol :: builder.baseClasses, builder.baseClassSet)
     }
 
     final override def derivesFrom(base: Symbol)(implicit ctx: Context): Boolean =
@@ -2096,7 +2077,9 @@ object SymDenotations {
     def contains(sym: Symbol): Boolean = contains(sym, classIds.length)
   }
 
-  private class BaseClassSetBuilder {
+  /** A class to combine base data from parent types */
+  class BaseDataBuilder {
+    private var classes: List[ClassSymbol] = Nil
     private var classIds = new Array[Int](32)
     private var length = 0
 
@@ -2106,19 +2089,34 @@ object SymDenotations {
       classIds = classIds1
     }
 
-    def contains(sym: Symbol): Boolean =
+    private def contains(sym: Symbol): Boolean =
       new BaseClassSet(classIds).contains(sym, length)
 
-    def add(sym: Symbol): Unit = {
+    private def add(sym: Symbol): Unit = {
       if (length == classIds.length) resize(length * 2)
       classIds(length) = sym.id
       length += 1
     }
 
-    def result = {
+    def addAll(bcs: List[ClassSymbol]): this.type = {
+      bcs match {
+        case bc :: bcs1 =>
+          addAll(bcs1)
+          if (!contains(bc)) {
+            add(bc)
+            classes = bc :: classes
+          }
+        case nil =>
+      }
+      this
+    }
+
+    def baseClassSet = {
       if (length != classIds.length) resize(length)
       new BaseClassSet(classIds)
     }
+
+    def baseClasses: List[ClassSymbol] = classes
   }
 
   @sharable private var indent = 0 // for completions printing

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -394,7 +394,10 @@ object Types {
         case tp: ClassInfo =>
           tp.cls.baseClasses
         case AndType(tp1, tp2) =>
-          tp1.baseClasses union tp2.baseClasses
+          (new BaseDataBuilder)
+            .addAll(tp1.baseClasses)
+            .addAll(tp2.baseClasses)
+            .baseClasses
         case OrType(tp1, tp2) =>
           tp1.baseClasses intersect tp2.baseClasses
         case _ => Nil