Implement grandparent inline traits, fix parameters shadowing

Allow an inline trait to extend another inline trait, and prevent code from being inlined inside the child inline trait: only inline in first non-inline class-like element

When parameters shadow each other (e.g. val x and private[this] val x), rename the instance-private ones to avoid clash
If multiple non-instance-private fields are present, the compiler should still raise the same error as with normal traits

Author: timotheeandres

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

@@ -20,6 +20,7 @@ import staging.StagingLevel
 import collection.mutable
 import reporting.trace
 import util.Spans.{Span, spanCoord}
+import NameOps.expandedName
 
 /** Support for querying inlineable methods and for inlining calls to such methods */
 object Inlines:
@@ -486,7 +487,17 @@ object Inlines:
       }
     }
 
+    protected class InlineTraitTreeMap extends InlinerTreeMap {
+      override def apply(tree: Tree) = tree match {
+        case tree @ Select(This(ident), name) if ident.name == parentSym.name && localParamAccessorsNames.contains(name) =>
+          Select(This(ctx.owner.asClass), localParamAccessorsNames(name)).withSpan(parent.span)
+        case tree =>
+          super.apply(tree)
+      }
+    }
+
     override protected val inlinerTypeMap: InlinerTypeMap = InlineTraitTypeMap()
+    override protected val inlinerTreeMap: InlinerTreeMap = InlineTraitTreeMap()
 
     private val paramAccessorsValueOf: Map[Name, Tree] =
       def allArgs(tree: Tree, acc: Vector[List[Tree]]): List[List[Tree]] = tree match
@@ -502,6 +513,8 @@ object Inlines:
         else parent.symbol.info
       allParams(info, Nil).flatten.zip(allArgs(parent, Vector.empty).flatten).toMap
 
+    private val localParamAccessorsNames = new mutable.HashMap[Name, Name]
+
     private def isStatAlreadyOverridden(stat: Tree): Boolean =
       overriddenDecls.contains(stat.symbol)
 
@@ -524,11 +537,17 @@ object Inlines:
           val inlinedInfo = ClassInfo(prefix, cls, declaredParents, Scopes.newScope, selfInfo) // TODO adapt parents
           sym.copy(owner = ctx.owner, info = inlinedInfo, coord = spanCoord(parent.span)).entered.asClass
         case _ =>
+          var name = sym.name
           var flags = sym.flags | Synthetic
           if sym.isType || !sym.is(Private) then flags |= Override
-          if sym.isTermParamAccessor then flags &~= ParamAccessor
+          if sym.isTermParamAccessor then
+            flags &~= ParamAccessor
+            if sym.is(Local) then
+              name = name.expandedName(parentSym)
+              localParamAccessorsNames(sym.name) = name
           sym.copy(
             owner = ctx.owner,
+            name = name,
             flags = flags,
             info = inlinerTypeMap(sym.info),
             coord = spanCoord(parent.span)).entered

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

@@ -2658,7 +2658,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     else {
       val dummy = localDummy(cls, impl)
       val inlineTraitDefs =
-        if ctx.isAfterTyper then
+        if ctx.isAfterTyper || cls.isInlineTrait then
           Nil
         else
           val overriddenSyms = cls.info.decls.toList.flatMap(_.allOverriddenSymbols).toSet

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

@@ -0,0 +1,6 @@
+0
+(Test SimpleC,Hello)
+
+5678
+(Test C,Hello,9)
+5678

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

@@ -0,0 +1,33 @@
+package simpleGrandParent:
+  inline trait SimpleGrandParent[T]:
+    def foo(): Int = 0
+    def foooo(): T = ???
+
+  inline trait SimpleParent[T, U](x: T, z: U) extends SimpleGrandParent[U]:
+    def bar(a: T) = (a, x)
+
+  class SimpleC extends SimpleParent("Hello", 1234)
+
+package grandParentWithArgs:
+  inline trait GrandParent[T](val x: T, val y: T):
+    def foo(): T = x
+    def foooo(): T = y
+
+  inline trait Parent[T, U](x: T, z: U) extends GrandParent[U]:
+    def bar(a: T) = (a, x, y)
+
+  class C extends Parent("Hello", 1234), GrandParent(5678, 9)
+
+@main def Test =
+  import simpleGrandParent.SimpleC
+  import grandParentWithArgs.C
+
+  val simpleC = SimpleC()
+  println(simpleC.foo())
+  println(simpleC.bar("Test SimpleC"))
+  println
+
+  val c = C()
+  println(c.foo())
+  println(c.bar("Test C"))
+  println(c.x)