Strip parents of inner class from concrete elements

When "transforming" an inner class into an inner trait, we need to adapt its parents as well.

When declaring its parents, a trait cannot call their constructor, therefore the different Apply and other trees should be pruned from them.

For example:
```
inline trait A:
  class InnerA extends Object
```
will result in the following code after Inlining:
```
inline trait A:
  trait InnerA$trait extends Object
  type InnerA <: InnerA$trait
```
The tree for `Object` in the first case is
```
Apply(Select(New(Ident(Object)),<init>),List())
```
but if we make InnerA a trait instead, it is simply
```
Ident(Object)
```

The goal is therefore to strip the different "concrete" elements of the parents when transforming a class into a trait.

Author: timotheeandres

compiler/src/dotty/tools/dotc/transform/Inlining.scala

@@ -78,13 +78,18 @@ class Inlining extends MacroTransform, SymTransformer {
       case member: MemberDef =>
         List(member)
       case _ =>
+        // Remove non-memberdefs, as they are normally placed into $init()
         Nil
     }
     val tmpl1 = cpy.Template(tmpl)(body = body1)
     cpy.TypeDef(inlineTrait)(rhs = tmpl1)
 
   private def makeTraitFromInnerClass(innerClass: TypeDef)(using Context): TypeDef =
-    cpy.TypeDef(innerClass)(name = newInnerClassName(innerClass.name))
+    val TypeDef(name, tmpl: Template) = innerClass: @unchecked
+    val newInnerParents = tmpl.parents.mapConserve(ConcreteParentStripper.apply)
+    val tmpl1 = cpy.Template(tmpl)(parents = newInnerParents) // TODO .withType(???)
+    cpy.TypeDef(innerClass)(name = newInnerClassName(name), rhs = tmpl1)
+  end makeTraitFromInnerClass
 
   private def makeTypeFromInnerClass(parentSym: Symbol, innerClass: TypeDef, newTraitSym: Symbol)(using Context): TypeDef =
     val upperBound = innerClass.symbol.primaryConstructor.info match {
@@ -164,6 +169,16 @@ class Inlining extends MacroTransform, SymTransformer {
   }
 
   private def newInnerClassName(name: Name): name.ThisName = name ++ str.INLINE_TRAIT_INNER_CLASS_SUFFIX
+
+  private object ConcreteParentStripper extends TreeAccumulator[Tree] {
+    def apply(tree: Tree)(using Context): Tree = apply(tree, tree)
+
+    override def apply(x: Tree, tree: Tree)(using Context): Tree = tree match {
+      case ident: Ident => ident
+      case tpt: TypeTree => tpt
+      case _ => foldOver(x, tree)
+    }
+  }
 }
 
 object Inlining: