--  ; when block_joins

        ; pure r}

   where

       -- TODO Consider whether this is the correct rule. It is consistent with

       -- the simplifier's behaviour - cost-centre-scoped ticks become part of

       -- the continuation, and thus they behave like part of an evaluation

              let rhs   = mkLams abs_vars e

                  avoid = in_scope `extendInScopeSetList` captured

              -- Remember this binding under a suitable name

              -- And jump to it from here

            ; return $ mkVarApps (Var v) abs_vars }

       asJoinId (mkSysLocal (fsLit "exit") initExitJoinUnique ManyTy ty)

         join_ty join_arity

     -- Pick a suitable name

     let ty = exprType rhs

     fs <- get

     put ((v,rhs):fs)

     return v

                     _ -> usage1

          -- usage3: see Note [Quasi join points] in GHC.Core.Opt.Simplify.Iteration.

     in WUD usage3 (Cast expr' co)

   = let (WUD usage expr') = occAnal env expr

         usage1 = addManyOccs usage (coVarsOfCo co)

             -- usage1: see Note [Gather occurrences of coercion variables]

             -- usage2: see Note [Quasi join points]

     in WUD usage2 (Cast expr' co)

 markAllNonTail ud@(UD { ud_env = env }) =

   ud { ud_z_tail   = fmap (const MarkNonTail) env }

 markAllInsideLamIf, markAllNonTailIf :: HasDebugCallStack => Bool -> UsageDetails -> UsageDetails

 trimJoinCont _ NotJoinPoint cont

   = cont -- Not a jump

 trimJoinCont var (JoinPoint { joinPointType = join_ty, joinPointArity = arity }) cont

   where

     trim 0 cont@(Stop {})

       = cont

 -- | Is @join f x in <tick> jump f x@ valid?

 tickishCanScopeJoin :: GenTickish pass -> Bool

 tickishCanScopeJoin tick = case tick of

   HpcTick{} -> False

   Breakpoint{} -> False

   SourceNote{} -> True