Merge remote tracking branch 'origin/2.10.x' into topic/merge-2.10.x-to-v2.11.0-M2-74-g00e6c8b

Conflicts:
    bincompat-backward.whitelist.conf
    bincompat-forward.whitelist.conf
    build.xml
    src/compiler/scala/reflect/reify/utils/Extractors.scala
    src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
    src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala
    src/compiler/scala/tools/nsc/transform/patmat/MatchOptimization.scala
    src/compiler/scala/tools/nsc/typechecker/Typers.scala
    src/partest/scala/tools/partest/nest/ReflectiveRunner.scala
    src/reflect/scala/reflect/internal/Types.scala
    src/reflect/scala/reflect/runtime/JavaUniverse.scala
    test/files/run/inline-ex-handlers.check
    test/files/run/t6223.check
    test/files/run/t6223.scala
    test/scaladoc/scalacheck/IndexTest.scala

1 files changed, 39 insertions, 8 deletions

diff --git a/test/files/run/outertest.scala b/test/files/run/outertest.scala
index 3cc96afa5b..fa0443f669 100644
--- a/test/files/run/outertest.scala
+++ b/test/files/run/outertest.scala
@@ -1,26 +1,57 @@
 // A test for the case where the outer field of class B#J should be eliminated.
-// You can verify this by running a javap on B.J
+
+import reflect.ClassTag
+
 abstract class A {
+  abstract class I
 
-  abstract class I {
+  val foo = this
+}
 
+class B extends A {
+  class J extends I {
+    val bar = foo
   }
 
-  val foo = "foo"
+  type II = I
+  class K extends II {
+    val bar = foo
+  }
 
+  class L extends (I @annotation.tailrec) {
+    val bar = foo
+  }
 }
 
-class B extends A {
 
-  class J extends I {
+class C extends A {
+  val c: C = this
+
+  class M extends c.I {
     val bar = foo
   }
-
 }
 
-object  Test extends App {
 
+object Test extends App {
   val b = new B
-  assert((new b.J).bar == b.foo)
+  val c0 = new C
+  val c = new { override val c = c0 } with C
+
+  assert((new b.J).bar eq b)
+  assert((new b.K).bar eq b)
+  assert((new b.L).bar eq b)
+  assert((new c.M).bar eq c)
+
+  def checkOuterFields[C: ClassTag](expected: Int) {
+    val cls = implicitly[ClassTag[C]].runtimeClass
+    val outerFields = cls.getDeclaredFields().filter(_.getName.contains("$outer"))
+    assert(outerFields.size == expected, outerFields.map(_.getName))
+  }
 
+  checkOuterFields[A#I](1) // the base class must have the $outer pointer
+  checkOuterFields[B#J](0) // reuse parent class' $outer pointer
+  checkOuterFields[B#K](0) // ... through an alias
+  checkOuterFields[B#L](0) // ... through the annotated type
+  checkOuterFields[C#M](1) // different prefix, can't share.
 }