[1589] Moved anonymous function missing parameter type error message to case class scheme.

Author: gvolpe

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

@@ -87,6 +87,7 @@ public enum ErrorMessageID {
     ValueClassParameterMayNotBeAVarID,
     ValueClassNeedsExactlyOneValParamID,
     OnlyCaseClassOrCaseObjectAllowedID,
+    AnonymousFunctionMissingParamTypeID
     ;
 
     public int errorNumber() {

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

@@ -176,6 +176,34 @@ object messages {
            |Or, add an explicit `()' as a parameter list to ${cdef.name}."""
   }
 
+  case class AnonymousFunctionMissingParamType(param: untpd.ValDef,
+                                               args: List[untpd.Tree],
+                                               tree: untpd.Function,
+                                               pt: Type)
+                                              (implicit ctx: Context)
+  extends Message(AnonymousFunctionMissingParamTypeID) {
+    val kind = "Syntax"
+
+    val msg = {
+      val ofFun =
+        if (MethodType.syntheticParamNames(args.length + 1) contains param.name)
+          i" of expanded function $tree"
+        else
+          ""
+
+      i"missing parameter type for parameter ${param.name}$ofFun, expected = $pt"
+    }
+
+    val explanation =
+      hl"""|Anonymous functions must define a type. For example, if you define a function like this one:
+           |
+           |val f = { case l@List(1,2,3) => Some(l) }
+           |
+           |Make sure you give it a type of what you expect to match and help the type inference system:
+           |
+           |val f: Seq[Int] => Option[List[Int]] = { case l@List(1,2,3) => Some(l) } """
+  }
+
 
   // Type Errors ------------------------------------------------------------ //
   case class DuplicateBind(bind: untpd.Bind, tree: untpd.CaseDef)(implicit ctx: Context)

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

@@ -762,12 +762,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
             }
           case _ =>
         }
-        val ofFun =
-          if (MethodType.syntheticParamNames(args.length + 1) contains param.name)
-            i" of expanded function $tree"
-          else
-            ""
-        errorType(i"missing parameter type for parameter ${param.name}$ofFun, expected = $pt", param.pos)
+        errorType(AnonymousFunctionMissingParamType(param, args, tree, pt), param.pos)
       }
 
       def protoFormal(i: Int): Type =

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

@@ -792,4 +792,22 @@ class ErrorMessagesTests extends ErrorMessagesTest {
         assertEquals(err, OnlyCaseClassOrCaseObjectAllowed())
       }
 
+  @Test def anonymousFunctionMissingParamType =
+    checkMessagesAfter("refchecks") {
+      """
+        |object AnonymousF {
+        |  val f = { case l@List(1,2,3) => Some(l) }
+        |}""".stripMargin
+    }
+      .expect { (ictx, messages) =>
+        implicit val ctx: Context = ictx
+        val defn = ictx.definitions
+
+        assertMessageCount(1, messages)
+        val AnonymousFunctionMissingParamType(param, args, _, pt) :: Nil = messages
+        assertEquals("x$1", param.show)
+        assertEquals(s"List(ValDef(${param.show},TypeTree,EmptyTree))", args.toString)
+        assertEquals("?", pt.show)
+      }
+
 }