Tests, manually written, for function converters.

Ichoran · retronym · commit 44643f44fd9b · 2015-07-28T16:58:03.000+10:00
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.
diff --git a/README.md b/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
diff --git a/fnGen/WrapFnGen.scala b/fnGen/WrapFnGen.scala
@@ -10,9 +10,9 @@ object WrapFnGen {
     | * This file auto-generated by WrapFnGen.scala.  Do not modify directly.
     | */
     |""".stripMargin
-  
+
   val packaging = "package scala.compat.java8"
-  
+
   import scala.tools.nsc._
   import scala.reflect.internal._
   val settings = new Settings(msg => sys.error(msg))
@@ -21,12 +21,12 @@ object WrapFnGen {
   val run = new compiler.Run
 
   import compiler._, definitions._
-  
-  
+
+
   implicit class IndentMe(v: Vector[String]) {
     def indent: Vector[String] = v.map("  " + _)
   }
-  
+
   implicit class FlattenMe(v: Vector[Vector[String]]) {
     def mkVec(join: String = ""): Vector[String] = {
       val vb = Vector.newBuilder[String]
@@ -39,7 +39,7 @@ object WrapFnGen {
       vb.result()
     }
   }
-  
+
   implicit class DoubleFlattenMe(v: Vector[Vector[Vector[String]]]) {
     def mkVecVec(join: String = ""): Vector[String] = {
       val vb = Vector.newBuilder[String]
@@ -57,39 +57,39 @@ object WrapFnGen {
       vb.result()
     }
   }
-  
+
   implicit class SplitMyLinesAndStuff(s: String) {
     def toVec = s.linesIterator.toVector
     def nonBlank = s.trim.length > 0
   }
-  
+
   implicit class TreeToText(t: Tree) {
     def text = showCode(t).replace("$", "").linesIterator.toVector
   }
-  
+
   case class Prioritized(lines: Vector[String], priority: Int) {
     def withPriority(i: Int) = copy(priority = i)
   }
-  
+
   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 {
     def apply(scc: SamConversionCode*): (Vector[String], Vector[Vector[String]]) = {
       val sccDepthSet = scc.map(_.implicitToJava.priority).toSet
-      val codes = 
+      val codes =
         {
           if (sccDepthSet != (0 to sccDepthSet.max).toSet) {
             val sccDepthMap = sccDepthSet.toList.sorted.zipWithIndex.toMap
@@ -98,43 +98,46 @@ object WrapFnGen {
           else scc
         }.toVector.sortBy(_.base)
       def priorityName(n: Int, pure: Boolean = false): String = {
-        val pre = 
+        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 = 
+      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 :+
         s"}"
       }
       val explicitDefs = codes.map(_.defs).mkVecVec()
       val packageObj =
-        s"${priorityName(0)} {" +: 
+        s"${priorityName(0)} {" +:
         s"  import functionConverterImpls._" +:
         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)
     }
   }
-  
+
   private def buildWrappersViaReflection: Seq[SamConversionCode] = {
 
     val pack: Symbol = rootMirror.getPackageIfDefined(TermName("java.util.function"))
-    
+
     case class Jfn(iface: Symbol, sam: Symbol) {
       lazy val genericCount = iface.typeParams.length
       lazy val name = sam.name.toTermName
@@ -145,77 +148,81 @@ object WrapFnGen {
       lazy val rType = sig.resultType
       def arity = params.length
     }
-    
+
     val sams = pack.info.decls.
       map(d => (d, d.typeSignature.members.filter(_.isAbstract).toList)).
       collect{ case (d, m :: Nil) if d.isAbstract => Jfn(d, m) }
-    
+
     def generate(jfn: Jfn): SamConversionCode = {
       def mkRef(tp: Type): Tree = if (tp.typeSymbol.isTypeParameter) Ident(tp.typeSymbol.name.toTypeName) else tq"$tp"
-      
+
       // Types for the Java SAM and the corresponding Scala function, plus all type parameters
       val scalaType = gen.mkAttributedRef(FunctionClass(jfn.arity))
       val javaType = gen.mkAttributedRef(jfn.iface)
       val tnParams: List[TypeName] = jfn.iface.typeParams.map(_.name.toTypeName)
       val tdParams: List[TypeDef] = tnParams.map(TypeDef(NoMods, _, Nil, EmptyTree))
       val javaTargs: List[Tree] = tdParams.map(_.name).map(Ident(_))
       val scalaTargs: List[Tree] = jfn.pTypes.map(mkRef) :+ mkRef(jfn.rType)
-      
+
       // Conversion wrappers have three or four components that we need to name
       // (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)
       val s2jValCN = TypeName("Rich" + scalaType.name.encoded + "As" + jfn.title)
       val s2jDefN = TermName("asJava" + jfn.title)
       val s2jImpN = TermName("enrichAsJava" + jfn.title)
-      
+
       // Argument lists for the function / SAM
-      val vParams = (jfn.params zip jfn.pTypes).map{ case (p,t) => 
+      val vParams = (jfn.params zip jfn.pTypes).map{ case (p,t) =>
         ValDef(NoMods, p.name.toTermName, if (t.typeSymbol.isTypeParameter) Ident(t.typeSymbol.name) else gen.mkAttributedRef(t.typeSymbol), EmptyTree)
       }
       val vParamRefs = vParams.map(_.name).map(Ident(_))
-      
-      val j2sClassTree = 
+
+      val j2sClassTree =
         q"""class $j2sClassN[..$tdParams](jf: $javaType[..$javaTargs]) extends $scalaType[..$scalaTargs] {
           def apply(..$vParams) = jf.${jfn.name}(..$vParamRefs)
         }"""
-      
+
       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] {
           def ${jfn.name}(..$vParams) = sf.apply(..$vParamRefs)
         }"""
-      
+
       val s2jValCTree =
         q"""class $s2jValCN[..$tdParams](private val underlying: $scalaType[..$scalaTargs]) extends AnyVal {
           @inline def asJava: $javaType[..$javaTargs] = new $s2jClassN[..$tnParams](underlying)
         }"""
-      
+
       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 {
@@ -242,29 +249,30 @@ object WrapFnGen {
             map(TypeDef(NoMods, _, Nil, EmptyTree)).
             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] = 
+          val tree =
+            q"""@inline implicit def $s2jImpN[..$scalafnTdefs](sf: $scalaType[..$scalafnTnames])(implicit ..$evs): $s2jValCN[..$tnParams] =
               new $s2jValCN[..$tnParams](sf.asInstanceOf[$scalaType[..$scalaTargs]])
             """
           val depth = numberedA.size
           (tree, tdParams.length)
         }
-      
+
       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,
         implicitToJava = s2jImpTree match { case (t,d) => Prioritized(t.text, d) },
         asJavaDef = s2jDefTree.text
       )
     }
-    
+
     sams.toSeq.map(generate)
   }
-    
+
   lazy val converterContents =
     s"""
     |$copyright
@@ -278,21 +286,21 @@ object WrapFnGen {
     (SamConversionCode(buildWrappersViaReflection: _*) match {
       case (impls, defs) => impls.mkString("\n") + "\n\n\n\n" + defs.map(_.mkString("\n")).mkString("\n\n\n\n")
     })
-    
+
   def sameText(f: java.io.File, text: String): Boolean = {
     val x = scala.io.Source.fromFile(f)
     val lines = try { x.getLines.toVector } finally { x.close }
     lines.iterator.filter(_.nonBlank) == text.linesIterator.filter(_.nonBlank)
   }
-  
+
   def write(f: java.io.File, text: String) {
     if (!f.exists || !sameText(f, text)) {
       val p = new java.io.PrintWriter(f)
       try { p.println(text) }
       finally { p.close() }
     }
   }
-  
+
   def main(args: Array[String]) {
     val names = args.iterator.map(x => new java.io.File(x))
     write(names.next, converterContents)
diff --git a/src/test/scala/scala/compat/java8/FunctionConvertersTest.scala b/src/test/scala/scala/compat/java8/FunctionConvertersTest.scala
