Fix #4389: Add test infrastructure for fuzzy tests

Add a new kind of compiler test that only checks for compiler crashes.

Add regression tests 146 tests in `tests/fuzzy` from the list in #4389 that compile now.
Only 3 tests from #4389 are still in `tests/pending/fuzzy`.
Also added the latest test from the (dotty-fuzzing-results)[https://github.com/alexknvl/dotty-fuzzing-results], most of them are in `pending`.

Author: nicolasstucki

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -167,6 +167,11 @@ class CompilationTests extends ParallelTesting {
     compileFile("tests/neg-custom-args/repeatedArgs213.scala", defaultOptions.and("-Ynew-collections"))
   }.checkExpectedErrors()
 
+  @Test def fuzzyAll: Unit = {
+    implicit val testGroup: TestGroup = TestGroup("compileFuzzy")
+    compileFilesInDir("tests/fuzzy", defaultOptions)
+  }.checkNoCrash()
+
   // Run tests -----------------------------------------------------------------
 
   @Test def runAll: Unit = {

compiler/test/dotty/tools/vulpix/ParallelTesting.scala

@@ -813,6 +813,32 @@ trait ParallelTesting extends RunnerOrchestration { self =>
     }
   }
 
+  private final class NoCrashTest(testSources: List[TestSource], times: Int, threadLimit: Option[Int], suppressAllOutput: Boolean)(implicit summaryReport: SummaryReporting)
+    extends Test(testSources, times, threadLimit, suppressAllOutput) {
+    protected def encapsulatedCompilation(testSource: TestSource) = new LoggedRunnable {
+      def checkTestSource(): Unit = tryCompile(testSource) {
+        def fail(msg: String): Nothing = {
+          echo(msg)
+          failTestSource(testSource)
+          ???
+        }
+        testSource match {
+          case testSource@JointCompilationSource(_, files, flags, outDir, fromTasty, decompilation) =>
+            val sourceFiles = testSource.sourceFiles
+            val reporter =
+              try compile(sourceFiles, flags, true, outDir)
+              catch {
+                case ex: Throwable => fail(s"Fatal compiler crash when compiling: ${testSource.title}")
+              }
+            if (reporter.compilerCrashed)
+              fail(s"Compiler crashed when compiling: ${testSource.title}")
+          case testSource@SeparateCompilationSource(_, dir, flags, outDir) => unsupported("NoCrashTest - SeparateCompilationSource")
+        }
+        registerCompletion()
+      }
+    }
+  }
+
   /** The `CompilationTest` is the main interface to `ParallelTesting`, it
    *  can be instantiated via one of the following methods:
    *
@@ -994,6 +1020,19 @@ trait ParallelTesting extends RunnerOrchestration { self =>
       this
     }
 
+    /** Creates a "fuzzy" test run, which makes sure that each test compiles (or not) without crashing */
+    def checkNoCrash()(implicit summaryReport: SummaryReporting): this.type = {
+      val test = new NoCrashTest(targets, times, threadLimit, shouldSuppressOutput).executeTestSuite()
+
+      cleanup()
+
+      if (test.didFail) {
+        fail("Neg test should have failed, but did not")
+      }
+
+      this
+    }
+
     /** Creates a "run" test run, which is a superset of "pos". In addition to
      *  making sure that all tests pass compilation and that they do not crash
      *  the compiler; it also makes sure that all tests can run with the

tests/fuzzy/015ea9cf2d07b27200a33c4451bfc4c93afe213e.scala

@@ -0,0 +1,29 @@
+class i0 {
+type Int;
+val i1 = 2
+private val i2 = (List(): List[Int])
+import i1.{ () => Double(_)).asInstanceOf[i2]) } else new i0(1)
+List(List(1), None)
+println(i1(17))
+new _
+collect i1 :: 2
+}
+object package {
+val i5 = scala { object false => } { class i2; 0 }
+}
+def i9(i8: String) = {}
+def Throwable
+trait i11
+abstract class i1 {
+override implicit def i2(i3: i0.i1) =  match {
+case i4(i5) => 1
+case _ => Console.println() }
+}
+}
+}
+trait i7[i10 <: i0, i8 <: i0, i12, i13, i16, i12] {
+@Seq[i1] => (i2, main)
+type i14[i1, i16 <: i4, <: i62, i18, i9, i18, i19, i20, i13, i19, i19, i14,, i20, 'i18, i14, i10),
+i77, 9, i14, i15, i16, i17, i19, i20, [Boolean, i20]): i2[i2] = sys.error()
+val i17 = i5[Int](1, )
+}

tests/fuzzy/028127de3ac8c2ee6ccde25072d765581dbd06f9.scala

@@ -0,0 +1,27 @@
+package i0
+package i1
+import scala.language.i1
+class i2[i3] {
+def i4(i5: i3): i4[i5] = null
+}
+class i8 {
+trait i1[i2]
+implicit def i6[i7[_]](i8: i0[i3]): i6[i5] = new i7[i9] {
+override def i8[i2](i9: i7): i7[i2] = new i5[i3]
+def map = i10
+}
+class i12 extends i1[String] {
+def i10(i4: String) = i11(i13, i9)
+}
+trait i11[i4] {
+def i19[i17[_]](i4: i15): i11[Boolean] = i12
+def i13[i14[_]](i12: i7[i10], i10: i9[i6]): Unit = ({
+val i12 = 1
+i1[i10[String]](_
+abstract class i1(i2: Int, i3: Int)
+class i6() {
+def i2(i5: Any) = i3 match {
+case (i3: Int, i4: Int) => i3 + i2 i3 1
+case _ => case i4 =>
+}
+}

tests/fuzzy/048e0594728ea7cdff7497c4e90bf702f220b206.scala

@@ -0,0 +1,19 @@
+class i0[@specialized i1] {
+def i2[i3[_]](i4: i1 => i3[Nothing]): i2[Int] = ???
+implicit def i5[i2](i6: i0[i1, i2]) = ???
+implicit def i5(implicit i3: i1[Int]): String => String = {
+val i6: i2 = new i0[Int] { def i7(i5: Int) = 0 }
+val i1 = i2 == i2 match { case i1[i2](i3, i6) =>
+def this(i6: Array[String]) = i3 _
+}
+}
+trait i7 { type i5 }
+trait i6 extends i5 { type i6 = i4 }
+val i7: i3 & i1 = new i1 { type i2 = String }
+val i8: String = i6
+val i9: i1
+final val i11: i3 = ???
+implicit def i10(i11: i0[Int, Int]): Unit = {
+List(1).asInstanceOf[toString])
+println(new i0[Int]())
+}

tests/fuzzy/06abe47b5828fec1c1975aae63202b4f93cf0bac.scala

@@ -0,0 +1,6 @@
+object i0 {
+def i1(i2: Int): Unit = {
+def i3(): Unit = {
+def this() = this(0);
+}
+}

tests/fuzzy/14b960e57195554a6a085eae8e039a949e8b106d.scala

@@ -0,0 +1,7 @@
+class i0 {
+val i1: (Any => String) = ???
+}
+object i0 {
+import Ordering.{ implicitly => } (true: Boolean) match { case _: i1 => true }
+def i1(erased i2: Int): Int = { i1: Set[Int] => }
+}

tests/fuzzy/1d1f57703bbd37dd850480cb5d99130930be08c9.scala

@@ -0,0 +1,17 @@
+object App {
+import i0.{ i1 => false }
+def Array(i0: Int => Boolean): Any = ???
+}
+object i2 {
+for (i1 <- i2) i2 match {
+case Some(i3) => ??? case i1(_)) => i2
+}
+val i7: i3 {type i1 = i1; val
+) println(i10 + 1) < 96: (List, [Int]) def i13[i12] => Array[try <: i0](i12: Int, i12: => Option[i1]
+): Int = (i14: Int) =>
+i2(i4)
+def i17[i12](i16: => String): List[i10] = i2
+def i14[@specialized i4: Option[Any], i8 > k943[assert, Object](i23 Array[Int]) = (i13)i12).isInstanceOf[i3])
+implicit def apply[i14[_], i14,i19](i11: i0[i1[new, Int]): Option[i5] = i11 += i11
+val i16 = i12
+}

tests/fuzzy/1e3ef21bb17fbe13bf3beaf13a18ca382b52a469.scala

@@ -0,0 +1,18 @@
+object i0 {
+type i1 = Int val i2: Int = { i2: Int => }
+def i3(i4: Int => String) = i4 match { case i3 => () })
+trait i5
+trait i6
+trait i7
+implicit def i5: Unit | ((_: String): Int) = ()
+val i6 = i2()
+val i5: i4.i2 = i4.i1[Nothing]
+println()
+println()
+trait i3 extends i2 {
+type i2 = i3
+class i4
+}
+trait i3 extends i0 {
+def i1 = classOf
+class i1(i0: Int) extends i2(i2)

tests/fuzzy/28752b8fb9b6db06fff4c606c3a402dc12b0ee06.scala

@@ -0,0 +1,12 @@
+class i0[i1] {
+def i2[i3[_], i4](i5: i1[i2], i6: i0[i4]): i4[i2] = i4
+}
+object i7 {
+val i8: i0[Int] = classOf[Nothing, _ with i5]()
+}
+object i9 {
+def i10[i10](i11: i12[i2]): i1[i2] = new i1[i2] {}
+def i15[i15](i11: i7[i13.i1]): i1[i2] = i15 match {
+case i15 :: i7 => i10 _ val i17: Symbol = ???
+}
+}