Fix signature caching involving type variables

Signatures should not be cached if they may change. The existing
`isUnderDefined` check is not enough to guarantee this because the signature
might have been computed based on a type variable instantiated in a TyperState
which was subsequently retracted.

To guard against this, we now rely on `Type#isProvisional`. This is a stricter
check than needed since the provisional part of the type does not always have
an impact on its signature, but in practice this is fine: when compiling Dotty,
signature cache misses increased by less than 2%.

Author: smarter

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -2272,7 +2272,7 @@ object Types {
 
       if ctx.runId != mySignatureRunId then
         mySignature = computeSignature
-        if !mySignature.isUnderDefined then mySignatureRunId = ctx.runId
+        if !mySignature.isUnderDefined && !isProvisional then mySignatureRunId = ctx.runId
       mySignature
     end signature
 
@@ -3784,17 +3784,17 @@ object Types {
         case SourceLanguage.Java =>
           if ctx.runId != myJavaSignatureRunId then
             myJavaSignature = computeSignature
-            if !myJavaSignature.isUnderDefined then myJavaSignatureRunId = ctx.runId
+            if !myJavaSignature.isUnderDefined && !isProvisional then myJavaSignatureRunId = ctx.runId
           myJavaSignature
         case SourceLanguage.Scala2 =>
           if ctx.runId != myScala2SignatureRunId then
             myScala2Signature = computeSignature
-            if !myScala2Signature.isUnderDefined then myScala2SignatureRunId = ctx.runId
+            if !myScala2Signature.isUnderDefined && !isProvisional then myScala2SignatureRunId = ctx.runId
           myScala2Signature
         case SourceLanguage.Scala3 =>
           if ctx.runId != mySignatureRunId then
             mySignature = computeSignature
-            if !mySignature.isUnderDefined then mySignatureRunId = ctx.runId
+            if !mySignature.isUnderDefined && !isProvisional then mySignatureRunId = ctx.runId
           mySignature
     end signature
 

compiler/test/dotty/tools/SignatureTest.scala

@@ -2,13 +2,15 @@ package dotty.tools
 
 import vulpix.TestConfiguration
 
+import org.junit.Assert._
 import org.junit.Test
 
 import dotc.ast.untpd
 import dotc.core.Decorators._
 import dotc.core.Contexts._
 import dotc.core.Flags._
 import dotc.core.Phases._
+import dotc.core.Names._
 import dotc.core.Types._
 import dotc.core.Symbols._
 import dotc.core.StdNames._
@@ -76,3 +78,38 @@ class SignatureTest:
       assert(isFullyDefined(tvar, force = ForceDegree.all), s"Could not instantiate $tvar")
       checkSignatures(expectedIsUnderDefined = false)
 
+  /** Check that signature caching behaves correctly with respect to retracted
+   *  instantiations of type variables.
+   */
+  @Test def cachingWithRetraction: Unit =
+    inCompilerContext(TestConfiguration.basicClasspath, separateRun = false,
+      """trait Foo
+        |trait Bar
+        |class A[T]:
+        |  def and(x: T & Foo): Unit = {}
+        |""".stripMargin):
+      val cls = requiredClass("A")
+      val tvar = constrained(cls.requiredMethod(nme.CONSTRUCTOR).info.asInstanceOf[TypeLambda], untpd.EmptyTree, alwaysAddTypeVars = true)._2.head.tpe
+      val prefix = cls.typeRef.appliedTo(tvar)
+      val ref = prefix.select(cls.requiredMethod("and")).asInstanceOf[TermRef]
+
+      /** Check that the signature of the first parameter of `ref` is equal to `expectedParamSig`. */
+      def checkParamSig(ref: TermRef, expectedParamSig: TypeName)(using Context): Unit =
+        assertEquals(i"Check failed for param signature of $ref",
+          expectedParamSig, ref.signature.paramsSig.head)
+        // Both NamedType and MethodOrPoly cache signatures, so check both caches.
+        assertEquals(i"Check failed for param signature of ${ref.info} (but not for $ref itself)",
+          expectedParamSig, ref.info.signature.paramsSig.head)
+        
+
+      // Initially, the param signature is Uninstantiated since it depends on an uninstantiated type variable
+      checkParamSig(ref, tpnme.Uninstantiated)
+
+      // In this context, the signature is the erasure of `Bar & Foo`.
+      inContext(ctx.fresh.setNewTyperState()):
+        tvar =:= requiredClass("Bar").typeRef
+        assert(isFullyDefined(tvar, force = ForceDegree.all), s"Could not instantiate $tvar")
+        checkParamSig(ref, "Bar".toTypeName)
+
+      // If our caching logic is working correctly, we should get the original signature here.
+      checkParamSig(ref, tpnme.Uninstantiated)