Create test infrastructure for plugins

Author: liufengyun

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

@@ -311,6 +311,34 @@ class CompilationTests extends ParallelTesting {
     compileShallowFilesInDir("../tests/neg", defaultOptimised, outputDir).checkExpectedErrors()
   }
 
+  @Test def testPlugins: Unit = {
+    val xmlFile = "scalac-plugin.xml"
+
+    // 1. hack with absolute path for -Xplugin
+    // 2. copy `xmlFile` to destination
+    def compileFilesInDir(dir: String): CompilationTest = {
+      val outDir = defaultOutputDir + "testPlugins/"
+      val sourceDir = new JFile(dir)
+
+      val dirs = sourceDir.listFiles.foldLeft(List.empty[JFile]) { case (dirs, f) =>
+        if (f.isDirectory) f :: dirs else dirs
+      }
+
+      val targets = dirs.map { dir =>
+        val compileDir = createOutputDirsForDir(dir, sourceDir, outDir)
+        import java.nio.file.StandardCopyOption.REPLACE_EXISTING
+        Files.copy(dir.toPath.resolve(xmlFile), compileDir.toPath.resolve(xmlFile), REPLACE_EXISTING)
+        val flags = TestFlags(classPath, noCheckOptions) and ("-Xplugin:" + compileDir.getAbsolutePath)
+        SeparateCompilationSource("testPlugins", dir, flags, compileDir)
+      }
+
+      new CompilationTest(targets)
+    }
+
+    compileFilesInDir("../tests/plugins/neg").checkExpectedErrors()
+    compileFilesInDir("../tests/plugins/pos").checkCompile(checkCompileOutput = true)
+  }
+
   private val (compilerSources, backendSources, backendJvmSources) = {
     val compilerDir = Paths.get("../compiler/src")
     val compilerSources0 = sources(Files.walk(compilerDir))

compiler/test/dotty/tools/dotc/reporting/TestReporter.scala

@@ -2,12 +2,11 @@ package dotty.tools
 package dotc
 package reporting
 
-import java.io.{ PrintStream, PrintWriter, File => JFile, FileOutputStream }
+import java.io.{ FileOutputStream, PrintStream, PrintWriter, StringWriter, File => JFile }
 import java.text.SimpleDateFormat
 import java.util.Date
 
 import scala.collection.mutable
-
 import util.SourcePosition
 import core.Contexts._
 import Reporter._
@@ -79,6 +78,23 @@ extends Reporter with UniqueMessagePositions with HideNonSensicalMessages with M
   }
 }
 
+class StoredTestReporter (val writer: StringWriter, val superWriter: PrintWriter, filePrintln: String => Unit, logLevel: Int)
+extends TestReporter(superWriter, filePrintln, logLevel) {
+  override def doReport(m: MessageContainer)(implicit ctx: Context): Unit = {
+    super.doReport(m)
+
+    val msg =
+      if (m.pos.exists)
+        "[" + diagnosticLevel(m) + "] Line " + (m.pos.line + 1) + ": " + m.contained().msg
+      else
+        "[" + diagnosticLevel(m) + "] " + m.contained().msg
+
+    writer.write(msg + "\n")
+  }
+
+  override def summary: String = ""
+}
+
 object TestReporter {
   private[this] var outFile: JFile = _
   private[this] var logWriter: PrintWriter = _
@@ -115,6 +131,9 @@ object TestReporter {
   def reporter(ps: PrintStream, logLevel: Int): TestReporter =
     new TestReporter(new PrintWriter(ps, true), logPrintln, logLevel)
 
+  def storedReporter(ps: PrintStream, logLevel: Int): TestReporter =
+    new StoredTestReporter(new StringWriter(), new PrintWriter(ps, true), logPrintln, logLevel)
+
   def simplifiedReporter(writer: PrintWriter): TestReporter = {
     val rep = new TestReporter(writer, logPrintln, WARNING) {
       /** Prints the message with the given position indication in a simplified manner */

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

@@ -6,22 +6,21 @@ import java.io.{ File => JFile }
 import java.text.SimpleDateFormat
 import java.util.HashMap
 import java.nio.file.StandardCopyOption.REPLACE_EXISTING
-import java.nio.file.{ Files, Path, Paths, NoSuchFileException }
-import java.util.concurrent.{ Executors => JExecutors, TimeUnit, TimeoutException }
+import java.nio.file.{ Files, NoSuchFileException, Path, Paths }
+import java.util.concurrent.{ TimeUnit, TimeoutException, Executors => JExecutors }
 
 import scala.io.Source
 import scala.util.control.NonFatal
 import scala.util.Try
 import scala.collection.mutable
 import scala.util.matching.Regex
 import scala.util.Random
-
 import dotc.core.Contexts._
-import dotc.reporting.{ Reporter, TestReporter }
+import dotc.reporting.{ Reporter, StoredTestReporter, TestReporter }
 import dotc.reporting.diagnostic.MessageContainer
 import dotc.interfaces.Diagnostic.ERROR
 import dotc.util.DiffUtil
-import dotc.{ Driver, Compiler }
+import dotc.{ Compiler, Driver }
 
 /** A parallel testing suite whose goal is to integrate nicely with JUnit
  *
@@ -47,7 +46,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
   /** A test source whose files or directory of files is to be compiled
    *  in a specific way defined by the `Test`
    */
-  private sealed trait TestSource { self =>
+  sealed trait TestSource { self =>
     def name: String
     def outDir: JFile
     def flags: TestFlags
@@ -128,7 +127,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
   /** A group of files that may all be compiled together, with the same flags
    *  and output directory
    */
-  private final case class JointCompilationSource(
+  final case class JointCompilationSource(
     name: String,
     files: Array[JFile],
     flags: TestFlags,
@@ -142,7 +141,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
   /** A test source whose files will be compiled separately according to their
    *  suffix `_X`
    */
-  private final case class SeparateCompilationSource(
+  final case class SeparateCompilationSource(
     name: String,
     dir: JFile,
     flags: TestFlags,
@@ -175,7 +174,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
   /** Each `Test` takes the `testSources` and performs the compilation and assertions
    *  according to the implementing class "neg", "run" or "pos".
    */
-  private abstract class Test(testSources: List[TestSource], times: Int, threadLimit: Option[Int], suppressAllOutput: Boolean)(implicit val summaryReport: SummaryReporting) { test =>
+  private abstract class Test(testSources: List[TestSource], times: Int, threadLimit: Option[Int], suppressAllOutput: Boolean, checkCompileOutput: Boolean = false)(implicit val summaryReport: SummaryReporting) { test =>
 
     import summaryReport._
 
@@ -360,9 +359,12 @@ trait ParallelTesting extends RunnerOrchestration { self =>
         else None
       } else None
 
+      val logLevel = if (suppressErrors || suppressAllOutput) ERROR + 1 else ERROR
       val reporter =
-        TestReporter.reporter(realStdout, logLevel =
-          if (suppressErrors || suppressAllOutput) ERROR + 1 else ERROR)
+        if (checkCompileOutput)
+          TestReporter.storedReporter(realStdout, logLevel = logLevel)
+        else
+          TestReporter.reporter(realStdout, logLevel = logLevel)
 
       val driver =
         if (times == 1) new Driver
@@ -440,10 +442,28 @@ trait ParallelTesting extends RunnerOrchestration { self =>
 
       this
     }
+
+    protected def verifyCompileOutput(source: TestSource, checkFile: JFile, reporter: StoredTestReporter): Unit = {
+      reporter.writer.flush()
+      val checkLines = Source.fromFile(checkFile).getLines().mkString("\n")
+      val outputLines = reporter.writer.toString.trim.replaceAll("\\s+\n", "\n")
+
+      if (outputLines != checkLines) {
+        val msg = s"Output from '${source.title}' did not match check file '${checkFile.getName}'."
+        println("===============================")
+        println("expected: \n" + checkLines)
+        println("actual: \n" + outputLines)
+        println("===============================")
+
+        echo(msg)
+        addFailureInstruction(msg)
+        failTestSource(source)
+      }
+    }
   }
 
-  private final class PosTest(testSources: List[TestSource], times: Int, threadLimit: Option[Int], suppressAllOutput: Boolean)(implicit summaryReport: SummaryReporting)
-  extends Test(testSources, times, threadLimit, suppressAllOutput) {
+  private final class PosTest(testSources: List[TestSource], times: Int, threadLimit: Option[Int], suppressAllOutput: Boolean, checkCompileOutput: Boolean = false)(implicit summaryReport: SummaryReporting)
+  extends Test(testSources, times, threadLimit, suppressAllOutput, checkCompileOutput) {
     protected def encapsulatedCompilation(testSource: TestSource) = new LoggedRunnable {
       def checkTestSource(): Unit = tryCompile(testSource) {
         testSource match {
@@ -475,6 +495,14 @@ trait ParallelTesting extends RunnerOrchestration { self =>
               reporters.foreach(logReporterContents)
               logBuildInstructions(reporters.head, testSource, errorCount, warningCount)
             }
+
+            // verify compilation check file
+            (1 to testSource.compilationGroups.length).foreach { index =>
+              val checkFile = new JFile(dir.getAbsolutePath.reverse.dropWhile(_ == '/').reverse + "/" + index + ".check")
+
+              if (checkFile.exists && checkCompileOutput)
+                verifyCompileOutput(testSource, checkFile, reporters(index).asInstanceOf[StoredTestReporter])
+            }
           }
         }
       }
@@ -599,8 +627,8 @@ trait ParallelTesting extends RunnerOrchestration { self =>
     }
   }
 
-  private final class NegTest(testSources: List[TestSource], times: Int, threadLimit: Option[Int], suppressAllOutput: Boolean)(implicit summaryReport: SummaryReporting)
-  extends Test(testSources, times, threadLimit, suppressAllOutput) {
+  private final class NegTest(testSources: List[TestSource], times: Int, threadLimit: Option[Int], suppressAllOutput: Boolean, checkCompileOutput: Boolean = false)(implicit summaryReport: SummaryReporting)
+  extends Test(testSources, times, threadLimit, suppressAllOutput, checkCompileOutput) {
     protected def encapsulatedCompilation(testSource: TestSource) = new LoggedRunnable {
       def checkTestSource(): Unit = tryCompile(testSource) {
         // In neg-tests we allow two types of error annotations,
@@ -678,6 +706,14 @@ trait ParallelTesting extends RunnerOrchestration { self =>
             if (actualErrors > 0)
               reporters.foreach(logReporterContents)
 
+             // Compilation check file: for testing plugins
+            (1 to testSource.compilationGroups.length).foreach { index =>
+              val checkFile = new JFile(dir.getAbsolutePath.reverse.dropWhile(_ == '/').reverse + "/" + index + ".check")
+
+              if (checkFile.exists && checkCompileOutput)
+                verifyCompileOutput(testSource, checkFile, reporters(index).asInstanceOf[StoredTestReporter])
+            }
+
             (compilerCrashed, expectedErrors, actualErrors, () => getMissingExpectedErrors(errorMap, errors), errorMap)
           }
         }
@@ -825,10 +861,10 @@ trait ParallelTesting extends RunnerOrchestration { self =>
   ) {
     import org.junit.Assert.fail
 
-    private[ParallelTesting] def this(target: TestSource) =
+    def this(target: TestSource) =
       this(List(target), 1, true, None, false, false)
 
-    private[ParallelTesting] def this(targets: List[TestSource]) =
+    def this(targets: List[TestSource]) =
       this(targets, 1, true, None, false, false)
 
     /** Compose test targets from `this` with `other`
@@ -857,8 +893,10 @@ trait ParallelTesting extends RunnerOrchestration { self =>
      *  compilation without generating errors and that they do not crash the
      *  compiler
      */
-    def checkCompile()(implicit summaryReport: SummaryReporting): this.type = {
-      val test = new PosTest(targets, times, threadLimit, shouldFail || shouldSuppressOutput).executeTestSuite()
+    def checkCompile(checkCompileOutput: Boolean = false)(implicit summaryReport: SummaryReporting): this.type = {
+      val test = new PosTest(targets, times, threadLimit, shouldFail || shouldSuppressOutput, checkCompileOutput).executeTestSuite()
+
+      cleanup()
 
       if (!shouldFail && test.didFail) {
         fail(s"Expected no errors when compiling, failed for the following reason(s):\n${ reasonsForFailure(test) }")
@@ -867,15 +905,17 @@ trait ParallelTesting extends RunnerOrchestration { self =>
         fail("Pos test should have failed, but didn't")
       }
 
-      cleanup()
+      this
     }
 
     /** Creates a "neg" test run, which makes sure that each test generates the
      *  correct amount of errors at the correct positions. It also makes sure
      *  that none of these tests crash the compiler
      */
-    def checkExpectedErrors()(implicit summaryReport: SummaryReporting): this.type = {
-      val test = new NegTest(targets, times, threadLimit, shouldFail || shouldSuppressOutput).executeTestSuite()
+    def checkExpectedErrors(checkCompileOutput : Boolean = false)(implicit summaryReport: SummaryReporting): this.type = {
+      val test = new NegTest(targets, times, threadLimit, shouldFail || shouldSuppressOutput, checkCompileOutput).executeTestSuite()
+
+      cleanup()
 
       if (!shouldFail && test.didFail) {
         fail(s"Neg test shouldn't have failed, but did. Reasons:\n${ reasonsForFailure(test) }")
@@ -884,7 +924,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
         fail("Neg test should have failed, but did not")
       }
 
-      cleanup()
+      this
     }
 
     /** Creates a "run" test run, which is a superset of "pos". In addition to
@@ -895,14 +935,16 @@ trait ParallelTesting extends RunnerOrchestration { self =>
     def checkRuns()(implicit summaryReport: SummaryReporting): this.type = {
       val test = new RunTest(targets, times, threadLimit, shouldFail || shouldSuppressOutput).executeTestSuite()
 
+      cleanup()
+
       if (!shouldFail && test.didFail) {
         fail(s"Run test failed, but should not, reasons:\n${ reasonsForFailure(test) }")
       }
       else if (shouldFail && !test.didFail) {
         fail("Run test should have failed, but did not")
       }
 
-      cleanup()
+      this
     }
 
     /** Deletes output directories and files */
@@ -1005,7 +1047,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
   }
 
   /** Create out directory for directory `d` */
-  private def createOutputDirsForDir(d: JFile, sourceDir: JFile, outDir: String): JFile = {
+  def createOutputDirsForDir(d: JFile, sourceDir: JFile, outDir: String): JFile = {
     val targetDir = new JFile(outDir + s"${sourceDir.getName}/${d.getName}")
     targetDir.mkdirs()
     targetDir

tests/plugins/neg/divideZero/Test_2.scala

@@ -0,0 +1,6 @@
+class Test {
+  val y = 5 / 0   // error
+  100 + 6 / 0     // error
+  6L / 0L         // error
+  val z = 7 / 0.0 // error
+}

tests/plugins/neg/divideZero/plugin_1.scala

@@ -0,0 +1,37 @@
+import dotty.tools.dotc._
+import core._
+import Contexts.Context
+import plugins.Plugin
+import Phases.Phase
+import ast.tpd
+import transform.MegaPhase.MiniPhase
+import Decorators._
+import Symbols.Symbol
+import Constants.Constant
+
+class DivideZero extends MiniPhase with Plugin {
+  val name: String = "divideZero"
+  override val description: String = "divide zero check"
+
+  val phaseName = name
+
+  override def init(phases: List[List[Phase]])(implicit ctx: Context): List[List[Phase]] = {
+    val (before, after) = phases.span(ps => !ps.exists(_.phaseName == "pickler"))
+    before ++ (List(this) :: after)
+  }
+
+  private def isNumericDivide(sym: Symbol)(implicit ctx: Context): Boolean = {
+    def test(tpe: String): Boolean =
+      (sym.owner eq ctx.requiredClass(tpe.toTermName)) && sym.name.show == "/"
+
+    test("scala.Int") || test("scala.Long") || test("scala.Short") || test("scala.FLoat") || test("scala.Double")
+  }
+
+  override def transformApply(tree: tpd.Apply)(implicit ctx: Context): tpd.Tree = tree match {
+    case tpd.Apply(fun, tpd.Literal(Constants.Constant(v)) :: Nil) if isNumericDivide(fun.symbol) && v == 0 =>
+      ctx.error("divide by zero", tree.pos)
+      tree
+    case _ =>
+      tree
+  }
+}

tests/plugins/neg/divideZero/scalac-plugin.xml

@@ -0,0 +1,4 @@
+<plugin>
+  <name>divideZero</name>
+  <classname>DivideZero</classname>
+</plugin>

tests/plugins/pos/divideZero/2.check

@@ -0,0 +1,3 @@
+[Warning] Line 2: divide by zero
+[Warning] Line 3: divide by zero
+[Warning] Line 4: divide by zero

tests/plugins/pos/divideZero/Test_2.scala

@@ -0,0 +1,5 @@
+class Test {
+  100 + 6 / 0
+  6L / 0L
+  println(3 + 7 / 0.0)
+}