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,23 @@ 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
+                val outerAccessibleClass =
+                  if tree.symbol.privateWithin.maybeOwner.exists && !tree.symbol.privateWithin.maybeOwner.isTopLevelClass then
+                    tree.symbol.privateWithin
+                  else ctx.owner.topLevelClass
+                if outerAccessibleClass.is(Module) then outerAccessibleClass
+                else if outerAccessibleClass.companionClass.exists then outerAccessibleClass.companionClass
+                else
+                  report.error(em"Cannot create inline accessor for $tree.\n\nThis can be fixed by creating a companion object for $outerAccessibleClass", tree.srcPos)
+                  outerAccessibleClass // Not the correct owner. Should we generate a static owner?
+
+              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

@@ -66,8 +66,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 +130,18 @@ 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, accessorClass0: Symbol)(using Context): Tree = {
       val accessed = reference.symbol.asTerm
-      var accessorClass = hostForAccessorOf(accessed: Symbol)
+      var accessorClass = accessorClass0 // TODO remove
       if (accessorClass.exists) {
-        if accessorClass.is(Package) then
-          accessorClass = ctx.owner.topLevelClass
-        val accessorName = accessorNameOf(accessed.name, accessorClass)
+        if accessorClass.is(Package) then // TODO can this be removed? Was it added only for inline accessors?
+          val topClass = ctx.owner.topLevelClass
+          if topClass.companionClass.exists then
+            accessorClass = topClass.companionClass
+          else
+            accessorClass = topClass // Not the correct owner. Should we generate a static owner?
+            report.error(em"Cannot create inline accessor for $reference.\n\nThis can be fixed by creating a companion object for $accessorClass", reference.srcPos)
+        val accessorName = accessorNameOf(accessed, accessorClass)
         val accessorInfo =
           accessed.info.ensureMethodic.asSeenFrom(accessorClass.thisType, accessed.owner)
         val accessor = accessorSymbol(accessorClass, accessorName, accessorInfo, accessed)
@@ -152,7 +157,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 +176,23 @@ object AccessProxies {
       else recur(cls.owner)
     recur(ctx.owner)
   }
+
+  /** Where an accessor for the `accessed` symbol should be placed.
+   *  This is the furthest enclosing class that has `accessed` as a member.
+   */
+  def outerHostForAccessorOf(accessed: Symbol)(using Context): Symbol = {
+    println()
+    println(s"accessed: $accessed")
+    def recur(cls: Symbol): Symbol =
+      println(s"cls: $cls")
+      if (!cls.exists) NoSymbol
+      else if cls.derivesFrom(accessed.owner)
+              || cls.companionModule.moduleClass == accessed.owner
+      then cls
+      else recur(cls.owner)
+    val res = recur(ctx.owner)
+    println(s"res: $res")
+    println(" ")
+    res
+  }
 }

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 = {

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

@@ -212,11 +212,12 @@ object Splicer {
           args.flatten.foreach(checkIfValidArgument)
 
         case _ =>
-          report.error(
-            """Malformed macro.
-              |
-              |Expected the splice ${...} to contain a single call to a static method.
-              |""".stripMargin, tree.srcPos)
+
+          // report.error(
+          //   """Malformed macro.
+          //     |
+          //     |Expected the splice ${...} to contain a single call to a static method.
+          //     |""".stripMargin, tree.srcPos)
       }
 
       checkIfValidStaticCall(tree)(using Set.empty)

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,4 @@
 A.f
 A.B.f
 A.B.C.f
+A.B.D.f

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

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

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

@@ -5,5 +5,6 @@ object Test {
     A.f
     A.B.f
     A.B.C.f
+    A.B.D.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)