Polish Synthetics.scala

Author: odersky

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

@@ -5,7 +5,10 @@ package cc
 import core.*
 import Symbols.*, SymDenotations.*, Contexts.*, Flags.*, Types.*, Decorators.*
 import StdNames.nme
+import Names.Name
 import NameKinds.DefaultGetterName
+import Phases.checkCapturesPhase
+import config.Printers.capt
 
 /** Classification and transformation methods for synthetic
  *  case class methods that need to be treated specially.
@@ -14,17 +17,14 @@ import NameKinds.DefaultGetterName
  *  compilation.
  */
 object Synthetics:
-  def isSyntheticCopyMethod(sym: SymDenotation)(using Context) =
+  private def isSyntheticCopyMethod(sym: SymDenotation)(using Context) =
     sym.name == nme.copy && sym.is(Synthetic) && sym.owner.isClass && sym.owner.is(Case)
 
-  def isSyntheticApplyMethod(sym: SymDenotation)(using Context) =
-    sym.name == nme.apply && sym.is(Synthetic) && sym.owner.is(Module) && sym.owner.companionClass.is(Case)
+  private def isSyntheticCompanionMethod(sym: SymDenotation, names: Name*)(using Context): Boolean =
+     names.contains(sym.name) && sym.is(Synthetic) && sym.owner.is(Module) && sym.owner.companionClass.is(Case)
 
-  def isSyntheticUnapplyMethod(sym: SymDenotation)(using Context) =
-    sym.name == nme.unapply && sym.is(Synthetic) && sym.owner.is(Module) && sym.owner.companionClass.is(Case)
-
-  def isSyntheticCopyDefaultGetterMethod(sym: SymDenotation)(using Context) = sym.name match
-    case DefaultGetterName(nme.copy, _) => sym.is(Synthetic)
+  private def isSyntheticCopyDefaultGetterMethod(sym: SymDenotation)(using Context) = sym.name match
+    case DefaultGetterName(nme.copy, _) => sym.is(Synthetic) && sym.owner.isClass && sym.owner.is(Case)
     case _ => false
 
   /** Is `sym` a synthetic apply, copy, or copy default getter method?
@@ -33,8 +33,7 @@ object Synthetics:
    */
   def needsTransform(sym: SymDenotation)(using Context): Boolean =
     isSyntheticCopyMethod(sym)
-    || isSyntheticApplyMethod(sym)
-    || isSyntheticUnapplyMethod(sym)
+    || isSyntheticCompanionMethod(sym, nme.apply, nme.unapply)
     || isSyntheticCopyDefaultGetterMethod(sym)
 
   /** Method is excluded from regular capture checking.
@@ -48,14 +47,20 @@ object Synthetics:
     && sym.owner.isClass
     && ( defn.caseClassSynthesized.exists(
              ccsym => sym.overriddenSymbol(ccsym.owner.asClass) == ccsym)
-        || sym.name == nme.fromProduct
-        || needsTransform(sym)
-      )
-
-  /** Add capture dependencies to the type of `apply` or `copy` method of a case class */
+        || isSyntheticCompanionMethod(sym, nme.fromProduct)
+        || needsTransform(sym))
+
+  /** 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:
+   *    case class CC(a: {d} A, b: B, {*} c: C)
+   *  would get type
+   *    def apply(a': {d} A, b: B, {*} c': C): {a', c'} CC { val a = {a'} A, val c = {c'} C }
+   *  where `'` is used to indicate the difference between parameter symbol and refinement name.
+   *  Analogous for the copy method.
+   */
   private def addCaptureDeps(info: Type)(using Context): Type = info match
     case info: MethodType =>
-      val trackedParams = info.paramRefs.filter(atPhase(ctx.phase.next)(_.isTracked))
+      val trackedParams = info.paramRefs.filter(atPhase(checkCapturesPhase)(_.isTracked))
       def augmentResult(tp: Type): Type = tp match
         case tp: MethodOrPoly =>
           tp.derivedLambdaType(resType = augmentResult(tp.resType))
@@ -67,7 +72,8 @@ object Synthetics:
                 CaptureSet(pref)))
           }
           CapturingType(refined, CaptureSet(trackedParams*))
-      if trackedParams.isEmpty then info else augmentResult(info)
+      if trackedParams.isEmpty then info
+      else augmentResult(info).showing(i"augment apply/copy type $info to $result", capt)
     case info: PolyType =>
       info.derivedLambdaType(resType = addCaptureDeps(info.resType))
     case _ =>
@@ -115,6 +121,7 @@ object Synthetics:
     case _ =>
       info
 
+  /** Augment an unapply of type `(x: C): D` to `(x: {*} C): {x} D` */
   private def addUnapplyCaptures(info: Type)(using Context): Type = info match
     case info: MethodType =>
       val paramInfo :: Nil = info.paramInfos: @unchecked
@@ -127,9 +134,11 @@ object Synthetics:
         case _ =>
           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 = addUnapplyCaptures(info.resType))
 
+  /** Drop added capture information from the type of an `unapply` */
   private def dropUnapplyCaptures(info: Type)(using Context): Type = info match
     case info: MethodType =>
       val CapturingType(oldParamInfo, _) :: Nil = info.paramInfos: @unchecked
@@ -142,28 +151,30 @@ object Synthetics:
     case info: PolyType =>
       info.derivedLambdaType(resType = dropUnapplyCaptures(info.resType))
 
-  /** If `sym` refers to a synthetic apply, copy, or copy default getter method
+  /** If `sym` refers to a synthetic apply, unapply, copy, or copy default getter method
    *  of a case class, transform it to account for capture information.
+   *  The method is run in phase CheckCaptures.Pre
    *  @pre needsTransform(sym)
    */
   def transformToCC(sym: SymDenotation)(using Context): SymDenotation = sym.name match
-    case DefaultGetterName(nme.copy, n) if sym.is(Synthetic) && sym.owner.is(Case) =>
+    case DefaultGetterName(nme.copy, n) =>
       sym.copySymDenotation(info = addDefaultGetterCapture(sym.info, sym.owner, n))
     case nme.unapply =>
       sym.copySymDenotation(info = addUnapplyCaptures(sym.info))
-    case _ =>
+    case nme.apply | nme.copy =>
       sym.copySymDenotation(info = addCaptureDeps(sym.info))
 
-  /** If `sym` refers to a synthetic apply, copy, or copy default getter method
+
+  /** If `sym` refers to a synthetic apply, unapply, copy, or copy default getter method
    *  of a case class, transform it back to what it was before the CC phase.
    *  @pre needsTransform(sym)
    */
-  def transformFromCC(sym: SymDenotation)(using Context): SymDenotation =
-    if isSyntheticCopyDefaultGetterMethod(sym) then
+  def transformFromCC(sym: SymDenotation)(using Context): SymDenotation = sym.name match
+    case DefaultGetterName(nme.copy, n) =>
       sym.copySymDenotation(info = dropDefaultGetterCapture(sym.info))
-    else if sym.name == nme.unapply then
+    case nme.unapply =>
       sym.copySymDenotation(info = dropUnapplyCaptures(sym.info))
-    else
+    case nme.apply | nme.copy =>
       sym.copySymDenotation(info = dropCaptureDeps(sym.info))
 
 end Synthetics