Widen type parameters before box adaptation (#23809)

Fixes #23746 and #19076. Widen type parameters to their upper bounds in certain cases before box adaptation. This helps revealing a boxed type inside the upper bound of a type parameter.

Author: odersky

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

@@ -15,7 +15,7 @@ import typer.Inferencing.isFullyDefined
 import typer.RefChecks.{checkAllOverrides, checkSelfAgainstParents, OverridingPairsChecker}
 import typer.Checking.{checkBounds, checkAppliedTypesIn}
 import typer.ErrorReporting.{Addenda, NothingToAdd, err}
-import typer.ProtoTypes.{LhsProto, WildcardSelectionProto}
+import typer.ProtoTypes.{LhsProto, WildcardSelectionProto, SelectionProto}
 import util.{SimpleIdentitySet, EqHashMap, EqHashSet, SrcPos, Property}
 import transform.{Recheck, PreRecheck, CapturedVars}
 import Recheck.*
@@ -1309,17 +1309,64 @@ class CheckCaptures extends Recheck, SymTransformer:
  override def checkConformsExpr(actual: Type, expected: Type, tree: Tree, addenda: Addenda)(using Context): Type =
  testAdapted(actual, expected, tree, addenda)(err.typeMismatch)
 
+ @annotation.tailrec
+ private def findImpureUpperBound(tp: Type)(using Context): Type = tp match
+ case _: SingletonType => findImpureUpperBound(tp.widen)
+ case tp: TypeRef if tp.symbol.isAbstractOrParamType =>
+ tp.info match
+ case TypeBounds(_, hi) if hi.isBoxedCapturing => hi
+ case TypeBounds(_, hi) => findImpureUpperBound(hi)
+ case _ => NoType
+ case _ => NoType
+
  inline def testAdapted(actual: Type, expected: Type, tree: Tree, addenda: Addenda)
  (fail: (Tree, Type, Addenda) => Unit)(using Context): Type =
+
  var expected1 = alignDependentFunction(expected, actual.stripCapturing)
  val falseDeps = expected1 ne expected
- val actualBoxed = adapt(actual, expected1, tree)
+ val actual1 =
+ if expected.stripCapturing.isInstanceOf[SelectionProto] then
+ // If the expected type is a `SelectionProto`, we should be careful about cases when
+ // the actual type is a type parameter (for instance, `X <: box IO^`).
+ // If `X` were not widen to reveal the boxed type, both sides are unboxed and thus
+ // no box adaptation happens. But it is unsound: selecting a member from `X` implicitly
+ // unboxes the value.
+ //
+ // Therefore, when the expected type is a selection proto, we conservatively widen
+ // the actual type to strip type parameters.
+ val hi = findImpureUpperBound(actual)
+ if !hi.exists then actual else hi
+ else actual
+ val actualBoxed = adapt(actual1, expected1, tree)
  //println(i"check conforms $actualBoxed <<< $expected1")
 
  if actualBoxed eq actual then
  // Only `addOuterRefs` when there is no box adaptation
  expected1 = addOuterRefs(expected1, actual, tree.srcPos)
- TypeComparer.compareResult(isCompatible(actualBoxed, expected1)) match
+
+ def tryCurrentType: Boolean =
+ isCompatible(actualBoxed, expected1)
+
+ /** When the actual type is a named type, and the previous attempt failed, try to widen the named type
+ * and try another time.
+ *
+ * This is useful for cases like:
+ *
+ * def id[X <: box IO^{a}](x: X): IO^{a} = x
+ *
+ * When typechecking the body, we need to show that `(x: X)` can be typed at `IO^{a}`.
+ * In the first attempt, since `X` is simply a parameter reference, we treat it as non-boxed and perform
+ * no box adptation. But its upper bound is in fact boxed, and adaptation is needed for typechecking the body.
+ * In those cases, we widen such types and try box adaptation another time.
+ */
+ def tryWidenNamed: Boolean =
+ val actual1 = findImpureUpperBound(actual)
+ actual1.exists && {
+ val actualBoxed1 = adapt(actual1, expected1, tree)
+ isCompatible(actualBoxed1, expected1)
+ }
+
+ TypeComparer.compareResult(tryCurrentType || tryWidenNamed) match
  case TypeComparer.CompareResult.Fail(notes) =>
  capt.println(i"conforms failed for ${tree}: $actual vs $expected")
  if falseDeps then expected1 = unalignFunction(expected1)
@@ -1477,7 +1524,8 @@ class CheckCaptures extends Recheck, SymTransformer:
  (actualShape, CaptureSet())
  end adaptShape
 
- def adaptStr = i"adapting $actual ${if covariant then "~~>" else "<~~"} $expected"
+ //val adaptStr = i"adapting $actual ${if covariant then "~~>" else "<~~"} $expected"
+ //println(adaptStr)
 
  // Get wildcards out of the way
  expected match

tests/neg-custom-args/captures/i23746.check

@@ -0,0 +1,21 @@
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i23746.scala:5:2 -----------------------------------------
+5 | () => op.run() // error
+ | ^^^^^^^^^^^^^^
+ | Found: () => Unit
+ | Required: () -> Unit
+ |
+ | Note that capability cap is not included in capture set {}.
+ |
+ | where: => refers to a fresh root capability in the type of type X
+ | cap is a fresh root capability in the type of type X
+ |
+ | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i23746.scala:10:4 ----------------------------------------
+10 | () => op.run() // error
+ | ^^^^^^^^^^^^^^
+ | Found: () ->{a} Unit
+ | Required: () -> Unit
+ |
+ | Note that capability a is not included in capture set {}.
+ |
+ | longer explanation available when compiling with `-explain`

tests/neg-custom-args/captures/i23746.scala

@@ -0,0 +1,10 @@
+import language.experimental.captureChecking
+trait Op:
+ def run(): Unit
+def helper[X <: Op^](op: X): () -> Unit =
+ () => op.run() // error
+def test1(a: Op^): Unit =
+ def foo[X <: Op^{a}](op: X): () ->{a} Unit =
+ () => op.run() // ok
+ def bar[X <: Op^{a}](op: X): () ->{} Unit =
+ () => op.run() // error

tests/pos-custom-args/captures/i19076.scala

@@ -0,0 +1,4 @@
+import language.experimental.captureChecking
+trait IO
+def main(a: IO^): Unit =
+ def foo[X <: IO^{a}](x: X): IO^{a} = x // now ok