Tests, manually written, for function converters.

These were written manually to avoid making the same assumptions in code
generation for the converters and the tests, and thereby missing important
bugs.  As a downside, though, they do not have complete code coverage.  This
should not matter given how the code generator works, but it is a weak point.

Author: Ichoran

README.md

@@ -25,6 +25,69 @@ class Test {
 
 [More Examples / Documentation](src/test/java/scala/compat/java8/LambdaTest.java)
 
+## Converters between `scala.FunctionN` and `java.util.function`
+
+A set of converters that enable interconversion between Java's standard
+Functional Interfaces defined in `java.util.function` and Scala's `Function0`, 
+`Function1`, and `Function2` traits.  These are intended for use when you
+already have an instance of a `java.util.function` and need a Scala function,
+or have a Scala function and need an instance of a `java.util.function`.
+
+The `.asScala` extension method will convert a `java.util.function` to the corresponding
+Scala function.  The `.asJava` extension method will convert a Scala function to
+the most specific corresponding Java functional interface.  If you wish to obtain
+a less specific functional interface, there are named methods that start with `asJava`
+and continue with the name of the Java functional interface.  For instance, the
+most specific interface corresponding to the Scala function `val rev = (s: String) => s.reverse`
+is `UnaryOperator[String]`, and that is what `rev.asJava` will produce.  However,
+`asJavaFunction(rev)` will return a `java.util.function.Function[String, String]` instead.
+
+The `asJava` methods can also be called conveniently from Java.  There are additional
+`asScalaFrom` methods (e.g. `asScalaFromUnaryOperator`) that will perform the
+functional-interface-to-Scala-function conversion; this is primarily of use when calling
+from Java since the `.asScala` extension method is more convenient in Scala.
+
+#### Usage examples
+
+In Scala:
+
+```scala
+import java.util.function._
+import scala.compat.java8.FunctionConverters._
+
+val foo: Int => Boolean = i => i > 7
+def testBig(ip: IntPredicate) = ip.test(9)
+println(testBig(foo.asJava))  // Prints true
+
+val bar = new UnaryOperator[String]{ def apply(s: String) = s.reverse }
+List("cod", "herring").map(bar.asScala)    // List("doc", "gnirrih")
+
+def testA[A](p: Predicate[A])(a: A) = p.test(a)
+println(testA(asJavaPredicate(foo))(4))  // Prints false
+
+// println(testA(foo.asJava)(4))  <-- doesn't work
+//                                    IntPredicate does not extend Predicate!
+```
+
+In Java:
+
+```java
+import java.util.function.*;
+import scala.compat.java8.FunctionConverters;
+
+class Example {
+  String foo(UnaryOperator<String> f) {
+    return f.apply("halibut");
+  }
+  String bar(scala.Function1<String, String> f) {
+    return foo(functionConverters.asJavaUnaryOperator(f));
+  }
+  String baz(Function<String, String> f) {
+    return bar(functionConverters.asScalaFromFunction(f));
+  }
+}
+```
+
 ## Converters between `scala.concurrent` and `java.util.concurrent`
 
  - [API](src/main/scala/scala/compat/java8/FutureConverters.scala)
@@ -53,6 +116,7 @@ class Test {
 }
 ```
 
+
 ## Future work
-  - Converters for `java.util.function`, `java.util.stream`
+  - Converters for `java.util.stream`
   - [`Spliterator`](https://docs.oracle.com/javase/8/docs/api/java/util/Spliterator.html)s for Scala collections

fnGen/WrapFnGen.scala

@@ -74,16 +74,16 @@ object WrapFnGen {
   case class SamConversionCode(
     base: String,
     wrappedAsScala: Vector[String],
+    asScalaAnyVal: Vector[String],
     implicitToScala: Vector[String],
     asScalaDef: Vector[String],
     wrappedAsJava: Vector[String],
     asJavaAnyVal: Vector[String],
     implicitToJava: Prioritized,
     asJavaDef: Vector[String]
   ) {
-    def impls: Vector[Vector[String]] = Vector(wrappedAsScala, wrappedAsJava, asJavaAnyVal)
+    def impls: Vector[Vector[String]] = Vector(wrappedAsScala, asScalaAnyVal, wrappedAsJava, asJavaAnyVal)
     def defs: Vector[Vector[String]] = Vector(asScalaDef, asJavaDef)
-    def convs: Vector[Vector[String]] = Vector(implicitToScala, implicitToJava.lines)
     def withPriority(i: Int): SamConversionCode = copy(implicitToJava = implicitToJava.withPriority(i))
   }
   object SamConversionCode {
@@ -100,19 +100,19 @@ object WrapFnGen {
       def priorityName(n: Int, pure: Boolean = false): String = {
         val pre = 
           if (n <= 0)
-            if (pure) "functionConverters"
+            if (pure) "FunctionConverters"
             else s"package object ${priorityName(n, pure = true)}"
           else
             if (pure) s"Priority${n}FunctionConverters"
             else s"trait ${priorityName(n, pure = true)}"
-        if (!pure && n < sccDepthSet.size) s"$pre extends ${priorityName(n+1, pure = true)}" else pre
+        if (!pure && n < (sccDepthSet.size-1)) s"$pre extends ${priorityName(n+1, pure = true)}" else pre
       }
       val impls = 
         "package functionConverterImpls {" +: {
           codes.map(_.impls).mkVecVec().indent
         } :+ "}"
       val traits = codes.filter(_.implicitToJava.priority > 0).groupBy(_.implicitToJava.priority).toVector.sortBy(- _._1).map{ case (k,vs) =>
-        s"trait Priority${k}FunctionConverters {" +:
+        s"${priorityName(k)} {" +:
         s"  import functionConverterImpls._" +:
         s"  " +:
         vs.map(_.implicitToJava.lines).mkVec().indent :+
@@ -125,7 +125,10 @@ object WrapFnGen {
         s"  " +:
         {
           explicitDefs.indent ++
-          codes.filter(_.implicitToJava.priority == 0).map(_.convs).mkVecVec().indent
+          Vector.fill(3)("  ") ++
+          codes.filter(_.implicitToJava.priority == 0).map(_.implicitToJava.lines).mkVec().indent ++
+          Vector.fill(3)("  ") ++
+          codes.map(_.implicitToScala).mkVec().indent
         } :+ "}"
       (impls, traits :+ packageObj)
     }
@@ -165,12 +168,13 @@ object WrapFnGen {
       // (1) The wrapper class that wraps a Java SAM as Scala function, or vice versa (ClassN)
       // (2) A value class that provides .asJava or .asScala to request the conversion (ValCN)
       // (3) A name for an explicit conversion method (DefN)
-      // (4) If nested-trait lookup is needed to pick types, an implicit conversion method name (ImpN)
+      // (4) An implicit conversion method name (ImpN) that invokes the value class
 
       // Names for Java conversions to Scala
       val j2sClassN = TypeName("FromJava" + jfn.title)
       val j2sValCN = TypeName("Rich" + jfn.title + "As" + scalaType.name.encoded)
       val j2sDefN = TermName("asScalaFrom" + jfn.title)
+      val j2sImpN = TermName("enrichAsScalaFrom" + jfn.title)
 
       // Names for Scala conversions to Java
       val s2jClassN = TypeName("AsJava" + jfn.title)
@@ -190,12 +194,15 @@ object WrapFnGen {
         }"""
 
       val j2sValCTree =
-        q"""implicit class $j2sValCN[..$tdParams](private val underlying: $javaType[..$javaTargs]) extends AnyVal {
+        q"""class $j2sValCN[..$tdParams](private val underlying: $javaType[..$javaTargs]) extends AnyVal {
           @inline def asScala: $scalaType[..$scalaTargs] = new $j2sClassN[..$tnParams](underlying)
         }"""
 
       val j2sDefTree =
-        q"""def $j2sDefN[..$tdParams](jf: $javaType[..$javaTargs]): $scalaType[..$scalaTargs] = new $j2sClassN[..$tnParams](jf)"""
+        q"""@inline def $j2sDefN[..$tdParams](jf: $javaType[..$javaTargs]): $scalaType[..$scalaTargs] = new $j2sClassN[..$tnParams](jf)"""
+      
+      val j2sImpTree =
+        q"""@inline implicit def $j2sImpN[..$tdParams](jf: $javaType[..$javaTargs]): $j2sValCN[..$tnParams] = new $j2sValCN[..$tnParams](jf)"""
 
       val s2jClassTree =
         q"""class $s2jClassN[..$tdParams](sf: $scalaType[..$scalaTargs]) extends $javaType[..$javaTargs] {
@@ -208,14 +215,14 @@ object WrapFnGen {
         }"""
 
       val s2jDefTree =
-        q"""def $s2jDefN[..$tdParams](sf: $scalaType[..$scalaTargs]): $javaType[..$javaTargs] = new $s2jClassN[..$tnParams](sf)"""
+        q"""@inline def $s2jDefN[..$tdParams](sf: $scalaType[..$scalaTargs]): $javaType[..$javaTargs] = new $s2jClassN[..$tnParams](sf)"""
 
       // This is especially tricky because functions are contravariant in their arguments
       // Need to prevent e.g. Any => String from "downcasting" itself to Int => String; we want the more exact conversion
       val s2jImpTree: (Tree, Int) =
         if (jfn.pTypes.forall(! _.isFinalType) && jfn.sig == jfn.sam.typeSignature)
           (
-            q"""implicit def $s2jImpN[..$tdParams](sf: $scalaType[..$scalaTargs]): $s2jValCN[..$tnParams] = new $s2jValCN[..$tnParams](sf)""",
+            q"""@inline implicit def $s2jImpN[..$tdParams](sf: $scalaType[..$scalaTargs]): $s2jValCN[..$tnParams] = new $s2jValCN[..$tnParams](sf)""",
             tdParams.length
           )
         else {
@@ -243,7 +250,7 @@ object WrapFnGen {
             dropRight(if (jfn.rType.isFinalType) 1 else 0)
           val evs = evidences.map{ case (generic, specific) => ValDef(NoMods, TermName("ev"+generic.toString), tq"$generic =:= $specific", EmptyTree) }
           val tree = 
-            q"""implicit def $s2jImpN[..$scalafnTdefs](sf: $scalaType[..$scalafnTnames])(implicit ..$evs): $s2jValCN[..$tnParams] = 
+            q"""@inline implicit def $s2jImpN[..$scalafnTdefs](sf: $scalaType[..$scalafnTnames])(implicit ..$evs): $s2jValCN[..$tnParams] = 
               new $s2jValCN[..$tnParams](sf.asInstanceOf[$scalaType[..$scalaTargs]])
             """
           val depth = numberedA.size
@@ -253,7 +260,8 @@ object WrapFnGen {
       SamConversionCode(
         base = jfn.title,
         wrappedAsScala = j2sClassTree.text,
-        implicitToScala = j2sValCTree.text,
+        asScalaAnyVal = j2sValCTree.text,
+        implicitToScala = j2sImpTree.text,
         asScalaDef = j2sDefTree.text,
         wrappedAsJava = s2jClassTree.text,
         asJavaAnyVal = s2jValCTree.text,