Merge remote-tracking branch 'staging/add-semantic-names' into add-semantic-names

# Conflicts:
#	compiler/src/dotty/tools/dotc/core/SymDenotations.scala

Author: odersky

tests/pending/neg/i1846.scala

@@ -0,0 +1,5 @@
+object Bug {
+  final val x = 42
+  val y = x
+  x match {case y.toString => 42 case y => 42}
+}

tests/pending/neg/i1905.scala

@@ -0,0 +1,21 @@
+class Arr[T](val underlying: scala.Array[T]) extends AnyVal {
+  def foo = underlying
+}
+
+abstract class SeqMonoTransforms[+A, +Repr] {
+  protected[this] def fromIterableWithSameElemType(): Repr
+  def getFIWSET: Repr = fromIterableWithSameElemType
+}
+
+class ArrOps[A](val xs: Arr[A]) extends SeqMonoTransforms[A, Arr[A]] {
+  def fromIterableWithSameElemType(): Arr[A] = xs
+}
+
+object Test {
+  def main(args: Array[String]) = {
+    val arr = new Arr(Array(1, 2, 3))
+    val t = new ArrOps(arr)
+    val t2 = t.getFIWSET
+    val x = arr.foo
+  }
+}

tests/pending/neg/i2104.scala

@@ -0,0 +1,18 @@
+case class Pair[A, B](_1: A, _2: B)
+
+trait Cons[+H, +T]
+
+object Cons {
+  def apply[H, T](h: H, t: T): Cons[H, T] = ???
+  def unapply[H, T](t: Cons[H, T]): Option[Pair[H, T]] = ???
+}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    Cons(Option(1), None) match {
+      case Cons(Some(i), None) =>
+        i: Int // error: found: Any(i), requires: Int
+        assert(i == 1)
+    }
+  }
+}

tests/pending/neg/match.scala

@@ -0,0 +1,33 @@
+object Test {
+
+  class Seq[T]
+  class List[T] extends Seq[T] { def head: T = ??? }
+
+  val ss: Seq[Int] = ???
+  ss match {
+    case ss: List[int] =>
+      val x = ss.head
+      val y: Int = x
+  }
+}
+object Test1 {
+
+  class Seq[T]
+  class List[T] extends Seq[T] { def head: T = ??? }
+
+  val ss: Seq[Int] = ???
+  ss match {
+    case ss: List[Int] =>
+      println(ss)
+  }
+}
+object Test2 {
+
+  trait A
+  trait B
+  val x: A & B = ???
+
+  (x: A) match {
+    case x: B =>
+  }
+}

tests/pending/pos/TypeIndexing.scala

@@ -0,0 +1,18 @@
+// works in neither scalac nor dotty, but maybe could be made to work?
+  trait A {
+    type T
+    val t : T
+  }
+
+  object A {
+    def unapply(arg: A): Option[arg.T] = Some(arg.t)
+  }
+
+object Test {
+  def use(a : A) = a match  {
+    case b @ A(t) ⇒
+      val s: b.T = t // type mismatch.
+                     // found t.type (with underlying type <unapply-selector>.T)
+                     // required: a.T
+  }
+}

tests/pending/pos/i1793.scala

@@ -0,0 +1,7 @@
+object Test {
+  import scala.ref.WeakReference
+  def unapply[T <: AnyRef](wr: WeakReference[T]): Option[T] = {
+    val x = wr.underlying.get
+    if (x != null) Some(x) else None
+  }
+}

tests/pending/pos/i1960.scala

@@ -0,0 +1,8 @@
+case class CC2[A, B](_1: A, _2: B)
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val CC2(_, CC2(a, _)) = CC2(0, CC2(1, 2))
+    assert(a == 1)
+  }
+}

tests/pending/pos/i2032.scala

@@ -0,0 +1,2 @@
+class foo(annotation: Any) // annotation.StaticAnnotation
+@foo(new AnyRef {}) trait A

tests/pending/pos/i2071.scala

@@ -0,0 +1,7 @@
+object Test {
+  type PF[A, B] = PartialFunction[A, B]
+
+  val f: PF[Int, String] = {
+    case i => "bar"
+  }
+}

tests/pending/pos/i2201a.scala

@@ -0,0 +1,8 @@
+class Foo[T]
+
+class Fix[F[_]](unfix: F[Fix[F]])
+object DocTree {
+  type Const[T] = Foo[Int]
+  type FixConst = Fix[Const]
+  def docTree(s: Const[FixConst]): FixConst = new Fix(s)
+}