Support @binaryAPI on private[this] definitions

In this case the annotation will generate a public accessor (and setter).
This accessor has a consistent name that avoids clashes (`<className>$inline$<definitionName>`).

It will have the same name as a private accessor that would have been generate
in a non final class by the old inline accessor generation.

Author: nicolasstucki

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

@@ -35,6 +35,9 @@ object PrepareInlineable {
   def makeInlineable(tree: Tree)(using Context): Tree =
     ctx.property(InlineAccessorsKey).get.makeInlineable(tree)
 
+  def makePrivateBinaryAPIAccessor(sym: Symbol)(using Context): Unit =
+    ctx.property(InlineAccessorsKey).get.makePrivateBinaryAPIAccessor(sym)
+
   def addAccessorDefs(cls: Symbol, body: List[Tree])(using Context): List[Tree] =
     ctx.property(InlineAccessorsKey) match
       case Some(inlineAccessors) => inlineAccessors.addAccessorDefs(cls, body)
@@ -51,15 +54,14 @@ object PrepareInlineable {
       case _ => false
     }
 
-    /** 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 {
+    trait InsertInlineAccessors extends Insert {
 
       def useBinaryAPI: Boolean
 
-      def accessorNameOf(name: TermName, site: Symbol)(using Context): TermName =
-        val accName = InlineAccessorName(name)
-        if site.isExtensibleClass then accName.expandedName(site) else accName
+      def accessorNameOf(accessed: Symbol, site: Symbol)(using Context): TermName =
+        val accName = InlineAccessorName(accessed.name.asTermName)
+        if site.isExtensibleClass || useBinaryAPI 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
@@ -74,11 +76,21 @@ object PrepareInlineable {
       def needsAccessor(sym: Symbol)(using Context): Boolean =
         sym.isTerm &&
         (sym.isOneOf(AccessFlags) || sym.privateWithin.exists) &&
-        (!useBinaryAPI || !sym.isBinaryAPI) &&
-        !sym.isContainedIn(inlineSym) &&
+        (!useBinaryAPI || !sym.isBinaryAPI || (sym.is(Private) && !sym.owner.is(Trait))) &&
         !(sym.isStableMember && sym.info.widenTermRefExpr.isInstanceOf[ConstantType]) &&
         !sym.isInlineMethod &&
         (Inlines.inInlineMethod || StagingLevel.level > 0)
+    }
+
+    class InsertPrivateBinaryAPIAccessors extends InsertInlineAccessors:
+      def useBinaryAPI: Boolean = true
+
+    /** A tree map which inserts accessors for non-public term members accessed from inlined code.
+     */
+    abstract class MakeInlineableMap(val inlineSym: Symbol) extends TreeMap with InsertInlineAccessors {
+
+      override def needsAccessor(sym: Symbol)(using Context): Boolean =
+        !sym.isContainedIn(inlineSym) && super.needsAccessor(sym)
 
       def preTransform(tree: Tree)(using Context): Tree
 
@@ -210,6 +222,16 @@ object PrepareInlineable {
       }
     }
 
+    /** Create an inline accessor for this definition. */
+    def makePrivateBinaryAPIAccessor(sym: Symbol)(using Context): Unit =
+      assert(sym.is(Private))
+      if !sym.owner.is(Trait) then
+        val ref = tpd.ref(sym).asInstanceOf[RefTree]
+        val insertPrivateBinaryAPIAccessors = new InsertPrivateBinaryAPIAccessors()
+        val accessor = insertPrivateBinaryAPIAccessors.useAccessor(ref)
+        if sym.is(Mutable) then
+          insertPrivateBinaryAPIAccessors.useSetter(accessor)
+
     /** Adds accessors for all non-public term members accessed
      *  from `tree`. Non-public type members are currently left as they are.
      *  This means that references to a private type will lead to typing failures

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

@@ -67,7 +67,7 @@ abstract class AccessProxies {
     import ast.tpd._
 
     /** The name of the accessor for definition with given `name` in given `site` */
-    def accessorNameOf(name: TermName, site: Symbol)(using Context): TermName
+    def accessorNameOf(accessed: Symbol, site: Symbol)(using Context): TermName
     def needsAccessor(sym: Symbol)(using Context): Boolean
 
     def ifNoHost(reference: RefTree)(using Context): Tree = {
@@ -136,7 +136,7 @@ abstract class AccessProxies {
       if (accessorClass.exists) {
         if accessorClass.is(Package) then
           accessorClass = ctx.owner.topLevelClass
-        val accessorName = accessorNameOf(accessed.name, accessorClass)
+        val accessorName = accessorNameOf(accessed, 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

@@ -64,7 +64,7 @@ class ProtectedAccessors extends MiniPhase {
 
   private class Accessors extends AccessProxies {
     val insert: Insert = new Insert {
-      def accessorNameOf(name: TermName, site: Symbol)(using Context): TermName = ProtectedAccessorName(name)
+      def accessorNameOf(accessed: Symbol, site: Symbol)(using Context): TermName = ProtectedAccessorName(accessed.name.asTermName)
       def needsAccessor(sym: Symbol)(using Context) = ProtectedAccessors.needsAccessor(sym)
 
       override def ifNoHost(reference: RefTree)(using Context): Tree = {

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

@@ -530,7 +530,6 @@ object Checking {
       if sym.is(Enum) then fail(em"@binaryAPI cannot be used on enum definitions.")
       else if sym.isType && !sym.is(Module) && !(sym.is(Given) || sym.companionModule.is(Given)) then fail(em"@binaryAPI cannot be used on ${sym.showKind} definitions")
       else if !sym.owner.isClass && !(sym.is(Param) && sym.owner.isConstructor) then fail(em"@binaryAPI cannot be used on local definitions.")
-      else if sym.is(Private) then fail(em"@binaryAPI cannot be used on private definitions.\n\nCould use private[${sym.owner.name}] or protected instead.")
     if (sym.hasAnnotation(defn.NativeAnnot)) {
       if (!sym.is(Deferred))
         fail(NativeMembersMayNotHaveImplementation(sym))

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

@@ -2429,6 +2429,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     }
     val vdef1 = assignType(cpy.ValDef(vdef)(name, tpt1, rhs1), sym)
     postProcessInfo(sym)
+    binaryAPI(sym)
     vdef1.setDefTree
   }
 
@@ -2532,6 +2533,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     val ddef2 = assignType(cpy.DefDef(ddef)(name, paramss1, tpt1, rhs1), sym)
 
     postProcessInfo(sym)
+    binaryAPI(sym)
     ddef2.setDefTree
       //todo: make sure dependent method types do not depend on implicits or by-name params
   }
@@ -2545,6 +2547,11 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     if !sym.is(Module) && !sym.isConstructor && sym.info.finalResultType.isErasedClass then
       sym.setFlag(Erased)
 
+  /** Generate inline accessors for definitions annotated with @inlineAccessible */
+  def binaryAPI(sym: Symbol)(using Context): Unit =
+    if !ctx.isAfterTyper && !sym.is(Param) && sym.is(Private) && sym.hasAnnotation(defn.BinaryAPIAnnot) then
+      PrepareInlineable.makePrivateBinaryAPIAccessor(sym)
+
   def typedTypeDef(tdef: untpd.TypeDef, sym: Symbol)(using Context): Tree = {
     val TypeDef(name, rhs) = tdef
     completeAnnotations(tdef, sym)