6 files changed, 90 insertions, 8 deletions
diff --git a/test/files/neg/t7623.check b/test/files/neg/t7623.check
new file mode 100644
index 0000000000..db368dd369
--- /dev/null
+++ b/test/files/neg/t7623.check
@@ -0,0 +1,21 @@
+t7623.scala:19: warning: A repeated case parameter or extracted sequence should be matched only by a sequence wildcard (_*).
+  def f = "" match { case X(s) => }
+                          ^
+t7623.scala:21: warning: A repeated case parameter or extracted sequence should be matched only by a sequence wildcard (_*).
+  def g = "" match { case X(s, t) => }
+                          ^
+t7623.scala:23: warning: A repeated case parameter or extracted sequence should be matched only by a sequence wildcard (_*).
+  def h = "" match { case X(s, t, u @ _*) => }
+                          ^
+t7623.scala:9: warning: A repeated case parameter or extracted sequence should be matched only by a sequence wildcard (_*).
+  def f = C("") match { case C(s) => }
+                             ^
+t7623.scala:11: warning: A repeated case parameter or extracted sequence should be matched only by a sequence wildcard (_*).
+  def g = C("") match { case C(s, t) => }
+                             ^
+t7623.scala:13: warning: A repeated case parameter or extracted sequence should be matched only by a sequence wildcard (_*).
+  def h = C("") match { case C(s, t, u @ _*) => }
+                             ^
+error: No warnings can be incurred under -Xfatal-warnings.
+6 warnings found
+one error found
diff --git a/test/files/neg/t7623.flags b/test/files/neg/t7623.flags
new file mode 100644
index 0000000000..74c9e38323
--- /dev/null
+++ b/test/files/neg/t7623.flags
@@ -0,0 +1 @@
+-Xlint:stars-align -Xfatal-warnings
diff --git a/test/files/neg/t7623.scala b/test/files/neg/t7623.scala
new file mode 100644
index 0000000000..5c40f37bc1
--- /dev/null
+++ b/test/files/neg/t7623.scala
@@ -0,0 +1,38 @@
+
+
+case class C(s: String, xs: Int*)
+
+object X { def unapplySeq(a: Any): Option[(String, Seq[Int])] = Some("", List(1,2,3)) }
+
+// for case classes with varargs, avoid misaligned patterns
+trait Ctest {
+  def f = C("") match { case C(s) => }
+
+  def g = C("") match { case C(s, t) => }
+
+  def h = C("") match { case C(s, t, u @ _*) => }
+
+  def ok = C("") match { case C(s, u @ _*) => }
+}
+// for extractors that unapplySeq: Option[(Something, Seq[_])], avoid misaligned patterns
+trait Xtest {
+  def f = "" match { case X(s) => }
+
+  def g = "" match { case X(s, t) => }
+
+  def h = "" match { case X(s, t, u @ _*) => }
+
+  def ok = "" match { case X(s, u @ _*) => }
+}
+// for extractors that unapplySeq: Option[Seq[_]], anything goes
+trait Rtest {
+  val r = "(a+)".r
+
+  def f = "" match { case r(s) => }
+
+  def g = "" match { case r(s, t) => }
+
+  def h = "" match { case r(s, t, u @ _*) => }
+
+  def whatever = "" match { case r(u @ _*) => }
+}
diff --git a/test/files/pos/t5154.scala b/test/files/pos/t5154.scala
new file mode 100644
index 0000000000..2629308f00
--- /dev/null
+++ b/test/files/pos/t5154.scala
@@ -0,0 +1,9 @@
+
+trait Z {
+  // extra space made the pattern OK
+  def f = <z> {{3}}</z> match { case <z> {{3}}</z> => }
+
+  // lack of space: error: illegal start of simple pattern
+  def g = <z>{{3}}</z> match { case <z>{{3}}</z> => }
+}
+
diff --git a/test/files/pos/t9050.scala b/test/files/pos/t9050.scala
new file mode 100644
index 0000000000..b1ab09f901
--- /dev/null
+++ b/test/files/pos/t9050.scala
@@ -0,0 +1,13 @@
+final class Mu[F](val value: Any) extends AnyVal {
+  def cata(f: F) {
+    // crash
+    ((y: Mu[F]) => y.cata(f))
+    // crash
+    def foo(x : Mu[F]) = x.cata(f)
+
+    // // okay
+    def x: Mu[F] = ???
+    (() => x.cata(f))
+    assert(true, cata(f))
+  }
+}
diff --git a/test/files/scalacheck/nan-ordering.scala b/test/files/scalacheck/nan-ordering.scala
index 2094a46e37..05e97a13c9 100644
--- a/test/files/scalacheck/nan-ordering.scala
+++ b/test/files/scalacheck/nan-ordering.scala
@@ -42,16 +42,16 @@ object Test extends Properties("NaN-Ordering") {
   property("Float equiv") = forAll(specFloats, specFloats) { (d1, d2) => numFloat.equiv(d1, d2) == (d1 == d2) }
 
   property("Float reverse.min") = forAll(specFloats, specFloats) { (d1, d2) => {
-      val mathmin = math.min(d1, d2)
+      val mathmax = math.max(d1, d2)
       val numericmin = numFloat.reverse.min(d1, d2)
-      mathmin == numericmin || mathmin.isNaN && numericmin.isNaN
+      mathmax == numericmin || mathmax.isNaN && numericmin.isNaN
     }
   }
 
   property("Float reverse.max") = forAll(specFloats, specFloats) { (d1, d2) => {
-      val mathmax = math.max(d1, d2)
+      val mathmin = math.min(d1, d2)
       val numericmax = numFloat.reverse.max(d1, d2)
-      mathmax == numericmax || mathmax.isNaN && numericmax.isNaN
+      mathmin == numericmax || mathmin.isNaN && numericmax.isNaN
     }
   }
 
@@ -105,16 +105,16 @@ object Test extends Properties("NaN-Ordering") {
   property("Double equiv") = forAll(specDoubles, specDoubles) { (d1, d2) => numDouble.equiv(d1, d2) == (d1 == d2) }
 
   property("Double reverse.min") = forAll(specDoubles, specDoubles) { (d1, d2) => {
-    val mathmin = math.min(d1, d2)
+    val mathmax = math.max(d1, d2)
     val numericmin = numDouble.reverse.min(d1, d2)
-    mathmin == numericmin || mathmin.isNaN && numericmin.isNaN
+    mathmax == numericmin || mathmax.isNaN && numericmin.isNaN
   }
   }
 
   property("Double reverse.max") = forAll(specDoubles, specDoubles) { (d1, d2) => {
-    val mathmax = math.max(d1, d2)
+    val mathmin = math.min(d1, d2)
     val numericmax = numDouble.reverse.max(d1, d2)
-    mathmax == numericmax || mathmax.isNaN && numericmax.isNaN
+    mathmin == numericmax || mathmin.isNaN && numericmax.isNaN
   }
   }