Restore backwards compatibility in Scala 2.12.0-RC1 (#78)

szeiger · web-flow · commit 90270f4b861e · 2016-09-09T16:50:59.000+02:00
- The various JFunction and JProcedure sources that were removed from Scala in scala/scala#5298 are now included here when building for Scala 2.12.x (except M5). - Code that relies on specialized JFunction types being subtypes of the generic JFunction types will inevitably break. This is unavoidable. The specialized types are still part of Scala but they extend Scala function types directly. - All JFunctionN types and JFunction.func methods are deprecated. They are provided for source compatibility between 2.11 and 2.12 only. - The JProcedureN classes, JFunction.funcSpecialized methods and JFunction.proc methods are still useful in 2.12 for easy interoperability between Scala specialization and Java’s primitive types from Java code. - Generate JFunction and JProcedure sources: Just like for 2.11, we generate the sources again for 2.12 (after M5). I wrote a new code generator which is much simpler than the old one (because there is less and simpler code to generate). We can remove the old one when we drop support for Scala 2.11. - Move code back from scala.runtime.java8 to scala.compat.java8: The standard library contains some specialized JFunction* classes in scala.runtime.java8, so we cannot use the same package here if we ever want this to work with Java 9 modules. Therefore everything is moved back to scala.compat.java8 where it was in 0.7. We have to drop compatibility with Scala 2.12.0-M5 which contains these classes as part of scala-library in scala.runtime.java8. - Update to proper Scala 2.12.0-RC so we can build a release
diff --git a/build.sbt b/build.sbt
@@ -2,8 +2,8 @@ val disableDocs = sys.props("nodocs") == "true"
 
 lazy val JavaDoc = config("genjavadoc") extend Compile
 
-def jwrite(dir: java.io.File)(name: String, content: String) = {
-  val f = dir / "scala" / "runtime" / "java8" / s"${name}.java"
+def jwrite(dir: java.io.File, pck: String = "scala/compat/java8")(name: String, content: String) = {
+  val f = dir / pck / s"${name}.java"
   IO.write(f, content)
   f
 }
@@ -16,8 +16,8 @@ def osgiExport(scalaVersion: String, version: String) = {
 }
 
 lazy val commonSettings = Seq(
-  scalaVersion := "2.11.8",
-  crossScalaVersions := List("2.11.8", "2.12.0-M5"),
+  crossScalaVersions := List("2.12.0-RC1", "2.11.8"),
+  scalaVersion := crossScalaVersions.value.head,
   organization := "org.scala-lang.modules",
   version := "0.8.0-SNAPSHOT"
 )
@@ -69,15 +69,16 @@ lazy val root = (project in file(".")).
     }.taskValue,
 
     sourceGenerators in Compile <+= (sourceManaged in Compile, scalaVersion) map { (dir, v) =>
+      val write = jwrite(dir) _
       if(v.startsWith("2.11.")) {
-        val write = jwrite(dir) _
         Seq(write("JFunction", CodeGen.factory)) ++
-        (0 to 22).map(n => write("JFunction" + n, CodeGen.fN(n))) ++
-        (0 to 22).map(n => write("JProcedure" + n, CodeGen.pN(n))) ++
-        CodeGen.specializedF0.map(write.tupled) ++
-        CodeGen.specializedF1.map(write.tupled) ++
-        CodeGen.specializedF2.map(write.tupled)
-      } else Seq.empty
+          (0 to 22).map(n => write("JFunction" + n, CodeGen.fN(n))) ++
+          (0 to 22).map(n => write("JProcedure" + n, CodeGen.pN(n))) ++
+          CodeGen.specializedF0.map(write.tupled) ++
+          CodeGen.specializedF1.map(write.tupled) ++
+          CodeGen.specializedF2.map(write.tupled) ++
+          CodeGen.packageDummy.map((jwrite(dir, "java/runtime/java8") _).tupled)
+      } else CodeGen.create212.map(write.tupled)
     },
 
     sourceGenerators in Test <+= sourceManaged in Test map { dir =>
@@ -86,7 +87,7 @@ lazy val root = (project in file(".")).
 
     initialize := {
       // Run previously configured inialization...
-      initialize.value
+      val _ = initialize.value
       // ... and then check the Java version.
       val specVersion = sys.props("java.specification.version")
       if (Set("1.5", "1.6", "1.7") contains specVersion)
diff --git a/fnGen/WrapFnGen.scala b/fnGen/WrapFnGen.scala
@@ -1,12 +1,12 @@
 /*
- * Copyright (C) 2015 Typesafe Inc. <http://www.typesafe.com>
+ * Copyright (C) 2015-2016 Lightbend Inc. <https://www.lightbend.com>
  */
 
 object WrapFnGen {
   val copyright =
     s"""
     |/*
-    | * Copyright (C) 2015, Typesafe Inc. <http://www.typesafe.com>
+    | * Copyright (C) 2015-2016, Lightbend Inc. <https://www.lightbend.com>
     | * This file auto-generated by WrapFnGen.scala.  Do not modify directly.
     | */
     |""".stripMargin
diff --git a/project/CodeGen.scala b/project/CodeGen.scala
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ * Copyright (C) 2012-2016 Lightbend Inc. <https://www.lightbend.com>
  */
 
 sealed abstract class Type(val code: Char, val prim: String, val ref: String) {
@@ -25,7 +25,7 @@ object Type {
 }
 
 object CodeGen {
-  def packaging = "package scala.runtime.java8;"
+  def packaging = "package scala.compat.java8;"
   case class arity(n: Int) {
     val ns = (1 to n).toList
 
@@ -288,7 +288,7 @@ object CodeGen {
   private val copyright =
     """
     |/*
-    | * Copyright (C) 2012-2015 Typesafe Inc. <http://www.typesafe.com>
+    | * Copyright (C) 2012-2016 Lightbend Inc. <https://www.lightbend.com>
     | */""".stripMargin.trim
 
   private def function0SpecMethods = {
@@ -433,4 +433,101 @@ object CodeGen {
   }
 
   def indent(s: String) = s.linesIterator.map("    " + _).mkString("\n")
+
+  /** Create a dummy class to put into scala.runtime.java8 for Scala 2.11 so that wildcard imports from the
+    * package won't fail. This allows importing both `scala.runtime.java8.*` and `scala.compat.java8.*` for
+    * source compatibility between 2.11 and 2.12.
+    */
+  def packageDummy: Seq[(String, String)] = Seq(
+    ( "PackageDummy",
+      s"""$copyright
+         |
+         |package scala.runtime.java8;
+         |
+         |public final class PackageDummy {
+         |  private PackageDummy() {}
+         |}
+       """.stripMargin)
+  )
+
+  /** Create the simpler JFunction and JProcedure sources for Scala 2.12+ */
+  def create212: Seq[(String, String)] = {
+    val blocks = for(i <- 0 to 22) yield {
+      val ts = (1 to i).map(i => s"T$i").mkString(", ")
+      val tsComma = if(ts.isEmpty) "" else s"$ts,"
+      val tsAngled = if(ts.isEmpty) "" else s"<$ts>"
+      val paramTs = (1 to i).map(i => s"T$i t$i").mkString(", ")
+      val argTs = (1 to i).map(i => s"t$i").mkString(", ")
+
+      (
+        ( s"JFunction$i",
+          s"""$copyright
+             |$packaging
+             |
+             |/** @deprecated Use scala.Function$i in Scala 2.12 */
+             |@Deprecated
+             |@FunctionalInterface
+             |public interface JFunction$i<$tsComma R> extends scala.Function$i<$tsComma R>, java.io.Serializable {}
+           """.stripMargin),
+        ( s"JProcedure$i",
+          s"""$copyright
+             |$packaging
+             |
+             |import scala.runtime.BoxedUnit;
+             |
+             |@FunctionalInterface
+             |public interface JProcedure$i$tsAngled extends scala.Function$i<$tsComma BoxedUnit> {
+             |  void applyVoid($paramTs);
+             |  default BoxedUnit apply($paramTs) { applyVoid($argTs); return BoxedUnit.UNIT; }
+             |}
+           """.stripMargin),
+        s"""  /** @deprecated Not needed anymore in Scala 2.12 */
+           |  @Deprecated
+           |  public static <$tsComma R> scala.Function$i<$tsComma R> func(scala.Function$i<$tsComma R> f) { return f; }
+           |  public static $tsAngled scala.Function$i<$tsComma BoxedUnit> proc(JProcedure$i$tsAngled p) { return p; }
+         """.stripMargin
+      )
+    }
+
+    def specialize(args: String): List[(Int, String, String)] = {
+      def combinations(l: List[String]): List[List[Char]] =
+        l.foldRight(List(Nil: List[Char])) { (s, z) => s.toList.flatMap(c => z.map(c :: _)) }
+      val split = args.split(",")
+      combinations(split.toList).map { s =>
+        val types = s.map {
+          case 'B' => "Byte"
+          case 'S' => "Short"
+          case 'V' => "BoxedUnit"
+          case 'I' => "Integer"
+          case 'J' => "Long"
+          case 'C' => "Character"
+          case 'F' => "Float"
+          case 'D' => "Double"
+          case 'Z' => "Boolean"
+        }
+        (split.length-1, (types.tail :+ types.head).mkString(", "), "$mc" + s.mkString + "$sp")
+      }
+    }
+
+    val specialized =
+      List("V", "V,IJFD", "V,IJD,IJD").flatMap(specialize).map { case (i, a, sp) =>
+        s"  public static scala.Function$i<$a> procSpecialized(JFunction$i$sp f) { return f; }" } ++
+      List("BSIJCFDZ", "ZIFJD,IJFD", "ZIFJD,IJD,IJD").flatMap(specialize).map { case (i, a, sp) =>
+        s"  public static scala.Function$i<$a> funcSpecialized(JFunction$i$sp f) { return f; }" }
+
+    (blocks.map(_._1) ++ blocks.map(_._2)) :+
+      ( "JFunction",
+        s"""$copyright
+           |$packaging
+           |
+           |import scala.runtime.BoxedUnit;
+           |import scala.runtime.java8.*;
+           |
+           |public final class JFunction {
+           |  private JFunction() {}
+           |${specialized.mkString("\n")}
+           |${blocks.map(_._3).mkString("\n")}
+           |}
+           """.stripMargin)
+  }
 }
diff --git a/src/test/java/scala/compat/java8/BoxingTest.java b/src/test/java/scala/compat/java8/BoxingTest.java
@@ -1,14 +1,15 @@
 /*
  * Copyright (C) 2012-2015 Typesafe Inc. <http://www.typesafe.com>
  */
-package scala.runtime.java8;
+package scala.compat.java8;
 
 import org.junit.Test;
+import scala.runtime.java8.*;
 
 public class BoxingTest {
     @Test
     public void nullBoxesInterpretedAsZeroF1() {
-        JFunction1$mcII$sp jFunction1 = new JFunction1$mcII$sp() {
+        scala.Function1<Integer, Integer> jFunction1 = new JFunction1$mcII$sp() {
             @Override
             public int apply$mcII$sp(int v1) {
                 return v1 + 1;
@@ -20,7 +21,7 @@ public void nullBoxesInterpretedAsZeroF1() {
 
     @Test
     public void nullBoxesInterpretedAsZeroF2() {
-        JFunction2$mcIII$sp jFunction2 = new JFunction2$mcIII$sp() {
+        scala.Function2<Integer, Integer, Integer> jFunction2 = new JFunction2$mcIII$sp() {
             @Override
             public int apply$mcIII$sp(int v1, int v2) {
                 return v1 + v2 + 1;
diff --git a/src/test/java/scala/compat/java8/LambdaTest.java b/src/test/java/scala/compat/java8/LambdaTest.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2012-2015 Typesafe Inc. <http://www.typesafe.com>
+ */
+package scala.compat.java8;
+
+import org.apache.commons.lang3.SerializationUtils;
+import scala.runtime.*;
+
+import static junit.framework.Assert.assertEquals;
+import static scala.compat.java8.JFunction.*;
+import static scala.compat.java8.TestAPI.*;
+
+import org.junit.Test;
+
+
+public class LambdaTest {
+    @Test
+    public void lambdaDemo() {
+        // Scala 2.12+ only:
+        //scala.Function1<String, String> f1 = (String s) -> s;
+
+        // Not allowed with Scala 2.10 nor 2.11
+        // "incompatible types: Function1 is not a functional interface"
+        // scala.Function1<String, String> f = (String s) -> s;
+
+        // Function1 is not a functional interface because it has abstract
+        // methods in addition to apply, namely `compose` and `andThen`
+        // (which are implemented in Scala-derived subclasses with mixin
+        // inheritance), and the specialized variants of apply (also provided
+        // by scalac.)
+
+        // That's a pity, but we can get pretty close with this library!
+
+        // We have to tell javac to use `JFunction1` as the functional interface.
+        // Scala 2.12 does not have or need JFunction anymore. We provide it as a
+        // deprecated stub for backwards compatibility. Use `scala.Function1` for
+        // code that targets Scala 2.12+ exclusively.
+        JFunction1<String, String> f1 = (String s) -> s;
+
+        // That's more or less equivalent to the old, anonymous class syntax:
+        new JFunction1<String, String>() {
+            public String apply(String s) { return s; }
+        };
+
+        // You might have seen this form before:
+        new AbstractFunction1<String, String>() {
+            public String apply(String s) { return s; }
+        };
+
+        // However, we can't use `AbstractFunction1` as a functional interface
+        // as it is a class. Further
+
+        // F1 is a subclass of Function1:
+        scala.Function1<String, String> f2 = f1;
+
+        // Factory methods in `JFunction` can reduce the verbosity a little:
+        // `func` is actually just an identity method; it only exists to
+        // trigger lambda creation using the `JFunction1` functional interface.
+        scala.Function1<String, String> f3 = func((String s) -> s);
+
+        // Note that javac's type inference can infer the parameter type here,
+        // based on the acribed type of `f4`.
+        scala.Function1<String, String> f4 = func(s -> s);
+
+        // f1.apply("");
+
+        // Specialized variants of the `apply` method are provided but implementing a specialized
+        // Scala function in this straight-forward way results in boxing and unboxing because the
+        // Java lambda operates on boxed types:
+        JFunction1<Integer, Integer> f5 = (i) -> -i;
+        assert(f5.apply(1) == -1);
+        assert(f5.apply$mcII$sp(1) == -1);
+
+        // We provide `JFunction.funcSpecialized` and `JFunction.procSpecialized` methods to avoid
+        // boxing:
+        scala.Function1<Integer, Integer> f5b = funcSpecialized((int i) -> -i);
+        assert(f5b.apply(1) == -1);
+        assert(f5b.apply$mcII$sp(1) == -1);
+
+        // as are `curried`, `tupled`, `compose`, `andThen`.
+        f3.compose(f3).andThen(f3).apply("");
+        scala.Function2<String, String, String> f6 = func((s1, s2) -> join(s1, s2));
+        assert(f6.curried().apply("1").apply("2").equals("12"));
+
+        // Functions returning unit can use the `JProcedure1`, ... functional interfaces
+        // in order to convert a void lamdba return to Scala's Unit:
+        JProcedure1<String> f7b = s -> sideEffect();
+        scala.Function1<String, BoxedUnit> f7c = f7b;
+
+        // The easiest way to do this is via `JFunction.proc`, ....
+        //
+        // Note that the lambda has a return type of `void` if the last
+        // statement is a call to a `void` returning method, or if it is
+        // a `return`.
+        scala.Function1<String, BoxedUnit> f7 = proc(s -> sideEffect());
+        scala.Function1<String, BoxedUnit> f8 = proc(s -> {s.toUpperCase(); return;});
+
+        // Function0 is also available
+        scala.Function0<String> f9 = func(() -> "42");
+        assert(f9.apply().equals("42"));
+
+        // You can go up to 22 (the highest arity function defined in the Scala standard library.)
+        assert(acceptFunction1(func(v1 -> v1.toUpperCase())).equals("1"));
+        acceptFunction1Unit(proc(v1 -> sideEffect()));
+        acceptFunction1Unit(proc(v1 -> {v1.toUpperCase(); return;}));
+
+        assert(acceptFunction2(func((v1, v2) -> join(v1, v2))).equals("12"));
+        acceptFunction2Unit(proc((v1, v2) -> {v1.toUpperCase(); return;}));
+
+        assert(acceptFunction3(func((v1, v2, v3) -> join(v1, v2, v3))).equals("123"));
+        acceptFunction3Unit(proc((v1, v2, v3) -> {v1.toUpperCase(); return;}));
+
+        assert(acceptFunction22(func((v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) -> join(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22))).equals("12345678910111213141516171819202122"));
+        acceptFunction22Unit(   proc((v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) -> {v1.toUpperCase(); return;}));
+    }
+
+    @Test
+    public void isSerializable() {
+        JFunction0<String> f0 = () -> "foo";
+        assertEquals("foo", SerializationUtils.clone(f0).apply());
+
+        JFunction1<String, String> f1 = (a) -> a.toUpperCase();
+        assertEquals("FOO", SerializationUtils.clone(f1).apply("foo"));
+
+        JFunction2<String, String, String> f2 = (a, b) -> a + b;
+        assertEquals("foobar", SerializationUtils.clone(f2).apply("foo", "bar"));
+
+        JFunction3<String, String, String, String> f3 = (a, b, c) -> a + b + c;
+        assertEquals("foobarbaz", SerializationUtils.clone(f3).apply("foo", "bar", "baz"));
+    }
+
+    private static scala.concurrent.Future<Integer> futureExample(
+            scala.concurrent.Future<String> future, scala.concurrent.ExecutionContext ec) {
+        return future.map(func(s -> s.toUpperCase()), ec).map(func(s -> s.length()), ec);
+    }
+
+    private static void sideEffect() {
+    }
+
+    private static String join(String... ss) {
+        String result = "";
+        for (String s : ss) {
+            result = result + s;
+        }
+        return result;
+    }
+}
diff --git a/src/test/java/scala/compat/java8/SpecializedTest.scala b/src/test/java/scala/compat/java8/SpecializedTest.scala
@@ -4,7 +4,7 @@
 package scala.compat.java8
 
 import org.junit.Test
-import scala.runtime.java8.SpecializedTestSupport.IntIdentity
+import SpecializedTestSupport.IntIdentity
 
 class SpecializedTest {
   @Test def specializationWorks() {
diff --git a/src/test/java/scala/compat/java8/SpecializedTestSupport.java b/src/test/java/scala/compat/java8/SpecializedTestSupport.java
@@ -1,11 +1,12 @@
 /*
  * Copyright (C) 2012-2015 Typesafe Inc. <http://www.typesafe.com>
  */
-package scala.runtime.java8;
+package scala.compat.java8;
 
 import java.util.Arrays;
 import java.util.List;
 import org.junit.Assert;
+import scala.runtime.java8.*;
 
 public class SpecializedTestSupport {
     public static class IntIdentity implements JFunction1$mcII$sp {
diff --git a/src/test/java/scala/runtime/java8/LambdaTest.java b/src/test/java/scala/runtime/java8/LambdaTest.java
