Add test for #620

The issue in #6642 shows that errors may be latent in seemingly
simple fixes if not tested, which can backlash us at critical moment.

Author: liufengyun

compiler/test/dotty/tools/dotc/printing/PrintingTest.scala

@@ -0,0 +1,84 @@
+package dotty
+package tools
+package dotc
+
+import vulpix.TestConfiguration
+import vulpix.TestConfiguration
+import reporting.TestReporter
+
+import java.io._
+import java.nio.file.{Path => JPath}
+import java.lang.System.{lineSeparator => EOL}
+
+import interfaces.Diagnostic.INFO
+import dotty.tools.io.Directory
+
+import scala.io.Source
+import org.junit.Test
+
+class PrintingTest {
+  val testsDir = "tests/printing"
+  val options = List("-Xprint:frontend", "-color:never", "-classpath", TestConfiguration.basicClasspath)
+
+  private def fileContent(filePath: String): List[String] =
+    if (new File(filePath).exists)
+      Source.fromFile(filePath, "UTF-8").getLines().toList
+    else Nil
+
+
+  private def compileFile(path: JPath): Boolean = {
+    val baseFilePath  = path.toAbsolutePath.toString.stripSuffix(".scala")
+    val outFilePath   = baseFilePath + ".out"
+    val checkFilePath = baseFilePath + ".check"
+    val ps = new PrintStream(new File(outFilePath))
+    val reporter = TestReporter.reporter(ps, INFO)
+
+    try {
+      Main.process((path.toString::options).toArray, reporter, null)
+    } catch {
+      case e: Throwable =>
+        println(s"Compile $path exception:")
+        e.printStackTrace()
+    }
+    finally ps.close()
+
+    val actual   = fileContent(outFilePath)
+    val expected = fileContent(checkFilePath)
+
+    val success =
+      actual.length == expected.length &&
+      (actual, expected).zipped.forall(_ == _)
+
+    success || {
+      println(
+        s"""|Output from '$outFilePath' did not match check file. Actual output:
+            |${actual.mkString(EOL)}
+            |""".stripMargin + "\n")
+
+      println(
+          s"""Test output dumped in: ${outFilePath}
+             |  See diff of the checkfile
+             |    > diff $checkFilePath $outFilePath
+             |  Replace checkfile with current output output
+             |    > mv $outFilePath $checkFilePath
+         """.stripMargin)
+
+      false
+    }
+  }
+
+  @Test
+  def printing: Unit = {
+    val res = Directory(testsDir).list.toList
+      .filter(f => f.extension == "scala")
+      .map { f => compileFile(f.jpath) }
+
+    val failed = res.filter(!_)
+
+    val msg = s"Pass: ${res.length - failed.length}, Failed: ${failed.length}"
+
+    assert(failed.length == 0, msg)
+
+    println(msg)
+  }
+}

tests/printing/i620.check

@@ -0,0 +1,29 @@
+package O {
+  package O.A {
+    class D() extends Object() {
+      class C() extends Object() {
+        protected[D] def a: Int = 0
+        private[D] def b: Int = 0
+        private def c: Int = 0
+        protected def d: Int = 0
+        private[A] def e: Int = 0
+        protected[A] def f: Int = 0
+        def g: Int = 0
+      }
+      private[D] class E() extends Object() {}
+      private class F() extends Object() {}
+      private[A] class G() extends Object() {}
+      protected[D] class H() extends Object() {}
+      protected class I() extends Object() {}
+      protected[A] class J() extends Object() {}
+      class K() extends Object() {}
+      protected[D] val a: Int = 0
+      private[D] val b: Int = 0
+      private val c: Int = 0
+      protected val d: Int = 0
+      private[A] val e: Int = 0
+      protected[A] val f: Int = 0
+      val g: Int = 0
+    }
+  }
+}

tests/printing/i620.scala

@@ -0,0 +1,32 @@
+// test printing of private[D] and protected[D]
+
+package O
+package A
+
+class D {
+  class C {
+    protected[D] def a: Int = 0
+    private[D]   def b: Int = 0
+    private      def c: Int = 0
+    protected    def d: Int = 0
+    private[A]   def e: Int = 0
+    protected[A] def f: Int = 0
+                 def g: Int = 0
+  }
+
+  private[D]      class E
+  private         class F
+  private[A]      class G
+  protected[D]    class H
+  protected       class I
+  protected[A]    class J
+                  class K
+
+  protected[D] val a: Int = 0
+  private[D]   val b: Int = 0
+  private      val c: Int = 0
+  protected    val d: Int = 0
+  private[A]   val e: Int = 0
+  protected[A] val f: Int = 0
+               val g: Int = 0
+}