--- If -fno-case-of-case, push /only applications/ inside a 'let', lest we

--- lose a join point.  See Note [Join points with -fno-case-of-case]

-simplExprF1 env let_expr@(Let {}) cont

-  | not (seCaseCase env)

-  , (inner, outer) <- splitContArgs cont

-  , not (contIsStop outer)

-  = do { let_expr' <- simplExprC env let_expr inner

-       ; rebuild env let_expr' outer }

-

-

-  | contIsStop cont        -- Common case; no need for fancy footwork

-  = assertPpr (seCaseCase env) (ppr cont) $

-    do { (floats1, cont')  <- mkDupableCont env cont

-{- Note [Join points and case-of-case]

-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

-  , ApplyToTy  { sc_cont = cont2, sc_arg_ty = hole_ty } <- cont1

-             (outer_cont, new_runrw_res_ty, inner_cont)

-                | seCaseCase env = (mkBoringStop overall_res_ty, overall_res_ty, cont3)

-                | otherwise      = (cont3, hole_ty, mkBoringStop hole_ty)

-                -- Only when case-of-case is on. See GHC.Driver.Config.Core.Opt.Simplify

-                -- See (COC1) in Note [Case-of-case and full laziness]

-                            ; body' <- simplExprC env' body inner_cont

-                         env'  = arg_env `addNewInScopeIds` [s']

-                         hole_ty = mkVisFunTy m realWorldStatePrimTy new_runrw_res_ty

-                              ApplyToVal { sc_arg = Var s', sc_cast = MRefl

-                                         , sc_env = Simplified OkDup

-                                         , sc_cont = inner_cont

-       ; let rr'   = getRuntimeRep new_runrw_res_ty

-             call' = mkApps (Var fun) [mkTyArg rr', mkTyArg new_runrw_res_ty, arg']

-       ; rebuild_go env call' outer_cont }

-  , seCaseCase env            -- But only when case-of-case is on.

-                              -- See Note [Case-of-case and full laziness]

-  | not (seCaseCase env)    -- Only when case-of-case is on.

-                            -- See GHC.Driver.Config.Core.Opt.Simplify

-                            --    Note [Case-of-case and full laziness]

-  = do { case_expr <- simplAlts (saf,env) scrut case_bndr alts

-                                (mkBoringStop (contHoleType cont))

-       ; rebuild env case_expr cont }

-

-  | otherwise

-    -- See Note [Case-of-case and full laziness]

-

-

-{- Note [Case-of-case and full laziness]

-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

-Case-of-case can hide opportunities for let-floating (full laziness).

-For example

-   rec { f = \y. case (expensive x) of (a,b) -> blah }

-We might hope to float the (expensive x) out of the \y-loop.

-But if we inline `expensive` we might get

-   \y. case (case x of I# x' -> body) of (a,b) -> blah

-Now if we do case-of-case we get

-   \y. case x if I# x2 ->

-       case body of (a,b) -> blah

-

-Sadly, at this point `body` mentions `x2`, so we can't float it out of the

-\y-loop.

-

-Solution: don't do case-of-case in the "gentle" simplification phase that

-precedes the first float-out transformation.  Implementation:

-

-  * `sm_case_case` field in SimplMode

-

-  * If `sm_case_case` is False (tested via `seCaseCase`), then:

-    (COC1) When simplifying (case scrut of alts), do not make a Select continuation.

-           This happens in the `Case` case of `simplExprF`.

-    (COC2) When simplifying (f arg), where `f` is strict, do not make a StrictArg

-           continuation.  See the `ApplyToVal` case of `rebuildArg`.

-

-    ...more to come...

-           in GHC.Core.Opt.Simplify.Iteration.rebuildCall.

-

-    (COC3) This applies equally to the case-of-runRW# transformation:

-           case (runRW# (\s. body)) of (a,b) -> blah

-           --->

-           runRW# (\s. case body of (a,b) -> blah)

-           Again, don't do this when `sm_case_case` is off.

-           See #25055 for a motivating example.

-

-Note [Join points with -fno-case-of-case]   FIX ME

-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

-Supose case-of-case is switched off, and we are simplifying

-

-    case (join j x = <j-rhs> in

-          case y of

-             A -> j 1

-             B -> j 2

-             C -> e) of <outer-alts>

-

-Usually, we'd push the outer continuation (case . of <outer-alts>) into

-both the RHS and the body of the join point j.  But since we aren't doing

-case-of-case we may then end up with this totally bogus result

-

-    join x = case <j-rhs> of <outer-alts> in

-    case (case y of

-             A -> j 1

-             B -> j 2

-             C -> e) of <outer-alts>

-

-This would be OK in the language of the paper, but not in GHC: j is no longer

-a join point.  We can only do the "push continuation into the RHS of the

-join point j" if we also push the continuation right down to the /jumps/ to

-j, so that it can evaporate there (trimJoinCont). Then, if we are doing

-case-of-case, we'll get to:

-

-    join x = case <j-rhs> of <outer-alts> in

-    case y of

-      A -> j 1

-      B -> j 2

-      C -> case e of <outer-alts>

-

-which is great.

-

-Bottom line: if case-of-case is off, we must stop pushing the continuation

-inwards altogether at any join point.  Instead simplify the (join ... in ...)

-with a Stop continuation, and wrap the original continuation around the

-outside.  Surprisingly tricky!

--}