Do fluidify when transforming symbols instead of on access

Author: odersky

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

@@ -342,46 +342,14 @@ class CheckCaptures extends Recheck, SymTransformer:
     def includeCallCaptures(sym: Symbol, pos: SrcPos)(using Context): Unit =
       if sym.exists && curEnv.isOpen then markFree(capturedVars(sym), pos)
 
-    private def handleBackwardsCompat(tp: Type, sym: Symbol, initialVariance: Int = 1)(using Context): Type =
-      val fluidify = new TypeMap with IdempotentCaptRefMap:
-        variance = initialVariance
-        def apply(t: Type): Type = t match
-          case t: MethodType =>
-            mapOver(t)
-          case t: TypeLambda =>
-            t.derivedLambdaType(resType = this(t.resType))
-          case CapturingType(_, _) =>
-            t
-          case _ =>
-            val t1  = t match
-              case t @ defn.RefinedFunctionOf(rinfo: MethodType) =>
-                t.derivedRefinedType(t.parent, t.refinedName, this(rinfo))
-              case _ =>
-                mapOver(t)
-            if variance > 0 then t1
-            else setup.decorate(t1, rootTarget = NoSymbol, addedSet = Function.const(CaptureSet.Fluid))
-
-      def isPreCC(sym: Symbol): Boolean =
-        sym.isTerm && sym.maybeOwner.isClass
-        && !sym.owner.is(CaptureChecked)
-        && !defn.isFunctionSymbol(sym.owner)
-
-      if isPreCC(sym) then
-        val tpw = tp.widen
-        val fluidTp = fluidify(tpw)
-        if fluidTp eq tpw then tp
-        else fluidTp.showing(i"fluid for ${sym.showLocated}, ${sym.is(JavaDefined)}: $tp --> $result", capt)
-      else tp
-    end handleBackwardsCompat
-
     override def recheckIdent(tree: Ident)(using Context): Type =
       if tree.symbol.is(Method) then
         if tree.symbol.info.isParameterless then
           // there won't be an apply; need to include call captures now
           includeCallCaptures(tree.symbol, tree.srcPos)
       else
         markFree(tree.symbol, tree.srcPos)
-      handleBackwardsCompat(super.recheckIdent(tree), tree.symbol)
+      super.recheckIdent(tree)
 
     /** A specialized implementation of the selection rule.
      *
@@ -411,7 +379,7 @@ class CheckCaptures extends Recheck, SymTransformer:
       val selType = recheckSelection(tree, qualType, name, disambiguate)
       val selCs = selType.widen.captureSet
       if selCs.isAlwaysEmpty || selType.widen.isBoxedCapturing || qualType.isBoxedCapturing then
-        handleBackwardsCompat(selType, tree.symbol)
+        selType
       else
         val qualCs = qualType.captureSet
         capt.println(i"pick one of $qualType, ${selType.widen}, $qualCs, $selCs in $tree")
@@ -1025,9 +993,8 @@ class CheckCaptures extends Recheck, SymTransformer:
             finally curEnv = saved
           actual1 frozen_<:< expected1
 
-        override def adjustInfo(tp: Type, member: Symbol)(using Context): Type =
-          handleBackwardsCompat(tp, member, initialVariance = 0)
-            //.showing(i"adjust $other: $tp --> $result")
+        override def needsCheck(overriding: Symbol, overridden: Symbol)(using Context): Boolean =
+          !setup.isPreCC(overriding) && !setup.isPreCC(overridden)
       end OverridingPairsCheckerCC
 
       def traverse(t: Tree)(using Context) =

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

@@ -11,7 +11,7 @@ import config.Feature
 import config.Printers.{capt, ccSetup}
 import ast.tpd, tpd.*
 import transform.{PreRecheck, Recheck}, Recheck.*
-import CaptureSet.IdentityCaptRefMap
+import CaptureSet.{IdentityCaptRefMap, IdempotentCaptRefMap}
 import Synthetics.isExcluded
 import util.Property
 import printing.{Printer, Texts}, Texts.{Text, Str}
@@ -21,7 +21,7 @@ import collection.mutable
 trait SetupAPI:
   type DefRecheck = (tpd.ValOrDefDef, Symbol) => Context ?=> Type
   def setupUnit(tree: Tree, recheckDef: DefRecheck)(using Context): Unit
-  def decorate(tp: Type, rootTarget: Symbol, addedSet: Type => CaptureSet)(using Context): Type
+  def isPreCC(sym: Symbol)(using Context): Boolean
 
 object Setup:
   def newScheme(using Context) = ctx.settings.YccNew.value // if new impl is conditional
@@ -82,14 +82,36 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
     then symd.flags &~ Private | Recheck.ResetPrivate
     else symd.flags
 
+  def isPreCC(sym: Symbol)(using Context): Boolean =
+    sym.isTerm && sym.maybeOwner.isClass
+    && !sym.is(Module)
+    && !sym.owner.is(CaptureChecked)
+    && !defn.isFunctionSymbol(sym.owner)
+
+  private def fluidify(using Context) = new TypeMap with IdempotentCaptRefMap:
+    def apply(t: Type): Type = t match
+      case t: MethodType =>
+        mapOver(t)
+      case t: TypeLambda =>
+        t.derivedLambdaType(resType = this(t.resType))
+      case CapturingType(_, _) =>
+        t
+      case _ =>
+        val t1  = t match
+          case t @ defn.RefinedFunctionOf(rinfo: MethodType) =>
+            t.derivedRefinedType(t.parent, t.refinedName, this(rinfo))
+          case _ =>
+            mapOver(t)
+        if variance > 0 then t1
+        else decorate(t1, rootTarget = NoSymbol, addedSet = Function.const(CaptureSet.Fluid))
+
   /**  - Reset `private` flags of parameter accessors so that we can refine them
    *     in Setup if they have non-empty capture sets.
    *   - Special handling of some symbols defined for case classes.
    *  Enabled only until recheck is finished, and provided some compilation unit
    *  is CC-enabled.
    */
   def transformSym(symd: SymDenotation)(using Context): SymDenotation =
-    def needsInfoTransform = newScheme || symd.isGetter
     if !pastRecheck && Feature.ccEnabledSomewhere then
       val sym = symd.symbol
       val needsInfoTransform = sym.isDefinedInCurrentRun && !toBeUpdated.contains(sym)
@@ -98,6 +120,8 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
       // create local roots if necessary
       if Synthetics.needsTransform(symd) then
         Synthetics.transform(symd)
+      else if isPreCC(sym) then
+        symd.copySymDenotation(info = fluidify(sym.info))
       else if symd.owner.isTerm || symd.is(CaptureChecked) || symd.owner.is(CaptureChecked) then
         val newFlags = newFlagsFor(symd)
         val newInfo =

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

@@ -223,36 +223,39 @@ object RefChecks {
           false
       precedesIn(parent.asClass.baseClasses)
 
-    // We can exclude pairs safely from checking only under three additional conditions
-    //   - their signatures also match in the parent class.
-    //     See neg/i12828.scala for an example where this matters.
-    //   - They overriding/overridden appear in linearization order.
-    //     See neg/i5094.scala for an example where this matters.
-    //   - The overridden symbol is not `abstract override`. For such symbols
-    //     we need a more extensive test since the virtual super chain depends
-    //     on the precise linearization order, which might be different for the
-    //     subclass. See neg/i14415.scala.
+    /** We can exclude pairs safely from checking only under three additional conditions
+     *   - their signatures also match in the parent class.
+     *     See neg/i12828.scala for an example where this matters.
+     *   - They overriding/overridden appear in linearization order.
+     *     See neg/i5094.scala for an example where this matters.
+     *   - The overridden symbol is not `abstract override`. For such symbols
+     *     we need a more extensive test since the virtual super chain depends
+     *     on the precise linearization order, which might be different for the
+     *     subclass. See neg/i14415.scala.
+     */
     override def canBeHandledByParent(sym1: Symbol, sym2: Symbol, parent: Symbol): Boolean =
       isOverridingPair(sym1, sym2, parent.thisType)
         .showing(i"already handled ${sym1.showLocated}: ${sym1.asSeenFrom(parent.thisType).signature}, ${sym2.showLocated}: ${sym2.asSeenFrom(parent.thisType).signature} = $result", refcheck)
       && inLinearizationOrder(sym1, sym2, parent)
       && !sym2.is(AbsOverride)
 
-    // Checks the subtype relationship tp1 <:< tp2.
-    // It is passed to the `checkOverride` operation in `checkAll`, to be used for
-    // compatibility checking.
+    /** Checks the subtype relationship tp1 <:< tp2.
+     *  It is passed to the `checkOverride` operation in `checkAll`, to be used for
+     *  compatibility checking.
+     */
     def checkSubType(tp1: Type, tp2: Type)(using Context): Boolean = tp1 frozen_<:< tp2
 
-    /** A hook that allows to adjust the type of `member` and `other` before checking conformance.
+    /** A hook that allows to omit override checks between `overriding` and `overridden`.
      *  Overridden in capture checking to handle non-capture checked classes leniently.
      */
-    def adjustInfo(tp: Type, member: Symbol)(using Context): Type = tp
+    def needsCheck(overriding: Symbol, overridden: Symbol)(using Context): Boolean = true
 
     private val subtypeChecker: (Type, Type) => Context ?=> Boolean = this.checkSubType
 
     def checkAll(checkOverride: ((Type, Type) => Context ?=> Boolean, Symbol, Symbol) => Unit) =
       while hasNext do
-        checkOverride(subtypeChecker, overriding, overridden)
+        if needsCheck(overriding, overridden) then
+          checkOverride(subtypeChecker, overriding, overridden)
         next()
 
       // The OverridingPairs cursor does assume that concrete overrides abstract
@@ -371,8 +374,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 checker.adjustInfo(self.memberInfo(member), member)
-      def otherTp(self: Type) = checker.adjustInfo(self.memberInfo(other), other)
+        else self.memberInfo(member)
+      def otherTp(self: Type) = self.memberInfo(other)
 
       refcheck.println(i"check override ${infoString(member)} overriding ${infoString(other)}")