Use expanded names for inline proxies in traits

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

@@ -68,7 +68,8 @@ abstract class AccessProxies {
   trait Insert {
     import ast.tpd._
 
-    def accessorNameKind: ClassifiedNameKind
+    /** The name of the accessor for definition with given `name` in given `site` */
+    def accessorNameOf(name: TermName, site: Symbol)(using Context): TermName
     def needsAccessor(sym: Symbol)(using Context): Boolean
 
     def ifNoHost(reference: RefTree)(using Context): Tree = {
@@ -134,7 +135,7 @@ abstract class AccessProxies {
       if (accessorClass.exists) {
         if accessorClass.is(Package) then
           accessorClass = ctx.owner.topLevelClass
-        val accessorName = accessorNameKind(accessed.name)
+        val accessorName = accessorNameOf(accessed.name, accessorClass)
         val accessorInfo =
           accessed.info.ensureMethodic.asSeenFrom(accessorClass.thisType, accessed.owner)
         val accessor = accessorSymbol(accessorClass, accessorName, accessorInfo, accessed)

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

@@ -6,6 +6,7 @@ import core.NameKinds._
 import core.Symbols._
 import core.Flags._
 import core.Decorators._
+import core.Names.TermName
 import MegaPhase.MiniPhase
 import config.Printers.transforms
 
@@ -51,7 +52,7 @@ class ProtectedAccessors extends MiniPhase {
 
   object Accessors extends AccessProxies {
     val insert: Insert = new Insert {
-      def accessorNameKind = ProtectedAccessorName
+      def accessorNameOf(name: TermName, site: Symbol)(using Context): TermName = ProtectedAccessorName(name)
       def needsAccessor(sym: Symbol)(using Context) = ProtectedAccessors.needsAccessor(sym)
 
       override def ifNoHost(reference: RefTree)(using Context): Tree = {

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

@@ -13,7 +13,7 @@ import Decorators._
 import NameKinds._
 import StdNames.nme
 import Contexts._
-import Names.Name
+import Names.{Name, TermName}
 import NameKinds.{InlineAccessorName, UniqueInlineName}
 import NameOps._
 import Annotations._
@@ -40,7 +40,9 @@ object PrepareInlineable {
     /** A tree map which inserts accessors for non-public term members accessed from inlined code.
      */
     abstract class MakeInlineableMap(val inlineSym: Symbol) extends TreeMap with Insert {
-      def accessorNameKind: PrefixNameKind = InlineAccessorName
+      def accessorNameOf(name: TermName, site: Symbol)(using Context): TermName =
+        val accName = InlineAccessorName(name)
+        if site.is(Trait) then accName.expandedName(site) else accName
 
       /** A definition needs an accessor if it is private, protected, or qualified private
        *  and it is not part of the tree that gets inlined. The latter test is implemented

tests/pos/i10477.scala

@@ -0,0 +1,9 @@
+trait A:
+  private def f: Int = 1
+  inline def g = f
+trait B:
+  private def f: Int = 1
+  inline def h = f
+class C extends A, B
+
+

tests/pos/i10477/A.scala

@@ -0,0 +1,22 @@
+package gopher
+
+import scala.util.Try
+
+def await[F[_],T](f:F[T])(using am:CpsAsyncMonad[F]):T = ???
+
+trait CpsAsyncMonad[F[_]]:
+
+   def adoptCallbackStyle[A](source: (Try[A]=>Unit) => Unit): F[A]
+
+trait IChannel[F[_]:CpsAsyncMonad, A]:
+
+   def aread:F[A] =
+      summon[CpsAsyncMonad[F]].adoptCallbackStyle(f => addReader(f))
+
+   inline def read: A = await(aread)
+
+   def addReader(f: Try[A]=>Unit): Unit
+
+
+trait IOChannel[F[_]:CpsAsyncMonad,I,O] extends IChannel[F,I] with OChannel[F,O]
+

tests/pos/i10477/Test.scala

@@ -0,0 +1,15 @@
+package gopher
+
+import scala.util.Try
+
+trait OChannel[F[_]:CpsAsyncMonad, A]:
+
+   def awrite(a:A):F[Unit] =
+     summon[CpsAsyncMonad[F]].adoptCallbackStyle(f =>
+         addWriter(a, f)
+     )
+
+   inline def write(a:A): Unit = await(awrite(a))
+
+   def addWriter(a:A, f: Try[Unit]=>Unit): Unit
+