Merge branch '2.11.x' into 2.12.x

27 files changed, 346 insertions, 14 deletions

diff --git a/test/files/jvm/beanInfo.check b/test/files/jvm/beanInfo.check
new file mode 100644
index 0000000000..d74e127711
--- /dev/null
+++ b/test/files/jvm/beanInfo.check
@@ -0,0 +1,6 @@
+property descriptors
+x -- int -- public int p.C.x() -- null
+y -- class java.lang.String -- public java.lang.String p.C.y() -- public void p.C.y_$eq(java.lang.String)
+z -- class scala.collection.immutable.List -- public scala.collection.immutable.List p.C.z() -- public void p.C.z_$eq(scala.collection.immutable.List)
+method descriptors
+f -- public p.C p.C.f()
diff --git a/test/files/jvm/beanInfo/C_1.scala b/test/files/jvm/beanInfo/C_1.scala
new file mode 100644
index 0000000000..a338abea1d
--- /dev/null
+++ b/test/files/jvm/beanInfo/C_1.scala
@@ -0,0 +1,9 @@
+package p
+
+@scala.beans.BeanInfo
+class C {
+  val x: Int = 0
+  var y: String = ""
+  var z: List[_] = Nil
+  def f: C = ???
+}
diff --git a/test/files/jvm/beanInfo/Test_2.scala b/test/files/jvm/beanInfo/Test_2.scala
new file mode 100644
index 0000000000..fa9b6e1391
--- /dev/null
+++ b/test/files/jvm/beanInfo/Test_2.scala
@@ -0,0 +1,17 @@
+object Test extends App {
+  val info = java.beans.Introspector.getBeanInfo(classOf[p.C])
+
+  println("property descriptors")
+
+  val pds = info.getPropertyDescriptors
+  for (pd <- pds) {
+    println(s"${pd.getName} -- ${pd.getPropertyType} -- ${pd.getReadMethod} -- ${pd.getWriteMethod}")
+  }
+
+  println("method descriptors")
+
+  val mds = info.getMethodDescriptors
+  for (md <- mds) {
+    println(s"${md.getName} -- ${md.getMethod}")
+  }
+}
diff --git a/test/files/jvm/t8582.check b/test/files/jvm/t8582.check
new file mode 100644
index 0000000000..1d19f1d6a8
--- /dev/null
+++ b/test/files/jvm/t8582.check
@@ -0,0 +1,47 @@
+t8582.scala:17: warning: class BeanInfo in package beans is deprecated: the generation of BeanInfo classes is no longer supported
+    class C1
+          ^
+getClass on module gives module class
+ class p1.p2.Singleton$Singleton$
+
+Nested module classes are found through reflection
+ p1.p2.Singleton$Singleton$: List(class p1.p2.Singleton$Singleton$Singleton$)
+
+Reflection can find direct nested classes (A1-B1-C1)
+ A1: List(class A1$B1)
+ A1$B1: List(class A1$B1$C1)
+ A1$B1$C1: List()
+
+Reflection can find direct nested classes (A2-B2-C2)
+ A2: List(class A2$B2)
+ A2$B2: List(class A2$B2$C2)
+ A2$B2$C2: List()
+
+Mirror classes have the same InnerClass attributes as the corresponding module class:
+ className[p1/p2/Singleton$Singleton$] outerClassName[p1/p2/Singleton] innerName[Singleton$] access[9]
+Module class
+ className[p1/p2/Singleton$Singleton$] outerClassName[p1/p2/Singleton] innerName[Singleton$] access[9]
+
+An outer class has a InnerClass attribute for direct nested classes
+ className[A1$B1] outerClassName[A1] innerName[B1] access[1]
+A nested class has an InnerClass attribute for itself (and also for its nested classes)
+ className[A1$B1] outerClassName[A1] innerName[B1] access[1]
+ className[A1$B1$C1] outerClassName[A1$B1] innerName[C1] access[1]
+C1 is a nested class, so it has an InnerClass attribute for itself.
+Because that attribute leads to an entry for B1 in the constant pool, C1 needs an InnerClass attribute for B1.
+ className[A1$B1] outerClassName[A1] innerName[B1] access[1]
+ className[A1$B1$C1] outerClassName[A1$B1] innerName[C1] access[1]
+
+The BeanInfo class has the same InnerClass attributes as the corresponding bean
+ className[A1$B1] outerClassName[A1] innerName[B1] access[1]
+ className[A1$B1$C1] outerClassName[A1$B1] innerName[C1] access[1]
+
+Class A2 mentions class C2 in the constant pool (due to method  f), therefore it needs an InnerClass attribute for C1
+ className[A2$B2] outerClassName[A2] innerName[B2] access[1]
+ className[A2$B2$C2] outerClassName[A2$B2] innerName[C2] access[1]
+B2
+ className[A2$B2] outerClassName[A2] innerName[B2] access[1]
+ className[A2$B2$C2] outerClassName[A2$B2] innerName[C2] access[1]
+C2
+ className[A2$B2] outerClassName[A2] innerName[B2] access[1]
+ className[A2$B2$C2] outerClassName[A2$B2] innerName[C2] access[1]
diff --git a/test/files/jvm/t8582.flags b/test/files/jvm/t8582.flags
new file mode 100644
index 0000000000..dcc59ebe32
--- /dev/null
+++ b/test/files/jvm/t8582.flags
@@ -0,0 +1 @@
+-deprecation
diff --git a/test/files/jvm/t8582.scala b/test/files/jvm/t8582.scala
new file mode 100644
index 0000000000..8a57ef7952
--- /dev/null
+++ b/test/files/jvm/t8582.scala
@@ -0,0 +1,81 @@
+import scala.tools.partest.BytecodeTest
+import scala.collection.JavaConverters._
+
+package p1 {
+  package p2 {
+    object Singleton {
+      object Singleton {
+        object Singleton
+      }
+    }
+  }
+}
+
+class A1 {
+  class B1 {
+    @scala.beans.BeanInfo
+    class C1
+  }
+}
+
+class A2 {
+  class B2 {
+    class C2
+  }
+  def f: B2#C2 = null
+}
+
+
+object Test extends BytecodeTest {
+  import p1.p2._
+
+  def nested(c: Class[_]) = s" ${c.getName}: ${c.getDeclaredClasses.toList}"
+
+  def nprintln(s: String) = println("\n"+s)
+  def printInner(cname: String): Unit = {
+    val cnode = loadClassNode(cname)
+    println(cnode.innerClasses.asScala.toList.map(i => s"className[${i.name}] outerClassName[${i.outerName}] innerName[${i.innerName}] access[${i.access}]").mkString(" ", "\n ", ""))
+  }
+
+  def show() {
+
+    println("getClass on module gives module class")
+    println(" " + Singleton.Singleton.getClass)
+
+    nprintln("Nested module classes are found through reflection")
+    println(nested(Singleton.Singleton.getClass))
+
+    nprintln("Reflection can find direct nested classes (A1-B1-C1)")
+    println(nested(classOf[A1]))
+    println(nested(classOf[A1#B1]))
+    println(nested(classOf[A1#B1#C1]))
+
+    nprintln("Reflection can find direct nested classes (A2-B2-C2)")
+    println(nested(classOf[A2]))
+    println(nested(classOf[A2#B2]))
+    println(nested(classOf[A2#B2#C2]))
+
+    nprintln("Mirror classes have the same InnerClass attributes as the corresponding module class:")
+    printInner("p1.p2.Singleton") // mirror class
+    println("Module class")
+    printInner("p1.p2.Singleton$")
+
+    nprintln("An outer class has a InnerClass attribute for direct nested classes")
+    printInner("A1")
+    println("A nested class has an InnerClass attribute for itself (and also for its nested classes)")
+    printInner("A1$B1")
+    println("C1 is a nested class, so it has an InnerClass attribute for itself.\n"+
+            "Because that attribute leads to an entry for B1 in the constant pool, C1 needs an InnerClass attribute for B1.")
+    printInner("A1$B1$C1")
+
+    nprintln("The BeanInfo class has the same InnerClass attributes as the corresponding bean")
+    printInner("A1$B1$C1BeanInfo")
+
+    nprintln("Class A2 mentions class C2 in the constant pool (due to method  f), therefore it needs an InnerClass attribute for C1")
+    printInner("A2")
+    println("B2")
+    printInner("A2$B2")
+    println("C2")
+    printInner("A2$B2$C2")
+  }
+}
diff --git a/test/files/neg/t6162-inheritance.check b/test/files/neg/t6162-inheritance.check
index 13c78030d9..c9f4ddaec1 100644
--- a/test/files/neg/t6162-inheritance.check
+++ b/test/files/neg/t6162-inheritance.check
@@ -7,12 +7,6 @@ object SubT extends T
 usage.scala:8: warning: inheritance from trait S in package t6126 is deprecated
   new S {
       ^
-usage.scala:3: warning: inheritance from class Foo in package t6126 is deprecated: `Foo` will be made final in a future version.
-class SubFoo extends Foo
-             ^
-usage.scala:5: warning: inheritance from trait T in package t6126 is deprecated
-object SubT extends T
-            ^
 error: No warnings can be incurred under -Xfatal-warnings.
-5 warnings found
+three warnings found
 one error found
diff --git a/test/files/pos/t8578.flags b/test/files/pos/t8578.flags
new file mode 100644
index 0000000000..48b438ddf8
--- /dev/null
+++ b/test/files/pos/t8578.flags
@@ -0,0 +1 @@
+-Ydelambdafy:method
diff --git a/test/files/pos/t8578.scala b/test/files/pos/t8578.scala
new file mode 100644
index 0000000000..879b5f5550
--- /dev/null
+++ b/test/files/pos/t8578.scala
@@ -0,0 +1,18 @@
+class DuplicateClassName {
+  () => {
+    {() => ()}
+    {() => ()}
+    {() => ()}
+    {() => ()}
+    {() => ()}
+    {() => ()}
+    {() => ()}
+    {() => ()}
+    {() => ()}
+    {() => () => ()}
+    {() => ()}
+  }
+}
+// Was:
+// Different class symbols have the same bytecode-level internal name:
+// name: DuplicateClassName$lambda$$$anonfun$111
\ No newline at end of file
diff --git a/test/files/run/classfile-format-51.scala b/test/files/run/classfile-format-51.scala
index f92382d89b..24b1ee8397 100644
--- a/test/files/run/classfile-format-51.scala
+++ b/test/files/run/classfile-format-51.scala
@@ -32,7 +32,7 @@ object Test extends DirectTest {
     val constructor = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null)
     constructor.visitCode()
     constructor.visitVarInsn(ALOAD, 0)
-    constructor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V")
+    constructor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false)
     constructor.visitInsn(RETURN)
     constructor.visitMaxs(1, 1)
     constructor.visitEnd()
@@ -47,19 +47,19 @@ object Test extends DirectTest {
     val bootstrap = cw.visitMethod(ACC_PUBLIC + ACC_STATIC, bootstrapMethodName, bootStrapMethodType, null, null)
     bootstrap.visitCode()
 //  val lookup = MethodHandles.lookup();
-    bootstrap.visitMethodInsn(INVOKESTATIC, "java/lang/invoke/MethodHandles", "lookup", "()Ljava/lang/invoke/MethodHandles$Lookup;")
+    bootstrap.visitMethodInsn(INVOKESTATIC, "java/lang/invoke/MethodHandles", "lookup", "()Ljava/lang/invoke/MethodHandles$Lookup;", false)
     bootstrap.visitVarInsn(ASTORE, 3) // lookup
 
 //  val clazz = lookup.lookupClass();
     bootstrap.visitVarInsn(ALOAD, 3) // lookup
-    bootstrap.visitMethodInsn(INVOKEVIRTUAL, "java/lang/invoke/MethodHandles$Lookup", "lookupClass", "()Ljava/lang/Class;")
+    bootstrap.visitMethodInsn(INVOKEVIRTUAL, "java/lang/invoke/MethodHandles$Lookup", "lookupClass", "()Ljava/lang/Class;", false)
     bootstrap.visitVarInsn(ASTORE, 4) // clazz
 
 // val methodType = MethodType.fromMethodDescriptorString("()Ljava/lang/String, clazz.getClassLoader()")
     bootstrap.visitLdcInsn("()Ljava/lang/String;")
     bootstrap.visitVarInsn(ALOAD, 4) // CLAZZ
-    bootstrap.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Class", "getClassLoader", "()Ljava/lang/ClassLoader;")
-    bootstrap.visitMethodInsn(INVOKESTATIC, "java/lang/invoke/MethodType", "fromMethodDescriptorString", "(Ljava/lang/String;Ljava/lang/ClassLoader;)Ljava/lang/invoke/MethodType;")
+    bootstrap.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Class", "getClassLoader", "()Ljava/lang/ClassLoader;", false)
+    bootstrap.visitMethodInsn(INVOKESTATIC, "java/lang/invoke/MethodType", "fromMethodDescriptorString", "(Ljava/lang/String;Ljava/lang/ClassLoader;)Ljava/lang/invoke/MethodType;", false)
     bootstrap.visitVarInsn(ASTORE, 5) // methodType
 
 //  val methodHandle = lookup.findStatic(thisClass, "target", methodType)
@@ -67,14 +67,14 @@ object Test extends DirectTest {
     bootstrap.visitVarInsn(ALOAD, 4) // clazz
     bootstrap.visitLdcInsn("target")
     bootstrap.visitVarInsn(ALOAD, 5) // methodType
-    bootstrap.visitMethodInsn(INVOKEVIRTUAL, "java/lang/invoke/MethodHandles$Lookup", "findStatic", "(Ljava/lang/Class;Ljava/lang/String;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/MethodHandle;")
+    bootstrap.visitMethodInsn(INVOKEVIRTUAL, "java/lang/invoke/MethodHandles$Lookup", "findStatic", "(Ljava/lang/Class;Ljava/lang/String;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/MethodHandle;", false)
     bootstrap.visitVarInsn(ASTORE, 6) // methodHandle
 
 //  new ConstantCallSite(methodHandle)
     bootstrap.visitTypeInsn(NEW, "java/lang/invoke/ConstantCallSite")
     bootstrap.visitInsn(DUP)
     bootstrap.visitVarInsn(ALOAD, 6) // methodHandle
-    bootstrap.visitMethodInsn(INVOKESPECIAL, "java/lang/invoke/ConstantCallSite", "<init>", "(Ljava/lang/invoke/MethodHandle;)V")
+    bootstrap.visitMethodInsn(INVOKESPECIAL, "java/lang/invoke/ConstantCallSite", "<init>", "(Ljava/lang/invoke/MethodHandle;)V", false)
     bootstrap.visitInsn(ARETURN)
     bootstrap.visitMaxs(4,7)
     bootstrap.visitEnd()
diff --git a/test/files/run/large_class.check b/test/files/run/large_class.check
new file mode 100644
index 0000000000..0585c267ac
--- /dev/null
+++ b/test/files/run/large_class.check
@@ -0,0 +1,3 @@
+newSource1.scala:1: error: Could not write class BigEnoughToFail because it exceeds JVM code size limits. Class file too large!
+class BigEnoughToFail {
+      ^
diff --git a/test/files/run/large_class.scala b/test/files/run/large_class.scala
new file mode 100644
index 0000000000..aa486ef8f7
--- /dev/null
+++ b/test/files/run/large_class.scala
@@ -0,0 +1,27 @@
+import scala.tools.partest._
+import java.io.{Console => _, _}
+
+// a cold run of partest takes about 15s for this test on my laptop
+object Test extends DirectTest {
+  override def extraSettings: String = "-usejavacp -d " + testOutput.path
+
+  def s(n: Int) = "\""+n+"\""
+
+  override def code
+    = s"""
+      |class BigEnoughToFail {
+      |  def m(a: String, b: String, c: String, d: String, e: String, f: String) = null
+      |  ${(1 to 5500) map (n => "def f"+n+" = m("+ s(n+10000)+","+
+                                                    s(n+20000)+","+
+                                                    s(n+30000)+","+
+                                                    s(n+40000)+","+
+                                                    s(n+50000)+","+
+                                                    s(n+60000)+")") mkString ";"}
+      |}""".stripMargin.trim
+
+  override def show(): Unit = {
+    Console.withErr(System.out) {
+      compile()
+    }
+  }
+}
diff --git a/test/files/run/t8574.scala b/test/files/run/t8574.scala
new file mode 100644
index 0000000000..8c23ada482
--- /dev/null
+++ b/test/files/run/t8574.scala
@@ -0,0 +1,27 @@
+import annotation._
+
+@SerialVersionUID(42) @strictfp class Foo[@specialized(Int) T] extends Serializable {
+  def foo(t: T) = t
+}
+
+object Test extends App {
+  def checkUID(cls: Class[_], expected: Long) = {
+    val actual = java.io.ObjectStreamClass.lookup(cls).getSerialVersionUID
+    assert(actual == expected, s"$actual != expected for ${cls}")
+  }
+  def checkStrictFp(cls: Class[_]) = {
+    import java.lang.reflect._
+    for (m <- cls.getDeclaredMethods) {
+      val isStrict = Modifier.isStrict(m.getModifiers)
+      assert(isStrict, cls)
+    }
+  }
+  def check(x: AnyRef) {
+    checkUID(x.getClass, 42)
+    checkStrictFp(x.getClass)
+  }
+
+  check(new Foo[String])
+  check(new Foo[Int])
+}
+
diff --git a/test/files/run/t8601-closure-elim.flags b/test/files/run/t8601-closure-elim.flags
new file mode 100644
index 0000000000..49d036a887
--- /dev/null
+++ b/test/files/run/t8601-closure-elim.flags
@@ -0,0 +1 @@
+-optimize
diff --git a/test/files/run/t8601-closure-elim.scala b/test/files/run/t8601-closure-elim.scala
new file mode 100644
index 0000000000..2c5b03af77
--- /dev/null
+++ b/test/files/run/t8601-closure-elim.scala
@@ -0,0 +1,26 @@
+import scala.tools.partest.BytecodeTest
+import scala.tools.asm
+import scala.tools.asm.util._
+import scala.collection.JavaConverters._
+
+object Test extends BytecodeTest {
+  val nullChecks = Set(asm.Opcodes.NEW)
+
+  def show: Unit = {
+    def test(methodName: String) {
+      val classNode = loadClassNode("Foo")
+      val methodNode = getMethod(classNode, "b")
+      val ops = methodNode.instructions.iterator.asScala.map(_.getOpcode).toList
+      assert(!ops.contains(asm.Opcodes.NEW), ops)// should be allocation free if the closure is eliminiated
+    }
+    test("b")
+  }
+}
+
+class Foo {
+  @inline final def a(x: Int => Int) = x(1)
+  final def b {
+    val delta = 0
+    a(x => delta + 1)
+  }
+}
diff --git a/test/files/run/t8601.flags b/test/files/run/t8601.flags
new file mode 100644
index 0000000000..1182725e86
--- /dev/null
+++ b/test/files/run/t8601.flags
@@ -0,0 +1 @@
+-optimize
\ No newline at end of file
diff --git a/test/files/run/t8601.scala b/test/files/run/t8601.scala
new file mode 100644
index 0000000000..e1afc23cc4
--- /dev/null
+++ b/test/files/run/t8601.scala
@@ -0,0 +1,15 @@
+object Test {
+  def idiv(x: Int): Unit = x / 0
+  def ldiv(x: Long): Unit = x / 0
+  def irem(x: Int): Unit = x % 0
+  def lrem(x: Long): Unit = x % 0
+
+  def check(x: => Any) = try { x; sys.error("failed to throw divide by zero!") } catch { case _: ArithmeticException => }
+
+  def main(args: Array[String]) {
+    check(idiv(1))
+    check(ldiv(1L))
+    check(irem(1))
+    check(lrem(1L))
+  }
+}
diff --git a/test/files/run/t8601b.flags b/test/files/run/t8601b.flags
new file mode 100644
index 0000000000..1182725e86
--- /dev/null
+++ b/test/files/run/t8601b.flags
@@ -0,0 +1 @@
+-optimize
\ No newline at end of file
diff --git a/test/files/run/t8601b.scala b/test/files/run/t8601b.scala
new file mode 100644
index 0000000000..9c37ce33d6
--- /dev/null
+++ b/test/files/run/t8601b.scala
@@ -0,0 +1,14 @@
+object Test {
+  def len(x: Array[String]): Unit = x.length
+  def load(x: Array[String]): Unit = x(0)
+  def newarray(i: Int): Unit = new Array[Int](i)
+
+  def check(x: => Any) = try { x; sys.error("failed to throw NPE!") } catch { case _: NullPointerException => }
+  def checkNegSize(x: => Any) = try { x; sys.error("failed to throw NegativeArraySizeException!") } catch { case _: NegativeArraySizeException => }
+
+  def main(args: Array[String]) {
+    check(len(null)) // bug: did not NPE
+    check(load(null))
+    checkNegSize(newarray(-1))
+  }
+}
diff --git a/test/files/run/t8601c.flags b/test/files/run/t8601c.flags
new file mode 100644
index 0000000000..1182725e86
--- /dev/null
+++ b/test/files/run/t8601c.flags
@@ -0,0 +1 @@
+-optimize
\ No newline at end of file
diff --git a/test/files/run/t8601c.scala b/test/files/run/t8601c.scala
new file mode 100644
index 0000000000..c487d6825e
--- /dev/null
+++ b/test/files/run/t8601c.scala
@@ -0,0 +1,12 @@
+object Test {
+  def loadField(x: scala.runtime.IntRef): Unit = x.elem
+  def storeField(x: scala.runtime.IntRef): Unit = x.elem = 42
+
+  def check(x: => Any) = try { x; sys.error("failed to throw NPE!") } catch { case _: NullPointerException => }
+
+  def main(args: Array[String]) {
+    check(loadField(null)) // bug: did not NPE under -Ydead-code
+    check(storeField(null))
+
+  }
+}
diff --git a/test/files/run/t8601d.flags b/test/files/run/t8601d.flags
new file mode 100644
index 0000000000..1182725e86
--- /dev/null
+++ b/test/files/run/t8601d.flags
@@ -0,0 +1 @@
+-optimize
\ No newline at end of file
diff --git a/test/files/run/t8601d.scala b/test/files/run/t8601d.scala
new file mode 100644
index 0000000000..ac89963d67
--- /dev/null
+++ b/test/files/run/t8601d.scala
@@ -0,0 +1,8 @@
+object Test {
+  def monitor(x: AnyRef): Unit = {x.synchronized(()); ()}
+  def check(x: => Any) = try { x; sys.error("failed to throw NPE") } catch { case _: NullPointerException => }
+
+  def main(args: Array[String]) {
+    check(monitor(null))
+  }
+}
diff --git a/test/files/run/t8601e.flags b/test/files/run/t8601e.flags
new file mode 100644
index 0000000000..49d036a887
--- /dev/null
+++ b/test/files/run/t8601e.flags
@@ -0,0 +1 @@
+-optimize
diff --git a/test/files/run/t8601e/StaticInit.class b/test/files/run/t8601e/StaticInit.class
new file mode 100644
index 0000000000..99a0e2a643
--- /dev/null
+++ b/test/files/run/t8601e/StaticInit.class
diff --git a/test/files/run/t8601e/StaticInit.java b/test/files/run/t8601e/StaticInit.java
new file mode 100644
index 0000000000..7543ed98b8
--- /dev/null
+++ b/test/files/run/t8601e/StaticInit.java
@@ -0,0 +1,8 @@
+public class StaticInit {
+	static {
+		if ("".isEmpty()) {
+			throw new RuntimeException();
+		}
+	}
+	public static int fld = 42;
+}
diff --git a/test/files/run/t8601e/Test.scala b/test/files/run/t8601e/Test.scala
new file mode 100644
index 0000000000..838114f6a7
--- /dev/null
+++ b/test/files/run/t8601e/Test.scala
@@ -0,0 +1,12 @@
+class C {
+  def foo: Unit = {StaticInit.fld}
+}
+
+object Test extends App {
+  try {
+    new C().foo
+    sys.error("StaticInit.<clinit> was not run!")
+  } catch {
+    case t: ExceptionInInitializerError =>
+  }
+}