Fix signature computation involving nested type variables

Signatures used for overloading/overriding resolution are cached and therefore
should not depend on uninstantiated type variables, this is handled in
`TypeErasure#sigName` by using the name `tpnme.Uninstantiated` when
encountering an uninstantiated type variable (this name is handled specially in
`Signature`). But before this commit, `sigName` only checked for type variables
at the top-level of the type, even though nested type variables can still have
an impact on type erasure, in particular when they appear as part of:
- an intersection
- a union
- an underlying type of a derived value class
- the element type of an array type
- an element type of a tuple (... *: X *: ...)

We fix this by using `Type#isProvisional` as in other caching mechanisms, this
required tweaking the implementation of `isProvisional` to force LazyRefs.

Author: smarter

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

@@ -860,6 +860,14 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
    *  Need to ensure correspondence with erasure!
    */
   private def sigName(tp: Type)(using Context): TypeName = try
+    // Signature caching relies on `Signature#isUnderDefined` which itself
+    // relies on us returning `tpnme.Uninstantiated` if the signature might
+    // change. Only some part of th types influence its signature, but it's
+    // simpler to always return `tpnme.Uninstantiated` if any part of the type
+    // might change (experimentally, this leads to 2% extra signature cache
+    // misses when compiling Dotty compared to a more precise analysis, but a
+    // much simpler implementation).
+    if tp.isProvisional then return tpnme.Uninstantiated
     tp match {
       case tp: TypeRef =>
         if (!tp.denot.exists)
@@ -902,9 +910,6 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
         sigName(underlyingOfTermRef(tp))
       case ExprType(rt) =>
         sigName(defn.FunctionOf(Nil, rt))
-      case tp: TypeVar =>
-        val inst = tp.instanceOpt
-        if (inst.exists) sigName(inst) else tpnme.Uninstantiated
       case tp @ RefinedType(parent, nme.apply, _) if parent.typeSymbol eq defn.PolyFunctionClass =>
         // we need this case rather than falling through to the default
         // because RefinedTypes <: TypeProxy and it would be caught by

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

@@ -135,7 +135,7 @@ object Types {
             case t: TypeVar =>
               !t.inst.exists || test(t.inst, theAcc)
             case t: LazyRef =>
-              !t.completed || test(t.ref, theAcc)
+              t.evaluating || test(t.ref, theAcc)
             case _ =>
               (if theAcc != null then theAcc else ProAcc()).foldOver(false, t)
         end if

compiler/test/dotty/tools/SignatureTest.scala

@@ -4,12 +4,19 @@ import vulpix.TestConfiguration
 
 import org.junit.Test
 
-import dotc.ast.Trees._
+import dotc.ast.untpd
 import dotc.core.Decorators._
 import dotc.core.Contexts._
+import dotc.core.Flags._
 import dotc.core.Phases._
 import dotc.core.Types._
 import dotc.core.Symbols._
+import dotc.core.StdNames._
+import dotc.core.Signature
+import dotc.typer.ProtoTypes.constrained
+import dotc.typer.Inferencing.isFullyDefined
+import dotc.typer.ForceDegree
+import dotc.util.NoSourcePosition
 
 import java.io.File
 import java.nio.file._
@@ -38,3 +45,43 @@ class SignatureTest:
              |${ref.denot.signature}""".stripMargin)
       }
     }
+
+  /** Ensure that signature computation returns an underdefined signature when
+   *  the signature depends on uninstantiated type variables.
+   *
+   *  This is important because signatures are considered safe to cache in
+   *  types if they're not underdefined.
+   */
+  @Test def underdefinedSignature: Unit =
+    inCompilerContext(TestConfiguration.basicClasspath, separateRun = false,
+      """trait Foo
+        |trait Bar
+        |class A[T <: Tuple]:
+        |  def and(x: T & Foo): Unit = {}
+        |  def andor(x: (T | Bar) & Foo): Unit = {}
+        |  def array(x: Array[(T | Bar) & Foo]): Unit = {}
+        |  def tuple(x: Foo *: T): Unit = {}
+        |  def tuple2(x: Foo *: (T | Tuple) & Foo): Unit = {}
+        |""".stripMargin) {
+      val cls = requiredClass("A")
+      val tvar = constrained(cls.requiredMethod(nme.CONSTRUCTOR).info.asInstanceOf[TypeLambda], untpd.EmptyTree, alwaysAddTypeVars = true)._2.head.tpe
+      tvar <:< defn.TupleTypeRef
+      val prefix = cls.typeRef.appliedTo(tvar)
+
+      def checkSignatures(expectedIsUnderDefined: Boolean): Unit =
+        for decl <- cls.info.decls.toList if decl.is(Method) && !decl.isConstructor do
+          val meth = decl.asSeenFrom(prefix)
+          val sig = meth.info.signature
+          val what = if expectedIsUnderDefined then "underdefined" else "fully-defined"
+          assert(sig.isUnderDefined == expectedIsUnderDefined, i"Signature of `$meth` with prefix `$prefix` and type `${meth.info}` should be $what but is `$sig`")
+
+      checkSignatures(expectedIsUnderDefined = true)
+
+      inContext(ctx.fresh.setNewTyperState()):
+        assert(isFullyDefined(tvar, force = ForceDegree.all), s"Could not instantiate $tvar")
+        // Signatures are still underdefined if the instantiation can be retracted.
+        checkSignatures(expectedIsUnderDefined = true)
+
+      assert(isFullyDefined(tvar, force = ForceDegree.all), s"Could not instantiate $tvar")
+      checkSignatures(expectedIsUnderDefined = false)
+    }

tests/pos/scala3mock.scala

@@ -0,0 +1,11 @@
+class MockFunction1[T1]:
+  def expects(v1: T1 | Foo): Any = ???
+  def expects(matcher: String): Any = ???
+
+def when[T1](f: T1 => Any): MockFunction1[T1] = ???
+
+class Foo
+
+def main =
+    val f: Foo = new Foo
+    when((x: Foo) => "").expects(f)