Merge 2.10.x into master

Conflicts:
	src/compiler/scala/tools/nsc/typechecker/Duplicators.scala
	src/library/scala/concurrent/Future.scala
	test/files/jvm/scala-concurrent-tck.scala

8 files changed, 229 insertions, 420 deletions

diff --git a/test/files/jvm/scala-concurrent-tck.check b/test/files/jvm/scala-concurrent-tck.check
deleted file mode 100644
index 18fc456acb..0000000000
--- a/test/files/jvm/scala-concurrent-tck.check
+++ /dev/null
@@ -1,3 +0,0 @@
-scala-concurrent-tck.scala:429: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
-    f
-    ^
diff --git a/test/files/jvm/scala-concurrent-tck.scala b/test/files/jvm/scala-concurrent-tck.scala
index 438ee310e6..6e2b8ca033 100644
--- a/test/files/jvm/scala-concurrent-tck.scala
+++ b/test/files/jvm/scala-concurrent-tck.scala
@@ -15,21 +15,17 @@ import scala.reflect.{ classTag, ClassTag }
 import scala.tools.partest.TestUtil.intercept
 
 trait TestBase {
-  
-  def once(body: (() => Unit) => Unit) {
-    val sv = new SyncVar[Boolean]
-    body(() => sv put true)
-    sv.take(2000)
+  trait Done { def apply(proof: => Boolean): Unit }
+  def once(body: Done => Unit) {
+    import java.util.concurrent.{ LinkedBlockingQueue, TimeUnit }
+    val q = new LinkedBlockingQueue[Try[Boolean]]
+    body(new Done {
+      def apply(proof: => Boolean): Unit = q offer Try(proof)
+    })
+    assert(q.poll(2000, TimeUnit.MILLISECONDS).get)
+    // Check that we don't get more than one completion
+    assert(q.poll(50, TimeUnit.MILLISECONDS) eq null)
   }
-
-  // def assert(cond: => Boolean) {
-  //   try {
-  //     Predef.assert(cond)
-  //   } catch {
-  //     case e => e.printStackTrace()
-  //   }
-  // }
-
 }
 
 
@@ -39,99 +35,52 @@ trait FutureCallbacks extends TestBase {
   def testOnSuccess(): Unit = once {
     done =>
     var x = 0
-    val f = future {
-      x = 1
-    }
-    f onSuccess {
-      case _ =>
-        done()
-        assert(x == 1)
-    }
+    val f = future { x = 1 }
+    f onSuccess { case _ => done(x == 1) }
   }
   
   def testOnSuccessWhenCompleted(): Unit = once {
     done =>
     var x = 0
-    val f = future {
-      x = 1
-    }
+    val f = future { x = 1 }
     f onSuccess { 
-      case _ =>
-      assert(x == 1)
+      case _ if x == 1 =>
       x = 2
-      f onSuccess { 
-        case _ =>
-          assert(x == 2)
-          done()
-      }
+      f onSuccess {  case _ => done(x == 2) }
     }
   }
 
   def testOnSuccessWhenFailed(): Unit = once {
     done =>
-    val f = future[Unit] {
-      done()
-      throw new Exception
-    }
-    f onSuccess {
-      case _ => assert(false)
-    }
+    val f = future[Unit] { throw new Exception }
+    f onSuccess { case _ => done(false) }
+    f onFailure { case _ => done(true) }
   }
   
   def testOnFailure(): Unit = once {
     done =>
-    var x = 0
-    val f = future[Unit] {
-      x = 1
-      throw new Exception
-    }
-    f onSuccess {
-      case _ =>
-        done()
-        assert(false)
-    }
-    f onFailure {
-      case _ =>
-        done()
-        assert(x == 1)
-    }
+    val f = future[Unit] { throw new Exception }
+    f onSuccess { case _ => done(false) }
+    f onFailure { case _ => done(true) }
   }
 
   def testOnFailureWhenSpecialThrowable(num: Int, cause: Throwable): Unit = once {
     done =>
-    val f = future[Unit] {
-      throw cause
-    }
-    f onSuccess {
-      case _ =>
-        done()
-        assert(false)
-    }
+    val f = future[Unit] { throw cause }
+    f onSuccess { case _ => done(false) }
     f onFailure {
-      case e: ExecutionException if (e.getCause == cause) =>
-        done()
-      case _ =>
-        done()
-        assert(false)
+      case e: ExecutionException if e.getCause == cause => done(true)
+      case _ => done(false)
     }
   }
   
   def testOnFailureWhenTimeoutException(): Unit = once {
     done =>
-    val f = future[Unit] {
-      throw new TimeoutException()
-    }
-    f onSuccess {
-      case _ =>
-        done()
-        assert(false)
-    }
+    val f = future[Unit] { throw new TimeoutException() }
+    f onSuccess { case _ => done(false) }
     f onFailure {
-      case e: TimeoutException =>
-        done()
-      case other =>
-        done()
-        assert(false)
+      case e: TimeoutException => done(true)
+      case _ => done(false)
     }
   }
 
@@ -151,7 +100,6 @@ trait FutureCallbacks extends TestBase {
   //testOnFailureWhenSpecialThrowable(7, new InterruptedException)
   testThatNestedCallbacksDoNotYieldStackOverflow()
   testOnFailureWhenTimeoutException()
-  
 }
 
 
@@ -162,207 +110,120 @@ trait FutureCombinators extends TestBase {
     done =>
       val f = future { 5 }
       val g = f map { x => "result: " + x }
-      g onSuccess {
-        case s =>
-          done()
-          assert(s == "result: 5")
-      }
-      g onFailure {
-        case _ =>
-          done()
-          assert(false)
-      }
+      g onSuccess { case s => done(s == "result: 5") }
+      g onFailure { case _ => done(false) }
   }
 
   def testMapFailure(): Unit = once {
     done =>
-      val f = future {
-        throw new Exception("exception message")
-      }
+      val f = future[Unit] { throw new Exception("exception message") }
       val g = f map { x => "result: " + x }
-      g onSuccess {
-        case _ =>
-          done()
-          assert(false)
-      }
-      g onFailure {
-        case t =>
-          done()
-          assert(t.getMessage() == "exception message")
-      }
+      g onSuccess { case _ => done(false) }
+      g onFailure { case t => done(t.getMessage() == "exception message") }
   }
 
   def testMapSuccessPF(): Unit = once {
     done =>
       val f = future { 5 }
       val g = f map { case r => "result: " + r }
-      g onSuccess {
-        case s =>
-          done()
-          assert(s == "result: 5")
-      }
-      g onFailure {
-        case _ =>
-          done()
-          assert(false)
-      }
+      g onSuccess { case s => done(s == "result: 5") }
+      g onFailure { case _ => done(false) }
   }
 
   def testTransformSuccess(): Unit = once {
     done =>
       val f = future { 5 }
       val g = f.transform(r => "result: " + r, identity)
-      g onSuccess {
-        case s =>
-          done()
-          assert(s == "result: 5")
-      }
-      g onFailure {
-        case _ =>
-          done()
-          assert(false)
-      }
+      g onSuccess { case s => done(s == "result: 5") }
+      g onFailure { case _ => done(false) }
   }
 
   def testTransformSuccessPF(): Unit = once {
     done =>
       val f = future { 5 }
       val g = f.transform( { case r => "result: " + r }, identity)
-      g onSuccess {
-        case s =>
-          done()
-          assert(s == "result: 5")
-      }
-      g onFailure {
-        case _ =>
-          done()
-          assert(false)
-      }
+      g onSuccess { case s => done(s == "result: 5") }
+      g onFailure { case _ => done(false) }
+  }
+
+def testTransformFailure(): Unit = once {
+    done =>
+      val transformed = new Exception("transformed")
+      val f = future { throw new Exception("expected") }
+      val g = f.transform(identity, _ => transformed)
+      g onSuccess { case _ => done(false) }
+      g onFailure { case e => done(e eq transformed) }
+  }
+
+  def testTransformFailurePF(): Unit = once {
+    done =>
+      val e = new Exception("expected")
+      val transformed = new Exception("transformed")
+      val f = future[Unit] { throw e }
+      val g = f.transform(identity, { case `e` => transformed })
+      g onSuccess { case _ => done(false) }
+      g onFailure { case e => done(e eq transformed) }
   }
 
   def testFoldFailure(): Unit = once {
     done =>
-      val f = future {
-        throw new Exception("exception message")
-      }
+      val f = future[Unit] { throw new Exception("expected") }
       val g = f.transform(r => "result: " + r, identity)
-      g onSuccess {
-        case _ =>
-          done()
-          assert(false)
-      }
-      g onFailure {
-        case t =>
-          done()
-          assert(t.getMessage() == "exception message")
-      }
+      g onSuccess { case _ => done(false) }
+      g onFailure { case t => done(t.getMessage() == "expected") }
   }
 
   def testFlatMapSuccess(): Unit = once {
     done =>
       val f = future { 5 }
       val g = f flatMap { _ => future { 10 } }
-      g onSuccess {
-        case x =>
-          done()
-          assert(x == 10)
-      }
-      g onFailure {
-        case _ =>
-          done()
-          assert(false)
-      }
+      g onSuccess { case x => done(x == 10) }
+      g onFailure { case _ => done(false) }
   }
 
   def testFlatMapFailure(): Unit = once {
     done =>
-      val f = future {
-        throw new Exception("exception message")
-      }
+      val f = future[Unit] { throw new Exception("expected") }
       val g = f flatMap { _ => future { 10 } }
-      g onSuccess {
-        case _ =>
-          done()
-          assert(false)
-      }
-      g onFailure {
-        case t =>
-          done()
-          assert(t.getMessage() == "exception message")
-      }
+      g onSuccess { case _ => done(false) }
+      g onFailure { case t => done(t.getMessage() == "expected") }
   }
 
   def testFilterSuccess(): Unit = once {
     done =>
       val f = future { 4 }
       val g = f filter { _ % 2 == 0 }
-      g onSuccess {
-        case x: Int =>
-          done()
-          assert(x == 4)
-      }
-      g onFailure {
-        case _ =>
-          done()
-          assert(false)
-      }
+      g onSuccess { case x: Int => done(x == 4) }
+      g onFailure { case _ => done(false) }
   }
 
   def testFilterFailure(): Unit = once {
     done =>
       val f = future { 4 }
       val g = f filter { _ % 2 == 1 }
-      g onSuccess {
-        case x: Int =>
-          done()
-          assert(false)
-      }
+      g onSuccess { case x: Int => done(false) }
       g onFailure {
-        case e: NoSuchElementException =>
-          done()
-          assert(true)
-        case _ =>
-          done()
-          assert(false)
+        case e: NoSuchElementException => done(true)
+        case _ => done(false)
       }
   }
 
   def testCollectSuccess(): Unit = once {
     done =>
       val f = future { -5 }
-      val g = f collect {
-        case x if x < 0 => -x
-      }
-      g onSuccess {
-        case x: Int =>
-          done()
-          assert(x == 5)
-      }
-      g onFailure {
-        case _ =>
-          done()
-          assert(false)
-      }
+      val g = f collect { case x if x < 0 => -x }
+      g onSuccess { case x: Int => done(x == 5) }
+      g onFailure { case _ => done(false) }
   }
 
   def testCollectFailure(): Unit = once {
     done =>
       val f = future { -5 }
-      val g = f collect {
-        case x if x > 0 => x * 2
-      }
-      g onSuccess {
-        case _ =>
-          done()
-          assert(false)
-      }
+      val g = f collect { case x if x > 0 => x * 2 }
+      g onSuccess { case _ => done(false) }
       g onFailure {
-        case e: NoSuchElementException =>
-          done()
-          assert(true)
-        case _ =>
-          done()
-          assert(false)
+        case e: NoSuchElementException => done(true)
+        case _ => done(false)
       }
   }
 
@@ -376,16 +237,8 @@ trait FutureCombinators extends TestBase {
       f foreach { x => p.success(x * 2) }
       val g = p.future
       
-      g.onSuccess {
-        case res: Int =>
-          done()
-          assert(res == 10)
-      }
-      g.onFailure {
-        case _ =>
-          done()
-          assert(false)
-      }
+      g.onSuccess { case res: Int => done(res == 10) }
+      g.onFailure { case _ => done(false) }
   }
 
   def testForeachFailure(): Unit = once {
@@ -396,16 +249,8 @@ trait FutureCombinators extends TestBase {
       f onFailure { case _ => p.failure(new Exception) }
       val g = p.future
       
-      g.onSuccess {
-        case _ =>
-          done()
-          assert(false)
-      }
-      g.onFailure {
-        case _ =>
-          done()
-          assert(true)
-      }
+      g.onSuccess { case _ => done(false) }
+      g.onFailure { case _ => done(true) }
   }
 
   def testRecoverSuccess(): Unit = once {
@@ -415,18 +260,9 @@ trait FutureCombinators extends TestBase {
       throw cause
     } recover {
       case re: RuntimeException =>
-        "recovered"
-    }
-    f onSuccess {
-      case x =>
-        done()
-        assert(x == "recovered")
-    }
-    f onFailure { case any =>
-      done()
-      assert(false)
-    }
-    f
+        "recovered" }
+    f onSuccess { case x => done(x == "recovered") }
+    f onFailure { case any => done(false) }
   }
 
   def testRecoverFailure(): Unit = once {
@@ -437,15 +273,8 @@ trait FutureCombinators extends TestBase {
     } recover {
       case te: TimeoutException => "timeout"
     }
-    f onSuccess {
-      case x =>
-        done()
-        assert(false)
-    }
-    f onFailure { case any =>
-      done()
-      assert(any == cause)
-    }
+    f onSuccess { case _ => done(false) }
+    f onFailure { case any => done(any == cause) }
   }
   
   def testRecoverWithSuccess(): Unit = once {
@@ -457,15 +286,8 @@ trait FutureCombinators extends TestBase {
       case re: RuntimeException =>
         future { "recovered" }
     }
-    f onSuccess {
-      case x =>
-        done()
-        assert(x == "recovered")
-    }
-    f onFailure { case any =>
-      done()
-      assert(false)
-    }
+    f onSuccess { case x => done(x == "recovered") }
+    f onFailure { case any => done(false) }
   }
 
   def testRecoverWithFailure(): Unit = once {
@@ -477,15 +299,8 @@ trait FutureCombinators extends TestBase {
       case te: TimeoutException =>
         future { "timeout" }
     }
-    f onSuccess {
-      case x =>
-        done()
-        assert(false)
-    }
-    f onFailure { case any =>
-      done()
-      assert(any == cause)
-    }
+    f onSuccess { case x => done(false) }
+    f onFailure { case any => done(any == cause) }
   }
  
   def testZipSuccess(): Unit = once {
@@ -493,52 +308,28 @@ trait FutureCombinators extends TestBase {
     val f = future { 5 }
     val g = future { 6 }
     val h = f zip g
-    h onSuccess {
-      case (l: Int, r: Int) =>
-        done()
-        assert(l+r == 11)
-    }
-    h onFailure {
-      case _ =>
-        done()
-        assert(false)
-    }
+    h onSuccess { case (l: Int, r: Int) => done(l+r == 11) }
+    h onFailure { case _ => done(false) }
   }
 
   def testZipFailureLeft(): Unit = once {
     done =>
-    val cause = new Exception("exception message")
+    val cause = new Exception("expected")
     val f = future { throw cause }
     val g = future { 6 }
     val h = f zip g
-    h onSuccess {
-      case _ =>
-        done()
-        assert(false)
-    }
-    h onFailure {
-      case e: Exception =>
-        done()
-        assert(e.getMessage == "exception message")
-    }
+    h onSuccess { case _ => done(false) }
+    h onFailure { case e: Exception => done(e.getMessage == "expected") }
   }
 
   def testZipFailureRight(): Unit = once {
     done =>
-    val cause = new Exception("exception message")
+    val cause = new Exception("expected")
     val f = future { 5 }
     val g = future { throw cause }
     val h = f zip g
-    h onSuccess {
-      case _ =>
-        done()
-        assert(false)
-    }
-    h onFailure {
-      case e: Exception =>
-        done()
-        assert(e.getMessage == "exception message")
-    }
+    h onSuccess { case _ => done(false) }
+    h onFailure { case e: Exception => done(e.getMessage == "expected") }
   }
 
   def testFallbackTo(): Unit = once {
@@ -546,17 +337,8 @@ trait FutureCombinators extends TestBase {
     val f = future { sys.error("failed") }
     val g = future { 5 }
     val h = f fallbackTo g
-
-    h onSuccess {
-      case x: Int =>
-        done()
-        assert(x == 5)
-    }
-    h onFailure {
-      case _ =>
-        done()
-        assert(false)
-    }
+    h onSuccess { case x: Int => done(x == 5) }
+    h onFailure { case _ => done(false) }
   }
 
   def testFallbackToFailure(): Unit = once {
@@ -566,16 +348,8 @@ trait FutureCombinators extends TestBase {
     val g = future { throw cause }
     val h = f fallbackTo g
 
-    h onSuccess {
-      case _ =>
-        done()
-        assert(false)
-    }
-    h onFailure {
-      case e: Exception =>
-        done()
-        assert(e == cause)
-    }
+    h onSuccess { case _ => done(false) }
+    h onFailure { case e => done(e eq cause) }
   }
 
   testMapSuccess()
@@ -597,6 +371,8 @@ trait FutureCombinators extends TestBase {
   testZipFailureRight()
   testFallbackTo()
   testFallbackToFailure()
+  testTransformSuccess()
+  testTransformSuccessPF()
 }
 
 
@@ -606,40 +382,26 @@ trait FutureProjections extends TestBase {
   def testFailedFailureOnComplete(): Unit = once {
     done =>
     val cause = new RuntimeException
-    val f = future {
-      throw cause
-    }
+    val f = future { throw cause }
     f.failed onComplete {
-      case Success(t) =>
-        assert(t == cause)
-        done()
-      case Failure(t) =>
-        assert(false)
+      case Success(t) => done(t == cause)
+      case Failure(t) => done(false)
     }
   }
   
   def testFailedFailureOnSuccess(): Unit = once {
     done =>
     val cause = new RuntimeException
-    val f = future {
-      throw cause
-    }
-    f.failed onSuccess {
-      case t =>
-        assert(t == cause)
-        done()
-    }
+    val f = future { throw cause }
+    f.failed onSuccess { case t => done(t == cause) }
   }
   
   def testFailedSuccessOnComplete(): Unit = once {
     done =>
     val f = future { 0 }
     f.failed onComplete {
-      case Success(t) =>
-        assert(false)
-      case Failure(t) =>
-        assert(t.isInstanceOf[NoSuchElementException])
-        done()
+      case Failure(_: NoSuchElementException) => done(true)
+      case _ => done(false)
     }
   }
   
@@ -647,19 +409,17 @@ trait FutureProjections extends TestBase {
     done =>
     val f = future { 0 }
     f.failed onFailure {
-      case nsee: NoSuchElementException =>
-      done()
+      case e: NoSuchElementException => done(true)
+      case _ => done(false)
     }
+    f.failed onSuccess { case _ => done(false) }
   }
   
   def testFailedFailureAwait(): Unit = once {
     done =>
     val cause = new RuntimeException
-    val f = future {
-      throw cause
-    }
-    assert(Await.result(f.failed, Duration(500, "ms")) == cause)
-    done()
+    val f = future { throw cause }
+    done(Await.result(f.failed, Duration(500, "ms")) == cause)
   }
   
   def testFailedSuccessAwait(): Unit = once {
@@ -667,9 +427,10 @@ trait FutureProjections extends TestBase {
     val f = future { 0 }
     try {
       Await.result(f.failed, Duration(500, "ms"))
-      assert(false)
+      done(false)
     } catch {
-      case nsee: NoSuchElementException => done()
+      case nsee: NoSuchElementException => done(true)
+      case _: Throwable => done(false)
     }
   }
 
@@ -682,8 +443,8 @@ trait FutureProjections extends TestBase {
       Await.ready(f, Duration.Zero)
       Await.ready(f, Duration(500, "ms"))
       Await.ready(f, Duration.Inf)
-      done()
-    } onFailure { case x => throw x }
+      done(true)
+    } onFailure { case x => done(throw x) }
   }
 
   def testAwaitNegativeDuration(): Unit = once { done =>
@@ -692,8 +453,8 @@ trait FutureProjections extends TestBase {
       intercept[TimeoutException] { Await.ready(f, Duration.Zero) }
       intercept[TimeoutException] { Await.ready(f, Duration.MinusInf) }
       intercept[TimeoutException] { Await.ready(f, Duration(-500, "ms")) }
-      done()
-    } onFailure { case x => throw x }
+      done(true)
+    } onFailure { case x => done(throw x) }
   }
   
   testFailedFailureOnComplete()
@@ -704,7 +465,6 @@ trait FutureProjections extends TestBase {
   testFailedSuccessAwait()
   testAwaitPositiveDuration()
   testAwaitNegativeDuration()
-  
 }
 
 
@@ -714,33 +474,25 @@ trait Blocking extends TestBase {
   def testAwaitSuccess(): Unit = once {
     done =>
     val f = future { 0 }
-    Await.result(f, Duration(500, "ms"))
-    done()
+    done(Await.result(f, Duration(500, "ms")) == 0)
   }
   
   def testAwaitFailure(): Unit = once {
     done =>
     val cause = new RuntimeException
-    val f = future {
-      throw cause
-    }
+    val f = future { throw cause }
     try {
       Await.result(f, Duration(500, "ms"))
-      assert(false)
+      done(false)
     } catch {
-      case t: Throwable =>
-        assert(t == cause)
-        done()
+      case  t: Throwable => done(t == cause)
     }
   }
   
   def testFQCNForAwaitAPI(): Unit = once {
     done =>
-    
-    assert(classOf[CanAwait].getName == "scala.concurrent.CanAwait")
-    assert(Await.getClass.getName == "scala.concurrent.Await")
-    
-    done()
+    done(classOf[CanAwait].getName == "scala.concurrent.CanAwait" && 
+         Await.getClass.getName == "scala.concurrent.Await")
   }
   
   testAwaitSuccess()
@@ -813,22 +565,26 @@ trait Promises extends TestBase {
     val p = promise[Int]()
     val f = p.future
     
-    f onSuccess {
-      case x =>
-        done()
-        assert(x == 5)
-    }
-    f onFailure {
-      case any =>
-        done()
-        assert(false)
-    }
+    f onSuccess { case x => done(x == 5) }
+    f onFailure { case any => done(false) }
     
     p.success(5)
   }
 
-  testSuccess()
+  def testFailure(): Unit = once {
+    done =>
+    val e = new Exception("expected")
+    val p = promise[Int]()
+    val f = p.future
+    
+    f onSuccess { case x => done(false) }
+    f onFailure { case any => done(any eq e) }
+    
+    p.failure(e)
+  }
 
+  testSuccess()
+  testFailure()
 }
 
 
@@ -888,11 +644,11 @@ trait CustomExecutionContext extends TestBase {
     val count = countExecs { implicit ec =>
       blocking {
         once { done =>
-          val f = future({ assertNoEC() })(defaultEC)
+          val f = future(assertNoEC())(defaultEC)
           f onSuccess {
             case _ =>
               assertEC()
-            done()
+              done(true)
           }
           assertNoEC()
         }
@@ -911,7 +667,7 @@ trait CustomExecutionContext extends TestBase {
           f onSuccess {
             case _ =>
               assertEC()
-            done()
+              done(true)
           }
         }
       }
@@ -935,15 +691,10 @@ trait CustomExecutionContext extends TestBase {
              Promise.successful(x + 1).future.map(addOne).map(addOne)
            } onComplete {
             case Failure(t) =>
-              try {
-                throw new AssertionError("error in test: " + t.getMessage, t)
-              } finally {
-                done()
-              }
+              done(throw new AssertionError("error in test: " + t.getMessage, t))
             case Success(x) =>
               assertEC()
-              assert(x == 14)
-              done()
+              done(x == 14)
           }
           assertNoEC()
         }
@@ -999,21 +750,14 @@ trait ExecutionContextPrepare extends TestBase {
     done =>
     theLocal.set("secret")
     val fut = future { 42 }
-    fut onComplete {
-      case _ =>
-        assert(theLocal.get == "secret")
-        done()
-    }
+    fut onComplete { case _ => done(theLocal.get == "secret") }
   }
   
   def testMap(): Unit = once {
     done =>
     theLocal.set("secret2")
     val fut = future { 42 }
-    fut map { x =>
-      assert(theLocal.get == "secret2")
-      done()
-    }
+    fut map { x => done(theLocal.get == "secret2") }
   }
   
   testOnComplete()
diff --git a/test/files/neg/valueclasses-impl-restrictions.check b/test/files/neg/valueclasses-impl-restrictions.check
index 63924493aa..0af9173f74 100644
--- a/test/files/neg/valueclasses-impl-restrictions.check
+++ b/test/files/neg/valueclasses-impl-restrictions.check
@@ -6,12 +6,8 @@ valueclasses-impl-restrictions.scala:9: error: implementation restriction: neste
 This restriction is planned to be removed in subsequent releases.
   trait I2 {
         ^
-valueclasses-impl-restrictions.scala:15: error: implementation restriction: nested class is not allowed in value class
-This restriction is planned to be removed in subsequent releases.
-    val i2 = new I2 { val q = x.s }
-                 ^
-valueclasses-impl-restrictions.scala:21: error: implementation restriction: nested class is not allowed in value class
+valueclasses-impl-restrictions.scala:23: error: implementation restriction: nested class is not allowed in value class
 This restriction is planned to be removed in subsequent releases.
   private[this] class I2(val q: String)
                       ^
-four errors found
+three errors found
diff --git a/test/files/neg/valueclasses-impl-restrictions.scala b/test/files/neg/valueclasses-impl-restrictions.scala
index 137f3f854c..f0577a94aa 100644
--- a/test/files/neg/valueclasses-impl-restrictions.scala
+++ b/test/files/neg/valueclasses-impl-restrictions.scala
@@ -12,8 +12,10 @@ class X1(val s: String) extends AnyVal {
   }
 
   def y(x: X1) = {
-    val i2 = new I2 { val q = x.s }
+    val i2 = new I2 { val q = x.s } // allowed as of SI-7571
     i2.z
+
+    { case x => x } : PartialFunction[Int, Int] // allowed
   }
 }
 
diff --git a/test/files/run/t7571.scala b/test/files/run/t7571.scala
new file mode 100644
index 0000000000..00b9695168
--- /dev/null
+++ b/test/files/run/t7571.scala
@@ -0,0 +1,12 @@
+class Foo(val a: Int) extends AnyVal {
+  def foo = { {case x => x + a}: PartialFunction[Int, Int]}
+
+  def bar = (new {}).toString
+}
+
+object Test extends App {
+  val x = new Foo(1).foo.apply(2)
+  assert(x == 3, x)
+  val s = new Foo(1).bar
+  assert(s.nonEmpty, s)
+}
diff --git a/test/files/specialized/SI-7343.scala b/test/files/specialized/SI-7343.scala
new file mode 100644
index 0000000000..5ee683064c
--- /dev/null
+++ b/test/files/specialized/SI-7343.scala
@@ -0,0 +1,55 @@
+class Parent[@specialized(Int) T] 
+
+object Test extends App {
+
+  /**
+   * This method will check if specialization is correctly rewiring parents
+   * for classes defined inside methods. The pattern is important since this
+   * is how closures are currently represented: as locally-defined anonymous
+   * classes, which usually end up inside methods. For these closures we do
+   * want their parents rewired correctly:
+   *
+   * ```
+   *  def checkSuperClass$mIc$sp[T](t: T, ...) = {
+   *    class X extends Parent$mcI$sp // instead of just Parent
+   *    ...
+   *  }
+   */
+  def checkSuperClass[@specialized(Int) T](t: T, expectedXSuper: String) = {
+    // test target:
+    //  - in checkSuperClass, X should extend Parent
+    //  - in checkSuperClass$mIc$sp, X should extend Parent$mcI$sp
+    class X extends Parent[T]()
+
+    // get the superclass for X and make sure it's correct
+    val actualXSuper = (new X).getClass().getSuperclass().getSimpleName()
+    assert(actualXSuper == expectedXSuper, actualXSuper + " != " + expectedXSuper)
+  }
+
+  checkSuperClass("x", "Parent")
+  checkSuperClass(101, "Parent$mcI$sp")
+
+  /**
+   * This is the same check, but in value. It should work exactly the same
+   * as its method counterpart.
+   */
+  class Val[@specialized(Int) T](t: T, expectedXSuper: String) {
+    val check: T = {
+      class X extends Parent[T]()
+
+      // get the superclass for X and make sure it's correct
+      val actualXSuper = (new X).getClass().getSuperclass().getSimpleName()
+      assert(actualXSuper == expectedXSuper, actualXSuper + " != " + expectedXSuper)
+      t
+    }
+  }
+
+  new Val("x", "Parent")
+  new Val(101, "Parent$mcI$sp")
+
+  /**
+   * NOTE: The the same check, only modified to affect constructors, won't
+   * work since the class X definition will always be lifted to become a
+   * member of the class, making it impossible to force its duplication.
+   */
+}
diff --git a/test/files/specialized/spec-ame.check b/test/files/specialized/spec-ame.check
index 9c1713cc8a..cf18c01191 100644
--- a/test/files/specialized/spec-ame.check
+++ b/test/files/specialized/spec-ame.check
@@ -1,3 +1,3 @@
 abc
 10
-3
\ No newline at end of file
+2
diff --git a/test/files/specialized/spec-ame.scala b/test/files/specialized/spec-ame.scala
index 79ee4217ed..129fb9f447 100644
--- a/test/files/specialized/spec-ame.scala
+++ b/test/files/specialized/spec-ame.scala
@@ -13,6 +13,9 @@ object Test {
   def main(args: Array[String]) {
     println((new A("abc")).foo.value)
     println((new A(10)).foo.value)
+    // before fixing SI-7343, this was printing 3. Now it's printing 2,
+    // since the anonymous class created by doing new B[T] { ... } when
+    // T = Int is now rewired to B$mcI$sp instead of just B[Int]
     println(runtime.BoxesRunTime.integerBoxCount)
   }
 }