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)

     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) $

              --      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

   | Just rule_match <- lookupRule ropts in_scope_env

                                   act_fun fn args rules

     -- Fire a rule for the function

        ; return (Just rule_match) }

   | otherwise  -- No rule fires

                       (pprModuleName . moduleName)

                       (ruleModule rule))

       | logHasDumpFlag logger Opt_D_dump_rule_rewrites

       = log_rule Opt_D_dump_rule_rewrites "Rule fired" $ vcat

           [ text "Rule:" <+> ftext (ruleName rule)

         --, text "Rule activation:" <+> ppr (ruleActivation rule)

           , text "Full arity:" <+>  ppr (ruleArity rule)

           , text "Before:" <+> hang (ppr fn) 2 (sep (map ppr args))

       | logHasDumpFlag logger Opt_D_dump_rule_firings

       = log_rule Opt_D_dump_rule_firings "Rule fired:" $

         return ( emptyFloats env

                , extendIdSubst env case_bndr (DoneEx scrut NotJoinPoint))

       = return (emptyFloats env', env')

       | otherwise

 preInlineUnconditionally

     :: SimplEnv -> TopLevelFlag -> InId

     -> Maybe SimplEnv       -- Returned env has extended substitution

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

 -- See Note [Core let-can-float invariant] in GHC.Core

 -- Reason: we don't want to inline single uses, or discard dead bindings,

 --         for unlifted, side-effect-ful bindings

   | not pre_inline_unconditionally           = Nothing

   | not active                               = Nothing

   | isTopLevel top_lvl && isDeadEndId bndr   = Nothing -- Note [Top-level bottoming Ids]

   -- See Note [Stable unfoldings and preInlineUnconditionally]

   | not (isInlinePragma inline_prag)

   , Just inl <- maybeUnfoldingTemplate unf   = Just $! (extend_subst_with inl)

   | otherwise                                = Nothing

   where

     unf = idUnfolding bndr

     one_occ IAmDead = True -- Happens in ((\x.1) v)

     one_occ OneOcc{ occ_n_br   = 1

   = sdocOption sdocSuppressTypeSignatures $ \suppress_sigs ->

     case () of

     _

       , CaseBind <- bind_site

       | not debug_on            -- Even dead binders can be one-shot

       | suppress_sigs -> pprUntypedBinder var