Generate static inline accessors in the outermost scope

Fixes #13215
Fixes #15413

Author: nicolasstucki

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

@@ -53,7 +53,8 @@ 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 accessorNameOf(name: TermName, site: Symbol)(using Context): TermName =
+      def accessorNameOf(sym: Symbol, site: Symbol)(using Context): TermName =
+        val name = if sym.owner.isStaticOwner then sym.flatName.asTermName else sym.name.asTermName
         val accName = InlineAccessorName(name)
         if site.isExtensibleClass then accName.expandedName(site) else accName
 
@@ -107,7 +108,12 @@ object PrepareInlineable {
             report.error("Implementation restriction: cannot use private constructors in inline methods", tree.srcPos)
             tree // TODO: create a proper accessor for the private constructor
           }
-          else useAccessor(tree)
+          else
+            val accessorClass =
+              if tree.symbol.owner.isStaticOwner then AccessProxies.staticHostForAccessorOf(tree.symbol, tree.srcPos)
+              else AccessProxies.hostForAccessorOf(tree.symbol)
+            // TODO generate old accessor for binary compat?
+            useAccessor(tree, accessorClass)
         case _ =>
           tree
       }

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

@@ -13,6 +13,7 @@ import TypeUtils._
 import Types._
 import util.Spans.Span
 import config.Printers.transforms
+import dotty.tools.dotc.util.SrcPos
 
 /** A utility class for generating access proxies. Currently used for
  *  inline accessors and protected accessors.
@@ -66,8 +67,8 @@ abstract class AccessProxies {
   trait Insert {
     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
+    /** The name of the accessor for definition with given accessed `sym` in given `site` */
+    def accessorNameOf(sym: Symbol, site: Symbol)(using Context): TermName
     def needsAccessor(sym: Symbol)(using Context): Boolean
 
     def ifNoHost(reference: RefTree)(using Context): Tree = {
@@ -130,13 +131,10 @@ abstract class AccessProxies {
       *  @param reference    The original reference to the non-public symbol
       *  @param onLHS        The reference is on the left-hand side of an assignment
       */
-    def useAccessor(reference: RefTree)(using Context): Tree = {
+    def useAccessor(reference: RefTree, accessorClass: Symbol)(using Context): Tree = {
       val accessed = reference.symbol.asTerm
-      var accessorClass = hostForAccessorOf(accessed: Symbol)
       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)
@@ -152,7 +150,7 @@ abstract class AccessProxies {
           report.error("Implementation restriction: cannot use private constructors in inlineable methods", tree.srcPos)
           tree // TODO: create a proper accessor for the private constructor
         }
-        else useAccessor(tree)
+        else useAccessor(tree, hostForAccessorOf(tree.symbol))
       case _ =>
         tree
     }
@@ -171,4 +169,22 @@ object AccessProxies {
       else recur(cls.owner)
     recur(ctx.owner)
   }
+
+  /** Where an accessor for the `accessed` symbol should be placed.
+   *  This is the furthest static enclosing class that has `accessed` as a member.
+   */
+  def staticHostForAccessorOf(accessed: Symbol, srcPos: SrcPos)(using Context): Symbol = {
+    val outerAccessibleClass =
+      if accessed.privateWithin.maybeOwner.exists && !accessed.privateWithin.maybeOwner.isTopLevelClass then
+        accessed.privateWithin
+      else ctx.owner.topLevelClass
+    if outerAccessibleClass.is(Module) then
+      outerAccessibleClass
+    else if outerAccessibleClass.companionClass.exists then
+      outerAccessibleClass.companionClass
+    else
+      // Should we generate a static owner? Generate companion class of the current top level class.
+      report.error(em"Cannot create inline accessor for $accessed.\n\nThis can be fixed by creating a companion object for ${outerAccessibleClass}", srcPos)
+      NoSymbol
+  }
 }

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(sym: Symbol, site: Symbol)(using Context): TermName = ProtectedAccessorName(sym.name.asTermName)
       def needsAccessor(sym: Symbol)(using Context) = ProtectedAccessors.needsAccessor(sym)
 
       override def ifNoHost(reference: RefTree)(using Context): Tree = {

tests/pos-macros/i15413/Macro_1.scala

@@ -0,0 +1,7 @@
+import scala.quoted.*
+
+class Macro:
+  inline def foo = ${ Macro.fooImpl }
+
+object Macro:
+  private def fooImpl(using Quotes) = '{}

tests/pos-macros/i15413/Test_2.scala

@@ -0,0 +1,2 @@
+def test =
+  new Macro().foo

tests/pos-macros/i15413b/Macro_1.scala

@@ -0,0 +1,5 @@
+import scala.quoted.*
+
+inline def foo = ${ fooImpl }
+
+private def fooImpl(using Quotes) = '{}

tests/pos-macros/i15413b/Test_2.scala

@@ -0,0 +1 @@
+def test = foo

tests/run-macros/inline-macro-inner-object.check

@@ -1,3 +1,5 @@
 A.f
 A.B.f
 A.B.C.f
+A.B.D.f
+A.B.E.f

tests/run-macros/inline-macro-inner-object/Macro_1.scala

@@ -18,5 +18,19 @@ object A {
         '{println("A.B.C.f")}
       }
     }
+
+    object D {
+      inline def f: Unit = ${impl}
+      private[D] def impl(using Quotes): Expr[Unit] = {
+        '{println("A.B.D.f")}
+      }
+    }
+
+    object E {
+      inline def f: Unit = ${impl}
+      private[A] def impl(using Quotes): Expr[Unit] = {
+        '{println("A.B.E.f")}
+      }
+    }
   }
 }

tests/run-macros/inline-macro-inner-object/Test_2.scala

@@ -5,5 +5,7 @@ object Test {
     A.f
     A.B.f
     A.B.C.f
+    A.B.D.f
+    A.B.E.f
   }
 }

tests/run/i13215.check

@@ -0,0 +1 @@
+public foo.Baz$ foo.Bar$.inline$Baz()

tests/run/i13215.scala

@@ -0,0 +1,10 @@
+package foo {
+  trait Bar:
+    inline def baz = Baz
+  object Bar // TODO can this requirement be removed?
+
+  private[foo] object Baz
+}
+
+@main def Test: Unit =
+  foo.Bar.getClass.getMethods.filter(_.getName.contains("Baz")).foreach(println)