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")
+
+  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/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/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/i947.check

@@ -0,0 +1,4 @@
+./tests/patmat/i947.scala:10: warning: unreachable code
+      case ys: List[d18383] => false
+                           ^
+one warning found

tests/patmat/i947.scala

@@ -0,0 +1,16 @@
+object Test {
+
+  class c {
+
+    private var x: Int = 0
+
+    override def equals(other: Any) = other match {
+      case o: c => x == o.x
+      case xs: List[c] => false
+      case ys: List[d18383] => false
+      case _ => false
+    }
+
+
+  }
+}

tests/patmat/partial-function.scala

@@ -0,0 +1,12 @@
+sealed abstract class TA
+sealed abstract class TB extends TA
+case object B extends TB
+case object B2 extends TB
+
+case class CC(i: Int, tb: TB)
+
+object Test {
+  def foo: PartialFunction[CC, Unit] = {
+    case CC(_, B) => ()
+  }
+}

tests/patmat/patmat-adt.check

@@ -0,0 +1,21 @@
+./tests/patmat/patmat-adt.scala:7: warning: match may not be exhaustive.
+It would fail on the following input: Bad(Good(_)), Good(Bad(_))
+  def foo1a(x: Odd) = x match { // warning: Good(_: Bad), Bad(_: Good)
+                        ^
+./tests/patmat/patmat-adt.scala:19: warning: match may not be exhaustive.
+It would fail on the following input: Some(_)
+  def foo2(x: Option[Int]) = x match { // warning: Some(_: Int)
+                               ^
+./tests/patmat/patmat-adt.scala:24: warning: match may not be exhaustive.
+It would fail on the following input: (None, Some(_)), (_, Some(_))
+  def foo3a[T](x: Option[T]) = (x, x) match { // warning: (Some(_), Some(_)), (None, Some(_))
+                                      ^
+./tests/patmat/patmat-adt.scala:29: warning: match may not be exhaustive.
+It would fail on the following input: (None, None), (Some(_), Some(_))
+  def foo3b[T](x: Option[T]) = (x, x) match { // warning: (Some(_), Some(_)), (None, None)
+                                      ^
+./tests/patmat/patmat-adt.scala:50: warning: match may not be exhaustive.
+It would fail on the following input: LetL(BooleanLit), LetL(IntLit)
+  def foo5(tree: Tree) : Any = tree match {
+                                    ^
+5 warnings found

tests/patmat/patmat-adt.scala

@@ -0,0 +1,58 @@
+object PatmatADT {
+  abstract sealed class Odd(x: Odd)
+
+  case class Good(x: Odd) extends Odd(x)
+  case class Bad(x: Odd) extends Odd(x)
+
+  def foo1a(x: Odd) = x match { // warning: Good(_: Bad), Bad(_: Good)
+    case Good(_: Good) => false
+    case Bad(_: Bad) => false
+  }
+
+  def foo1b(x: Odd) = x match {
+    case Good(_: Good) => false
+    case Bad(_: Bad) => false
+    case Good(_: Bad) => false
+    case Bad(_: Good) => false
+  }
+
+  def foo2(x: Option[Int]) = x match { // warning: Some(_: Int)
+    case Some(_: Double) => true
+    case None => true
+  }
+
+  def foo3a[T](x: Option[T]) = (x, x) match { // warning: (Some(_), Some(_)), (None, Some(_))
+    case (Some(_), None) => true
+    case (None, None) => true
+  }
+
+  def foo3b[T](x: Option[T]) = (x, x) match { // warning: (Some(_), Some(_)), (None, None)
+    case (Some(_), None) => true
+    case (None, Some(_)) => true
+  }
+
+  sealed trait Base
+  case class Foo() extends Base
+
+  def foo4(x: Base) = x match {
+    case Foo() =>
+  }
+
+  sealed abstract class CL3Literal
+  case object IntLit extends CL3Literal
+  case object CharLit extends CL3Literal
+  case object BooleanLit extends CL3Literal
+
+
+  sealed abstract class Tree
+  case class LetL(value: CL3Literal) extends Tree
+
+  def foo5(tree: Tree) : Any = tree match {
+    case LetL(CharLit) =>
+  }
+
+  def foo6[T](l: List[T]): Boolean = l match {
+    case x::xs => true
+    case Nil => false
+  }
+}

tests/patmat/patmat-extractor.scala

@@ -0,0 +1,17 @@
+sealed trait Node
+case class NodeA(i: Int) extends Node
+case class NodeB(b: Boolean) extends Node
+case class NodeC(s: String) extends Node
+
+object Node {
+  def unapply(node: Node): Option[(Node, Node)] = ???
+}
+
+// currently scalac can't do anything with following
+// it's possible to do better in our case
+object Test {
+  def foo(x: Node): Boolean = x match { // unexhaustive
+    case Node(NodeA(_), NodeB(_)) => true
+    case Node(NodeA(4), NodeB(false)) => true // unreachable code
+  }
+}