SI-3452 Correct Java generic signatures for mixins, static forwarders

This took me so long to figure out I can't even tell you. Partly because
there were two different bugs, one which only arose for trait forwarders
and one for mirror class forwarders, and every time I'd make one set
of tests work another set would start failing. The runtime failures
associated with these bugs were fairly well hidden because you usually
have to go through java to encounter them: scala doesn't pay that much
attention to generic signatures, so they can be wrong and scala might still
generate correct code. But java is not so lucky.

Bug #1)

During mixin composition, classes which extend traits receive forwarders
to the implementations. An attempt was made to give these the correct
info (in method "cloneBeforeErasure") but it was prone to giving
the wrong answer, because: the key attribute which the forwarder
must capture is what the underlying method will erase to *where the
implementation is*, not how it appears to the class which contains it.
That means the signature of the forwarder must be no more precise than
the signature of the inherited implementation unless additional measures
will be taken.

This subtle difference will put on an unsubtle show for you in test
run/t3452.scala.

  trait C[T]
  trait Search[M] { def search(input: M): C[Int] = null }
  object StringSearch extends Search[String] { }
  StringSearch.search("test");  // java
  // java.lang.NoSuchMethodError: StringSearch.search(Ljava/lang/String;)LC;

This commit creates a bridge method to match the erased interface
signature exactly. This forwards to a method with a more refined
signature.

Bug #2) The same principle is at work, at a different location.
During genjvm, objects without declared companion classes
are given static forwarders in the corresponding class, e.g.

  object Foo { def bar = 5 }

which creates these classes (taking minor liberties):

  class Foo$ { static val MODULE$ = new Foo$ ; def bar = 5 }
  class Foo  { static def bar = Foo$.MODULE$.bar }

In generating these, genjvm circumvented the usual process whereby one
creates a symbol and gives it an info, preferring to target the bytecode
directly. However generic signatures are calculated from symbol info
(in this case reusing the info from the module class.) Lacking even the
attempt which was being made in mixin to "clone before erasure", we
would have runtime failures of this kind:

  abstract class Foo {
    type T
    def f(x: T): List[T] = List()
  }
  object Bar extends Foo { type T = String }
  Bar.f("");    // java
  // java.lang.NoSuchMethodError: Bar.f(Ljava/lang/String;)Lscala/collection/immutable/List;

Before/after this commit:

<   signature                                     f  (Ljava/lang/String;)Lscala/collection/immutable/List<Ljava/lang/String;>;
---
>   signature                                     f  (Ljava/lang/Object;)Lscala/collection/immutable/List<Ljava/lang/Object;>;

Closes SI-3452.

fail

Author: paulp

src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala

@@ -1061,7 +1061,18 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM {
       )
 
       // TODO needed? for(ann <- m.annotations) { ann.symbol.initialize }
-      val jgensig = if (m.isDeferred) null else getGenericSignature(m, module); // only add generic signature if method concrete; bug #1745
+      val jgensig = (
+        // only add generic signature if method concrete; bug #1745
+        if (m.isDeferred) null else {
+          val clazz = module.linkedClassOfClass
+          val m1 = (
+            if ((clazz.info member m.name) eq NoSymbol)
+              enteringErasure(m.cloneSymbol(clazz, Flags.METHOD | Flags.STATIC))
+            else m
+          )
+          getGenericSignature(m1, clazz)
+        }
+      )
       addRemoteExceptionAnnot(isRemoteClass, hasPublicBitSet(flags), m)
       val (throws, others) = m.annotations partition (_.symbol == ThrowsClass)
       val thrownExceptions: List[String] = getExceptions(throws)

src/compiler/scala/tools/nsc/transform/Erasure.scala

@@ -444,30 +444,18 @@ abstract class Erasure extends AddInterfaces
       val other  = high
       val otpe   = highErased
 
-      val bridgeNeeded = exitingErasure (
-        !member.isMacro &&
-        !(other.tpe =:= member.tpe) &&
-        !(deconstMap(other.tpe) =:= deconstMap(member.tpe)) &&
-        { var e = bridgesScope.lookupEntry(member.name)
-          while ((e ne null) && !((e.sym.tpe =:= otpe) && (bridgeTarget(e.sym) == member)))
-            e = bridgesScope.lookupNextEntry(e)
-          (e eq null)
-        }
-      )
+      val bridgeNeeded = isBridgeNeeded(pair) && {
+        var e = bridgesScope.lookupEntry(member.name)
+        while ((e ne null) && !((e.sym.tpe =:= otpe) && (bridgeTarget(e.sym) == member)))
+          e = bridgesScope.lookupNextEntry(e)
+        (e eq null)
+      }
+
       if (!bridgeNeeded)
         return
 
-      val newFlags = (member.flags | BRIDGE | ARTIFACT) & ~(ACCESSOR | DEFERRED | LAZY | lateDEFERRED)
-      val bridge   = other.cloneSymbolImpl(root, newFlags) setPos root.pos
+      val bridge   = makeBridgeSymbol(root, pair)
 
-      debuglog("generating bridge from %s (%s): %s to %s: %s".format(
-        other, flagsToString(newFlags),
-        otpe + other.locationString, member,
-        specialErasure(root)(member.tpe) + member.locationString)
-      )
-
-      // the parameter symbols need to have the new owner
-      bridge setInfo (otpe cloneInfo bridge)
       bridgeTarget(bridge) = member
 
       if (!(member.tpe exists (_.typeSymbol.isDerivedValueClass)) ||
@@ -479,46 +467,79 @@ abstract class Erasure extends AddInterfaces
         }
 
         bridgesScope enter bridge
-        bridges ::= makeBridgeDefDef(bridge, member, other)
+        bridges ::= makeBridgeDefDef(bridge, pair)
       }
     }
 
-    def makeBridgeDefDef(bridge: Symbol, member: Symbol, other: Symbol) = exitingErasure {
-      // type checking ensures we can safely call `other`, but unless `member.tpe <:< other.tpe`,
-      // calling `member` is not guaranteed to succeed in general, there's
-      // nothing we can do about this, except for an unapply: when this subtype test fails,
-      // return None without calling `member`
-      //
-      // TODO: should we do this for user-defined unapplies as well?
-      // does the first argument list have exactly one argument -- for user-defined unapplies we can't be sure
-      def maybeWrap(bridgingCall: Tree): Tree = {
-        val guardExtractor = ( // can't statically know which member is going to be selected, so don't let this depend on member.isSynthetic
-             (member.name == nme.unapply || member.name == nme.unapplySeq)
-          && !exitingErasure((member.tpe <:< other.tpe))) // no static guarantees (TODO: is the subtype test ever true?)
-
-        import CODE._
-        val _false    = FALSE
-        val pt        = member.tpe.resultType
-        lazy val zero =
-          if      (_false.tpe <:< pt)    _false
-          else if (NoneModule.tpe <:< pt) REF(NoneModule)
-          else EmptyTree
-
-        if (guardExtractor && (zero ne EmptyTree)) {
-          val typeTest = gen.mkIsInstanceOf(REF(bridge.firstParam), member.tpe.params.head.tpe)
-          IF (typeTest) THEN bridgingCall ELSE zero
-        } else bridgingCall
-      }
-      val rhs = member.tpe match {
-        case MethodType(Nil, ConstantType(c)) => Literal(c)
-        case _                                =>
-          val sel: Tree    = Select(This(root), member)
-          val bridgingCall = (sel /: bridge.paramss)((fun, vparams) => Apply(fun, vparams map Ident))
+    def makeBridgeDefDef(bridge: Symbol, pair: SymbolPair): Tree =
+      Erasure.this.makeBridgeDefDef(root, bridge, pair)
+  }
 
-          maybeWrap(bridgingCall)
-      }
-      DefDef(bridge, rhs)
+  final def isBridgeNeeded(pair: SymbolPair): Boolean = {
+    val member = pair.low
+    val other = pair.high
+    exitingErasure(
+         !member.isMacro
+      && !(other.tpe =:= member.tpe)
+      && !(deconstMap(other.tpe) =:= deconstMap(member.tpe))
+    )
+  }
+
+  final def makeBridgeSymbol(root: Symbol, pair: SymbolPair): Symbol = {
+    import pair._
+    val member = low
+    val other  = high
+    val otpe   = highErased
+    val newFlags = (member.flags | BRIDGE | ARTIFACT) & ~(ACCESSOR | DEFERRED | LAZY | lateDEFERRED)
+    val bridge   = pair.low.cloneSymbolImpl(root, newFlags) setPos root.pos
+
+    debuglog("generating bridge from %s (%s): %s to %s: %s".format(
+      other, flagsToString(newFlags),
+      otpe + other.locationString, member,
+      specialErasure(root)(member.tpe) + member.locationString)
+    )
+
+    // the parameter symbols need to have the new owner
+    bridge setInfo (otpe cloneInfo bridge)
+  }
+
+  final def makeBridgeDefDef(root: Symbol, bridge: Symbol, pair: SymbolPair): DefDef = exitingErasure {
+    val member = pair.low
+    val other = pair.high
+    // type checking ensures we can safely call `other`, but unless `member.tpe <:< other.tpe`,
+    // calling `member` is not guaranteed to succeed in general, there's
+    // nothing we can do about this, except for an unapply: when this subtype test fails,
+    // return None without calling `member`
+    //
+    // TODO: should we do this for user-defined unapplies as well?
+    // does the first argument list have exactly one argument -- for user-defined unapplies we can't be sure
+    def maybeWrap(bridgingCall: Tree): Tree = {
+      val guardExtractor = ( // can't statically know which member is going to be selected, so don't let this depend on member.isSynthetic
+           (member.name == nme.unapply || member.name == nme.unapplySeq)
+        && !exitingErasure((member.tpe <:< other.tpe))) // no static guarantees (TODO: is the subtype test ever true?)
+
+      import CODE._
+      val _false    = FALSE
+      val pt        = member.tpe.resultType
+      lazy val zero =
+        if      (_false.tpe <:< pt)    _false
+        else if (NoneModule.tpe <:< pt) REF(NoneModule)
+        else EmptyTree
+
+      if (guardExtractor && (zero ne EmptyTree)) {
+        val typeTest = gen.mkIsInstanceOf(REF(bridge.firstParam), member.tpe.params.head.tpe)
+        IF (typeTest) THEN bridgingCall ELSE zero
+      } else bridgingCall
+    }
+    val rhs = member.tpe match {
+      case MethodType(Nil, ConstantType(c)) => Literal(c)
+      case _                                =>
+        val sel: Tree    = Select(This(root), member)
+        val bridgingCall = (sel /: bridge.paramss)((fun, vparams) => Apply(fun, vparams map Ident))
+
+        maybeWrap(bridgingCall)
     }
+    DefDef(bridge, rhs)
   }
 
   /** The modifier typer which retypes with erased types. */

src/compiler/scala/tools/nsc/transform/Mixin.scala

@@ -162,28 +162,43 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
     debuglog("new member of " + clazz + ":" + member.defString)
     clazz.info.decls enter member setFlag MIXEDIN
   }
+
   def cloneAndAddMember(mixinClass: Symbol, mixinMember: Symbol, clazz: Symbol): Symbol =
     addMember(clazz, cloneBeforeErasure(mixinClass, mixinMember, clazz))
 
+  private val bridgeTo = perRunCaches.newMap[Symbol, SymbolPair]()
+
   def cloneBeforeErasure(mixinClass: Symbol, mixinMember: Symbol, clazz: Symbol): Symbol = {
     val newSym = enteringErasure {
       // since we used `mixinMember` from the interface that represents the trait that's
       // being mixed in, have to instantiate the interface type params (that may occur in mixinMember's
       // info) as they are seen from the class.  We can't use the member that we get from the
       // implementation class, as it's a clone that was made after erasure, and thus it does not
       // know its info at the beginning of erasure anymore.
-      //   Optimize: no need if mixinClass has no typeparams.
-      mixinMember cloneSymbol clazz modifyInfo (info =>
-        if (mixinClass.typeParams.isEmpty) info
-        else (clazz.thisType baseType mixinClass) memberInfo mixinMember
-      )
+      val sym = mixinMember cloneSymbol clazz
+
+      def forwarderInfo(forwardee: Type): Type =
+        (clazz.thisType baseType mixinClass) memberInfo mixinMember
+      // Optimize: no need if mixinClass has no typeparams.
+      val result =
+        if (mixinClass.typeParams.isEmpty) sym
+        else sym modifyInfo (info => forwarderInfo(info))
+
+      // Add a bridge, if needed.
+      val root = sym.owner
+      val pair = new SymbolPair(root, sym, mixinMember)
+      if (erasure.isBridgeNeeded(pair)) {
+        log("bridge needed for: " + pair)
+        val bridgeSym = erasure.makeBridgeSymbol(root, pair)
+        enteringMixin {
+          addMember(clazz, bridgeSym)
+        }
+        bridgeTo(bridgeSym) = pair
+      }
+
+      result
     }
-    // clone before erasure got rid of type info we'll need to generate a javaSig
-    // now we'll have the type info at (the beginning of) erasure in our history,
-    // and now newSym has the info that's been transformed to fit this period
-    // (no need for asSeenFrom as phase.erasedTypes)
-    // TODO: verify we need the updateInfo and document why
-    newSym updateInfo (mixinMember.info cloneInfo newSym)
+    newSym
   }
 
   /** Add getters and setters for all non-module fields of an implementation
@@ -269,8 +284,14 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
         val imember = member overriddenSymbol mixinInterface
         imember overridingSymbol clazz match {
           case NoSymbol =>
-            if (clazz.info.findMember(member.name, 0, lateDEFERRED, stableOnly = false).alternatives contains imember)
-              cloneAndAddMixinMember(mixinInterface, imember).asInstanceOf[TermSymbol] setAlias member
+            if (clazz.info.findMember(member.name, 0, lateDEFERRED, stableOnly = false).alternatives contains imember) {
+              val forwarder = cloneAndAddMixinMember(mixinInterface, imember).asInstanceOf[TermSymbol] setAlias member
+              log("Adding forwarder from %s to %s during mixin:\n  before erasure: %s => %s\n   after erasure: %s => %s".format(
+                clazz, member.owner,
+                enteringErasure(forwarder.defString), enteringErasure(member.defString),
+                forwarder.defString, member.defString)
+              )
+            }
           case _        =>
         }
       }
@@ -1076,11 +1097,20 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
             // add superaccessors
             addDefDef(sym)
           }
+          else if (sym.isBridge) {
+            val bridge = sym
+            val root = sym.owner
+            val pair = bridgeTo(bridge)
+            val bridgeDefDef = erasure.makeBridgeDefDef(root, bridge, pair)
+            addDefDef(bridge, localTyper.typed(bridgeDefDef.rhs, bridge.tpe.finalResultType)) // TODO run erasure tree transformer over this?
+          }
           else {
             // add forwarders
             assert(sym.alias != NoSymbol, sym)
             // debuglog("New forwarder: " + sym.defString + " => " + sym.alias.defString)
-            if (!sym.isMacro) addDefDef(sym, Apply(staticRef(sym.alias), gen.mkAttributedThis(clazz) :: sym.paramss.head.map(Ident)))
+            if (!sym.isMacro) {
+              addDefDef(sym, Apply(staticRef(sym.alias), gen.mkAttributedThis(clazz) :: sym.paramss.head.map(Ident)))
+            }
           }
         }
       }

test/files/neg/t4749.check

@@ -25,6 +25,10 @@ t4749.scala:26: warning: Fail6 has a main method with parameter type Array[Strin
 
   object Fail6 {
          ^
+t4749.scala:35: warning: Fail7 has a main method with parameter type Array[String], but bippy.Fail7 will not be a runnable program.
+  Reason: main methods cannot refer to type parameters or abstract types.
+  object Fail7 extends FailBippy[Unit] { }
+         ^
 error: No warnings can be incurred under -Xfatal-warnings.
-6 warnings found
+7 warnings found
 one error found

test/files/neg/t4749.scala

@@ -29,16 +29,16 @@ package bippy {
   class Fail6 {
     def main = "bippy"
   }
+  trait FailBippy[T] {
+    def main(args: Array[String]): T = null.asInstanceOf[T]
+  }
+  object Fail7 extends FailBippy[Unit] { }
 
   object Win1 {
     def main(args: Array[String]): Unit = ()
   }
   object Win2 extends Bippy[Unit] {
     override def main(args: Array[String]): Unit = ()
   }
-  trait WinBippy[T] {
-    def main(args: Array[String]): T = null.asInstanceOf[T]
-  }
-  object Win3 extends WinBippy[Unit] { }
 }
 

test/files/pos/t3452f.scala

@@ -0,0 +1,10 @@
+class Base[Coll] {
+  trait Transformed[S] {
+    lazy val underlying: Coll = ???
+  }
+}
+
+class Derived extends Base[String] {
+  class C extends Transformed[Any]
+}
+

test/files/run/mixin-signatures.check

@@ -0,0 +1,68 @@
+class Test$bar1$ {
+  public java.lang.String Test$bar1$.f(java.lang.String)
+  public java.lang.Object Test$bar1$.f(java.lang.Object) <bridge> <synthetic>
+  public java.lang.String Test$bar1$.f(java.lang.Object) <bridge> <synthetic>
+  public java.lang.String Test$bar1$.g(java.lang.String)
+  public java.lang.Object Test$bar1$.g(java.lang.Object) <bridge> <synthetic>
+  public java.lang.String Test$bar1$.g(java.lang.Object) <bridge> <synthetic>
+  public java.lang.String Test$bar1$.h(java.lang.String)
+  public java.lang.Object Test$bar1$.h(java.lang.Object) <bridge> <synthetic>
+}
+
+class Test$bar2$ {
+  public java.lang.String Test$bar2$.f(java.lang.String)
+  public java.lang.Object Test$bar2$.f(java.lang.Object) <bridge> <synthetic>
+  public java.lang.Object Test$bar2$.f(java.lang.String) <bridge> <synthetic>
+  public java.lang.String Test$bar2$.g(java.lang.String)
+  public java.lang.Object Test$bar2$.g(java.lang.Object) <bridge> <synthetic>
+  public java.lang.Object Test$bar2$.g(java.lang.String) <bridge> <synthetic>
+  public java.lang.String Test$bar2$.h(java.lang.String)
+  public java.lang.Object Test$bar2$.h(java.lang.Object) <bridge> <synthetic>
+}
+
+class Test$bar3$ {
+  public java.lang.String Foo3.f(java.lang.Object)
+    generic: public java.lang.String Foo3.f(T)
+  public java.lang.Object Foo3.f(java.lang.Object) <bridge> <synthetic>
+  public java.lang.String Test$bar3$.g(java.lang.String)
+  public java.lang.Object Test$bar3$.g(java.lang.Object) <bridge> <synthetic>
+  public java.lang.String Test$bar3$.g(java.lang.Object) <bridge> <synthetic>
+  public java.lang.String Foo3.h(java.lang.Object)
+    generic: public java.lang.String Foo3.h(T)
+  public java.lang.Object Foo3.h(java.lang.Object) <bridge> <synthetic>
+}
+
+class Test$bar4$ {
+  public java.lang.Object Foo4.f(java.lang.String)
+    generic: public R Foo4.f(java.lang.String)
+  public java.lang.Object Foo4.f(java.lang.Object) <bridge> <synthetic>
+  public java.lang.String Test$bar4$.g(java.lang.String)
+  public java.lang.Object Test$bar4$.g(java.lang.Object) <bridge> <synthetic>
+  public java.lang.Object Test$bar4$.g(java.lang.String) <bridge> <synthetic>
+  public java.lang.Object Foo4.h(java.lang.String)
+    generic: public R Foo4.h(java.lang.String)
+  public java.lang.Object Foo4.h(java.lang.Object) <bridge> <synthetic>
+}
+
+class Test$bar5$ {
+  public java.lang.String Test$bar5$.f(java.lang.String)
+  public java.lang.Object Test$bar5$.f(java.lang.Object) <bridge> <synthetic>
+  public java.lang.Object Test$bar5$.f(java.lang.String) <bridge> <synthetic>
+  public java.lang.String Test$bar5$.f(java.lang.Object) <bridge> <synthetic>
+  public java.lang.String Test$bar5$.g(java.lang.String)
+  public java.lang.Object Test$bar5$.g(java.lang.Object) <bridge> <synthetic>
+  public java.lang.Object Test$bar5$.g(java.lang.String) <bridge> <synthetic>
+  public java.lang.String Test$bar5$.g(java.lang.Object) <bridge> <synthetic>
+  public java.lang.String Test$bar5$.h(java.lang.String)
+  public java.lang.Object Test$bar5$.h(java.lang.Object) <bridge> <synthetic>
+}
+
+class Foo1$class {
+  public static java.lang.String Foo1$class.f(Foo1,java.lang.Object)
+}
+
+class Foo2$class {
+  public static java.lang.Object Foo2$class.f(Foo2,java.lang.String)
+}
+
+000000000000000000000000000000000000