Merge pull request #28 from ShaneDelmore/Issue_27_support_no_implicit_typeclass_found

Implement advice for no implicit typeclass found requested in issue #27

Author: adamw

model/src/main/scala/com/softwaremill/clippy/CompilationError.scala

@@ -103,6 +103,26 @@ case class ImplicitNotFoundError[T <: Template](parameter: T, implicitType: T) e
     RegexT.fromPattern(implicitType.v))
 }
 
+case class TypeclassNotFoundError[T <: Template](typeclass: T, forType: T) extends CompilationError[T] {
+
+  override def toString = s"Implicit $typeclass typeclass not found error: for type $forType"
+
+  override def toJson =
+    JObject(
+      TypeField -> JString("typeclassNotFound"),
+      "typeclass" -> JString(typeclass.v),
+      "forType" -> JString(forType.v)
+    )
+
+  override def matches(other: CompilationError[ExactT])(implicit ev: T =:= RegexT) = other match {
+    case TypeclassNotFoundError(p, i) => typeclass.matches(p) && forType.matches(i)
+    case _ => false
+  }
+
+  override def asRegex(implicit ev: T =:= ExactT) = TypeclassNotFoundError(RegexT.fromPattern(typeclass.v),
+    RegexT.fromPattern(forType.v))
+}
+
 case class DivergingImplicitExpansionError[T <: Template](forType: T, startingWith: T, in: T) extends CompilationError[T] {
 
   override def toString = s"Diverging implicit expansion error: for type $forType starting with $startingWith in $in"
@@ -203,6 +223,12 @@ object CompilationError {
           alternatives <- multipleRegexTFromJson(fields, "alternatives")
         } yield TypeArgumentsDoNotConformToOverloadedBoundsError(typeArgs, alternativesOf, alternatives)
 
+      case "typeclassNotFound" =>
+        for {
+          typeclass <- regexTFromJson(fields, "typeclass")
+          forType <- regexTFromJson(fields, "forType")
+        } yield TypeclassNotFoundError(typeclass, forType)
+
       case _ => None
     }
 

model/src/main/scala/com/softwaremill/clippy/CompilationErrorParser.scala

@@ -13,6 +13,13 @@ object CompilationErrorParser {
   private val ImplicitNotFoundRegexp = """could not find implicit value for parameter\s*([^:]+):\s*([^\n]+)""".r
   private val DivergingImplicitExpansionRegexp = """diverging implicit expansion for type\s*([^\s]+)\s*.*\s*starting with method\s*([^\s]+)\s*in\s*([^\n]+)""".r
   private val TypeArgumentsDoNotConformToOverloadedBoundsRegexp = """type arguments \[([^\]]+)\] conform to the bounds of none of the overloaded alternatives of\s*([^:\n]+)[^:]*: ([^\n]+)""".r
+  private val TypeclassNotFoundRegexp = """No implicit (.*) defined for (.*)\.""".r
+
+  /*
+  No implicit Ordering defined for java.time.LocalDate.
+    Seq(java.time.LocalDate.MIN, java.time.LocalDate.MAX).sorted
+  ^
+  */
 
   def parse(e: String): Option[CompilationError[ExactT]] = {
     val error = e.replaceAll(Pattern.quote("[error]"), "")
@@ -58,6 +65,11 @@ object CompilationErrorParser {
       } yield TypeArgumentsDoNotConformToOverloadedBoundsError[ExactT](ExactT(inf.group(1)), ExactT(inf.group(2)),
         inf.group(3).split(Pattern.quote(" <and> ")).toSet.map(ExactT.apply))
     }
+    else if (error.contains("No implicit")) {
+      for {
+        inf <- TypeclassNotFoundRegexp.findFirstMatchIn(error)
+      } yield TypeclassNotFoundError(ExactT(inf.group(1)), ExactT(inf.group(2)))
+    }
     else None
   }
 }

tests/src/test/scala/org/softwaremill/clippy/CompileTests.scala

@@ -55,6 +55,14 @@ class CompileTests extends FlatSpec with Matchers with BeforeAndAfterAll {
       ).asRegex,
         "incorrect class name passed to TableQuery",
         Library("com.typesafe.slick", "slick", "3.1.1")
+      ),
+      Advice(
+        TypeclassNotFoundError(
+          ExactT("Ordering"),
+          ExactT("java.time.LocalDate")
+        ).asRegex,
+        "implicit val localDateOrdering: Ordering[java.time.LocalDate] = Ordering.by(_.toEpochDay)",
+        Library("java-lang", "time", "8+")
       )
     )
 
@@ -91,6 +99,7 @@ class CompileTests extends FlatSpec with Matchers with BeforeAndAfterAll {
                      |class A()
                      |val a = wire[A]
                    """.stripMargin,
+    "missing_typeclass" -> "Seq(java.time.LocalDate.MIN, java.time.LocalDate.MAX).sorted",
     "slick" -> """
                      |case class User(id1: Long, id2: Long)
                      |trait TestSchema {