Also fluidify member when doing overriding checks

As `Map` shows, it's possible that an overriding check is from an external
non-capture checked subclass member against a currently compiled & capture-checked
superclass member. Hence, we have to add Fluid sets to either part of an
overriding check if that part is not compiled with capture checking.

This allows to include collection/Map in the set of capture checked stdlib sources.

Author: odersky

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

@@ -311,8 +311,8 @@ class CheckCaptures extends Recheck, SymTransformer:
 
       def isPreCC(sym: Symbol): Boolean =
         sym.isTerm && sym.maybeOwner.isClass
-        && !defn.isFunctionSymbol(sym.owner)
         && !sym.owner.is(CaptureChecked)
+        && !defn.isFunctionSymbol(sym.owner)
 
       if isPreCC(sym) then
         val tpw = tp.widen
@@ -948,8 +948,8 @@ class CheckCaptures extends Recheck, SymTransformer:
             finally curEnv = saved
           actual1 frozen_<:< expected1
 
-        override def adjustOtherType(tp: Type, other: Symbol)(using Context): Type =
-          handleBackwardsCompat(tp, other, initialVariance = 0)
+        override def adjustInfo(tp: Type, member: Symbol)(using Context): Type =
+          handleBackwardsCompat(tp, member, initialVariance = 0)
             //.showing(i"adjust $other: $tp --> $result")
       end OverridingPairsCheckerCC
 

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

@@ -239,10 +239,10 @@ object RefChecks {
     // compatibility checking.
     def checkSubType(tp1: Type, tp2: Type)(using Context): Boolean = tp1 frozen_<:< tp2
 
-    /** A hook that allows to adjust the type of `other` before checking conformance.
-     *  Overridden in capture checking to handle non-capture checked superclasses leniently.
+    /** A hook that allows to adjust the type of `member` and `other` before checking conformance.
+     *  Overridden in capture checking to handle non-capture checked classes leniently.
      */
-    def adjustOtherType(tp: Type, other: Symbol)(using Context): Type = tp
+    def adjustInfo(tp: Type, member: Symbol)(using Context): Type = tp
 
     private val subtypeChecker: (Type, Type) => Context ?=> Boolean = this.checkSubType
 
@@ -367,8 +367,8 @@ object RefChecks {
     def checkOverride(checkSubType: (Type, Type) => Context ?=> Boolean, member: Symbol, other: Symbol): Unit =
       def memberTp(self: Type) =
         if (member.isClass) TypeAlias(member.typeRef.EtaExpand(member.typeParams))
-        else self.memberInfo(member)
-      def otherTp(self: Type) = checker.adjustOtherType(self.memberInfo(other), other)
+        else checker.adjustInfo(self.memberInfo(member), member)
+      def otherTp(self: Type) = checker.adjustInfo(self.memberInfo(other), other)
 
       refcheck.println(i"check override ${infoString(member)} overriding ${infoString(other)}")
 

tests/pos/stdlib/collection/Map.scala

@@ -17,7 +17,7 @@ import scala.annotation.nowarn
 import scala.collection.generic.DefaultSerializable
 import scala.collection.mutable.StringBuilder
 import scala.util.hashing.MurmurHash3
-//import language.experimental.captureChecking
+import language.experimental.captureChecking
 
 /** Base Map type */
 trait Map[K, +V]
@@ -132,7 +132,7 @@ trait MapOps[K, +V, +CC[_, _] <: IterableOps[_, AnyConstr, _], +C]
   /** Similar to `fromIterable`, but returns a Map collection type.
     * Note that the return type is now `CC[K2, V2]`.
     */
-  @`inline` protected final def mapFromIterable[K2, V2](it: Iterable[(K2, V2)]): CC[K2, V2] = mapFactory.from(it)
+  @`inline` protected final def mapFromIterable[K2, V2](it: Iterable[(K2, V2)]^): CC[K2, V2] = mapFactory.from(it)
 
   /** The companion object of this map, providing various factory methods.
     *
@@ -319,7 +319,7 @@ trait MapOps[K, +V, +CC[_, _] <: IterableOps[_, AnyConstr, _], +C]
     *  @return       a new $coll resulting from applying the given collection-valued function
     *                `f` to each element of this $coll and concatenating the results.
     */
-  def flatMap[K2, V2](f: ((K, V)) => IterableOnce[(K2, V2)]): CC[K2, V2] = mapFactory.from(new View.FlatMap(this, f))
+  def flatMap[K2, V2](f: ((K, V)) => IterableOnce[(K2, V2)]^): CC[K2, V2] = mapFactory.from(new View.FlatMap(this, f))
 
   /** Returns a new $coll containing the elements from the left hand operand followed by the elements from the
     *  right hand operand. The element type of the $coll is the most specific superclass encompassing
@@ -329,15 +329,15 @@ trait MapOps[K, +V, +CC[_, _] <: IterableOps[_, AnyConstr, _], +C]
     *  @return       a new $coll which contains all elements
     *                of this $coll followed by all elements of `suffix`.
     */
-  def concat[V2 >: V](suffix: collection.IterableOnce[(K, V2)]): CC[K, V2] = mapFactory.from(suffix match {
+  def concat[V2 >: V](suffix: collection.IterableOnce[(K, V2)]^): CC[K, V2] = mapFactory.from(suffix match {
     case it: Iterable[(K, V2)] => new View.Concat(this, it)
     case _ => iterator.concat(suffix.iterator)
   })
 
   // Not final because subclasses refine the result type, e.g. in SortedMap, the result type is
   // SortedMap's CC, while Map's CC is fixed to Map
   /** Alias for `concat` */
-  /*@`inline` final*/ def ++ [V2 >: V](xs: collection.IterableOnce[(K, V2)]): CC[K, V2] = concat(xs)
+  /*@`inline` final*/ def ++ [V2 >: V](xs: collection.IterableOnce[(K, V2)]^): CC[K, V2] = concat(xs)
 
   override def addString(sb: StringBuilder, start: String, sep: String, end: String): sb.type =
     iterator.map { case (k, v) => s"$k -> $v" }.addString(sb, start, sep, end)
@@ -351,14 +351,14 @@ trait MapOps[K, +V, +CC[_, _] <: IterableOps[_, AnyConstr, _], +C]
     mapFactory.from(new View.Concat(new View.Appended(new View.Appended(this, elem1), elem2), elems))
 
   @deprecated("Consider requiring an immutable Map.", "2.13.0")
-  @`inline` def -- (keys: IterableOnce[K]): C = {
+  @`inline` def -- (keys: IterableOnce[K]^): C = {
     lazy val keysSet = keys.iterator.to(immutable.Set)
     fromSpecific(this.view.filterKeys(k => !keysSet.contains(k)))
   }
 
   @deprecated("Use ++ instead of ++: for collections of type Iterable", "2.13.0")
-  def ++: [V1 >: V](that: IterableOnce[(K,V1)]): CC[K,V1] = {
-    val thatIterable: Iterable[(K, V1)] = that match {
+  def ++: [V1 >: V](that: IterableOnce[(K,V1)]^): CC[K,V1] = {
+    val thatIterable: Iterable[(K, V1)]^{that} = that match {
       case that: Iterable[(K, V1)] => that
       case that => View.from(that)
     }
@@ -381,10 +381,10 @@ object MapOps {
     def map[K2, V2](f: ((K, V)) => (K2, V2)): CC[K2, V2] =
       self.mapFactory.from(new View.Map(filtered, f))
 
-    def flatMap[K2, V2](f: ((K, V)) => IterableOnce[(K2, V2)]): CC[K2, V2] =
+    def flatMap[K2, V2](f: ((K, V)) => IterableOnce[(K2, V2)]^): CC[K2, V2] =
       self.mapFactory.from(new View.FlatMap(filtered, f))
 
-    override def withFilter(q: ((K, V)) => Boolean): WithFilter[K, V, IterableCC, CC] =
+    override def withFilter(q: ((K, V)) => Boolean): WithFilter[K, V, IterableCC, CC]^{p, q} =
       new WithFilter[K, V, IterableCC, CC](self, (kv: (K, V)) => p(kv) && q(kv))
 
   }