Add an error message for "invalid unapply return type" error.

Part of #1589.

Author: Marc Karassev

compiler/src/dotty/tools/dotc/reporting/diagnostic/ErrorMessageID.java

@@ -115,6 +115,7 @@ public enum ErrorMessageID {
     TraitRedefinedFinalMethodFromAnyRefID,
     PackageNameAlreadyDefinedID,
     UnapplyInvalidNumberOfArgumentsID,
+    InvalidUnapplyReturnTypeID,
     StaticFieldsOnlyAllowedInObjectsID,
     CyclicInheritanceID,
     UnableToExtendSealedClassID,

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -1943,6 +1943,57 @@ object messages {
         |""".stripMargin
   }
 
+  case class InvalidUnapplyReturnType(unapplyResult: Type, unapplyName: Symbol#ThisName)(implicit ctx: Context)
+    extends Message(InvalidUnapplyReturnTypeID) {
+    val kind = "Type Mismatch"
+    val msg = hl"""| ${Red(i"$unapplyResult")} is not a valid result type of an $unapplyName method of an ${Magenta("extractor")}."""
+    val explanation = if (unapplyName.show == "unapply")
+      hl"""
+          |To be used as an extractor, an unapply method has to return a type that either:
+          | - has members ${Magenta("isEmpty: Boolean")} and ${Magenta("get: S")} (usually an ${Green("Option[S]")})
+          | - is a ${Green("Boolean")}
+          | - is a ${Green("Product")} (like a ${Magenta("Tuple2[T1, T2]")})
+          |
+          |class A(val i: Int)
+          |
+          |object B {
+          |  def unapply(a: A): ${Green("Option[Int]")} = Some(a.i)
+          |}
+          |
+          |object C {
+          |  def unapply(a: A): ${Green("Boolean")} = a.i == 2
+          |}
+          |
+          |object D {
+          |  def unapply(a: A): ${Green("(Int, Int)")} = (a.i, a.i)
+          |}
+          |
+          |object Test {
+          |  def test(a: A) = a match {
+          |    ${Magenta("case B(1)")} => 1
+          |    ${Magenta("case a @ C()")} => 2
+          |    ${Magenta("case D(3, 3)")} => 3
+          |  }
+          |}
+        """.stripMargin
+    else
+      hl"""
+          |To be used as an extractor, an unapplySeq method has to return a type which has members
+          |${Magenta("isEmpty: Boolean")} and ${Magenta("get: S")} where ${Magenta("S <: Seq[V]")} (usually an ${Green("Option[Seq[V]]")}):
+          |
+          |object CharList {
+          |  def unapplySeq(s: String): ${Green("Option[Seq[Char]")} = Some(s.toList)
+          |
+          |  "example" match {
+          |    ${Magenta("case CharList(c1, c2, c3, c4, _, _, _)")} =>
+          |      println(s"$$c1,$$c2,$$c3,$$c4")
+          |    case _ =>
+          |      println("Expected *exactly* 7 characters!")
+          |  }
+          |}
+        """.stripMargin
+  }
+
   case class StaticFieldsOnlyAllowedInObjects(member: Symbol)(implicit ctx: Context) extends Message(StaticFieldsOnlyAllowedInObjectsID) {
     val msg = hl"${"@static"} $member in ${member.owner} must be defined inside an ${"object"}."
     val kind = "Syntax"

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -34,6 +34,7 @@ import reporting.diagnostic.Message
 import reporting.trace
 import Constants.{Constant, IntTag, LongTag}
 import dotty.tools.dotc.reporting.diagnostic.messages.UnapplyInvalidNumberOfArguments
+import dotty.tools.dotc.reporting.diagnostic.messages.InvalidUnapplyReturnType
 
 import scala.collection.mutable.ListBuffer
 
@@ -93,7 +94,7 @@ object Applications {
     def getTp = extractorMemberType(unapplyResult, nme.get, pos)
 
     def fail = {
-      ctx.error(i"$unapplyResult is not a valid result type of an $unapplyName method of an extractor", pos)
+      ctx.error(InvalidUnapplyReturnType(unapplyResult, unapplyName))
       Nil
     }
 

compiler/test/dotty/tools/dotc/reporting/ErrorMessagesTests.scala

@@ -1225,6 +1225,46 @@ class ErrorMessagesTests extends ErrorMessagesTest {
         assertEquals("(class Int, class String)", argTypes.map(_.typeSymbol).mkString("(", ", ", ")"))
       }
 
+  @Test def invalidUnapplyReturnType =
+    checkMessagesAfter("frontend") {
+      """
+        |class A(val i: Int)
+        |
+        |object A {
+        |  def unapply(a: A): Int = a.i
+        |  def test(a: A) = a match {
+        |    case A() => 1
+        |  }
+        |}
+      """.stripMargin
+    }.expect { (ictx, messages) =>
+      implicit val ctx: Context = ictx
+      assertMessageCount(1, messages)
+      val InvalidUnapplyReturnType(unapplyResult, unapplyName) :: Nil = messages
+      assertEquals("Int", unapplyResult.show)
+      assertEquals("unapply", unapplyName.show)
+    }
+
+  @Test def invalidUnapplySeqReturnType =
+    checkMessagesAfter("frontend") {
+      """
+        |class A(val i: Int)
+        |
+        |object A {
+        |  def unapplySeq(a: A): Int = a.i
+        |  def test(a: A) = a match {
+        |    case A() => 1
+        |  }
+        |}
+      """.stripMargin
+    }.expect { (ictx, messages) =>
+      implicit val ctx: Context = ictx
+      assertMessageCount(1, messages)
+      val InvalidUnapplyReturnType(unapplyResult, unapplyName) :: Nil = messages
+      assertEquals("Int", unapplyResult.show)
+      assertEquals("unapplySeq", unapplyName.show)
+    }
+
   @Test def staticOnlyAllowedInsideObjects =
     checkMessagesAfter("checkStatic") {
       """