Fixed Either/OptionCapture (they just never worked at all) (fixes #25)

Author: djspiewak

core/src/main/scala/shims/util/capture.scala

@@ -21,7 +21,7 @@ import scala.language.experimental.macros
 import scala.annotation.implicitNotFound
 import scala.util.Either
 
-@implicitNotFound("unable to find an implicit value of type ${A}")
+@implicitNotFound("could not find an implicit value of type ${A}")
 final case class Capture[A](value: A) extends AnyVal
 
 object Capture {
@@ -30,7 +30,7 @@ object Capture {
     macro CaptureMacros.materializeCapture[A]
 }
 
-@implicitNotFound("unable to find an implicit value of type ${A} or ${B}")
+@implicitNotFound("could not find an implicit value of type ${A} or ${B}")
 final case class EitherCapture[A, B](value: Either[A, B]) extends AnyVal
 
 object EitherCapture {

core/src/main/scala/shims/util/macros.scala

@@ -27,43 +27,42 @@ class CaptureMacros(val c: whitebox.Context) extends OpenImplicitMacros {
 
   def materializeCapture[A: WeakTypeTag]: Tree = {
     val A = openImplicitTpeParam.getOrElse(weakTypeOf[A])
-
     q"""_root_.shims.util.Capture[$A](${reconstructImplicit(A)})"""
   }
 
   def materializeEitherCapture[A: WeakTypeTag, B: WeakTypeTag]: Tree = {
-    val A = openImplicitTpeParam.getOrElse(weakTypeOf[A])
-    val B = openImplicitTpeParam.getOrElse(weakTypeOf[B])
-
     val treeAM = try {
-      Right(q"_root_.scala.util.Left(${reconstructImplicit(A)})")
+      val A = leftImplicitTpeParam.getOrElse(weakTypeOf[A])
+      val B = weakTypeOf[B]
+      Right(q"""_root_.shims.util.EitherCapture[$A, $B](_root_.scala.util.Left[$A, $B](${reconstructImplicit(A)}))""")
     } catch {
-      case e: Exception => Left(e)
+      // ok it's actually an Error, not an Exception 🤦‍♀️
+      case t: Throwable => Left(t)
     }
 
     val treeBM = try {
-      Right(q"_root_.scala.util.Right(${reconstructImplicit(B)})")
+      val A = weakTypeOf[A]
+      val B = rightImplicitTpeParam.getOrElse(weakTypeOf[B])
+      Right(q"""_root_.shims.util.EitherCapture[$A, $B](_root_.scala.util.Right[$A, $B](${reconstructImplicit(B)}))""")
     } catch {
-      case e: Exception => Left(e)
+      // ok it's actually an Error, not an Exception 🤦‍♀️
+      case t: Throwable => Left(t)
     }
 
-    val result = treeAM.right.map(Right(_)).right.getOrElse(treeBM).fold(
+    treeAM.fold(_ => treeBM, Right(_)).fold(
       throw _,    // it's so great how scalac uses exceptions...
       identity)
-
-    q"""_root_.shims.util.EitherCapture[$A, $B]($result)"""
   }
 
   def materializeOptionCapture[A: WeakTypeTag]: Tree = {
-    val A = openImplicitTpeParam.getOrElse(weakTypeOf[A])
-
-    val result = try {
-      q"_root_.scala.Some(${reconstructImplicit(A)})"
+    try {
+      val A = openImplicitTpeParam.getOrElse(weakTypeOf[A])
+      q"""_root_.shims.util.OptionCapture[$A](_root_.scala.Some(${reconstructImplicit(A)}))"""
     } catch {
-      case e: Exception => q"_root_.scala.None"
+      // ok it's actually an Error, not an Exception 🤦‍♀️
+      case t: Throwable =>
+        q"""_root_.shims.util.OptionCapture[${weakTypeOf[A]}](_root_.scala.None)"""
     }
-
-    q"""_root_.shims.util.OptionCapture[$A]($result)"""
   }
 
   private def reconstructImplicit(A: Type): Tree = {
@@ -73,16 +72,16 @@ class CaptureMacros(val c: whitebox.Context) extends OpenImplicitMacros {
       try {
         c.inferImplicitValue(A)
       } catch {
-        case e: Exception => c.abort(c.enclosingPosition, s"Implicit $A not found")
+        case t: Throwable => c.abort(c.enclosingPosition, s"implicit $A not found")
       }
     }
 
     if (tree0 == EmptyTree) {
-      c.abort(c.enclosingPosition, s"Implicit $A not found")
+      c.abort(c.enclosingPosition, s"implicit $A not found")
     }
 
     if (tree0.tpe <:< Synthetic) {
-      c.abort(c.enclosingPosition, s"Cannot capture subtype of Synthetic")
+      c.abort(c.enclosingPosition, s"cannot capture subtype of Synthetic")
     }
 
     tree0
@@ -109,7 +108,7 @@ private[util] object CaptureMacros {
 
     // simple divergence check
     if (vs.exists(tpe <:< _.asInstanceOf[c.universe.Type])) {
-      c.abort(c.enclosingPosition, s"Implicit $tpe not found")
+      c.abort(c.enclosingPosition, s"implicit $tpe not found")
     } else {
       val vs2 = tpe :: vs
 
@@ -133,17 +132,29 @@ private[shims] trait OpenImplicitMacros {
     c.openImplicits.headOption.map(_.pt)
 
   def openImplicitTpeParam: Option[Type] =
-    openImplicitTpe.map {
+    openImplicitTpe map {
       case TypeRef(_, _, List(tpe)) =>
         tpe.map(_.dealias)
+
+      case other =>
+        c.abort(c.enclosingPosition, s"bad materialization: $other")
+    }
+
+  def leftImplicitTpeParam: Option[Type] =
+    openImplicitTpe map {
+      case TypeRef(_, _, List(tpe, _)) =>
+        tpe.map(_.dealias)
+
       case other =>
-        c.abort(c.enclosingPosition, s"Bad materialization: $other")
+        c.abort(c.enclosingPosition, s"bad materialization (left): $other")
     }
 
-  def secondOpenImplicitTpe: Option[Type] =
-    c.openImplicits match {
-      case (List(_, second, _ @ _*)) =>
-        Some(second.pt)
-      case _ => None
+  def rightImplicitTpeParam: Option[Type] =
+    openImplicitTpe map {
+      case TypeRef(_, _, List(_, tpe)) =>
+        tpe.map(_.dealias)
+
+      case other =>
+        c.abort(c.enclosingPosition, s"bad materialization (right): $other")
     }
 }

core/src/test/scala/shims/MonadConversionSpecs.scala

@@ -191,6 +191,15 @@ object MonadConversionSpecs extends Specification with Discipline {
 
         checkAll("Option", MonadTests[Option].monad[Int, Int, Int])
       }
+
+      "F[_]" >> {
+        def foo[F[_]](implicit F: scalaz.Monad[F]) = {
+          cats.Applicative[F]
+          cats.Monad[F]
+        }
+
+        ok
+      }
     }
   }
 

core/src/test/scala/shims/util/CaptureSpecs.scala

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2018 Daniel Spiewak
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package shims.util
+
+import org.specs2.mutable._
+
+object CaptureSpecs extends Specification {
+
+  "capture" should {
+    trait Foo
+    implicit case object Foo extends Foo
+
+    "find implicits" in {
+      implicitly[Capture[Foo]].value mustEqual implicitly[Foo]
+    }
+  }
+
+  "either capture" should {
+    "find left" in {
+      trait Foo
+      implicit case object Foo extends Foo
+      trait Bar
+
+      implicitly[EitherCapture[Foo, Bar]].value must beLeft(implicitly[Foo])
+    }
+
+    "find right" in {
+      trait Foo
+      trait Bar
+      implicit case object Bar extends Bar
+
+      implicitly[EitherCapture[Foo, Bar]].value must beRight(implicitly[Bar])
+    }
+  }
+
+  "option capture" should {
+    "find some" in {
+      trait Foo
+      implicit case object Foo extends Foo
+
+      implicitly[OptionCapture[Foo]].value must beSome(implicitly[Foo])
+    }
+
+    "find none" in {
+      trait Foo
+
+      implicitly[OptionCapture[Foo]].value must beNone
+    }
+  }
+}

scratch/src/main/scala/shims/playground.scala

@@ -1,3 +1,19 @@
+/*
+ * Copyright 2018 Daniel Spiewak
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 import shims._
 
 object ScalazExamples {

scratch/src/main/scala/shims/test.scala

@@ -1,7 +1,27 @@
+/*
+ * Copyright 2018 Daniel Spiewak
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package shims
 
-object Test /*{
-  implicit val capList: cats.Applicative[List] = null
+import shims.util.EitherCapture
+
+object Test {
+  trait Foo
+  implicit case object Foo extends Foo
+  trait Bar
 
-  scalaz.Applicative[List]
-}*/
+  implicitly[EitherCapture[Foo, Bar]]
+}