Adapt superclass inference to new scheme

It could now be that a superclass type is an AndType of two class types.
This case needs to be rejected and healed. Test case is templateParents.scala,
which crashed without the fix in this commit.

Author: odersky

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

@@ -580,12 +580,15 @@ trait Checking {
     case _ =>
   }
 
-  /** Check that any top-level type arguments in this type are feasible, i.e. that
-   *  their lower bound conforms to their upper bound. If a type argument is
-   *  infeasible, issue and error and continue with upper bound.
+  /** Check that `tp` is a class type and that any top-level type arguments in this type
+   *  are feasible, i.e. that their lower bound conforms to their upper bound. If a type
+   *  argument is infeasible, issue and error and continue with upper bound.
    */
-  def checkFeasible(tp: Type, pos: Position, where: => String = "")(implicit ctx: Context): Type =
+  def checkFeasibleParent(tp: Type, pos: Position, where: => String = "")(implicit ctx: Context): Type =
     tp match {
+      case tp @ AndType(tp1, tp2) =>
+        ctx.error(s"conflicting type arguments$where", pos)
+        tp1
       case tp @ AppliedType(tycon, args) =>
         def checkArg(arg: Type) = arg match {
           case tp @ TypeBounds(lo, hi) if !(lo <:< hi) =>
@@ -595,7 +598,7 @@ trait Checking {
         }
         tp.derivedAppliedType(tycon, args.mapConserve(checkArg))
       case tp: RefinedType => // @!!!
-        tp.derivedRefinedType(tp.parent, tp.refinedName, checkFeasible(tp.refinedInfo, pos, where))
+        tp.derivedRefinedType(tp.parent, tp.refinedName, checkFeasibleParent(tp.refinedInfo, pos, where))
       case tp: RecType => // @!!!
         tp.rebind(tp.parent)
       case tp @ TypeBounds(lo, hi) if !(lo <:< hi) => // @!!!
@@ -745,7 +748,7 @@ trait NoChecking extends Checking {
   override def checkStable(tp: Type, pos: Position)(implicit ctx: Context): Unit = ()
   override def checkClassType(tp: Type, pos: Position, traitReq: Boolean, stablePrefixReq: Boolean)(implicit ctx: Context): Type = tp
   override def checkImplicitParamsNotSingletons(vparamss: List[List[ValDef]])(implicit ctx: Context): Unit = ()
-  override def checkFeasible(tp: Type, pos: Position, where: => String = "")(implicit ctx: Context): Type = tp
+  override def checkFeasibleParent(tp: Type, pos: Position, where: => String = "")(implicit ctx: Context): Type = tp
   override def checkInlineConformant(tree: Tree, what: => String)(implicit ctx: Context) = ()
   override def checkNoDoubleDefs(cls: Symbol)(implicit ctx: Context): Unit = ()
   override def checkParentCall(call: Tree, caller: ClassSymbol)(implicit ctx: Context) = ()

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

@@ -913,7 +913,7 @@ class Namer { typer: Typer =>
       indexAndAnnotate(rest)(inClassContext(selfInfo))
       symbolOfTree(constr).ensureCompleted()
 
-      val parentTypes = ensureFirstIsClass(parents.map(checkedParentType(_)))
+      val parentTypes = ensureFirstIsClass(parents.map(checkedParentType(_)), cls.pos)
       val parentRefs = ctx.normalizeToClassRefs(parentTypes, cls, decls)
       typr.println(i"completing $denot, parents = $parents%, %, parentTypes = $parentTypes%, %, parentRefs = $parentRefs%, %")
 

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

@@ -1394,7 +1394,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
 
     completeAnnotations(cdef, cls)
     val constr1 = typed(constr).asInstanceOf[DefDef]
-    val parentsWithClass = ensureFirstIsClass(parents mapconserve typedParent, cdef.namePos)
+    val parentsWithClass = ensureFirstTreeIsClass(parents mapconserve typedParent, cdef.namePos)
     val parents1 = ensureConstrCall(cls, parentsWithClass)(superCtx)
     val self1 = typed(self)(ctx.outer).asInstanceOf[ValDef] // outer context where class members are not visible
     if (self1.tpt.tpe.isError || classExistsOnSelf(cls.unforcedDecls, self1)) {
@@ -1452,7 +1452,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
    *  - has C as its class symbol, and
    *  - for all parents P_i: If P_i derives from C then P_i <:< CT.
    */
-  def ensureFirstIsClass(parents: List[Type])(implicit ctx: Context): List[Type] = {
+  def ensureFirstIsClass(parents: List[Type], pos: Position)(implicit ctx: Context): List[Type] = {
     def realClassParent(cls: Symbol): ClassSymbol =
       if (!cls.isClass) defn.ObjectClass
       else if (!(cls is Trait)) cls.asClass
@@ -1469,19 +1469,16 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       case _ =>
         val pcls = (defn.ObjectClass /: parents)(improve)
         typr.println(i"ensure first is class $parents%, % --> ${parents map (_ baseTypeWithArgs pcls)}%, %")
-        val ptype = ctx.typeComparer.glb(
+        val first = ctx.typeComparer.glb(
             defn.ObjectType :: (parents map (_ baseTypeWithArgs pcls)))
-        ptype :: parents
+        checkFeasibleParent(first, pos, em" in inferred superclass $first") :: parents
     }
   }
 
   /** Ensure that first parent tree refers to a real class. */
-  def ensureFirstIsClass(parents: List[Tree], pos: Position)(implicit ctx: Context): List[Tree] = parents match {
+  def ensureFirstTreeIsClass(parents: List[Tree], pos: Position)(implicit ctx: Context): List[Tree] = parents match {
     case p :: ps if p.tpe.classSymbol.isRealClass => parents
-    case _ =>
-      // add synthetic class type
-      val first :: _ = ensureFirstIsClass(parents.tpes)
-      TypeTree(checkFeasible(first, pos, em"\n in inferred parent $first")).withPos(pos) :: parents
+    case _ => TypeTree(ensureFirstIsClass(parents.tpes, pos).head).withPos(pos) :: parents
   }
 
   /** If this is a real class, make sure its first parent is a

tests/neg/templateParents.scala

@@ -12,5 +12,5 @@ object templateParentsNeg1 {
   trait D extends C[String]
   trait E extends C[Int]
 
-  val x = new D with E // error no type fits between inferred bounds
+  val x = new D with E // error: conflicting type arguments inferred type
 }