Handle superAccessors in the presence of @TargetNAME

Author: odersky

compiler/src/dotty/tools/dotc/core/SymDenotations.scala

@@ -522,6 +522,9 @@ object SymDenotations {
           then carrier.unforcedAnnotation(defn.TargetNameAnnot)
           else carrier.getAnnotation(defn.TargetNameAnnot)
         myTargetName = computeTargetName(targetNameAnnot)
+        if name.is(SuperAccessorName) then
+          myTargetName = myTargetName.unmangle(List(ExpandedName, SuperAccessorName, ExpandPrefixName))
+
       myTargetName
 
     // ----- Tests -------------------------------------------------

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -2204,7 +2204,7 @@ import transform.SymUtils._
     def explain = ""
   }
 
-  class IllegalSuperAccessor(base: Symbol, memberName: Name,
+  class IllegalSuperAccessor(base: Symbol, memberName: Name, targetName: Name,
       acc: Symbol, accTp: Type,
       other: Symbol, otherTp: Type)(using Context) extends DeclarationMsg(IllegalSuperAccessorID) {
     def msg = {
@@ -2220,7 +2220,8 @@ import transform.SymUtils._
       // does in classes, i.e. followed the linearization of the trait itself.
       val staticSuperCall = {
         val staticSuper = accMixin.asClass.info.parents.reverse
-          .find(_.nonPrivateMember(memberName).matchingDenotation(accMixin.thisType, acc.info).exists)
+          .find(_.nonPrivateMember(memberName)
+            .matchingDenotation(accMixin.thisType, acc.info, targetName).exists)
         val staticSuperName = staticSuper match {
           case Some(parent) =>
             parent.classSymbol.name.show

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

@@ -82,20 +82,24 @@ object ResolveSuper {
     var bcs = base.info.baseClasses.dropWhile(acc.owner != _).tail
     var sym: Symbol = NoSymbol
 
-    var mix: Name = nme.EMPTY
-    val memberName = acc.name.unexpandedName match
-      case SuperAccessorName(ExpandPrefixName(name, mixName)) =>
-        mix = mixName.toTypeName
-        name
-      case SuperAccessorName(name) =>
-        name
+    def decomposeSuperName(superName: Name): (Name, TypeName) =
+      superName.unexpandedName match
+        case SuperAccessorName(ExpandPrefixName(name, mixName)) =>
+          (name, mixName.toTypeName)
+        case SuperAccessorName(name) =>
+          (name, EmptyTypeName)
+
+    val (memberName, mix) = decomposeSuperName(acc.name.unexpandedName)
+    val targetName =
+      if acc.name == acc.erasedName then memberName
+      else decomposeSuperName(acc.erasedName)._1
 
     report.debuglog(i"starting rebindsuper from $base of ${acc.showLocated}: ${acc.info} in $bcs, name = $memberName")
 
     while (bcs.nonEmpty && sym == NoSymbol) {
       val other = bcs.head.info.nonPrivateDecl(memberName)
         .filterWithPredicate(denot => mix.isEmpty || denot.symbol.owner.name == mix)
-        .matchingDenotation(base.thisType, base.thisType.memberInfo(acc))
+        .matchingDenotation(base.thisType, base.thisType.memberInfo(acc), targetName)
       report.debuglog(i"rebindsuper ${bcs.head} $other deferred = ${other.symbol.is(Deferred)}")
       if other.exists && !other.symbol.is(Deferred) then
         sym = other.symbol
@@ -104,11 +108,11 @@ object ResolveSuper {
         val otherTp = other.asSeenFrom(base.typeRef).info
         val accTp = acc.asSeenFrom(base.typeRef).info
         if (!(otherTp.overrides(accTp, matchLoosely = true)))
-          report.error(IllegalSuperAccessor(base, memberName, acc, accTp, other.symbol, otherTp), base.srcPos)
+          report.error(IllegalSuperAccessor(base, memberName, targetName, acc, accTp, other.symbol, otherTp), base.srcPos)
 
       bcs = bcs.tail
     }
-    assert(sym.exists)
+    assert(sym.exists, i"cannot rebind $acc, ${acc.erasedName} $memberName")
     sym
   }
 }

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

@@ -8,6 +8,8 @@ import ValueClasses.isMethodWithExtension
 import core._
 import Contexts._, Flags._, Symbols._, Names._, StdNames._, NameOps._, Trees._
 import TypeUtils._, SymUtils._
+import Constants.Constant
+import Annotations.Annotation
 import DenotTransformers.DenotTransformer
 import Symbols._
 import util.Spans._
@@ -67,11 +69,15 @@ class SuperAccessors(thisPhase: DenotTransformer) {
     val Select(qual, name) = sel
     val sym = sel.symbol
     val clazz = qual.symbol.asClass
-    val preName = if (mixName.isEmpty) name.toTermName else ExpandPrefixName(name.toTermName, mixName.toTermName)
-    var superName = SuperAccessorName(preName)
-    if (clazz.is(Trait)) superName = superName.expandedName(clazz)
-    val superInfo = sel.tpe.widenSingleton.ensureMethodic
 
+    def superAccessorName(original: Name) =
+      val unexpanded = SuperAccessorName(
+        if mixName.isEmpty then original.toTermName
+        else ExpandPrefixName(original.toTermName, mixName.toTermName))
+      if clazz.is(Trait) then unexpanded.expandedName(clazz) else unexpanded
+
+    val superName = superAccessorName(name)
+    val superInfo = sel.tpe.widenSingleton.ensureMethodic
     val accRange = sel.span.focus
     val superAcc = clazz.info.decl(superName)
       .suchThat(_.signature == superInfo.signature).symbol
@@ -81,6 +87,10 @@ class SuperAccessors(thisPhase: DenotTransformer) {
         val acc = newSymbol(
             clazz, superName, Artifact | Method | maybeDeferred,
             superInfo, coord = accRange).enteredAfter(thisPhase)
+        if !Denotations.targetNamesMatch(sym.name, sym.erasedName) then
+          acc.addAnnotation(
+            Annotation(defn.TargetNameAnnot,
+              Literal(Constant(superAccessorName(sym.erasedName).toString)).withSpan(sym.span)))
         // Diagnostic for SI-7091
         if (!accDefs.contains(clazz))
           report.error(

tests/run/supercalls-traits-targetname.check

@@ -0,0 +1,5 @@
+C1A1A2B1B2C2
+C1B3B4C3
+IT
+AT
+ER

tests/run/supercalls-traits-targetname.scala

@@ -0,0 +1,57 @@
+import annotation.targetName
+
+trait A {
+ @targetName("foo2") def foo = 1
+}
+
+trait B {
+ @targetName("foo2") def foo = 2
+}
+
+class C extends A with B {
+ @targetName("foo2") override def foo = super[A].foo + super[B].foo
+}
+
+class Base[A](exp: => Option[A])
+
+object Empty extends Base[Nothing](None)
+
+
+trait B1 extends C1 { @targetName("f2") override def f() = { super.f(); print("B1") }}
+trait B2 extends B1 { @targetName("f2") override def f() = { super.f(); print("B2") }}
+trait A1 extends C1 { @targetName("f2") override def f() = { super.f(); print("A1") }}
+trait A2 extends A1 { @targetName("f2") override def f() = { super.f(); print("A2") }}
+class C1 { @targetName("f2") def f() = print("C1") }
+class C2 extends A2 with B2 { @targetName("f2") override def f() = { super.f(); print("C2") }}
+
+
+trait B3 extends C1 { @targetName("f2") override def f() = { super.f(); print("B3") }}
+trait B4 extends C1 { this: B3 =>  @targetName("f2") override def f() = { super.f(); print("B4") }}
+class C3 extends C1 with B3 with B4 { @targetName("f2") override def f() = { super.f(); print("C3") }}
+
+trait DT {
+  @targetName("f2") def f(): Unit
+}
+trait IT extends DT {
+  @targetName("f2") def f() = { println("IT") }
+}
+abstract class MPT {
+}
+trait AT extends MPT with DT {
+  @targetName("f2") abstract override def f() = { super.f(); println("AT") }
+}
+class ER extends MPT with IT with AT {
+  @targetName("f2") override def f() = { super.f(); println("ER") }
+}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    assert(new C().foo == 3)
+    new C2().f()
+    println()
+    new C3().f()
+    println()
+    new ER().f()
+    Empty
+  }
+}