Drop error messages tests

I believe error messages tests should be dropped, unless they test something really specific.
E.g. a way information is represented that is easy to break.

For normal tests we have check files, or (most of the time even better) `// error` annotations.

The problem with over-engineered solutions like error messages tests is that they cause a huge
friction when things change. I lost an inordinate amount of time getting the extensions PR
over the line since in the meantime there landed an elaborate error messages commit. Fixing rebase
breakages over this PR is not a good use of my time! Two things could improve that situation:

 - we go slower on inessential PRs like error messages, _in particular_ if there is a pending
   conflict with a pending PR
 - we go faster merging essential PRs.

Author: odersky

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

@@ -1840,74 +1840,6 @@ class ErrorMessagesTests extends ErrorMessagesTest {
         assertEquals("given x @ String", x.show)
       }
 
-  @Test def extensionMethodsNotAllowed =
-    checkMessagesAfter(RefChecks.name) {
-      """object Test {
-        |  extension on[T] (t: T) {
-        |    def (c: T).f: T = ???
-        |  }
-        |}
-      """.stripMargin
-    }
-      .expect { (ictx, messages) ⇒
-        implicit val ctx: Context = ictx
-        assertMessageCount(1, messages)
-        val errorMsg = messages.head.msg
-        val NoExtensionMethodAllowed(x) :: Nil = messages
-        assertEquals("No extension method allowed here, since collective parameters are given", errorMsg)
-        assertEquals("def (c: T) f: T = ???", x.show)
-      }
-
-  @Test def extensionMethodTypeParamsNotAllowed =
-    checkMessagesAfter(RefChecks.name) {
-      """object Test {
-        |  extension on[T] (t: T) {
-        |    def f[U](u: U): T = ???
-        |  }
-        |}
-      """.stripMargin
-    }
-      .expect { (ictx, messages) ⇒
-        implicit val ctx: Context = ictx
-        assertMessageCount(1, messages)
-        val errorMsg = messages.head.msg
-        val ExtensionMethodCannotHaveTypeParams(x) :: Nil = messages
-        assertEquals("Extension method cannot have type parameters since some were already given previously", errorMsg)
-        assertEquals("def f[U](u: U): T = ???", x.show)
-      }
-
-  @Test def extensionMethodCanOnlyHaveDefs =
-    checkMessagesAfter(RefChecks.name) {
-      """object Test {
-        |  extension on[T] (t: T) {
-        |    val v: T = t
-        |  }
-        |}
-      """.stripMargin
-    }
-      .expect { (ictx, messages) ⇒
-        implicit val ctx: Context = ictx
-        assertMessageCount(1, messages)
-        val errorMsg = messages.head.msg
-        val ExtensionCanOnlyHaveDefs(x) :: Nil = messages
-        assertEquals("Only methods allowed here, since collective parameters are given", errorMsg)
-        assertEquals("val v: T = t", x.show)
-      }
-
-  @Test def anonymousInstanceMustImplementAType =
-    checkMessagesAfter(RefChecks.name) {
-      """object Test {
-        |  extension on[T] (t: T) { }
-        |}
-      """.stripMargin
-    }
-      .expect { (ictx, messages) ⇒
-        implicit val ctx: Context = ictx
-        assertMessageCount(1, messages)
-        val errorMsg = messages.head.msg
-        assertEquals("anonymous instance must implement a type or have at least one extension method", errorMsg)
-      }
-
   @Test def typeSplicesInValPatterns =
     checkMessagesAfter(RefChecks.name) {
       s"""import scala.quoted._