Add more varargs tests

Author: TheElectronWill

tests/pos/varargs-annot-currying.scala

@@ -0,0 +1,18 @@
+import scala.annotation.varargs
+
+object VarArgs {
+   @varargs
+   def two(a: Int)(b: String*): Nothing = ???
+
+   @varargs
+   def twoPrimitive(a: Int)(b: Int*): Nothing = ???
+
+   @varargs
+   def three(a3: Int)(b3: String)(c3: String*): Nothing = ???
+
+   @varargs
+   def threePrimitive(a3: Int)(b3: String)(c3: Int*): Nothing = ???
+
+   @varargs
+   def emptyOk()()(xs: String*): Nothing = ???
+}

tests/pos/varargs-annot-generics.scala

@@ -0,0 +1,21 @@
+import scala.annotation.varargs
+
+object VarArgs {
+   @varargs
+   def foo1[A](x: A, xs: String*): A = ???
+
+   @varargs
+   def foo2[A](x: List[A], xs: String*): A = ???
+
+   @varargs
+   def foo3[A](n: Int*): Unit = ???
+
+   @varargs
+   def bar1[A](x: A*): Unit = ???
+
+   @varargs
+   def bar2[A](x: A, xs: A*): A = ???
+
+   @varargs
+   def bar3[A <: Comparable[A]](xs: A*): A = ???
+}

tests/run/varargs-abstract/Test.java

@@ -2,18 +2,24 @@
 
 public class Test {
   public static void main(String[] args) {
-    ClassImplementsClass c = new ClassImplementsClass();
+    VarargImplClass c = new VarargImplClass();
 
-    c.x("a", "b", "c");
+    c.x(0, 1, 2);
     c.y("a", "b", "c");
     c.z("a", "b", "c");
+    c.generic("a", "b", "c");
+    c.genericBounded("a", "b", "c");
 
-    VarargAbstractClass<String> i = new ClassImplementsClass();
+    VarargAbstractClass<String> i = new VarargImplClass();
 
-    i.x("a", "b", "c");
+    i.x(0, 1, 2);
     i.y("a", "b", "c");
-    // i.z("a", "b", "c");
-    // ClassCastException at runtime because the generated
-    // signature of z doesn't mention the type parameter (it should)
+    i.z("a", "b", "c");
+    i.generic("a", "b", "c");
+    i.genericBounded("a", "b", "c");
+
+    VarargClassBounded<String> b = new VarargClassBounded<>();
+    b.v1("a", "b", "c");
+    b.v2("a", "b", "c");
   }
 }

tests/run/varargs-abstract/test.scala

@@ -2,17 +2,32 @@ import scala.annotation.varargs
 
 abstract class VarargAbstractClass[T] {
   @varargs
-  def x(els: String*): Int
+  def x(v: Int*): Int
 
   @varargs
-  def y(els: String*): Int
+  def y(v: String*): Int
 
   @varargs
-  def z(els: T*): Int
+  def z(v: T*): Int
+
+  @varargs
+  def generic[E](e: E*): Unit = ()
+
+  @varargs
+  def genericBounded[E <: Comparable[E] & Serializable](e: E*): Unit = ()
+}
+
+class VarargImplClass extends VarargAbstractClass[String] {
+
+  override def x(v: Int*): Int = v.length
+  override def y(v: String*): Int = v.length
+  override def z(v: String*): Int = v.length
 }
-class ClassImplementsClass extends VarargAbstractClass[String] {
 
-  override def x(els: String*): Int = els.length
-  override def y(els: String*): Int = els.length
-  override def z(els: String*): Int = els.length
+class VarargClassBounded[B <: Comparable[B]] {
+  @varargs
+  def v1(v: B*): Unit = ()
+
+  @varargs
+  def v2(first: B, more: B*): B = first
 }