, text "joins:" <+> ppr jf

                        , text "in_scope:" <+> ppr is ])

 emptyFloats env

   = SimplFloats { sfLetFloats  = emptyLetFloats

                 , sfJoinFloats = emptyJoinFloats

 simplRecOrTopPair env bind_cxt old_bndr new_bndr rhs

   | Just env' <- preInlineUnconditionally env (bindContextLevel bind_cxt)

   = {-#SCC "simplRecOrTopPair-pre-inline-uncond" #-}

     simplTrace "SimplBindr:inline-uncond1" (ppr old_bndr) $

     do { tick (PreInlineUnconditionally old_bndr)

         ; completeBind (BC_Join is_rec cont) (old_bndr, unf_se) (new_bndr, rhs', env) }

 --------------------------

              -> SimplM (SimplFloats, SimplEnv)

 -- A specialised variant of completeBindX used to construct non-recursive

 -- auxiliary bindings, notably in knownCon.

 --

 -- Precondition: rhs satisfies the let-can-float invariant

   | assertPpr (isId bndr && not (isJoinId bndr)) (ppr bndr) $

     isDeadBinder bndr   -- Not uncommon; e.g. case (a,b) of c { (p,q) -> p }

   = return (emptyFloats env, env)    --  Here c is dead, and we avoid

         ; let rhs_floats = emptyFloats env `addLetFloats` anf_floats

           -- Simplify the binder and complete the binding

         ; (bind_float, env2) <- completeBind (BC_Let NotTopLevel NonRecursive)

         ; return (rhs_floats `addFloats` bind_float, env2) }

 {- *********************************************************************

 *                                                                      *

            Cast worker/wrapper

 -}

 prepareRhs :: HasDebugCallStack

            -> FastString    -- Base for any new variables

            -> OutExpr

            -> SimplM (LetFloats, OutExpr)

     anfise other = return (emptyLetFloats, other)

 makeTrivialArg env arg@(ValArg { as_arg = e, as_dmd = dmd })

   = do { (floats, e') <- makeTrivial env NotTopLevel dmd (fsLit "arg") e

        ; return (floats, arg { as_arg = e' }) }

   = return (emptyLetFloats, arg)

 makeTrivial :: HasDebugCallStack

             -> FastString  -- ^ A "friendly name" to build the new binder from

             -> OutExpr

             -> SimplM (LetFloats, OutExpr)

           -- observed the quadratic behavior, so this extra entanglement

           -- seems not worthwhile.

         simplExprF env fun $

                    , sc_hole_ty = substTy env (exprType fun)

 simplExprF1 env expr@(Lam {}) cont

   = {-#SCC "simplExprF1-Lam" #-}

 simplExprF1 env (Case scrut bndr _ alts) cont

   = {-#SCC "simplExprF1-Case" #-}

 simplExprF1 env (Let (Rec pairs) body) cont

   | Just pairs' <- joinPointBindings_maybe pairs

     do { ty' <- simplType env ty

        ; simplExprF (extendTvSubst env bndr ty') body cont }

     -- Because of the let-can-float invariant, it's ok to

     -- inline freely, or to drop the binding if it is dead.

   = do { simplTrace "SimplBindr:inline-uncond2" (ppr bndr) $

 rebuild :: SimplEnv -> OutExpr -> SimplCont -> SimplM (SimplFloats, OutExpr)

 rebuild env expr cont = rebuild_go (zapSubstEnv env) expr cont

 -- SimplEnvIS: at this point the substitution in the SimplEnv is irrelevant;

 -- only the in-scope set matters, plus the flags.

 rebuild_go env expr cont

           co' = optOutCoercion env co opt

       Select { sc_bndr = bndr, sc_alts = alts, sc_env = se, sc_cont = cont }

       StrictArg { sc_fun = fun, sc_cont = cont, sc_fun_ty = fun_ty }

         -> rebuildCall env (addValArgTo fun expr fun_ty) cont

       StrictBind { sc_bndr = b, sc_body = body, sc_env = se

                  , sc_cont = cont, sc_from = from_what }

       ApplyToTy  { sc_arg_ty = ty, sc_cont = cont}

         -> rebuild_go env (App expr (Type ty)) cont

                  , sc_cont = cont, sc_hole_ty = fun_ty }

         -- See Note [Avoid redundant simplification]

               ; rebuild_go env (App expr arg') cont }

 completeBindX :: SimplEnv

     --         co1 :: t1 ~ s1

     --         co2 :: s2 ~ t2

     go co co_is_opt cont@(ApplyToVal { sc_arg = arg, sc_env = arg_se

                                      , sc_hole_ty = fun_ty })

       | not co_is_opt

       = -- pushCoValArg duplicates the coercion, so optimise first

                   -- See Note [Avoiding simplifying repeatedly]

                MCo co1 ->

                 -- When we build the ApplyTo we can't mix the OutCoercion

                 -- 'co' with the InExpr 'arg', so we simplify

                 -- to make it all consistent.  It's a bit messy.

                 -- Example of use: #995

            ; return (ApplyToVal { sc_arg  = mkCast arg' co1

                                 , sc_env  = arg_se'

                                 , sc_cont = tail'

                                 , sc_hole_ty = coercionLKind co }) } } }

     go_mco MRefl    _   cont = return cont

     go_mco (MCo co) opt cont = go co opt cont

                Nothing -> mkBoringStop arg_ty

                Just ai -> mkLazyArgStop arg_ty ai

        ; arg' <- simplExprC arg_env' arg stop

          -- Return a StaticEnv that includes the in-scope set from 'env',

          -- because arg' may well mention those variables (#20639)

                                     , sc_cont = cont })

   = assertPpr (isCoVar bndr) (ppr bndr) $

     do { tick (BetaReduction bndr)

        ; simplLam (extendCvSubst env bndr arg_co') body cont }

 -- Value beta-reduction

 -- This works for /coercion/ lambdas too

 simpl_lam env bndr body (ApplyToVal { sc_arg = arg, sc_env = arg_se

                                     , sc_hole_ty = fun_ty})

   = do { tick (BetaReduction bndr)

        ; let from_what = FromBeta arg_levity

              --      It's wrong to err in either direction

              --      But fun_ty is an OutType, so is fully substituted

             , not (needsCaseBindingL arg_levity arg)

               -- Ok to test arg::InExpr in needsCaseBinding because

               -- exprOkForSpeculation is stable under simplification

                     tick (PreInlineUnconditionally bndr)

                   ; simplLam env' body cont }

             | otherwise

 -- Discard a non-counting tick on a lambda.  This may change the

 -- cost attribution slightly (moving the allocation of the

   = -- Evaluate RHS strictly

     simplExprF (rhs_se `setInScopeFromE` env) rhs

                (StrictBind { sc_bndr = bndr, sc_body = body, sc_from = from_what

   | otherwise  -- Evaluate RHS lazily

   = do { (env1, bndr1)    <- simplNonRecBndr env bndr

 simplInId env var cont

   | Just dc <- isDataConWorkId_maybe var

   , isLazyDataConRep dc                    -- See Note [Fast path for lazy data constructors]

   | otherwise

   = case substId env var of

       ContEx tvs cvs ids e -> simplExprF env' e cont

 ---------------------------------------------------------

 -- A teeny-tiny simplifier for an OutExpr, which parsimonously avoids re-simplifying

 -- the entire things all over again

 --

 -- What if expr = (K x y) and cont is `Select`?  That is handled by rebuild.

 --   (Why?  That's a bit inconsistent with beta.)

 simplOutExpr env expr cont

   | Lam {} <- expr

   , cont_has_args

   = simplLam env (occurAnalyseExpr expr) cont

     -- pprTrace "simplOutExpr" (vcat [ ppr v <+> dcolon <+> ppr (idType v)

     --                              , text "args:" <+> ppr args

     --                              , text "cont:" <+> ppr cont ]) $

   | otherwise

   = rebuild_go env expr cont

                , sc_env = arg_se, sc_hole_ty = fun_ty } <- cont2

   -- Do this even if (contIsStop cont), or if seCaseCase is off.

   -- See Note [No eta-expansion in runRW#]

              overall_res_ty = contResultType cont3

              -- hole_ty is the type of the current runRW# application

            _ -> do { s' <- newId (fsLit "s") ManyTy realWorldStatePrimTy

                    ; let (m,_,_) = splitFunTy fun_ty

                          env'  = arg_env `addNewInScopeIds` [s']

                                             , sc_hole_ty = mkVisFunTy m realWorldStatePrimTy new_runrw_res_ty }

                                 -- cont' applies to s', then K

                    ; body' <- simplExprC env' arg cont'

 ---------- Simplify value arguments --------------------

 rebuildCall env fun_info

             (ApplyToVal { sc_arg = arg, sc_env = arg_se

                (StrictArg { sc_fun = fun_info, sc_fun_ty = fun_ty

                           , sc_cont = cont })

                 -- Note [Shadowing in the Simplifier]

         ; rebuildCall env (addValArgTo fun_info  arg' fun_ty) cont }

 ---------- No further useful info, revert to generic rebuild ------------

   = return Nothing

   where

     interesting_cont = interestingCallContext env call_cont

     log_inlining doc

        , rm_binds = wrap, rm_bndrs = bndrs } <- rule_match

   = do { let env' = env `addNewInScopeIds` bndrs

        ; (floats, e') <- simplExprF env' rhs $

        ; return $

          if isEmptyBindWrapper wrap  -- Not very pretty

          then (floats, e')

                  , ValArg { as_arg = no_cast_scrut

                           , as_dmd = seqDmd

                           , as_hole_ty = res3_ty } ]

     out_args = [Type rhs_rep, Type scrut_ty, Type rhs_ty, no_cast_scrut]

                -- Cheaper than (map argSpecArg out_arg_specs)

 --      Eliminate the case if possible

 rebuildCase, reallyRebuildCase

    -> OutExpr          -- Scrutinee

    -> InId             -- Case binder

    -> [InAlt]          -- Alternatives (increasing order)

 --      1. Eliminate the case if there's a known constructor

 --------------------------------------------------

   | Lit lit <- scrut    -- No need for same treatment as constructors

                         -- because literals are inlined more vigorously

   , not (litIsLifted lit)

   = do  { tick (KnownBranch case_bndr)

         ; case findAlt (LitAlt lit) alts of

             Nothing             -> missingAlt env case_bndr alts cont

   | Just (in_scope', wfloats, con, ty_args, other_args)

       <- exprIsConApp_maybe (getUnfoldingInRuleMatch env) scrut

         ; wrapDataConFloats env wfloats case_bndr cont $

           case findAlt (DataAlt con) alts of

             Nothing                   -> missingAlt env0 case_bndr alts cont

         }

   where

 --------------------------------------------------

 --      2. Eliminate the case if scrutinee is evaluated

 --------------------------------------------------

   -- See if we can get rid of the case altogether

   -- See Note [Case elimination]

   -- mkCase made sure that if all the alternatives are equal,

   | all_dead_bndrs

   , doCaseToLet scrut case_bndr

   = do { tick (CaseElim case_bndr)

        ; (floats2, expr') <- simplExprF env' rhs cont

        ; return (floats1 `addFloats` floats2, expr') }

   = do { mb_rule <- trySeqRules env scrut rhs cont

        ; case mb_rule of

            Just (rm, ass, rcont) -> fireRuleAFTER env rm ass rcont

   where

     all_dead_bndrs = all isDeadBinder bndrs       -- bndrs are [InId]

     is_plain_seq   = all_dead_bndrs && isDeadBinder case_bndr -- Evaluation *only* for effect

 --------------------------------------------------

 --      3. Primop-related case-rules

 --------------------------------------------------

   | Just (scrut', case_bndr', alts') <- caseRules2 (sePlatform env) scrut case_bndr alts

   | otherwise

 doCaseToLet :: OutExpr          -- Scrutinee

             -> InId             -- Case binder

 --      3. Catch-all case

 --------------------------------------------------

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

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

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

                                 (mkBoringStop (contHoleType cont))

        ; rebuild env case_expr cont }

   | otherwise

   = do { (floats, env', cont') <- mkDupableCaseCont env alts cont

                                 (scaleIdBy holeScaling case_bndr)

                                 (scaleAltsBy holeScaling alts)

                                 cont'

 computed in the continuation (with function `contHoleScaling`).

 -}

           -> SimplCont

           -> SimplM OutExpr  -- Returns the complete simplified case expression

   = do  { traceSmpl "simplAlts" (vcat [ ppr case_bndr

                                       , text "cont':" <+> ppr cont'

                                       , text "in_scope" <+> ppr (seInScope env0) ])

         ; let case_bndr2 = case_bndr1 `setIdUnfolding` evaldUnfolding

               env2       = modifyInScope env1 case_bndr2

               -- See Note [Case binder evaluated-ness]

               fam_envs   = seFamEnvs env0

                                                        case_bndr case_bndr2 alts

         ; (imposs_deflt_cons, in_alts) <- prepareAlts scrut' case_bndr alts

           --     See Note [Shadowing in prepareAlts] in GHC.Core.Opt.Simplify.Utils

         ; alts' <- forM in_alts $

                      case_bndr' (scrutOkForBinderSwap scrut) cont'

         ; let alts_ty' = contResultType cont'

 ------------------------------------

            -> OutExpr -> InId -> OutId -> [InAlt]

            -> SimplM (SimplEnv, OutExpr, OutId)

 -- Note [Improving seq]

   = do { case_bndr2 <- newId (fsLit "nt") ManyTy ty2

         ; let rhs  = DoneEx (Var case_bndr2 `Cast` mkSymCo co) NotJoinPoint

               env2 = extendIdSubst env case_bndr rhs

         ; return (env2, scrut `Cast` co, case_bndr2) }

   = return (env, scrut, case_bndr1)

 ------------------------------------

          -> Maybe OutExpr       -- The scrutinee

          -> [AltCon]            -- These constructors can't be present when

                                 -- matching the DEFAULT alternative

          -> InAlt

          -> SimplM OutAlt

   = assert (null bndrs) $

     do  { let env' = addDefaultUnfoldings env case_bndr' bndr_swap' imposs_deflt_cons

         ; return (Alt DEFAULT [] rhs') }

   = assert (null bndrs) $

     do  { let env' = addAltUnfoldings env case_bndr' bndr_swap' (Lit lit)

         ; return (Alt (LitAlt lit) [] rhs') }

   = do  { -- See Note [Adding evaluatedness info to pattern-bound variables]

           -- and Note [DataAlt occ info]

         ; let vs_with_info = adjustFieldsIdInfo scrut' case_bndr' bndr_swap' con vs

           -- Adjust evaluated-ness and occ-info flags before `simplBinders`

           -- because the latter extends the in-scope set, which propagates this

           -- adjusted info to use sites.

                 -- Bind the case-binder to (con args)

         ; let inst_tys' = tyConAppArgs (idType case_bndr')

               con_app = mkConApp2 con inst_tys' vs'

               env''   = addAltUnfoldings env' case_bndr' bndr_swap' con_app

         ; return (Alt (DataAlt con) vs' rhs') }

 {- Note [Adding evaluatedness info to pattern-bound variables]

   | keep_occ_info = pat_id

   | otherwise     = zapIdOccInfo pat_id