Add error message for only functional erased or implicit types

Author: Nadezhda Balashova

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -1423,9 +1423,9 @@ object Parsers {
         case FORSOME => syntaxError(ExistentialTypesNoLongerSupported()); t
         case _ =>
           if (imods.isOneOf(GivenOrImplicit) && !t.isInstanceOf[FunctionWithMods])
-            syntaxError("Types with implicit keyword can only be function types `implicit (...) => ...`", implicitKwPos(start))
+            syntaxError(ImplicitTypesCanOnlyBeFunctionTypes())
           if (imods.is(Erased) && !t.isInstanceOf[FunctionWithMods])
-            syntaxError("Types with erased keyword can only be function types `erased (...) => ...`", implicitKwPos(start))
+            syntaxError(ErasedTypesCanOnlyBeFunctionTypes())
           t
       }
     }

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

@@ -148,7 +148,9 @@ enum ErrorMessageID extends java.lang.Enum[ErrorMessageID] {
     IllegalSuperAccessorID,
     TraitParameterUsedAsParentPrefixID,
     UnknownNamedEnclosingClassOrObjectID,
-    IllegalCyclicTypeReferenceID
+    IllegalCyclicTypeReferenceID,
+    ImplicitTypesCanOnlyBeFunctionTypesID,
+    ErasedTypesCanOnlyBeFunctionTypesID
 
   def errorNumber = ordinal - 2
 }

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

@@ -2401,4 +2401,18 @@ object messages {
       val msg: String = i"illegal cyclic type reference: ${where} ${hl(lastChecked.show)} of $sym refers back to the type itself"
       val explanation: String = ""
     }
+
+  case class ImplicitTypesCanOnlyBeFunctionTypes()(implicit val ctx: Context)
+    extends Message(ImplicitTypesCanOnlyBeFunctionTypesID) {
+    val kind: String = "Syntax"
+    val msg: String = "Types with implicit keyword can only be function types `given (...) => ...`"
+    val explanation: String = ""
+  }
+
+  case class ErasedTypesCanOnlyBeFunctionTypes()(implicit val ctx: Context)
+    extends Message(ErasedTypesCanOnlyBeFunctionTypesID) {
+    val kind: String = "Syntax"
+    val msg: String = "Types with erased keyword can only be function types `erased (...) => ...`"
+    val explanation: String = ""
+  }
 }

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

@@ -1687,4 +1687,30 @@ class ErrorMessagesTests extends ErrorMessagesTest {
       assertEquals("alias", where)
       assertEquals("List[X]", lastChecked.show)
     }
+
+  @Test def implicitTypesCanOnlyBeFunctionTypesSuccess() =
+    checkMessagesAfter(RefChecks.name) ("def foo(f: (given Int) => Int): Int = 1")
+    .expectNoErrors
+
+  @Test def erasedTypesCanOnlyBeFunctionTypesSuccess() =
+    checkMessagesAfter(FrontEnd.name) ("def foo(f: (erased Int) => Int): Int = 1")
+      .expectNoErrors
+
+  @Test def implicitTypesCanOnlyBeFunctionTypesFailed() =
+    checkMessagesAfter(FrontEnd.name) ("def foo(f: (given Int)): Int = 1")
+      .expect { (ictx, messages) =>
+        implicit val ctx: Context = ictx
+        assertMessageCount(1, messages)
+        val ImplicitTypesCanOnlyBeFunctionTypes() :: Nil = messages
+        assertEquals("Types with implicit keyword can only be function types `given (...) => ...`", messages.head.msg)
+      }
+
+  @Test def erasedTypesCanOnlyBeFunctionTypesFailed() =
+    checkMessagesAfter(FrontEnd.name) ("def foo(f: (erased Int)): Int = 1")
+      .expect { (ictx, messages) =>
+        implicit val ctx: Context = ictx
+        assertMessageCount(1, messages)
+        val ErasedTypesCanOnlyBeFunctionTypes() :: Nil = messages
+        assertEquals("Types with erased keyword can only be function types `erased (...) => ...`", messages.head.msg)
+      }
 }