Closes #4300 adds better worded pattern match unreachability warning

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

@@ -130,6 +130,7 @@ public enum ErrorMessageID {
     DoubleDeclarationID,
     MatchCaseOnlyNullWarningID,
     ImportRenamedTwiceID,
+    PatternMatchAlwaysSucceedsID,
     ;
 
     public int errorNumber() {

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

@@ -2117,4 +2117,38 @@ object messages {
     val explanation: String = ""
   }
 
+  case class PatternMatchAlwaysSucceeds(foundCls: Symbol, testCls: Symbol)(implicit ctx: Context) extends Message(PatternMatchAlwaysSucceedsID) {
+    val kind = "Syntax"
+    val msg: String =
+      hl"""
+         |The type check in the highlighted part of the pattern match case statement will always succeed,
+         |since `$foundCls` is a subclass of `$testCls`.
+       """
+    val codeExampleValidWarning = "def foo(a: Int) = a match { case x: Int => x }"
+    val codeExampleDisregardWarning =
+      hl"""
+        |object Foo {
+        |  def unapply(x: Int): Option[Int] = if (x % 2 == 0) Some(x) else None
+        |}
+        |
+        |class Test {
+        |  def foo(a: Int) = a match { case Foo(x: Int) => x }
+        |}
+      """
+    val explanation: String =
+      hl"""
+          |The highlighted typecheck will always match.
+          |For example:
+          |
+          |$codeExampleValidWarning
+          |
+          |The type of the scrutinee 'a' will always be 'Int', so a the 'case x: Int'
+          |match will always be successful. Maybe a guard clause was forgotten.
+          |
+          |In the following counter-example, because of the unapply method, the
+          |whole match will not be always successful, only the type check.
+          |$codeExampleDisregardWarning
+          |
+        """
+  }
 }

compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala

@@ -10,6 +10,7 @@ import ValueClasses._
 import SymUtils._
 import core.Flags._
 import util.Positions._
+import reporting.diagnostic.messages.PatternMatchAlwaysSucceeds
 import reporting.trace
 
 
@@ -90,9 +91,12 @@ object TypeTestsCasts {
 
           if (expr.tpe <:< testType)
             if (expr.tpe.isNotNull) {
-              ctx.warning(
-                em"this will always yield true, since `$foundCls` is a subclass of `$testCls`",
-                expr.pos)
+              if (inMatch)
+                ctx.warning(PatternMatchAlwaysSucceeds(foundCls, testCls), tree.pos)
+              else
+                ctx.warning(
+                  em"this will always yield true, since `$foundCls` is a subclass of `$testCls`",
+                  expr.pos)
               constant(expr, Literal(Constant(true)))
             }
             else expr.testNotNull