module Exitify ( exitifyProgram ) where

{-
Note [Exitification]
~~~~~~~~~~~~~~~~~~~~

This module implements Exitification. The goal is to pull as much code out of
recursive functions as possible, as the simplifier is better at inlining into
call-sites that are not in recursive functions.

Example:

  let t = foo bar
  joinrec go 0     x y = t (x*x)
          go (n-1) x y = jump go (n-1) (x+y)
  in …

We’d like to inline `t`, but that does not happen: Because t is a thunk and is
used in a recursive function, doing so might lose sharing in general. In
this case, however, `t` is on the _exit path_ of `go`, so called at most once.
How do we make this clearly visible to the simplifier?

A code path (i.e., an expression in a tail-recursive position) in a recursive
function is an exit path if it does not contain a recursive call. We can bind
this expression outside the recursive function, as a join-point.

Example result:

  let t = foo bar
  join exit x = t (x*x)
  joinrec go 0     x y = jump exit x
          go (n-1) x y = jump go (n-1) (x+y)
  in …

Now `t` is no longer in a recursive function, and good things happen!
-}

import GhcPrelude
import Var
import Id
import IdInfo
import CoreSyn
import CoreUtils
import State
import Unique
import VarSet
import VarEnv
import CoreFVs
import FastString
import Type
import Util( mapSnd )

import Data.Bifunctor
import Control.Monad

-- | Traverses the AST, simply to find all joinrecs and call 'exitify' on them.
-- The really interesting function is exitifyRec
exitifyProgram :: CoreProgram -> CoreProgram
exitifyProgram :: CoreProgram -> CoreProgram
exitifyProgram CoreProgram
binds = (Bind CoreBndr -> Bind CoreBndr) -> CoreProgram -> CoreProgram
forall a b. (a -> b) -> [a] -> [b]
map Bind CoreBndr -> Bind CoreBndr
goTopLvl CoreProgram
binds
  where
    goTopLvl :: Bind CoreBndr -> Bind CoreBndr
goTopLvl (NonRec CoreBndr
v Expr CoreBndr
e) = CoreBndr -> Expr CoreBndr -> Bind CoreBndr
forall b. b -> Expr b -> Bind b
NonRec CoreBndr
v (InScopeSet -> Expr CoreBndr -> Expr CoreBndr
go InScopeSet
in_scope_toplvl Expr CoreBndr
e)
    goTopLvl (Rec [(CoreBndr, Expr CoreBndr)]
pairs) = [(CoreBndr, Expr CoreBndr)] -> Bind CoreBndr
forall b. [(b, Expr b)] -> Bind b
Rec (((CoreBndr, Expr CoreBndr) -> (CoreBndr, Expr CoreBndr))
-> [(CoreBndr, Expr CoreBndr)] -> [(CoreBndr, Expr CoreBndr)]
forall a b. (a -> b) -> [a] -> [b]
map ((Expr CoreBndr -> Expr CoreBndr)
-> (CoreBndr, Expr CoreBndr) -> (CoreBndr, Expr CoreBndr)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second (InScopeSet -> Expr CoreBndr -> Expr CoreBndr
go InScopeSet
in_scope_toplvl)) [(CoreBndr, Expr CoreBndr)]
pairs)
      -- Top-level bindings are never join points

    in_scope_toplvl :: InScopeSet
in_scope_toplvl = InScopeSet
emptyInScopeSet InScopeSet -> [CoreBndr] -> InScopeSet
`extendInScopeSetList` CoreProgram -> [CoreBndr]
forall b. [Bind b] -> [b]
bindersOfBinds CoreProgram
binds

    go :: InScopeSet -> CoreExpr -> CoreExpr
    go :: InScopeSet -> Expr CoreBndr -> Expr CoreBndr
go InScopeSet
_    e :: Expr CoreBndr
e@(Var{})       = Expr CoreBndr
e
    go InScopeSet
_    e :: Expr CoreBndr
e@(Lit {})      = Expr CoreBndr
e
    go InScopeSet
_    e :: Expr CoreBndr
e@(Type {})     = Expr CoreBndr
e
    go InScopeSet
_    e :: Expr CoreBndr
e@(Coercion {}) = Expr CoreBndr
e
    go InScopeSet
in_scope (Cast Expr CoreBndr
e' Coercion
c) = Expr CoreBndr -> Coercion -> Expr CoreBndr
forall b. Expr b -> Coercion -> Expr b
Cast (InScopeSet -> Expr CoreBndr -> Expr CoreBndr
go InScopeSet
in_scope Expr CoreBndr
e') Coercion
c
    go InScopeSet
in_scope (Tick Tickish CoreBndr
t Expr CoreBndr
e') = Tickish CoreBndr -> Expr CoreBndr -> Expr CoreBndr
forall b. Tickish CoreBndr -> Expr b -> Expr b
Tick Tickish CoreBndr
t (InScopeSet -> Expr CoreBndr -> Expr CoreBndr
go InScopeSet
in_scope Expr CoreBndr
e')
    go InScopeSet
in_scope (App Expr CoreBndr
e1 Expr CoreBndr
e2) = Expr CoreBndr -> Expr CoreBndr -> Expr CoreBndr
forall b. Expr b -> Expr b -> Expr b
App (InScopeSet -> Expr CoreBndr -> Expr CoreBndr
go InScopeSet
in_scope Expr CoreBndr
e1) (InScopeSet -> Expr CoreBndr -> Expr CoreBndr
go InScopeSet
in_scope Expr CoreBndr
e2)

    go InScopeSet
in_scope (Lam CoreBndr
v Expr CoreBndr
e')
      = CoreBndr -> Expr CoreBndr -> Expr CoreBndr
forall b. b -> Expr b -> Expr b
Lam CoreBndr
v (InScopeSet -> Expr CoreBndr -> Expr CoreBndr
go InScopeSet
in_scope' Expr CoreBndr
e')
      where in_scope' :: InScopeSet
in_scope' = InScopeSet
in_scope InScopeSet -> CoreBndr -> InScopeSet
`extendInScopeSet` CoreBndr
v

    go InScopeSet
in_scope (Case Expr CoreBndr
scrut CoreBndr
bndr Type
ty [Alt CoreBndr]
alts)
      = Expr CoreBndr
-> CoreBndr -> Type -> [Alt CoreBndr] -> Expr CoreBndr
forall b. Expr b -> b -> Type -> [Alt b] -> Expr b
Case (InScopeSet -> Expr CoreBndr -> Expr CoreBndr
go InScopeSet
in_scope Expr CoreBndr
scrut) CoreBndr
bndr Type
ty ((Alt CoreBndr -> Alt CoreBndr) -> [Alt CoreBndr] -> [Alt CoreBndr]
forall a b. (a -> b) -> [a] -> [b]
map Alt CoreBndr -> Alt CoreBndr
forall a.
(a, [CoreBndr], Expr CoreBndr) -> (a, [CoreBndr], Expr CoreBndr)
go_alt [Alt CoreBndr]
alts)
      where
        in_scope1 :: InScopeSet
in_scope1 = InScopeSet
in_scope InScopeSet -> CoreBndr -> InScopeSet
`extendInScopeSet` CoreBndr
bndr
        go_alt :: (a, [CoreBndr], Expr CoreBndr) -> (a, [CoreBndr], Expr CoreBndr)
go_alt (a
dc, [CoreBndr]
pats, Expr CoreBndr
rhs) = (a
dc, [CoreBndr]
pats, InScopeSet -> Expr CoreBndr -> Expr CoreBndr
go InScopeSet
in_scope' Expr CoreBndr
rhs)
           where in_scope' :: InScopeSet
in_scope' = InScopeSet
in_scope1 InScopeSet -> [CoreBndr] -> InScopeSet
`extendInScopeSetList` [CoreBndr]
pats

    go InScopeSet
in_scope (Let (NonRec CoreBndr
bndr Expr CoreBndr
rhs) Expr CoreBndr
body)
      = Bind CoreBndr -> Expr CoreBndr -> Expr CoreBndr
forall b. Bind b -> Expr b -> Expr b
Let (CoreBndr -> Expr CoreBndr -> Bind CoreBndr
forall b. b -> Expr b -> Bind b
NonRec CoreBndr
bndr (InScopeSet -> Expr CoreBndr -> Expr CoreBndr
go InScopeSet
in_scope Expr CoreBndr
rhs)) (InScopeSet -> Expr CoreBndr -> Expr CoreBndr
go InScopeSet
in_scope' Expr CoreBndr
body)
      where
        in_scope' :: InScopeSet
in_scope' = InScopeSet
in_scope InScopeSet -> CoreBndr -> InScopeSet
`extendInScopeSet` CoreBndr
bndr

    go InScopeSet
in_scope (Let (Rec [(CoreBndr, Expr CoreBndr)]
pairs) Expr CoreBndr
body)
      | Bool
is_join_rec = CoreProgram -> Expr CoreBndr -> Expr CoreBndr
forall b. [Bind b] -> Expr b -> Expr b
mkLets (InScopeSet -> [(CoreBndr, Expr CoreBndr)] -> CoreProgram
exitifyRec InScopeSet
in_scope' [(CoreBndr, Expr CoreBndr)]
pairs') Expr CoreBndr
body'
      | Bool
otherwise   = Bind CoreBndr -> Expr CoreBndr -> Expr CoreBndr
forall b. Bind b -> Expr b -> Expr b
Let ([(CoreBndr, Expr CoreBndr)] -> Bind CoreBndr
forall b. [(b, Expr b)] -> Bind b
Rec [(CoreBndr, Expr CoreBndr)]
pairs') Expr CoreBndr
body'
      where
        is_join_rec :: Bool
is_join_rec = ((CoreBndr, Expr CoreBndr) -> Bool)
-> [(CoreBndr, Expr CoreBndr)] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (CoreBndr -> Bool
isJoinId (CoreBndr -> Bool)
-> ((CoreBndr, Expr CoreBndr) -> CoreBndr)
-> (CoreBndr, Expr CoreBndr)
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CoreBndr, Expr CoreBndr) -> CoreBndr
forall a b. (a, b) -> a
fst) [(CoreBndr, Expr CoreBndr)]
pairs
        in_scope' :: InScopeSet
in_scope'   = InScopeSet
in_scope InScopeSet -> [CoreBndr] -> InScopeSet
`extendInScopeSetList` Bind CoreBndr -> [CoreBndr]
forall b. Bind b -> [b]
bindersOf ([(CoreBndr, Expr CoreBndr)] -> Bind CoreBndr
forall b. [(b, Expr b)] -> Bind b
Rec [(CoreBndr, Expr CoreBndr)]
pairs)
        pairs' :: [(CoreBndr, Expr CoreBndr)]
pairs'      = (Expr CoreBndr -> Expr CoreBndr)
-> [(CoreBndr, Expr CoreBndr)] -> [(CoreBndr, Expr CoreBndr)]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSnd (InScopeSet -> Expr CoreBndr -> Expr CoreBndr
go InScopeSet
in_scope') [(CoreBndr, Expr CoreBndr)]
pairs
        body' :: Expr CoreBndr
body'       = InScopeSet -> Expr CoreBndr -> Expr CoreBndr
go InScopeSet
in_scope' Expr CoreBndr
body


-- | State Monad used inside `exitify`
type ExitifyM =  State [(JoinId, CoreExpr)]

-- | Given a recursive group of a joinrec, identifies “exit paths” and binds them as
--   join-points outside the joinrec.
exitifyRec :: InScopeSet -> [(Var,CoreExpr)] -> [CoreBind]
exitifyRec :: InScopeSet -> [(CoreBndr, Expr CoreBndr)] -> CoreProgram
exitifyRec InScopeSet
in_scope [(CoreBndr, Expr CoreBndr)]
pairs
  = [ CoreBndr -> Expr CoreBndr -> Bind CoreBndr
forall b. b -> Expr b -> Bind b
NonRec CoreBndr
xid Expr CoreBndr
rhs | (CoreBndr
xid,Expr CoreBndr
rhs) <- [(CoreBndr, Expr CoreBndr)]
exits ] CoreProgram -> CoreProgram -> CoreProgram
forall a. [a] -> [a] -> [a]
++ [[(CoreBndr, Expr CoreBndr)] -> Bind CoreBndr
forall b. [(b, Expr b)] -> Bind b
Rec [(CoreBndr, Expr CoreBndr)]
pairs']
  where
    -- We need the set of free variables of many subexpressions here, so
    -- annotate the AST with them
    -- see Note [Calculating free variables]
    ann_pairs :: [(CoreBndr, CoreExprWithFVs)]
ann_pairs = ((CoreBndr, Expr CoreBndr) -> (CoreBndr, CoreExprWithFVs))
-> [(CoreBndr, Expr CoreBndr)] -> [(CoreBndr, CoreExprWithFVs)]
forall a b. (a -> b) -> [a] -> [b]
map ((Expr CoreBndr -> CoreExprWithFVs)
-> (CoreBndr, Expr CoreBndr) -> (CoreBndr, CoreExprWithFVs)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second Expr CoreBndr -> CoreExprWithFVs
freeVars) [(CoreBndr, Expr CoreBndr)]
pairs

    -- Which are the recursive calls?
    recursive_calls :: VarSet
recursive_calls = [CoreBndr] -> VarSet
mkVarSet ([CoreBndr] -> VarSet) -> [CoreBndr] -> VarSet
forall a b. (a -> b) -> a -> b
$ ((CoreBndr, Expr CoreBndr) -> CoreBndr)
-> [(CoreBndr, Expr CoreBndr)] -> [CoreBndr]
forall a b. (a -> b) -> [a] -> [b]
map (CoreBndr, Expr CoreBndr) -> CoreBndr
forall a b. (a, b) -> a
fst [(CoreBndr, Expr CoreBndr)]
pairs

    ([(CoreBndr, Expr CoreBndr)]
pairs',[(CoreBndr, Expr CoreBndr)]
exits) = (State [(CoreBndr, Expr CoreBndr)] [(CoreBndr, Expr CoreBndr)]
-> [(CoreBndr, Expr CoreBndr)]
-> ([(CoreBndr, Expr CoreBndr)], [(CoreBndr, Expr CoreBndr)])
forall s a. State s a -> s -> (a, s)
`runState` []) (State [(CoreBndr, Expr CoreBndr)] [(CoreBndr, Expr CoreBndr)]
 -> ([(CoreBndr, Expr CoreBndr)], [(CoreBndr, Expr CoreBndr)]))
-> State [(CoreBndr, Expr CoreBndr)] [(CoreBndr, Expr CoreBndr)]
-> ([(CoreBndr, Expr CoreBndr)], [(CoreBndr, Expr CoreBndr)])
forall a b. (a -> b) -> a -> b
$ do
        [(CoreBndr, CoreExprWithFVs)]
-> ((CoreBndr, CoreExprWithFVs)
    -> State [(CoreBndr, Expr CoreBndr)] (CoreBndr, Expr CoreBndr))
-> State [(CoreBndr, Expr CoreBndr)] [(CoreBndr, Expr CoreBndr)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [(CoreBndr, CoreExprWithFVs)]
ann_pairs (((CoreBndr, CoreExprWithFVs)
  -> State [(CoreBndr, Expr CoreBndr)] (CoreBndr, Expr CoreBndr))
 -> State [(CoreBndr, Expr CoreBndr)] [(CoreBndr, Expr CoreBndr)])
-> ((CoreBndr, CoreExprWithFVs)
    -> State [(CoreBndr, Expr CoreBndr)] (CoreBndr, Expr CoreBndr))
-> State [(CoreBndr, Expr CoreBndr)] [(CoreBndr, Expr CoreBndr)]
forall a b. (a -> b) -> a -> b
$ \(CoreBndr
x,CoreExprWithFVs
rhs) -> do
            -- go past the lambdas of the join point
            let ([CoreBndr]
args, CoreExprWithFVs
body) = Int -> CoreExprWithFVs -> ([CoreBndr], CoreExprWithFVs)
forall bndr annot.
Int -> AnnExpr bndr annot -> ([bndr], AnnExpr bndr annot)
collectNAnnBndrs (CoreBndr -> Int
idJoinArity CoreBndr
x) CoreExprWithFVs
rhs
            Expr CoreBndr
body' <- [CoreBndr] -> CoreExprWithFVs -> ExitifyM (Expr CoreBndr)
go [CoreBndr]
args CoreExprWithFVs
body
            let rhs' :: Expr CoreBndr
rhs' = [CoreBndr] -> Expr CoreBndr -> Expr CoreBndr
forall b. [b] -> Expr b -> Expr b
mkLams [CoreBndr]
args Expr CoreBndr
body'
            (CoreBndr, Expr CoreBndr)
-> State [(CoreBndr, Expr CoreBndr)] (CoreBndr, Expr CoreBndr)
forall (m :: * -> *) a. Monad m => a -> m a
return (CoreBndr
x, Expr CoreBndr
rhs')

    ---------------------
    -- 'go' is the main working function.
    -- It goes through the RHS (tail-call positions only),
    -- checks if there are no more recursive calls, if so, abstracts over
    -- variables bound on the way and lifts it out as a join point.
    --
    -- ExitifyM is a state monad to keep track of floated binds
    go :: [Var]           -- ^ Variables that are in-scope here, but
                          -- not in scope at the joinrec; that is,
                          -- we must potentially abstract over them.
                          -- Invariant: they are kept in dependency order
       -> CoreExprWithFVs -- ^ Current expression in tail position
       -> ExitifyM CoreExpr

    -- We first look at the expression (no matter what it shape is)
    -- and determine if we can turn it into a exit join point
    go :: [CoreBndr] -> CoreExprWithFVs -> ExitifyM (Expr CoreBndr)
go [CoreBndr]
captured CoreExprWithFVs
ann_e
        | -- An exit expression has no recursive calls
          let fvs :: VarSet
fvs = DVarSet -> VarSet
dVarSetToVarSet (CoreExprWithFVs -> DVarSet
freeVarsOf CoreExprWithFVs
ann_e)
        , VarSet -> VarSet -> Bool
disjointVarSet VarSet
fvs VarSet
recursive_calls
        = [CoreBndr] -> Expr CoreBndr -> VarSet -> ExitifyM (Expr CoreBndr)
go_exit [CoreBndr]
captured (CoreExprWithFVs -> Expr CoreBndr
forall bndr annot. AnnExpr bndr annot -> Expr bndr
deAnnotate CoreExprWithFVs
ann_e) VarSet
fvs

    -- We could not turn it into a exit joint point. So now recurse
    -- into all expression where eligible exit join points might sit,
    -- i.e. into all tail-call positions:

    -- Case right hand sides are in tail-call position
    go [CoreBndr]
captured (DVarSet
_, AnnCase CoreExprWithFVs
scrut CoreBndr
bndr Type
ty [AnnAlt CoreBndr DVarSet]
alts) = do
        [Alt CoreBndr]
alts' <- [AnnAlt CoreBndr DVarSet]
-> (AnnAlt CoreBndr DVarSet
    -> State [(CoreBndr, Expr CoreBndr)] (Alt CoreBndr))
-> State [(CoreBndr, Expr CoreBndr)] [Alt CoreBndr]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [AnnAlt CoreBndr DVarSet]
alts ((AnnAlt CoreBndr DVarSet
  -> State [(CoreBndr, Expr CoreBndr)] (Alt CoreBndr))
 -> State [(CoreBndr, Expr CoreBndr)] [Alt CoreBndr])
-> (AnnAlt CoreBndr DVarSet
    -> State [(CoreBndr, Expr CoreBndr)] (Alt CoreBndr))
-> State [(CoreBndr, Expr CoreBndr)] [Alt CoreBndr]
forall a b. (a -> b) -> a -> b
$ \(AltCon
dc, [CoreBndr]
pats, CoreExprWithFVs
rhs) -> do
            Expr CoreBndr
rhs' <- [CoreBndr] -> CoreExprWithFVs -> ExitifyM (Expr CoreBndr)
go ([CoreBndr]
captured [CoreBndr] -> [CoreBndr] -> [CoreBndr]
forall a. [a] -> [a] -> [a]
++ [CoreBndr
bndr] [CoreBndr] -> [CoreBndr] -> [CoreBndr]
forall a. [a] -> [a] -> [a]
++ [CoreBndr]
pats) CoreExprWithFVs
rhs
            Alt CoreBndr -> State [(CoreBndr, Expr CoreBndr)] (Alt CoreBndr)
forall (m :: * -> *) a. Monad m => a -> m a
return (AltCon
dc, [CoreBndr]
pats, Expr CoreBndr
rhs')
        Expr CoreBndr -> ExitifyM (Expr CoreBndr)
forall (m :: * -> *) a. Monad m => a -> m a
return (Expr CoreBndr -> ExitifyM (Expr CoreBndr))
-> Expr CoreBndr -> ExitifyM (Expr CoreBndr)
forall a b. (a -> b) -> a -> b
$ Expr CoreBndr
-> CoreBndr -> Type -> [Alt CoreBndr] -> Expr CoreBndr
forall b. Expr b -> b -> Type -> [Alt b] -> Expr b
Case (CoreExprWithFVs -> Expr CoreBndr
forall bndr annot. AnnExpr bndr annot -> Expr bndr
deAnnotate CoreExprWithFVs
scrut) CoreBndr
bndr Type
ty [Alt CoreBndr]
alts'

    go [CoreBndr]
captured (DVarSet
_, AnnLet AnnBind CoreBndr DVarSet
ann_bind CoreExprWithFVs
body)
        -- join point, RHS and body are in tail-call position
        | AnnNonRec CoreBndr
j CoreExprWithFVs
rhs <- AnnBind CoreBndr DVarSet
ann_bind
        , Just Int
join_arity <- CoreBndr -> Maybe Int
isJoinId_maybe CoreBndr
j
        = do let ([CoreBndr]
params, CoreExprWithFVs
join_body) = Int -> CoreExprWithFVs -> ([CoreBndr], CoreExprWithFVs)
forall bndr annot.
Int -> AnnExpr bndr annot -> ([bndr], AnnExpr bndr annot)
collectNAnnBndrs Int
join_arity CoreExprWithFVs
rhs
             Expr CoreBndr
join_body' <- [CoreBndr] -> CoreExprWithFVs -> ExitifyM (Expr CoreBndr)
go ([CoreBndr]
captured [CoreBndr] -> [CoreBndr] -> [CoreBndr]
forall a. [a] -> [a] -> [a]
++ [CoreBndr]
params) CoreExprWithFVs
join_body
             let rhs' :: Expr CoreBndr
rhs' = [CoreBndr] -> Expr CoreBndr -> Expr CoreBndr
forall b. [b] -> Expr b -> Expr b
mkLams [CoreBndr]
params Expr CoreBndr
join_body'
             Expr CoreBndr
body' <- [CoreBndr] -> CoreExprWithFVs -> ExitifyM (Expr CoreBndr)
go ([CoreBndr]
captured [CoreBndr] -> [CoreBndr] -> [CoreBndr]
forall a. [a] -> [a] -> [a]
++ [CoreBndr
j]) CoreExprWithFVs
body
             Expr CoreBndr -> ExitifyM (Expr CoreBndr)
forall (m :: * -> *) a. Monad m => a -> m a
return (Expr CoreBndr -> ExitifyM (Expr CoreBndr))
-> Expr CoreBndr -> ExitifyM (Expr CoreBndr)
forall a b. (a -> b) -> a -> b
$ Bind CoreBndr -> Expr CoreBndr -> Expr CoreBndr
forall b. Bind b -> Expr b -> Expr b
Let (CoreBndr -> Expr CoreBndr -> Bind CoreBndr
forall b. b -> Expr b -> Bind b
NonRec CoreBndr
j Expr CoreBndr
rhs') Expr CoreBndr
body'

        -- rec join point, RHSs and body are in tail-call position
        | AnnRec [(CoreBndr, CoreExprWithFVs)]
pairs <- AnnBind CoreBndr DVarSet
ann_bind
        , CoreBndr -> Bool
isJoinId ((CoreBndr, CoreExprWithFVs) -> CoreBndr
forall a b. (a, b) -> a
fst ([(CoreBndr, CoreExprWithFVs)] -> (CoreBndr, CoreExprWithFVs)
forall a. [a] -> a
head [(CoreBndr, CoreExprWithFVs)]
pairs))
        = do let js :: [CoreBndr]
js = ((CoreBndr, CoreExprWithFVs) -> CoreBndr)
-> [(CoreBndr, CoreExprWithFVs)] -> [CoreBndr]
forall a b. (a -> b) -> [a] -> [b]
map (CoreBndr, CoreExprWithFVs) -> CoreBndr
forall a b. (a, b) -> a
fst [(CoreBndr, CoreExprWithFVs)]
pairs
             [(CoreBndr, Expr CoreBndr)]
pairs' <- [(CoreBndr, CoreExprWithFVs)]
-> ((CoreBndr, CoreExprWithFVs)
    -> State [(CoreBndr, Expr CoreBndr)] (CoreBndr, Expr CoreBndr))
-> State [(CoreBndr, Expr CoreBndr)] [(CoreBndr, Expr CoreBndr)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [(CoreBndr, CoreExprWithFVs)]
pairs (((CoreBndr, CoreExprWithFVs)
  -> State [(CoreBndr, Expr CoreBndr)] (CoreBndr, Expr CoreBndr))
 -> State [(CoreBndr, Expr CoreBndr)] [(CoreBndr, Expr CoreBndr)])
-> ((CoreBndr, CoreExprWithFVs)
    -> State [(CoreBndr, Expr CoreBndr)] (CoreBndr, Expr CoreBndr))
-> State [(CoreBndr, Expr CoreBndr)] [(CoreBndr, Expr CoreBndr)]
forall a b. (a -> b) -> a -> b
$ \(CoreBndr
j,CoreExprWithFVs
rhs) -> do
                 let join_arity :: Int
join_arity = CoreBndr -> Int
idJoinArity CoreBndr
j
                     ([CoreBndr]
params, CoreExprWithFVs
join_body) = Int -> CoreExprWithFVs -> ([CoreBndr], CoreExprWithFVs)
forall bndr annot.
Int -> AnnExpr bndr annot -> ([bndr], AnnExpr bndr annot)
collectNAnnBndrs Int
join_arity CoreExprWithFVs
rhs
                 Expr CoreBndr
join_body' <- [CoreBndr] -> CoreExprWithFVs -> ExitifyM (Expr CoreBndr)
go ([CoreBndr]
captured [CoreBndr] -> [CoreBndr] -> [CoreBndr]
forall a. [a] -> [a] -> [a]
++ [CoreBndr]
js [CoreBndr] -> [CoreBndr] -> [CoreBndr]
forall a. [a] -> [a] -> [a]
++ [CoreBndr]
params) CoreExprWithFVs
join_body
                 let rhs' :: Expr CoreBndr
rhs' = [CoreBndr] -> Expr CoreBndr -> Expr CoreBndr
forall b. [b] -> Expr b -> Expr b
mkLams [CoreBndr]
params Expr CoreBndr
join_body'
                 (CoreBndr, Expr CoreBndr)
-> State [(CoreBndr, Expr CoreBndr)] (CoreBndr, Expr CoreBndr)
forall (m :: * -> *) a. Monad m => a -> m a
return (CoreBndr
j, Expr CoreBndr
rhs')
             Expr CoreBndr
body' <- [CoreBndr] -> CoreExprWithFVs -> ExitifyM (Expr CoreBndr)
go ([CoreBndr]
captured [CoreBndr] -> [CoreBndr] -> [CoreBndr]
forall a. [a] -> [a] -> [a]
++ [CoreBndr]
js) CoreExprWithFVs
body
             Expr CoreBndr -> ExitifyM (Expr CoreBndr)
forall (m :: * -> *) a. Monad m => a -> m a
return (Expr CoreBndr -> ExitifyM (Expr CoreBndr))
-> Expr CoreBndr -> ExitifyM (Expr CoreBndr)
forall a b. (a -> b) -> a -> b
$ Bind CoreBndr -> Expr CoreBndr -> Expr CoreBndr
forall b. Bind b -> Expr b -> Expr b
Let ([(CoreBndr, Expr CoreBndr)] -> Bind CoreBndr
forall b. [(b, Expr b)] -> Bind b
Rec [(CoreBndr, Expr CoreBndr)]
pairs') Expr CoreBndr
body'

        -- normal Let, only the body is in tail-call position
        | Bool
otherwise
        = do Expr CoreBndr
body' <- [CoreBndr] -> CoreExprWithFVs -> ExitifyM (Expr CoreBndr)
go ([CoreBndr]
captured [CoreBndr] -> [CoreBndr] -> [CoreBndr]
forall a. [a] -> [a] -> [a]
++ Bind CoreBndr -> [CoreBndr]
forall b. Bind b -> [b]
bindersOf Bind CoreBndr
bind ) CoreExprWithFVs
body
             Expr CoreBndr -> ExitifyM (Expr CoreBndr)
forall (m :: * -> *) a. Monad m => a -> m a
return (Expr CoreBndr -> ExitifyM (Expr CoreBndr))
-> Expr CoreBndr -> ExitifyM (Expr CoreBndr)
forall a b. (a -> b) -> a -> b
$ Bind CoreBndr -> Expr CoreBndr -> Expr CoreBndr
forall b. Bind b -> Expr b -> Expr b
Let Bind CoreBndr
bind Expr CoreBndr
body'
      where bind :: Bind CoreBndr
bind = AnnBind CoreBndr DVarSet -> Bind CoreBndr
forall b annot. AnnBind b annot -> Bind b
deAnnBind AnnBind CoreBndr DVarSet
ann_bind

    -- Cannot be turned into an exit join point, but also has no
    -- tail-call subexpression. Nothing to do here.
    go [CoreBndr]
_ CoreExprWithFVs
ann_e = Expr CoreBndr -> ExitifyM (Expr CoreBndr)
forall (m :: * -> *) a. Monad m => a -> m a
return (CoreExprWithFVs -> Expr CoreBndr
forall bndr annot. AnnExpr bndr annot -> Expr bndr
deAnnotate CoreExprWithFVs
ann_e)

    ---------------------
    go_exit :: [Var]      -- Variables captured locally
            -> CoreExpr   -- An exit expression
            -> VarSet     -- Free vars of the expression
            -> ExitifyM CoreExpr
    -- go_exit deals with a tail expression that is floatable
    -- out as an exit point; that is, it mentions no recursive calls
    go_exit :: [CoreBndr] -> Expr CoreBndr -> VarSet -> ExitifyM (Expr CoreBndr)
go_exit [CoreBndr]
captured Expr CoreBndr
e VarSet
fvs
      -- Do not touch an expression that is already a join jump where all arguments
      -- are captured variables. See Note [Idempotency]
      -- But _do_ float join jumps with interesting arguments.
      -- See Note [Jumps can be interesting]
      | (Var CoreBndr
f, [Expr CoreBndr]
args) <- Expr CoreBndr -> (Expr CoreBndr, [Expr CoreBndr])
forall b. Expr b -> (Expr b, [Expr b])
collectArgs Expr CoreBndr
e
      , CoreBndr -> Bool
isJoinId CoreBndr
f
      , (Expr CoreBndr -> Bool) -> [Expr CoreBndr] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Expr CoreBndr -> Bool
forall b. Expr b -> Bool
isCapturedVarArg [Expr CoreBndr]
args
      = Expr CoreBndr -> ExitifyM (Expr CoreBndr)
forall (m :: * -> *) a. Monad m => a -> m a
return Expr CoreBndr
e

      -- Do not touch a boring expression (see Note [Interesting expression])
      | Bool -> Bool
not Bool
is_interesting
      = Expr CoreBndr -> ExitifyM (Expr CoreBndr)
forall (m :: * -> *) a. Monad m => a -> m a
return Expr CoreBndr
e

      -- Cannot float out if local join points are used, as
      -- we cannot abstract over them
      | Bool
captures_join_points
      = Expr CoreBndr -> ExitifyM (Expr CoreBndr)
forall (m :: * -> *) a. Monad m => a -> m a
return Expr CoreBndr
e

      -- We have something to float out!
      | Bool
otherwise
      = do { -- Assemble the RHS of the exit join point
             let rhs :: Expr CoreBndr
rhs   = [CoreBndr] -> Expr CoreBndr -> Expr CoreBndr
forall b. [b] -> Expr b -> Expr b
mkLams [CoreBndr]
abs_vars Expr CoreBndr
e
                 avoid :: InScopeSet
avoid = InScopeSet
in_scope InScopeSet -> [CoreBndr] -> InScopeSet
`extendInScopeSetList` [CoreBndr]
captured
             -- Remember this binding under a suitable name
           ; CoreBndr
v <- InScopeSet -> Int -> Expr CoreBndr -> ExitifyM CoreBndr
addExit InScopeSet
avoid ([CoreBndr] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [CoreBndr]
abs_vars) Expr CoreBndr
rhs
             -- And jump to it from here
           ; Expr CoreBndr -> ExitifyM (Expr CoreBndr)
forall (m :: * -> *) a. Monad m => a -> m a
return (Expr CoreBndr -> ExitifyM (Expr CoreBndr))
-> Expr CoreBndr -> ExitifyM (Expr CoreBndr)
forall a b. (a -> b) -> a -> b
$ Expr CoreBndr -> [CoreBndr] -> Expr CoreBndr
forall b. Expr b -> [CoreBndr] -> Expr b
mkVarApps (CoreBndr -> Expr CoreBndr
forall b. CoreBndr -> Expr b
Var CoreBndr
v) [CoreBndr]
abs_vars }

      where
        -- Used to detect exit expressoins that are already proper exit jumps
        isCapturedVarArg :: Expr b -> Bool
isCapturedVarArg (Var CoreBndr
v) = CoreBndr
v CoreBndr -> [CoreBndr] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [CoreBndr]
captured
        isCapturedVarArg Expr b
_ = Bool
False

        -- An interesting exit expression has free, non-imported
        -- variables from outside the recursive group
        -- See Note [Interesting expression]
        is_interesting :: Bool
is_interesting = (CoreBndr -> Bool) -> VarSet -> Bool
anyVarSet CoreBndr -> Bool
isLocalId (VarSet -> Bool) -> VarSet -> Bool
forall a b. (a -> b) -> a -> b
$
                         VarSet
fvs VarSet -> VarSet -> VarSet
`minusVarSet` [CoreBndr] -> VarSet
mkVarSet [CoreBndr]
captured

        -- The arguments of this exit join point
        -- See Note [Picking arguments to abstract over]
        abs_vars :: [CoreBndr]
abs_vars = (VarSet, [CoreBndr]) -> [CoreBndr]
forall a b. (a, b) -> b
snd ((VarSet, [CoreBndr]) -> [CoreBndr])
-> (VarSet, [CoreBndr]) -> [CoreBndr]
forall a b. (a -> b) -> a -> b
$ (CoreBndr -> (VarSet, [CoreBndr]) -> (VarSet, [CoreBndr]))
-> (VarSet, [CoreBndr]) -> [CoreBndr] -> (VarSet, [CoreBndr])
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr CoreBndr -> (VarSet, [CoreBndr]) -> (VarSet, [CoreBndr])
pick (VarSet
fvs, []) [CoreBndr]
captured
          where
            pick :: CoreBndr -> (VarSet, [CoreBndr]) -> (VarSet, [CoreBndr])
pick CoreBndr
v (VarSet
fvs', [CoreBndr]
acc) | CoreBndr
v CoreBndr -> VarSet -> Bool
`elemVarSet` VarSet
fvs' = (VarSet
fvs' VarSet -> CoreBndr -> VarSet
`delVarSet` CoreBndr
v, CoreBndr -> CoreBndr
zap CoreBndr
v CoreBndr -> [CoreBndr] -> [CoreBndr]
forall a. a -> [a] -> [a]
: [CoreBndr]
acc)
                               | Bool
otherwise           = (VarSet
fvs',               [CoreBndr]
acc)

        -- We are going to abstract over these variables, so we must
        -- zap any IdInfo they have; see #15005
        -- cf. SetLevels.abstractVars
        zap :: CoreBndr -> CoreBndr
zap CoreBndr
v | CoreBndr -> Bool
isId CoreBndr
v = CoreBndr -> IdInfo -> CoreBndr
setIdInfo CoreBndr
v IdInfo
vanillaIdInfo
              | Bool
otherwise = CoreBndr
v

        -- We cannot abstract over join points
        captures_join_points :: Bool
captures_join_points = (CoreBndr -> Bool) -> [CoreBndr] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any CoreBndr -> Bool
isJoinId [CoreBndr]
abs_vars


-- Picks a new unique, which is disjoint from
--  * the free variables of the whole joinrec
--  * any bound variables (captured)
--  * any exit join points created so far.
mkExitJoinId :: InScopeSet -> Type -> JoinArity -> ExitifyM JoinId
mkExitJoinId :: InScopeSet -> Type -> Int -> ExitifyM CoreBndr
mkExitJoinId InScopeSet
in_scope Type
ty Int
join_arity = do
    [(CoreBndr, Expr CoreBndr)]
fs <- State [(CoreBndr, Expr CoreBndr)] [(CoreBndr, Expr CoreBndr)]
forall s. State s s
get
    let avoid :: InScopeSet
avoid = InScopeSet
in_scope InScopeSet -> [CoreBndr] -> InScopeSet
`extendInScopeSetList` (((CoreBndr, Expr CoreBndr) -> CoreBndr)
-> [(CoreBndr, Expr CoreBndr)] -> [CoreBndr]
forall a b. (a -> b) -> [a] -> [b]
map (CoreBndr, Expr CoreBndr) -> CoreBndr
forall a b. (a, b) -> a
fst [(CoreBndr, Expr CoreBndr)]
fs)
                         InScopeSet -> CoreBndr -> InScopeSet
`extendInScopeSet` CoreBndr
exit_id_tmpl -- just cosmetics
    CoreBndr -> ExitifyM CoreBndr
forall (m :: * -> *) a. Monad m => a -> m a
return (InScopeSet -> CoreBndr -> CoreBndr
uniqAway InScopeSet
avoid CoreBndr
exit_id_tmpl)
  where
    exit_id_tmpl :: CoreBndr
exit_id_tmpl = FastString -> Unique -> Type -> CoreBndr
mkSysLocal (String -> FastString
fsLit String
"exit") Unique
initExitJoinUnique Type
ty
                    CoreBndr -> Int -> CoreBndr
`asJoinId` Int
join_arity

addExit :: InScopeSet -> JoinArity -> CoreExpr -> ExitifyM JoinId
addExit :: InScopeSet -> Int -> Expr CoreBndr -> ExitifyM CoreBndr
addExit InScopeSet
in_scope Int
join_arity Expr CoreBndr
rhs = do
    -- Pick a suitable name
    let ty :: Type
ty = Expr CoreBndr -> Type
exprType Expr CoreBndr
rhs
    CoreBndr
v <- InScopeSet -> Type -> Int -> ExitifyM CoreBndr
mkExitJoinId InScopeSet
in_scope Type
ty Int
join_arity
    [(CoreBndr, Expr CoreBndr)]
fs <- State [(CoreBndr, Expr CoreBndr)] [(CoreBndr, Expr CoreBndr)]
forall s. State s s
get
    [(CoreBndr, Expr CoreBndr)] -> State [(CoreBndr, Expr CoreBndr)] ()
forall s. s -> State s ()
put ((CoreBndr
v,Expr CoreBndr
rhs)(CoreBndr, Expr CoreBndr)
-> [(CoreBndr, Expr CoreBndr)] -> [(CoreBndr, Expr CoreBndr)]
forall a. a -> [a] -> [a]
:[(CoreBndr, Expr CoreBndr)]
fs)
    CoreBndr -> ExitifyM CoreBndr
forall (m :: * -> *) a. Monad m => a -> m a
return CoreBndr
v

{-
Note [Interesting expression]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
We do not want this to happen:

  joinrec go 0     x y = x
          go (n-1) x y = jump go (n-1) (x+y)
  in …
==>
  join exit x = x
  joinrec go 0     x y = jump exit x
          go (n-1) x y = jump go (n-1) (x+y)
  in …

because the floated exit path (`x`) is simply a parameter of `go`; there are
not useful interactions exposed this way.

Neither do we want this to happen

  joinrec go 0     x y = x+x
          go (n-1) x y = jump go (n-1) (x+y)
  in …
==>
  join exit x = x+x
  joinrec go 0     x y = jump exit x
          go (n-1) x y = jump go (n-1) (x+y)
  in …

where the floated expression `x+x` is a bit more complicated, but still not
intersting.

Expressions are interesting when they move an occurrence of a variable outside
the recursive `go` that can benefit from being obviously called once, for example:
 * a local thunk that can then be inlined (see example in note [Exitification])
 * the parameter of a function, where the demand analyzer then can then
   see that it is called at most once, and hence improve the function’s
   strictness signature

So we only hoist an exit expression out if it mentiones at least one free,
non-imported variable.

Note [Jumps can be interesting]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
A jump to a join point can be interesting, if its arguments contain free
non-exported variables (z in the following example):

  joinrec go 0     x y = jump j (x+z)
          go (n-1) x y = jump go (n-1) (x+y)
  in …
==>
  join exit x y = jump j (x+z)
  joinrec go 0     x y = jump exit x
          go (n-1) x y = jump go (n-1) (x+y)


The join point itself can be interesting, even if none if its
arguments have free variables free in the joinrec.  For example

  join j p = case p of (x,y) -> x+y
  joinrec go 0     x y = jump j (x,y)
          go (n-1) x y = jump go (n-1) (x+y) y
  in …

Here, `j` would not be inlined because we do not inline something that looks
like an exit join point (see Note [Do not inline exit join points]). But
if we exitify the 'jump j (x,y)' we get

  join j p = case p of (x,y) -> x+y
  join exit x y = jump j (x,y)
  joinrec go 0     x y = jump exit x y
          go (n-1) x y = jump go (n-1) (x+y) y
  in …

and now 'j' can inline, and we get rid of the pair. Here's another
example (assume `g` to be an imported function that, on its own,
does not make this interesting):

  join j y = map f y
  joinrec go 0     x y = jump j (map g x)
          go (n-1) x y = jump go (n-1) (x+y)
  in …

Again, `j` would not be inlined because we do not inline something that looks
like an exit join point (see Note [Do not inline exit join points]).

But after exitification we have

  join j y = map f y
  join exit x = jump j (map g x)
  joinrec go 0     x y = jump j (map g x)
              go (n-1) x y = jump go (n-1) (x+y)
  in …

and now we can inline `j` and this will allow `map/map` to fire.


Note [Idempotency]
~~~~~~~~~~~~~~~~~~

We do not want this to happen, where we replace the floated expression with
essentially the same expression:

  join exit x = t (x*x)
  joinrec go 0     x y = jump exit x
          go (n-1) x y = jump go (n-1) (x+y)
  in …
==>
  join exit x = t (x*x)
  join exit' x = jump exit x
  joinrec go 0     x y = jump exit' x
          go (n-1) x y = jump go (n-1) (x+y)
  in …

So when the RHS is a join jump, and all of its arguments are captured variables,
then we leave it in place.

Note that `jump exit x` in this example looks interesting, as `exit` is a free
variable. Therefore, idempotency does not simply follow from floating only
interesting expressions.

Note [Calculating free variables]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
We have two options where to annotate the tree with free variables:

 A) The whole tree.
 B) Each individual joinrec as we come across it.

Downside of A: We pay the price on the whole module, even outside any joinrecs.
Downside of B: We pay the price per joinrec, possibly multiple times when
joinrecs are nested.

Further downside of A: If the exitify function returns annotated expressions,
it would have to ensure that the annotations are correct.

We therefore choose B, and calculate the free variables in `exitify`.


Note [Do not inline exit join points]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
When we have

  let t = foo bar
  join exit x = t (x*x)
  joinrec go 0     x y = jump exit x
          go (n-1) x y = jump go (n-1) (x+y)
  in …

we do not want the simplifier to simply inline `exit` back in (which it happily
would).

To prevent this, we need to recognize exit join points, and then disable
inlining.

Exit join points, recognizeable using `isExitJoinId` are join points with an
occurence in a recursive group, and can be recognized (after the occurence
analyzer ran!) using `isExitJoinId`.
This function detects joinpoints with `occ_in_lam (idOccinfo id) == True`,
because the lambdas of a non-recursive join point are not considered for
`occ_in_lam`.  For example, in the following code, `j1` is /not/ marked
occ_in_lam, because `j2` is called only once.

  join j1 x = x+1
  join j2 y = join j1 (y+2)

To prevent inlining, we check for isExitJoinId
* In `preInlineUnconditionally` directly.
* In `simplLetUnfolding` we simply give exit join points no unfolding, which
  prevents inlining in `postInlineUnconditionally` and call sites.

Note [Placement of the exitification pass]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
I (Joachim) experimented with multiple positions for the Exitification pass in
the Core2Core pipeline:

 A) Before the `simpl_phases`
 B) Between the `simpl_phases` and the "main" simplifier pass
 C) After demand_analyser
 D) Before the final simplification phase

Here is the table (this is without inlining join exit points in the final
simplifier run):

        Program |                       Allocs                      |                      Instrs
                | ABCD.log     A.log     B.log     C.log     D.log  | ABCD.log     A.log     B.log     C.log     D.log
----------------|---------------------------------------------------|-------------------------------------------------
 fannkuch-redux |   -99.9%     +0.0%    -99.9%    -99.9%    -99.9%  |    -3.9%     +0.5%     -3.0%     -3.9%     -3.9%
          fasta |    -0.0%     +0.0%     +0.0%     -0.0%     -0.0%  |    -8.5%     +0.0%     +0.0%     -0.0%     -8.5%
            fem |     0.0%      0.0%      0.0%      0.0%     +0.0%  |    -2.2%     -0.1%     -0.1%     -2.1%     -2.1%
           fish |     0.0%      0.0%      0.0%      0.0%     +0.0%  |    -3.1%     +0.0%     -1.1%     -1.1%     -0.0%
   k-nucleotide |   -91.3%    -91.0%    -91.0%    -91.3%    -91.3%  |    -6.3%    +11.4%    +11.4%     -6.3%     -6.2%
            scs |    -0.0%     -0.0%     -0.0%     -0.0%     -0.0%  |    -3.4%     -3.0%     -3.1%     -3.3%     -3.3%
         simple |    -6.0%      0.0%     -6.0%     -6.0%     +0.0%  |    -3.4%     +0.0%     -5.2%     -3.4%     -0.1%
  spectral-norm |    -0.0%      0.0%      0.0%     -0.0%     +0.0%  |    -2.7%     +0.0%     -2.7%     -5.4%     -5.4%
----------------|---------------------------------------------------|-------------------------------------------------
            Min |   -95.0%    -91.0%    -95.0%    -95.0%    -95.0%  |    -8.5%     -3.0%     -5.2%     -6.3%     -8.5%
            Max |    +0.2%     +0.2%     +0.2%     +0.2%     +1.5%  |    +0.4%    +11.4%    +11.4%     +0.4%     +1.5%
 Geometric Mean |    -4.7%     -2.1%     -4.7%     -4.7%     -4.6%  |    -0.4%     +0.1%     -0.1%     -0.3%     -0.2%

Position A is disqualified, as it does not get rid of the allocations in
fannkuch-redux.
Position A and B are disqualified because it increases instructions in k-nucleotide.
Positions C and D have their advantages: C decreases allocations in simpl, but D instructions in fasta.

Assuming we have a budget of _one_ run of Exitification, then C wins (but we
could get more from running it multiple times, as seen in fish).

Note [Picking arguments to abstract over]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

When we create an exit join point, so we need to abstract over those of its
free variables that are be out-of-scope at the destination of the exit join
point. So we go through the list `captured` and pick those that are actually
free variables of the join point.

We do not just `filter (`elemVarSet` fvs) captured`, as there might be
shadowing, and `captured` may contain multiple variables with the same Unique. I
these cases we want to abstract only over the last occurence, hence the `foldr`
(with emphasis on the `r`). This is #15110.

-}