Merge branch 'master' into topic/reflect

19 files changed, 536 insertions, 27 deletions

diff --git a/test/files/continuations-neg/infer0.check b/test/disabled/continuations-neg/infer0.check
index 1dd072ef09..1dd072ef09 100644
--- a/test/files/continuations-neg/infer0.check
+++ b/test/disabled/continuations-neg/infer0.check
diff --git a/test/files/continuations-neg/infer0.scala b/test/disabled/continuations-neg/infer0.scala
index 9cf69c5d35..6d97d7504d 100644
--- a/test/files/continuations-neg/infer0.scala
+++ b/test/disabled/continuations-neg/infer0.scala
@@ -4,11 +4,9 @@ import scala.util.continuations._
 
 
 object Test {
- 
   def test(x: => Int @cpsParam[String,Int]) = 7
-  
-  def main(args: Array[String]): Any = {
+
+  def main(args: Array[String]) {
     test(8)
   }
-  
-}
\ No newline at end of file
+}
diff --git a/test/files/continuations-run/shift-pct.check b/test/files/continuations-run/shift-pct.check
new file mode 100644
index 0000000000..fb190e770a
--- /dev/null
+++ b/test/files/continuations-run/shift-pct.check
@@ -0,0 +1,25 @@
+d = 1, d2 = 1.0, pct = 1.000
+d = 2, d2 = 4.0, pct = 0.500
+d = 3, d2 = 9.0, pct = 0.333
+d = 4, d2 = 16.0, pct = 0.250
+d = 5, d2 = 25.0, pct = 0.200
+d = 6, d2 = 36.0, pct = 0.167
+d = 7, d2 = 49.0, pct = 0.143
+d = 8, d2 = 64.0, pct = 0.125
+d = 9, d2 = 81.0, pct = 0.111
+d = 10, d2 = 100.0, pct = 0.100
+d = 11, d2 = 121.0, pct = 0.091
+d = 12, d2 = 144.0, pct = 0.083
+d = 13, d2 = 169.0, pct = 0.077
+d = 14, d2 = 196.0, pct = 0.071
+d = 15, d2 = 225.0, pct = 0.067
+d = 16, d2 = 256.0, pct = 0.063
+d = 17, d2 = 289.0, pct = 0.059
+d = 18, d2 = 324.0, pct = 0.056
+d = 19, d2 = 361.0, pct = 0.053
+d = 20, d2 = 400.0, pct = 0.050
+d = 21, d2 = 441.0, pct = 0.048
+d = 22, d2 = 484.0, pct = 0.045
+d = 23, d2 = 529.0, pct = 0.043
+d = 24, d2 = 576.0, pct = 0.042
+d = 25, d2 = 625.0, pct = 0.040
diff --git a/test/files/continuations-run/shift-pct.scala b/test/files/continuations-run/shift-pct.scala
new file mode 100644
index 0000000000..7ef9922168
--- /dev/null
+++ b/test/files/continuations-run/shift-pct.scala
@@ -0,0 +1,30 @@
+import scala.util.continuations._
+
+object Test {
+  abstract class IfReturnRepro {
+    def s1: Double @cpsParam[Any, Unit]
+    def s2: Double @cpsParam[Any, Unit]
+
+    def p(i: Int): Double @cpsParam[Unit, Any] = {
+      val px = s1
+      val pct = if (px > 100) px else px / s2
+      println("pct = %.3f".format(pct))
+      pct
+    }
+  }
+
+  def main(args: Array[String]) : Unit = {
+    var d: Double = 0d
+    def d2 = d * d
+
+    val irr = new IfReturnRepro {
+      def s1 = shift(f => f(d))
+      def s2 = shift(f => f(d2))
+    }
+    1 to 25 foreach { i =>
+      d = i
+      print("d = " + i + ", d2 = " + d2 + ", ")
+      run(irr p i)
+    }
+  }
+}
diff --git a/test/files/continuations-run/z1673.check b/test/files/continuations-run/z1673.check
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/test/files/continuations-run/z1673.check
diff --git a/test/files/continuations-run/z1673.scala b/test/files/continuations-run/z1673.scala
new file mode 100644
index 0000000000..716b374860
--- /dev/null
+++ b/test/files/continuations-run/z1673.scala
@@ -0,0 +1,31 @@
+import scala.util.continuations._
+
+class MatchRepro {
+  def s: String @cps[Any] = shift { k => k("foo") }
+
+  def p = {
+    val k = s
+    s match { case lit0 => }
+  }
+
+  def q = {
+    val k = s
+    k match { case lit1 => }
+  }
+
+  def r = {
+    s match { case "FOO" => }
+  }
+
+  def t = {
+    val k = s
+    k match { case "FOO" => }
+  }
+}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val m = new MatchRepro
+    ()
+  }
+}
diff --git a/test/files/jvm/scala-concurrent-tck.scala b/test/files/jvm/scala-concurrent-tck.scala
index 75e2b92ff6..b3470d275d 100644
--- a/test/files/jvm/scala-concurrent-tck.scala
+++ b/test/files/jvm/scala-concurrent-tck.scala
@@ -1,6 +1,3 @@
-
-
-
 import scala.concurrent.{
   Future,
   Promise,
@@ -398,6 +395,80 @@ trait Exceptions extends TestBase {
   
 }
 
+trait TryEitherExtractor extends TestBase {
+
+  import scala.util.{Try, Success, Failure}
+
+  def testSuccessMatch(): Unit = once {
+    done => 
+    val thisIsASuccess = Success(42)
+    thisIsASuccess match {
+      case Success(v) => 
+        done()
+        assert(v == 42)
+      case Failure(e) =>
+        done()
+        assert(false)
+      case other =>
+        done()
+        assert(false)
+    }
+  }
+
+  def testRightMatch(): Unit = once {
+    done =>
+    val thisIsNotASuccess: Right[Throwable, Int] = Right(43)
+    thisIsNotASuccess match {
+      case Success(v) =>
+        done()
+        assert(v == 43)
+      case Failure(e) =>
+        done()
+        assert(false)
+      case other =>
+        done()
+        assert(false)
+    }
+  }
+
+  def testFailureMatch(): Unit = once {
+    done =>
+    val thisIsAFailure = Failure(new Exception("I'm an exception"))
+    thisIsAFailure match {
+      case Success(v) =>
+        done()
+        assert(false)
+      case Failure(e) =>
+        done()
+        assert(e.getMessage == "I'm an exception")
+      case other =>
+        done()
+        assert(false)
+    }
+  }
+
+  def testLeftMatch(): Unit = once {
+    done =>
+    val thisIsNotAFailure: Left[Throwable, Int] = Left(new Exception("I'm an exception"))
+    thisIsNotAFailure match {
+      case Success(v) => 
+        done()
+        assert(false)
+      case Failure(e) =>
+        done()
+        assert(e.getMessage == "I'm an exception")
+      case other =>
+        done()
+        assert(false)
+    }
+    
+  }
+
+  testSuccessMatch()
+  testRightMatch()
+  testFailureMatch()
+  testLeftMatch()
+}
 
 object Test
 extends App
@@ -406,8 +477,11 @@ with FutureCombinators
 with FutureProjections
 with Promises
 with Exceptions
+with TryEitherExtractor
 {
   System.exit(0)
 }
 
 
+
+
diff --git a/test/files/neg/variances.check b/test/files/neg/variances.check
index dc72b05e1e..0643e533b7 100644
--- a/test/files/neg/variances.check
+++ b/test/files/neg/variances.check
@@ -1,16 +1,19 @@
 variances.scala:4: error: covariant type A occurs in contravariant position in type test.Vector[A] of value x
-  def append(x: Vector[A]): Vector[A] 
+  def append(x: Vector[A]): Vector[A]
              ^
-variances.scala:14: error: covariant type A occurs in contravariant position in type A of value a
-    private[this] def setA(a : A) = this.a = a 
-                           ^
-variances.scala:16: error: covariant type A occurs in invariant position in supertype test.C[A] of object Baz
+variances.scala:18: error: covariant type A occurs in contravariant position in type A of value a
+    private def setA3(a : A) = this.a = a
+                      ^
+variances.scala:19: error: covariant type A occurs in contravariant position in type A of value a
+    protected def setA4(a : A) = this.a = a
+                        ^
+variances.scala:21: error: covariant type A occurs in invariant position in supertype test.C[A] of object Baz
     object Baz extends C[A]
            ^
-variances.scala:63: error: covariant type A occurs in contravariant position in type => test.Covariant.T[A]{val m: A => A} of value x
+variances.scala:74: error: covariant type A occurs in contravariant position in type => test.Covariant.T[A]{val m: A => A} of value x
     val x: T[A] {
         ^
-variances.scala:79: error: covariant type T occurs in contravariant position in type => test.TestAlias.B[C.this.A] of method foo
+variances.scala:90: error: covariant type T occurs in contravariant position in type => test.TestAlias.B[C.this.A] of method foo
     def foo: B[A]
         ^
-5 errors found
+6 errors found
diff --git a/test/files/neg/variances.scala b/test/files/neg/variances.scala
index 726bc35270..10ca111cd0 100644
--- a/test/files/neg/variances.scala
+++ b/test/files/neg/variances.scala
@@ -1,7 +1,7 @@
 package test
 
 trait Vector[+A] {
-  def append(x: Vector[A]): Vector[A] 
+  def append(x: Vector[A]): Vector[A]
   private[this] def append3(x: Vector[A]): Vector[A] = append(x)
 }
 
@@ -11,19 +11,27 @@ object Covariant {
   class Foo[+A] {
     private[this] var a : A = _
     def getA : A = a
-    private[this] def setA(a : A) = this.a = a 
-    
+    // allowed
+    private[this] def setA1(a : A) = this.a = a
+    protected[this] def setA2(a : A) = this.a = a
+    // forbidden
+    private def setA3(a : A) = this.a = a
+    protected def setA4(a : A) = this.a = a
+
     object Baz extends C[A]
     trait Convert[B] {
       def b2a(b : B) : A
-      def doit(b : B) = setA(b2a(b))
+      def doit1(b : B) = setA1(b2a(b))
+      def doit2(b : B) = setA2(b2a(b))
+      def doit3(b : B) = setA3(b2a(b))
+      def doit4(b : B) = setA4(b2a(b))
     }
   }
   class Foo2[+A] {
     private[this] var a : A = _
     def getA : A = a
-    private[this] def setA(a : A) = this.a = a 
-    
+    private[this] def setA(a : A) = this.a = a
+
     {
       trait Convert[B] {
         def b2a(b : B) : A
@@ -35,8 +43,8 @@ object Covariant {
   class Foo3[+A] {
     private[this] var a : A = _
     def getA : A = a
-    private[this] def setA(a : A) = this.a = a 
-    
+    private[this] def setA(a : A) = this.a = a
+
     private[this] trait Convert[B] {
       def b2a(b : B) : A
       def doit(b : B) = setA(b2a(b))
@@ -54,7 +62,10 @@ object Covariant {
   }
   def main(args : Array[String]) {
     val test = new Test
-    test.c.doit(test.b)
+    test.c.doit1(test.b)
+    test.c.doit2(test.b)
+    test.c.doit3(test.b)
+    test.c.doit4(test.b)
     val x : java.lang.Character = test.a.getA
     Console.println("XXX " + x)
   }
diff --git a/test/files/pos/t3272.scala b/test/files/pos/t3272.scala
new file mode 100644
index 0000000000..8efd5ded2c
--- /dev/null
+++ b/test/files/pos/t3272.scala
@@ -0,0 +1,8 @@
+trait A {
+  trait C[+T] {
+    protected[this] def f(t: T) {}
+  }
+  trait D[T] extends C[T] {
+    def g(t: T) { f(t) }
+  }
+}
diff --git a/test/files/pos/t4910.scala b/test/files/pos/t4910.scala
new file mode 100644
index 0000000000..c66fd523f5
--- /dev/null
+++ b/test/files/pos/t4910.scala
@@ -0,0 +1,6 @@
+class A {
+  implicit object foo
+  // it compiles if we uncomment this
+  // implicit val bar = foo
+  implicitly[foo.type]
+}
diff --git a/test/files/presentation/memory-leaks.check b/test/files/presentation/memory-leaks.check
new file mode 100644
index 0000000000..9d8cbb4da4
--- /dev/null
+++ b/test/files/presentation/memory-leaks.check
@@ -0,0 +1,14 @@
+reload: Trees.scala, Typers.scala, Types.scala
+reload: Trees.scala
+reload: Types.scala
+reload: Typers.scala
+reload: Typers.scala
+reload: Typers.scala
+reload: Typers.scala
+reload: Typers.scala
+reload: Typers.scala
+reload: Typers.scala
+reload: Typers.scala
+reload: Typers.scala
+reload: Typers.scala
+No leaks detected.
diff --git a/test/files/presentation/memory-leaks/MemoryLeaksTest.scala b/test/files/presentation/memory-leaks/MemoryLeaksTest.scala
new file mode 100644
index 0000000000..e24f36d7b6
--- /dev/null
+++ b/test/files/presentation/memory-leaks/MemoryLeaksTest.scala
@@ -0,0 +1,125 @@
+import java.io.PrintWriter
+import java.io.FileOutputStream
+import java.util.Calendar
+
+import scala.tools.nsc.interactive.tests._
+import scala.tools.nsc.util._
+import scala.tools.nsc.io._
+
+/** This test runs the presentation compiler on the Scala compiler project itself and records memory consumption.
+ * 
+ * The test scenario is to open Typers, Trees and Types, then repeatedly add and remove one character
+ * in Typers.scala. Each step causes the parser, namer, and type checker to run.
+ * 
+ * At each step we record the memory usage after the GC has run. At the end of the test, 
+ * simple linear regression is used to compute the straight line that best fits the
+ * curve, and if the slope is higher than 1 (meaning a leak of 1MB/run), we fail the test.
+ * 
+ * The Scala compiler sources are assumed to be under 'basedir/src/compiler'.
+ * 
+ * The individual data points are saved under 'usedMem-<date>.txt', under the test project
+ * directory. Use the cool graph-it.R (https://github.com/scala-ide/scala-ide/blob/master/org.scala-ide.sdt.core.tests/graph-it.R)
+ *  script to see the memory curve for the given test run.
+ */
+object Test extends InteractiveTest {
+  final val mega = 1024 * 1024
+
+  override def main(args: Array[String]) {
+    memoryConsumptionTest()
+    compiler.askShutdown()
+  }
+
+  def batchSource(name: String) =
+    new BatchSourceFile(AbstractFile.getFile(name))
+
+  def memoryConsumptionTest() {
+    val N = 10
+    val filename = "usedmem-%tF.txt".format(Calendar.getInstance.getTime)
+
+    val typerUnit = AbstractFile.getFile(baseDir.parent.parent.parent.parent / "src/compiler/scala/tools/nsc/typechecker/Typers.scala")
+    val typesUnit = AbstractFile.getFile(baseDir.parent.parent.parent.parent / "src/compiler/scala/reflect/internal/Types.scala")
+    val treesUnit = AbstractFile.getFile(baseDir.parent.parent.parent.parent / "src/compiler/scala/reflect/internal/Trees.scala")
+
+    askReload(Seq(new BatchSourceFile(typerUnit), new BatchSourceFile(typesUnit), new BatchSourceFile(treesUnit)))   
+    typeCheckWith(treesUnit, new String(treesUnit.toCharArray))
+    typeCheckWith(typesUnit, new String(typesUnit.toCharArray))
+
+    val originalTyper = new String(typerUnit.toCharArray)
+
+    val (prefix, postfix) = originalTyper.splitAt(originalTyper.indexOf("import global._"))
+    val changedTyper = prefix + " a\n " + postfix
+
+    val usedMem = for (i <- 1 to N) yield {
+      val src = if (i % 2 == 0) originalTyper else changedTyper
+
+      val usedMem = withGC {
+        typeCheckWith(typerUnit, src)
+      }
+
+//      println("UsedMem:\t%d\t%d".format(i, usedMem / mega))
+      usedMem / mega // report size in MB
+    }
+
+  //  println("=" * 80)
+    
+    val outputFile = new PrintWriter(new FileOutputStream(filename))
+    outputFile.println("\tusedMem")
+    for ((dataPoint, i) <- usedMem.zipWithIndex) {
+      outputFile.println("%d\t%d".format(i, dataPoint))
+    }
+    outputFile.close()
+    // drop the first two measurements, since the compiler needs some memory when initializing
+    val (a, b) = linearModel((3L to N).toSeq, usedMem.drop(2))
+    //println("LinearModel: constant: %.4f\tslope:%.4f".format(a, b))
+    
+    if (b > 1.0)
+      println("Rate of memory consumption is alarming! %.4f MB/run".format(b))
+    else
+      println("No leaks detected.")
+  }
+
+  private def typeCheckWith(file: AbstractFile, src: String) = {
+    val sourceFile = new BatchSourceFile(file, src.toCharArray)
+    askReload(Seq(sourceFile))
+    askLoadedTyped(sourceFile).get // block until it's here
+  }
+  
+  
+  /** Return the linear model of these values, (a, b). First value is the constant factor, 
+   *  second value is the slope, i.e. `y = a + bx`
+   * 
+   *  The linear model of a set of points is a straight line that minimizes the square distance 
+   *  between the each point and the line.
+   * 
+   *  See: http://en.wikipedia.org/wiki/Simple_linear_regression
+   */
+  def linearModel(xs: Seq[Long], ys: Seq[Long]): (Double, Double) = {
+    require(xs.length == ys.length)
+    
+    def mean(v: Seq[Long]): Double = v.sum.toDouble / v.length
+      
+    val meanXs = mean(xs)
+    val meanYs = mean(ys)
+    
+    val beta = (mean((xs, ys).zipped.map(_ * _)) - meanXs * meanYs) / (mean(xs.map(x => x * x)) - meanXs * meanXs)
+    val alfa = meanYs - beta * meanXs
+    
+    (alfa, beta)
+  }
+
+  /** Run the given closure and return the amount of used memory at the end of its execution.
+   * 
+   *  Runs the GC before and after the execution of `f'. 
+   */
+  def withGC(f: => Unit): Long = {
+    val r = Runtime.getRuntime
+    System.gc()
+
+    f;
+
+    System.gc()
+
+    r.totalMemory() - r.freeMemory()
+  }
+
+}
\ No newline at end of file
diff --git a/test/files/run/concurrent-map-conversions.scala b/test/files/run/concurrent-map-conversions.scala
new file mode 100644
index 0000000000..0350b69642
--- /dev/null
+++ b/test/files/run/concurrent-map-conversions.scala
@@ -0,0 +1,36 @@
+
+
+
+
+
+object Test {
+  
+  def main(args: Array[String]) {
+    testConversions()
+    testConverters()
+  }
+  
+  def needPackageConcurrentMap(map: collection.concurrent.Map[Int, Int]) {
+  }
+  def needJavaConcurrent(map: java.util.concurrent.ConcurrentMap[Int, Int]) {
+  }
+  
+  def testConversions() {
+    import collection.JavaConversions._
+    val skiplist = new java.util.concurrent.ConcurrentSkipListMap[Int, Int]
+    val ctrie = new collection.concurrent.TrieMap[Int, Int]
+    
+    needPackageConcurrentMap(skiplist)
+    needJavaConcurrent(ctrie)
+  }
+  
+  def testConverters() {
+    import collection.JavaConverters._
+    val skiplist = new java.util.concurrent.ConcurrentSkipListMap[Int, Int]
+    val ctrie = new collection.concurrent.TrieMap[Int, Int]
+    
+    needPackageConcurrentMap(skiplist.asScala)
+    needJavaConcurrent(ctrie.asJava)
+  }
+  
+}
diff --git a/test/files/run/is-valid-num.scala b/test/files/run/is-valid-num.scala
index f919a21dee..9c43e98911 100644
--- a/test/files/run/is-valid-num.scala
+++ b/test/files/run/is-valid-num.scala
@@ -1,11 +1,15 @@
 object Test {
   def x = BigInt("10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
   def y = BigDecimal("" + (Short.MaxValue + 1) + ".0")
+  def y1 = BigDecimal("0.1")
+  def y2 = BigDecimal("0.5")
   
   def l1 = Int.MaxValue.toLong + 1
   def l2 = Int.MinValue.toLong - 1
 
   def main(args: Array[String]): Unit = {
+    assert(!x.isValidDouble, x)
+    assert(!x.isValidFloat, x)
     assert(!x.isValidLong, x)
     assert(!x.isValidInt, x)
     assert(!x.isValidChar, x)
@@ -13,8 +17,81 @@ object Test {
     assert(!y.isValidShort, y)
     assert(y.isValidChar, y)
     assert(y.isValidInt, y)
+    assert(y.isValidFloat, y)
+    assert(y.isValidDouble, y)
+    assert(!y1.isValidLong, y1)
+    assert(!y1.isValidFloat, y1)
+    assert(!y1.isValidDouble, y1)
+    assert(!y2.isValidLong, y2)
+    assert(y2.isValidFloat, y2)
+    assert(y2.isValidDouble, y2)
+
+    testBigIntIsFloat()
+    testBigIntIsDouble()
 
     assert(!l1.isValidInt && (l1 - 1).isValidInt, l1)
     assert(!l2.isValidInt && (l2 + 1).isValidInt, l2)
   }
+
+  def biExp2(e: Int) = BigInt(1) << e
+
+  def testBigIntIsFloat() {
+    val prec = 24
+    def checkFloatT(x: BigInt) = {
+      assert(x.isValidFloat, x)
+      assert((-x).isValidFloat, -x)
+    }
+    def checkFloatF(x: BigInt) = {
+      assert(!x.isValidFloat, x)
+      assert(!(-x).isValidFloat, -x)
+    } 
+    checkFloatT(biExp2(prec) - 1)
+    checkFloatT(biExp2(prec))
+    checkFloatF(biExp2(prec) + 1)
+    checkFloatT(biExp2(prec) + 2)
+    checkFloatT(biExp2(prec) - 2)
+    checkFloatF(biExp2(prec + 1) - 1)
+    checkFloatT(biExp2(prec + 1))
+    checkFloatF(biExp2(prec + 1) + 1)
+    checkFloatF(biExp2(prec + 1) + 2)
+    checkFloatF(biExp2(prec + 1) + 3)
+    checkFloatT(biExp2(prec + 1) + 4)
+    checkFloatT(biExp2(64))
+    checkFloatF(biExp2(64) + biExp2(64 - prec))
+    checkFloatT(biExp2(64) + biExp2(64 - prec + 1))
+    checkFloatT(biExp2(127))
+    checkFloatT(biExp2(128) - biExp2(128 - prec))
+    checkFloatF(biExp2(128) - biExp2(128 - prec - 1))
+    checkFloatF(biExp2(128))
+  }
+
+  def testBigIntIsDouble() {
+    val prec = 53
+    def checkDoubleT(x: BigInt) = {
+      assert(x.isValidDouble, x)
+      assert((-x).isValidDouble, -x)
+    }
+    def checkDoubleF(x: BigInt) = {
+      assert(!x.isValidDouble, x)
+      assert(!(-x).isValidDouble, -x)
+    }
+    checkDoubleT(biExp2(prec) - 1)
+    checkDoubleT(biExp2(prec))
+    checkDoubleF(biExp2(prec) + 1)
+    checkDoubleT(biExp2(prec) + 2)
+    checkDoubleT(biExp2(prec + 1) - 2)
+    checkDoubleF(biExp2(prec + 1) - 1)
+    checkDoubleT(biExp2(prec + 1))
+    checkDoubleF(biExp2(prec + 1) + 1)
+    checkDoubleF(biExp2(prec + 1) + 2)
+    checkDoubleF(biExp2(prec + 1) + 3)
+    checkDoubleT(biExp2(prec + 1) + 4)
+    checkDoubleT(biExp2(64))
+    checkDoubleF(biExp2(64) + biExp2(64 - prec))
+    checkDoubleT(biExp2(64) + biExp2(64 - prec + 1))
+    checkDoubleT(biExp2(1023))
+    checkDoubleT(biExp2(1024) - biExp2(1024 - prec))
+    checkDoubleF(biExp2(1024) - biExp2(1024 - prec - 1))
+    checkDoubleF(biExp2(1024))
+  }
 }
diff --git a/test/files/run/numbereq.scala b/test/files/run/numbereq.scala
index 77a217df36..a1f11da205 100644
--- a/test/files/run/numbereq.scala
+++ b/test/files/run/numbereq.scala
@@ -16,7 +16,20 @@ object Test {
     
     base ::: extras
   }
-      
+
+  def mkNumbers(x: BigInt): List[AnyRef] = {
+    List(
+      List(BigDecimal(x, java.math.MathContext.UNLIMITED)), 
+      List(x),
+      if (x.isValidDouble) List(new java.lang.Double(x.toDouble)) else Nil,
+      if (x.isValidFloat) List(new java.lang.Float(x.toFloat)) else Nil,
+      if (x.isValidLong) List(new java.lang.Long(x.toLong)) else Nil,
+      if (x.isValidInt) List(new java.lang.Integer(x.toInt)) else Nil,
+      if (x.isValidShort) List(new java.lang.Short(x.toShort)) else Nil,
+      if (x.isValidByte) List(new java.lang.Byte(x.toByte)) else Nil,
+      if (x.isValidChar) List(new java.lang.Character(x.toChar)) else Nil
+    ).flatten
+  }
   
   def main(args: Array[String]): Unit = {
     val ints    = (0 to 15).toList map (Short.MinValue >> _)
@@ -37,5 +50,23 @@ object Test {
       assert(x == y, "%s/%s != %s/%s".format(x, x.getClass, y, y.getClass))
       assert(x.## == y.##, "%s != %s".format(x.getClass, y.getClass))
     }
+
+    val bigInts  = (0 to 1024).toList map (BigInt(-1) << _)
+    val bigInts2 = bigInts map (x => -x)
+    val bigInts3 = bigInts map (_ + 1)
+    val bigInts4 = bigInts2 map (_ - 1)
+    
+    val setneg1b = bigInts map mkNumbers
+    val setneg2b = bigInts3 map mkNumbers
+    val setpos1b = bigInts2 map mkNumbers
+    val setpos2b = bigInts4 map mkNumbers
+
+    val sets2 = setneg1 ++ setneg1b ++ setneg2 ++ setneg2b ++ List(zero) ++ setpos1 ++ setpos1b ++ setpos2 ++ setpos2b
+    
+    for (set <- sets2 ; x <- set ; y <- set) {
+//      println("'%s' == '%s' (%s == %s) (%s == %s)".format(x, y, x.hashCode, y.hashCode, x.##, y.##))
+      assert(x == y, "%s/%s != %s/%s".format(x, x.getClass, y, y.getClass))
+//      assert(x.## == y.##, "%s != %s".format(x.getClass, y.getClass))    Disable until Double.## is fixed (SI-5640)
+    }
   }
-}
\ No newline at end of file
+}
diff --git a/test/files/run/option-fold.check b/test/files/run/option-fold.check
new file mode 100644
index 0000000000..4e3fe99f98
--- /dev/null
+++ b/test/files/run/option-fold.check
@@ -0,0 +1,5 @@
+List()
+List(5)
+-1
+0
+1
diff --git a/test/files/run/option-fold.scala b/test/files/run/option-fold.scala
new file mode 100644
index 0000000000..d554ba4f9b
--- /dev/null
+++ b/test/files/run/option-fold.scala
@@ -0,0 +1,19 @@
+object Test {
+  sealed class A
+  case object B extends A
+  case class C(x: Int) extends A
+  
+  def f[T](x: Option[T]) = x.fold(List.empty[T])(List(_))
+  def g(x: Option[A]) = x.fold(-1) {
+    case B    => 0
+    case C(x) => x
+  }
+
+  def main(args: Array[String]): Unit = {
+    println(f(None))
+    println(f(Some(5)))
+    println(g(None))
+    println(g(Some(B)))
+    println(g(Some(C(1))))
+  }
+}
diff --git a/test/files/run/reflect-overload.scala b/test/files/run/reflect-overload.scala
new file mode 100644
index 0000000000..af82a1948d
--- /dev/null
+++ b/test/files/run/reflect-overload.scala
@@ -0,0 +1,16 @@
+object Test extends App {
+  import reflect.mirror._
+
+  val s = "hello world"
+  val sc = symbolOfInstance(s)
+  val st = sc.asType
+  val m = st member newTermName("indexOf")
+  val IntType = definitions.IntClass.asType
+  val indexOf = m resolveOverloaded(actuals = List(IntType))
+  assert(invoke(s, indexOf)('w') == 6)
+  assert((invoke(s, indexOf)('w') match { case x: Int => x }) == 6)
+
+  val m2 = st member newTermName("substring")
+  val substring = m2 resolveOverloaded(actuals = List(IntType, IntType))
+  assert(invoke(s, substring)(2, 6) == "llo ")
+}