Signature caching test for this PR

This currently fails with:
assertion failed: Before erasure, the signature of a TypeRef should be the signature of its denotation,
but the cached signature of TermRef(ThisType(TypeRef(ThisType(TypeRef(NoPrefix,module class <empty>)),class Foo)),method value) was:
Signature(List(),scala.Unit), whereas its denotation signature at typer was:
Signature(List(),)

Author: smarter

compiler/test/dotty/tools/SignatureTest.scala

@@ -0,0 +1,34 @@
+package dotty.tools
+
+import vulpix.TestConfiguration
+
+import org.junit.Test
+
+import dotc.ast.Trees._
+import dotc.core.Decorators._
+import dotc.core.Contexts._
+import dotc.core.Types._
+
+import java.io.File
+import java.nio.file._
+
+class SignatureTest:
+  @Test def signatureCaching: Unit =
+    inCompilerContext(TestConfiguration.basicClasspath, separateRun = true, "case class Foo(value: Unit)") {
+      val (ref, refSig) = ctx.atPhase(ctx.erasurePhase.next) {
+        val cls = ctx.requiredClass("Foo")
+        val ref = cls.requiredMethod("value").termRef
+        (ref, ref.signature)
+      }
+      ctx.atPhase(ctx.typerPhase) {
+        assert(refSig == ref.signature,
+          s"""The signature of a type should never change but the signature of $ref was:
+             |${ref.signature} at typer, whereas it was:
+             |${refSig} after erasure""".stripMargin)
+        assert(ref.signature == ref.denot.signature,
+          s"""Before erasure, the signature of a TypeRef should be the signature of its denotation,
+             |but the cached signature of $ref was:
+             |${ref.signature}, whereas its denotation signature at typer was:
+             |${ref.denot.signature}""".stripMargin)
+      }
+    }

compiler/test/dotty/tools/compilerSupport.scala

@@ -1,7 +1,7 @@
 package dotty.tools
 
 import javax.tools._
-import java.io.File
+import java.io._
 import java.nio.file._
 import java.net.URI
 import scala.jdk.CollectionConverters._
@@ -10,14 +10,34 @@ import core._
 import core.Contexts._
 import dotc.core.Comments.{ContextDoc, ContextDocstrings}
 
-/** Initialize a compiler context with the given classpath and
- *  pass it to `op`.
+// TODO: refactor, copy-pasted from Run#compileFromStrings
+private def sourceFile(source: String, isJava: Boolean): util.SourceFile = {
+  val uuid = java.util.UUID.randomUUID().toString
+  val ext = if (isJava) ".java" else ".scala"
+  val virtualFile = new io.VirtualFile(s"compileFromString-$uuid.$ext")
+  val writer = new BufferedWriter(new OutputStreamWriter(virtualFile.output, "UTF-8")) // buffering is still advised by javadoc
+  writer.write(source)
+  writer.close()
+  new util.SourceFile(virtualFile, scala.io.Codec.UTF8)
+}
+
+/** Initialize a compiler context with the given `classpath`, compile all
+ *  `scalaSources`, then run `op`.
+ *
+ *  If `separateRun` is true , then `op` will be run in a new run different from the
+ *  one used to compile the sources, this makes it easier to test for potential
+ *  issues involving retrieving symbols defined in a previous run.
  */
-def inCompilerContext[T](classpath: String)(op: Context ?=> T): T =
+def inCompilerContext[T](classpath: String, separateRun: Boolean = true, scalaSources: String*)(op: Context ?=> T): T =
   val compiler = Compiler()
-  val run = compiler.newRun(initCtx(classpath))
-  run.compileUnits(Nil) // Initialize phases
-  op(using run.runContext)
+  val rootCtx = initCtx(classpath)
+  val firstRun = compiler.newRun(rootCtx)
+  firstRun.compileUnits(scalaSources.toList.map(s =>
+    CompilationUnit(sourceFile(s, isJava = false))(using firstRun.runContext)))
+  val opRun = if separateRun
+    then compiler.newRun(rootCtx)
+    else firstRun
+  op(using opRun.runContext)
 
 private def initCtx(classpath: String): Context =
   val ctx0 = (new ContextBase).initialCtx.fresh