Drop ConstrainResultDeep mode

Author: odersky

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

@@ -92,7 +92,7 @@ object ProtoTypes {
             case mt: MethodType =>
               constrainResult(resultTypeApprox(mt), pt.resultType)
               && {
-                if ctx.mode.is(Mode.ConstrainResultDeep) then
+                if pt.constrainResultDeep then
                   if mt.isImplicitMethod == (pt.applyKind == ApplyKind.Using) then
                     val tpargs = pt.args.lazyZip(mt.paramInfos).map(pt.typedArg)
                     tpargs.tpes.corresponds(mt.paramInfos)(_ <:< _)
@@ -300,9 +300,21 @@ object ProtoTypes {
   /** A prototype for expressions that appear in function position
    *
    *  [](args): resultType
+   *
+   *  @param  args      The untyped arguments to which the function is applied
+   *  @param  resType   The expeected result type
+   *  @param  typer     The typer to use for typing the arguments
+   *  @param  applyKind The kind of application (regular/using/tupled infix operand)
+   *  @param  state     The state object to use for tracking the changes to this prototype
+   *  @param  constrainResultDeep
+   *                    A flag to indicate that constrainResult on this prototype
+   *                    should typechec and compare the arguments.
    */
-  case class FunProto(args: List[untpd.Tree], resType: Type)(typer: Typer,
-    override val applyKind: ApplyKind, state: FunProtoState = new FunProtoState)(using protoCtx: Context)
+  case class FunProto(args: List[untpd.Tree], resType: Type)(
+    typer: Typer,
+    override val applyKind: ApplyKind,
+    state: FunProtoState = new FunProtoState,
+    val constrainResultDeep: Boolean = false)(using protoCtx: Context)
   extends UncachedGroundType with ApplyingProto with FunOrPolyProto {
     override def resultType(using Context): Type = resType
 
@@ -314,8 +326,16 @@ object ProtoTypes {
       typer.isApplicableType(tp, args, resultType, keepConstraint && !args.exists(isPoly))
     }
 
-    def derivedFunProto(args: List[untpd.Tree] = this.args, resultType: Type, typer: Typer = this.typer): FunProto =
-      if ((args eq this.args) && (resultType eq this.resultType) && (typer eq this.typer)) this
+    def derivedFunProto(
+        args: List[untpd.Tree] = this.args,
+        resultType: Type = this.resultType,
+        typer: Typer = this.typer,
+        constrainResultDeep: Boolean = this.constrainResultDeep): FunProto =
+      if (args eq this.args)
+          && (resultType eq this.resultType)
+          && (typer eq this.typer)
+          && constrainResultDeep == this.constrainResultDeep
+      then this
       else new FunProto(args, resultType)(typer, applyKind)
 
     /** @return True if all arguments have types.
@@ -444,10 +464,10 @@ object ProtoTypes {
       ta(ta.foldOver(x, typedArgs().tpes), resultType)
 
     override def deepenProto(using Context): FunProto =
-      derivedFunProto(args, resultType.deepenProto, typer)
+      derivedFunProto(args, resultType.deepenProto)
 
     override def deepenProtoTrans(using Context): FunProto =
-      derivedFunProto(args, resultType.deepenProtoTrans, typer)
+      derivedFunProto(args, resultType.deepenProtoTrans, constrainResultDeep = true)
 
     override def withContext(newCtx: Context): ProtoType =
       if newCtx `eq` protoCtx then this

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

@@ -3174,10 +3174,7 @@ class Typer extends Namer
             arg.tpe match
               case failed: AmbiguousImplicits =>
                 val pt1 = pt.deepenProtoTrans
-                if (pt1 `ne` pt) && (pt1 ne sharpenedPt)
-                   && withMode(Mode.ConstrainResultDeep)(
-                        constrainResult(tree.symbol, wtp, pt1)
-                      )
+                if (pt1 `ne` pt) && (pt1 ne sharpenedPt) && constrainResult(tree.symbol, wtp, pt1)
                 then implicitArgs(formals, argIndex, pt1)
                 else arg :: implicitArgs(formals1, argIndex + 1, pt1)
               case failed: SearchFailureType =>