Merge pull request #2906 from retronym/merge/2.10.x-to-2.10.3v2.10.3-RC2

Merge/2.10.x to 2.10.3

28 files changed, 668 insertions, 136 deletions

diff --git a/test/files/gitignore.SAMPLE b/test/files/.gitignore
index 161be5b55f..161be5b55f 100644
--- a/test/files/gitignore.SAMPLE
+++ b/test/files/.gitignore
diff --git a/test/files/pos/t4760.scala b/test/files/pos/t4760.scala
new file mode 100644
index 0000000000..767e3847f4
--- /dev/null
+++ b/test/files/pos/t4760.scala
@@ -0,0 +1,34 @@
+
+class Test {
+  // parses
+  def f1 = {
+    import scala._;
+  }
+  // b.scala:7: error: ';' expected but '}' found.
+  //   }
+  //   ^
+  // one error found
+  def f2 = {
+    import scala._
+  }
+  def f2b = {
+    import scala.collection.mutable.{ Map => MMap }
+  }
+  def f(): Unit = {
+    locally {
+      import scala.util.Properties.lineSeparator
+    }
+  }
+  
+  // parses
+  def f3 = {
+    import scala._
+    5
+  }
+  locally { (x: Int) =>
+    import scala.util._
+  }
+  1 match {
+    case 1 => import scala.concurrent._
+  }
+}
diff --git a/test/files/pos/t7486-named.scala b/test/files/pos/t7486-named.scala
new file mode 100644
index 0000000000..253293e5f1
--- /dev/null
+++ b/test/files/pos/t7486-named.scala
@@ -0,0 +1,8 @@
+
+object Test {
+  def fold(empty: Any) = ()
+  implicit val notAnnotatedImplicit = new {
+    fold(empty = 0)
+    def empty[A]: Any = ???
+  }
+}
diff --git a/test/pending/pos/t7486.scala b/test/files/pos/t7486.scala
index 6dd7f4c4ac..6dd7f4c4ac 100644
--- a/test/pending/pos/t7486.scala
+++ b/test/files/pos/t7486.scala
diff --git a/test/files/pos/t7782.scala b/test/files/pos/t7782.scala
new file mode 100644
index 0000000000..037bdad673
--- /dev/null
+++ b/test/files/pos/t7782.scala
@@ -0,0 +1,25 @@
+package pack
+
+object Test {
+  import O.empty
+  empty // this will trigger completion of `test`
+        // with skolemizationLevel = 1
+}
+
+object O {
+  // order matters (!!!)
+
+  // this order breaks under 2.10.x
+  def empty[E]: C[E] = ???
+  def empty(implicit a: Any): Any = ???
+}
+
+abstract class C[E] {
+  def foo[BB](f: BB)
+  def test[B](f: B): Any = foo(f)
+  // error: no type parameters for method foo: (<param> f: BB)scala.this.Unit exist so that it can be applied to arguments (B&1)
+  // --- because ---
+  // argument expression's type is not compatible with formal parameter type;
+  // found   : B&1
+  // required: ?BB
+}
diff --git a/test/files/pos/t7782b.scala b/test/files/pos/t7782b.scala
new file mode 100644
index 0000000000..09da4a5c5b
--- /dev/null
+++ b/test/files/pos/t7782b.scala
@@ -0,0 +1,25 @@
+package pack
+
+object Test {
+  import O.empty
+  empty // this will trigger completion of `test`
+        // with skolemizationLevel = 1
+}
+
+object O {
+  // order matters (!!!)
+
+  // this order breaks under 2.11.x
+  def empty(implicit a: Any): Any = ???
+  def empty[E]: C[E] = ???
+}
+
+abstract class C[E] {
+  def foo[BB](f: BB)
+  def test[B](f: B): Any = foo(f)
+  // error: no type parameters for method foo: (<param> f: BB)scala.this.Unit exist so that it can be applied to arguments (B&1)
+  // --- because ---
+  // argument expression's type is not compatible with formal parameter type;
+  // found   : B&1
+  // required: ?BB
+}
diff --git a/test/files/pos/t7818.scala b/test/files/pos/t7818.scala
new file mode 100644
index 0000000000..77b99e7d5d
--- /dev/null
+++ b/test/files/pos/t7818.scala
@@ -0,0 +1,10 @@
+class Observable1[+T](val asJava: JObservable[_ <: T]) extends AnyVal {
+  private def foo[X](a: JObservable[X]): JObservable[X] = ???
+  // was generating a type error as the type of the RHS included an existential
+  // skolem based on the class type parameter `T`, which did not conform
+  // to the typer parameter of the extension method into which the RHS is
+  // transplanted.
+  def synchronize: Observable1[T] = new Observable1(foo(asJava))
+}
+
+class JObservable[T]
diff --git a/test/files/pos/t942/Amount_1.java b/test/files/pos/t942/Amount_1.java
new file mode 100644
index 0000000000..d9d37d127b
--- /dev/null
+++ b/test/files/pos/t942/Amount_1.java
@@ -0,0 +1,5 @@
+import java.util.concurrent.Callable;
+
+public abstract class Amount_1<Q> extends Object
+    implements Callable<Amount_1<?>> {
+}
diff --git a/test/files/pos/t942/Test_2.scala b/test/files/pos/t942/Test_2.scala
new file mode 100644
index 0000000000..3cc84dae3c
--- /dev/null
+++ b/test/files/pos/t942/Test_2.scala
@@ -0,0 +1,3 @@
+abstract class Foo {
+  val x: Amount_1[Foo]
+}
diff --git a/test/files/run/WeakHashSetTest.scala b/test/files/run/WeakHashSetTest.scala
new file mode 100644
index 0000000000..3c8f380150
--- /dev/null
+++ b/test/files/run/WeakHashSetTest.scala
@@ -0,0 +1,174 @@
+object Test {
+  def main(args: Array[String]) {
+    val test = scala.reflect.internal.util.WeakHashSetTest
+    test.checkEmpty
+    test.checkPlusEquals
+    test.checkPlusEqualsCollisions
+    test.checkRehashing
+    test.checkRehashCollisions
+    test.checkFindOrUpdate
+    test.checkMinusEquals
+    test.checkMinusEqualsCollisions
+    test.checkClear
+    test.checkIterator
+    test.checkIteratorCollisions
+
+    // This test is commented out because it relies on gc behavior which isn't reliable enough in an automated environment
+    // test.checkRemoveUnreferencedObjects
+  }
+}
+
+// put the main test object in the same package as WeakHashSet because
+// it uses the package private "diagnostics" method
+package scala.reflect.internal.util {
+
+  object WeakHashSetTest {
+    // a class guaranteed to provide hash collisions
+    case class Collider(x : String) extends Comparable[Collider] with Serializable {
+      override def hashCode = 0
+      def compareTo(y : Collider) = this.x compareTo y.x
+    }
+
+    // basic emptiness check
+    def checkEmpty {
+      val hs = new WeakHashSet[String]()
+      assert(hs.size == 0)
+      hs.diagnostics.fullyValidate    
+    }
+
+    // make sure += works
+    def checkPlusEquals {
+      val hs = new WeakHashSet[String]()
+      val elements = List("hello", "goodbye")
+      elements foreach (hs += _)
+      assert(hs.size == 2)
+      assert(hs contains "hello")
+      assert(hs contains "goodbye")
+      hs.diagnostics.fullyValidate
+    }
+
+    // make sure += works when there are collisions
+    def checkPlusEqualsCollisions {
+      val hs = new WeakHashSet[Collider]()
+      val elements = List("hello", "goodbye") map Collider
+      elements foreach (hs += _)
+      assert(hs.size == 2)
+      assert(hs contains Collider("hello"))
+      assert(hs contains Collider("goodbye"))
+      hs.diagnostics.fullyValidate
+    }
+
+    // add a large number of elements to force rehashing and then validate
+    def checkRehashing {
+      val size = 200
+      val hs = new WeakHashSet[String]()
+      val elements = (0 until size).toList map ("a" + _)
+      elements foreach (hs += _)
+      elements foreach {i => assert(hs contains i)}
+      hs.diagnostics.fullyValidate
+    }
+
+    // make sure rehashing works properly when the set is rehashed
+    def checkRehashCollisions {
+      val size = 200
+      val hs = new WeakHashSet[Collider]()
+      val elements = (0 until size).toList map {x => Collider("a" + x)}
+      elements foreach (hs += _)
+      elements foreach {i => assert(hs contains i)}
+      hs.diagnostics.fullyValidate
+    }
+
+    // test that unreferenced objects are removed
+    // not run in an automated environment because gc behavior can't be relied on
+    def checkRemoveUnreferencedObjects {
+      val size = 200
+      val hs = new WeakHashSet[Collider]()
+      val elements = (0 until size).toList map {x => Collider("a" + x)}
+      elements foreach (hs += _)
+      // don't throw the following into a retained collection so gc 
+      // can remove them
+      for (i <- 0 until size) {
+        hs += Collider("b" + i)
+      }
+      System.gc()
+      Thread.sleep(1000)
+      assert(hs.size == 200)
+      elements foreach {i => assert(hs contains i)}
+      for (i <- 0 until size) {
+        assert(!(hs contains Collider("b" + i)))
+      }
+      hs.diagnostics.fullyValidate
+    }
+
+    // make sure findOrUpdate returns the originally entered element
+    def checkFindOrUpdate {
+      val size = 200
+      val hs = new WeakHashSet[Collider]()
+      val elements = (0 until size).toList map {x => Collider("a" + x)}
+      elements foreach {x => assert(hs findEntryOrUpdate x eq x)}
+      for (i <- 0 until size) {
+        // when we do a lookup the result should be the same reference we
+        // original put in
+        assert(hs findEntryOrUpdate(Collider("a" + i)) eq elements(i))
+      }
+      hs.diagnostics.fullyValidate
+    }
+
+    // check -= functionality
+    def checkMinusEquals {
+      val hs = new WeakHashSet[String]()
+      val elements = List("hello", "goodbye")
+      elements foreach (hs += _)
+      hs -= "goodbye"
+      assert(hs.size == 1)
+      assert(hs contains "hello")
+      assert(!(hs contains "goodbye"))
+      hs.diagnostics.fullyValidate
+    }
+
+    // check -= when there are collisions
+    def checkMinusEqualsCollisions {
+      val hs = new WeakHashSet[Collider]
+      val elements = List(Collider("hello"), Collider("goodbye"))
+      elements foreach (hs += _)
+      hs -= Collider("goodbye")
+      assert(hs.size == 1)
+      assert(hs contains Collider("hello"))
+      assert(!(hs contains Collider("goodbye")))
+      hs -= Collider("hello")
+      assert(hs.size == 0)
+      assert(!(hs contains Collider("hello")))
+      hs.diagnostics.fullyValidate
+    }
+
+    // check that the clear method actually cleans everything
+    def checkClear {
+      val size = 200
+      val hs = new WeakHashSet[String]()
+      val elements = (0 until size).toList map ("a" + _)
+      elements foreach (hs += _)
+      hs.clear()
+      assert(hs.size == 0)
+      elements foreach {i => assert(!(hs contains i))}
+      hs.diagnostics.fullyValidate    
+    }
+    
+    // check that the iterator covers all the contents
+    def checkIterator {
+      val hs = new WeakHashSet[String]()
+      val elements = (0 until 20).toList map ("a" + _)
+      elements foreach (hs += _)
+      assert(elements.iterator.toList.sorted == elements.sorted)
+      hs.diagnostics.fullyValidate
+    }
+    
+    // check that the iterator covers all the contents even when there is a collision
+    def checkIteratorCollisions {
+      val hs = new WeakHashSet[Collider]
+      val elements = (0 until 20).toList map {x => Collider("a" + x)}
+      elements foreach (hs += _)
+      assert(elements.iterator.toList.sorted == elements.sorted) 
+      hs.diagnostics.fullyValidate
+    }
+  }
+}  
diff --git a/test/files/run/predef-cycle.scala b/test/files/run/predef-cycle.scala
new file mode 100644
index 0000000000..ab147688bc
--- /dev/null
+++ b/test/files/run/predef-cycle.scala
@@ -0,0 +1,71 @@
+class Force {
+	val t1 = new Thread {
+    override def run() {
+      scala.`package`
+    }
+  }
+  val t2 = new Thread {
+    override def run() {
+      scala.Predef
+    }
+  }
+  t1.start()
+  t2.start()
+  t1.join()
+  t2.join()
+}
+
+object Test {
+  def main(args: Array[String]) {
+     new Force()
+  }
+}
+
+/* Was deadlocking:
+"Thread-2" prio=5 tid=7f9637268000 nid=0x119601000 in Object.wait() [119600000]
+   java.lang.Thread.State: RUNNABLE
+  at scala.Predef$.<init>(Predef.scala:90)
+  at scala.Predef$.<clinit>(Predef.scala)
+  at Force$$anon$2.run(predef-cycle.scala:10)
+
+"Thread-1" prio=5 tid=7f9637267800 nid=0x1194fe000 in Object.wait() [1194fb000]
+   java.lang.Thread.State: RUNNABLE
+  at scala.collection.immutable.Set$Set4.$plus(Set.scala:127)
+  at scala.collection.immutable.Set$Set4.$plus(Set.scala:121)
+  at scala.collection.mutable.SetBuilder.$plus$eq(SetBuilder.scala:24)
+  at scala.collection.mutable.SetBuilder.$plus$eq(SetBuilder.scala:22)
+  at scala.collection.generic.Growable$$anonfun$$plus$plus$eq$1.apply(Growable.scala:48)
+  at scala.collection.generic.Growable$$anonfun$$plus$plus$eq$1.apply(Growable.scala:48)
+  at scala.collection.immutable.List.foreach(List.scala:318)
+  at scala.collection.generic.Growable$class.$plus$plus$eq(Growable.scala:48)
+  at scala.collection.mutable.SetBuilder.$plus$plus$eq(SetBuilder.scala:22)
+  at scala.collection.TraversableLike$class.to(TraversableLike.scala:629)
+  at scala.collection.AbstractTraversable.to(Traversable.scala:105)
+  at scala.collection.TraversableOnce$class.toSet(TraversableOnce.scala:267)
+  at scala.collection.AbstractTraversable.toSet(Traversable.scala:105)
+  at scala.runtime.ScalaRunTime$.<init>(ScalaRunTime.scala:50)
+  at scala.runtime.ScalaRunTime$.<clinit>(ScalaRunTime.scala)
+  at scala.collection.mutable.HashTable$HashUtils$class.elemHashCode(HashTable.scala)
+  at scala.collection.mutable.HashMap.elemHashCode(HashMap.scala:39)
+  at scala.collection.mutable.HashTable$class.findOrAddEntry(HashTable.scala:161)
+  at scala.collection.mutable.HashMap.findOrAddEntry(HashMap.scala:39)
+  at scala.collection.mutable.HashMap.put(HashMap.scala:75)
+  at scala.collection.mutable.HashMap.update(HashMap.scala:80)
+  at scala.sys.SystemProperties$.addHelp(SystemProperties.scala:64)
+  at scala.sys.SystemProperties$.bool(SystemProperties.scala:68)
+  at scala.sys.SystemProperties$.noTraceSupression$lzycompute(SystemProperties.scala:80)
+  - locked <7b8b0e228> (a scala.sys.SystemProperties$)
+  at scala.sys.SystemProperties$.noTraceSupression(SystemProperties.scala:80)
+  at scala.util.control.NoStackTrace$.<init>(NoStackTrace.scala:31)
+  at scala.util.control.NoStackTrace$.<clinit>(NoStackTrace.scala)
+  at scala.util.control.NoStackTrace$class.fillInStackTrace(NoStackTrace.scala:22)
+  at scala.util.control.BreakControl.fillInStackTrace(Breaks.scala:93)
+  at java.lang.Throwable.<init>(Throwable.java:181)
+  at scala.util.control.BreakControl.<init>(Breaks.scala:93)
+  at scala.util.control.Breaks.<init>(Breaks.scala:28)
+  at scala.collection.Traversable$.<init>(Traversable.scala:96)
+  at scala.collection.Traversable$.<clinit>(Traversable.scala)
+  at scala.package$.<init>(package.scala:46)
+  at scala.package$.<clinit>(package.scala)
+  at Force$$anon$1.run(predef-cycle.scala:4)
+  */
\ No newline at end of file
diff --git a/test/files/run/t7269.scala b/test/files/run/t7269.scala
new file mode 100644
index 0000000000..d22e57dfee
--- /dev/null
+++ b/test/files/run/t7269.scala
@@ -0,0 +1,32 @@
+import scala.collection.JavaConversions._
+import scala.collection.mutable
+
+object Test extends App {
+
+  def testMap(): Unit = {
+    val mapJ = new java.util.HashMap[Int, String]
+    val mapS: mutable.Map[Int, String] = mapJ
+
+    (10 to 20).foreach(i => mapS += ((i, i.toString)))
+    assert(11 == mapS.size)
+
+    // ConcurrentModificationException thrown in the following line
+    mapS.retain((i, str) => i % 2 == 0)
+    assert(6 == mapS.size)
+  }
+
+  def testSet(): Unit = {
+    val mapJ = new java.util.HashSet[Int]
+    val mapS: mutable.Set[Int] = mapJ
+
+    (10 to 20).foreach(i => mapS += i)
+    assert(11 == mapS.size)
+
+    // ConcurrentModificationException thrown in the following line
+    mapS.retain((i) => i % 2 == 0)
+    assert(6 == mapS.size)
+  }
+
+  testSet()
+  testMap()
+}
diff --git a/test/files/run/t7398.scala b/test/files/run/t7398.scala
index dd59697b71..493c4dcf40 100644
--- a/test/files/run/t7398.scala
+++ b/test/files/run/t7398.scala
@@ -3,11 +3,9 @@ import scala.tools.partest._
 object Test extends CompilerTest {
   import global._
 
-  // This way we auto-pass on non-java8 since there's nothing to check
-  override lazy val units: List[CompilationUnit]  = testUnderJavaAtLeast("1.8") {
+  override lazy val units: List[CompilationUnit] = {
+    // This test itself does not depend on JDK8.
     javaCompilationUnits(global)(defaultMethodSource)
-  } otherwise {
-    Nil
   }
 
   private def defaultMethodSource = """
diff --git a/test/files/run/t7775.scala b/test/files/run/t7775.scala
new file mode 100644
index 0000000000..5fb0327611
--- /dev/null
+++ b/test/files/run/t7775.scala
@@ -0,0 +1,17 @@
+import scala.concurrent.{duration, future, Await, ExecutionContext}
+import scala.tools.nsc.Settings
+import ExecutionContext.Implicits.global
+
+// Was failing pretty regularly with a ConcurrentModificationException as
+// WrappedProperties#systemProperties iterated directly over the mutable
+// global system properties map.
+object Test {
+  def main(args: Array[String]) {
+    val tries = 1000 // YMMV
+    val compiler = future {
+      for(_ <- 1 to tries) new Settings(_ => {})
+    }
+    for(i <- 1 to tries * 10) System.setProperty(s"foo$i", i.toString)
+    Await.result(compiler, duration.Duration.Inf)
+  }
+}
diff --git a/test/files/run/t7779.scala b/test/files/run/t7779.scala
new file mode 100644
index 0000000000..db32cb751f
--- /dev/null
+++ b/test/files/run/t7779.scala
@@ -0,0 +1,67 @@
+// -Xmax-classfile-length doesn't compress top-level classes.
+// class :::::::::::::::::::::::::::::::::::::::::::::::::
+
+trait Marker
+
+class Short extends Marker
+
+// We just test with member classes
+object O {
+  object ::::::::::::::::::::::::::::::::::::::::::::::::: extends Marker
+}
+class C {
+  class D {
+    class ::::::::::::::::::::::::::::::::::::::::::::::::: extends Marker
+  }
+}
+
+package pack {
+  // abbreviates to: $colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon to $read$$iw$$iw$$colon$colon$colon$colon$colon$colon$colon$colon$$$$c39b3f245029fbed9732fc888d44231b$$$$on$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon
+  // class :::::::::::::::::::::::::::::::::::::::::::::::::
+
+  class Short extends Marker
+
+  // We just test with member classes
+  object O {
+    object ::::::::::::::::::::::::::::::::::::::::::::::::: extends Marker
+  }
+  class C {
+    class D {
+      class ::::::::::::::::::::::::::::::::::::::::::::::::: extends Marker
+    }
+  }
+  package p2 {
+    class Short extends Marker
+
+    object O {
+      object ::::::::::::::::::::::::::::::::::::::::::::::::: extends Marker
+    }
+    class C {
+      class D {
+        class ::::::::::::::::::::::::::::::::::::::::::::::::: extends Marker
+      }
+    }
+  }
+}
+
+
+object Test extends App {
+  import reflect.runtime.universe._
+  def test[T: TypeTag] = {
+    val tt = typeTag[T]
+    val clz = tt.mirror.runtimeClass(tt.tpe)
+    assert(classOf[Marker].isAssignableFrom(clz), clz.toString)
+  }
+
+  test[Short]
+  test[O.:::::::::::::::::::::::::::::::::::::::::::::::::.type]
+  test[C#D#`:::::::::::::::::::::::::::::::::::::::::::::::::`]
+
+  test[pack.Short]
+  test[pack.O.:::::::::::::::::::::::::::::::::::::::::::::::::.type]
+  test[pack.C#D#`:::::::::::::::::::::::::::::::::::::::::::::::::`]
+
+  test[pack.p2.Short]
+  test[pack.p2.O.:::::::::::::::::::::::::::::::::::::::::::::::::.type]
+  test[pack.p2.C#D#`:::::::::::::::::::::::::::::::::::::::::::::::::`]
+}
diff --git a/test/files/run/t7825.scala b/test/files/run/t7825.scala
new file mode 100644
index 0000000000..65ca06fdfc
--- /dev/null
+++ b/test/files/run/t7825.scala
@@ -0,0 +1,34 @@
+import scala.tools.partest._
+
+object Test extends CompilerTest {
+  import global._
+
+  override lazy val units: List[CompilationUnit] = {
+    // We can test this on JDK6.
+    javaCompilationUnits(global)(defaultMethodSource) ++ compilationUnits(global)(scalaExtendsDefault)
+  }
+
+  private def defaultMethodSource = """
+public interface Iterator<E> {
+    boolean hasNext();
+    E next();
+    default void remove() {
+        throw new UnsupportedOperationException("remove");
+    }
+}
+  """
+
+  private def scalaExtendsDefault = """
+object Test {
+  object X extends Iterator[String] {
+    def hasNext = true
+    def next = "!"
+  }
+}
+  """
+
+  // We're only checking we that the Scala compilation unit passes refchecks
+  // No further checks are needed here.
+  def check(source: String, unit: global.CompilationUnit): Unit = {
+  }
+}
diff --git a/test/files/run/typed-annotated.check b/test/files/run/typed-annotated.check
new file mode 100644
index 0000000000..d81cc0710e
--- /dev/null
+++ b/test/files/run/typed-annotated.check
@@ -0,0 +1 @@
+42
diff --git a/test/files/run/typed-annotated/Macros_1.scala b/test/files/run/typed-annotated/Macros_1.scala
new file mode 100644
index 0000000000..dd18c63d90
--- /dev/null
+++ b/test/files/run/typed-annotated/Macros_1.scala
@@ -0,0 +1,17 @@
+import scala.reflect.macros.Context
+import language.experimental.macros
+
+class ann extends scala.annotation.StaticAnnotation
+
+object Macros {
+  def impl(c: Context) = {
+    import c.universe._
+    // val tpt = Annotated(Apply(Select(New(Ident(newTypeName("ann"))), nme.CONSTRUCTOR), List()), Ident(newTypeName("Int")))
+    val tpt = Annotated(Apply(Select(New(Ident(newTypeName("ann"))), nme.CONSTRUCTOR), List()), TypeTree(weakTypeOf[Int]))
+    c.Expr[Unit](Block(
+      List(ValDef(Modifiers(), newTermName("x"), tpt, Literal(Constant(42)))),
+      Apply(Ident(newTermName("println")), List(Ident(newTermName("x"))))))
+  }
+
+  def foo = macro impl
+}
\ No newline at end of file
diff --git a/test/files/run/typed-annotated/Test_2.scala b/test/files/run/typed-annotated/Test_2.scala
new file mode 100644
index 0000000000..acfddae942
--- /dev/null
+++ b/test/files/run/typed-annotated/Test_2.scala
@@ -0,0 +1,3 @@
+object Test extends App {
+  Macros.foo
+}
\ No newline at end of file
diff --git a/test/instrumented/boxes.patch b/test/instrumented/boxes.patch
index 6c5ff23f9f..2bb3243221 100644
--- a/test/instrumented/boxes.patch
+++ b/test/instrumented/boxes.patch
@@ -1,5 +1,5 @@
 9c9
-<
+< 
 ---
 > /* INSTRUMENTED VERSION */
 51a52,59
diff --git a/test/instrumented/library/scala/runtime/BoxesRunTime.java b/test/instrumented/library/scala/runtime/BoxesRunTime.java
index 172ed8ee14..57799bd9b1 100644
--- a/test/instrumented/library/scala/runtime/BoxesRunTime.java
+++ b/test/instrumented/library/scala/runtime/BoxesRunTime.java
@@ -1,6 +1,6 @@
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2006-2011, LAMP/EPFL             **
+**    / __/ __// _ | / /  / _ |    (c) 2006-2013, LAMP/EPFL             **
 **  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
 ** /____/\___/_/ |_/____/_/ | |                                         **
 **                          |/                                          **
@@ -244,7 +244,7 @@ public final class BoxesRunTime
      *  as yet have not.
      *
      *  Note: Among primitives, Float.NaN != Float.NaN, but the boxed
-     *  verisons are equal.  This still needs reconciliation.
+     *  versions are equal.  This still needs reconciliation.
      */
     public static int hashFromLong(java.lang.Long n) {
         int iv = n.intValue();
@@ -258,6 +258,9 @@ public final class BoxesRunTime
 
         long lv = n.longValue();
         if (lv == dv) return java.lang.Long.valueOf(lv).hashCode();
+
+        float fv = n.floatValue();
+        if (fv == dv) return java.lang.Float.valueOf(fv).hashCode();
         else return n.hashCode();
     }
     public static int hashFromFloat(java.lang.Float n) {
diff --git a/test/instrumented/library/scala/runtime/ScalaRunTime.scala b/test/instrumented/library/scala/runtime/ScalaRunTime.scala
index 5a3f83015f..e474ae737c 100644
--- a/test/instrumented/library/scala/runtime/ScalaRunTime.scala
+++ b/test/instrumented/library/scala/runtime/ScalaRunTime.scala
@@ -1,6 +1,6 @@
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2002-2011, LAMP/EPFL             **
+**    / __/ __// _ | / /  / _ |    (c) 2002-2013, LAMP/EPFL             **
 **  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
 ** /____/\___/_/ |_/____/_/ | |                                         **
 **                          |/                                          **
@@ -8,7 +8,8 @@
 
 /* INSTRUMENTED VERSION */
 
-package scala.runtime
+package scala
+package runtime
 
 import scala.collection.{ Seq, IndexedSeq, TraversableView, AbstractIterator }
 import scala.collection.mutable.WrappedArray
@@ -17,6 +18,7 @@ import scala.collection.generic.{ Sorted }
 import scala.reflect.{ ClassTag, classTag }
 import scala.util.control.ControlThrowable
 import scala.xml.{ Node, MetaData }
+import java.lang.{ Class => jClass }
 
 import java.lang.Double.doubleToLongBits
 import java.lang.reflect.{ Modifier, Method => JMethod }
@@ -30,29 +32,21 @@ object ScalaRunTime {
   def isArray(x: Any, atLevel: Int): Boolean =
     x != null && isArrayClass(x.getClass, atLevel)
 
-  private def isArrayClass(clazz: Class[_], atLevel: Int): Boolean =
+  private def isArrayClass(clazz: jClass[_], atLevel: Int): Boolean =
     clazz.isArray && (atLevel == 1 || isArrayClass(clazz.getComponentType, atLevel - 1))
 
-  def isValueClass(clazz: Class[_]) = clazz.isPrimitive()
-  def isTuple(x: Any) = x != null && tupleNames(x.getClass.getName)
+  def isValueClass(clazz: jClass[_]) = clazz.isPrimitive()
+
+  // includes specialized subclasses and future proofed against hypothetical TupleN (for N > 22)
+  def isTuple(x: Any) = x != null && x.getClass.getName.startsWith("scala.Tuple")
   def isAnyVal(x: Any) = x match {
     case _: Byte | _: Short | _: Char | _: Int | _: Long | _: Float | _: Double | _: Boolean | _: Unit => true
     case _                                                                                             => false
   }
-  // Avoiding boxing which messes up the specialized tests.  Don't ask.
-  private val tupleNames = {
-    var i = 22
-    var names: List[String] = Nil
-    while (i >= 1) {
-      names ::= ("scala.Tuple" + String.valueOf(i))
-      i -= 1
-    }
-    names.toSet
-  }
 
   /** Return the class object representing an array with element class `clazz`.
    */
-  def arrayClass(clazz: Class[_]): Class[_] = {
+  def arrayClass(clazz: jClass[_]): jClass[_] = {
     // newInstance throws an exception if the erasure is Void.TYPE. see SI-5680
     if (clazz == java.lang.Void.TYPE) classOf[Array[Unit]]
     else java.lang.reflect.Array.newInstance(clazz, 0).getClass
@@ -60,18 +54,19 @@ object ScalaRunTime {
 
   /** Return the class object representing elements in arrays described by a given schematic.
    */
-  def arrayElementClass(schematic: Any): Class[_] = schematic match {
-    case cls: Class[_] => cls.getComponentType
+  def arrayElementClass(schematic: Any): jClass[_] = schematic match {
+    case cls: jClass[_]   => cls.getComponentType
     case tag: ClassTag[_] => tag.runtimeClass
-    case _ => throw new UnsupportedOperationException("unsupported schematic %s (%s)".format(schematic, if (schematic == null) "null" else schematic.getClass))
+    case _                =>
+      throw new UnsupportedOperationException(s"unsupported schematic $schematic (${schematic.getClass})")
   }
 
   /** Return the class object representing an unboxed value type,
    *  e.g. classOf[int], not classOf[java.lang.Integer].  The compiler
    *  rewrites expressions like 5.getClass to come here.
    */
-  def anyValClass[T <: AnyVal : ClassTag](value: T): Class[T] =
-    classTag[T].runtimeClass.asInstanceOf[Class[T]]
+  def anyValClass[T <: AnyVal : ClassTag](value: T): jClass[T] =
+    classTag[T].runtimeClass.asInstanceOf[jClass[T]]
 
   var arrayApplyCount = 0
 
@@ -93,11 +88,9 @@ object ScalaRunTime {
     }
   }
 
-  var arrayUpdateCount = 0
-
   /** update generic array element */
   def array_update(xs: AnyRef, idx: Int, value: Any): Unit = {
-    arrayUpdateCount += 1
+    arrayApplyCount += 1
     xs match {
       case x: Array[AnyRef]  => x(idx) = value.asInstanceOf[AnyRef]
       case x: Array[Int]     => x(idx) = value.asInstanceOf[Int]
@@ -156,7 +149,7 @@ object ScalaRunTime {
       dest
   }
 
-  def toArray[T](xs: collection.Seq[T]) = {
+  def toArray[T](xs: scala.collection.Seq[T]) = {
     val arr = new Array[AnyRef](xs.length)
     var i = 0
     for (x <- xs) {
@@ -179,39 +172,10 @@ object ScalaRunTime {
   def checkInitialized[T <: AnyRef](x: T): T =
     if (x == null) throw new UninitializedError else x
 
-  abstract class Try[+A] {
-    def Catch[B >: A](handler: PartialFunction[Throwable, B]): B
-    def Finally(fin: => Unit): A
-  }
-
-  def Try[A](block: => A): Try[A] = new Try[A] with Runnable {
-    private var result: A = _
-    private var exception: Throwable =
-      try   { run() ; null }
-      catch {
-        case e: ControlThrowable  => throw e  // don't catch non-local returns etc
-        case e: Throwable         => e
-      }
-
-    def run() { result = block }
-
-    def Catch[B >: A](handler: PartialFunction[Throwable, B]): B =
-      if (exception == null) result
-      else if (handler isDefinedAt exception) handler(exception)
-      else throw exception
-
-    def Finally(fin: => Unit): A = {
-      fin
-
-      if (exception == null) result
-      else throw exception
-    }
-  }
-
   def _toString(x: Product): String =
     x.productIterator.mkString(x.productPrefix + "(", ",", ")")
 
-  def _hashCode(x: Product): Int = scala.util.MurmurHash3.productHash(x)
+  def _hashCode(x: Product): Int = scala.util.hashing.MurmurHash3.productHash(x)
 
   /** A helper for case classes. */
   def typedProductIterator[T](x: Product): Iterator[T] = {
@@ -246,12 +210,12 @@ object ScalaRunTime {
   // Note that these are the implementations called by ##, so they
   // must not call ## themselves.
 
-  @inline def hash(x: Any): Int =
+  def hash(x: Any): Int =
     if (x == null) 0
     else if (x.isInstanceOf[java.lang.Number]) BoxesRunTime.hashFromNumber(x.asInstanceOf[java.lang.Number])
     else x.hashCode
 
-  @inline def hash(dv: Double): Int = {
+  def hash(dv: Double): Int = {
     val iv = dv.toInt
     if (iv == dv) return iv
 
@@ -261,7 +225,7 @@ object ScalaRunTime {
     val fv = dv.toFloat
     if (fv == dv) fv.hashCode else dv.hashCode
   }
-  @inline def hash(fv: Float): Int = {
+  def hash(fv: Float): Int = {
     val iv = fv.toInt
     if (iv == fv) return iv
 
@@ -269,29 +233,29 @@ object ScalaRunTime {
     if (lv == fv) return hash(lv)
     else fv.hashCode
   }
-  @inline def hash(lv: Long): Int = {
+  def hash(lv: Long): Int = {
     val low = lv.toInt
     val lowSign = low >>> 31
     val high = (lv >>> 32).toInt
     low ^ (high + lowSign)
   }
-  @inline def hash(x: Number): Int  = runtime.BoxesRunTime.hashFromNumber(x)
+  def hash(x: Number): Int  = runtime.BoxesRunTime.hashFromNumber(x)
 
   // The remaining overloads are here for completeness, but the compiler
   // inlines these definitions directly so they're not generally used.
-  @inline def hash(x: Int): Int = x
-  @inline def hash(x: Short): Int = x.toInt
-  @inline def hash(x: Byte): Int = x.toInt
-  @inline def hash(x: Char): Int = x.toInt
-  @inline def hash(x: Boolean): Int = if (x) true.hashCode else false.hashCode
-  @inline def hash(x: Unit): Int = 0
+  def hash(x: Int): Int = x
+  def hash(x: Short): Int = x.toInt
+  def hash(x: Byte): Int = x.toInt
+  def hash(x: Char): Int = x.toInt
+  def hash(x: Boolean): Int = if (x) true.hashCode else false.hashCode
+  def hash(x: Unit): Int = 0
 
   /** A helper method for constructing case class equality methods,
    *  because existential types get in the way of a clean outcome and
    *  it's performing a series of Any/Any equals comparisons anyway.
    *  See ticket #2867 for specifics.
    */
-  def sameElements(xs1: collection.Seq[Any], xs2: collection.Seq[Any]) = xs1 sameElements xs2
+  def sameElements(xs1: scala.collection.Seq[Any], xs2: scala.collection.Seq[Any]) = xs1 sameElements xs2
 
   /** Given any Scala value, convert it to a String.
    *
@@ -358,7 +322,7 @@ object ScalaRunTime {
       case x: String                    => if (x.head.isWhitespace || x.last.isWhitespace) "\"" + x + "\"" else x
       case x if useOwnToString(x)       => x.toString
       case x: AnyRef if isArray(x)      => arrayToString(x)
-      case x: collection.Map[_, _]      => x.iterator take maxElements map mapInner mkString (x.stringPrefix + "(", ", ", ")")
+      case x: scala.collection.Map[_, _]      => x.iterator take maxElements map mapInner mkString (x.stringPrefix + "(", ", ", ")")
       case x: Iterable[_]               => x.iterator take maxElements map inner mkString (x.stringPrefix + "(", ", ", ")")
       case x: Traversable[_]            => x take maxElements map inner mkString (x.stringPrefix + "(", ", ", ")")
       case x: Product1[_] if isTuple(x) => "(" + inner(x._1) + ",)" // that special trailing comma
diff --git a/test/instrumented/srt.patch b/test/instrumented/srt.patch
index 47dcfa2197..ee619b2ecb 100644
--- a/test/instrumented/srt.patch
+++ b/test/instrumented/srt.patch
@@ -1,67 +1,10 @@
 8a9,10
 > /* INSTRUMENTED VERSION */
 > 
-73a76,77
+68a71,72
 >   var arrayApplyCount = 0
 > 
-75,86c79,93
-<   def array_apply(xs: AnyRef, idx: Int): Any = xs match {
-<     case x: Array[AnyRef]  => x(idx).asInstanceOf[Any]
-<     case x: Array[Int]     => x(idx).asInstanceOf[Any]
-<     case x: Array[Double]  => x(idx).asInstanceOf[Any]
-<     case x: Array[Long]    => x(idx).asInstanceOf[Any]
-<     case x: Array[Float]   => x(idx).asInstanceOf[Any]
-<     case x: Array[Char]    => x(idx).asInstanceOf[Any]
-<     case x: Array[Byte]    => x(idx).asInstanceOf[Any]
-<     case x: Array[Short]   => x(idx).asInstanceOf[Any]
-<     case x: Array[Boolean] => x(idx).asInstanceOf[Any]
-<     case x: Array[Unit]    => x(idx).asInstanceOf[Any]
-<     case null => throw new NullPointerException
----
->   def array_apply(xs: AnyRef, idx: Int): Any = {
+70a75
+>     arrayApplyCount += 1
+87a93
 >     arrayApplyCount += 1
->     xs match {
->       case x: Array[AnyRef]  => x(idx).asInstanceOf[Any]
->       case x: Array[Int]     => x(idx).asInstanceOf[Any]
->       case x: Array[Double]  => x(idx).asInstanceOf[Any]
->       case x: Array[Long]    => x(idx).asInstanceOf[Any]
->       case x: Array[Float]   => x(idx).asInstanceOf[Any]
->       case x: Array[Char]    => x(idx).asInstanceOf[Any]
->       case x: Array[Byte]    => x(idx).asInstanceOf[Any]
->       case x: Array[Short]   => x(idx).asInstanceOf[Any]
->       case x: Array[Boolean] => x(idx).asInstanceOf[Any]
->       case x: Array[Unit]    => x(idx).asInstanceOf[Any]
->       case null => throw new NullPointerException
->     }
-88a96,97
->   var arrayUpdateCount = 0
-> 
-90,101c99,113
-<   def array_update(xs: AnyRef, idx: Int, value: Any): Unit = xs match {
-<     case x: Array[AnyRef]  => x(idx) = value.asInstanceOf[AnyRef]
-<     case x: Array[Int]     => x(idx) = value.asInstanceOf[Int]
-<     case x: Array[Double]  => x(idx) = value.asInstanceOf[Double]
-<     case x: Array[Long]    => x(idx) = value.asInstanceOf[Long]
-<     case x: Array[Float]   => x(idx) = value.asInstanceOf[Float]
-<     case x: Array[Char]    => x(idx) = value.asInstanceOf[Char]
-<     case x: Array[Byte]    => x(idx) = value.asInstanceOf[Byte]
-<     case x: Array[Short]   => x(idx) = value.asInstanceOf[Short]
-<     case x: Array[Boolean] => x(idx) = value.asInstanceOf[Boolean]
-<     case x: Array[Unit]    => x(idx) = value.asInstanceOf[Unit]
-<     case null => throw new NullPointerException
----
->   def array_update(xs: AnyRef, idx: Int, value: Any): Unit = {
->     arrayUpdateCount += 1
->     xs match {
->       case x: Array[AnyRef]  => x(idx) = value.asInstanceOf[AnyRef]
->       case x: Array[Int]     => x(idx) = value.asInstanceOf[Int]
->       case x: Array[Double]  => x(idx) = value.asInstanceOf[Double]
->       case x: Array[Long]    => x(idx) = value.asInstanceOf[Long]
->       case x: Array[Float]   => x(idx) = value.asInstanceOf[Float]
->       case x: Array[Char]    => x(idx) = value.asInstanceOf[Char]
->       case x: Array[Byte]    => x(idx) = value.asInstanceOf[Byte]
->       case x: Array[Short]   => x(idx) = value.asInstanceOf[Short]
->       case x: Array[Boolean] => x(idx) = value.asInstanceOf[Boolean]
->       case x: Array[Unit]    => x(idx) = value.asInstanceOf[Unit]
->       case null => throw new NullPointerException
->     }
diff --git a/test/junit/scala/runtime/ScalaRunTimeTest.scala b/test/junit/scala/runtime/ScalaRunTimeTest.scala
new file mode 100644
index 0000000000..9da197c71a
--- /dev/null
+++ b/test/junit/scala/runtime/ScalaRunTimeTest.scala
@@ -0,0 +1,70 @@
+package scala.runtime
+
+import org.junit.Assert._
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+/** Tests for the private class DefaultPromise */
+@RunWith(classOf[JUnit4])
+class ScalaRunTimeTest {
+  @Test
+  def testIsTuple() {
+    import ScalaRunTime.isTuple
+    def check(v: Any) = {
+      assertTrue(v.toString, isTuple(v))
+    }
+
+    val s = ""
+    check(Tuple1(s))
+    check((s, s))
+    check((s, s, s))
+    check((s, s, s, s))
+    check((s, s, s, s, s))
+    check((s, s, s, s, s, s))
+    check((s, s, s, s, s, s, s))
+    check((s, s, s, s, s, s, s, s))
+    check((s, s, s, s, s, s, s, s, s))
+    check((s, s, s, s, s, s, s, s, s, s))
+    check((s, s, s, s, s, s, s, s, s, s, s))
+    check((s, s, s, s, s, s, s, s, s, s, s, s))
+    check((s, s, s, s, s, s, s, s, s, s, s, s, s))
+    check((s, s, s, s, s, s, s, s, s, s, s, s, s, s))
+    check((s, s, s, s, s, s, s, s, s, s, s, s, s, s, s))
+    check((s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s))
+    check((s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s))
+    check((s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s))
+    check((s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s))
+    check((s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s))
+    check((s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s))
+    check((s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s))
+
+    // some specialized variants will have mangled classnames
+    check(Tuple1(0))
+    check((0, 0))
+    check((0, 0, 0))
+    check((0, 0, 0, 0))
+    check((0, 0, 0, 0, 0))
+    check((0, 0, 0, 0, 0, 0))
+    check((0, 0, 0, 0, 0, 0, 0))
+    check((0, 0, 0, 0, 0, 0, 0, 0))
+    check((0, 0, 0, 0, 0, 0, 0, 0, 0))
+    check((0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
+    check((0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
+    check((0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
+    check((0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
+    check((0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
+    check((0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
+    check((0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
+    check((0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
+    check((0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
+    check((0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
+    check((0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
+    check((0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
+    check((0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
+
+    case class C()
+    val c = new C()
+    assertFalse(c.toString, isTuple(c))
+  }
+}
diff --git a/test/pending/pos/t7778/Foo_1.java b/test/pending/pos/t7778/Foo_1.java
new file mode 100644
index 0000000000..65431ffd46
--- /dev/null
+++ b/test/pending/pos/t7778/Foo_1.java
@@ -0,0 +1,6 @@
+import java.util.concurrent.Callable;
+
+public abstract class Foo_1<T> implements Callable<Foo_1<Object>.Inner> {
+    public abstract class Inner {
+    }
+}
diff --git a/test/pending/pos/t7778/Test_2.scala b/test/pending/pos/t7778/Test_2.scala
new file mode 100644
index 0000000000..306303a99e
--- /dev/null
+++ b/test/pending/pos/t7778/Test_2.scala
@@ -0,0 +1,3 @@
+class Test {
+  null: Foo_1[_]
+}
diff --git a/test/scaladoc/run/t7767.check b/test/scaladoc/run/t7767.check
new file mode 100644
index 0000000000..619c56180b
--- /dev/null
+++ b/test/scaladoc/run/t7767.check
@@ -0,0 +1 @@
+Done.
diff --git a/test/scaladoc/run/t7767.scala b/test/scaladoc/run/t7767.scala
new file mode 100644
index 0000000000..6c9ceb511d
--- /dev/null
+++ b/test/scaladoc/run/t7767.scala
@@ -0,0 +1,18 @@
+import scala.tools.nsc.doc.model._
+import scala.tools.partest.ScaladocModelTest
+
+object Test extends ScaladocModelTest {
+
+  override def code = """
+      class Docable extends { /**Doc*/ val foo = 0 } with AnyRef
+  """
+
+  // no need for special settings
+  def scaladocSettings = ""
+
+  def testModel(rootPackage: Package) = {
+    import access._
+    val comment = rootPackage._class("Docable")._value("foo").comment.map(_.body.toString.trim).getOrElse("")
+    assert(comment.contains("Doc"), comment)
+  }
+}