closes #2741, #4079: pickling now ensures that ...

closes #2741, #4079: pickling now ensures that a local type param with
a non-local owner, which will thus get a localized owner, will only get
a class as its localized owner if its old owner was a class (otherwise,
NoSymbol) this ensures that asSeenFrom does not treat typerefs to this
symbol differently after pickling.

todo: should we pro-actively set the owner of these type params to
something else than the type alias that they originate from? see notes
in typeFunAnon

review by odersky

2 files changed, 36 insertions, 0 deletions

diff --git a/test/files/neg/t4079/t4079_1.scala b/test/files/neg/t4079/t4079_1.scala
new file mode 100644
index 0000000000..cbae864788
--- /dev/null
+++ b/test/files/neg/t4079/t4079_1.scala
@@ -0,0 +1,33 @@
+trait Functor[F[_]] {
+  def map[A,B](fa: F[A], f: A => B): F[B]
+}
+
+trait ComposeT[F[_],G[_]] {
+  type Apply[A] = F[G[A]]
+}
+
+case class Compose[F[_],G[_]]() {
+  def Functor(implicit f: Functor[F], g: Functor[G]): Functor[ComposeT[F,G]#Apply] =
+    new Functor[ComposeT[F,G]#Apply] {
+      def map[A,B](c: ComposeT[F,G]#Apply[A], h: A => B) =
+        f.map(c, (x:G[A]) => g.map(x,h))
+    }
+}
+
+object Cat {
+  def compose[F[_],G[_]] = Compose[F,G]()
+}
+
+object Functors {
+  implicit val List = new Functor[List] {
+    def map[A,B](fa: List[A], f: A => B): List[B] = fa map f
+  }
+  implicit val Option = new Functor[Option] {
+    def map[A,B](fa: Option[A], f: A => B): Option[B] = fa map f
+  }
+}
+
+object Main {
+  import Functors._
+  val cf = Cat.compose[List,Option].Functor
+}
diff --git a/test/files/neg/t4079/t4079_2.scala b/test/files/neg/t4079/t4079_2.scala
new file mode 100644
index 0000000000..9069f0ab4e
--- /dev/null
+++ b/test/files/neg/t4079/t4079_2.scala
@@ -0,0 +1,3 @@
+object Test {
+  Cat.compose[List,Option].Functor
+}