Generalize syncing between parent trees and parent types

Namer will augment the parent types of a class with possibly other types.
Currently the only such change is a possibly leading class type, but with
#7613 we wll also generate trait parents that take context parameters.
The new method `parentTrees` will reflect any such changes in the parent
trees in Typer.

Author: odersky

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

@@ -1237,12 +1237,43 @@ class Namer { typer: Typer =>
         }
       }
 
+      /** Ensure that the first type in a list of parent types Ps points to a non-trait class.
+       *  If that's not already the case, add one. The added class type CT is determined as follows.
+       *  First, let C be the unique class such that
+       *  - there is a parent P_i such that P_i derives from C, and
+       *  - for every class D: If some parent P_j, j <= i derives from D, then C derives from D.
+       *  Then, let CT be the smallest type which
+       *  - 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])(using Context): List[Type] =
+
+        def realClassParent(sym: Symbol): ClassSymbol =
+          if !sym.isClass then defn.ObjectClass
+          else if !sym.is(Trait) then sym.asClass
+          else sym.info.parents match
+            case parentRef :: _ => realClassParent(parentRef.typeSymbol)
+            case nil => defn.ObjectClass
+
+        def improve(candidate: ClassSymbol, parent: Type): ClassSymbol =
+          val pcls = realClassParent(parent.classSymbol)
+          if (pcls derivesFrom candidate) pcls else candidate
+
+        parents match
+          case p :: _ if p.classSymbol.isRealClass => parents
+          case _ =>
+            val pcls = parents.foldLeft(defn.ObjectClass)(improve)
+            typr.println(i"ensure first is class $parents%, % --> ${parents map (_ baseType pcls)}%, %")
+            val first = TypeComparer.glb(defn.ObjectType :: parents.map(_.baseType(pcls)))
+            checkFeasibleParent(first, cls.srcPos, em" in inferred superclass $first") :: parents
+      end ensureFirstIsClass
+
       completeConstructor(denot)
       denot.info = tempInfo
 
       val parentTypes = defn.adjustForTuple(cls, cls.typeParams,
         defn.adjustForBoxedUnit(cls,
-          ensureFirstIsClass(parents.map(checkedParentType(_)), cls.span)
+          ensureFirstIsClass(parents.map(checkedParentType(_)))
         )
       )
       typr.println(i"completing $denot, parents = $parents%, %, parentTypes = $parentTypes%, %")

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

@@ -2278,8 +2278,11 @@ class Typer extends Namer
 
     completeAnnotations(cdef, cls)
     val constr1 = typed(constr).asInstanceOf[DefDef]
-    val parentsWithClass = ensureFirstTreeIsClass(parents.mapconserve(typedParent).filterConserve(!_.isEmpty), cdef.nameSpan)
-    val parents1 = ensureConstrCall(cls, parentsWithClass)(using superCtx)
+    val parents0 = parentTrees(
+        cls.classInfo.declaredParents,
+        parents.mapconserve(typedParent).filterConserve(!_.isEmpty),
+        cdef.nameSpan)
+    val parents1 = ensureConstrCall(cls, parents0)(using superCtx)
     val firstParentTpe = parents1.head.tpe.dealias
     val firstParent = firstParentTpe.typeSymbol
 
@@ -2348,42 +2351,22 @@ class Typer extends Namer
   protected def addAccessorDefs(cls: Symbol, body: List[Tree])(using Context): List[Tree] =
     ctx.compilationUnit.inlineAccessors.addAccessorDefs(cls, body)
 
-  /** Ensure that the first type in a list of parent types Ps points to a non-trait class.
-   *  If that's not already the case, add one. The added class type CT is determined as follows.
-   *  First, let C be the unique class such that
-   *  - there is a parent P_i such that P_i derives from C, and
-   *  - for every class D: If some parent P_j, j <= i derives from D, then C derives from D.
-   *  Then, let CT be the smallest type which
-   *  - has C as its class symbol, and
-   *  - for all parents P_i: If P_i derives from C then P_i <:< CT.
+  /** Augment `ptrees` to have the same class symbols as `parents`. Generate TypeTrees
+   *  to fill in any parents for wich no tree exists yet.
    */
-  def ensureFirstIsClass(parents: List[Type], span: Span)(using Context): List[Type] = {
-    def realClassParent(cls: Symbol): ClassSymbol =
-      if (!cls.isClass) defn.ObjectClass
-      else if (!cls.is(Trait)) cls.asClass
-      else cls.info.parents match {
-        case parentRef :: _ => realClassParent(parentRef.typeSymbol)
-        case nil => defn.ObjectClass
-      }
-    def improve(candidate: ClassSymbol, parent: Type): ClassSymbol = {
-      val pcls = realClassParent(parent.classSymbol)
-      if (pcls derivesFrom candidate) pcls else candidate
-    }
-    parents match {
-      case p :: _ if p.classSymbol.isRealClass => parents
-      case _ =>
-        val pcls = parents.foldLeft(defn.ObjectClass)(improve)
-        typr.println(i"ensure first is class $parents%, % --> ${parents map (_ baseType pcls)}%, %")
-        val first = TypeComparer.glb(defn.ObjectType :: parents.map(_.baseType(pcls)))
-        checkFeasibleParent(first, ctx.source.atSpan(span), em" in inferred superclass $first") :: parents
-    }
-  }
-
-  /** Ensure that first parent tree refers to a real class. */
-  def ensureFirstTreeIsClass(parents: List[Tree], span: Span)(using Context): List[Tree] = parents match {
-    case p :: ps if p.tpe.classSymbol.isRealClass => parents
-    case _ => TypeTree(ensureFirstIsClass(parents.tpes, span).head).withSpan(span.focus) :: parents
-  }
+  def parentTrees(parents: List[Type], ptrees: List[Tree], span: Span)(using Context): List[Tree] = parents match
+    case parent :: parents1 =>
+      val psym = parent.classSymbol
+      def hasSameParent(ptree: Tree) = ptree.tpe.classSymbol == psym
+      ptrees match
+        case ptree :: ptrees1 if hasSameParent(ptree) =>
+          ptree :: parentTrees(parents1, ptrees1, span)
+        case ptree :: ptrees1 if ptrees1.exists(hasSameParent) =>
+          ptree :: parentTrees(parents, ptrees1, span)
+        case _ =>
+          TypeTree(parent).withSpan(span.focus) :: parentTrees(parents1, ptrees, span)
+    case _ =>
+      ptrees
 
   /** If this is a real class, make sure its first parent is a
    *  constructor call. Cannot simply use a type. Overridden in ReTyper.

tests/neg/i6060.scala

@@ -1,6 +1,6 @@
 class I1(i2: Int) {
   def apply(i3: Int) = 1
-  new I1(1)(2) {} // error: too many arguments in parent constructor
+  new I1(1)(2) {} // error: too many arguments in parent constructor // error
 }
 
 class I0(i1: Int) {

tests/pos/i7613.scala

@@ -0,0 +1,13 @@
+trait Foo[A]
+trait Bar[A] extends Foo[A]
+trait Baz[A] extends Bar[A]
+
+trait FooLaws[A](using Foo[A])
+trait BarLaws[A](using Bar[A]) extends FooLaws[A]
+trait BazLaws[A](using Baz[A]) extends BarLaws[A]
+
+def instance1[A](using Baz[A]): BazLaws[A] =
+  new FooLaws[A] with BarLaws[A] with BazLaws[A] {}
+
+def instance2[A](using Baz[A]): BazLaws[A] =
+  new BazLaws[A] {}