Fix #16018: Existential widening for wildcard arguments

The Scala 3 typer was rejecting subtypings of the form

    F[? >: lo <: hi]  <:  F[X]

for covariant or contravariant `F`, even when `X = hi` (covariant) or
`X = lo` (contravariant). This is a regression against Scala 2 and surfaced
as the akka-derived report in #16018:

    def f[M](xs: java.lang.Iterable[? <: Container[Any, ? <: M]])
        : Seq[Container[Any, M]] =
      seqOf(xs).collect {
        case g: SubContainer[Any, M] @unchecked => g
        case other                              => other
      }

Once `Inferencing.captureWildcards` lifted the Java wildcard to a
`TypeBox.CAP` skolem and pattern matching narrowed the first case body
to `pat ∩ ?N.CAP`, the inferred result reduced to a chain of subtype
checks that ultimately required `F[? <: M] <:< F[M]` for covariant `F`.
That check went through `TypeComparer.compareCaptured` and was answered
in the negative.

Type-theoretic justification
----------------------------
For a covariant type constructor `F` and an existential `∃X. X <: hi`,

    ⨆{F[X] | X <: hi} = F[hi]                          (covariant supremum)

— the supremum is attained at `X = hi`, by covariance. The compiler must
admit that supremum as a subtype of `F[hi]`. Dually for contravariance with
the lower bound:

    ⨅{G[X] | X >: lo} = G[lo]                          (contravariant infimum)

This is the standard existential-elimination rule for variant occurrences.

Bug
---
`compareCaptured` was checking

    v > 0:  isSubType(paramBounds(tparam).hi, arg2)
    v < 0:  isSubType(arg2, paramBounds(tparam).lo)

i.e. it asked whether the *declared parameter bound* (which collapses to
`Any` / `Nothing` for unconstrained type parameters) conforms to `arg2`,
instead of asking whether the *wildcard's own bound* (`arg1.hi` / `arg1.lo`)
does. That rejected every interesting case.

Fix
---
In `TypeComparer.compareCaptured` use the wildcard's own hi/lo, intersected
(resp. unioned) with the declared parameter bounds to preserve soundness in
the corner case where a wildcard is wider than its parameter permits:

    v > 0:  isSubType(arg1.hi & paramBounds(tparam).hi, arg2)
    v < 0:  isSubType(arg2, arg1.lo | paramBounds(tparam).lo)

Tests (directional matrix)
--------------------------
- `tests/pos/i16018.scala`  — mbovel's minimization plus a pure-Scala matrix
  that exercises subtype patterns + fallback `case other` over wildcards.
- `tests/pos/i16018b.scala` — the akka-style shapes that motivated the
  ticket: `java.lang.Iterable[? <: G[? <: M]]` / `java.util.List[…]`
  routed through `seqOf`, then `collect` / `map` with subtype + fallback
  patterns.
- `tests/pos/i16018c.scala` — positive half of the variance × bound matrix
  for the fix itself: covariant + upper, contravariant + lower, nested,
  via method type params, with parameter-bound tightening.
- `tests/neg/i16018c.scala` — negative half of the matrix: invariant
  containers, covariant + lower, contravariant + upper, and the soundness
  guard against wildcards wider than the required type. These must remain
  rejected after the fix.

Verified locally
----------------
- All four `i16018*` tests: 16/16 pass via
  `sbt 'scala3-compiler-bootstrapped/testOnly … CompilationTests'`
  with `-Ddotty.tests.filter=i16018`.
- `wildcard` / `match` / `variance` filter subsets: 16/16 each.
- Full `CompilationTests` run: the remaining 4 failures
  (`tests/run/i13358.scala`, `tests/run/lazy-*.scala`,
  `tests/run/t5552.scala`, `tests/run/t7406.scala`,
  `tests/run/isInstanceOf-eval.scala`,
  `tests/run/i24553.scala`,
  `tests/pos-custom-args/captures/fill-cbn.scala`, and the
  capture-checking neg suite) reproduce on `main` without this change and
  are caused by JDK 25 environment drift (`sun.misc.Unsafe` deprecation
  messages on stdout, the introduction of `java.lang.IO`, and removal of
  `native` from `Object.wait`).

Author: He-Pin

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

@@ -1890,10 +1890,25 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
                 // The captured reference could be illegal and cause a
                 // TypeError to be thrown in argDenot
                 false
+            // Existential widening for wildcard arguments (issue #16018):
+            // `arg1` is the bounds carried by a `? >: lo <: hi` wildcard. For
+            // `arg2` to be a (covariant / contravariant) supertype of `arg1`,
+            // we only need the *wildcard's own* hi/lo to conform — the
+            // declared parameter bounds (`paramBounds(tparam)`) only ever
+            // *constrain* the wildcard further, never relax it. The earlier
+            // formulation used `paramBounds(tparam).hi`, which collapses to
+            // `Any` for unconstrained type parameters and rejects valid
+            // subtypings such as `F[? <: M] <: F[M]` for covariant `F`
+            // (mathematically: ⨆{F[X] | X <: M} = F[M] by covariance, since
+            // the supremum is attained at X = M). Intersecting with
+            // `paramBounds(tparam)` keeps soundness in the rare case where
+            // the wildcard's bound is *wider* than what `tparam` permits.
             else if (v > 0)
-              isSubType(paramBounds(tparam).hi, arg2)
+              val effectiveHi = arg1.hi & paramBounds(tparam).hi
+              isSubType(effectiveHi, arg2)
             else if (v < 0)
-              isSubType(arg2, paramBounds(tparam).lo)
+              val effectiveLo = arg1.lo | paramBounds(tparam).lo
+              isSubType(arg2, effectiveLo)
             else
               false
           case _ =>

tests/neg/i16018c.scala

@@ -0,0 +1,40 @@
+// Negative half of the directional matrix for the fix to
+// `TypeComparer.compareCaptured` (#16018 / Existential widening for wildcard
+// arguments).
+//
+// These shapes must remain *rejected* after the fix: the fix only adds
+// widening that is justified by variance — covariant + upper bound,
+// contravariant + lower bound. Any other combination is unsound and must
+// keep the same diagnostic it had before. If any of these `//<space>error`
+// markers stops firing, the fix has overreached.
+
+object Test:
+
+  class Co[+T]
+  class Contra[-T]
+  class Inv[T]
+
+  // ---- A. Invariant containers never widen the wildcard ---------------
+  def inv_upper_bad[M](xs: Inv[? <: M]): Inv[M] = xs   // error
+  def inv_lower_bad[M](xs: Inv[? >: M]): Inv[M] = xs   // error
+
+  // ---- B. Covariant with a *lower*-bounded wildcard does not widen ----
+  //
+  // For covariant F, `F[? >: lo]` is the type of F[X] for some X >: lo.
+  // That has no useful relationship to F[lo] — picking X = Any is
+  // permitted yet gives F[Any], not F[lo].
+  def co_lower_bad[M](xs: Co[? >: M]): Co[M] = xs       // error
+
+  // ---- C. Contravariant with an *upper*-bounded wildcard does not widen
+  //
+  // Dual to (B): for contravariant G, `G[? <: hi]` makes no commitment
+  // that the picked X is `hi` itself; it could be `Nothing`.
+  def contra_upper_bad[M](xs: Contra[? <: M]): Contra[M] = xs // error
+
+  // ---- D. The required type's hi is strictly tighter than the wildcard
+  //
+  // `Co[? <: Any]` is the trivial widening shape (any T). It must not be
+  // accepted at `Co[Holder]` because the wildcard's hi (`Any`) is wider
+  // than the target.
+  trait Holder
+  def co_too_wide(xs: Co[? <: Any]): Co[Holder] = xs    // error

tests/pos/i16018.scala

@@ -0,0 +1,58 @@
+// Regression test for #16018: type inference with `_ <: T` wildcards in
+// pattern matching over capture-converted scrutinees.
+//
+// Coverage axes for the positive matrix:
+//   1. The mbovel minimization (single wildcard via List.map) — was fixed
+//      since 3.2.0, kept here as a pin.
+//   2. Pure-Scala collections — never trigger the capture-conversion path.
+//   3. Identity / generic Scala helpers over the wildcard-bearing collection.
+//
+// The dual cases reached through Java-generic interop (java.lang.Iterable /
+// java.util.List), which were the original akka regression, are in
+// tests/pos/i16018b.scala.
+
+object Test:
+
+  class Box[T](val value: T)
+  class Container[+S, +M]
+  class SubContainer[+S, +M] extends Container[S, M]
+
+  // ---- 1. mbovel's minimized case from #16018 ------------------------
+  def f1[T](l: List[Box[? <: T]]): List[T] = l.map(_.value)
+
+  // 1b. Variant: returning the wildcard-bearing element preserved.
+  def f1b[T](l: List[Box[? <: T]]): List[Box[? <: T]] = l.map(identity)
+
+  // ---- 2. Pure-Scala scrutinee — never goes through capture conversion -
+  def f2[M](xs: scala.collection.immutable.Seq[Container[Any, ? <: M]])
+      : scala.collection.immutable.Seq[Container[Any, M]] =
+    xs.collect {
+      case g: SubContainer[Any, M] @unchecked => g
+      case other                              => other
+    }
+
+  // 2b. Variant: `.map` instead of `.collect`.
+  def f2b[M](xs: scala.collection.immutable.Seq[Container[Any, ? <: M]])
+      : scala.collection.immutable.Seq[Container[Any, M]] =
+    xs.map {
+      case g: SubContainer[Any, M] @unchecked => g
+      case other                              => other
+    }
+
+  // 2c. Variant: List instead of Seq.
+  def f2c[M](xs: List[Container[Any, ? <: M]])
+      : List[Container[Any, M]] =
+    xs.collect {
+      case g: SubContainer[Any, M] @unchecked => g
+      case other                              => other
+    }
+
+  // ---- 3. Generic helper that stays pure-Scala does not skolemize ----
+  def idSeq[T](it: Iterable[T]): scala.collection.immutable.Seq[T] = ???
+
+  def f3[M](xs: List[Container[Any, ? <: M]])
+      : scala.collection.immutable.Seq[Container[Any, M]] =
+    idSeq(xs).collect {
+      case g: SubContainer[Any, M] @unchecked => g
+      case other                              => other
+    }

tests/pos/i16018b.scala

@@ -0,0 +1,47 @@
+// Regression test for #16018: the akka-derived shapes.
+//
+// These exercise the path that motivated the original ticket: a value of
+// type `J[? <: G[? <: M]]` (J a Java generic) flows through a method that
+// re-projects it as a Scala collection, and is then `collect`/`map`-ed with
+// a subtype pattern + a fallback `case other`. The combination triggers
+//   (i)  `Inferencing.captureWildcards` — the Java-generic argument becomes
+//        a TypeBox.CAP skolem `?N.CAP`, and
+//   (ii) `Match` typing — pattern narrowing turns the first case body into
+//        `pat ∩ ?N.CAP`, while `case other` keeps the raw `?N.CAP`.
+//
+// Until the fix in `TypeComparer.compareCaptured` for wildcard-bound
+// existential widening, the inferred result type could not escape the
+// skolem cleanly. See:
+//   - tests/pos/i16018.scala — companion pos matrix (pure-Scala)
+//   - scala/scala3 #16018 — original bug report
+
+object Test:
+
+  class Container[+S, +M]
+  class SubContainer[+S, +M] extends Container[S, M]
+
+  def seqOf[T](it: java.lang.Iterable[T]): scala.collection.immutable.Seq[T] = ???
+
+  // ---- f1: trigger via java.lang.Iterable ----------------------------
+  def f1[M](xs: java.lang.Iterable[? <: Container[Any, ? <: M]])
+      : scala.collection.immutable.Seq[Container[Any, M]] =
+    seqOf(xs).collect {
+      case g: SubContainer[Any, M] @unchecked => g
+      case other                              => other
+    }
+
+  // ---- f2: same trigger via java.util.List ---------------------------
+  def f2[M](xs: java.util.List[? <: Container[Any, ? <: M]])
+      : scala.collection.immutable.Seq[Container[Any, M]] =
+    seqOf(xs).collect {
+      case g: SubContainer[Any, M] @unchecked => g
+      case other                              => other
+    }
+
+  // ---- f3: same trigger via .map instead of .collect -----------------
+  def f3[M](xs: java.lang.Iterable[? <: Container[Any, ? <: M]])
+      : scala.collection.immutable.Seq[Container[Any, M]] =
+    seqOf(xs).map {
+      case g: SubContainer[Any, M] @unchecked => g
+      case other                              => other
+    }

tests/pos/i16018c.scala

@@ -0,0 +1,58 @@
+// Directional matrix for the fix to `TypeComparer.compareCaptured`
+// (#16018 / Existential widening for wildcard arguments).
+//
+// The fix lets the compiler conclude
+//
+//     F[? <: hi] <: F[hi]      when F is covariant   in that position
+//     G[? >: lo] <: G[lo]      when G is contravariant in that position
+//
+// while leaving invariant positions and the opposite-bound directions
+// intentionally rigid. The matrix below enumerates each axis so that any
+// future refactor sees green/red as soon as the boundary moves.
+
+object Test:
+
+  class Co[+T]
+  class Contra[-T]
+  class Inv[T]
+
+  // ---- 1. Covariant + upper-bounded wildcard widens to its hi --------
+
+  // Direct shape
+  def co_upper_direct[M](xs: Co[? <: M]): Co[M] = xs
+
+  // Nested in another covariant container (the akka shape)
+  def co_upper_in_co[M](xs: Co[Co[? <: M]]): Co[Co[M]] = xs
+  def co_upper_in_seq[M](xs: scala.collection.immutable.Seq[Co[? <: M]])
+      : scala.collection.immutable.Seq[Co[M]] = xs
+
+  // The wildcard hi is reached via a type parameter
+  def co_upper_via_tparam[A, M <: A](xs: Co[? <: M]): Co[M] = xs
+
+  // ---- 2. Contravariant + lower-bounded wildcard widens to its lo ----
+
+  // Direct shape, dual to (1)
+  def contra_lower_direct[M](xs: Contra[? >: M]): Contra[M] = xs
+
+  // Nested in another covariant container (variance composition: Co[+] · Contra[-])
+  def contra_lower_in_co[M](xs: Co[Contra[? >: M]]): Co[Contra[M]] = xs
+
+  // ---- 3. Tightest wildcard against unconstrained param ----------------
+  //
+  // `Co[+T]` declares `T` with `paramBounds = [Nothing, Any]`. Pre-fix the
+  // typer asked `Any <: M`, which is false. Post-fix it asks `M <: M`,
+  // which is true. This is the most common shape — exercised in many
+  // places of the matrix above, repeated here as the headline regression.
+
+  trait Holder
+  def headline(xs: Co[? <: Holder]): Co[Holder] = xs
+
+  // ---- 4. Wildcard wider than the parameter (soundness guard) ----------
+  //
+  // When `T <: Holder` and the wildcard says `? <: Any`, the effective hi
+  // must remain `Holder` (not `Any`), because the parameter constrains it
+  // further. The fix uses `arg1.hi & paramBounds(tparam).hi` precisely to
+  // preserve this. We just witness that this shape still type-checks.
+
+  class CoBounded[+T <: Holder]
+  def soundness_guard(xs: CoBounded[? <: Holder]): CoBounded[Holder] = xs