add test set for exhaustivity and redundancy check

Author: liufengyun

test/test/transform/PatmatExhaustivityTest.scala

@@ -0,0 +1,90 @@
+package test.transform
+
+import java.io._
+
+import scala.io.Source._
+import scala.reflect.io.Directory
+import org.junit.Test
+import dotty.tools.dotc.Main
+import dotty.tools.dotc.reporting.ConsoleReporter
+
+class PatmatExhaustivityTest {
+  val testsDir = "./tests/patmat"
+  // stop-after: patmatexhaust-huge.scala crash compiler
+  val options = List("-Ystop-after:splitter", "-Ycheck-all-patmat")
+
+  private def compileFile(file: File) = {
+    val stringBuffer = new StringWriter()
+    val reporter = new ConsoleReporter(writer = new PrintWriter(stringBuffer))
+
+    try {
+      Main.process((file.getPath::options).toArray, reporter, null)
+    } catch {
+      case e: Throwable =>
+        println(s"Compile $file exception:")
+        e.printStackTrace()
+    }
+
+    val actual = stringBuffer.toString.trim
+    val checkFilePath = file.getAbsolutePath.stripSuffix(".scala") + ".check"
+    val checkContent =
+      if (new File(checkFilePath).exists)
+        fromFile(checkFilePath).getLines.mkString("\n").trim
+      else ""
+
+    (file, checkContent, actual)
+  }
+
+  /** A single test with multiple files grouped in a folder */
+  private def compileDir(file: File) = {
+    val stringBuffer = new StringWriter()
+    val reporter = new ConsoleReporter(writer = new PrintWriter(stringBuffer))
+
+    val files = Directory(file.getPath).list.toList
+      .filter(f => f.extension == "scala" || f.extension == "java" )
+      .map(_.jfile.getPath)
+
+    try {
+      Main.process((options ++ files).toArray, reporter, null)
+    } catch {
+      case e: Throwable =>
+        println(s"Compile $file exception:")
+        e.printStackTrace()
+    }
+
+    val actual = stringBuffer.toString.trim
+    val checkFilePath = file.getPath + File.separator + "expected.check"
+    val checkContent =
+      if (new File(checkFilePath).exists)
+        fromFile(checkFilePath).getLines.mkString("\n").trim
+      else ""
+
+    (file, checkContent, actual)
+  }
+
+  @Test def patmatExhaustivity: Unit = {
+    val res = Directory(testsDir).list.toList
+      .filter(f => f.extension == "scala" || f.isDirectory)
+      .map { f =>
+        if (f.isDirectory)
+          compileDir(f.jfile)
+        else
+          compileFile(f.jfile)
+      }
+
+    val failed = res.filter { case (_, expected, actual) => expected != actual }
+    val ignored = Directory(testsDir).list.toList.filter(_.extension == "ignore")
+
+    failed.foreach { case (file, expected, actual) =>
+      println(s"\n----------------- incorrect output for $file --------------\n" +
+        s"Expected:\n-------\n$expected\n\nActual\n----------\n$actual\n"
+      )
+    }
+
+    val msg = s"Total: ${res.length + ignored.length}, Failed: ${failed.length}, Ignored: ${ignored.length}"
+
+    assert(failed.length == 0, msg)
+
+    println(msg)
+  }
+}

tests/patmat/NonAbstractSealed.check

@@ -0,0 +1,5 @@
+./tests/patmat/NonAbstractSealed.scala:6: warning: match may not be exhaustive.
+It would fail on the following input: _: A
+  (null: A) match {
+            ^
+one warning found

tests/patmat/NonAbstractSealed.scala

@@ -0,0 +1,10 @@
+sealed class A
+class B extends A
+class C extends A
+
+object Test {
+  (null: A) match {
+    case t: B =>
+    case t: C =>
+  }
+}

tests/patmat/TwoTrait.scala

@@ -0,0 +1,12 @@
+object Test {
+  sealed trait A
+  sealed trait B
+
+  abstract sealed class Parent
+  class Foo extends Parent with A with B
+  class Bar extends Parent with B with A
+
+  (null: A) match {
+    case _: B =>
+  }
+}

tests/patmat/aladdin1055/A.scala

@@ -0,0 +1,6 @@
+object A {
+  sealed trait T { def f: Int }
+  class TT extends T { def f = 0 }
+
+  def foo = new T { def f = 1 } // local subclass of sealed trait T
+}

tests/patmat/aladdin1055/Test_1.scala.ignore

@@ -0,0 +1,5 @@
+object Test {
+  def foo(t: A.T) = t match {
+    case a: A.TT => 0
+  }
+}

tests/patmat/aladdin1055/expected.check.ignore

@@ -0,0 +1,5 @@
+./tests/patmat/aladdin1055/Test_1.scala:2: warning: match may not be exhaustive.
+It would fail on the following input: (_ : this.<local child>)
+  def foo(t: A.T) = t match {
+                    ^
+one warning found

tests/patmat/enum/Day.java

@@ -0,0 +1,4 @@
+public enum Day {
+  SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
+  THURSDAY, FRIDAY, SATURDAY
+}

tests/patmat/enum/expected.check

@@ -0,0 +1,9 @@
+./tests/patmat/enum/patmat-enum.scala:4: warning: match may not be exhaustive.
+It would fail on the following input: SATURDAY, FRIDAY, THURSDAY, SUNDAY
+  day match {
+      ^
+./tests/patmat/enum/patmat-enum.scala:15: warning: match may not be exhaustive.
+It would fail on the following input: SATURDAY, FRIDAY, THURSDAY
+  day match {
+      ^
+two warnings found

tests/patmat/enum/patmat-enum.scala

@@ -0,0 +1,21 @@
+object Test1 {
+  val day: Day = ???
+
+  day match {
+    case Day.MONDAY => true
+    case Day.TUESDAY => true
+    case Day.WEDNESDAY => true
+  }
+}
+
+object Test2 {
+  import Day._
+  val day: Day = ???
+
+  day match {
+    case MONDAY => true
+    case TUESDAY => true
+    case WEDNESDAY => true
+    case SUNDAY => true
+  }
+}

tests/patmat/exhausting.check

@@ -0,0 +1,25 @@
+./tests/patmat/exhausting.scala:21: warning: match may not be exhaustive.
+It would fail on the following input: List(_), List(_, _, _)
+  def fail1[T](xs: List[T]) = xs match {
+                                 ^
+./tests/patmat/exhausting.scala:27: warning: match may not be exhaustive.
+It would fail on the following input: Nil
+  def fail2[T](xs: List[T]) = xs match {
+                                 ^
+./tests/patmat/exhausting.scala:32: warning: match may not be exhaustive.
+It would fail on the following input: List(_, _)
+  def fail3a(xs: List[Int]) = xs match {
+                                 ^
+./tests/patmat/exhausting.scala:39: warning: match may not be exhaustive.
+It would fail on the following input: Bar3
+  def fail3[T](x: Foo[T]) = x match {
+                              ^
+./tests/patmat/exhausting.scala:44: warning: match may not be exhaustive.
+It would fail on the following input: (Bar2, Bar2)
+  def fail4[T <: AnyRef](xx: (Foo[T], Foo[T])) = xx match {
+                                                    ^
+./tests/patmat/exhausting.scala:53: warning: match may not be exhaustive.
+It would fail on the following input: (Bar2, Bar2), (Bar2, Bar1), (Bar1, Bar3), (Bar1, Bar2)
+  def fail5[T](xx: (Foo[T], Foo[T])) = xx match {
+                                          ^
+6 warnings found

tests/patmat/exhausting.scala

@@ -0,0 +1,58 @@
+object Test {
+  sealed abstract class Foo[T]
+  case object Bar1 extends Foo[Int]
+  case object Bar2 extends Foo[String]
+  case object Bar3 extends Foo[Any]
+
+  def ex1[T](xs: List[T]) = xs match {
+    case ys: List[_]  => "ok"
+  }
+  def ex2[T](xx: (Foo[T], Foo[T])) = xx match {
+    case (Bar1, Bar1) => ()
+    case (_, Bar1) => ()
+    case (_, Bar3) => ()
+    case (_, Bar2) => ()
+  }
+  def ex3[T](xx: (Foo[T], Foo[T])) = xx match {
+    case (_: Foo[_], _: Foo[_]) => ()
+  }
+
+  // fails for: ::(_, Nil), ::(_, ::(_, ::(_, _))), ...
+  def fail1[T](xs: List[T]) = xs match {
+    case Nil            => "ok"
+    case x :: y :: Nil  => "ok"
+  }
+
+  // fails for: Nil
+  def fail2[T](xs: List[T]) = xs match {
+    case _ :: _ => "ok"
+  }
+
+  // fails for: ::(<not in (2, 1)>, _)
+  def fail3a(xs: List[Int]) = xs match {
+    case 1 :: _ =>
+    case 2 :: _ =>
+    case Nil =>
+  }
+
+  // fails for: Bar3
+  def fail3[T](x: Foo[T]) = x match {
+    case Bar1   => "ok"
+    case Bar2   => "ok"
+  }
+  // fails for: (Bar2, Bar2)
+  def fail4[T <: AnyRef](xx: (Foo[T], Foo[T])) = xx match {
+    case (Bar1, Bar1) => ()
+    case (Bar2, Bar3) => ()
+    case (Bar3, _) => ()
+  }
+  // fails for: (Bar1, Bar2)
+  // fails for: (Bar1, Bar3)
+  // fails for: (Bar2, Bar1)
+  // fails for: (Bar2, Bar2)
+  def fail5[T](xx: (Foo[T], Foo[T])) = xx match {
+    case (Bar1, Bar1) => ()
+    case (Bar2, Bar3) => ()
+    case (Bar3, _) => ()
+  }
+}

tests/patmat/exhaustive_heuristics.scala

@@ -0,0 +1,26 @@
+// tests exhaustivity doesn't give warnings (due to its heuristic rewrites kicking in or it backing off)
+object Test {
+  // List() => Nil
+  List(1) match {
+    case List() =>
+    case x :: xs =>
+  }
+
+  // we don't look into guards
+  val turnOffChecks = true
+  List(1) match {
+    case _ if turnOffChecks =>
+  }
+
+  // we back off when there are any user-defined extractors
+  // in fact this is exhaustive, but we pretend we don't know since List's unapplySeq is not special to the compiler
+  // to compensate our ignorance, we back off
+  // well, in truth, we do rewrite List() to Nil, but otherwise we do nothing
+  // the full rewrite List(a, b) to a :: b :: Nil, for example is planned (but not sure it's a good idea)
+  List(true, false) match {
+    case List(_, _, _:_*) =>
+    case List(node, _:_*)  =>
+    case Nil =>
+  }
+
+}

tests/patmat/for.scala

@@ -0,0 +1,5 @@
+object Test {
+  def foo[A, B](l: List[(A, B)]): List[A] = {
+    for ((a, b) <- l) yield a
+  }
+}

tests/patmat/gadt.check

@@ -0,0 +1,17 @@
+./tests/patmat/gadt.scala:13: warning: match may not be exhaustive.
+It would fail on the following input: IntLit(_)
+  def foo1b(x: Expr[Int]) = x match {
+                              ^
+./tests/patmat/gadt.scala:22: warning: match may not be exhaustive.
+It would fail on the following input: Or(_, _)
+  def foo2b(x: Expr[Boolean]) = x match {
+                                  ^
+./tests/patmat/gadt.scala:45: warning: match may not be exhaustive.
+It would fail on the following input: BooleanLit(_), IntLit(_)
+  def foo4b(x: Expr[_]) = x match {
+                            ^
+./tests/patmat/gadt.scala:55: warning: match may not be exhaustive.
+It would fail on the following input: Sum(_, _)
+  def foo5b[T <: Int](x: Expr[T]) = x match {
+                                      ^
+four warnings found

tests/patmat/gadt.scala

@@ -0,0 +1,58 @@
+object Test {
+  sealed trait Expr[T]
+  case class IntLit(i: Int) extends Expr[Int]
+  case class BooleanLit(b: Boolean) extends Expr[Boolean]
+  case class Sum(l: Expr[Int], r: Expr[Int]) extends Expr[Int]
+  case class Or(l: Expr[Boolean], r: Expr[Boolean]) extends Expr[Boolean]
+
+  def foo1a(x: Expr[Int]) = x match {
+    case _: IntLit => true
+    case _: Sum => true
+  }
+
+  def foo1b(x: Expr[Int]) = x match {
+    case _: Sum => true
+  }
+
+  def foo2a(x: Expr[Boolean]) = x match {
+    case _: BooleanLit => true
+    case _: Or => true
+  }
+
+  def foo2b(x: Expr[Boolean]) = x match {
+    case _: BooleanLit => true
+  }
+
+  def foo3a(x: Expr[Boolean]) = x match {
+    case _: BooleanLit => true
+    case _: Or => true
+    // case _: Sum => true
+  }
+
+  def foo3b(x: Expr[Int]) = x match {
+    case _: IntLit => true
+    case _: Sum => true
+    // case _: Or => true
+  }
+
+  def foo4a(x: Expr[_]) = x match {
+    case _: IntLit => true
+    case _: Sum => true
+    case _: BooleanLit => true
+    case _: Or => true
+  }
+
+  def foo4b(x: Expr[_]) = x match {
+    case _: Sum => true
+    case _: Or => true
+  }
+
+  def foo5a[T <: Int](x: Expr[T]) = x match {
+    case _: IntLit => true
+    case _: Sum => true
+  }
+
+  def foo5b[T <: Int](x: Expr[T]) = x match {
+    case _: IntLit => true
+  }
+}

tests/patmat/gadt2.scala.ignore

@@ -0,0 +1,14 @@
+sealed trait Nat[+T]
+case class Zero() extends Nat[Nothing]
+case class Succ[T]() extends Nat[T]
+
+sealed trait Vect[+N <: Nat[_], +T]
+case class VN[T]() extends Vect[Zero, T]
+case class VC[T, N <: Nat[_]](x: T, xs: Vect[N, T]) extends Vect[Succ[N], T]
+
+object Test {
+  def foo[N <: Nat[_], A, B](v1: Vect[N, A], v2: Vect[N, B]) = (v1, v2) match {
+    case (VN(), VN()) => 1
+    case (VC(x, xs), VC(y, ys)) => 2
+  }
+}