Optimise SpaceEngine.signature for synthetic unapplies

Instead of creating type vars, constraining against them, then
instantiating them, just instantiate the PolyType with the scrutinee
type args (or the lo/hi bound or bounded wildcard from the param).

Author: dwijnand

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

@@ -4636,6 +4636,7 @@ object Types extends TypeUtils {
     type BT <: LambdaType
     def paramNum: Int
     def paramName: binder.ThisName = binder.paramNames(paramNum)
+    def paramInfo: binder.PInfo    = binder.paramInfos(paramNum)
 
     override def underlying(using Context): Type = {
       // TODO: update paramInfos's type to nullable

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -5,7 +5,7 @@ package patmat
 
 import core.*, Constants.*, Contexts.*, Decorators.*, Flags.*, Names.*, NameOps.*, StdNames.*, Symbols.*, Types.*
 import ast.*, tpd.*
-import config.Printers.*
+import config.Printers.exhaustivity
 import printing.{ Printer, * }, Texts.*
 import reporting.*
 import typer.*, Applications.*, Inferencing.*, ProtoTypes.*
@@ -531,14 +531,48 @@ object SpaceEngine {
     val mt: MethodType = unapp.widen match {
       case mt: MethodType => mt
       case pt: PolyType   =>
+        if unappSym.is(Synthetic) then
+          val mt = pt.resultType.asInstanceOf[MethodType]
+          val unapplyArgType = mt.paramInfos.head
+          val targs = scrutineeTp.baseType(unapplyArgType.classSymbol) match
+            case AppliedType(_, targs) => targs
+            case _ =>
+              // Typically when the scrutinee is Null or Nothing (see i5067 and i5067b)
+              // For performance, do `variances(unapplyArgType)` but without using TypeVars
+              // so just find the variance, so we know if to min/max to the LB/UB or use a wildcard.
+              object accu extends TypeAccumulator[VarianceMap[TypeParamRef]]:
+                def apply(vmap: VarianceMap[TypeParamRef], tp: Type) = tp match
+                  case tp: TypeParamRef if tp.binder eq pt => vmap.recordLocalVariance(tp, variance)
+                  case _                                   => foldOver(vmap, tp)
+              val vs = accu(VarianceMap.empty[TypeParamRef], unapplyArgType)
+              pt.paramRefs.map: p =>
+                vs.computedVariance(p).uncheckedNN match
+                  case -1 => p.paramInfo.lo
+                  case 1  => p.paramInfo.hi
+                  case _  => WildcardType(p.paramInfo)
+          pt.instantiate(targs).asInstanceOf[MethodType]
+        else
+          val locked = ctx.typerState.ownedVars
           val tvars = constrained(pt)
           val mt = pt.instantiate(tvars).asInstanceOf[MethodType]
-          scrutineeTp <:< mt.paramInfos(0)
+          val unapplyArgType = mt.paramInfos.head
+          scrutineeTp <:< unapplyArgType
           // force type inference to infer a narrower type: could be singleton
           // see tests/patmat/i4227.scala
-          mt.paramInfos(0) <:< scrutineeTp
-          instantiateSelected(mt, tvars)
-          isFullyDefined(mt, ForceDegree.all)
+          unapplyArgType <:< scrutineeTp
+          maximizeType(unapplyArgType, Spans.NoSpan)
+          if !(ctx.typerState.ownedVars -- locked).isEmpty then
+            // constraining can create type vars out of wildcard types
+            // (in legalBound, by using a LevelAvoidMap)
+            // maximise will only do one pass at maximising the type vars in the target type
+            // which means we can maximise to types that include other type vars
+            // this fails TreeChecker's "non-empty constraint at end of $fusedPhase" check
+            // e.g. run-macros/string-context-implicits
+            // I can't prove that a second call won't also create type vars,
+            // but I'd rather have an unassigned new-new type var, than an infinite loop.
+            // After all, there's nothing strictly "wrong" with unassigned type vars,
+            // it just fails TreeChecker's linting.
+            maximizeType(unapplyArgType, Spans.NoSpan)
           mt
     }