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

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

 -- See Note [Cast worker/wrapper]

 mkCastWrapperInlinePrag prag = prag

   `setInlinePragmaSource` src_txt

   --       in GHC.Core.Opt.WorkWrap

   --       in GHC.Core.Opt.WorkWrap

   where

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

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

 import GHC.Data.OrdList

 import GHC.Data.List.SetOps

 import GHC.Types.Basic

 import GHC.Types.Unique.Supply

     -- Copy InlinePragma information from the parent Id.

     -- So if f has INLINE[1] so does spec_fn

     spec_inl_prag

       | not is_local     -- See Note [Specialising imported functions]

       , isStrongLoopBreaker (idOccInfo fn) -- in GHC.Core.Opt.OccurAnal

 import GHC.Data.FastString

 import GHC.Types.Var

 import GHC.Types.Id

     fn_unfolding    = realUnfoldingInfo fn_info

     fn_rules        = ruleInfoRules (ruleInfo fn_info)

 mkStrWrapperInlinePrag (InlinePragma { inl_inline = fn_inl

                                      , inl_act    = fn_act

                                      , inl_rule   = rule_info }) rules

 import GHC.Core.Opt.OccurAnal( occurAnalyseExpr )

 import GHC.Core.Rules.Config (roBuiltinRules)

 import GHC.Tc.Utils.TcType  ( tcSplitTyConApp_maybe )

 import GHC.Builtin.Types    ( anyTypeOfKind )

                           in ds `unionBags` go env' binds

 data RuleCheckEnv = RuleCheckEnv

     , rc_id_unf    :: IdUnfoldingFun

     , rc_pattern   :: String

     , rc_rules     :: Id -> [CoreRule]

 import GHC.Utils.Panic

 import GHC.Utils.Misc

 import Data.Maybe ( isNothing, catMaybes )

              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.

 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

 import GHC.Builtin.Types ( constraintKindTyConName )

 import GHC.Stg.EnforceEpt.TagSig

 import GHC.Parser.Annotation (noLocA)

 import GHC.Hs.Doc ( WithHsDocIdentifiers(..) )

 import GHC.Utils.Lexeme (isLexSym)

   = HsArity         Arity

   | HsDmdSig        DmdSig

   | HsCprSig        CprSig

   | HsUnfold        Bool             -- True <=> isStrongLoopBreaker is true

                     IfaceUnfolding   -- See Note [Expose recursive functions]

   | HsNoCafRefs

   | 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

     warn_multiple_inlines _ [] = return ()

     tc_one hs_ty

       = do { spec_ty <- tcHsSigType   (FunSigCtxt name NoRRC) hs_ty

            ; wrap    <- tcSpecWrapper (FunSigCtxt name (lhsSigTypeContextSpan hs_ty)) poly_ty spec_ty

 tcSpecPrag poly_id (SpecSigE nm rule_bndrs spec_e inl)

   -- For running commentary, see Note [Handling new-form SPECIALISE pragmas]

                            , spe_bndrs = qevs ++ rule_bndrs' -- Dependency order

                                                              -- does not matter

                            , spe_call  = lhs_call

 tcSpecPrag _ prag = pprPanic "tcSpecPrag" (ppr prag)

 mkDefMethBind loc dfun_id clas sel_id dm_name dm_spec

   = do  { logger <- getLogger

         ; dm_id <- tcLookupId dm_name

               inline_prags | isAnyInlinePragma inline_prag

                            = [noLocA (InlineSig noAnn fn inline_prag)]

                            | otherwise

 import GHC.Core.Class

 import GHC.Core.Multiplicity

 import GHC.Types.RepType

 import GHC.Types.Demand

 -- | Returns an unfolding only if

 --   (a) not a strong loop breaker and

 --   (b) active in according to is_active

 whenActiveUnfoldingFun is_active id

   | is_active (idInlineActivation id) = idUnfolding id

   | otherwise                         = NoUnfolding

 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 = inlinePragmaActivation (idInlinePragma id)

 setInlineActivation id act = modifyInlinePragma id (\prag -> setInlinePragmaActivation prag act)

 idRuleMatchInfo :: Id -> RuleMatchInfo

         realUnfoldingInfo, unfoldingInfo, setUnfoldingInfo, hasInlineUnfolding,

         -- ** The InlinePragInfo type

         inlinePragInfo, setInlinePragInfo,

         -- ** The OccInfo type

 import GHC.Core.Type (mkTyConApp)

 import GHC.Core.PatSyn

 import GHC.Core.ConLike

 import GHC.Types.ForeignCall

 import GHC.Unit.Module

 import GHC.Types.Demand

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

 setInlinePragInfo info pr = pr `seq` info { inlinePragInfo = pr }

 setOccInfo :: IdInfo -> OccInfo -> IdInfo

 ppArityInfo 0 = empty

 ppArityInfo n = hsep [text "Arity", int n]

 {-

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

 *                                                                      *

 import GHC.Core.Class

 import GHC.Core.DataCon

 import GHC.Types.Literal

 import GHC.Types.RepType ( countFunRepArgs, typePrimRep )

 import GHC.Types.Name.Set

                       -- See Note [Strict fields in Core]

                    `setLFInfo`             wkr_lf_info

     wkr_inline_prag = alwaysInlineConLikePragma

     wkr_arity = dataConRepArity data_con

            ; return (unbox_fn expr) }

 -- See Note [DataCon wrappers are conlike]

 dataConWrapperInlinePragma =  alwaysInlineConLikePragma

     -- ** InlinePragma

     -- *** Data-type

     InlinePragma(..)

     -- *** Constants

   , defaultInlinePragma

   , alwaysInlinePragma

   , setInlinePragmaSpec

   , setInlinePragmaRuleMatchInfo

     -- *** GHC pass conversions

     -- *** Pretty-printing

   , pprInline

   , pprInlineDebug

   rnf (AppliedToAtLeast !w) = rnf w `seq` ()

   rnf !AnySaturation = ()

 data XInlinePragmaGhc = XInlinePragmaGhc

   { xinl_src :: SourceText

       -- ^ See Note [Pragma source text]

 type instance XXInlinePragma (GhcPass _) = DataConCantHappen

 type instance XXActivation   (GhcPass _) = XXActivationGhc

 -- | The default 'InlinePragma' definition for GHC.

 -- The type and value of 'inl_ext' provided will differ

 -- between the passes of GHC. Consequently, it may be

   => InlinePragma (GhcPass p) -> InlineSaturation

 inlinePragmaSaturation = xinl_sat . inl_ext

 inlinePragmaSpec :: InlinePragma p -> InlineSpec

 inlinePragmaSpec = inl_inline

   AlwaysActive   -> AlwaysActive

   NeverActive    -> NeverActive

 activateAfterInitial :: Activation (GhcPass p)

 -- ^ Active in the first phase after the initial phase

 activateAfterInitial = activeAfter (nextPhase InitialPhase)

     -- *** Data-type

   , Activation(..)

   , PhaseNum

   ) where

 import Language.Haskell.Syntax.Extension

     ActiveBefore aa -> rnf aa

     ActiveAfter ab -> rnf ab

     XActivation x -> rnf x `seq` ()

 type family XXSig             x

 -- Inline Pragma families

 -- Inline Activation family

 type family XXActivation   x