Emit generic signatures for all trait fields

compiler/src/dotty/tools/backend/jvm/BCodeHelpers.scala

@@ -319,7 +319,7 @@ trait BCodeHelpers(val backendUtils: BackendUtils)(using ctx: Context) extends B
           // Mixins are resolved _after_ erasure, so we cannot simply ask for "the information before erasure" for these,
           // since that information never existed.
           // Thus, we first check if the symbol was specifically marked as having generic information,
-          if sym.is(MixedIn) then mixinPhase.asInstanceOf[Mixin].mixinGenericInfos.get(sym) match
+          mixinPhase.asInstanceOf[Mixin].mixinGenericInfos.get(sym) match
             // and if so, we use it.
             case Some(genericInfo) => return genericInfo
             case _ => ()

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

@@ -6,7 +6,6 @@ import core.*
 import MegaPhase.*
 import Contexts.*
 import Flags.*
-
 import Symbols.*
 import SymDenotations.*
 import Types.*
@@ -18,7 +17,6 @@ import NameKinds.*
 import NameOps.*
 import Phases.erasurePhase
 import ast.Trees.*
-
 import dotty.tools.dotc.transform.sjs.JSSymUtils.isJSType
 
 object Mixin {
@@ -166,6 +164,8 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
           val setter = makeTraitSetter(decl.asTerm)
           setter.validFor = thisPhase.validFor // validity of setter = next phase up to next transformer afterwards
           decls1.enter(setter)
+          // Re-create the setter from the unerased getter so we can have its unerased form for generic signatures
+          mixinGenericInfos(setter) = atPhase(erasurePhase) { makeTraitSetter(decl.asTerm).info }
           modified = true
       if modified then
         sym.copySymDenotation(
@@ -297,8 +297,11 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
               Underscore(getter.info.resultType)
           // transformFollowing call is needed to make memoize & lazy vals run
           val forwarder = mkForwarderSym(getter.asTerm)
-          val erased = atPhase(erasurePhase) { cls.thisType.memberInfo(getter) }
-          mixinGenericInfos(forwarder) = erased
+          // Store the unerased form for generic signature use later,
+          // but only if it's not private (which we must check at erasure time, as here we've removed that flag already),
+          // since otherwise it might refer to private classes
+          if atPhase(erasurePhase) { !getter.is(Private) } then
+            mixinGenericInfos(forwarder) = atPhase(erasurePhase) { cls.thisType.memberInfo(getter) }
           transformFollowing(DefDef(forwarder, rhs))
         }
         else if wasOneOf(getter, ParamAccessor) then
@@ -311,8 +314,13 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
       val mixinSetters = mixin.info.decls.filter { sym =>
         sym.isSetter && (!wasOneOf(sym, Deferred) || sym.name.is(TraitSetterName))
       }
-      for (setter <- mixinSetters)
-      yield transformFollowing(DefDef(mkForwarderSym(setter.asTerm), unitLiteral.withSpan(cls.span)))
+      mixinSetters.map(setter => {
+        val copied = transformFollowing(DefDef(mkForwarderSym(setter.asTerm), unitLiteral.withSpan(cls.span)))
+        mixinGenericInfos.get(setter) match
+          case Some(gi) => mixinGenericInfos(copied.symbol) = gi
+          case None => ()
+        copied
+      })
 
     def mixinForwarders(mixin: ClassSymbol): List[Tree] =
       for meth <- mixin.info.decls.filter(d => needsMixinForwarder(mixin, d))

tests/generic-java-signatures/trait-field-generic-signature-class.check

@@ -0,0 +1,4 @@
+public void Bar.Foo$_setter_$foo_$eq(scala.Option)
+public void Bar.Foo$_setter_$foo_$eq(scala.Option<java.lang.String>)
+public scala.Option Bar.foo()
+public scala.Option<java.lang.String> Bar.foo()

tests/generic-java-signatures/trait-field-generic-signature-class.scala

@@ -0,0 +1,11 @@
+trait Foo {
+  val foo: Option[String] = ???
+}
+class Bar extends Foo
+
+object Test:
+  def main(args: Array[String]): Unit =
+    classOf[Bar].getMethods.sortBy(_.getName).filter(_.getName.contains("foo")).foreach(m => {
+      println(m)
+      println(m.toGenericString)
+    })

tests/generic-java-signatures/trait-field-generic-signature-object.check

@@ -0,0 +1,10 @@
+Foo:
+public abstract void Foo.Foo$_setter_$foo_$eq(scala.Option)
+public abstract void Foo.Foo$_setter_$foo_$eq(scala.Option<java.lang.String>)
+public abstract scala.Option Foo.foo()
+public abstract scala.Option<java.lang.String> Foo.foo()
+bar:
+public void bar$.Foo$_setter_$foo_$eq(scala.Option)
+public void bar$.Foo$_setter_$foo_$eq(scala.Option<java.lang.String>)
+public scala.Option bar$.foo()
+public scala.Option<java.lang.String> bar$.foo()

tests/generic-java-signatures/trait-field-generic-signature-object.scala

@@ -0,0 +1,18 @@
+trait Foo {
+  val foo: Option[String] = ???
+}
+object bar extends Foo
+
+object Test:
+  def main(args: Array[String]): Unit =
+    println("Foo:")
+    classOf[Foo].getMethods.sortBy(_.getName).filter(_.getName.contains("foo")).foreach(m => {
+      println(m)
+      println(m.toGenericString)
+    })
+    println("bar:")
+    classOf[bar.type].getMethods.sortBy(_.getName).filter(_.getName.contains("foo")).foreach(m => {
+      println(m)
+      println(m.toGenericString)
+    })
+

tests/pos/private-class-in-trait.scala

@@ -0,0 +1,12 @@
+trait T {
+  private val classValue = new PrivateClass
+  private val objectValue = PrivateObject
+
+  private val classOption: Option[PrivateClass] = Some(new PrivateClass)
+  private val objectOption: Option[PrivateObject.type] = Some(PrivateObject)
+
+  private class PrivateClass
+  private object PrivateObject
+}
+
+object Test extends T