, text "rhs:" <+> ppr rhs ])

         ; return (mkFloatBind env (NonRec bndr rhs)) }

 -- See Note [Cast worker/wrapper]

   where

     -- See Note [Wrapper activation] in GHC.Core.Opt.WorkWrap

     -- But simpler, because we don't need to disable during InitialPhase

     wrap_act | isNeverActive fn_act = activateDuringFinal

              | otherwise            = fn_act

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

 *                                                                      *

 import GHC.Data.OrdList

 import GHC.Data.List.SetOps

 import GHC.Types.Basic

 import GHC.Types.Unique.Supply

     (rhs_bndrs, rhs_body) = collectBindersPushingCo rhs

                             -- See Note [Account for casts in binding]

     not_in_scope :: InterestingVarFun

     not_in_scope v = isLocalVar v && not (v `elemInScopeSet` in_scope)

                  --      See Note [Arity decrease] in GHC.Core.Opt.Simplify

                  join_arity_decr = length rule_lhs_args         - length rule_rhs_args1

                  arity_decr      = count isValArg rule_lhs_args - count isId rule_rhs_args1

                  spec_fn_info

                                    `setInlinePragInfo` spec_inl_prag

                                    `setUnfoldingInfo`  spec_unf

 import GHC.Data.FastString

 import GHC.Types.Var

 import GHC.Types.Id

                    _        -> inl_act wrap_prag

     srcTxt = SourceText $ fsLit "{-# INLINE"

                              , inl_inline = fn_inline_spec

                              , inl_act    = work_act

                              , inl_rule   = FunLike }

                   | otherwise   = topDmd

     wrap_rhs  = wrap_fn work_id

     wrap_unf  = mkWrapperUnfolding simpl_opts wrap_rhs arity

     wrap_id   = fn_id `setIdUnfolding`  wrap_unf

     fn_unfolding    = realUnfoldingInfo fn_info

     fn_rules        = ruleInfoRules (ruleInfo fn_info)

 mkStrWrapperInlinePrag (InlinePragma { inl_inline = fn_inl

                                      , inl_act    = fn_act

                  , inl_inline = fn_inl

                       -- See Note [Worker/wrapper for INLINABLE functions]

     ------------  Inline prag  --------------

     inline_prag = inlinePragInfo id_info

     inline_hsinfo | isDefaultInlinePragma inline_prag = Nothing

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

 toIfUnfolding :: Bool -> Unfolding -> Maybe IfaceInfoItem

                      -- No SpecPrags (no dicts)

                      -- Can't be a default method (default methods are singletons)

                = do { dsHsWrapper wrap $ \core_wrap -> do

                              , core_wrap (Var lcl_id)) } }

        ; main_prs <- mapM mk_main exports

        ; let bind_prs' = map mk_aux_bind bind_prs

                                  mkVarApps (Var poly_tup_id) (tyvars ++ dicts)

                            rhs_for_spec = Let (NonRec poly_tup_id poly_tup_rhs) rhs

                      ; (spec_binds, rules) <- dsSpecs rhs_for_spec spec_prags

                                              `addIdSpecialisations` rules

                            -- Kill the INLINE pragma because it applies to

                            -- the user written (local) function.  The global

   = (gbl_id `setIdUnfolding` mkCompulsoryUnfolding' simpl_opts rhs, rhs)

   | otherwise

           NoUserInlinePrag -> (gbl_id, rhs)

           NoInline  {}     -> (gbl_id, rhs)

           Opaque    {}     -> (gbl_id, rhs)

           Inline    {}     -> inline_pair

   where

     simpl_opts    = initSimpleOpts dflags

     inlinable_unf = mkInlinableUnfolding simpl_opts StableUserSrc rhs

 dictArity :: [Var] -> Arity

 -- Don't count coercion variables in arity

              fn_unf     = realIdUnfolding poly_id

              spec_unf   = specUnfolding simpl_opts spec_bndrs mk_spec_body rule_lhs_args fn_unf

              spec_info  = vanillaIdInfo

                           `setUnfoldingInfo`  spec_unf

              spec_id    = mkLocalVar (idDetails poly_id) spec_name ManyTy spec_ty spec_info

                           -- Specialised binding is toplevel, hence Many.

        ; dsWarnOrphanRule rule

        ; case checkUselessSpecPrag poly_id rule_lhs_args spec_bndrs

            Nothing -> return (Just result)

            Just reason -> do { diagnosticDs $ DsUselessSpecialisePragma poly_nm is_dfun reason

     -- Is this SPECIALISE pragma useless?

 checkUselessSpecPrag :: Id -> [CoreExpr]

    ->  Maybe UselessSpecialisePragmaReason

 checkUselessSpecPrag poly_id rule_lhs_args

                      spec_bndrs no_act_spec spec_inl rule_act

 getCastedVar (Cast (Var v) co) = Just (v, MCo co)

 getCastedVar _                 = Nothing

 -- See Note [Activation pragmas for SPECIALISE]

 specFunInlinePrag poly_id id_inl spec_inl

   | not (isDefaultInlinePragma spec_inl)    = spec_inl

   | isGlobalId poly_id  -- See Note [Specialising imported functions]

                         -- in OccurAnal

   | otherwise                               = id_inl

      -- Get the INLINE pragma from SPECIALISE declaration, or,

      -- failing that, from the original Id

 dsWarnOrphanRule :: CoreRule -> DsM ()

 dsWarnOrphanRule rule

                      TopSigCtxt {} -> lookupLocatedOccRn WL_TermVariable v

                      _             -> lookupSigOccRn ctxt sig v

         ; (new_ty, fvs) <- foldM do_one ([],emptyFVs) tys

   where

     do_one (tys,fvs) ty

       = do { (new_ty, fvs_ty) <- rnHsSigType (SpecialiseSigCtx v) TypeLevel ty

        ; fn_name <- lookupOccRn WL_TermVariable fn_rdr  -- Checks that the head isn't forall-bound

        ; bindRuleBndrs (SpecECtx fn_rdr) bndrs $ \_ bndrs' ->

          do { (spec_e', fvs) <- rnLExpr spec_e

 renameSig ctxt sig@(InlineSig _ v s)

   = do  { new_v <- lookupSigOccRn ctxt sig v

 renameSig ctxt (FixSig _ fsig)

   = do  { new_fsig <- rnSrcFixityDecl ctxt fsig

 add_inl_arity :: Arity -> InlinePragma GhcRn -> InlinePragma GhcRn

 add_inl_arity ar prag@(InlinePragma { inl_inline = inl_spec })

   | Inline {} <- inl_spec  -- Add arity only for real INLINE pragmas, not INLINABLE

   | otherwise

   = prag

   | inl@(L _ prag) : inls <- inl_prags

   = do { traceTc "addInlinePrag" (ppr poly_id $$ ppr prag)

        ; unless (null inls) (warn_multiple_inlines inl inls)

   | otherwise

   = return poly_id

   where

 import GHC.Platform

 import GHC.Types.Basic ( TypeOrConstraint(..) )

 import GHC.Types.SourceText ( SourceText(..) )

 import GHC.Iface.Env( newGlobalBinder )

 import GHC.Core.TyCo.Rep( Type(..), TyLit(..) )

       | otherwise

       = do -- Place a NOINLINE pragma on KindReps since they tend to be quite

            -- large and bloat interface files.

                    <$> newSysLocalId (fsLit "$krep") ManyTy (mkTyConTy kindRepTyCon)

            -- do we need to tie a knot here?

 import GHC.Types.Var.Set

 import GHC.Types.Basic

 import GHC.Types.Id

 import GHC.Types.InlinePragma

 import GHC.Types.SourceFile

 import GHC.Types.SourceText

 -- is messing with.

 addDFunPrags dfun_id sc_meth_ids

  = dfun_id `setIdUnfolding`  mkDFunUnfolding dfun_bndrs dict_con dict_args

            -- NB: mkDFunUnfolding takes care of unary classes

  where

    dict_args  = map Type inst_tys ++ var_apps

    var_apps   = [mkVarApps (Var id) dfun_bndrs | id <- sc_meth_ids]

   = do  { logger <- getLogger

         ; dm_id <- tcLookupId dm_name

         ; let inline_prag :: InlinePragma GhcRn

               inline_prags | isAnyInlinePragma inline_prag

                            = [noLocA (InlineSig noAnn fn inline_prag)]

                            | otherwise

 tcSpecInst :: Id -> Sig GhcRn -> TcM TcSpecPrag

 tcSpecInst dfun_id prag@(SpecInstSig _ hs_ty)

   = addErrCtxt (SpecPragmaCtxt prag) $

 tcSpecInst _  _ = panic "tcSpecInst"

 module GHC.Types.Arity

    ( Arity

    , FullArgCount

    ) where

 import GHC.Prelude

 {-

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

 *                                                                      *

 -- See also Note [Definition of arity] in "GHC.Core.Opt.Arity"

 type Arity = Int

 -- | Representation Arity

 --

 -- are counted.

 type JoinArity = Int

 {- Note [Visibility and arity]

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 failed Failed    = True

 {-

   { inl_ghcrn_src   :: {-# UNPACK#-} !SourceText

   , inl_ghcrn_arity :: {-# UNPACK#-} !Arity

   }

   deriving (Eq, Data)

 type instance XInlinePragma GhcPs = SourceText

 type instance XXInlinePragma (GhcPass _) = DataConCantHappen

 defaultInlinePragma, alwaysInlinePragma, neverInlinePragma, dfunInlinePragma

 setInlinePragmaArity :: InlinePragma GhcPs -> Arity -> InlinePragma GhcTc

 setInlinePragmaArity prag@(InlinePragma { inl_ext = srcTxt }) arity =

 inlinePragmaSource :: forall p. IsPass p => InlinePragma (GhcPass p) -> SourceText

 import GHC.Core.Class

 import GHC.Core.Multiplicity

 import GHC.Types.RepType

 import GHC.Types.Demand

 OK not to if optimisation is switched off.

 -}

 idInlinePragma id = inlinePragInfo (idInfo id)

 setInlinePragma id prag = modifyIdInfo (`setInlinePragInfo` prag) id

 modifyInlinePragma id fn = modifyIdInfo (\info -> info `setInlinePragInfo` (fn (inlinePragInfo info))) id

 idInlineActivation :: Id -> Activation

 import GHC.Types.Demand

 import GHC.Types.Cpr

 import GHC.Types.InlinePragma

 import {-# SOURCE #-} GHC.Tc.Utils.TcType ( ConcreteTyVars, noConcreteTyVars )

 import GHC.Utils.Outputable

 import GHC.Utils.Panic

 import GHC.Stg.EnforceEpt.TagSig

         -- See Note [Specialisations and RULES in IdInfo]

         realUnfoldingInfo   :: Unfolding,

         -- ^ The 'Id's unfolding

         -- ^ Any inline pragma attached to the 'Id'

         occInfo         :: OccInfo,

         -- ^ How the 'Id' occurs in the program

 setRuleInfo :: IdInfo -> RuleInfo -> IdInfo

 setRuleInfo       info sp = sp `seq` info { ruleInfo = sp }

 setOccInfo :: IdInfo -> OccInfo -> IdInfo

 setOccInfo        info oc = oc `seq` info { occInfo = oc }

   = IdInfo {

             ruleInfo       = emptyRuleInfo,

             realUnfoldingInfo  = noUnfolding,

             occInfo        = noOccInfo,

             demandInfo     = topDmd,

             dmdSigInfo     = nopSig,

 import GHC.Core.Class

 import GHC.Core.DataCon

 import GHC.Types.Literal

 import GHC.Types.RepType ( countFunRepArgs, typePrimRep )

                       -- See Note [Strict fields in Core]

                    `setLFInfo`             wkr_lf_info

     wkr_arity = dataConRepArity data_con

     wkr_sig = mkClosedDmdSig wkr_dmds topDiv

            ; return (unbox_fn expr) }

 -- See Note [DataCon wrappers are conlike]

 dataConWrapperInlinePragma =  alwaysInlineConLikePragma

 -- a way to write this literal in Haskell.

 nullAddrId = pcMiscPrelId nullAddrName addrPrimTy info

   where

                        `setUnfoldingInfo`  mkCompulsoryUnfolding (Lit nullAddrLit)

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

 (c) The GRASP/AQUA Project, Glasgow University, 1997-1998

 -}

 module GHC.Types.InlinePragma

   ( -- * Inline Pragma Encoding

   , neverInlinePragma

     -- *** Field accessors

   , inlinePragmaActivation

   , inlinePragmaName

   , inlinePragmaRuleMatchInfo

   , inlinePragmaSource

   , isNoInlinePragma

   , isOpaquePragma

     -- *** Mutators

   , setInlinePragmaActivation

   , setInlinePragmaRuleMatchInfo

     -- *** GHC pass conversions

   , promoteInlinePragmaRn

     -- *** Pretty-printing

   , pprInline

   , pprInlineDebug

     -- ** Extensible record type for GhcRn & GhcTc

     -- ** InlineSpec

     -- *** Data-type

 import GHC.Data.FastString

 import GHC.Utils.Binary

 import GHC.Utils.Outputable

 import Control.DeepSeq (NFData(..))

 import Language.Haskell.Syntax.Binds.InlinePragma

 import Language.Haskell.Syntax.Extension

 data XInlinePragmaGhc = XInlinePragmaGhc

   { xinl_src :: SourceText

       -- ^ See Note [Pragma source text]

       -- (non-type, non-dictionary) arguments.

       --

       -- That is, 'xinl_sat' describes the number of *source-code*

   }

   deriving (Eq, Data)

 type instance XInlinePragma GhcPs = SourceText

 type instance XXInlinePragma (GhcPass _) = DataConCantHappen

 -- A DFun has an always-active inline activation so that

 -- exprIsConApp_maybe can "see" its unfolding

 -- (However, its actual Unfolding is a DFunUnfolding, which is

 --  never inlined other than via exprIsConApp_maybe.)

 isDefaultInlinePragma :: InlinePragma p -> Bool

 isDefaultInlinePragma (XInlinePragma _) = False

                                     , inl_inline = inline })

   = noUserInlineSpec inline && isAlwaysActive activation && isFunLike match_info

 setInlinePragmaArity prag arity =

 inlinePragmaSource :: forall p. IsPass p => InlinePragma (GhcPass p) -> SourceText