not constrain if formal contains instantiated type vars

Author: Alex1005a

compiler/src/dotty/tools/dotc/typer/Inferencing.scala

@@ -27,8 +27,8 @@ object Inferencing {
    *  but only if the overall result of `isFullyDefined` is `true`.
    *  Variables that are successfully minimized do not count as uninstantiated.
    */
-  def isFullyDefined(tp: Type, force: ForceDegree.Value, ifProto: Boolean = false)(using Context): Boolean =
-    withFreshTyperState(new IsFullyDefinedAccumulator(force, ifProto = ifProto).process(tp), x => x)
+  def isFullyDefined(tp: Type, force: ForceDegree.Value)(using Context): Boolean =
+    withFreshTyperState(new IsFullyDefinedAccumulator(force).process(tp), x => x)
 
   /** Try to fully define `tp`. Return whether constraint has changed.
    *  Any changed constraint is kept.
@@ -161,7 +161,7 @@ object Inferencing {
    *  Instance types can be improved by replacing covariant occurrences of Nothing
    *  with fresh type variables, if `force` allows this in its `canImprove` implementation.
    */
-  private class IsFullyDefinedAccumulator(force: ForceDegree.Value, minimizeSelected: Boolean = false, ifProto: Boolean = false)
+  private class IsFullyDefinedAccumulator(force: ForceDegree.Value, minimizeSelected: Boolean = false)
     (using Context) extends TypeAccumulator[Boolean] {
 
     /** Replace toplevel-covariant occurrences (i.e. covariant without double flips)
@@ -233,10 +233,8 @@ object Inferencing {
       val tpd = tp.dealias
       if tpd ne tp then apply(x, tpd)
       else tp match
-        case _: WildcardType =>
+        case _: WildcardType | _: ProtoType =>
           false
-        case tp: ProtoType =>
-          ifProto && foldOver(x, tp)
         case tvar: TypeVar if !tvar.isInstantiated =>
           force.appliesTo(tvar)
           && ctx.typerState.constraint.contains(tvar)

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -54,7 +54,6 @@ import transform.CheckUnused.OriginalName
 import scala.annotation.{unchecked as _, *}
 import dotty.tools.dotc.util.chaining.*
 import dotty.tools.dotc.ast.untpd.Mod
-import dotty.tools.dotc.reporting.Reporter.NoReporter
 
 object Typer {
 
@@ -4358,33 +4357,25 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
                 else formals1
               implicitArgs(formals2, argIndex + 1, pt)
 
-
-            def doesntContainsWildcards = {
-              val newCtx = ctx.fresh.setNewScope.setReporter(new reporting.ThrowingReporter(NoReporter))
-              val substCtxMap = new TypeMap():
-                def apply(tp: Type): Type = tp match
-                  case tp: FunProto => mapOver(
-                    tp.derivedFunProto(resultType = tp.resultType(using newCtx)).withContext(newCtx)
-                  )
-                  case tp => mapOver(tp)
-              val pt1 = substCtxMap(pt.deepenProtoTrans(using newCtx))
-              try {
-                !pt1.containsWildcardTypes(using newCtx)
-              } catch {
-                case _: UnhandledError => false
-              }
-            }
             val pt1 = pt.deepenProtoTrans
+            val approxPt = withMode(Mode.TypevarsMissContext):
+              wildApprox(pt1)
+            var formalConstrained = false
+            val tm = new TypeMap:
+              def apply(t: Type): Type = t match
+                case tvar: TypeVar =>
+                  formalConstrained |= ctx.typerState.constraint.contains(tvar) || tvar.instanceOpt.isInstanceOf[TypeVar]
+                  tvar
+                case _ =>
+                  if formalConstrained then t
+                  else mapOver(t)
+            tm(formal)
             if (pt1 `ne` pt)
               && (pt1 ne sharpenedPt)
-              && formal.typeSymbol != defn.ClassTagClass
+              && (AvoidWildcardsMap()(approxPt) `eq` approxPt)
               && !isFullyDefined(formal, ForceDegree.none)
-              && !formal.existsPart(ty => {
-                  val dty = ty.dealias
-                  (dty ne ty) && ty.isInstanceOf[TypeVar] && dty.isInstanceOf[TypeVar]
-                }, StopAt.Static, forceLazy = false)
-              && doesntContainsWildcards then
-              withoutMode(Mode.ImplicitsEnabled)(constrainResult(tree.symbol, wtp, wildApprox(pt1)))
+              && !formalConstrained then
+              constrainResult(tree.symbol, wtp, pt1)
             val arg = inferImplicitArg(formal, tree.span.endPos)
 
             def canProfitFromMoreConstraints =