Special treatment of types of function members

Members

   andThen, compose, curried, tupled

of function types are now given special types for capture checking that
reflect fine-grained capture dependencies.

Author: odersky

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

@@ -10,8 +10,8 @@ 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.
+/** Classification and transformation methods for function methods and
+ *  synthetic case class methods that need to be treated specially.
  *  In particular, compute capturing types for some of these methods which
  *  have inferred (result-)types that need to be established under separate
  *  compilation.
@@ -27,6 +27,9 @@ object Synthetics:
     case DefaultGetterName(nme.copy, _) => sym.is(Synthetic) && sym.owner.isClass && sym.owner.is(Case)
     case _ => false
 
+  private val functionCombinatorNames = Set[Name](
+    nme.andThen, nme.compose, nme.curried, nme.tupled)
+
   /** Is `sym` a synthetic apply, copy, or copy default getter method?
    *  The types of these symbols are transformed in a special way without
    *  looking at the definitions's RHS
@@ -37,6 +40,7 @@ object Synthetics:
     || isSyntheticCopyDefaultGetterMethod(symd)
     || (symd.symbol eq defn.Object_eq)
     || (symd.symbol eq defn.Object_ne)
+    || defn.isFunctionClass(symd.owner) && functionCombinatorNames.contains(symd.name)
 
   /** Method is excluded from regular capture checking.
    *  Excluded are synthetic class members
@@ -156,6 +160,37 @@ object Synthetics:
     case info: PolyType =>
       info.derivedLambdaType(resType = dropUnapplyCaptures(info.resType))
 
+  private def transformComposeCaptures(symd: SymDenotation, toCC: Boolean)(using Context): Type =
+    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)
+
+  def transformCurriedTupledCaptures(symd: SymDenotation, toCC: Boolean)(using Context): Type =
+    val (et: ExprType) = symd.info: @unchecked
+    val (enclThis: ThisType) = symd.owner.thisType: @unchecked
+    def mapFinalResult(tp: Type, f: Type => Type): Type =
+      val defn.FunctionOf(args, res, isContextual) = tp: @unchecked
+      if defn.isFunctionNType(res) then
+        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)
+
   /** 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
@@ -168,6 +203,10 @@ object Synthetics:
       sym.copySymDenotation(info = addUnapplyCaptures(sym.info))
     case nme.apply | nme.copy =>
       sym.copySymDenotation(info = addCaptureDeps(sym.info))
+    case nme.andThen | nme.compose =>
+      sym.copySymDenotation(info = transformComposeCaptures(sym, toCC = true))
+    case nme.curried | nme.tupled =>
+      sym.copySymDenotation(info = transformCurriedTupledCaptures(sym, toCC = true))
     case n if n == nme.eq || n == nme.ne =>
       sym.copySymDenotation(info =
         MethodType(defn.ObjectType.capturing(CaptureSet.universal) :: Nil, defn.BooleanType))
@@ -183,6 +222,10 @@ object Synthetics:
       sym.copySymDenotation(info = dropUnapplyCaptures(sym.info))
     case nme.apply | nme.copy =>
       sym.copySymDenotation(info = dropCaptureDeps(sym.info))
+    case nme.andThen | nme.compose =>
+      sym.copySymDenotation(info = transformComposeCaptures(sym, toCC = false))
+    case nme.curried | nme.tupled =>
+      sym.copySymDenotation(info = transformCurriedTupledCaptures(sym, toCC = false))
     case n if n == nme.eq || n == nme.ne =>
       sym.copySymDenotation(info = defn.methOfAnyRef(defn.BooleanType))
 

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

@@ -395,6 +395,7 @@ object StdNames {
     val UNIT : N                = "UNIT"
     val acc: N                  = "acc"
     val adhocExtensions: N      = "adhocExtensions"
+    val andThen: N              = "andThen"
     val annotation: N           = "annotation"
     val any2stringadd: N        = "any2stringadd"
     val anyHash: N              = "anyHash"
@@ -443,11 +444,13 @@ object StdNames {
     val command: N              = "command"
     val common: N               = "common"
     val compiletime : N         = "compiletime"
+    val compose: N              = "compose"
     val conforms_ : N           = "$conforms"
     val contents: N             = "contents"
     val copy: N                 = "copy"
-    val currentMirror: N        = "currentMirror"
     val create: N               = "create"
+    val currentMirror: N        = "currentMirror"
+    val curried: N              = "curried"
     val definitions: N          = "definitions"
     val delayedInit: N          = "delayedInit"
     val delayedInitArg: N       = "delayedInit$body"
@@ -622,6 +625,7 @@ object StdNames {
     val transparent : N         = "transparent"
     val tree : N                = "tree"
     val true_ : N               = "true"
+    val tupled: N               = "tupled"
     val typedProductIterator: N = "typedProductIterator"
     val typeTagToManifest: N    = "typeTagToManifest"
     val unapply: N              = "unapply"

tests/pos-custom-args/captures/function-combinators.scala

@@ -0,0 +1,28 @@
+class ContextClass
+type Context = ContextClass^
+
+def Test(using ctx1: Context, ctx2: Context) =
+  val f: Int => Int = identity
+  val g1: Int ->{ctx1} Int = identity
+  val g2: Int ->{ctx2} Int = identity
+  val h: Int -> Int = identity
+  val a1 = f.andThen(f); val _: Int ->{f} Int = a1
+  val a2 = f.andThen(g1); val _: Int ->{f, g1} Int = a2
+  val a3 = f.andThen(g2); val _: Int ->{f, g2} Int = a3
+  val a4 = f.andThen(h); val _: Int ->{f} Int = a4
+  val b1 = g1.andThen(f); val _: Int ->{f, g1} Int = b1
+  val b2 = g1.andThen(g1); val _: Int ->{g1} Int = b2
+  val b3 = g1.andThen(g2); val _: Int ->{g1, g2} Int = b3
+  val b4 = g1.andThen(h); val _: Int ->{g1} Int = b4
+  val c1 = h.andThen(f); val _: Int ->{f} Int = c1
+  val c2 = h.andThen(g1); val _: Int ->{g1} Int = c2
+  val c3 = h.andThen(g2); val _: Int ->{g2} Int = c3
+  val c4 = h.andThen(h); val _: Int -> Int = c4
+
+  val f2: (Int, Int) => Int = _ + _
+  val f2c = f2.curried; val _: Int -> Int ->{f2} Int = f2c
+  val f2t = f2.tupled; val _: ((Int, Int)) ->{f2} Int = f2t
+
+  val f3: (Int, Int, Int) => Int = ???
+  val f3c = f3.curried; val _: Int -> Int -> Int ->{f3} Int = f3c
+  val f3t = f3.tupled; val _: ((Int, Int, Int)) ->{f3} Int = f3t

tests/pos-custom-args/captures/inlined-closure.scala

@@ -12,7 +12,3 @@ def Test(using ctx: Context) =
   info.paramRefs.filter(_.isTracked)
   val p = atPhase()((_: ParamRef).isTracked)
   val _: ParamRef ->{ctx} Boolean = p
-
-  //val f: String => ParamRef = ???
-  //val q = f.andThen(p)
-