Merge pull request #30 from kubukoz/more-honest-wildcard-error

Show more honest errors when a wildcard name is used in implicit0

Author: oleg-py

better-monadic-for/src/main/scala/com/olegpy/bm4/ImplicitPatterns.scala

@@ -102,19 +102,43 @@ trait ImplicitPatterns extends TreeUtils { self =>
 
   object HasImplicitPattern {
     def unapply(arg: Tree): Boolean = arg.exists {
-      case q"implicit0(${Bind(t: TermName, Typed(Ident(termNames.WILDCARD), _))})" if t != termNames.WILDCARD =>
+      case t@q"implicit0(${WildcardIdentifier(typed)})" =>
+        val andType = if(typed) " and type" else ""
+
+        reporter.error(
+          arg.pos,
+          s"implicit pattern requires an identifier, but a wildcard was used: `$t`. " +
+            s"This doesn't introduce anything into the implicit scope. You might want to remove the implicit0 pattern$andType."
+        )
+        false
+
+      case q"implicit0(${Bind(t: TermName, Typed(Ident(termNames.WILDCARD), _))})" =>
         true
+
       case q"implicit0($_)" =>
-        reporter.error(arg.pos, "implicit pattern only supports identifier with type pattern")
+        reporter.error(arg.pos, "implicit pattern only supports identifiers with a type pattern")
         false
+
       case q"implicit0(..$_)" =>
         reporter.error(arg.pos, "implicit pattern only accepts a single parameter")
         false
+
       case _ =>
         false
     }
   }
 
+  object WildcardIdentifier {
+    /**
+     * Matches the `_: Foo` and `_` patterns, and specifies whether the type annotation was present.
+     */
+    def unapply(arg: Tree): Option[Boolean] = arg match {
+      case Typed(Ident(termNames.WILDCARD), _) => Some(true)
+      case Ident(termNames.WILDCARD) => Some(false)
+      case _ => None
+    }
+  }
+
   object StripImplicitZero extends Transformer {
     override def transform(tree: Tree): Tree = tree match {
       case q"implicit0(${Bind(t: TermName, _)})" => super.transform(Bind(t, Ident(termNames.WILDCARD)))

pcplod-tests/src/test/resources/Arrows.scala

@@ -5,4 +5,4 @@ object PcTest {
     x@flatmap@x: Int <- mkRight(66)
     (_, y@map@y) <- mkRight((11, 42))
   } yield xx + yy
-}
+}

pcplod-tests/src/test/resources/Wildcards.scala

@@ -0,0 +1,9 @@
+object Wildcards {
+  val a = for {
+    implicit0(_: Int) <- Option(42)
+  } yield "ok"
+
+  val b = for {
+    implicit0(_) <- Option(42)
+  } yield "ok"
+}

pcplod-tests/src/test/scala/com/olegpy/bm4/PresentationCompiler.scala

@@ -18,4 +18,26 @@ class PresentationCompiler extends FreeSpec {
       assert(pc.typeAtPoint('map).contains("Int"))
     }
   }
+
+  "PC should yield errors" - {
+    "when implicit0(_: Tpe) is used" in {
+      withMrPlod("Wildcards.scala") { pc =>
+        val firstError = pc.messages.head
+
+        assert(firstError.severity == PcMessageSeverity.Error)
+        assert(firstError.message == "implicit pattern requires an identifier, but a wildcard was used: `implicit0((_: Int))`. " +
+          "This doesn't introduce anything into the implicit scope. You might want to remove the implicit0 pattern and type.")
+      }
+    }
+
+    "when implicit0(_) is used" in {
+      withMrPlod("Wildcards.scala") { pc =>
+        val secondError = pc.messages(1)
+
+        assert(secondError.severity == PcMessageSeverity.Error)
+        assert(secondError.message == "implicit pattern requires an identifier, but a wildcard was used: `implicit0(_)`. " +
+          "This doesn't introduce anything into the implicit scope. You might want to remove the implicit0 pattern.")
+      }
+    }
+  }
 }

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

@@ -13,9 +13,6 @@ class TestImplicitPatterns extends FreeSpec {
   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" - {
       "with type ascription" - {