Merge pull request scala#8055 from retronym/ticket/11523

Avoid bad generic signatures when mixin forwarders tparams shadow

Author: adriaanm

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

@@ -17,6 +17,7 @@ import symtab._
 import Flags._
 import scala.annotation.tailrec
 import scala.collection.mutable
+import scala.reflect.NameTransformer
 
 
 abstract class Mixin extends Transform with ast.TreeDSL with AccessorSynthesis {
@@ -192,11 +193,37 @@ abstract class Mixin extends Transform with ast.TreeDSL with AccessorSynthesis {
       // Optimize: no need if mixinClass has no typeparams.
       // !!! JZ Really? What about the effect of abstract types, prefix?
       if (mixinClass.typeParams.isEmpty) sym
-      else sym modifyInfo (_ => forwarderInfo)
+      else {
+        sym modifyInfo (_ => forwarderInfo)
+        avoidTypeParamShadowing(mixinMember, sym)
+        sym
+      }
     }
     newSym
   }
 
+  // scala/bug#11523 rename method type parameters that shadow enclosing class type parameters in the host class
+  // of the mixin forwarder
+  private def avoidTypeParamShadowing(mixinMember: Symbol, forwarder: Symbol): Unit = {
+    def isForwarderTparam(sym: Symbol) = {
+      val owner = sym.owner
+      // TODO fix forwarder's info should not refer to tparams of mixinMember, fix cloning in caller!
+      //      try forwarderInfo.cloneInfo(sym)
+      owner == forwarder || owner == mixinMember
+    }
+
+    val symTparams: mutable.Map[Name, Symbol] = mutable.Map.from(forwarder.typeParams.iterator.map(t => (t.name, t)))
+    forwarder.info.foreach {
+      case TypeRef(_, tparam, _) if tparam.isTypeParameter && !isForwarderTparam(tparam) =>
+        symTparams.get(tparam.name).foreach{ symTparam =>
+          debuglog(s"Renaming ${symTparam} (owned by ${symTparam.owner}, a mixin forwarder hosted in ${forwarder.enclClass.fullNameString}) to avoid shadowing enclosing type parameter of ${tparam.owner.fullNameString})")
+          symTparam.name = symTparam.name.append(NameTransformer.NAME_JOIN_STRING)
+          symTparams.remove(tparam.name) // only rename once
+        }
+      case _ =>
+    }
+  }
+
   def publicizeTraitMethods(clazz: Symbol): Unit = {
     if (treatedClassInfos(clazz) != clazz.info) {
       treatedClassInfos(clazz) = clazz.info

test/files/pos/t11525a/A.scala

@@ -0,0 +1,16 @@
+package example
+
+
+trait PartialFunction[-A, +B] extends Function1[A,B] { self =>
+  def isDefinedAt(x: A): Boolean
+  def compose[CLASH](k: PartialFunction[CLASH, A]): PartialFunction[CLASH, B] = null
+}
+
+trait Function1[-T1, +R] extends AnyRef { self =>
+  def apply(v1: T1): R
+  def compose[A](g: Function1[A, T1]): Function1[A , R] = null
+}
+
+abstract class AbstractPartialFunction[-T1, +CLASH] extends Function1[T1, CLASH] with PartialFunction[T1, CLASH] { self =>
+  def apply(x: T1): CLASH = ???
+}

test/files/pos/t11525a/Test.java

@@ -0,0 +1,5 @@
+public class Test {
+    class D extends example.AbstractPartialFunction<String, String> {
+        public boolean isDefinedAt(String s) { return false; }
+    };
+}

test/files/pos/t11525b/Test.java

@@ -0,0 +1,5 @@
+public class Test {
+    class D extends scala.runtime.AbstractPartialFunction<String, String> {
+        public boolean isDefinedAt(String s) { return false; }
+    };
+}