Simplify Synthetics.transform

No backward mapping is necessary anymore.

# Conflicts:
#	compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala

Author: odersky

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

@@ -42,7 +42,7 @@ object CheckCaptures:
         if sym.isAllOf(PrivateParamAccessor) && !sym.hasAnnotation(defn.ConstructorOnlyAnnot) then
           sym.copySymDenotation(initFlags = sym.flags &~ Private | Recheck.ResetPrivate)
         else if Synthetics.needsTransform(sym) then
-          Synthetics.transform(sym, toCC = true)
+          Synthetics.transform(sym)
         else sym
       else sym
   end Pre
@@ -203,11 +203,7 @@ class CheckCaptures extends Recheck, SymTransformer:
   override def run(using Context): Unit =
     if Feature.ccEnabled then
       super.run
-
-  override def transformSym(sym: SymDenotation)(using Context): SymDenotation =
-    if Synthetics.needsTransform(sym) then Synthetics.transform(sym, toCC = false)
-    else super.transformSym(sym)
-
+      
   override def printingContext(ctx: Context) = ctx.withProperty(ccStateKey, Some(new CCState))
 
   class CaptureChecker(ictx: Context) extends Rechecker(ictx):

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

@@ -61,7 +61,7 @@ object Synthetics:
    *  @param  sym  The method to transform @pre needsTransform(sym) must hold.
    *  @param  toCC Whether to transform the type to capture checking or back.
    */
-  def transform(sym: SymDenotation, toCC: Boolean)(using Context): SymDenotation =
+  def transform(sym: SymDenotation)(using Context): SymDenotation =
 
     /** Add capture dependencies to the type of the `apply` or `copy` method of a case class.
      *  An apply method in a case class like this:
@@ -92,31 +92,18 @@ object Synthetics:
       case _ =>
         info
 
-    /** Drop capture dependencies from the type of `apply` or `copy` method of a case class */
-    def dropCaptureDeps(tp: Type): Type = tp match
-      case tp: MethodOrPoly =>
-        tp.derivedLambdaType(resType = dropCaptureDeps(tp.resType))
-      case CapturingType(parent, _) =>
-        dropCaptureDeps(parent)
-      case RefinedType(parent, _, _) =>
-        dropCaptureDeps(parent)
-      case _ =>
-        tp
-
     /** Add capture information to the type of the default getter of a case class copy method
-     *  if toCC = true, or remove the added info again if toCC = false.
      */
     def transformDefaultGetterCaptures(info: Type, owner: Symbol, idx: Int)(using Context): Type = info match
       case info: MethodOrPoly =>
         info.derivedLambdaType(resType = transformDefaultGetterCaptures(info.resType, owner, idx))
       case info: ExprType =>
         info.derivedExprType(transformDefaultGetterCaptures(info.resType, owner, idx))
       case EventuallyCapturingType(parent, _) =>
-        if toCC then transformDefaultGetterCaptures(parent, owner, idx)
-        else parent
+        transformDefaultGetterCaptures(parent, owner, idx)
       case info @ AnnotatedType(parent, annot) =>
         info.derivedAnnotatedType(transformDefaultGetterCaptures(parent, owner, idx), annot)
-      case _ if toCC && idx < owner.asClass.paramGetters.length =>
+      case _ if idx < owner.asClass.paramGetters.length =>
         val param = owner.asClass.paramGetters(idx)
         val pinfo = param.info
         atPhase(ctx.phase.next) {
@@ -126,49 +113,29 @@ object Synthetics:
       case _ =>
         info
 
-    /** Augment an unapply of type `(x: C): D` to `(x: C^{cap}): D^{x}` if toCC is true,
-     *  or remove the added capture sets again if toCC = false.
-     */
+    /** Augment an unapply of type `(x: C): D` to `(x: C^{cap}): D^{x}` */
     def transformUnapplyCaptures(info: Type)(using Context): Type = info match
       case info: MethodType =>
-        if toCC then
-          val paramInfo :: Nil = info.paramInfos: @unchecked
-          val newParamInfo = CapturingType(paramInfo, CaptureSet.universal)
-          val trackedParam = info.paramRefs.head
-          def newResult(tp: Type): Type = tp match
-            case tp: MethodOrPoly =>
-              tp.derivedLambdaType(resType = newResult(tp.resType))
-            case _ =>
-              CapturingType(tp, CaptureSet(trackedParam))
-          info.derivedLambdaType(paramInfos = newParamInfo :: Nil, resType = newResult(info.resType))
-            .showing(i"augment unapply type $info to $result", capt)
-        else info.paramInfos match
-          case CapturingType(oldParamInfo, _) :: Nil =>
-            def oldResult(tp: Type): Type = tp match
-              case tp: MethodOrPoly =>
-                tp.derivedLambdaType(resType = oldResult(tp.resType))
-              case CapturingType(tp, _) =>
-                tp
-            info.derivedLambdaType(paramInfos = oldParamInfo :: Nil, resType = oldResult(info.resType))
+        val paramInfo :: Nil = info.paramInfos: @unchecked
+        val newParamInfo = CapturingType(paramInfo, CaptureSet.universal)
+        val trackedParam = info.paramRefs.head
+        def newResult(tp: Type): Type = tp match
+          case tp: MethodOrPoly =>
+            tp.derivedLambdaType(resType = newResult(tp.resType))
           case _ =>
-            info
+            CapturingType(tp, CaptureSet(trackedParam))
+        info.derivedLambdaType(paramInfos = newParamInfo :: Nil, resType = newResult(info.resType))
+          .showing(i"augment unapply type $info to $result", capt)
       case info: PolyType =>
         info.derivedLambdaType(resType = transformUnapplyCaptures(info.resType))
 
     def transformComposeCaptures(symd: SymDenotation) =
       val (pt: PolyType) = symd.info: @unchecked
       val (mt: MethodType) = pt.resType: @unchecked
       val (enclThis: ThisType) = symd.owner.thisType: @unchecked
-      val mt1 =
-        if toCC then
-          MethodType(mt.paramNames)(
-            mt1 => mt.paramInfos.map(_.capturing(CaptureSet.universal)),
-            mt1 => CapturingType(mt.resType, CaptureSet(enclThis, mt1.paramRefs.head)))
-        else
-          MethodType(mt.paramNames)(
-            mt1 => mt.paramInfos.map(_.stripCapturing),
-            mt1 => mt.resType.stripCapturing)
-      pt.derivedLambdaType(resType = mt1)
+      pt.derivedLambdaType(resType = MethodType(mt.paramNames)(
+        mt1 => mt.paramInfos.map(_.capturing(CaptureSet.universal)),
+        mt1 => CapturingType(mt.resType, CaptureSet(enclThis, mt1.paramRefs.head))))
 
     def transformCurriedTupledCaptures(symd: SymDenotation) =
       val (et: ExprType) = symd.info: @unchecked
@@ -179,26 +146,18 @@ object Synthetics:
           defn.FunctionOf(args, mapFinalResult(res, f), isContextual)
         else
           f(tp)
-      val resType1 =
-        if toCC then
-          mapFinalResult(et.resType, CapturingType(_, CaptureSet(enclThis)))
-        else
-          et.resType.stripCapturing
-      ExprType(resType1)
+      ExprType(mapFinalResult(et.resType, CapturingType(_, CaptureSet(enclThis))))
 
     def transformCompareCaptures =
-      if toCC then
-        MethodType(defn.ObjectType.capturing(CaptureSet.universal) :: Nil, defn.BooleanType)
-      else
-        defn.methOfAnyRef(defn.BooleanType)
+      MethodType(defn.ObjectType.capturing(CaptureSet.universal) :: Nil, defn.BooleanType)
 
     sym.copySymDenotation(info = sym.name match
       case DefaultGetterName(nme.copy, n) =>
         transformDefaultGetterCaptures(sym.info, sym.owner, n)
       case nme.unapply =>
         transformUnapplyCaptures(sym.info)
       case nme.apply | nme.copy =>
-        if toCC then addCaptureDeps(sym.info) else dropCaptureDeps(sym.info)
+        addCaptureDeps(sym.info)
       case nme.andThen | nme.compose =>
         transformComposeCaptures(sym)
       case nme.curried | nme.tupled =>