Merge pull request #2372 from dotty-staging/fix-strawman-compile-2

Fix strawman compilation v2

Author: odersky

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

@@ -305,7 +305,7 @@ object NameKinds {
       case _ => None
     }
 
-    def mkString(underlying: TermName, info: ThisInfo): String = unsupported("mkString")
+    def mkString(underlying: TermName, info: ThisInfo): String = s"$underlying[with sig ${info.sig}]"
     def infoString: String = "Signed"
   }
 

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -347,7 +347,7 @@ class TreePickler(pickler: TastyPickler) {
             case _ => name
           }
           val sig = tree.tpe.signature
-          if (sig == Signature.NotAMethod) pickleName(realName)
+          if (name.isTypeName || sig == Signature.NotAMethod) pickleName(realName)
           else pickleNameAndSig(realName, sig)
           pickleTree(qual)
         case Apply(fun, args) =>

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

@@ -89,8 +89,8 @@ class ElimErasedValueType extends MiniPhaseTransform with InfoTransformer {
       if (!info1.matchesLoosely(info2))
         ctx.error(
             em"""double definition:
-                |$sym1: $info1 in ${sym1.owner} ${sym1.flags} and
-                |$sym2: $info2 in ${sym2.owner} ${sym2.flags}
+                |$sym1: $info1 in ${sym1.owner} and
+                |$sym2: $info2 in ${sym2.owner}
                 |have same type after erasure: $info""",
             root.pos)
     }

tests/neg/i2202.scala

@@ -0,0 +1,11 @@
+class A {
+  def compareTo(o: Any): Int = 0
+}
+class B extends A with Comparable[B] { // error
+  def compareTo(b: B): Int = 0
+}
+object C {
+  def main(args: Array[String]): Unit = {
+    println(new B().compareTo(new Object()))
+  }
+}

tests/pos/poly-inheritance.scala

@@ -0,0 +1,44 @@
+// A strawman collection design study in a nutshell
+import reflect.ClassTag
+import Predef.???
+
+class It[+A] extends Ops[A, It, It[A]]
+
+trait Ops[+A, +CC[_], +C] extends Any {
+  def filter(f: A => Boolean): C = ???
+  def map[B](f: A => B): CC[B] = ???
+  def toSeq: It[A] = ???
+}
+
+class ArraySeq[A] extends It[A] with Ops[A, ArraySeq, ArraySeq[A]]
+
+
+class LP {
+  implicit def arrayToSeq[A](xs: Array[A]): ArraySeq[A] = ???
+}
+object Test extends LP {
+
+  implicit class ArrOps[A](val xs: Array[A]) extends AnyVal with Ops[A, ArraySeq, Array[A]] {
+    def map[B: ClassTag](f: A => B): Array[B] = ???
+    override def toSeq: ArraySeq[A] = arrayToSeq(xs)
+  }
+
+  val xs1 = Array(1, 2, 3)
+  val xs2 = xs1.filter(_ % 2 == 0)
+  val xs2a: Array[Int] = xs2
+  val xs3 = xs1.map(_ + "!")
+  val xs3a: Array[String] = xs3
+
+  def f[T](f: Int => T) = {
+    val xs1 = Array(1, 2, 3)
+    val xs2 = xs1.filter(_ % 2 == 0)
+    val xs2a: Array[Int] = xs2
+    val xs3 = xs1.toSeq.map(f)
+    val xs3a: ArraySeq[T] = xs3
+  }
+}
+
+
+
+
+