Implement ancestors inline traits without term args

Ancestors without term args do not need to be specified in the list of extended symbols

This means that we need to recreate the trees manually, and most importantly, make sure the inlined members are overridden in the correct order

The order of inheritance is defined by a left-handed DFS and is accessible through SymDenotation#baseClasses

Author: timotheeandres

compiler/src/dotty/tools/dotc/inlines/Inlines.scala

@@ -85,6 +85,26 @@ object Inlines:
   private def symbolFromParent(parent: Tree)(using Context): Symbol =
     if parent.symbol.isConstructor then parent.symbol.owner else parent.symbol
 
+  private def inlineTraitAncestors(cls: TypeDef)(using Context): List[Tree] = cls match {
+    case tpd.TypeDef(_, tmpl: Template) =>
+      val parentTrees: Map[Symbol, Tree] = tmpl.parents.map(par => symbolFromParent(par) -> par).toMap.filter(_._1.isInlineTrait)
+      val ancestors: List[ClassSymbol] = cls.tpe.baseClasses.filter(sym => sym.isInlineTrait && sym != cls.symbol)
+      ancestors.flatMap(ancestor =>
+        def baseTree =
+          cls.tpe.baseType(ancestor) match
+            case AppliedType(tycon, targs) =>
+              Some(AppliedTypeTree(TypeTree(tycon), targs.map(TypeTree(_))))
+            case tref: TypeRef =>
+              Some(Ident(tref))
+            case baseTpe =>
+              report.error(s"unknown base type ${baseTpe.show} for ancestor ${ancestor.show} of ${cls.symbol.show}")
+              None
+        parentTrees.get(ancestor).orElse(baseTree.map(_.withSpan(cls.span)))
+      )
+    case _ =>
+      Nil
+  }
+
   private def needsTransparentInlining(tree: Tree)(using Context): Boolean =
     tree.symbol.is(Transparent)
     || ctx.mode.is(Mode.ForceInline)
@@ -190,16 +210,14 @@ object Inlines:
 
   def inlineParentInlineTraits(cls: Tree)(using Context): Tree =
     cls match {
-      case cls @ TypeDef(_, impl: Template) =>
-        val overriddenSyms = cls.symbol.info.decls.toList.flatMap(_.allOverriddenSymbols).toSet
-        val inlineDefs = impl.parents.flatMap(
-          parent =>
-            if symbolFromParent(parent).isInlineTrait then
-              InlineParentTrait(parent)(using ctx.withOwner(cls.symbol)).expandDefs(overriddenSyms)
-            else
-              Nil
+      case cls @ tpd.TypeDef(_, impl: Template) =>
+        val clsOverriddenSyms = cls.symbol.info.decls.toList.flatMap(_.allOverriddenSymbols).toSet
+        val inlineDefs = inlineTraitAncestors(cls).foldLeft(List.empty[Tree])(
+          (defs, parent) =>
+            val overriddenSymbols = clsOverriddenSyms ++ defs.flatMap(_.symbol.allOverriddenSymbols)
+            defs ::: InlineParentTrait(parent)(using ctx.withOwner(cls.symbol)).expandDefs(overriddenSymbols)
         )
-        val impl1 = cpy.Template(impl)(body = inlineDefs ::: impl.body)
+        val impl1 = cpy.Template(impl)(body = impl.body ::: inlineDefs)
         cpy.TypeDef(cls)(rhs = impl1)
       case _ =>
         cls

tests/run/inline-trait-inheritance-inline-ancestors.check

@@ -0,0 +1,7 @@
+0
+11
+12
+13
+21
+22
+30

tests/run/inline-trait-inheritance-inline-ancestors.scala

@@ -0,0 +1,72 @@
+/*
+ * Inheritance tree:
+ *
+ *   ___T0___
+ *  /    |   \
+ * T11  T12  T13
+ *  \   /\   /
+ *   T21  T22
+ *     \  /
+ *      C
+ *
+ * Each trait overrides members so that they should have the same value as their name in C
+ * (zero should be 0, eleven should be 11, etc.).
+ */
+
+@main def Test =
+  val c = C()
+  for v <- allValues(c)
+  do println(v)
+
+def allValues(c: C): List[Int] =
+  List(
+    c.zero,
+    c.eleven,
+    c.twelve,
+    c.thirteen,
+    c.twentyOne,
+    c.twentyTwo,
+    c.thirty,
+  )
+
+inline trait T0:
+  def zero: Int = 0
+  def eleven: Int = 0
+  def twelve: Int = 0
+  def twentyOne: Int = 0
+  def thirteen: Int = 0
+  def twentyTwo: Int = 0
+  def thirty: Int = 0
+
+inline trait T11 extends T0:
+  override def eleven: Int = 11
+  override def twelve: Int = 11
+  override def twentyOne: Int = 11
+  override def thirteen: Int = 11
+  override def twentyTwo: Int = 11
+  override def thirty: Int = 11
+
+inline trait T12 extends T0:
+  override def twelve: Int = 12
+  override def twentyOne: Int = 12
+  override def thirteen: Int = 12
+  override def twentyTwo: Int = 12
+  override def thirty: Int = 12
+
+inline trait T21 extends T11, T12:
+  override def twentyOne: Int = 21
+  override def thirteen: Int = 21
+  override def twentyTwo: Int = 21
+  override def thirty: Int = 21
+
+inline trait T13 extends T0:
+  override def thirteen: Int = 13
+  override def twentyTwo: Int = 13
+  override def thirty: Int = 13
+
+inline trait T22 extends T12, T13:
+  override def twentyTwo: Int = 22
+  override def thirty: Int = 22
+
+class C extends T21, T22:
+  override def thirty: Int = 30