, 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

   --   and more direct to focus on the "hot" cases.

   -- e.g. auxiliary bindings have no NOLINE pragmas, RULEs, or stable unfoldings

   | exprIsTrivial new_rhs  -- Short-cut for let x = y in ...

   = return ( emptyFloats env

            , extendCvIdSubst env bndr new_rhs )  -- bndr can be a CoVar

              out_args     = contOutArgs env cont :: [OutExpr]

        ; mb_match <- if not (null rules_for_me) &&

                         (isClassOpId fun || activeUnfolding (seMode env) fun)

                      else return Nothing

        ; case mb_match of {

              Just (rule_arity, rhs) -> simplExprF env rhs $

                                        dropContArgs rule_arity cont ;

   = rebuild env (argInfoExpr fun rev_args) cont

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

   = do { let args = reverse rev_args

        ; case mb_match of

            Just (rule_arity, rhs) -> simplExprF env rhs $

                                      pushSimplifiedArgs env (drop rule_arity args) cont

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

 -}

          -> SimplM (Maybe (FullArgCount, CoreExpr))

   -- Fire a rule for the function

   = do { logger <- getLogger

        ; checkedTick (RuleFired (ruleName rule))

                  -- See Note [Occurrence-analyse after rule firing]

        ; dump logger rule rule_rhs

        ; return (Just (ruleArity rule, occ_anald_rhs)) }

 trySeqRules in_env scrut rhs cont

   = do { rule_base <- getSimplRules

        ; let seq_rules = getRules rule_base seqId

        ; case mb_match of

             Nothing                -> return Nothing

             Just (rule_arity, rhs) -> return (Just (rhs, cont'))

         | n_br >= 100 -> False  -- See #23627

         | n_br == 1, NotInsideLam <- in_lam  -- One syntactic occurrence

         -> True                              -- See Note [Post-inline for single-use things]

 --        | is_unlifted                        -- Unlifted binding, hence ok-for-spec

                                             -- so inlining duplicates code but nothing more

         | otherwise

               -- Multiple syntactic occurences; but lazy, and small enough to dup

               -- ToDo: consider discount on smallEnoughToInline if int_cxt is true

       _ -> False

   where

     work_ok NotInsideLam _              = True

     work_ok IsInsideLam  IsInteresting  = isCheapUnfolding unfolding

     work_ok IsInsideLam  NotInteresting = False

                  -> OutExpr -> [OutExpr] -> (OutExpr, [OutExpr])

 fireRewriteRules env (Var f) args

   | let rules = getRules (se_rules env) f

   , let rest_args    = drop (ruleArity rule) args -- See Note [Extra args in the target]

         zapped_subst = se_subst env   -- Just needed for the InScopeSet

         expr'        = simpleOptExprWith defaultSimpleOpts zapped_subst (mkApps expr rest_args)

 alreadyCovered env bndrs fn args is_active rules

   = case specLookupRule env fn args is_active rules of

       Nothing             -> False

         | isAutoRule rule -> -- Discard identical rules

                              -- We know that (fn args) is an instance of RULE

                              -- Check if RULE is an instance of (fn args)

 specLookupRule :: HasDebugCallStack

                => SpecEnv -> Id -> [CoreExpr]

                -> (ActivationGhc -> Bool)  -- Which rules are active

 specLookupRule env fn args is_active rules

   | null rules

   = Nothing    -- Saves building a few thunks in the common case

 module GHC.Core.Rules (

         -- ** Looking up rules

         lookupRule, matchExprs, ruleLhsIsMoreSpecific,

         -- ** RuleBase, RuleEnv

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

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

 -}

 -- | The main rule matching function. Attempts to apply all (active)

 -- supplied rules to this instance of an application in a given

 -- context, returning the rule applied and the resulting expression if

            -> Id -- Function head

            -> [CoreExpr] -- Args

            -> [CoreRule] -- Rules

 -- See Note [Extra args in the target]

 -- See comments on matchRule

     args' = map (stripTicksTopE tickishFloatable) args

     ticks = concatMap (stripTicksTopT tickishFloatable) args

     go ms [] = ms

     go ms (r:rs)

       | otherwise

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

         --   ppr [ (arg_id, maybeUnfoldingTemplate unf)

         go ms rs

 findBest :: InScopeSet -> (Id, [CoreExpr])

 -- All these pairs matched the expression

 -- Return the pair the most specific rule

 -- The (fn,args) is just for overlap reporting

   | debugIsOn = let pp_rule rule

                       = ifPprDebug (ppr rule)

                                    (doubleQuotes (ftext (ruleName rule)))

                                  <+> sep (map ppr args)

                                , text "Rule 1:" <+> pp_rule rule1

                                , text "Rule 2:" <+> pp_rule rule2]) $

 ruleIsMoreSpecific :: InScopeSet -> CoreRule -> CoreRule -> Bool

 -- The call (rule1 `ruleIsMoreSpecific` rule2)

           -> Id -> [CoreExpr] -> [Maybe Name]

           -> CoreRule -> Maybe CoreExpr

 -- then (f args) matches the rule, and the corresponding

 -- rewritten RHS is rhs

 --

 -- NB: The 'surplus' argument e4 in the input is simply dropped.

 -- See Note [Extra args in the target]

           (BuiltinRule { ru_try = match_fn })

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

 -- For a given match template and context, find bindings to wrap around

 -- the entire result and what should be substituted for each template variable.

 --

 -- If there are too /many/ actual arguments, we simply ignore the

 -- trailing ones, returning the result of applying the rule to a prefix

 -- of the actual arguments.

 matchExprs (ISE in_scope id_unf) tmpl_vars tmpl_es target_es

   = do  { rule_subst <- match_exprs init_menv emptyRuleSubst tmpl_es target_es

         ; let (_, matched_es) = mapAccumL (lookup_tmpl rule_subst)

             -> [CoreExpr]       -- Targets

             -> Maybe RuleSubst

 -- If the targets are longer than templates, succeed, simply ignoring

 --

 -- Precondition: corresponding elements of es1 and es2 have the same

 --               type, assuming earlier elements match.