, typeArity, arityTypeArity, etaExpandAT )

 import GHC.Core.SimpleOpt ( exprIsConApp_maybe, joinPointBinding_maybe, joinPointBindings_maybe )

 import GHC.Core.FVs     ( mkRuleInfo {- exprsFreeIds -} )

 import GHC.Core.Multiplicity

 import GHC.Hs.Extension

       _                        -> rebuild_go env expr cont

   where

     (fun, args) = collectArgs expr

     occ_fun = occurAnalyseExpr fun  -- ToDo:explain; c.f. Note [Occurrence-analyse after rule firing]

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

                      then tryRules env rules_for_me fun out_args

                      else return Nothing

        ; case mb_match of {

     -- Try inlining

     do { logger <- getLogger

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

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

   | null rules

   | otherwise  -- Try rules again: Plan (AFTER) in Note [When to apply rewrite rules]

        ; case mb_match of

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

 tryInlining :: SimplEnv -> Logger -> OutId -> SimplCont -> SimplM (Maybe OutExpr)

 ************************************************************************

 -}

 tryRules :: SimplEnv -> [CoreRule]

          -> OutId -> [OutExpr]

 tryRules env rules fn args

   | otherwise  -- No rule fires

   = do { logger <- getLogger

        ; let seq_rules = getRules rule_base seqId

        ; mb_match <- tryRules in_env seq_rules seqId out_args

        ; case mb_match of

   where

     no_cast_scrut = drop_casts scrut

 module GHC.Core.Rules (

         -- ** Looking up rules

         RuleMatch(..), lookupRule, matchExprs, ruleLhsIsMoreSpecific,

         -- ** RuleBase, RuleEnv

         RuleBase, RuleEnv(..), mkRuleEnv, emptyRuleEnv,

 import GHC.Data.FastString

 import GHC.Data.Maybe

 import GHC.Data.Bag

 import GHC.Data.List.SetOps( hasNoDups )

 import GHC.Utils.FV( filterFV, fvVarSet )

     go ms [] = ms

     go ms (r:rs)

       | Just rm <- matchRule opts rule_env is_active fn args' rough_args r

       | otherwise

       = -- pprTrace "match failed" (ppr r $$ ppr args $$

         --   ppr [ (arg_id, maybeUnfoldingTemplate unf)

        ; return (RM { rm_rule = rule

                     , rm_rhs = rhs

                     , rm_args = []

                     , rm_bndrs = [] }) }

 matchRule _opts rule_env is_active _fn target_es rough_args

                     , rs_bndrs    :: [Var]        -- Variables bound by floated lets

                     }

   -- See Notes [Matching lets] and [Matching cases]

   -- we represent the floated bindings as a core-to-core function

 emptyRuleSubst :: RuleSubst

 emptyRuleSubst = RS { rs_tv_subst = emptyVarEnv, rs_id_subst = emptyVarEnv

 {- Note [Casts in the target]

   | otherwise

   = Nothing

   where

 match renv subst e@(Tick t e1) e2 mco

   | tickishFloatable t  -- Ignore floatable ticks in rule template.

                 -- We are floating the let-binding out, as if it had enclosed

                 -- the entire target from Day 1.  So we must add its binders to

                 -- the in-scope set (#20200)

                  , rs_bndrs = new_bndrs ++ rs_bndrs subst })

           e1 e2 mco

   | otherwise

   , Just (x2, e2', ts) <- exprIsLambda_maybe in_scope_env casted_e2

     -- See Note [Lambdas in the template]

   = let renv'  = rnMatchBndr2 renv x1 x2

     in  match renv' subst' e1 e2' MRefl

 match renv subst e1 e2@(Lam {}) mco

 eta_reduce :: RuleMatchEnv -> CoreExpr -> Maybe (RuleMatchEnv, CoreExpr)

 -- See Note [Eta reduction in the target]

 eta_reduce renv e@(Lam {})

   where

     go :: RuleMatchEnv -> BindWrapper -> [Var] -> CoreExpr

        -> Maybe (RuleMatchEnv, CoreExpr)

     go renv bw vs (Lam v e) = go renv' bw (v':vs) e

       where

       , v == rnOccR (rv_lcl renv) tv

       = go renv bw vs f

     go _    _  (_:_) _ = Nothing

 eta_reduce _ _ = Nothing