test printing of annotations

Author: bishabosha

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

@@ -19,17 +19,18 @@ import scala.io.Source
 import org.junit.Test
 
 class PrintingTest {
-  val testsDir = "tests/printing"
-  val options = List("-Xprint:typer", "-color:never", "-classpath", TestConfiguration.basicClasspath)
 
-  private def compileFile(path: JPath): Boolean = {
+  def options(phase: String) =
+    List(s"-Xprint:$phase", "-color:never", "-classpath", TestConfiguration.basicClasspath)
+
+  private def compileFile(path: JPath, phase: String): Boolean = {
     val baseFilePath  = path.toString.stripSuffix(".scala")
     val checkFilePath = baseFilePath + ".check"
     val byteStream    = new ByteArrayOutputStream()
     val reporter = TestReporter.reporter(new PrintStream(byteStream), INFO)
 
     try {
-      Main.process((path.toString::options).toArray, reporter, null)
+      Main.process((path.toString::options(phase)).toArray, reporter, null)
     } catch {
       case e: Throwable =>
         println(s"Compile $path exception:")
@@ -40,11 +41,10 @@ class PrintingTest {
     FileDiff.checkAndDump(path.toString, actualLines.toIndexedSeq, checkFilePath)
   }
 
-  @Test
-  def printing: Unit = {
+  def testIn(testsDir: String, phase: String) =
     val res = Directory(testsDir).list.toList
       .filter(f => f.extension == "scala")
-      .map { f => compileFile(f.jpath) }
+      .map { f => compileFile(f.jpath, phase) }
 
     val failed = res.filter(!_)
 
@@ -53,5 +53,12 @@ class PrintingTest {
     assert(failed.length == 0, msg)
 
     println(msg)
-  }
+
+  end testIn
+
+  @Test
+  def printing: Unit = testIn("tests/printing", "typer")
+
+  @Test
+  def untypedPrinting: Unit = testIn("tests/printing/untyped", "parser")
 }

tests/printing/annot-printing.check

@@ -0,0 +1,22 @@
+[[syntax trees at end of                     typer]] // tests/printing/annot-printing.scala
+package <empty> {
+  import scala.annotation.*
+  class Foo() extends annotation.Annotation() {}
+  class Bar(s: String) extends annotation.Annotation() {
+    private[this] val s: String
+  }
+  class Xyz(i: Int) extends annotation.Annotation() {
+    private[this] val i: Int
+  }
+  final lazy module val Xyz: Xyz = new Xyz()
+  final module class Xyz() extends AnyRef() { this: Xyz.type =>
+    def $lessinit$greater$default$1: Int @uncheckedVariance = 23
+  }
+  final lazy module val annot-printing$package: annot-printing$package = 
+    new annot-printing$package()
+  final module class annot-printing$package() extends Object() { 
+    this: annot-printing$package.type =>
+    def x: Int @nowarn() @main @Xyz() @Foo @Bar("hello") = ???
+  }
+}
+

tests/printing/annot-printing.scala

@@ -0,0 +1,7 @@
+import scala.annotation.*
+
+class Foo() extends Annotation
+class Bar(s: String) extends Annotation
+class Xyz(i: Int = 23) extends Annotation
+
+def x: Int @nowarn @main @Xyz() @Foo @Bar("hello") = ???

tests/printing/dependent-annot.check

@@ -0,0 +1,25 @@
+[[syntax trees at end of                     typer]] // tests/printing/dependent-annot.scala
+package <empty> {
+  class C() extends Object() {}
+  class ann(x: Seq[Any] @Repeated) extends annotation.Annotation() {
+    private[this] val x: Seq[Any] @Repeated
+  }
+  final lazy module val dependent-annot$package: dependent-annot$package = 
+    new dependent-annot$package()
+  final module class dependent-annot$package() extends Object() { 
+    this: dependent-annot$package.type =>
+    def f(y: C, z: C): Unit = 
+      {
+        def g(): C @ann([y,z : Any]*) = ???
+        val ac: 
+          (C => Array[String]) 
+            {
+              def apply(x: C): Array[String @ann([x : Any]*)]
+            }
+         = ???
+        val dc: Array[String] = ac.apply(g())
+        ()
+      }
+  }
+}
+

tests/printing/dependent-annot.scala

@@ -0,0 +1,7 @@
+class C
+class ann(x: Any*) extends annotation.Annotation
+
+def f(y: C, z: C) =
+  def g(): C @ann(y, z) = ???
+  val ac: ((x: C) => Array[String @ann(x)]) = ???
+  val dc = ac(g())

tests/printing/untyped/annot-printing.check

@@ -0,0 +1,9 @@
+[[syntax trees at end of                    parser]] // tests/printing/untyped/annot-printing.scala
+package <empty> {
+  import scala.annotation.*
+  class Foo() extends Annotation {}
+  class Bar(private[this] val s: String) extends Annotation {}
+  class Xyz(private[this] val i: Int = 23) extends Annotation {}
+  def x: Int @nowarn @main @Xyz @Foo @Bar("hello") = ???
+}
+

tests/printing/untyped/annot-printing.scala

@@ -0,0 +1,7 @@
+import scala.annotation.*
+
+class Foo() extends Annotation
+class Bar(s: String) extends Annotation
+class Xyz(i: Int = 23) extends Annotation
+
+def x: Int @nowarn @main @Xyz() @Foo @Bar("hello") = ???

tests/printing/untyped/dependent-annot.check

@@ -0,0 +1,13 @@
+[[syntax trees at end of                    parser]] // tests/printing/untyped/dependent-annot.scala
+package <empty> {
+  class C {}
+  class ann(private[this] val x: Any *) extends annotation.Annotation {}
+  def f(y: C, z: C) = 
+    {
+      def g(): C @ann(y, z) = ???
+      val ac: ((x: C) => Array[String @ann(x)]) = ???
+      val dc = ac(g())
+      <empty>
+    }
+}
+

tests/printing/untyped/dependent-annot.scala

@@ -0,0 +1,7 @@
+class C
+class ann(x: Any*) extends annotation.Annotation
+
+def f(y: C, z: C) =
+  def g(): C @ann(y, z) = ???
+  val ac: ((x: C) => Array[String @ann(x)]) = ???
+  val dc = ac(g())