WIP support private inline trait members

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

@@ -41,6 +41,21 @@ object InlineTraits:
       else inlinedSymbolValOrDef(cls, sym, traitTargs)
   end inlinedMemberSymbols
 
+  def inlinedPrivateMemberSymbols(cls: ClassSymbol)(using Context): List[Symbol] =
+    assert(!cls.isInlineTrait, cls)
+    println("     ")
+    for
+      parent <- cls.info.parents
+      parentSym = parent.typeSymbol
+      if parentSym.isAllOf(InlineTrait)
+      sym <- parentSym.info.decls.toList
+      if sym.isTerm && sym.is(Private)
+    yield
+      val traitTargs = parentTargs(cls, sym)
+      inlinedSymbolPrivateValOrDef(cls, sym, traitTargs)
+
+
+
   private def isInlinableMember(sym: Symbol)(using Context): Boolean =
     (sym.isTerm || sym.isClass)
     && !sym.isConstructor && !sym.is(ParamAccessor)
@@ -60,6 +75,15 @@ object InlineTraits:
     val privateWithin = inlinableDecl.privateWithin // TODO what should `privateWithin` be?
     newSymbol(cls, inlinableDecl.name, flags, info, privateWithin, cls.span)
 
+  private def inlinedSymbolPrivateValOrDef(cls: ClassSymbol, inlinableDecl: Symbol, traitTargs: List[Type])(using Context): Symbol =
+    val name = atPhase(ctx.phase.next) { inlinableDecl.name }
+    val flags = inlinableDecl.flags | Synthetic
+    val info = inlinableDecl.info
+      .substThis(inlinableDecl.owner.asClass, ThisType.raw(cls.typeRef))
+      .subst(inlinableDecl.owner.typeParams, traitTargs)
+    val privateWithin = inlinableDecl.privateWithin // TODO what should `privateWithin` be?
+    newSymbol(cls, name, flags, info, privateWithin, cls.span)
+
   private def inlinedSymbolClassDef(cls: ClassSymbol, inlinableDecl: ClassSymbol, traitTargs: List[Type])(using Context): ClassSymbol =
     def infoFn(cls1: ClassSymbol) =
       inlinableDecl.info.asInstanceOf[ClassInfo].derivedClassInfo(
@@ -98,7 +122,7 @@ object InlineTraits:
 
   def inlinedDefs(cls: ClassSymbol)(using Context): List[Tree] =
     atPhase(ctx.phase.next) { cls.info.decls.toList }
-      .filter(sym => sym.is(Synthetic) && sym.nextOverriddenSymbol.maybeOwner.isInlineTrait)
+      .filter(sym => sym.is(Synthetic) && (atPhase(ctx.phase.next) { sym.nextOverriddenSymbol }.maybeOwner.isInlineTrait))
       .map { sym =>
         if sym.isClass then inlinedClassDefs(cls, sym.asClass)
         else inlinedValOrDefDefs(cls, sym)
@@ -158,7 +182,7 @@ object InlineTraits:
       stat match
         case stat: ValOrDefDef =>
           if sym.is(Module) then report.error(em"Implementation restriction: object cannot be defined in inline traits", stat.srcPos)
-          else if sym.is(Private) then report.error(em"Implementation restriction: private ${sym.kindString} cannot be defined in inline traits", stat.srcPos)
+          // else if sym.is(Private) then report.error(em"Implementation restriction: private ${sym.kindString} cannot be defined in inline traits", stat.srcPos)
           else () // Ok
         case stat: TypeDef =>
           if sym.isClass && !sym.is(Trait) then report.error(em"Implementation restriction: ${sym.kindString} cannot be defined in inline traits", stat.srcPos)

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

@@ -71,8 +71,12 @@ class TraitInlining extends MacroTransform, DenotTransformer {
           case tp @ ClassInfo(_, cls, _, decls, _) if needsTraitInlining(sym.asClass) =>
             val newDecls = decls.cloneScope
             inlinedMemberSymbols(sym.asClass).foreach(newDecls.enter)
+            inlinedPrivateMemberSymbols(sym.asClass).foreach(newDecls.enter)
             val newInfo = tp.derivedClassInfo(decls = newDecls)
             ref.copySymDenotation(info = newInfo).copyCaches(ref, ctx.phase.next)
+          case _ if ref.isTerm && ref.owner.isInlineTrait && ref.is(Private) =>
+            val newName = (sym.name.expandedName(ref.owner).toString + "$inline$trait").toTermName // TODO use NameKinds
+            ref.copySymDenotation(name = newName, initFlags = ref.flags &~ Private)
           case _ =>
             ref
       case _ =>