0.3.0 release for 2.13 compat

Author: oleg-py

Diff for: .gitignore

@@ -1,2 +1,4 @@
 target/
 .idea/
+.bloop/
+.metals/

Diff for: README.md

@@ -8,7 +8,7 @@ A Scala compiler plugin to give patterns and for-comprehensions the love they de
 ## Getting started
 The plugin is available on Maven Central.
 ```sbt
-addCompilerPlugin("com.olegpy" %% "better-monadic-for" % "0.3.0-M4")
+addCompilerPlugin("com.olegpy" %% "better-monadic-for" % "0.3.0")
 ```
 Supports Scala 2.11, 2.12, and 2.13.0-RC1
 

Diff for: build.sbt

@@ -1,10 +1,13 @@
+import xerial.sbt.Sonatype._
+
 lazy val scala213 = "2.13.0-RC1"
 lazy val scala212 = "2.12.8"
 lazy val scala211 = "2.11.12"
+
 lazy val supportedScalaVersions = List(scala211, scala212, scala213)
 
 ThisBuild / organization := "com.olegpy"
-ThisBuild / version := "0.2.4"
+ThisBuild / version := "0.3.0"
 ThisBuild / licenses += ("MIT", url("http://opensource.org/licenses/MIT"))
 ThisBuild / homepage := Some(url("https://github.com/oleg-py/better-monadic-for"))
 ThisBuild / scalaVersion := scala212
@@ -14,7 +17,7 @@ val testSettings = Seq(
     "org.scalatest" %% "scalatest" % "3.0.8-RC2" % Test
   ),
   Test / scalacOptions ++= {
-    val jar = (plugin / Compile / packageBin).value
+    val jar = (betterMonadicFor / Compile / packageBin).value
     Seq(s"-Xplugin:${jar.getAbsolutePath}", s"-Jdummy=${jar.lastModified}") // ensures recompile
   },
   Test / scalacOptions ++= {
@@ -27,23 +30,26 @@ val testSettings = Seq(
 )
 
 lazy val root = (project in file("."))
-  .aggregate(plugin, pluginTests, catsTests, pcplodTests)
+  .aggregate(betterMonadicFor, pluginTests, catsTests, scalazTests, pcplodTests)
   .settings(
     crossScalaVersions := Nil,
     publish / skip := true
   )
 
-lazy val plugin = (project in file("plugin"))
+lazy val betterMonadicFor = (project in file("better-monadic-for"))
   .settings(
     name := "better-monadic-for",
     crossScalaVersions := supportedScalaVersions,
     libraryDependencies ++= Seq(
       scalaOrganization.value % "scala-compiler" % scalaVersion.value,
-    )
+    ),
+    publishTo := sonatypePublishTo.value,
+    publishMavenStyle := true,
+    sonatypeProjectHosting := Some(GitHubHosting("oleg-py", "better-monadic-for", "[email protected]")),
   )
 
 lazy val pluginTests = (project in file("plugin-tests"))
-  .dependsOn(plugin)
+  .dependsOn(betterMonadicFor)
   .settings(crossScalaVersions := supportedScalaVersions)
   .settings(testSettings)
 
@@ -74,3 +80,15 @@ lazy val catsTests = (project in file("cats-tests"))
     )
   )
   .settings(testSettings)
+
+
+lazy val scalazTests = (project in file("scalaz-tests"))
+  .dependsOn(pluginTests % "compile->compile;test->test")
+  .settings(
+    name := "scalaz-tests",
+    crossScalaVersions := List(scala211, scala212),
+    libraryDependencies ++= Seq(
+      "org.scalaz" %% "scalaz-core" % "7.2.27" % Test,
+    )
+  )
+  .settings(testSettings)

Diff for: cats-tests/src/test/scala/com/olegpy/bm4/CatsSyntaxTest.scala

@@ -1,19 +1,22 @@
 package com.olegpy.bm4
 
+import cats.Monad
 import org.scalatest.FreeSpec
+import cats.implicits._
 
 class CatsSyntaxTest extends FreeSpec {
-  implicit val catsInstance: cats.FlatMap[MapCheck] = new cats.FlatMap[MapCheck] {
+  implicit val mcCatsInstance: cats.FlatMap[MapCheck] = new cats.FlatMap[MapCheck] {
     def flatMap[A, B](fa: MapCheck[A])(f: A => MapCheck[B]): MapCheck[B] = {
       fa.flatMap(f)
     }
 
     def tailRecM[A, B](a: A)(f: A => MapCheck[Either[A, B]]): MapCheck[B] = {
-      assert(false)
-      null
+      fail()
     }
     def map[A, B](fa: MapCheck[A])(f: A => B): MapCheck[B] = fa.map(f)
   }
+  case class ImplicitTest(id: String)
+  def typed[A](a: A) = ()
 
   "works in generic context with extension methods of cats" in {
     import cats.syntax.all._
@@ -25,4 +28,19 @@ class CatsSyntaxTest extends FreeSpec {
 
     sillyTest(new MapCheck(11), new MapCheck(42))
   }
+
+  "supports implicit0 in F-parametric methods" - {
+    "in = bindings" in {
+      def f[F[_]: Monad] =
+        for {
+          x <- 42.pure[F]
+          _ <- "dummy".pure[F]
+          implicit0(it: ImplicitTest) = ImplicitTest("eggs")
+          str = "dummy"
+          _ = typed[String](str)
+        } yield assert(it eq implicitly[ImplicitTest])
+
+      f[Option]
+    }
+  }
 }

Diff for: plugin-tests/src/test/scala/com/olegpy/bm4/TestImplicitPatterns.scala

@@ -0,0 +1,96 @@
+package com.olegpy.bm4
+
+import org.scalatest.FreeSpec
+
+object CTTest {
+  def foo[A]: Mo[A] = for {
+    implicit0(a: A) <- Mo.delay(null.asInstanceOf[A])
+  } yield implicitly[A]
+}
+
+class TestImplicitPatterns extends FreeSpec {
+  case class ImplicitTest(id: String)
+  def typed[A](a: A) = ()
+  case class ImplicitTest2(id: String)
+
+  // Make IDE happy
+//  object implicit0 { def unapply[A](a: A) = Some(a) }
+
+  "Implicit patterns support" - {
+    "for-comprehensions with plain types" - {
+      "without type ascription" - {
+        "as <- binding" in {
+          for {
+            x <- Option(42)
+            implicit0(it: ImplicitTest) <- Option(ImplicitTest("eggs"))
+            _ <- Option("dummy")
+            _ = "dummy"
+            _ = assert(implicitly[ImplicitTest] eq it)
+          } yield "ok"
+        }
+
+        "as = binding" - {
+          "followed by multiple = bindings" in {
+            for {
+              x <- Option(42)
+              _ <- Option("dummy")
+              implicit0(it: ImplicitTest) = ImplicitTest("eggs")
+              _ = "dummy"
+              _ = assert(implicitly[ImplicitTest] eq it)
+            } yield "ok"
+          }
+
+          "followed by <- bindings then = bindings" in {
+            for {
+              x <- Option(42)
+              _ <- Option("dummy")
+              implicit0(it: ImplicitTest) = ImplicitTest("eggs")
+              _ <- Option("dummy")
+              _ = assert(implicitly[ImplicitTest] eq it)
+            } yield "ok"
+          }
+
+          "followed by = bindings then <- bindings" in {
+            for {
+              x <- Option(42)
+              _ <- Option("dummy")
+              implicit0(it: ImplicitTest) = ImplicitTest("eggs")
+              _ = assert(implicitly[ImplicitTest] eq it)
+              _ <- Option("dummy")
+            } yield "ok"
+          }
+
+          "with multiple implicit variables" - {
+            "mixed bindings" in {
+              for {
+                _ <- Option("dummy")
+                implicit0(it: ImplicitTest) = ImplicitTest("eggs")
+                implicit0(it1: ImplicitTest2) <- Option(ImplicitTest2("42"))
+                _ = assert(implicitly[ImplicitTest] eq it)
+                _ = assert(implicitly[ImplicitTest2] eq it1)
+              } yield "ok"
+            }
+
+            "<- bindings" in {
+              for {
+                implicit0(it1: ImplicitTest2) <- Option(ImplicitTest2("42"))
+                implicit0(it: ImplicitTest) <- Option(ImplicitTest("eggs"))
+                _ = assert(implicitly[ImplicitTest] eq it)
+                _ = assert(implicitly[ImplicitTest2] eq it1)
+              } yield "ok"
+            }
+          }
+        }
+      }
+    }
+
+    "match clauses" - {
+      "without type ascription" in {
+        (1, "foo", ImplicitTest("eggs")) match {
+          case (_, "foo", implicit0(it: ImplicitTest)) =>
+            assert(implicitly[ImplicitTest] eq it)
+        }
+      }
+    }
+  }
+}

Diff for: plugin-tests/src/test/scala/com/olegpy/bm4/TestNoTuples.scala

@@ -32,69 +32,69 @@ class TestNoTuples extends FreeSpec {
         b3 = 42
         b4 = 42
         c <- new TupleChecker(6)
-      } yield a + b0 + c + b4
-      assert(r.a == 94)
-    }
-
-    "for too many bindings" in {
-      val r = for {
-        _ <- new TupleChecker(4)
-        a = 0
-        b = 1
-        c = 2
-        d = 3
-        e = 4
-        f = 5
-        g = 6
-        h = 7
-        i = 8
-        j = 9
-        k = 10
-        l = 11
-        m = 12
-        n = 13
-        o = 14
-        p = 15
-        q = 16
-        r = 17
-        s = 18
-        t = 19
-        u = 20
-        v = 21
-        w = 22
-        x = 23
-        y = 24
-        z = 25
-        a0 = "0"
-        b0 = "1"
-        c0 = "2"
-        d0 = "3"
-        e0 = "4"
-        f0 = "5"
-        g0 = "6"
-        h0 = "7"
-        i0 = "8"
-        j0 = "9"
-        k0 = "10"
-        l0 = "11"
-        m0 = "12"
-        n0 = "13"
-        o0 = "14"
-        p0 = "15"
-        q0 = "16"
-        r0 = "17"
-        s0 = "18"
-        t0 = "19"
-        u0 = "20"
-        v0 = "21"
-        w0 = "22"
-        x0 = "23"
-        y0 = "24"
-        z0 = "25"
-      } yield s"$a$z$z0"
-
-      assert(r.a == "02525")
+      } yield a + b0 - b1 + b2 + c - b3 + b4
+      assert(r.a == 52)
     }
+//
+//    "for too many bindings" in {
+//      val r = for {
+//        _ <- new TupleChecker(4)
+//        a = 0
+//        b = 1
+//        c = 2
+//        d = 3
+//        e = 4
+//        f = 5
+//        g = 6
+//        h = 7
+//        i = 8
+//        j = 9
+//        k = 10
+//        l = 11
+//        m = 12
+//        n = 13
+//        o = 14
+//        p = 15
+//        q = 16
+//        r = 17
+//        s = 18
+//        t = 19
+//        u = 20
+//        v = 21
+//        w = 22
+//        x = 23
+//        y = 24
+//        z = 25
+//        a0 = "0"
+//        b0 = "1"
+//        c0 = "2"
+//        d0 = "3"
+//        e0 = "4"
+//        f0 = "5"
+//        g0 = "6"
+//        h0 = "7"
+//        i0 = "8"
+//        j0 = "9"
+//        k0 = "10"
+//        l0 = "11"
+//        m0 = "12"
+//        n0 = "13"
+//        o0 = "14"
+//        p0 = "15"
+//        q0 = "16"
+//        r0 = "17"
+//        s0 = "18"
+//        t0 = "19"
+//        u0 = "20"
+//        v0 = "21"
+//        w0 = "22"
+//        x0 = "23"
+//        y0 = "24"
+//        z0 = "25"
+//      } yield s"$a$z$z0"
+//
+//      assert(r.a == "02525")
+//    }
 
     "for Either in 2.11" in {
       def mkRight(a: Int): Either[String, Int] = Right(a)

Diff for: plugin-tests/src/test/scala/com/olegpy/bm4/TestUnused.scala

@@ -0,0 +1,9 @@
+package com.olegpy.bm4
+
+// Test for issue #12
+object TestUnused extends App{
+  for {
+    _ <- Option(()) //parameter value x$5 in value $anonfun is never used
+    _ = 0
+  } yield ()
+}