Import Nicolas' work

Allows for private trait parameters and private inner classes

compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala

@@ -124,8 +124,7 @@ class TreeTypeMap(
         case ddef @ DefDef(name, paramss, tpt, _) =>
           val (tmap1, paramss1) = transformAllParamss(paramss)
           val res = cpy.DefDef(ddef)(name, paramss1, tmap1.transform(tpt), tmap1.transform(ddef.rhs))
-          if tree.symbol.owner.isInlineTrait then
-            res.symbol.info = mapType(res.symbol.info)  // FIXME inline traits' info doesn't get mapped
+          res.symbol.info = mapType(res.symbol.info)  // FIXME inline traits' info doesn't get mapped
           res.symbol.setParamssFromDefs(paramss1)
           res.symbol.transformAnnotations {
             case ann: BodyAnnotation => ann.derivedAnnotation(transform(ann.tree))

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

@@ -579,23 +579,6 @@ class Inliner(val call: tpd.Tree)(using Context):
           }
         },
       treeMap = {
-        case tree: (DefDef | ValDef | TypeDef) if inlinedMethod.is(Trait) && tree.symbol.owner == inlinedMethod =>
-          val sym = tree.symbol
-          val inlinedSym = sym.copy(owner = ctx.owner, flags = sym.flags | Override)
-          inlinedSym.entered // Should this be entered here? Or after inlining process has succeeded
-
-          tree match {
-            case tree: DefDef =>
-              def rhsFun(paramss: List[List[Tree]]): Tree =
-                val oldParamSyms = tree.paramss.flatten.map(_.symbol)
-                val newParamSyms = paramss.flatten.map(_.symbol)
-                tree.rhs.subst(oldParamSyms, newParamSyms)
-              tpd.DefDef(inlinedSym.asTerm, rhsFun).withSpan(tree.span)
-            case tree: ValDef =>
-              tpd.ValDef(inlinedSym.asTerm, tree.rhs).withSpan(tree.span)
-            case tree: TypeDef =>
-              tpd.TypeDef(inlinedSym.asType).withSpan(tree.span)
-          }
         case tree: This =>
           tree.tpe match {
             case thistpe: ThisType =>

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

@@ -470,7 +470,69 @@ object Inlines:
     import Inlines.*
 
     def expandDefs(): List[Tree] =
+      val argsMap = parent match
+        case Apply(_, args) =>
+          val MethodType(paramNames) = parent.symbol.info: @unchecked
+          paramNames.zip(args).toMap
+        case _ => Map.empty
+
       val Block(stats, _) = Inlines.bodyToInline(parentSym): @unchecked
-      stats.map(stat => inlined(stat)._2)
+
+      val stats1 = stats.map { stat =>
+          val sym = stat.symbol
+          stat match
+            case tree: ValDef if sym.is(ParamAccessor) =>
+              val vdef = cloneValDef(tree)
+              vdef.symbol.resetFlag(ParamAccessor)
+              cpy.ValDef(vdef)(rhs = argsMap(sym.name.asTermName))
+            case stat: ValDef =>
+              val vdef = cloneValDef(stat)
+              if !sym.is(Private) then vdef.symbol.setFlag(Override)
+              cpy.ValDef(vdef)() // TODO keep rhs? Can we do a single ValOrDefDef case using cloneStat?
+            case stat: DefDef =>
+              val ddef = cloneDefDef(stat)
+              if !sym.is(Private) then ddef.symbol.setFlag(Override)
+              ddef
+            case stat @ TypeDef(_, impl: Template) =>
+              cloneClass(stat, impl)
+            case stat: TypeDef =>
+              val tdef = cloneTypeDef(stat)
+              tdef.symbol.setFlag(Override)
+              cpy.TypeDef(tdef)()
+      }
+      stats1.map(stat => inlined(stat)._2)
+
+    private def cloneClass(clDef: TypeDef, impl: Template)(using Context): TypeDef =
+      val inlinedCls: ClassSymbol =
+        val ClassInfo(prefix, cls, declaredParents, scope, selfInfo) = clDef.symbol.info: @unchecked
+        val inlinedInfo = ClassInfo(prefix, cls, declaredParents, Scopes.newScope, selfInfo) // TODO adapt parents
+        clDef.symbol.copy(owner = ctx.owner, info = inlinedInfo).entered.asClass
+      val (constr, body) = inContext(ctx.withOwner(inlinedCls)) {
+        (cloneDefDef(impl.constr), impl.body.map(cloneStat))
+      }
+      tpd.ClassDefWithParents(inlinedCls, constr, impl.parents, body).withSpan(clDef.span) // TODO adapt parents
+
+    private def cloneStat(tree: Tree)(using Context): Tree = tree match
+      case tree: DefDef => cloneDefDef(tree)
+      case tree: ValDef => cloneValDef(tree)
+      // TODO case stat @ TypeDef(_, impl: Template) => cloneClass(stat, impl)
+      // TODO case tree: TypeDef => cloneTypeDef(tree)
+
+    private def cloneDefDef(ddef: DefDef)(using Context): DefDef =
+      val inlinedSym = ddef.symbol.copy(owner = ctx.owner).entered
+      def rhsFun(paramss: List[List[Tree]]): Tree =
+        val oldParamSyms = ddef.paramss.flatten.map(_.symbol)
+        val newParamSyms = paramss.flatten.map(_.symbol)
+        ddef.rhs.subst(oldParamSyms, newParamSyms) // TODO clone local classes?
+      tpd.DefDef(inlinedSym.asTerm, rhsFun).withSpan(ddef.span)
+
+    private def cloneValDef(vdef: ValDef)(using Context): ValDef =
+      val inlinedSym = vdef.symbol.copy(owner = ctx.owner).entered
+      tpd.ValDef(inlinedSym.asTerm, vdef.rhs).withSpan(vdef.span) // TODO clone local classes?
+
+    private def cloneTypeDef(tdef: TypeDef)(using Context): TypeDef =
+      val inlinedSym = tdef.symbol.copy(owner = ctx.owner).entered
+      tpd.TypeDef(inlinedSym.asType).withSpan(tdef.span)
+
   end InlineParentTrait
 end Inlines

tests/pos/inline-trait-1-simple-trait.scala

@@ -2,12 +2,15 @@ inline trait A:
   type X = String
 
   val x: Int = 3
-  val y: Int = x + 1
+  val y: Int = x + z
+  private val z: Int = 1
 
-  def f: Int = f
+  def f: Int = g
   def f(x: Int): Int = x
   def f[T](x: T): Int = 2
 
+  private def g = 1
+
   def xx: X = "foo".asInstanceOf[X]
 end A
 
@@ -16,12 +19,16 @@ class B extends A:
   <generated> override type X = String
 
   <generated> override val x: Int = 3
-  <generated> override val y: Int = x + 1
+  <generated> override val y: Int = this.x.+(this.z)
+
+  <generated> private[this] val z: Int = 1
 
-  <generated> override def f: Int = 2
-  <generated> override def f(x: Int): Int = 2
+  <generated> override def f: Int = this.g
+  <generated> override def f(x: Int): Int = x
   <generated> override def f[T](x: T): Int = 2
 
+  <generated> private[this] def g: Int = 1
+
   <generated> override def xx: X = "foo".asInstanceOf[X]
   */
 end B

tests/pos/inline-trait-3-trait-params.scala

@@ -0,0 +1,15 @@
+inline trait A(a: Int):
+  def f: Int = a
+  def g(b: Int): Int = a + b
+end A
+
+class B extends A(4):
+  // FIXME: Should not generate second field for A.a (probably in the memoize phase). `B.A$$a` could point to the `a` we already have.
+  //        Alternative: remove the field and defs from `A`.
+
+  /*
+  <generated> private val a: Int = 4
+  <generated> override def f: Int = this.a
+  <generated> override def g(x: Int): Int = this.a.+(b)
+  */
+end B

tests/pos/inline-trait-4-inner-class.scala

@@ -0,0 +1,28 @@
+inline trait Options[T]:
+  // FIXME: remove original class definition from inline trait to allow public classes
+  private trait Option:
+    def get: T
+  // FIXME: support constructor parameter
+  // FIXME: support specialized parents
+  private class Some://(x: T): // extends Option
+    def get: T = ??? // x
+  // FIXME: support specialized modules
+  // private object None // extends Option
+  //   def get: T = throw new NoSuchElementException("None.get")
+
+  // FIXME: specialize reference to Option and Some
+  // def option(value: T): Option = new Some//(value)
+end Options
+
+object IntOptions extends Options[Int]:
+  /*
+  <generated> trait Option:
+    def get: Int
+  <generated> class Some(x: Int) extends Option
+    def get: Int = x
+  <generated> object None extends Option
+    def get: Int = throw new NoSuchElementException("None.get")
+
+  <generated> def option(value: Int): Option = new Some(value)
+  */
+end IntOptions