Don't do mode adaptation when constraining closures

Ignore the mode instead, since it will anyway be adapted later when we
check the closure's type.

Also: Improve error message when closure parameters don't match.

Author: odersky

compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala

@@ -20,7 +20,7 @@ import scala.collection.mutable
 import CaptureSet.{withCaptureSetsExplained, IdempotentCaptRefMap}
 import StdNames.nme
 import NameKinds.DefaultGetterName
-import reporting.trace
+import reporting.{trace, ClosureParameterMismatch}
 
 /** The capture checker */
 object CheckCaptures:
@@ -506,7 +506,9 @@ class CheckCaptures extends Recheck, SymTransformer:
 
       def constrainParams(ptformals: List[Type], params: ParamClause) =
         for (param, ptformal) <- params.lazyZip(ptformals) do
-          checkConformsExpr(ptformal, param.symbol.info, param)
+          withMode(Mode.CCIgnoreBoxing):
+            if !isCompatible(ptformal, param.symbol.info, param) then
+              report.error(ClosureParameterMismatch(ptformal, param.symbol.info), param.srcPos)
 
       def constrain(pt: Type, paramss: List[ParamClause]): Unit = (pt: @unchecked) match
         case RefinedType(_, nme.apply, rinfo) =>

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

@@ -153,11 +153,14 @@ object Mode {
    */
   val ForceInline: Mode = newMode(29, "ForceInline")
 
+  val CCIgnoreBoxing = ForceInline // Reuse mode bit in checkCaptures phase to indicate relaxed boxing
+
   /** This mode is enabled when we check Java overriding in explicit nulls.
    *  Type `Null` becomes a subtype of non-primitive value types in TypeComparer.
    */
   val RelaxedOverriding: Mode = newMode(30, "RelaxedOverriding")
 
   /** We are checking the original call of an Inlined node */
   val InlinedCall: Mode = newMode(31, "InlinedCall")
+
 }

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

@@ -2696,6 +2696,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
    */
   protected def sameBoxed(tp1: Type, tp2: Type, refs1: CaptureSet)(using Context): Boolean =
     (tp1.isBoxedCapturing == tp2.isBoxedCapturing)
+    || ctx.mode.is(Mode.CCIgnoreBoxing)
     || refs1.subCaptures(CaptureSet.empty, frozenConstraint).isOK
 
   // ----------- Diagnostics --------------------------------------------------

compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala

@@ -202,6 +202,7 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe
   case ImplausiblePatternWarningID // erorNumber: 186
   case SynchronizedCallOnBoxedClassID // errorNumber: 187
   case VarArgsParamCannotBeGivenID // erorNumber: 188
+  case ClosureParameterMismatchID // errorNumber 189
 
   def errorNumber = ordinal - 1
 

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -1584,6 +1584,14 @@ class IllegalParameterInit(found: Type, expected: Type, param: Symbol, cls: Symb
         |  The argument passed for $param has type: $found
         |  but $cls expects $param to have type: $expected"""
 
+class ClosureParameterMismatch(inferred: Type, declared: Type)(using Context)
+  extends TypeMismatchMsg(inferred, declared)(ClosureParameterMismatchID):
+  def msg(using Context) =
+    i"""Inferred closure parameter type is incompatible with declared parameter type.
+       |
+       |Inferred type: $inferred
+       |Declared type: $declared"""
+
 class AbstractMemberMayNotHaveModifier(sym: Symbol, flag: FlagSet)(
   implicit ctx: Context)
   extends SyntaxMsg(AbstractMemberMayNotHaveModifierID) {

compiler/src/dotty/tools/dotc/transform/Recheck.scala

@@ -562,18 +562,18 @@ abstract class Recheck extends Phase, SymTransformer:
       case _ =>
         checkConformsExpr(tpe.widenExpr, pt.widenExpr, tree)
 
+    def isCompatible(actual: Type, expected: Type, tree: Tree)(using Context): Boolean =
+      actual <:< expected
+      || expected.isRepeatedParam
+          && isCompatible(actual, expected.translateFromRepeated(toArray = tree.tpe.widen.isRef(defn.ArrayClass)), tree)
+      || {
+        val widened = widenSkolems(expected)
+        (widened ne expected) && isCompatible(actual, widened, tree)
+      }
+
     def checkConformsExpr(actual: Type, expected: Type, tree: Tree)(using Context): Unit =
       //println(i"check conforms $actual <:< $expected")
-
-      def isCompatible(expected: Type): Boolean =
-        actual <:< expected
-        || expected.isRepeatedParam
-            && isCompatible(expected.translateFromRepeated(toArray = tree.tpe.isRef(defn.ArrayClass)))
-        || {
-          val widened = widenSkolems(expected)
-          (widened ne expected) && isCompatible(widened)
-        }
-      if !isCompatible(expected) then
+      if !isCompatible(actual, expected, tree) then
         recheckr.println(i"conforms failed for ${tree}: $actual vs $expected")
         err.typeMismatch(tree.withType(actual), expected)
       else if debugSuccesses then