Backport "Move warn tests from tests/neg to tests/warn: Batch 2" to LTS

tests/warn/14034b.scala

@@ -0,0 +1,15 @@
+//> using options  -deprecation
+
+@deprecated trait Exp
+@deprecated val exp = 1
+
+def test1 = exp // warn
+def test2(a: Exp) = () // warn
+
+type Foo0 = Exp // warn
+type Foo = Option[Exp] // warn
+type Bar = Option[exp.type] // warn
+type Baz = Exp | Int // warn
+type Quux = [X] =>> X match
+  case Exp => Int // warn
+type Quuz[A <: Exp] = Int // warn

tests/neg/15981.check → tests/warn/15981.check

@@ -1,5 +1,5 @@
--- [E092] Pattern Match Error: tests/neg/15981.scala:4:45 --------------------------------------------------------------
-4 |    override def equals(any: Any): Boolean = any.isInstanceOf[PosInt] // error
+-- [E092] Pattern Match Unchecked Warning: tests/warn/15981.scala:4:45 -------------------------------------------------
+4 |    override def equals(any: Any): Boolean = any.isInstanceOf[PosInt] // warn
   |                                             ^^^
   |                                  the type test for PosInt cannot be checked at runtime because it's a local class
   |

tests/neg/15981.scala → tests/warn/15981.scala

@@ -1,6 +1,6 @@
-//> using options -Werror
+
 val _ = locally{
   sealed abstract class PosInt(val value: Int) {
-    override def equals(any: Any): Boolean = any.isInstanceOf[PosInt] // error
+    override def equals(any: Any): Boolean = any.isInstanceOf[PosInt] // warn
   }
 }

tests/neg/17284.check → tests/warn/17284.check

@@ -1,5 +1,5 @@
--- [E187] Potential Issue Error: tests/neg/17284.scala:4:6 -------------------------------------------------------------
-4 |  451.synchronized {} // error
+-- [E187] Potential Issue Warning: tests/warn/17284.scala:4:6 ----------------------------------------------------------
+4 |  451.synchronized {} // warn
   |  ^^^^^^^^^^^^^^^^
   |  Suspicious synchronized call on boxed class
   |---------------------------------------------------------------------------------------------------------------------
@@ -8,8 +8,8 @@
   | You called the synchronized method on a boxed primitive. This might not be what
   | you intended.
    ---------------------------------------------------------------------------------------------------------------------
--- [E187] Potential Issue Error: tests/neg/17284.scala:8:4 -------------------------------------------------------------
-8 |  x.synchronized {} // error
+-- [E187] Potential Issue Warning: tests/warn/17284.scala:8:4 ----------------------------------------------------------
+8 |  x.synchronized {} // warn
   |  ^^^^^^^^^^^^^^
   |  Suspicious synchronized call on boxed class
   |---------------------------------------------------------------------------------------------------------------------
@@ -18,8 +18,8 @@
   | You called the synchronized method on a boxed primitive. This might not be what
   | you intended.
    ---------------------------------------------------------------------------------------------------------------------
--- [E187] Potential Issue Error: tests/neg/17284.scala:11:7 ------------------------------------------------------------
-11 |  true.synchronized {} // error
+-- [E187] Potential Issue Warning: tests/warn/17284.scala:11:7 ---------------------------------------------------------
+11 |  true.synchronized {} // warn
    |  ^^^^^^^^^^^^^^^^^
    |  Suspicious synchronized call on boxed class
    |--------------------------------------------------------------------------------------------------------------------

tests/warn/17284.scala

@@ -0,0 +1,14 @@
+//> using options  -explain
+
+def test =
+  451.synchronized {} // warn
+
+def test2 =
+  val x: Integer = 451
+  x.synchronized {} // warn
+
+def test3 =
+  true.synchronized {} // warn
+
+def test4 =
+  true.hashCode() // success

tests/neg-deep-subtype/1828.scala → tests/warn/1828.scala

@@ -1,8 +1,8 @@
-//> using options -Xfatal-warnings
+
 
 class Test {
   def remove[S](a: S | Int, f: Int => S):S = a match {
-    case a: S => a             // error
+    case a: S => a             // warn
     case a: Int => f(a)
   }
 

tests/warn/18493.check

@@ -0,0 +1,8 @@
+-- [E030] Match case Unreachable Warning: tests/warn/18493.scala:6:9 ---------------------------------------------------
+6 |    case "abc" => // warn
+  |         ^^^^^
+  |         Unreachable case
+-- [E030] Match case Unreachable Warning: tests/warn/18493.scala:12:9 --------------------------------------------------
+12 |    case "abc" => // warn
+   |         ^^^^^
+   |         Unreachable case

tests/neg/18493.scala → tests/warn/18493.scala

@@ -1,14 +1,14 @@
-//> using options -Werror
+
 object PartialFunctionNoWarning {
   // nice warning
   "abc" match {
     case "abc" =>
-    case "abc" => // error
+    case "abc" => // warn
   }
 
   // no warnings
   val pf: PartialFunction[String, Unit] = {
     case "abc" =>
-    case "abc" => // error
+    case "abc" => // warn
   }
 }

tests/warn/3324b.scala

@@ -0,0 +1,11 @@
+
+
+class C[T] {
+  val x: Any = ???
+  if (x.isInstanceOf[List[String]]) // warn: unchecked
+    if (x.isInstanceOf[T])          // warn: unchecked
+      x match {
+        case x: List[String] =>     // warn: unchecked
+        case x: T =>                // warn: unchecked
+      }
+}

tests/warn/3324f.scala

@@ -0,0 +1,11 @@
+
+
+trait C[T]
+class D[T]
+
+class Test {
+  def foo[T](x: C[T]) = x match {
+    case _: D[T] =>    // warn
+    case _: C[Int] =>  // warn
+  }
+}