    {-
    (c) The University of Glasgow 2006
    (c) The GRASP/AQUA Project, Glasgow University, 1993-1998
    -}

    {-# LANGUAGE CPP #-}
    {-# LANGUAGE LambdaCase #-}

    module GHC.Iface.Syntax (
            module GHC.Iface.Type,

            IfaceDecl(..), IfaceFamTyConFlav(..), IfaceClassOp(..), IfaceAT(..),
            IfaceConDecl(..), IfaceConDecls(..), IfaceEqSpec,
            IfaceExpr(..), IfaceAlt(..), IfaceLetBndr(..), IfaceJoinInfo(..),
            IfaceBinding(..), IfaceConAlt(..),
            IfaceIdInfo, IfaceIdDetails(..), IfaceUnfolding(..),
            IfaceInfoItem(..), IfaceRule(..), IfaceAnnotation(..), IfaceAnnTarget,
            IfaceClsInst(..), IfaceFamInst(..), IfaceTickish(..),
            IfaceClassBody(..),
            IfaceBang(..),
            IfaceSrcBang(..), SrcUnpackedness(..), SrcStrictness(..),
            IfaceAxBranch(..),
            IfaceTyConParent(..),
            IfaceCompleteMatch(..),
            IfaceLFInfo(..),

            -- * Binding names
            IfaceTopBndr,
            putIfaceTopBndr, getIfaceTopBndr,

            -- Misc
            ifaceDeclImplicitBndrs, visibleIfConDecls,
            ifaceDeclFingerprints,

            -- Free Names
            freeNamesIfDecl, freeNamesIfRule, freeNamesIfFamInst,

            -- Pretty printing
            pprIfaceExpr,
            pprIfaceDecl,
            AltPpr(..), ShowSub(..), ShowHowMuch(..), showToIface, showToHeader
        ) where

    #include "HsVersions.h"

    import GHC.Prelude

    import GHC.Builtin.Names ( unrestrictedFunTyConKey, liftedTypeKindTyConKey )
    import GHC.Types.Unique ( hasKey )
    import GHC.Iface.Type
    import GHC.Iface.Recomp.Binary
    import GHC.Core( IsOrphan, isOrphan )
    import GHC.Types.Demand
    import GHC.Types.Cpr
    import GHC.Core.Class
    import GHC.Types.FieldLabel
    import GHC.Types.Name.Set
    import GHC.Core.Coercion.Axiom ( BranchIndex )
    import GHC.Types.Name
    import GHC.Types.CostCentre
    import GHC.Types.Literal
    import GHC.Types.ForeignCall
    import GHC.Types.Annotations( AnnPayload, AnnTarget )
    import GHC.Types.Basic
    import GHC.Unit.Module
    import GHC.Types.SrcLoc
    import GHC.Data.BooleanFormula ( BooleanFormula, pprBooleanFormula, isTrue )
    import GHC.Types.Var( VarBndr(..), binderVar, tyVarSpecToBinders )
    import GHC.Core.TyCon ( Role (..), Injectivity(..), tyConBndrVisArgFlag )
    import GHC.Core.DataCon (SrcStrictness(..), SrcUnpackedness(..))
    import GHC.Builtin.Types ( constraintKindTyConName )

    import GHC.Utils.Lexeme (isLexSym)
    import GHC.Utils.Fingerprint
    import GHC.Utils.Binary
    import GHC.Utils.Binary.Typeable ()
    import GHC.Utils.Outputable as Outputable
    import GHC.Utils.Panic
    import GHC.Utils.Misc( dropList, filterByList, notNull, unzipWith, debugIsOn,
                           seqList, zipWithEqual )

    import Control.Monad
    import System.IO.Unsafe
    import Control.DeepSeq

    infixl 3 &&&

    {-
    ************************************************************************
    *                                                                      *
                        Declarations
    *                                                                      *
    ************************************************************************
    -}

    -- | A binding top-level 'Name' in an interface file (e.g. the name of an
    -- 'IfaceDecl').
    type IfaceTopBndr = Name
      -- It's convenient to have a Name in the Iface syntax, although in each
      -- case the namespace is implied by the context. However, having a
      -- Name makes things like ifaceDeclImplicitBndrs and ifaceDeclFingerprints
      -- very convenient. Moreover, having the key of the binder means that
      -- we can encode known-key things cleverly in the symbol table. See Note
      -- [Symbol table representation of Names]
      --
      -- We don't serialise the namespace onto the disk though; rather we
      -- drop it when serialising and add it back in when deserialising.

    getIfaceTopBndr :: BinHandle -> IO IfaceTopBndr
    getIfaceTopBndr :: BinHandle -> IO IfExtName
    getIfaceTopBndr BinHandle
    bh = BinHandle -> IO IfExtName
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh

    putIfaceTopBndr :: BinHandle -> IfaceTopBndr -> IO ()
    putIfaceTopBndr :: BinHandle -> IfExtName -> IO ()
    putIfaceTopBndr BinHandle
    bh IfExtName
    name =
        case BinHandle -> UserData
    getUserData BinHandle
    bh of
          UserData{ ud_put_binding_name :: UserData -> BinHandle -> IfExtName -> IO ()
    ud_put_binding_name = BinHandle -> IfExtName -> IO ()
    put_binding_name } ->
              --pprTrace "putIfaceTopBndr" (ppr name) $
              BinHandle -> IfExtName -> IO ()
    put_binding_name BinHandle
    bh IfExtName
    name

    data IfaceDecl
      = IfaceId { IfaceDecl -> IfExtName
    ifName      :: IfaceTopBndr,
                  IfaceDecl -> IfaceType
    ifType      :: IfaceType,
                  IfaceDecl -> IfaceIdDetails
    ifIdDetails :: IfaceIdDetails,
                  IfaceDecl -> IfaceIdInfo
    ifIdInfo    :: IfaceIdInfo
                  }

      | IfaceData { ifName       :: IfaceTopBndr,   -- Type constructor
                    IfaceDecl -> [IfaceTyConBinder]
    ifBinders    :: [IfaceTyConBinder],
                    IfaceDecl -> IfaceType
    ifResKind    :: IfaceType,      -- Result kind of type constructor
                    IfaceDecl -> Maybe CType
    ifCType      :: Maybe CType,    -- C type for CAPI FFI
                    IfaceDecl -> [Role]
    ifRoles      :: [Role],         -- Roles
                    IfaceDecl -> IfaceContext
    ifCtxt       :: IfaceContext,   -- The "stupid theta"
                    IfaceDecl -> IfaceConDecls
    ifCons       :: IfaceConDecls,  -- Includes new/data/data family info
                    IfaceDecl -> Bool
    ifGadtSyntax :: Bool,           -- True <=> declared using
                                                    -- GADT syntax
                    IfaceDecl -> IfaceTyConParent
    ifParent     :: IfaceTyConParent -- The axiom, for a newtype,
                                                     -- or data/newtype family instance
        }

      | IfaceSynonym { ifName    :: IfaceTopBndr,      -- Type constructor
                       ifRoles   :: [Role],            -- Roles
                       ifBinders :: [IfaceTyConBinder],
                       ifResKind :: IfaceKind,         -- Kind of the *result*
                       IfaceDecl -> IfaceType
    ifSynRhs  :: IfaceType }

      | IfaceFamily  { ifName    :: IfaceTopBndr,      -- Type constructor
                       IfaceDecl -> Maybe IfLclName
    ifResVar  :: Maybe IfLclName,   -- Result variable name, used
                                                       -- only for pretty-printing
                                                       -- with --show-iface
                       ifBinders :: [IfaceTyConBinder],
                       ifResKind :: IfaceKind,         -- Kind of the *tycon*
                       IfaceDecl -> IfaceFamTyConFlav
    ifFamFlav :: IfaceFamTyConFlav,
                       IfaceDecl -> Injectivity
    ifFamInj  :: Injectivity }      -- injectivity information

      | IfaceClass { ifName    :: IfaceTopBndr,             -- Name of the class TyCon
                     ifRoles   :: [Role],                   -- Roles
                     ifBinders :: [IfaceTyConBinder],
                     IfaceDecl -> [FunDep IfLclName]
    ifFDs     :: [FunDep IfLclName],       -- Functional dependencies
                     IfaceDecl -> IfaceClassBody
    ifBody    :: IfaceClassBody            -- Methods, superclasses, ATs
        }

      | IfaceAxiom { ifName       :: IfaceTopBndr,        -- Axiom name
                     IfaceDecl -> IfaceTyCon
    ifTyCon      :: IfaceTyCon,     -- LHS TyCon
                     IfaceDecl -> Role
    ifRole       :: Role,           -- Role of axiom
                     IfaceDecl -> [IfaceAxBranch]
    ifAxBranches :: [IfaceAxBranch] -- Branches
        }

      | IfacePatSyn { ifName          :: IfaceTopBndr,           -- Name of the pattern synonym
                      IfaceDecl -> Bool
    ifPatIsInfix    :: Bool,
                      IfaceDecl -> (IfExtName, Bool)
    ifPatMatcher    :: (IfExtName, Bool),
                      IfaceDecl -> Maybe (IfExtName, Bool)
    ifPatBuilder    :: Maybe (IfExtName, Bool),
                      -- Everything below is redundant,
                      -- but needed to implement pprIfaceDecl
                      IfaceDecl -> [IfaceForAllSpecBndr]
    ifPatUnivBndrs  :: [IfaceForAllSpecBndr],
                      IfaceDecl -> [IfaceForAllSpecBndr]
    ifPatExBndrs    :: [IfaceForAllSpecBndr],
                      IfaceDecl -> IfaceContext
    ifPatProvCtxt   :: IfaceContext,
                      IfaceDecl -> IfaceContext
    ifPatReqCtxt    :: IfaceContext,
                      IfaceDecl -> IfaceContext
    ifPatArgs       :: [IfaceType],
                      IfaceDecl -> IfaceType
    ifPatTy         :: IfaceType,
                      IfaceDecl -> [FieldLabel]
    ifFieldLabels   :: [FieldLabel] }

    -- See also 'ClassBody'
    data IfaceClassBody
      -- Abstract classes don't specify their body; they only occur in @hs-boot@ and
      -- @hsig@ files.
      = IfAbstractClass
      | IfConcreteClass {
         IfaceClassBody -> IfaceContext
    ifClassCtxt :: IfaceContext,             -- Super classes
         IfaceClassBody -> [IfaceAT]
    ifATs       :: [IfaceAT],                -- Associated type families
         IfaceClassBody -> [IfaceClassOp]
    ifSigs      :: [IfaceClassOp],           -- Method signatures
         IfaceClassBody -> BooleanFormula IfLclName
    ifMinDef    :: BooleanFormula IfLclName  -- Minimal complete definition
        }

    data IfaceTyConParent
      = IfNoParent
      | IfDataInstance
           IfExtName     -- Axiom name
           IfaceTyCon    -- Family TyCon (pretty-printing only, not used in GHC.IfaceToCore)
                         -- see Note [Pretty printing via Iface syntax] in GHC.Types.TyThing.Ppr
           IfaceAppArgs  -- Arguments of the family TyCon

    data IfaceFamTyConFlav
      = IfaceDataFamilyTyCon                      -- Data family
      | IfaceOpenSynFamilyTyCon
      | IfaceClosedSynFamilyTyCon (Maybe (IfExtName, [IfaceAxBranch]))
        -- ^ Name of associated axiom and branches for pretty printing purposes,
        -- or 'Nothing' for an empty closed family without an axiom
        -- See Note [Pretty printing via Iface syntax] in "GHC.Types.TyThing.Ppr"
      | IfaceAbstractClosedSynFamilyTyCon
      | IfaceBuiltInSynFamTyCon -- for pretty printing purposes only

    data IfaceClassOp
      = IfaceClassOp IfaceTopBndr
                     IfaceType                         -- Class op type
                     (Maybe (DefMethSpec IfaceType))   -- Default method
                     -- The types of both the class op itself,
                     -- and the default method, are *not* quantified
                     -- over the class variables

    data IfaceAT = IfaceAT  -- See GHC.Core.Class.ClassATItem
                      IfaceDecl          -- The associated type declaration
                      (Maybe IfaceType)  -- Default associated type instance, if any

    -- This is just like CoAxBranch
    data IfaceAxBranch = IfaceAxBranch { IfaceAxBranch -> [IfaceTvBndr]
    ifaxbTyVars    :: [IfaceTvBndr]
                                       , IfaceAxBranch -> [IfaceTvBndr]
    ifaxbEtaTyVars :: [IfaceTvBndr]
                                       , IfaceAxBranch -> [IfaceIdBndr]
    ifaxbCoVars    :: [IfaceIdBndr]
                                       , IfaceAxBranch -> IfaceAppArgs
    ifaxbLHS       :: IfaceAppArgs
                                       , IfaceAxBranch -> [Role]
    ifaxbRoles     :: [Role]
                                       , IfaceAxBranch -> IfaceType
    ifaxbRHS       :: IfaceType
                                       , IfaceAxBranch -> [Int]
    ifaxbIncomps   :: [BranchIndex] }
                                         -- See Note [Storing compatibility] in GHC.Core.Coercion.Axiom

    data IfaceConDecls
      = IfAbstractTyCon     -- c.f TyCon.AbstractTyCon
      | IfDataTyCon [IfaceConDecl] -- Data type decls
      | IfNewTyCon  IfaceConDecl   -- Newtype decls

    -- For IfDataTyCon and IfNewTyCon we store:
    --  * the data constructor(s);
    -- The field labels are stored individually in the IfaceConDecl
    -- (there is some redundancy here, because a field label may occur
    -- in multiple IfaceConDecls and represent the same field label)

    data IfaceConDecl
      = IfCon {
            IfaceConDecl -> IfExtName
    ifConName    :: IfaceTopBndr,                -- Constructor name
            IfaceConDecl -> Bool
    ifConWrapper :: Bool,                   -- True <=> has a wrapper
            IfaceConDecl -> Bool
    ifConInfix   :: Bool,                   -- True <=> declared infix

            -- The universal type variables are precisely those
            -- of the type constructor of this data constructor
            -- This is *easy* to guarantee when creating the IfCon
            -- but it's not so easy for the original TyCon/DataCon
            -- So this guarantee holds for IfaceConDecl, but *not* for DataCon

            IfaceConDecl -> [IfaceBndr]
    ifConExTCvs   :: [IfaceBndr],  -- Existential ty/covars
            IfaceConDecl -> [IfaceForAllSpecBndr]
    ifConUserTvBinders :: [IfaceForAllSpecBndr],
              -- The tyvars, in the order the user wrote them
              -- INVARIANT: the set of tyvars in ifConUserTvBinders is exactly the
              --            set of tyvars (*not* covars) of ifConExTCvs, unioned
              --            with the set of ifBinders (from the parent IfaceDecl)
              --            whose tyvars do not appear in ifConEqSpec
              -- See Note [DataCon user type variable binders] in GHC.Core.DataCon
            IfaceConDecl -> [IfaceTvBndr]
    ifConEqSpec  :: IfaceEqSpec,        -- Equality constraints
            IfaceConDecl -> IfaceContext
    ifConCtxt    :: IfaceContext,       -- Non-stupid context
            IfaceConDecl -> [(IfaceType, IfaceType)]
    ifConArgTys  :: [(IfaceMult, IfaceType)],-- Arg types
            IfaceConDecl -> [FieldLabel]
    ifConFields  :: [FieldLabel],  -- ...ditto... (field labels)
            IfaceConDecl -> [IfaceBang]
    ifConStricts :: [IfaceBang],
              -- Empty (meaning all lazy),
              -- or 1-1 corresp with arg tys
              -- See Note [Bangs on imported data constructors] in GHC.Types.Id.Make
            IfaceConDecl -> [IfaceSrcBang]
    ifConSrcStricts :: [IfaceSrcBang] } -- empty meaning no src stricts

    type IfaceEqSpec = [(IfLclName,IfaceType)]

    -- | This corresponds to an HsImplBang; that is, the final
    -- implementation decision about the data constructor arg
    data IfaceBang
      = IfNoBang | IfStrict | IfUnpack | IfUnpackCo IfaceCoercion

    -- | This corresponds to HsSrcBang
    data IfaceSrcBang
      = IfSrcBang SrcUnpackedness SrcStrictness

    data IfaceClsInst
      = IfaceClsInst { IfaceClsInst -> IfExtName
    ifInstCls  :: IfExtName,                -- See comments with
                       IfaceClsInst -> [Maybe IfaceTyCon]
    ifInstTys  :: [Maybe IfaceTyCon],       -- the defn of ClsInst
                       IfaceClsInst -> IfExtName
    ifDFun     :: IfExtName,                -- The dfun
                       IfaceClsInst -> OverlapFlag
    ifOFlag    :: OverlapFlag,              -- Overlap flag
                       IfaceClsInst -> IsOrphan
    ifInstOrph :: IsOrphan }                -- See Note [Orphans] in GHC.Core.InstEnv
            -- There's always a separate IfaceDecl for the DFun, which gives
            -- its IdInfo with its full type and version number.
            -- The instance declarations taken together have a version number,
            -- and we don't want that to wobble gratuitously
            -- If this instance decl is *used*, we'll record a usage on the dfun;
            -- and if the head does not change it won't be used if it wasn't before

    -- The ifFamInstTys field of IfaceFamInst contains a list of the rough
    -- match types
    data IfaceFamInst
      = IfaceFamInst { IfaceFamInst -> IfExtName
    ifFamInstFam      :: IfExtName            -- Family name
                     , IfaceFamInst -> [Maybe IfaceTyCon]
    ifFamInstTys      :: [Maybe IfaceTyCon]   -- See above
                     , IfaceFamInst -> IfExtName
    ifFamInstAxiom    :: IfExtName            -- The axiom
                     , IfaceFamInst -> IsOrphan
    ifFamInstOrph     :: IsOrphan             -- Just like IfaceClsInst
                     }

    data IfaceRule
      = IfaceRule {
            IfaceRule -> IfLclName
    ifRuleName   :: RuleName,
            IfaceRule -> Activation
    ifActivation :: Activation,
            IfaceRule -> [IfaceBndr]
    ifRuleBndrs  :: [IfaceBndr],    -- Tyvars and term vars
            IfaceRule -> IfExtName
    ifRuleHead   :: IfExtName,      -- Head of lhs
            IfaceRule -> [IfaceExpr]
    ifRuleArgs   :: [IfaceExpr],    -- Args of LHS
            IfaceRule -> IfaceExpr
    ifRuleRhs    :: IfaceExpr,
            IfaceRule -> Bool
    ifRuleAuto   :: Bool,
            IfaceRule -> IsOrphan
    ifRuleOrph   :: IsOrphan   -- Just like IfaceClsInst
        }

    data IfaceAnnotation
      = IfaceAnnotation {
            IfaceAnnotation -> IfaceAnnTarget
    ifAnnotatedTarget :: IfaceAnnTarget,
            IfaceAnnotation -> AnnPayload
    ifAnnotatedValue  :: AnnPayload
      }

    type IfaceAnnTarget = AnnTarget OccName

    data IfaceCompleteMatch = IfaceCompleteMatch [IfExtName] (Maybe IfaceTyCon)

    instance Outputable IfaceCompleteMatch where
      ppr :: IfaceCompleteMatch -> SDoc
    ppr (IfaceCompleteMatch [IfExtName]
    cls Maybe IfaceTyCon
    mtc) = String -> SDoc
    text String
    "COMPLETE" SDoc -> SDoc -> SDoc
    <> SDoc
    colon SDoc -> SDoc -> SDoc
    <+> [IfExtName] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [IfExtName]
    cls SDoc -> SDoc -> SDoc
    <+> case Maybe IfaceTyCon
    mtc of
        Maybe IfaceTyCon
    Nothing -> SDoc
    empty
        Just IfaceTyCon
    tc -> SDoc
    dcolon SDoc -> SDoc -> SDoc
    <+> IfaceTyCon -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfaceTyCon
    tc

    -- Here's a tricky case:
    --   * Compile with -O module A, and B which imports A.f
    --   * Change function f in A, and recompile without -O
    --   * When we read in old A.hi we read in its IdInfo (as a thunk)
    --      (In earlier GHCs we used to drop IdInfo immediately on reading,
    --       but we do not do that now.  Instead it's discarded when the
    --       ModIface is read into the various decl pools.)
    --   * The version comparison sees that new (=NoInfo) differs from old (=HasInfo *)
    --      and so gives a new version.

    type IfaceIdInfo = [IfaceInfoItem]

    data IfaceInfoItem
      = HsArity         Arity
      | HsStrictness    StrictSig
      | HsCpr           CprSig
      | HsInline        InlinePragma
      | HsUnfold        Bool             -- True <=> isStrongLoopBreaker is true
                        IfaceUnfolding   -- See Note [Expose recursive functions]
      | HsNoCafRefs
      | HsLevity                         -- Present <=> never levity polymorphic
      | HsLFInfo        IfaceLFInfo

    -- NB: Specialisations and rules come in separately and are
    -- only later attached to the Id.  Partial reason: some are orphans.

    data IfaceUnfolding
      = IfCoreUnfold Bool IfaceExpr -- True <=> INLINABLE, False <=> regular unfolding
                                    -- Possibly could eliminate the Bool here, the information
                                    -- is also in the InlinePragma.

      | IfCompulsory IfaceExpr      -- default methods and unsafeCoerce#
                                    -- for more about unsafeCoerce#, see
                                    -- Note [Wiring in unsafeCoerce#] in "GHC.HsToCore"

      | IfInlineRule Arity          -- INLINE pragmas
                     Bool           -- OK to inline even if *un*-saturated
                     Bool           -- OK to inline even if context is boring
                     IfaceExpr

      | IfDFunUnfold [IfaceBndr] [IfaceExpr]

    -- We only serialise the IdDetails of top-level Ids, and even then
    -- we only need a very limited selection.  Notably, none of the
    -- implicit ones are needed here, because they are not put it
    -- interface files

    data IfaceIdDetails
      = IfVanillaId
      | IfRecSelId (Either IfaceTyCon IfaceDecl) Bool
      | IfDFunId

    -- | Iface type for LambdaFormInfo. Fields not relevant for imported Ids are
    -- omitted in this type.
    data IfaceLFInfo
      = IfLFReEntrant !RepArity
      | IfLFThunk
          !Bool -- True <=> updatable
          !Bool -- True <=> might be a function type
      | IfLFCon !Name
      | IfLFUnknown !Bool
      | IfLFUnlifted

    instance Outputable IfaceLFInfo where
        ppr :: IfaceLFInfo -> SDoc
    ppr (IfLFReEntrant Int
    arity) =
          String -> SDoc
    text String
    "LFReEntrant" SDoc -> SDoc -> SDoc
    <+> Int -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Int
    arity

        ppr (IfLFThunk Bool
    updatable Bool
    mb_fun) =
          String -> SDoc
    text String
    "LFThunk" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    parens
            (String -> SDoc
    text String
    "updatable=" SDoc -> SDoc -> SDoc
    <> Bool -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Bool
    updatable SDoc -> SDoc -> SDoc
    <+>
             String -> SDoc
    text String
    "might_be_function=" SDoc -> SDoc -> SDoc
    <+> Bool -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Bool
    mb_fun)

        ppr (IfLFCon IfExtName
    con) =
          String -> SDoc
    text String
    "LFCon" SDoc -> SDoc -> SDoc
    <> SDoc -> SDoc
    brackets (IfExtName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfExtName
    con)

        ppr IfaceLFInfo
    IfLFUnlifted =
          String -> SDoc
    text String
    "LFUnlifted"

        ppr (IfLFUnknown Bool
    fun_flag) =
          String -> SDoc
    text String
    "LFUnknown" SDoc -> SDoc -> SDoc
    <+> Bool -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Bool
    fun_flag

    instance Binary IfaceLFInfo where
        put_ :: BinHandle -> IfaceLFInfo -> IO ()
    put_ BinHandle
    bh (IfLFReEntrant Int
    arity) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    0
            BinHandle -> Int -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Int
    arity
        put_ BinHandle
    bh (IfLFThunk Bool
    updatable Bool
    mb_fun) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    1
            BinHandle -> Bool -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Bool
    updatable
            BinHandle -> Bool -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Bool
    mb_fun
        put_ BinHandle
    bh (IfLFCon IfExtName
    con_name) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    2
            BinHandle -> IfExtName -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfExtName
    con_name
        put_ BinHandle
    bh (IfLFUnknown Bool
    fun_flag) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    3
            BinHandle -> Bool -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Bool
    fun_flag
        put_ BinHandle
    bh IfaceLFInfo
    IfLFUnlifted =
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    4
        get :: BinHandle -> IO IfaceLFInfo
    get BinHandle
    bh = do
            Word8
    tag <- BinHandle -> IO Word8
    getByte BinHandle
    bh
            case Word8
    tag of
                Word8
    0 -> Int -> IfaceLFInfo
    IfLFReEntrant (Int -> IfaceLFInfo) -> IO Int -> IO IfaceLFInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> BinHandle -> IO Int
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                Word8
    1 -> Bool -> Bool -> IfaceLFInfo
    IfLFThunk (Bool -> Bool -> IfaceLFInfo)
    -> IO Bool -> IO (Bool -> IfaceLFInfo)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> BinHandle -> IO Bool
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh IO (Bool -> IfaceLFInfo) -> IO Bool -> IO IfaceLFInfo
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> BinHandle -> IO Bool
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                Word8
    2 -> IfExtName -> IfaceLFInfo
    IfLFCon (IfExtName -> IfaceLFInfo) -> IO IfExtName -> IO IfaceLFInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> BinHandle -> IO IfExtName
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                Word8
    3 -> Bool -> IfaceLFInfo
    IfLFUnknown (Bool -> IfaceLFInfo) -> IO Bool -> IO IfaceLFInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> BinHandle -> IO Bool
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                Word8
    4 -> IfaceLFInfo -> IO IfaceLFInfo
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure IfaceLFInfo
    IfLFUnlifted
                Word8
    _ -> String -> IO IfaceLFInfo
    forall a. String -> a
    panic String
    "Invalid byte"

    {-
    Note [Versioning of instances]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    See [https://gitlab.haskell.org/ghc/ghc/wikis/commentary/compiler/recompilation-avoidance#instances]

    ************************************************************************
    *                                                                      *
                    Functions over declarations
    *                                                                      *
    ************************************************************************
    -}

    visibleIfConDecls :: IfaceConDecls -> [IfaceConDecl]
    visibleIfConDecls :: IfaceConDecls -> [IfaceConDecl]
    visibleIfConDecls IfaceConDecls
    IfAbstractTyCon  = []
    visibleIfConDecls (IfDataTyCon [IfaceConDecl]
    cs) = [IfaceConDecl]
    cs
    visibleIfConDecls (IfNewTyCon IfaceConDecl
    c)   = [IfaceConDecl
    c]

    ifaceDeclImplicitBndrs :: IfaceDecl -> [OccName]
    --  *Excludes* the 'main' name, but *includes* the implicitly-bound names
    -- Deeply revolting, because it has to predict what gets bound,
    -- especially the question of whether there's a wrapper for a datacon
    -- See Note [Implicit TyThings] in GHC.Driver.Env

    -- N.B. the set of names returned here *must* match the set of
    -- TyThings returned by GHC.Driver.Env.implicitTyThings, in the sense that
    -- TyThing.getOccName should define a bijection between the two lists.
    -- This invariant is used in GHC.IfaceToCore.tc_iface_decl_fingerprint (see note
    -- [Tricky iface loop])
    -- The order of the list does not matter.

    ifaceDeclImplicitBndrs :: IfaceDecl -> [OccName]
    ifaceDeclImplicitBndrs (IfaceData {ifName :: IfaceDecl -> IfExtName
    ifName = IfExtName
    tc_name, ifCons :: IfaceDecl -> IfaceConDecls
    ifCons = IfaceConDecls
    cons })
      = case IfaceConDecls
    cons of
          IfaceConDecls
    IfAbstractTyCon -> []
          IfNewTyCon  IfaceConDecl
    cd  -> OccName -> OccName
    mkNewTyCoOcc (IfExtName -> OccName
    forall name. HasOccName name => name -> OccName
    occName IfExtName
    tc_name) OccName -> [OccName] -> [OccName]
    forall a. a -> [a] -> [a]
    : IfaceConDecl -> [OccName]
    ifaceConDeclImplicitBndrs IfaceConDecl
    cd
          IfDataTyCon [IfaceConDecl]
    cds -> (IfaceConDecl -> [OccName]) -> [IfaceConDecl] -> [OccName]
    forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
    concatMap IfaceConDecl -> [OccName]
    ifaceConDeclImplicitBndrs [IfaceConDecl]
    cds

    ifaceDeclImplicitBndrs (IfaceClass { ifBody :: IfaceDecl -> IfaceClassBody
    ifBody = IfaceClassBody
    IfAbstractClass })
      = []

    ifaceDeclImplicitBndrs (IfaceClass { ifName :: IfaceDecl -> IfExtName
    ifName = IfExtName
    cls_tc_name
                                       , ifBody :: IfaceDecl -> IfaceClassBody
    ifBody = IfConcreteClass {
                                            ifClassCtxt :: IfaceClassBody -> IfaceContext
    ifClassCtxt = IfaceContext
    sc_ctxt,
                                            ifSigs :: IfaceClassBody -> [IfaceClassOp]
    ifSigs      = [IfaceClassOp]
    sigs,
                                            ifATs :: IfaceClassBody -> [IfaceAT]
    ifATs       = [IfaceAT]
    ats
                                         }})
      = --   (possibly) newtype coercion
        [OccName]
    co_occs [OccName] -> [OccName] -> [OccName]
    forall a. [a] -> [a] -> [a]
    ++
        --    data constructor (DataCon namespace)
        --    data worker (Id namespace)
        --    no wrapper (class dictionaries never have a wrapper)
        [OccName
    dc_occ, OccName
    dcww_occ] [OccName] -> [OccName] -> [OccName]
    forall a. [a] -> [a] -> [a]
    ++
        -- associated types
        [IfExtName -> OccName
    forall name. HasOccName name => name -> OccName
    occName (IfaceDecl -> IfExtName
    ifName IfaceDecl
    at) | IfaceAT IfaceDecl
    at Maybe IfaceType
    _ <- [IfaceAT]
    ats ] [OccName] -> [OccName] -> [OccName]
    forall a. [a] -> [a] -> [a]
    ++
        -- superclass selectors
        [Int -> OccName -> OccName
    mkSuperDictSelOcc Int
    n OccName
    cls_tc_occ | Int
    n <- [Int
    1..Int
    n_ctxt]] [OccName] -> [OccName] -> [OccName]
    forall a. [a] -> [a] -> [a]
    ++
        -- operation selectors
        [IfExtName -> OccName
    forall name. HasOccName name => name -> OccName
    occName IfExtName
    op | IfaceClassOp IfExtName
    op  IfaceType
    _ Maybe (DefMethSpec IfaceType)
    _ <- [IfaceClassOp]
    sigs]
      where
        cls_tc_occ :: OccName
    cls_tc_occ = IfExtName -> OccName
    forall name. HasOccName name => name -> OccName
    occName IfExtName
    cls_tc_name
        n_ctxt :: Int
    n_ctxt = IfaceContext -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length IfaceContext
    sc_ctxt
        n_sigs :: Int
    n_sigs = [IfaceClassOp] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length [IfaceClassOp]
    sigs
        co_occs :: [OccName]
    co_occs | Bool
    is_newtype = [OccName -> OccName
    mkNewTyCoOcc OccName
    cls_tc_occ]
                | Bool
    otherwise  = []
        dcww_occ :: OccName
    dcww_occ = OccName -> OccName
    mkDataConWorkerOcc OccName
    dc_occ
        dc_occ :: OccName
    dc_occ = OccName -> OccName
    mkClassDataConOcc OccName
    cls_tc_occ
        is_newtype :: Bool
    is_newtype = Int
    n_sigs Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    n_ctxt Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1 -- Sigh (keep this synced with buildClass)

    ifaceDeclImplicitBndrs IfaceDecl
    _ = []

    ifaceConDeclImplicitBndrs :: IfaceConDecl -> [OccName]
    ifaceConDeclImplicitBndrs :: IfaceConDecl -> [OccName]
    ifaceConDeclImplicitBndrs (IfCon {
            ifConWrapper :: IfaceConDecl -> Bool
    ifConWrapper = Bool
    has_wrapper, ifConName :: IfaceConDecl -> IfExtName
    ifConName = IfExtName
    con_name })
      = [IfExtName -> OccName
    forall name. HasOccName name => name -> OccName
    occName IfExtName
    con_name, OccName
    work_occ] [OccName] -> [OccName] -> [OccName]
    forall a. [a] -> [a] -> [a]
    ++ [OccName]
    wrap_occs
      where
        con_occ :: OccName
    con_occ = IfExtName -> OccName
    forall name. HasOccName name => name -> OccName
    occName IfExtName
    con_name
        work_occ :: OccName
    work_occ  = OccName -> OccName
    mkDataConWorkerOcc OccName
    con_occ                   -- Id namespace
        wrap_occs :: [OccName]
    wrap_occs | Bool
    has_wrapper = [OccName -> OccName
    mkDataConWrapperOcc OccName
    con_occ]  -- Id namespace
                  | Bool
    otherwise   = []

    -- -----------------------------------------------------------------------------
    -- The fingerprints of an IfaceDecl

           -- We better give each name bound by the declaration a
           -- different fingerprint!  So we calculate the fingerprint of
           -- each binder by combining the fingerprint of the whole
           -- declaration with the name of the binder. (#5614, #7215)
    ifaceDeclFingerprints :: Fingerprint -> IfaceDecl -> [(OccName,Fingerprint)]
    ifaceDeclFingerprints :: Fingerprint -> IfaceDecl -> [(OccName, Fingerprint)]
    ifaceDeclFingerprints Fingerprint
    hash IfaceDecl
    decl
      = (IfaceDecl -> OccName
    forall a. NamedThing a => a -> OccName
    getOccName IfaceDecl
    decl, Fingerprint
    hash) (OccName, Fingerprint)
    -> [(OccName, Fingerprint)] -> [(OccName, Fingerprint)]
    forall a. a -> [a] -> [a]
    :
        [ (OccName
    occ, (Fingerprint, OccName) -> Fingerprint
    computeFingerprint' (Fingerprint
    hash,OccName
    occ))
        | OccName
    occ <- IfaceDecl -> [OccName]
    ifaceDeclImplicitBndrs IfaceDecl
    decl ]
      where
         computeFingerprint' :: (Fingerprint, OccName) -> Fingerprint
    computeFingerprint' =
           IO Fingerprint -> Fingerprint
    forall a. IO a -> a
    unsafeDupablePerformIO
            (IO Fingerprint -> Fingerprint)
    -> ((Fingerprint, OccName) -> IO Fingerprint)
    -> (Fingerprint, OccName)
    -> Fingerprint
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (BinHandle -> IfExtName -> IO ())
    -> (Fingerprint, OccName) -> IO Fingerprint
    forall a.
    Binary a =>
    (BinHandle -> IfExtName -> IO ()) -> a -> IO Fingerprint
    computeFingerprint (String -> BinHandle -> IfExtName -> IO ()
    forall a. String -> a
    panic String
    "ifaceDeclFingerprints")

    {-
    ************************************************************************
    *                                                                      *
                    Expressions
    *                                                                      *
    ************************************************************************
    -}

    data IfaceExpr
      = IfaceLcl    IfLclName
      | IfaceExt    IfExtName
      | IfaceType   IfaceType
      | IfaceCo     IfaceCoercion
      | IfaceTuple  TupleSort [IfaceExpr]   -- Saturated; type arguments omitted
      | IfaceLam    IfaceLamBndr IfaceExpr
      | IfaceApp    IfaceExpr IfaceExpr
      | IfaceCase   IfaceExpr IfLclName [IfaceAlt]
      | IfaceECase  IfaceExpr IfaceType     -- See Note [Empty case alternatives]
      | IfaceLet    IfaceBinding  IfaceExpr
      | IfaceCast   IfaceExpr IfaceCoercion
      | IfaceLit    Literal
      | IfaceFCall  ForeignCall IfaceType
      | IfaceTick   IfaceTickish IfaceExpr    -- from Tick tickish E

    data IfaceTickish
      = IfaceHpcTick Module Int                -- from HpcTick x
      | IfaceSCC     CostCentre Bool Bool      -- from ProfNote
      | IfaceSource  RealSrcSpan String        -- from SourceNote
      -- no breakpoints: we never export these into interface files

    data IfaceAlt = IfaceAlt IfaceConAlt [IfLclName] IfaceExpr
            -- Note: IfLclName, not IfaceBndr (and same with the case binder)
            -- We reconstruct the kind/type of the thing from the context
            -- thus saving bulk in interface files

    data IfaceConAlt = IfaceDefault
                     | IfaceDataAlt IfExtName
                     | IfaceLitAlt Literal

    data IfaceBinding
      = IfaceNonRec IfaceLetBndr IfaceExpr
      | IfaceRec    [(IfaceLetBndr, IfaceExpr)]

    -- IfaceLetBndr is like IfaceIdBndr, but has IdInfo too
    -- It's used for *non-top-level* let/rec binders
    -- See Note [IdInfo on nested let-bindings]
    data IfaceLetBndr = IfLetBndr IfLclName IfaceType IfaceIdInfo IfaceJoinInfo

    data IfaceJoinInfo = IfaceNotJoinPoint
                       | IfaceJoinPoint JoinArity

    {-
    Note [Empty case alternatives]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    In Iface syntax an IfaceCase does not record the types of the alternatives,
    unlike Core syntax Case. But we need this type if the alternatives are empty.
    Hence IfaceECase. See Note [Empty case alternatives] in GHC.Core.

    Note [Expose recursive functions]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    For supercompilation we want to put *all* unfoldings in the interface
    file, even for functions that are recursive (or big).  So we need to
    know when an unfolding belongs to a loop-breaker so that we can refrain
    from inlining it (except during supercompilation).

    Note [IdInfo on nested let-bindings]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Occasionally we want to preserve IdInfo on nested let bindings. The one
    that came up was a NOINLINE pragma on a let-binding inside an INLINE
    function.  The user (Duncan Coutts) really wanted the NOINLINE control
    to cross the separate compilation boundary.

    In general we retain all info that is left by GHC.Core.Tidy.tidyLetBndr, since
    that is what is seen by importing module with --make

    Note [Displaying axiom incompatibilities]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    With -fprint-axiom-incomps we display which closed type family equations
    are incompatible with which. This information is sometimes necessary
    because GHC doesn't try equations in order: any equation can be used when
    all preceding equations that are incompatible with it do not apply.

    For example, the last "a && a = a" equation in Data.Type.Bool.&& is
    actually compatible with all previous equations, and can reduce at any
    time.

    This is displayed as:
    Prelude> :i Data.Type.Equality.==
    type family (==) (a :: k) (b :: k) :: Bool
      where
        {- #0 -} (==) (f a) (g b) = (f == g) && (a == b)
        {- #1 -} (==) a a = 'True
              -- incompatible with: #0
        {- #2 -} (==) _1 _2 = 'False
              -- incompatible with: #1, #0
    The comment after an equation refers to all previous equations (0-indexed)
    that are incompatible with it.

    ************************************************************************
    *                                                                      *
                  Printing IfaceDecl
    *                                                                      *
    ************************************************************************
    -}

    pprAxBranch :: SDoc -> BranchIndex -> IfaceAxBranch -> SDoc
    -- The TyCon might be local (just an OccName), or this might
    -- be a branch for an imported TyCon, so it would be an ExtName
    -- So it's easier to take an SDoc here
    --
    -- This function is used
    --    to print interface files,
    --    in debug messages
    --    in :info F for GHCi, which goes via toConToIfaceDecl on the family tycon
    -- For user error messages we use Coercion.pprCoAxiom and friends
    pprAxBranch :: SDoc -> Int -> IfaceAxBranch -> SDoc
    pprAxBranch SDoc
    pp_tc Int
    idx (IfaceAxBranch { ifaxbTyVars :: IfaceAxBranch -> [IfaceTvBndr]
    ifaxbTyVars = [IfaceTvBndr]
    tvs
                                         , ifaxbCoVars :: IfaceAxBranch -> [IfaceIdBndr]
    ifaxbCoVars = [IfaceIdBndr]
    _cvs
                                         , ifaxbLHS :: IfaceAxBranch -> IfaceAppArgs
    ifaxbLHS = IfaceAppArgs
    pat_tys
                                         , ifaxbRHS :: IfaceAxBranch -> IfaceType
    ifaxbRHS = IfaceType
    rhs
                                         , ifaxbIncomps :: IfaceAxBranch -> [Int]
    ifaxbIncomps = [Int]
    incomps })
      = ASSERT2( null _cvs, pp_tc $$ ppr _cvs )
        SDoc -> Int -> SDoc -> SDoc
    hang SDoc
    ppr_binders Int
    2 (SDoc -> Int -> SDoc -> SDoc
    hang SDoc
    pp_lhs Int
    2 (SDoc
    equals SDoc -> SDoc -> SDoc
    <+> IfaceType -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfaceType
    rhs))
        SDoc -> SDoc -> SDoc
    $+$
        Int -> SDoc -> SDoc
    nest Int
    4 SDoc
    maybe_incomps
      where
        -- See Note [Printing foralls in type family instances] in GHC.Iface.Type
        ppr_binders :: SDoc
    ppr_binders = SDoc
    maybe_index SDoc -> SDoc -> SDoc
    <+>
          [IfaceForAllBndr] -> SDoc
    pprUserIfaceForAll ((IfaceTvBndr -> IfaceForAllBndr)
    -> [IfaceTvBndr] -> [IfaceForAllBndr]
    forall a b. (a -> b) -> [a] -> [b]
    map (ArgFlag -> IfaceTvBndr -> IfaceForAllBndr
    mkIfaceForAllTvBndr ArgFlag
    Specified) [IfaceTvBndr]
    tvs)
        pp_lhs :: SDoc
    pp_lhs = SDoc -> Int -> SDoc -> SDoc
    hang SDoc
    pp_tc Int
    2 (IfaceAppArgs -> SDoc
    pprParendIfaceAppArgs IfaceAppArgs
    pat_tys)

        -- See Note [Displaying axiom incompatibilities]
        maybe_index :: SDoc
    maybe_index
          = (SDocContext -> Bool) -> SDoc -> SDoc
    ppWhenOption SDocContext -> Bool
    sdocPrintAxiomIncomps (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $
              String -> SDoc
    text String
    "{-" SDoc -> SDoc -> SDoc
    <+> (String -> SDoc
    text String
    "#" SDoc -> SDoc -> SDoc
    <> Int -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Int
    idx) SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "-}"
        maybe_incomps :: SDoc
    maybe_incomps
          = (SDocContext -> Bool) -> SDoc -> SDoc
    ppWhenOption SDocContext -> Bool
    sdocPrintAxiomIncomps (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $
              Bool -> SDoc -> SDoc
    ppWhen ([Int] -> Bool
    forall (f :: * -> *) a. Foldable f => f a -> Bool
    notNull [Int]
    incomps) (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $
                String -> SDoc
    text String
    "--" SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "incompatible with:"
                SDoc -> SDoc -> SDoc
    <+> (Int -> SDoc) -> [Int] -> SDoc
    forall a. (a -> SDoc) -> [a] -> SDoc
    pprWithCommas (\Int
    incomp -> String -> SDoc
    text String
    "#" SDoc -> SDoc -> SDoc
    <> Int -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Int
    incomp) [Int]
    incomps

    instance Outputable IfaceAnnotation where
      ppr :: IfaceAnnotation -> SDoc
    ppr (IfaceAnnotation IfaceAnnTarget
    target AnnPayload
    value) = IfaceAnnTarget -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfaceAnnTarget
    target SDoc -> SDoc -> SDoc
    <+> SDoc
    colon SDoc -> SDoc -> SDoc
    <+> AnnPayload -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr AnnPayload
    value

    instance NamedThing IfaceClassOp where
      getName :: IfaceClassOp -> IfExtName
    getName (IfaceClassOp IfExtName
    n IfaceType
    _ Maybe (DefMethSpec IfaceType)
    _) = IfExtName
    n

    instance HasOccName IfaceClassOp where
      occName :: IfaceClassOp -> OccName
    occName = IfaceClassOp -> OccName
    forall a. NamedThing a => a -> OccName
    getOccName

    instance NamedThing IfaceConDecl where
      getName :: IfaceConDecl -> IfExtName
    getName = IfaceConDecl -> IfExtName
    ifConName

    instance HasOccName IfaceConDecl where
      occName :: IfaceConDecl -> OccName
    occName = IfaceConDecl -> OccName
    forall a. NamedThing a => a -> OccName
    getOccName

    instance NamedThing IfaceDecl where
      getName :: IfaceDecl -> IfExtName
    getName = IfaceDecl -> IfExtName
    ifName

    instance HasOccName IfaceDecl where
      occName :: IfaceDecl -> OccName
    occName = IfaceDecl -> OccName
    forall a. NamedThing a => a -> OccName
    getOccName

    instance Outputable IfaceDecl where
      ppr :: IfaceDecl -> SDoc
    ppr = ShowSub -> IfaceDecl -> SDoc
    pprIfaceDecl ShowSub
    showToIface

    {-
    Note [Minimal complete definition] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    The minimal complete definition should only be included if a complete
    class definition is shown. Since the minimal complete definition is
    anonymous we can't reuse the same mechanism that is used for the
    filtering of method signatures. Instead we just check if anything at all is
    filtered and hide it in that case.
    -}

    data ShowSub
      = ShowSub
          { ShowSub -> ShowHowMuch
    ss_how_much :: ShowHowMuch
          , ShowSub -> ShowForAllFlag
    ss_forall :: ShowForAllFlag }

    -- See Note [Printing IfaceDecl binders]
    -- The alternative pretty printer referred to in the note.
    newtype AltPpr = AltPpr (Maybe (OccName -> SDoc))

    data ShowHowMuch
      = ShowHeader AltPpr -- ^Header information only, not rhs
      | ShowSome [OccName] AltPpr
      -- ^ Show only some sub-components. Specifically,
      --
      -- [@\[\]@] Print all sub-components.
      -- [@(n:ns)@] Print sub-component @n@ with @ShowSub = ns@;
      -- elide other sub-components to @...@
      -- May 14: the list is max 1 element long at the moment
      | ShowIface
      -- ^Everything including GHC-internal information (used in --show-iface)

    {-
    Note [Printing IfaceDecl binders]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    The binders in an IfaceDecl are just OccNames, so we don't know what module they
    come from.  But when we pretty-print a TyThing by converting to an IfaceDecl
    (see GHC.Types.TyThing.Ppr), the TyThing may come from some other module so we really need
    the module qualifier.  We solve this by passing in a pretty-printer for the
    binders.

    When printing an interface file (--show-iface), we want to print
    everything unqualified, so we can just print the OccName directly.
    -}

    instance Outputable ShowHowMuch where
      ppr :: ShowHowMuch -> SDoc
    ppr (ShowHeader AltPpr
    _)    = String -> SDoc
    text String
    "ShowHeader"
      ppr ShowHowMuch
    ShowIface         = String -> SDoc
    text String
    "ShowIface"
      ppr (ShowSome [OccName]
    occs AltPpr
    _) = String -> SDoc
    text String
    "ShowSome" SDoc -> SDoc -> SDoc
    <+> [OccName] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [OccName]
    occs

    showToHeader :: ShowSub
    showToHeader :: ShowSub
    showToHeader = ShowSub { ss_how_much :: ShowHowMuch
    ss_how_much = AltPpr -> ShowHowMuch
    ShowHeader (AltPpr -> ShowHowMuch) -> AltPpr -> ShowHowMuch
    forall a b. (a -> b) -> a -> b
    $ Maybe (OccName -> SDoc) -> AltPpr
    AltPpr Maybe (OccName -> SDoc)
    forall a. Maybe a
    Nothing
                           , ss_forall :: ShowForAllFlag
    ss_forall = ShowForAllFlag
    ShowForAllWhen }

    showToIface :: ShowSub
    showToIface :: ShowSub
    showToIface = ShowSub { ss_how_much :: ShowHowMuch
    ss_how_much = ShowHowMuch
    ShowIface
                          , ss_forall :: ShowForAllFlag
    ss_forall = ShowForAllFlag
    ShowForAllWhen }

    ppShowIface :: ShowSub -> SDoc -> SDoc
    ppShowIface :: ShowSub -> SDoc -> SDoc
    ppShowIface (ShowSub { ss_how_much :: ShowSub -> ShowHowMuch
    ss_how_much = ShowHowMuch
    ShowIface }) SDoc
    doc = SDoc
    doc
    ppShowIface ShowSub
    _                                     SDoc
    _   = SDoc
    Outputable.empty

    -- show if all sub-components or the complete interface is shown
    ppShowAllSubs :: ShowSub -> SDoc -> SDoc -- Note [Minimal complete definition]
    ppShowAllSubs :: ShowSub -> SDoc -> SDoc
    ppShowAllSubs (ShowSub { ss_how_much :: ShowSub -> ShowHowMuch
    ss_how_much = ShowSome [] AltPpr
    _ }) SDoc
    doc = SDoc
    doc
    ppShowAllSubs (ShowSub { ss_how_much :: ShowSub -> ShowHowMuch
    ss_how_much = ShowHowMuch
    ShowIface })     SDoc
    doc = SDoc
    doc
    ppShowAllSubs ShowSub
    _                                         SDoc
    _   = SDoc
    Outputable.empty

    ppShowRhs :: ShowSub -> SDoc -> SDoc
    ppShowRhs :: ShowSub -> SDoc -> SDoc
    ppShowRhs (ShowSub { ss_how_much :: ShowSub -> ShowHowMuch
    ss_how_much = ShowHeader AltPpr
    _ }) SDoc
    _   = SDoc
    Outputable.empty
    ppShowRhs ShowSub
    _                                        SDoc
    doc = SDoc
    doc

    showSub :: HasOccName n => ShowSub -> n -> Bool
    showSub :: forall n. HasOccName n => ShowSub -> n -> Bool
    showSub (ShowSub { ss_how_much :: ShowSub -> ShowHowMuch
    ss_how_much = ShowHeader AltPpr
    _ })     n
    _     = Bool
    False
    showSub (ShowSub { ss_how_much :: ShowSub -> ShowHowMuch
    ss_how_much = ShowSome (OccName
    n:[OccName]
    _) AltPpr
    _ }) n
    thing = OccName
    n OccName -> OccName -> Bool
    forall a. Eq a => a -> a -> Bool
    == n -> OccName
    forall name. HasOccName name => name -> OccName
    occName n
    thing
    showSub (ShowSub { ss_how_much :: ShowSub -> ShowHowMuch
    ss_how_much = ShowHowMuch
    _ })              n
    _     = Bool
    True

    ppr_trim :: [Maybe SDoc] -> [SDoc]
    -- Collapse a group of Nothings to a single "..."
    ppr_trim :: [Maybe SDoc] -> [SDoc]
    ppr_trim [Maybe SDoc]
    xs
      = (Bool, [SDoc]) -> [SDoc]
    forall a b. (a, b) -> b
    snd ((Maybe SDoc -> (Bool, [SDoc]) -> (Bool, [SDoc]))
    -> (Bool, [SDoc]) -> [Maybe SDoc] -> (Bool, [SDoc])
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr Maybe SDoc -> (Bool, [SDoc]) -> (Bool, [SDoc])
    go (Bool
    False, []) [Maybe SDoc]
    xs)
      where
        go :: Maybe SDoc -> (Bool, [SDoc]) -> (Bool, [SDoc])
    go (Just SDoc
    doc) (Bool
    _,     [SDoc]
    so_far) = (Bool
    False, SDoc
    doc SDoc -> [SDoc] -> [SDoc]
    forall a. a -> [a] -> [a]
    : [SDoc]
    so_far)
        go Maybe SDoc
    Nothing    (Bool
    True,  [SDoc]
    so_far) = (Bool
    True, [SDoc]
    so_far)
        go Maybe SDoc
    Nothing    (Bool
    False, [SDoc]
    so_far) = (Bool
    True, String -> SDoc
    text String
    "..." SDoc -> [SDoc] -> [SDoc]
    forall a. a -> [a] -> [a]
    : [SDoc]
    so_far)

    isIfaceDataInstance :: IfaceTyConParent -> Bool
    isIfaceDataInstance :: IfaceTyConParent -> Bool
    isIfaceDataInstance IfaceTyConParent
    IfNoParent = Bool
    False
    isIfaceDataInstance IfaceTyConParent
    _          = Bool
    True

    pprClassRoles :: ShowSub -> IfaceTopBndr -> [IfaceTyConBinder] -> [Role] -> SDoc
    pprClassRoles :: ShowSub -> IfExtName -> [IfaceTyConBinder] -> [Role] -> SDoc
    pprClassRoles ShowSub
    ss IfExtName
    clas [IfaceTyConBinder]
    binders [Role]
    roles =
        (Role -> Bool) -> SDoc -> [IfaceTyConBinder] -> [Role] -> SDoc
    pprRoles (Role -> Role -> Bool
    forall a. Eq a => a -> a -> Bool
    == Role
    Nominal)
                 (ShowHowMuch -> OccName -> SDoc
    pprPrefixIfDeclBndr (ShowSub -> ShowHowMuch
    ss_how_much ShowSub
    ss) (IfExtName -> OccName
    forall name. HasOccName name => name -> OccName
    occName IfExtName
    clas))
                 [IfaceTyConBinder]
    binders
                 [Role]
    roles

    pprClassStandaloneKindSig :: ShowSub -> IfaceTopBndr -> IfaceKind -> SDoc
    pprClassStandaloneKindSig :: ShowSub -> IfExtName -> IfaceType -> SDoc
    pprClassStandaloneKindSig ShowSub
    ss IfExtName
    clas =
      SDoc -> IfaceType -> SDoc
    pprStandaloneKindSig (ShowHowMuch -> OccName -> SDoc
    pprPrefixIfDeclBndr (ShowSub -> ShowHowMuch
    ss_how_much ShowSub
    ss) (IfExtName -> OccName
    forall name. HasOccName name => name -> OccName
    occName IfExtName
    clas))

    constraintIfaceKind :: IfaceKind
    constraintIfaceKind :: IfaceType
    constraintIfaceKind =
      IfaceTyCon -> IfaceAppArgs -> IfaceType
    IfaceTyConApp (IfExtName -> IfaceTyConInfo -> IfaceTyCon
    IfaceTyCon IfExtName
    constraintKindTyConName (PromotionFlag -> IfaceTyConSort -> IfaceTyConInfo
    mkIfaceTyConInfo PromotionFlag
    NotPromoted IfaceTyConSort
    IfaceNormalTyCon)) IfaceAppArgs
    IA_Nil

    pprIfaceDecl :: ShowSub -> IfaceDecl -> SDoc
    -- NB: pprIfaceDecl is also used for pretty-printing TyThings in GHCi
    --     See Note [Pretty-printing TyThings] in GHC.Types.TyThing.Ppr
    pprIfaceDecl :: ShowSub -> IfaceDecl -> SDoc
    pprIfaceDecl ShowSub
    ss (IfaceData { ifName :: IfaceDecl -> IfExtName
    ifName = IfExtName
    tycon, ifCType :: IfaceDecl -> Maybe CType
    ifCType = Maybe CType
    ctype,
                                 ifCtxt :: IfaceDecl -> IfaceContext
    ifCtxt = IfaceContext
    context, ifResKind :: IfaceDecl -> IfaceType
    ifResKind = IfaceType
    kind,
                                 ifRoles :: IfaceDecl -> [Role]
    ifRoles = [Role]
    roles, ifCons :: IfaceDecl -> IfaceConDecls
    ifCons = IfaceConDecls
    condecls,
                                 ifParent :: IfaceDecl -> IfaceTyConParent
    ifParent = IfaceTyConParent
    parent,
                                 ifGadtSyntax :: IfaceDecl -> Bool
    ifGadtSyntax = Bool
    gadt,
                                 ifBinders :: IfaceDecl -> [IfaceTyConBinder]
    ifBinders = [IfaceTyConBinder]
    binders })

      | Bool
    gadt      = [SDoc] -> SDoc
    vcat [ SDoc
    pp_roles
                         , SDoc
    pp_ki_sig
                         , SDoc
    pp_nd SDoc -> SDoc -> SDoc
    <+> SDoc
    pp_lhs SDoc -> SDoc -> SDoc
    <+> SDoc
    pp_kind SDoc -> SDoc -> SDoc
    <+> SDoc
    pp_where
                         , Int -> SDoc -> SDoc
    nest Int
    2 ([SDoc] -> SDoc
    vcat [SDoc]
    pp_cons)
                         , Int -> SDoc -> SDoc
    nest Int
    2 (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ ShowSub -> SDoc -> SDoc
    ppShowIface ShowSub
    ss SDoc
    pp_extra ]
      | Bool
    otherwise = [SDoc] -> SDoc
    vcat [ SDoc
    pp_roles
                         , SDoc
    pp_ki_sig
                         , SDoc -> Int -> SDoc -> SDoc
    hang (SDoc
    pp_nd SDoc -> SDoc -> SDoc
    <+> SDoc
    pp_lhs) Int
    2 ([SDoc] -> SDoc
    add_bars [SDoc]
    pp_cons)
                         , Int -> SDoc -> SDoc
    nest Int
    2 (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ ShowSub -> SDoc -> SDoc
    ppShowIface ShowSub
    ss SDoc
    pp_extra ]
      where
        is_data_instance :: Bool
    is_data_instance = IfaceTyConParent -> Bool
    isIfaceDataInstance IfaceTyConParent
    parent
        -- See Note [Printing foralls in type family instances] in GHC.Iface.Type
        pp_data_inst_forall :: SDoc
        pp_data_inst_forall :: SDoc
    pp_data_inst_forall = [IfaceForAllBndr] -> SDoc
    pprUserIfaceForAll [IfaceForAllBndr]
    forall_bndrs

        forall_bndrs :: [IfaceForAllBndr]
        forall_bndrs :: [IfaceForAllBndr]
    forall_bndrs = [IfaceBndr -> ArgFlag -> IfaceForAllBndr
    forall var argf. var -> argf -> VarBndr var argf
    Bndr (IfaceTyConBinder -> IfaceBndr
    forall tv argf. VarBndr tv argf -> tv
    binderVar IfaceTyConBinder
    tc_bndr) ArgFlag
    Specified | IfaceTyConBinder
    tc_bndr <- [IfaceTyConBinder]
    binders]

        cons :: [IfaceConDecl]
    cons       = IfaceConDecls -> [IfaceConDecl]
    visibleIfConDecls IfaceConDecls
    condecls
        pp_where :: SDoc
    pp_where   = Bool -> SDoc -> SDoc
    ppWhen (Bool
    gadt Bool -> Bool -> Bool
    && Bool -> Bool
    not ([IfaceConDecl] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [IfaceConDecl]
    cons)) (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    text String
    "where"
        pp_cons :: [SDoc]
    pp_cons    = [Maybe SDoc] -> [SDoc]
    ppr_trim ((IfaceConDecl -> Maybe SDoc) -> [IfaceConDecl] -> [Maybe SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map IfaceConDecl -> Maybe SDoc
    show_con [IfaceConDecl]
    cons) :: [SDoc]
        pp_kind :: SDoc
    pp_kind    = Bool -> SDoc -> SDoc
    ppUnless (if Bool
    ki_sig_printable
                                  then IfaceType -> Bool
    isIfaceTauType IfaceType
    kind
                                          -- Even in the presence of a standalone kind signature, a non-tau
                                          -- result kind annotation cannot be discarded as it determines the arity.
                                          -- See Note [Arity inference in kcCheckDeclHeader_sig] in GHC.Tc.Gen.HsType
                                  else IfaceType -> Bool
    isIfaceLiftedTypeKind IfaceType
    kind)
                              (SDoc
    dcolon SDoc -> SDoc -> SDoc
    <+> IfaceType -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfaceType
    kind)

        pp_lhs :: SDoc
    pp_lhs = case IfaceTyConParent
    parent of
                   IfaceTyConParent
    IfNoParent -> SuppressBndrSig
    -> IfaceContext
    -> ShowSub
    -> IfExtName
    -> [IfaceTyConBinder]
    -> SDoc
    pprIfaceDeclHead SuppressBndrSig
    suppress_bndr_sig IfaceContext
    context ShowSub
    ss IfExtName
    tycon [IfaceTyConBinder]
    binders
                   IfDataInstance{}
                              -> String -> SDoc
    text String
    "instance" SDoc -> SDoc -> SDoc
    <+> SDoc
    pp_data_inst_forall
                                                 SDoc -> SDoc -> SDoc
    <+> IfaceTyConParent -> SDoc
    pprIfaceTyConParent IfaceTyConParent
    parent

        pp_roles :: SDoc
    pp_roles
          | Bool
    is_data_instance = SDoc
    empty
          | Bool
    otherwise        = (Role -> Bool) -> SDoc -> [IfaceTyConBinder] -> [Role] -> SDoc
    pprRoles (Role -> Role -> Bool
    forall a. Eq a => a -> a -> Bool
    == Role
    Representational) SDoc
    name_doc [IfaceTyConBinder]
    binders [Role]
    roles
                -- Don't display roles for data family instances (yet)
                -- See discussion on #8672.

        ki_sig_printable :: Bool
    ki_sig_printable =
          -- If we print a standalone kind signature for a data instance, we leak
          -- the internal constructor name:
          --
          --    type T15827.R:Dka :: forall k. k -> *
          --    data instance forall k (a :: k). D a = MkD (Proxy a)
          --
          -- This T15827.R:Dka is a compiler-generated type constructor for the
          -- data instance.
          Bool -> Bool
    not Bool
    is_data_instance

        pp_ki_sig :: SDoc
    pp_ki_sig = Bool -> SDoc -> SDoc
    ppWhen Bool
    ki_sig_printable (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $
                    SDoc -> IfaceType -> SDoc
    pprStandaloneKindSig SDoc
    name_doc ([IfaceTyConBinder] -> IfaceType -> IfaceType
    mkIfaceTyConKind [IfaceTyConBinder]
    binders IfaceType
    kind)

        -- See Note [Suppressing binder signatures] in GHC.Iface.Type
        suppress_bndr_sig :: SuppressBndrSig
    suppress_bndr_sig = Bool -> SuppressBndrSig
    SuppressBndrSig Bool
    ki_sig_printable

        name_doc :: SDoc
    name_doc = ShowHowMuch -> OccName -> SDoc
    pprPrefixIfDeclBndr (ShowSub -> ShowHowMuch
    ss_how_much ShowSub
    ss) (IfExtName -> OccName
    forall name. HasOccName name => name -> OccName
    occName IfExtName
    tycon)

        add_bars :: [SDoc] -> SDoc
    add_bars []     = SDoc
    Outputable.empty
        add_bars (SDoc
    c:[SDoc]
    cs) = [SDoc] -> SDoc
    sep ((SDoc
    equals SDoc -> SDoc -> SDoc
    <+> SDoc
    c) SDoc -> [SDoc] -> [SDoc]
    forall a. a -> [a] -> [a]
    : (SDoc -> SDoc) -> [SDoc] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map (SDoc
    vbar SDoc -> SDoc -> SDoc
    <+>) [SDoc]
    cs)

        ok_con :: IfaceConDecl -> Bool
    ok_con IfaceConDecl
    dc = ShowSub -> IfaceConDecl -> Bool
    forall n. HasOccName n => ShowSub -> n -> Bool
    showSub ShowSub
    ss IfaceConDecl
    dc Bool -> Bool -> Bool
    || (FieldLabel -> Bool) -> [FieldLabel] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    any (ShowSub -> IfExtName -> Bool
    forall n. HasOccName n => ShowSub -> n -> Bool
    showSub ShowSub
    ss (IfExtName -> Bool)
    -> (FieldLabel -> IfExtName) -> FieldLabel -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FieldLabel -> IfExtName
    flSelector) (IfaceConDecl -> [FieldLabel]
    ifConFields IfaceConDecl
    dc)

        show_con :: IfaceConDecl -> Maybe SDoc
    show_con IfaceConDecl
    dc
          | IfaceConDecl -> Bool
    ok_con IfaceConDecl
    dc = SDoc -> Maybe SDoc
    forall a. a -> Maybe a
    Just (SDoc -> Maybe SDoc) -> SDoc -> Maybe SDoc
    forall a b. (a -> b) -> a -> b
    $ ShowSub
    -> Bool
    -> IfExtName
    -> [IfaceTyConBinder]
    -> IfaceTyConParent
    -> IfaceConDecl
    -> SDoc
    pprIfaceConDecl ShowSub
    ss Bool
    gadt IfExtName
    tycon [IfaceTyConBinder]
    binders IfaceTyConParent
    parent IfaceConDecl
    dc
          | Bool
    otherwise = Maybe SDoc
    forall a. Maybe a
    Nothing

        pp_nd :: SDoc
    pp_nd = case IfaceConDecls
    condecls of
                  IfAbstractTyCon{} -> String -> SDoc
    text String
    "data"
                  IfDataTyCon{}     -> String -> SDoc
    text String
    "data"
                  IfNewTyCon{}      -> String -> SDoc
    text String
    "newtype"

        pp_extra :: SDoc
    pp_extra = [SDoc] -> SDoc
    vcat [Maybe CType -> SDoc
    pprCType Maybe CType
    ctype]

    pprIfaceDecl ShowSub
    ss (IfaceClass { ifName :: IfaceDecl -> IfExtName
    ifName  = IfExtName
    clas
                                , ifRoles :: IfaceDecl -> [Role]
    ifRoles = [Role]
    roles
                                , ifFDs :: IfaceDecl -> [FunDep IfLclName]
    ifFDs    = [FunDep IfLclName]
    fds
                                , ifBinders :: IfaceDecl -> [IfaceTyConBinder]
    ifBinders = [IfaceTyConBinder]
    binders
                                , ifBody :: IfaceDecl -> IfaceClassBody
    ifBody = IfaceClassBody
    IfAbstractClass })
      = [SDoc] -> SDoc
    vcat [ ShowSub -> IfExtName -> [IfaceTyConBinder] -> [Role] -> SDoc
    pprClassRoles ShowSub
    ss IfExtName
    clas [IfaceTyConBinder]
    binders [Role]
    roles
             , ShowSub -> IfExtName -> IfaceType -> SDoc
    pprClassStandaloneKindSig ShowSub
    ss IfExtName
    clas ([IfaceTyConBinder] -> IfaceType -> IfaceType
    mkIfaceTyConKind [IfaceTyConBinder]
    binders IfaceType
    constraintIfaceKind)
             , String -> SDoc
    text String
    "class" SDoc -> SDoc -> SDoc
    <+> SuppressBndrSig
    -> IfaceContext
    -> ShowSub
    -> IfExtName
    -> [IfaceTyConBinder]
    -> SDoc
    pprIfaceDeclHead SuppressBndrSig
    suppress_bndr_sig [] ShowSub
    ss IfExtName
    clas [IfaceTyConBinder]
    binders SDoc -> SDoc -> SDoc
    <+> [FunDep IfLclName] -> SDoc
    forall a. Outputable a => [FunDep a] -> SDoc
    pprFundeps [FunDep IfLclName]
    fds ]
      where
        -- See Note [Suppressing binder signatures] in GHC.Iface.Type
        suppress_bndr_sig :: SuppressBndrSig
    suppress_bndr_sig = Bool -> SuppressBndrSig
    SuppressBndrSig Bool
    True

    pprIfaceDecl ShowSub
    ss (IfaceClass { ifName :: IfaceDecl -> IfExtName
    ifName  = IfExtName
    clas
                                , ifRoles :: IfaceDecl -> [Role]
    ifRoles = [Role]
    roles
                                , ifFDs :: IfaceDecl -> [FunDep IfLclName]
    ifFDs    = [FunDep IfLclName]
    fds
                                , ifBinders :: IfaceDecl -> [IfaceTyConBinder]
    ifBinders = [IfaceTyConBinder]
    binders
                                , ifBody :: IfaceDecl -> IfaceClassBody
    ifBody = IfConcreteClass {
                                    ifATs :: IfaceClassBody -> [IfaceAT]
    ifATs = [IfaceAT]
    ats,
                                    ifSigs :: IfaceClassBody -> [IfaceClassOp]
    ifSigs = [IfaceClassOp]
    sigs,
                                    ifClassCtxt :: IfaceClassBody -> IfaceContext
    ifClassCtxt = IfaceContext
    context,
                                    ifMinDef :: IfaceClassBody -> BooleanFormula IfLclName
    ifMinDef = BooleanFormula IfLclName
    minDef
                                  }})
      = [SDoc] -> SDoc
    vcat [ ShowSub -> IfExtName -> [IfaceTyConBinder] -> [Role] -> SDoc
    pprClassRoles ShowSub
    ss IfExtName
    clas [IfaceTyConBinder]
    binders [Role]
    roles
             , ShowSub -> IfExtName -> IfaceType -> SDoc
    pprClassStandaloneKindSig ShowSub
    ss IfExtName
    clas ([IfaceTyConBinder] -> IfaceType -> IfaceType
    mkIfaceTyConKind [IfaceTyConBinder]
    binders IfaceType
    constraintIfaceKind)
             , String -> SDoc
    text String
    "class" SDoc -> SDoc -> SDoc
    <+> SuppressBndrSig
    -> IfaceContext
    -> ShowSub
    -> IfExtName
    -> [IfaceTyConBinder]
    -> SDoc
    pprIfaceDeclHead SuppressBndrSig
    suppress_bndr_sig IfaceContext
    context ShowSub
    ss IfExtName
    clas [IfaceTyConBinder]
    binders SDoc -> SDoc -> SDoc
    <+> [FunDep IfLclName] -> SDoc
    forall a. Outputable a => [FunDep a] -> SDoc
    pprFundeps [FunDep IfLclName]
    fds SDoc -> SDoc -> SDoc
    <+> SDoc
    pp_where
             , Int -> SDoc -> SDoc
    nest Int
    2 ([SDoc] -> SDoc
    vcat [ [SDoc] -> SDoc
    vcat [SDoc]
    asocs, [SDoc] -> SDoc
    vcat [SDoc]
    dsigs
                            , ShowSub -> SDoc -> SDoc
    ppShowAllSubs ShowSub
    ss (BooleanFormula IfLclName -> SDoc
    pprMinDef BooleanFormula IfLclName
    minDef)])]
        where
          pp_where :: SDoc
    pp_where = ShowSub -> SDoc -> SDoc
    ppShowRhs ShowSub
    ss (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ Bool -> SDoc -> SDoc
    ppUnless ([IfaceClassOp] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [IfaceClassOp]
    sigs Bool -> Bool -> Bool
    && [IfaceAT] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [IfaceAT]
    ats) (String -> SDoc
    text String
    "where")

          asocs :: [SDoc]
    asocs = [Maybe SDoc] -> [SDoc]
    ppr_trim ([Maybe SDoc] -> [SDoc]) -> [Maybe SDoc] -> [SDoc]
    forall a b. (a -> b) -> a -> b
    $ (IfaceAT -> Maybe SDoc) -> [IfaceAT] -> [Maybe SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map IfaceAT -> Maybe SDoc
    maybeShowAssoc [IfaceAT]
    ats
          dsigs :: [SDoc]
    dsigs = [Maybe SDoc] -> [SDoc]
    ppr_trim ([Maybe SDoc] -> [SDoc]) -> [Maybe SDoc] -> [SDoc]
    forall a b. (a -> b) -> a -> b
    $ (IfaceClassOp -> Maybe SDoc) -> [IfaceClassOp] -> [Maybe SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map IfaceClassOp -> Maybe SDoc
    maybeShowSig [IfaceClassOp]
    sigs

          maybeShowAssoc :: IfaceAT -> Maybe SDoc
          maybeShowAssoc :: IfaceAT -> Maybe SDoc
    maybeShowAssoc asc :: IfaceAT
    asc@(IfaceAT IfaceDecl
    d Maybe IfaceType
    _)
            | ShowSub -> IfaceDecl -> Bool
    forall n. HasOccName n => ShowSub -> n -> Bool
    showSub ShowSub
    ss IfaceDecl
    d = SDoc -> Maybe SDoc
    forall a. a -> Maybe a
    Just (SDoc -> Maybe SDoc) -> SDoc -> Maybe SDoc
    forall a b. (a -> b) -> a -> b
    $ ShowSub -> IfaceAT -> SDoc
    pprIfaceAT ShowSub
    ss IfaceAT
    asc
            | Bool
    otherwise    = Maybe SDoc
    forall a. Maybe a
    Nothing

          maybeShowSig :: IfaceClassOp -> Maybe SDoc
          maybeShowSig :: IfaceClassOp -> Maybe SDoc
    maybeShowSig IfaceClassOp
    sg
            | ShowSub -> IfaceClassOp -> Bool
    forall n. HasOccName n => ShowSub -> n -> Bool
    showSub ShowSub
    ss IfaceClassOp
    sg = SDoc -> Maybe SDoc
    forall a. a -> Maybe a
    Just (SDoc -> Maybe SDoc) -> SDoc -> Maybe SDoc
    forall a b. (a -> b) -> a -> b
    $  ShowSub -> IfaceClassOp -> SDoc
    pprIfaceClassOp ShowSub
    ss IfaceClassOp
    sg
            | Bool
    otherwise     = Maybe SDoc
    forall a. Maybe a
    Nothing

          pprMinDef :: BooleanFormula IfLclName -> SDoc
          pprMinDef :: BooleanFormula IfLclName -> SDoc
    pprMinDef BooleanFormula IfLclName
    minDef = Bool -> SDoc -> SDoc
    ppUnless (BooleanFormula IfLclName -> Bool
    forall a. BooleanFormula a -> Bool
    isTrue BooleanFormula IfLclName
    minDef) (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ -- hide empty definitions
            String -> SDoc
    text String
    "{-# MINIMAL" SDoc -> SDoc -> SDoc
    <+>
            (Rational -> IfLclName -> SDoc)
    -> Rational -> BooleanFormula IfLclName -> SDoc
    forall a.
    (Rational -> a -> SDoc) -> Rational -> BooleanFormula a -> SDoc
    pprBooleanFormula
              (\Rational
    _ IfLclName
    def -> Bool -> SDoc -> SDoc
    cparen (IfLclName -> Bool
    isLexSym IfLclName
    def) (IfLclName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfLclName
    def)) Rational
    0 BooleanFormula IfLclName
    minDef SDoc -> SDoc -> SDoc
    <+>
            String -> SDoc
    text String
    "#-}"

          -- See Note [Suppressing binder signatures] in GHC.Iface.Type
          suppress_bndr_sig :: SuppressBndrSig
    suppress_bndr_sig = Bool -> SuppressBndrSig
    SuppressBndrSig Bool
    True

    pprIfaceDecl ShowSub
    ss (IfaceSynonym { ifName :: IfaceDecl -> IfExtName
    ifName    = IfExtName
    tc
                                  , ifBinders :: IfaceDecl -> [IfaceTyConBinder]
    ifBinders = [IfaceTyConBinder]
    binders
                                  , ifSynRhs :: IfaceDecl -> IfaceType
    ifSynRhs  = IfaceType
    mono_ty
                                  , ifResKind :: IfaceDecl -> IfaceType
    ifResKind = IfaceType
    res_kind})
      = [SDoc] -> SDoc
    vcat [ SDoc -> IfaceType -> SDoc
    pprStandaloneKindSig SDoc
    name_doc ([IfaceTyConBinder] -> IfaceType -> IfaceType
    mkIfaceTyConKind [IfaceTyConBinder]
    binders IfaceType
    res_kind)
             , SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    text String
    "type" SDoc -> SDoc -> SDoc
    <+> SuppressBndrSig
    -> IfaceContext
    -> ShowSub
    -> IfExtName
    -> [IfaceTyConBinder]
    -> SDoc
    pprIfaceDeclHead SuppressBndrSig
    suppress_bndr_sig [] ShowSub
    ss IfExtName
    tc [IfaceTyConBinder]
    binders SDoc -> SDoc -> SDoc
    <+> SDoc
    equals)
               Int
    2 ([SDoc] -> SDoc
    sep [ [IfaceForAllBndr] -> SDoc
    pprIfaceForAll [IfaceForAllBndr]
    tvs, IfaceContext -> SDoc
    pprIfaceContextArr IfaceContext
    theta, SDoc
    ppr_tau
                      , Bool -> SDoc -> SDoc
    ppUnless (IfaceType -> Bool
    isIfaceLiftedTypeKind IfaceType
    res_kind) (SDoc
    dcolon SDoc -> SDoc -> SDoc
    <+> IfaceType -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfaceType
    res_kind) ])
             ]
      where
        ([IfaceForAllBndr]
    tvs, IfaceContext
    theta, IfaceType
    tau) = IfaceType -> ([IfaceForAllBndr], IfaceContext, IfaceType)
    splitIfaceSigmaTy IfaceType
    mono_ty
        name_doc :: SDoc
    name_doc = ShowHowMuch -> OccName -> SDoc
    pprPrefixIfDeclBndr (ShowSub -> ShowHowMuch
    ss_how_much ShowSub
    ss) (IfExtName -> OccName
    forall name. HasOccName name => name -> OccName
    occName IfExtName
    tc)

        -- See Note [Printing type abbreviations] in GHC.Iface.Type
        ppr_tau :: SDoc
    ppr_tau | IfExtName
    tc IfExtName -> Unique -> Bool
    forall a. Uniquable a => a -> Unique -> Bool
    `hasKey` Unique
    liftedTypeKindTyConKey Bool -> Bool -> Bool
    ||
                  IfExtName
    tc IfExtName -> Unique -> Bool
    forall a. Uniquable a => a -> Unique -> Bool
    `hasKey` Unique
    unrestrictedFunTyConKey
                = (SDocContext -> SDocContext) -> SDoc -> SDoc
    updSDocContext (\SDocContext
    ctx -> SDocContext
    ctx { sdocPrintTypeAbbreviations :: Bool
    sdocPrintTypeAbbreviations = Bool
    False }) (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ IfaceType -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfaceType
    tau
                | Bool
    otherwise = IfaceType -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfaceType
    tau

        -- See Note [Suppressing binder signatures] in GHC.Iface.Type
        suppress_bndr_sig :: SuppressBndrSig
    suppress_bndr_sig = Bool -> SuppressBndrSig
    SuppressBndrSig Bool
    True

    pprIfaceDecl ShowSub
    ss (IfaceFamily { ifName :: IfaceDecl -> IfExtName
    ifName = IfExtName
    tycon
                                 , ifFamFlav :: IfaceDecl -> IfaceFamTyConFlav
    ifFamFlav = IfaceFamTyConFlav
    rhs, ifBinders :: IfaceDecl -> [IfaceTyConBinder]
    ifBinders = [IfaceTyConBinder]
    binders
                                 , ifResKind :: IfaceDecl -> IfaceType
    ifResKind = IfaceType
    res_kind
                                 , ifResVar :: IfaceDecl -> Maybe IfLclName
    ifResVar = Maybe IfLclName
    res_var, ifFamInj :: IfaceDecl -> Injectivity
    ifFamInj = Injectivity
    inj })
      | IfaceFamTyConFlav
    IfaceDataFamilyTyCon <- IfaceFamTyConFlav
    rhs
      = [SDoc] -> SDoc
    vcat [ SDoc -> IfaceType -> SDoc
    pprStandaloneKindSig SDoc
    name_doc ([IfaceTyConBinder] -> IfaceType -> IfaceType
    mkIfaceTyConKind [IfaceTyConBinder]
    binders IfaceType
    res_kind)
             , String -> SDoc
    text String
    "data family" SDoc -> SDoc -> SDoc
    <+> SuppressBndrSig
    -> IfaceContext
    -> ShowSub
    -> IfExtName
    -> [IfaceTyConBinder]
    -> SDoc
    pprIfaceDeclHead SuppressBndrSig
    suppress_bndr_sig [] ShowSub
    ss IfExtName
    tycon [IfaceTyConBinder]
    binders
             ]

      | Bool
    otherwise
      = [SDoc] -> SDoc
    vcat [ SDoc -> IfaceType -> SDoc
    pprStandaloneKindSig SDoc
    name_doc ([IfaceTyConBinder] -> IfaceType -> IfaceType
    mkIfaceTyConKind [IfaceTyConBinder]
    binders IfaceType
    res_kind)
             , SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    text String
    "type family"
                       SDoc -> SDoc -> SDoc
    <+> SuppressBndrSig
    -> IfaceContext
    -> ShowSub
    -> IfExtName
    -> [IfaceTyConBinder]
    -> SDoc
    pprIfaceDeclHead SuppressBndrSig
    suppress_bndr_sig [] ShowSub
    ss IfExtName
    tycon [IfaceTyConBinder]
    binders
                       SDoc -> SDoc -> SDoc
    <+> ShowSub -> SDoc -> SDoc
    ppShowRhs ShowSub
    ss (IfaceFamTyConFlav -> SDoc
    pp_where IfaceFamTyConFlav
    rhs))
                  Int
    2 (Maybe IfLclName -> Injectivity -> SDoc
    pp_inj Maybe IfLclName
    res_var Injectivity
    inj SDoc -> SDoc -> SDoc
    <+> ShowSub -> SDoc -> SDoc
    ppShowRhs ShowSub
    ss (IfaceFamTyConFlav -> SDoc
    pp_rhs IfaceFamTyConFlav
    rhs))
               SDoc -> SDoc -> SDoc
    $$
               Int -> SDoc -> SDoc
    nest Int
    2 (ShowSub -> SDoc -> SDoc
    ppShowRhs ShowSub
    ss (IfaceFamTyConFlav -> SDoc
    pp_branches IfaceFamTyConFlav
    rhs))
             ]
      where
        name_doc :: SDoc
    name_doc = ShowHowMuch -> OccName -> SDoc
    pprPrefixIfDeclBndr (ShowSub -> ShowHowMuch
    ss_how_much ShowSub
    ss) (IfExtName -> OccName
    forall name. HasOccName name => name -> OccName
    occName IfExtName
    tycon)

        pp_where :: IfaceFamTyConFlav -> SDoc
    pp_where (IfaceClosedSynFamilyTyCon {}) = String -> SDoc
    text String
    "where"
        pp_where IfaceFamTyConFlav
    _                              = SDoc
    empty

        pp_inj :: Maybe IfLclName -> Injectivity -> SDoc
    pp_inj Maybe IfLclName
    Nothing    Injectivity
    _   = SDoc
    empty
        pp_inj (Just IfLclName
    res) Injectivity
    inj
           | Injective [Bool]
    injectivity <- Injectivity
    inj = [SDoc] -> SDoc
    hsep [ SDoc
    equals, IfLclName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfLclName
    res
                                                 , IfLclName -> [Bool] -> SDoc
    pp_inj_cond IfLclName
    res [Bool]
    injectivity]
           | Bool
    otherwise = [SDoc] -> SDoc
    hsep [ SDoc
    equals, IfLclName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfLclName
    res ]

        pp_inj_cond :: IfLclName -> [Bool] -> SDoc
    pp_inj_cond IfLclName
    res [Bool]
    inj = case [Bool] -> [IfaceTyConBinder] -> [IfaceTyConBinder]
    forall a. [Bool] -> [a] -> [a]
    filterByList [Bool]
    inj [IfaceTyConBinder]
    binders of
           []  -> SDoc
    empty
           [IfaceTyConBinder]
    tvs -> [SDoc] -> SDoc
    hsep [SDoc
    vbar, IfLclName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfLclName
    res, String -> SDoc
    text String
    "->", [IfLclName] -> SDoc
    forall a. Outputable a => [a] -> SDoc
    interppSP ((IfaceTyConBinder -> IfLclName)
    -> [IfaceTyConBinder] -> [IfLclName]
    forall a b. (a -> b) -> [a] -> [b]
    map IfaceTyConBinder -> IfLclName
    ifTyConBinderName [IfaceTyConBinder]
    tvs)]

        pp_rhs :: IfaceFamTyConFlav -> SDoc
    pp_rhs IfaceFamTyConFlav
    IfaceDataFamilyTyCon
          = ShowSub -> SDoc -> SDoc
    ppShowIface ShowSub
    ss (String -> SDoc
    text String
    "data")
        pp_rhs IfaceFamTyConFlav
    IfaceOpenSynFamilyTyCon
          = ShowSub -> SDoc -> SDoc
    ppShowIface ShowSub
    ss (String -> SDoc
    text String
    "open")
        pp_rhs IfaceFamTyConFlav
    IfaceAbstractClosedSynFamilyTyCon
          = ShowSub -> SDoc -> SDoc
    ppShowIface ShowSub
    ss (String -> SDoc
    text String
    "closed, abstract")
        pp_rhs (IfaceClosedSynFamilyTyCon {})
          = SDoc
    empty  -- see pp_branches
        pp_rhs IfaceFamTyConFlav
    IfaceBuiltInSynFamTyCon
          = ShowSub -> SDoc -> SDoc
    ppShowIface ShowSub
    ss (String -> SDoc
    text String
    "built-in")

        pp_branches :: IfaceFamTyConFlav -> SDoc
    pp_branches (IfaceClosedSynFamilyTyCon (Just (IfExtName
    ax, [IfaceAxBranch]
    brs)))
          = [SDoc] -> SDoc
    vcat ((Int -> IfaceAxBranch -> SDoc) -> [(Int, IfaceAxBranch)] -> [SDoc]
    forall a b c. (a -> b -> c) -> [(a, b)] -> [c]
    unzipWith (SDoc -> Int -> IfaceAxBranch -> SDoc
    pprAxBranch
                         (ShowHowMuch -> OccName -> SDoc
    pprPrefixIfDeclBndr
                           (ShowSub -> ShowHowMuch
    ss_how_much ShowSub
    ss)
                           (IfExtName -> OccName
    forall name. HasOccName name => name -> OccName
    occName IfExtName
    tycon))
                      ) ([(Int, IfaceAxBranch)] -> [SDoc])
    -> [(Int, IfaceAxBranch)] -> [SDoc]
    forall a b. (a -> b) -> a -> b
    $ [Int] -> [IfaceAxBranch] -> [(Int, IfaceAxBranch)]
    forall a b. [a] -> [b] -> [(a, b)]
    zip [Int
    0..] [IfaceAxBranch]
    brs)
            SDoc -> SDoc -> SDoc
    $$ ShowSub -> SDoc -> SDoc
    ppShowIface ShowSub
    ss (String -> SDoc
    text String
    "axiom" SDoc -> SDoc -> SDoc
    <+> IfExtName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfExtName
    ax)
        pp_branches IfaceFamTyConFlav
    _ = SDoc
    Outputable.empty

        -- See Note [Suppressing binder signatures] in GHC.Iface.Type
        suppress_bndr_sig :: SuppressBndrSig
    suppress_bndr_sig = Bool -> SuppressBndrSig
    SuppressBndrSig Bool
    True

    pprIfaceDecl ShowSub
    _ (IfacePatSyn { ifName :: IfaceDecl -> IfExtName
    ifName = IfExtName
    name,
                                  ifPatUnivBndrs :: IfaceDecl -> [IfaceForAllSpecBndr]
    ifPatUnivBndrs = [IfaceForAllSpecBndr]
    univ_bndrs, ifPatExBndrs :: IfaceDecl -> [IfaceForAllSpecBndr]
    ifPatExBndrs = [IfaceForAllSpecBndr]
    ex_bndrs,
                                  ifPatProvCtxt :: IfaceDecl -> IfaceContext
    ifPatProvCtxt = IfaceContext
    prov_ctxt, ifPatReqCtxt :: IfaceDecl -> IfaceContext
    ifPatReqCtxt = IfaceContext
    req_ctxt,
                                  ifPatArgs :: IfaceDecl -> IfaceContext
    ifPatArgs = IfaceContext
    arg_tys,
                                  ifPatTy :: IfaceDecl -> IfaceType
    ifPatTy = IfaceType
    pat_ty} )
      = (SDocContext -> SDoc) -> SDoc
    sdocWithContext SDocContext -> SDoc
    mk_msg
      where
        mk_msg :: SDocContext -> SDoc
    mk_msg SDocContext
    sdocCtx
          = SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    text String
    "pattern" SDoc -> SDoc -> SDoc
    <+> IfExtName -> SDoc
    forall a. OutputableBndr a => a -> SDoc
    pprPrefixOcc IfExtName
    name)
               Int
    2 (SDoc
    dcolon SDoc -> SDoc -> SDoc
    <+> [SDoc] -> SDoc
    sep [SDoc
    univ_msg
                                 , IfaceContext -> SDoc
    pprIfaceContextArr IfaceContext
    req_ctxt
                                 , Bool -> SDoc -> SDoc
    ppWhen Bool
    insert_empty_ctxt (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ SDoc -> SDoc
    parens SDoc
    empty SDoc -> SDoc -> SDoc
    <+> SDoc
    darrow
                                 , SDoc
    ex_msg
                                 , IfaceContext -> SDoc
    pprIfaceContextArr IfaceContext
    prov_ctxt
                                 , IfaceType -> SDoc
    pprIfaceType (IfaceType -> SDoc) -> IfaceType -> SDoc
    forall a b. (a -> b) -> a -> b
    $ (IfaceType -> IfaceType -> IfaceType)
    -> IfaceType -> IfaceContext -> IfaceType
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr (AnonArgFlag -> IfaceType -> IfaceType -> IfaceType -> IfaceType
    IfaceFunTy AnonArgFlag
    VisArg IfaceType
    many_ty) IfaceType
    pat_ty IfaceContext
    arg_tys ])
          where
            univ_msg :: SDoc
    univ_msg = [IfaceForAllBndr] -> SDoc
    pprUserIfaceForAll ([IfaceForAllBndr] -> SDoc) -> [IfaceForAllBndr] -> SDoc
    forall a b. (a -> b) -> a -> b
    $ [IfaceForAllSpecBndr] -> [IfaceForAllBndr]
    forall a. [VarBndr a Specificity] -> [VarBndr a ArgFlag]
    tyVarSpecToBinders [IfaceForAllSpecBndr]
    univ_bndrs
            ex_msg :: SDoc
    ex_msg   = [IfaceForAllBndr] -> SDoc
    pprUserIfaceForAll ([IfaceForAllBndr] -> SDoc) -> [IfaceForAllBndr] -> SDoc
    forall a b. (a -> b) -> a -> b
    $ [IfaceForAllSpecBndr] -> [IfaceForAllBndr]
    forall a. [VarBndr a Specificity] -> [VarBndr a ArgFlag]
    tyVarSpecToBinders [IfaceForAllSpecBndr]
    ex_bndrs

            insert_empty_ctxt :: Bool
    insert_empty_ctxt = IfaceContext -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null IfaceContext
    req_ctxt
                Bool -> Bool -> Bool
    && Bool -> Bool
    not (IfaceContext -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null IfaceContext
    prov_ctxt Bool -> Bool -> Bool
    && SDocContext -> SDoc -> Bool
    isEmpty SDocContext
    sdocCtx SDoc
    ex_msg)

    pprIfaceDecl ShowSub
    ss (IfaceId { ifName :: IfaceDecl -> IfExtName
    ifName = IfExtName
    var, ifType :: IfaceDecl -> IfaceType
    ifType = IfaceType
    ty,
                                  ifIdDetails :: IfaceDecl -> IfaceIdDetails
    ifIdDetails = IfaceIdDetails
    details, ifIdInfo :: IfaceDecl -> IfaceIdInfo
    ifIdInfo = IfaceIdInfo
    info })
      = [SDoc] -> SDoc
    vcat [ SDoc -> Int -> SDoc -> SDoc
    hang (ShowHowMuch -> OccName -> SDoc
    pprPrefixIfDeclBndr (ShowSub -> ShowHowMuch
    ss_how_much ShowSub
    ss) (IfExtName -> OccName
    forall name. HasOccName name => name -> OccName
    occName IfExtName
    var) SDoc -> SDoc -> SDoc
    <+> SDoc
    dcolon)
                  Int
    2 (ShowForAllFlag -> IfaceType -> SDoc
    pprIfaceSigmaType (ShowSub -> ShowForAllFlag
    ss_forall ShowSub
    ss) IfaceType
    ty)
             , ShowSub -> SDoc -> SDoc
    ppShowIface ShowSub
    ss (IfaceIdDetails -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfaceIdDetails
    details)
             , ShowSub -> SDoc -> SDoc
    ppShowIface ShowSub
    ss (IfaceIdInfo -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfaceIdInfo
    info) ]

    pprIfaceDecl ShowSub
    _ (IfaceAxiom { ifName :: IfaceDecl -> IfExtName
    ifName = IfExtName
    name, ifTyCon :: IfaceDecl -> IfaceTyCon
    ifTyCon = IfaceTyCon
    tycon
                               , ifAxBranches :: IfaceDecl -> [IfaceAxBranch]
    ifAxBranches = [IfaceAxBranch]
    branches })
      = SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    text String
    "axiom" SDoc -> SDoc -> SDoc
    <+> IfExtName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfExtName
    name SDoc -> SDoc -> SDoc
    <+> SDoc
    dcolon)
           Int
    2 ([SDoc] -> SDoc
    vcat ([SDoc] -> SDoc) -> [SDoc] -> SDoc
    forall a b. (a -> b) -> a -> b
    $ (Int -> IfaceAxBranch -> SDoc) -> [(Int, IfaceAxBranch)] -> [SDoc]
    forall a b c. (a -> b -> c) -> [(a, b)] -> [c]
    unzipWith (SDoc -> Int -> IfaceAxBranch -> SDoc
    pprAxBranch (IfaceTyCon -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfaceTyCon
    tycon)) ([(Int, IfaceAxBranch)] -> [SDoc])
    -> [(Int, IfaceAxBranch)] -> [SDoc]
    forall a b. (a -> b) -> a -> b
    $ [Int] -> [IfaceAxBranch] -> [(Int, IfaceAxBranch)]
    forall a b. [a] -> [b] -> [(a, b)]
    zip [Int
    0..] [IfaceAxBranch]
    branches)

    pprCType :: Maybe CType -> SDoc
    pprCType :: Maybe CType -> SDoc
    pprCType Maybe CType
    Nothing      = SDoc
    Outputable.empty
    pprCType (Just CType
    cType) = String -> SDoc
    text String
    "C type:" SDoc -> SDoc -> SDoc
    <+> CType -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr CType
    cType

    -- if, for each role, suppress_if role is True, then suppress the role
    -- output
    pprRoles :: (Role -> Bool) -> SDoc -> [IfaceTyConBinder]
             -> [Role] -> SDoc
    pprRoles :: (Role -> Bool) -> SDoc -> [IfaceTyConBinder] -> [Role] -> SDoc
    pprRoles Role -> Bool
    suppress_if SDoc
    tyCon [IfaceTyConBinder]
    bndrs [Role]
    roles
      = (SDocContext -> Bool) -> (Bool -> SDoc) -> SDoc
    forall a. (SDocContext -> a) -> (a -> SDoc) -> SDoc
    sdocOption SDocContext -> Bool
    sdocPrintExplicitKinds ((Bool -> SDoc) -> SDoc) -> (Bool -> SDoc) -> SDoc
    forall a b. (a -> b) -> a -> b
    $ \Bool
    print_kinds ->
          let froles :: [Role]
    froles = PrintExplicitKinds -> [IfaceTyConBinder] -> [Role] -> [Role]
    forall a. PrintExplicitKinds -> [IfaceTyConBinder] -> [a] -> [a]
    suppressIfaceInvisibles (Bool -> PrintExplicitKinds
    PrintExplicitKinds Bool
    print_kinds) [IfaceTyConBinder]
    bndrs [Role]
    roles
          in Bool -> SDoc -> SDoc
    ppUnless ((Role -> Bool) -> [Role] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    all Role -> Bool
    suppress_if [Role]
    froles Bool -> Bool -> Bool
    || [Role] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [Role]
    froles) (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $
             String -> SDoc
    text String
    "type role" SDoc -> SDoc -> SDoc
    <+> SDoc
    tyCon SDoc -> SDoc -> SDoc
    <+> [SDoc] -> SDoc
    hsep ((Role -> SDoc) -> [Role] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map Role -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [Role]
    froles)

    pprStandaloneKindSig :: SDoc -> IfaceType -> SDoc
    pprStandaloneKindSig :: SDoc -> IfaceType -> SDoc
    pprStandaloneKindSig SDoc
    tyCon IfaceType
    ty = String -> SDoc
    text String
    "type" SDoc -> SDoc -> SDoc
    <+> SDoc
    tyCon SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "::" SDoc -> SDoc -> SDoc
    <+> IfaceType -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfaceType
    ty

    pprInfixIfDeclBndr :: ShowHowMuch -> OccName -> SDoc
    pprInfixIfDeclBndr :: ShowHowMuch -> OccName -> SDoc
    pprInfixIfDeclBndr (ShowSome [OccName]
    _ (AltPpr (Just OccName -> SDoc
    ppr_bndr))) OccName
    name
      = Bool -> SDoc -> SDoc
    pprInfixVar (OccName -> Bool
    isSymOcc OccName
    name) (OccName -> SDoc
    ppr_bndr OccName
    name)
    pprInfixIfDeclBndr ShowHowMuch
    _ OccName
    name
      = Bool -> SDoc -> SDoc
    pprInfixVar (OccName -> Bool
    isSymOcc OccName
    name) (OccName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr OccName
    name)

    pprPrefixIfDeclBndr :: ShowHowMuch -> OccName -> SDoc
    pprPrefixIfDeclBndr :: ShowHowMuch -> OccName -> SDoc
    pprPrefixIfDeclBndr (ShowHeader (AltPpr (Just OccName -> SDoc
    ppr_bndr))) OccName
    name
      = OccName -> SDoc -> SDoc
    parenSymOcc OccName
    name (OccName -> SDoc
    ppr_bndr OccName
    name)
    pprPrefixIfDeclBndr (ShowSome [OccName]
    _ (AltPpr (Just OccName -> SDoc
    ppr_bndr))) OccName
    name
      = OccName -> SDoc -> SDoc
    parenSymOcc OccName
    name (OccName -> SDoc
    ppr_bndr OccName
    name)
    pprPrefixIfDeclBndr ShowHowMuch
    _ OccName
    name
      = OccName -> SDoc -> SDoc
    parenSymOcc OccName
    name (OccName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr OccName
    name)

    instance Outputable IfaceClassOp where
       ppr :: IfaceClassOp -> SDoc
    ppr = ShowSub -> IfaceClassOp -> SDoc
    pprIfaceClassOp ShowSub
    showToIface

    pprIfaceClassOp :: ShowSub -> IfaceClassOp -> SDoc
    pprIfaceClassOp :: ShowSub -> IfaceClassOp -> SDoc
    pprIfaceClassOp ShowSub
    ss (IfaceClassOp IfExtName
    n IfaceType
    ty Maybe (DefMethSpec IfaceType)
    dm)
      = IfExtName -> IfaceType -> SDoc
    pp_sig IfExtName
    n IfaceType
    ty SDoc -> SDoc -> SDoc
    $$ SDoc
    generic_dm
      where
       generic_dm :: SDoc
    generic_dm | Just (GenericDM IfaceType
    dm_ty) <- Maybe (DefMethSpec IfaceType)
    dm
                  =  String -> SDoc
    text String
    "default" SDoc -> SDoc -> SDoc
    <+> IfExtName -> IfaceType -> SDoc
    pp_sig IfExtName
    n IfaceType
    dm_ty
                  | Bool
    otherwise
                  = SDoc
    empty
       pp_sig :: IfExtName -> IfaceType -> SDoc
    pp_sig IfExtName
    n IfaceType
    ty
         = ShowHowMuch -> OccName -> SDoc
    pprPrefixIfDeclBndr (ShowSub -> ShowHowMuch
    ss_how_much ShowSub
    ss) (IfExtName -> OccName
    forall name. HasOccName name => name -> OccName
    occName IfExtName
    n)
         SDoc -> SDoc -> SDoc
    <+> SDoc
    dcolon
         SDoc -> SDoc -> SDoc
    <+> ShowForAllFlag -> IfaceType -> SDoc
    pprIfaceSigmaType ShowForAllFlag
    ShowForAllWhen IfaceType
    ty

    instance Outputable IfaceAT where
       ppr :: IfaceAT -> SDoc
    ppr = ShowSub -> IfaceAT -> SDoc
    pprIfaceAT ShowSub
    showToIface

    pprIfaceAT :: ShowSub -> IfaceAT -> SDoc
    pprIfaceAT :: ShowSub -> IfaceAT -> SDoc
    pprIfaceAT ShowSub
    ss (IfaceAT IfaceDecl
    d Maybe IfaceType
    mb_def)
      = [SDoc] -> SDoc
    vcat [ ShowSub -> IfaceDecl -> SDoc
    pprIfaceDecl ShowSub
    ss IfaceDecl
    d
             , case Maybe IfaceType
    mb_def of
                  Maybe IfaceType
    Nothing  -> SDoc
    Outputable.empty
                  Just IfaceType
    rhs -> Int -> SDoc -> SDoc
    nest Int
    2 (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $
                              String -> SDoc
    text String
    "Default:" SDoc -> SDoc -> SDoc
    <+> IfaceType -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfaceType
    rhs ]

    instance Outputable IfaceTyConParent where
      ppr :: IfaceTyConParent -> SDoc
    ppr IfaceTyConParent
    p = IfaceTyConParent -> SDoc
    pprIfaceTyConParent IfaceTyConParent
    p

    pprIfaceTyConParent :: IfaceTyConParent -> SDoc
    pprIfaceTyConParent :: IfaceTyConParent -> SDoc
    pprIfaceTyConParent IfaceTyConParent
    IfNoParent
      = SDoc
    Outputable.empty
    pprIfaceTyConParent (IfDataInstance IfExtName
    _ IfaceTyCon
    tc IfaceAppArgs
    tys)
      = PprPrec -> IfaceTyCon -> IfaceAppArgs -> SDoc
    pprIfaceTypeApp PprPrec
    topPrec IfaceTyCon
    tc IfaceAppArgs
    tys

    pprIfaceDeclHead :: SuppressBndrSig
                     -> IfaceContext -> ShowSub -> Name
                     -> [IfaceTyConBinder]   -- of the tycon, for invisible-suppression
                     -> SDoc
    pprIfaceDeclHead :: SuppressBndrSig
    -> IfaceContext
    -> ShowSub
    -> IfExtName
    -> [IfaceTyConBinder]
    -> SDoc
    pprIfaceDeclHead SuppressBndrSig
    suppress_sig IfaceContext
    context ShowSub
    ss IfExtName
    tc_occ [IfaceTyConBinder]
    bndrs
      = (SDocContext -> Bool) -> (Bool -> SDoc) -> SDoc
    forall a. (SDocContext -> a) -> (a -> SDoc) -> SDoc
    sdocOption SDocContext -> Bool
    sdocPrintExplicitKinds ((Bool -> SDoc) -> SDoc) -> (Bool -> SDoc) -> SDoc
    forall a b. (a -> b) -> a -> b
    $ \Bool
    print_kinds ->
        [SDoc] -> SDoc
    sep [ IfaceContext -> SDoc
    pprIfaceContextArr IfaceContext
    context
            , ShowHowMuch -> OccName -> SDoc
    pprPrefixIfDeclBndr (ShowSub -> ShowHowMuch
    ss_how_much ShowSub
    ss) (IfExtName -> OccName
    forall name. HasOccName name => name -> OccName
    occName IfExtName
    tc_occ)
              SDoc -> SDoc -> SDoc
    <+> SuppressBndrSig -> [IfaceTyConBinder] -> SDoc
    pprIfaceTyConBinders SuppressBndrSig
    suppress_sig
                    (PrintExplicitKinds
    -> [IfaceTyConBinder] -> [IfaceTyConBinder] -> [IfaceTyConBinder]
    forall a. PrintExplicitKinds -> [IfaceTyConBinder] -> [a] -> [a]
    suppressIfaceInvisibles (Bool -> PrintExplicitKinds
    PrintExplicitKinds Bool
    print_kinds) [IfaceTyConBinder]
    bndrs [IfaceTyConBinder]
    bndrs) ]

    pprIfaceConDecl :: ShowSub -> Bool
                    -> IfaceTopBndr
                    -> [IfaceTyConBinder]
                    -> IfaceTyConParent
                    -> IfaceConDecl -> SDoc
    pprIfaceConDecl :: ShowSub
    -> Bool
    -> IfExtName
    -> [IfaceTyConBinder]
    -> IfaceTyConParent
    -> IfaceConDecl
    -> SDoc
    pprIfaceConDecl ShowSub
    ss Bool
    gadt_style IfExtName
    tycon [IfaceTyConBinder]
    tc_binders IfaceTyConParent
    parent
            (IfCon { ifConName :: IfaceConDecl -> IfExtName
    ifConName = IfExtName
    name, ifConInfix :: IfaceConDecl -> Bool
    ifConInfix = Bool
    is_infix,
                     ifConUserTvBinders :: IfaceConDecl -> [IfaceForAllSpecBndr]
    ifConUserTvBinders = [IfaceForAllSpecBndr]
    user_tvbs,
                     ifConEqSpec :: IfaceConDecl -> [IfaceTvBndr]
    ifConEqSpec = [IfaceTvBndr]
    eq_spec, ifConCtxt :: IfaceConDecl -> IfaceContext
    ifConCtxt = IfaceContext
    ctxt, ifConArgTys :: IfaceConDecl -> [(IfaceType, IfaceType)]
    ifConArgTys = [(IfaceType, IfaceType)]
    arg_tys,
                     ifConStricts :: IfaceConDecl -> [IfaceBang]
    ifConStricts = [IfaceBang]
    stricts, ifConFields :: IfaceConDecl -> [FieldLabel]
    ifConFields = [FieldLabel]
    fields })
      | Bool
    gadt_style = SDoc
    pp_prefix_con SDoc -> SDoc -> SDoc
    <+> SDoc
    dcolon SDoc -> SDoc -> SDoc
    <+> SDoc
    ppr_gadt_ty
      | Bool
    otherwise  = SDoc -> SDoc
    ppr_ex_quant SDoc
    pp_h98_con
      where
        pp_h98_con :: SDoc
    pp_h98_con
          | Bool -> Bool
    not ([FieldLabel] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [FieldLabel]
    fields) = SDoc
    pp_prefix_con SDoc -> SDoc -> SDoc
    <+> SDoc
    pp_field_args
          | Bool
    is_infix
          , [SDoc
    ty1, SDoc
    ty2] <- [SDoc]
    pp_args
          = [SDoc] -> SDoc
    sep [ SDoc
    ty1
                , ShowHowMuch -> OccName -> SDoc
    pprInfixIfDeclBndr ShowHowMuch
    how_much (IfExtName -> OccName
    forall name. HasOccName name => name -> OccName
    occName IfExtName
    name)
                , SDoc
    ty2]
          | Bool
    otherwise = SDoc
    pp_prefix_con SDoc -> SDoc -> SDoc
    <+> [SDoc] -> SDoc
    sep [SDoc]
    pp_args

        how_much :: ShowHowMuch
    how_much = ShowSub -> ShowHowMuch
    ss_how_much ShowSub
    ss
        tys_w_strs :: [(IfaceBang, IfaceType)]
        tys_w_strs :: [(IfaceBang, IfaceType)]
    tys_w_strs = [IfaceBang] -> IfaceContext -> [(IfaceBang, IfaceType)]
    forall a b. [a] -> [b] -> [(a, b)]
    zip [IfaceBang]
    stricts (((IfaceType, IfaceType) -> IfaceType)
    -> [(IfaceType, IfaceType)] -> IfaceContext
    forall a b. (a -> b) -> [a] -> [b]
    map (IfaceType, IfaceType) -> IfaceType
    forall a b. (a, b) -> b
    snd [(IfaceType, IfaceType)]
    arg_tys)
        pp_prefix_con :: SDoc
    pp_prefix_con = ShowHowMuch -> OccName -> SDoc
    pprPrefixIfDeclBndr ShowHowMuch
    how_much (IfExtName -> OccName
    forall name. HasOccName name => name -> OccName
    occName IfExtName
    name)

        -- If we're pretty-printing a H98-style declaration with existential
        -- quantification, then user_tvbs will always consist of the universal
        -- tyvar binders followed by the existential tyvar binders. So to recover
        -- the visibilities of the existential tyvar binders, we can simply drop
        -- the universal tyvar binders from user_tvbs.
        ex_tvbs :: [IfaceForAllSpecBndr]
    ex_tvbs = [IfaceTyConBinder]
    -> [IfaceForAllSpecBndr] -> [IfaceForAllSpecBndr]
    forall b a. [b] -> [a] -> [a]
    dropList [IfaceTyConBinder]
    tc_binders [IfaceForAllSpecBndr]
    user_tvbs
        ppr_ex_quant :: SDoc -> SDoc
    ppr_ex_quant = [IfaceForAllBndr] -> IfaceContext -> SDoc -> SDoc
    pprIfaceForAllPartMust ([IfaceForAllSpecBndr] -> [IfaceForAllBndr]
    ifaceForAllSpecToBndrs [IfaceForAllSpecBndr]
    ex_tvbs) IfaceContext
    ctxt
        pp_gadt_res_ty :: SDoc
    pp_gadt_res_ty = [IfaceTvBndr] -> SDoc
    mk_user_con_res_ty [IfaceTvBndr]
    eq_spec
        ppr_gadt_ty :: SDoc
    ppr_gadt_ty = [IfaceForAllBndr] -> IfaceContext -> SDoc -> SDoc
    pprIfaceForAllPart ([IfaceForAllSpecBndr] -> [IfaceForAllBndr]
    ifaceForAllSpecToBndrs [IfaceForAllSpecBndr]
    user_tvbs) IfaceContext
    ctxt SDoc
    pp_tau

            -- A bit gruesome this, but we can't form the full con_tau, and ppr it,
            -- because we don't have a Name for the tycon, only an OccName
        pp_tau :: SDoc
    pp_tau | [FieldLabel] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [FieldLabel]
    fields
               = case [SDoc]
    pp_args [SDoc] -> [SDoc] -> [SDoc]
    forall a. [a] -> [a] -> [a]
    ++ [SDoc
    pp_gadt_res_ty] of
                    (SDoc
    t:[SDoc]
    ts) -> [SDoc] -> SDoc
    fsep (SDoc
    t SDoc -> [SDoc] -> [SDoc]
    forall a. a -> [a] -> [a]
    : String
    -> ((IfaceType, IfaceType) -> SDoc -> SDoc)
    -> [(IfaceType, IfaceType)]
    -> [SDoc]
    -> [SDoc]
    forall a b c. String -> (a -> b -> c) -> [a] -> [b] -> [c]
    zipWithEqual String
    "pprIfaceConDecl" (\(IfaceType
    w,IfaceType
    _) SDoc
    d -> IfaceType -> SDoc
    ppr_arr IfaceType
    w SDoc -> SDoc -> SDoc
    <+> SDoc
    d) [(IfaceType, IfaceType)]
    arg_tys [SDoc]
    ts)
                    []     -> String -> SDoc
    forall a. String -> a
    panic String
    "pp_con_taus"
               | Bool
    otherwise
               = [SDoc] -> SDoc
    sep [SDoc
    pp_field_args, SDoc
    arrow SDoc -> SDoc -> SDoc
    <+> SDoc
    pp_gadt_res_ty]

        -- Constructors are linear by default, but we don't want to show
        -- linear arrows when -XLinearTypes is disabled
        ppr_arr :: IfaceType -> SDoc
    ppr_arr IfaceType
    w = (SDocContext -> Bool) -> (Bool -> SDoc) -> SDoc
    forall a. (SDocContext -> a) -> (a -> SDoc) -> SDoc
    sdocOption SDocContext -> Bool
    sdocLinearTypes (\Bool
    linearTypes -> if Bool
    linearTypes
                                                                then IfaceType -> SDoc
    ppr_fun_arrow IfaceType
    w
                                                                else SDoc
    arrow)

        ppr_bang :: IfaceBang -> SDoc
    ppr_bang IfaceBang
    IfNoBang = SDoc -> SDoc
    whenPprDebug (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ Char -> SDoc
    char Char
    '_'
        ppr_bang IfaceBang
    IfStrict = Char -> SDoc
    char Char
    '!'
        ppr_bang IfaceBang
    IfUnpack = String -> SDoc
    text String
    "{-# UNPACK #-}"
        ppr_bang (IfUnpackCo IfaceCoercion
    co) = String -> SDoc
    text String
    "! {-# UNPACK #-}" SDoc -> SDoc -> SDoc
    <>
                                   IfaceCoercion -> SDoc
    pprParendIfaceCoercion IfaceCoercion
    co

        pprFieldArgTy, pprArgTy :: (IfaceBang, IfaceType) -> SDoc
        -- If using record syntax, the only reason one would need to parenthesize
        -- a compound field type is if it's preceded by a bang pattern.
        pprFieldArgTy :: (IfaceBang, IfaceType) -> SDoc
    pprFieldArgTy (IfaceBang
    bang, IfaceType
    ty) = PprPrec -> IfaceBang -> IfaceType -> SDoc
    ppr_arg_ty (IfaceBang -> PprPrec
    bang_prec IfaceBang
    bang) IfaceBang
    bang IfaceType
    ty
        -- If not using record syntax, a compound field type might need to be
        -- parenthesized if one of the following holds:
        --
        -- 1. We're using Haskell98 syntax.
        -- 2. The field type is preceded with a bang pattern.
        pprArgTy :: (IfaceBang, IfaceType) -> SDoc
    pprArgTy (IfaceBang
    bang, IfaceType
    ty) = PprPrec -> IfaceBang -> IfaceType -> SDoc
    ppr_arg_ty (PprPrec -> PprPrec -> PprPrec
    forall a. Ord a => a -> a -> a
    max PprPrec
    gadt_prec (IfaceBang -> PprPrec
    bang_prec IfaceBang
    bang)) IfaceBang
    bang IfaceType
    ty

        ppr_arg_ty :: PprPrec -> IfaceBang -> IfaceType -> SDoc
        ppr_arg_ty :: PprPrec -> IfaceBang -> IfaceType -> SDoc
    ppr_arg_ty PprPrec
    prec IfaceBang
    bang IfaceType
    ty = IfaceBang -> SDoc
    ppr_bang IfaceBang
    bang SDoc -> SDoc -> SDoc
    <> PprPrec -> IfaceType -> SDoc
    pprPrecIfaceType PprPrec
    prec IfaceType
    ty

        -- If we're displaying the fields GADT-style, e.g.,
        --
        --   data Foo a where
        --     MkFoo :: (Int -> Int) -> Maybe a -> Foo
        --
        -- Then we use `funPrec`, since that will ensure `Int -> Int` gets the
        -- parentheses that it requires, but simple compound types like `Maybe a`
        -- (which don't require parentheses in a function argument position) won't
        -- get them, assuming that there are no bang patterns (see bang_prec).
        --
        -- If we're displaying the fields Haskell98-style, e.g.,
        --
        --   data Foo a = MkFoo (Int -> Int) (Maybe a)
        --
        -- Then not only must we parenthesize `Int -> Int`, we must also
        -- parenthesize compound fields like (Maybe a). Therefore, we pick
        -- `appPrec`, which has higher precedence than `funPrec`.
        gadt_prec :: PprPrec
        gadt_prec :: PprPrec
    gadt_prec
          | Bool
    gadt_style = PprPrec
    funPrec
          | Bool
    otherwise  = PprPrec
    appPrec

        -- The presence of bang patterns or UNPACK annotations requires
        -- surrounding the type with parentheses, if needed (#13699)
        bang_prec :: IfaceBang -> PprPrec
        bang_prec :: IfaceBang -> PprPrec
    bang_prec IfaceBang
    IfNoBang     = PprPrec
    topPrec
        bang_prec IfaceBang
    IfStrict     = PprPrec
    appPrec
        bang_prec IfaceBang
    IfUnpack     = PprPrec
    appPrec
        bang_prec IfUnpackCo{} = PprPrec
    appPrec

        pp_args :: [SDoc] -- No records, e.g., `  Maybe a  ->  Int -> ...` or
                          --                   `!(Maybe a) -> !Int -> ...`
        pp_args :: [SDoc]
    pp_args = ((IfaceBang, IfaceType) -> SDoc)
    -> [(IfaceBang, IfaceType)] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map (IfaceBang, IfaceType) -> SDoc
    pprArgTy [(IfaceBang, IfaceType)]
    tys_w_strs

        pp_field_args :: SDoc -- Records, e.g., { x ::   Maybe a,  y ::  Int } or
                              --                { x :: !(Maybe a), y :: !Int }
        pp_field_args :: SDoc
    pp_field_args = SDoc -> SDoc
    braces (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ [SDoc] -> SDoc
    sep ([SDoc] -> SDoc) -> [SDoc] -> SDoc
    forall a b. (a -> b) -> a -> b
    $ SDoc -> [SDoc] -> [SDoc]
    punctuate SDoc
    comma ([SDoc] -> [SDoc]) -> [SDoc] -> [SDoc]
    forall a b. (a -> b) -> a -> b
    $ [Maybe SDoc] -> [SDoc]
    ppr_trim ([Maybe SDoc] -> [SDoc]) -> [Maybe SDoc] -> [SDoc]
    forall a b. (a -> b) -> a -> b
    $
                        (FieldLabel -> (IfaceBang, IfaceType) -> Maybe SDoc)
    -> [FieldLabel] -> [(IfaceBang, IfaceType)] -> [Maybe SDoc]
    forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
    zipWith FieldLabel -> (IfaceBang, IfaceType) -> Maybe SDoc
    maybe_show_label [FieldLabel]
    fields [(IfaceBang, IfaceType)]
    tys_w_strs

        maybe_show_label :: FieldLabel -> (IfaceBang, IfaceType) -> Maybe SDoc
        maybe_show_label :: FieldLabel -> (IfaceBang, IfaceType) -> Maybe SDoc
    maybe_show_label FieldLabel
    lbl (IfaceBang, IfaceType)
    bty
          | ShowSub -> IfExtName -> Bool
    forall n. HasOccName n => ShowSub -> n -> Bool
    showSub ShowSub
    ss IfExtName
    sel = SDoc -> Maybe SDoc
    forall a. a -> Maybe a
    Just (ShowHowMuch -> OccName -> SDoc
    pprPrefixIfDeclBndr ShowHowMuch
    how_much OccName
    occ
                                    SDoc -> SDoc -> SDoc
    <+> SDoc
    dcolon SDoc -> SDoc -> SDoc
    <+> (IfaceBang, IfaceType) -> SDoc
    pprFieldArgTy (IfaceBang, IfaceType)
    bty)
          | Bool
    otherwise      = Maybe SDoc
    forall a. Maybe a
    Nothing
          where
            sel :: IfExtName
    sel = FieldLabel -> IfExtName
    flSelector FieldLabel
    lbl
            occ :: OccName
    occ = IfLclName -> OccName
    mkVarOccFS (FieldLabel -> IfLclName
    flLabel FieldLabel
    lbl)

        mk_user_con_res_ty :: IfaceEqSpec -> SDoc
        -- See Note [Result type of a data family GADT]
        mk_user_con_res_ty :: [IfaceTvBndr] -> SDoc
    mk_user_con_res_ty [IfaceTvBndr]
    eq_spec
          | IfDataInstance IfExtName
    _ IfaceTyCon
    tc IfaceAppArgs
    tys <- IfaceTyConParent
    parent
          = IfaceType -> SDoc
    pprIfaceType (IfaceTyCon -> IfaceAppArgs -> IfaceType
    IfaceTyConApp IfaceTyCon
    tc (IfaceTySubst -> IfaceAppArgs -> IfaceAppArgs
    substIfaceAppArgs IfaceTySubst
    gadt_subst IfaceAppArgs
    tys))
          | Bool
    otherwise
          = IfaceTySubst -> SDoc
    ppr_tc_app IfaceTySubst
    gadt_subst
          where
            gadt_subst :: IfaceTySubst
    gadt_subst = [IfaceTvBndr] -> IfaceTySubst
    mkIfaceTySubst [IfaceTvBndr]
    eq_spec

        -- When pretty-printing a GADT return type, we:
        --
        -- 1. Take the data tycon binders, extract their variable names and
        --    visibilities, and construct suitable arguments from them. (This is
        --    the role of mk_tc_app_args.)
        -- 2. Apply the GADT substitution constructed from the eq_spec.
        --    (See Note [Result type of a data family GADT].)
        -- 3. Pretty-print the data type constructor applied to its arguments.
        --    This process will omit any invisible arguments, such as coercion
        --    variables, if necessary. (See Note
        --    [VarBndrs, TyCoVarBinders, TyConBinders, and visibility] in GHC.Core.TyCo.Rep.)
        ppr_tc_app :: IfaceTySubst -> SDoc
    ppr_tc_app IfaceTySubst
    gadt_subst =
          ShowHowMuch -> OccName -> SDoc
    pprPrefixIfDeclBndr ShowHowMuch
    how_much (IfExtName -> OccName
    forall name. HasOccName name => name -> OccName
    occName IfExtName
    tycon)
          SDoc -> SDoc -> SDoc
    <+> IfaceAppArgs -> SDoc
    pprParendIfaceAppArgs
                (IfaceTySubst -> IfaceAppArgs -> IfaceAppArgs
    substIfaceAppArgs IfaceTySubst
    gadt_subst ([IfaceTyConBinder] -> IfaceAppArgs
    mk_tc_app_args [IfaceTyConBinder]
    tc_binders))

        mk_tc_app_args :: [IfaceTyConBinder] -> IfaceAppArgs
        mk_tc_app_args :: [IfaceTyConBinder] -> IfaceAppArgs
    mk_tc_app_args [] = IfaceAppArgs
    IA_Nil
        mk_tc_app_args (Bndr IfaceBndr
    bndr TyConBndrVis
    vis:[IfaceTyConBinder]
    tc_bndrs) =
          IfaceType -> ArgFlag -> IfaceAppArgs -> IfaceAppArgs
    IA_Arg (IfLclName -> IfaceType
    IfaceTyVar (IfaceBndr -> IfLclName
    ifaceBndrName IfaceBndr
    bndr)) (TyConBndrVis -> ArgFlag
    tyConBndrVisArgFlag TyConBndrVis
    vis)
                 ([IfaceTyConBinder] -> IfaceAppArgs
    mk_tc_app_args [IfaceTyConBinder]
    tc_bndrs)

    instance Outputable IfaceRule where
      ppr :: IfaceRule -> SDoc
    ppr (IfaceRule { ifRuleName :: IfaceRule -> IfLclName
    ifRuleName = IfLclName
    name, ifActivation :: IfaceRule -> Activation
    ifActivation = Activation
    act, ifRuleBndrs :: IfaceRule -> [IfaceBndr]
    ifRuleBndrs = [IfaceBndr]
    bndrs,
                       ifRuleHead :: IfaceRule -> IfExtName
    ifRuleHead = IfExtName
    fn, ifRuleArgs :: IfaceRule -> [IfaceExpr]
    ifRuleArgs = [IfaceExpr]
    args, ifRuleRhs :: IfaceRule -> IfaceExpr
    ifRuleRhs = IfaceExpr
    rhs,
                       ifRuleOrph :: IfaceRule -> IsOrphan
    ifRuleOrph = IsOrphan
    orph })
        = [SDoc] -> SDoc
    sep [ [SDoc] -> SDoc
    hsep [ IfLclName -> SDoc
    pprRuleName IfLclName
    name
                     , if IsOrphan -> Bool
    isOrphan IsOrphan
    orph then String -> SDoc
    text String
    "[orphan]" else SDoc
    Outputable.empty
                     , Activation -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Activation
    act
                     , SDoc
    pp_foralls ]
              , Int -> SDoc -> SDoc
    nest Int
    2 ([SDoc] -> SDoc
    sep [IfExtName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfExtName
    fn SDoc -> SDoc -> SDoc
    <+> [SDoc] -> SDoc
    sep ((IfaceExpr -> SDoc) -> [IfaceExpr] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map IfaceExpr -> SDoc
    pprParendIfaceExpr [IfaceExpr]
    args),
                            String -> SDoc
    text String
    "=" SDoc -> SDoc -> SDoc
    <+> IfaceExpr -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfaceExpr
    rhs]) ]
        where
          pp_foralls :: SDoc
    pp_foralls = Bool -> SDoc -> SDoc
    ppUnless ([IfaceBndr] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [IfaceBndr]
    bndrs) (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ SDoc
    forAllLit SDoc -> SDoc -> SDoc
    <+> [IfaceBndr] -> SDoc
    pprIfaceBndrs [IfaceBndr]
    bndrs SDoc -> SDoc -> SDoc
    <> SDoc
    dot

    instance Outputable IfaceClsInst where
      ppr :: IfaceClsInst -> SDoc
    ppr (IfaceClsInst { ifDFun :: IfaceClsInst -> IfExtName
    ifDFun = IfExtName
    dfun_id, ifOFlag :: IfaceClsInst -> OverlapFlag
    ifOFlag = OverlapFlag
    flag
                        , ifInstCls :: IfaceClsInst -> IfExtName
    ifInstCls = IfExtName
    cls, ifInstTys :: IfaceClsInst -> [Maybe IfaceTyCon]
    ifInstTys = [Maybe IfaceTyCon]
    mb_tcs
                        , ifInstOrph :: IfaceClsInst -> IsOrphan
    ifInstOrph = IsOrphan
    orph })
        = SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    text String
    "instance" SDoc -> SDoc -> SDoc
    <+> OverlapFlag -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr OverlapFlag
    flag
                  SDoc -> SDoc -> SDoc
    <+> (if IsOrphan -> Bool
    isOrphan IsOrphan
    orph then String -> SDoc
    text String
    "[orphan]" else SDoc
    Outputable.empty)
                  SDoc -> SDoc -> SDoc
    <+> IfExtName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfExtName
    cls SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    brackets ((Maybe IfaceTyCon -> SDoc) -> [Maybe IfaceTyCon] -> SDoc
    forall a. (a -> SDoc) -> [a] -> SDoc
    pprWithCommas Maybe IfaceTyCon -> SDoc
    ppr_rough [Maybe IfaceTyCon]
    mb_tcs))
             Int
    2 (SDoc
    equals SDoc -> SDoc -> SDoc
    <+> IfExtName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfExtName
    dfun_id)

    instance Outputable IfaceFamInst where
      ppr :: IfaceFamInst -> SDoc
    ppr (IfaceFamInst { ifFamInstFam :: IfaceFamInst -> IfExtName
    ifFamInstFam = IfExtName
    fam, ifFamInstTys :: IfaceFamInst -> [Maybe IfaceTyCon]
    ifFamInstTys = [Maybe IfaceTyCon]
    mb_tcs
                        , ifFamInstAxiom :: IfaceFamInst -> IfExtName
    ifFamInstAxiom = IfExtName
    tycon_ax, ifFamInstOrph :: IfaceFamInst -> IsOrphan
    ifFamInstOrph = IsOrphan
    orph })
        = SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    text String
    "family instance"
                  SDoc -> SDoc -> SDoc
    <+> (if IsOrphan -> Bool
    isOrphan IsOrphan
    orph then String -> SDoc
    text String
    "[orphan]" else SDoc
    Outputable.empty)
                  SDoc -> SDoc -> SDoc
    <+> IfExtName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfExtName
    fam SDoc -> SDoc -> SDoc
    <+> (Maybe IfaceTyCon -> SDoc) -> [Maybe IfaceTyCon] -> SDoc
    forall a. (a -> SDoc) -> [a] -> SDoc
    pprWithCommas (SDoc -> SDoc
    brackets (SDoc -> SDoc)
    -> (Maybe IfaceTyCon -> SDoc) -> Maybe IfaceTyCon -> SDoc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Maybe IfaceTyCon -> SDoc
    ppr_rough) [Maybe IfaceTyCon]
    mb_tcs)
             Int
    2 (SDoc
    equals SDoc -> SDoc -> SDoc
    <+> IfExtName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfExtName
    tycon_ax)

    ppr_rough :: Maybe IfaceTyCon -> SDoc
    ppr_rough :: Maybe IfaceTyCon -> SDoc
    ppr_rough Maybe IfaceTyCon
    Nothing   = SDoc
    dot
    ppr_rough (Just IfaceTyCon
    tc) = IfaceTyCon -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfaceTyCon
    tc

    {-
    Note [Result type of a data family GADT]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Consider
       data family T a
       data instance T (p,q) where
          T1 :: T (Int, Maybe c)
          T2 :: T (Bool, q)

    The IfaceDecl actually looks like

       data TPr p q where
          T1 :: forall p q. forall c. (p~Int,q~Maybe c) => TPr p q
          T2 :: forall p q. (p~Bool) => TPr p q

    To reconstruct the result types for T1 and T2 that we
    want to pretty print, we substitute the eq-spec
    [p->Int, q->Maybe c] in the arg pattern (p,q) to give
       T (Int, Maybe c)
    Remember that in IfaceSyn, the TyCon and DataCon share the same
    universal type variables.

    ----------------------------- Printing IfaceExpr ------------------------------------
    -}

    instance Outputable IfaceExpr where
        ppr :: IfaceExpr -> SDoc
    ppr IfaceExpr
    e = (SDoc -> SDoc) -> IfaceExpr -> SDoc
    pprIfaceExpr SDoc -> SDoc
    noParens IfaceExpr
    e

    noParens :: SDoc -> SDoc
    noParens :: SDoc -> SDoc
    noParens SDoc
    pp = SDoc
    pp

    pprParendIfaceExpr :: IfaceExpr -> SDoc
    pprParendIfaceExpr :: IfaceExpr -> SDoc
    pprParendIfaceExpr = (SDoc -> SDoc) -> IfaceExpr -> SDoc
    pprIfaceExpr SDoc -> SDoc
    parens

    -- | Pretty Print an IfaceExpr
    --
    -- The first argument should be a function that adds parens in context that need
    -- an atomic value (e.g. function args)
    pprIfaceExpr :: (SDoc -> SDoc) -> IfaceExpr -> SDoc

    pprIfaceExpr :: (SDoc -> SDoc) -> IfaceExpr -> SDoc
    pprIfaceExpr SDoc -> SDoc
    _       (IfaceLcl IfLclName
    v)       = IfLclName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfLclName
    v
    pprIfaceExpr SDoc -> SDoc
    _       (IfaceExt IfExtName
    v)       = IfExtName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfExtName
    v
    pprIfaceExpr SDoc -> SDoc
    _       (IfaceLit Literal
    l)       = Literal -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Literal
    l
    pprIfaceExpr SDoc -> SDoc
    _       (IfaceFCall ForeignCall
    cc IfaceType
    ty) = SDoc -> SDoc
    braces (ForeignCall -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr ForeignCall
    cc SDoc -> SDoc -> SDoc
    <+> IfaceType -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfaceType
    ty)
    pprIfaceExpr SDoc -> SDoc
    _       (IfaceType IfaceType
    ty)     = Char -> SDoc
    char Char
    '@' SDoc -> SDoc -> SDoc
    <> IfaceType -> SDoc
    pprParendIfaceType IfaceType
    ty
    pprIfaceExpr SDoc -> SDoc
    _       (IfaceCo IfaceCoercion
    co)       = String -> SDoc
    text String
    "@~" SDoc -> SDoc -> SDoc
    <> IfaceCoercion -> SDoc
    pprParendIfaceCoercion IfaceCoercion
    co

    pprIfaceExpr SDoc -> SDoc
    add_par app :: IfaceExpr
    app@(IfaceApp IfaceExpr
    _ IfaceExpr
    _) = SDoc -> SDoc
    add_par (IfaceExpr -> [SDoc] -> SDoc
    pprIfaceApp IfaceExpr
    app [])
    pprIfaceExpr SDoc -> SDoc
    _       (IfaceTuple TupleSort
    c [IfaceExpr]
    as)  = TupleSort -> SDoc -> SDoc
    tupleParens TupleSort
    c ((IfaceExpr -> SDoc) -> [IfaceExpr] -> SDoc
    forall a. (a -> SDoc) -> [a] -> SDoc
    pprWithCommas IfaceExpr -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [IfaceExpr]
    as)

    pprIfaceExpr SDoc -> SDoc
    add_par i :: IfaceExpr
    i@(IfaceLam IfaceLamBndr
    _ IfaceExpr
    _)
      = SDoc -> SDoc
    add_par ([SDoc] -> SDoc
    sep [Char -> SDoc
    char Char
    '\\' SDoc -> SDoc -> SDoc
    <+> [SDoc] -> SDoc
    sep ((IfaceLamBndr -> SDoc) -> [IfaceLamBndr] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map IfaceLamBndr -> SDoc
    pprIfaceLamBndr [IfaceLamBndr]
    bndrs) SDoc -> SDoc -> SDoc
    <+> SDoc
    arrow,
                      (SDoc -> SDoc) -> IfaceExpr -> SDoc
    pprIfaceExpr SDoc -> SDoc
    noParens IfaceExpr
    body])
      where
        ([IfaceLamBndr]
    bndrs,IfaceExpr
    body) = [IfaceLamBndr] -> IfaceExpr -> ([IfaceLamBndr], IfaceExpr)
    collect [] IfaceExpr
    i
        collect :: [IfaceLamBndr] -> IfaceExpr -> ([IfaceLamBndr], IfaceExpr)
    collect [IfaceLamBndr]
    bs (IfaceLam IfaceLamBndr
    b IfaceExpr
    e) = [IfaceLamBndr] -> IfaceExpr -> ([IfaceLamBndr], IfaceExpr)
    collect (IfaceLamBndr
    bIfaceLamBndr -> [IfaceLamBndr] -> [IfaceLamBndr]
    forall a. a -> [a] -> [a]
    :[IfaceLamBndr]
    bs) IfaceExpr
    e
        collect [IfaceLamBndr]
    bs IfaceExpr
    e              = ([IfaceLamBndr] -> [IfaceLamBndr]
    forall a. [a] -> [a]
    reverse [IfaceLamBndr]
    bs, IfaceExpr
    e)

    pprIfaceExpr SDoc -> SDoc
    add_par (IfaceECase IfaceExpr
    scrut IfaceType
    ty)
      = SDoc -> SDoc
    add_par ([SDoc] -> SDoc
    sep [ String -> SDoc
    text String
    "case" SDoc -> SDoc -> SDoc
    <+> (SDoc -> SDoc) -> IfaceExpr -> SDoc
    pprIfaceExpr SDoc -> SDoc
    noParens IfaceExpr
    scrut
                     , String -> SDoc
    text String
    "ret_ty" SDoc -> SDoc -> SDoc
    <+> IfaceType -> SDoc
    pprParendIfaceType IfaceType
    ty
                     , String -> SDoc
    text String
    "of {}" ])

    pprIfaceExpr SDoc -> SDoc
    add_par (IfaceCase IfaceExpr
    scrut IfLclName
    bndr [IfaceAlt IfaceConAlt
    con [IfLclName]
    bs IfaceExpr
    rhs])
      = SDoc -> SDoc
    add_par ([SDoc] -> SDoc
    sep [String -> SDoc
    text String
    "case"
                            SDoc -> SDoc -> SDoc
    <+> (SDoc -> SDoc) -> IfaceExpr -> SDoc
    pprIfaceExpr SDoc -> SDoc
    noParens IfaceExpr
    scrut SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "of"
                            SDoc -> SDoc -> SDoc
    <+> IfLclName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfLclName
    bndr SDoc -> SDoc -> SDoc
    <+> Char -> SDoc
    char Char
    '{' SDoc -> SDoc -> SDoc
    <+> IfaceConAlt -> [IfLclName] -> SDoc
    ppr_con_bs IfaceConAlt
    con [IfLclName]
    bs SDoc -> SDoc -> SDoc
    <+> SDoc
    arrow,
                      (SDoc -> SDoc) -> IfaceExpr -> SDoc
    pprIfaceExpr SDoc -> SDoc
    noParens IfaceExpr
    rhs SDoc -> SDoc -> SDoc
    <+> Char -> SDoc
    char Char
    '}'])

    pprIfaceExpr SDoc -> SDoc
    add_par (IfaceCase IfaceExpr
    scrut IfLclName
    bndr [IfaceAlt]
    alts)
      = SDoc -> SDoc
    add_par ([SDoc] -> SDoc
    sep [String -> SDoc
    text String
    "case"
                            SDoc -> SDoc -> SDoc
    <+> (SDoc -> SDoc) -> IfaceExpr -> SDoc
    pprIfaceExpr SDoc -> SDoc
    noParens IfaceExpr
    scrut SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "of"
                            SDoc -> SDoc -> SDoc
    <+> IfLclName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfLclName
    bndr SDoc -> SDoc -> SDoc
    <+> Char -> SDoc
    char Char
    '{',
                      Int -> SDoc -> SDoc
    nest Int
    2 ([SDoc] -> SDoc
    sep ((IfaceAlt -> SDoc) -> [IfaceAlt] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map IfaceAlt -> SDoc
    pprIfaceAlt [IfaceAlt]
    alts)) SDoc -> SDoc -> SDoc
    <+> Char -> SDoc
    char Char
    '}'])

    pprIfaceExpr SDoc -> SDoc
    _       (IfaceCast IfaceExpr
    expr IfaceCoercion
    co)
      = [SDoc] -> SDoc
    sep [IfaceExpr -> SDoc
    pprParendIfaceExpr IfaceExpr
    expr,
             Int -> SDoc -> SDoc
    nest Int
    2 (String -> SDoc
    text String
    "`cast`"),
             IfaceCoercion -> SDoc
    pprParendIfaceCoercion IfaceCoercion
    co]

    pprIfaceExpr SDoc -> SDoc
    add_par (IfaceLet (IfaceNonRec IfaceLetBndr
    b IfaceExpr
    rhs) IfaceExpr
    body)
      = SDoc -> SDoc
    add_par ([SDoc] -> SDoc
    sep [String -> SDoc
    text String
    "let {",
                      Int -> SDoc -> SDoc
    nest Int
    2 ((IfaceLetBndr, IfaceExpr) -> SDoc
    ppr_bind (IfaceLetBndr
    b, IfaceExpr
    rhs)),
                      String -> SDoc
    text String
    "} in",
                      (SDoc -> SDoc) -> IfaceExpr -> SDoc
    pprIfaceExpr SDoc -> SDoc
    noParens IfaceExpr
    body])

    pprIfaceExpr SDoc -> SDoc
    add_par (IfaceLet (IfaceRec [(IfaceLetBndr, IfaceExpr)]
    pairs) IfaceExpr
    body)
      = SDoc -> SDoc
    add_par ([SDoc] -> SDoc
    sep [String -> SDoc
    text String
    "letrec {",
                      Int -> SDoc -> SDoc
    nest Int
    2 ([SDoc] -> SDoc
    sep (((IfaceLetBndr, IfaceExpr) -> SDoc)
    -> [(IfaceLetBndr, IfaceExpr)] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map (IfaceLetBndr, IfaceExpr) -> SDoc
    ppr_bind [(IfaceLetBndr, IfaceExpr)]
    pairs)),
                      String -> SDoc
    text String
    "} in",
                      (SDoc -> SDoc) -> IfaceExpr -> SDoc
    pprIfaceExpr SDoc -> SDoc
    noParens IfaceExpr
    body])

    pprIfaceExpr SDoc -> SDoc
    add_par (IfaceTick IfaceTickish
    tickish IfaceExpr
    e)
      = SDoc -> SDoc
    add_par (IfaceTickish -> SDoc
    pprIfaceTickish IfaceTickish
    tickish SDoc -> SDoc -> SDoc
    <+> (SDoc -> SDoc) -> IfaceExpr -> SDoc
    pprIfaceExpr SDoc -> SDoc
    noParens IfaceExpr
    e)

    pprIfaceAlt :: IfaceAlt -> SDoc
    pprIfaceAlt :: IfaceAlt -> SDoc
    pprIfaceAlt (IfaceAlt IfaceConAlt
    con [IfLclName]
    bs IfaceExpr
    rhs)
      = [SDoc] -> SDoc
    sep [IfaceConAlt -> [IfLclName] -> SDoc
    ppr_con_bs IfaceConAlt
    con [IfLclName]
    bs, SDoc
    arrow SDoc -> SDoc -> SDoc
    <+> (SDoc -> SDoc) -> IfaceExpr -> SDoc
    pprIfaceExpr SDoc -> SDoc
    noParens IfaceExpr
    rhs]

    ppr_con_bs :: IfaceConAlt -> [IfLclName] -> SDoc
    ppr_con_bs :: IfaceConAlt -> [IfLclName] -> SDoc
    ppr_con_bs IfaceConAlt
    con [IfLclName]
    bs = IfaceConAlt -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfaceConAlt
    con SDoc -> SDoc -> SDoc
    <+> [SDoc] -> SDoc
    hsep ((IfLclName -> SDoc) -> [IfLclName] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map IfLclName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [IfLclName]
    bs)

    ppr_bind :: (IfaceLetBndr, IfaceExpr) -> SDoc
    ppr_bind :: (IfaceLetBndr, IfaceExpr) -> SDoc
    ppr_bind (IfLetBndr IfLclName
    b IfaceType
    ty IfaceIdInfo
    info IfaceJoinInfo
    ji, IfaceExpr
    rhs)
      = [SDoc] -> SDoc
    sep [SDoc -> Int -> SDoc -> SDoc
    hang (IfLclName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfLclName
    b SDoc -> SDoc -> SDoc
    <+> SDoc
    dcolon SDoc -> SDoc -> SDoc
    <+> IfaceType -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfaceType
    ty) Int
    2 (IfaceJoinInfo -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfaceJoinInfo
    ji SDoc -> SDoc -> SDoc
    <+> IfaceIdInfo -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfaceIdInfo
    info),
             SDoc
    equals SDoc -> SDoc -> SDoc
    <+> (SDoc -> SDoc) -> IfaceExpr -> SDoc
    pprIfaceExpr SDoc -> SDoc
    noParens IfaceExpr
    rhs]

    ------------------
    pprIfaceTickish :: IfaceTickish -> SDoc
    pprIfaceTickish :: IfaceTickish -> SDoc
    pprIfaceTickish (IfaceHpcTick Module
    m Int
    ix)
      = SDoc -> SDoc
    braces (String -> SDoc
    text String
    "tick" SDoc -> SDoc -> SDoc
    <+> Module -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Module
    m SDoc -> SDoc -> SDoc
    <+> Int -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Int
    ix)
    pprIfaceTickish (IfaceSCC CostCentre
    cc Bool
    tick Bool
    scope)
      = SDoc -> SDoc
    braces (CostCentre -> SDoc
    pprCostCentreCore CostCentre
    cc SDoc -> SDoc -> SDoc
    <+> Bool -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Bool
    tick SDoc -> SDoc -> SDoc
    <+> Bool -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Bool
    scope)
    pprIfaceTickish (IfaceSource RealSrcSpan
    src String
    _names)
      = SDoc -> SDoc
    braces (Bool -> RealSrcSpan -> SDoc
    pprUserRealSpan Bool
    True RealSrcSpan
    src)

    ------------------
    pprIfaceApp :: IfaceExpr -> [SDoc] -> SDoc
    pprIfaceApp :: IfaceExpr -> [SDoc] -> SDoc
    pprIfaceApp (IfaceApp IfaceExpr
    fun IfaceExpr
    arg) [SDoc]
    args = IfaceExpr -> [SDoc] -> SDoc
    pprIfaceApp IfaceExpr
    fun ([SDoc] -> SDoc) -> [SDoc] -> SDoc
    forall a b. (a -> b) -> a -> b
    $
                                              Int -> SDoc -> SDoc
    nest Int
    2 (IfaceExpr -> SDoc
    pprParendIfaceExpr IfaceExpr
    arg) SDoc -> [SDoc] -> [SDoc]
    forall a. a -> [a] -> [a]
    : [SDoc]
    args
    pprIfaceApp IfaceExpr
    fun                [SDoc]
    args = [SDoc] -> SDoc
    sep (IfaceExpr -> SDoc
    pprParendIfaceExpr IfaceExpr
    fun SDoc -> [SDoc] -> [SDoc]
    forall a. a -> [a] -> [a]
    : [SDoc]
    args)

    ------------------
    instance Outputable IfaceConAlt where
        ppr :: IfaceConAlt -> SDoc
    ppr IfaceConAlt
    IfaceDefault      = String -> SDoc
    text String
    "DEFAULT"
        ppr (IfaceLitAlt Literal
    l)   = Literal -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Literal
    l
        ppr (IfaceDataAlt IfExtName
    d)  = IfExtName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfExtName
    d

    ------------------
    instance Outputable IfaceIdDetails where
      ppr :: IfaceIdDetails -> SDoc
    ppr IfaceIdDetails
    IfVanillaId       = SDoc
    Outputable.empty
      ppr (IfRecSelId Either IfaceTyCon IfaceDecl
    tc Bool
    b) = String -> SDoc
    text String
    "RecSel" SDoc -> SDoc -> SDoc
    <+> Either IfaceTyCon IfaceDecl -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Either IfaceTyCon IfaceDecl
    tc
                              SDoc -> SDoc -> SDoc
    <+> if Bool
    b
                                    then String -> SDoc
    text String
    "<naughty>"
                                    else SDoc
    Outputable.empty
      ppr IfaceIdDetails
    IfDFunId          = String -> SDoc
    text String
    "DFunId"

    instance Outputable IfaceInfoItem where
      ppr :: IfaceInfoItem -> SDoc
    ppr (HsUnfold Bool
    lb IfaceUnfolding
    unf)     = String -> SDoc
    text String
    "Unfolding"
                                  SDoc -> SDoc -> SDoc
    <> Bool -> SDoc -> SDoc
    ppWhen Bool
    lb (String -> SDoc
    text String
    "(loop-breaker)")
                                  SDoc -> SDoc -> SDoc
    <> SDoc
    colon SDoc -> SDoc -> SDoc
    <+> IfaceUnfolding -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfaceUnfolding
    unf
      ppr (HsInline InlinePragma
    prag)       = String -> SDoc
    text String
    "Inline:" SDoc -> SDoc -> SDoc
    <+> InlinePragma -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr InlinePragma
    prag
      ppr (HsArity Int
    arity)       = String -> SDoc
    text String
    "Arity:" SDoc -> SDoc -> SDoc
    <+> Int -> SDoc
    int Int
    arity
      ppr (HsStrictness StrictSig
    str)    = String -> SDoc
    text String
    "Strictness:" SDoc -> SDoc -> SDoc
    <+> StrictSig -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr StrictSig
    str
      ppr (HsCpr CprSig
    cpr)           = String -> SDoc
    text String
    "CPR:" SDoc -> SDoc -> SDoc
    <+> CprSig -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr CprSig
    cpr
      ppr IfaceInfoItem
    HsNoCafRefs           = String -> SDoc
    text String
    "HasNoCafRefs"
      ppr IfaceInfoItem
    HsLevity              = String -> SDoc
    text String
    "Never levity-polymorphic"
      ppr (HsLFInfo IfaceLFInfo
    lf_info)    = String -> SDoc
    text String
    "LambdaFormInfo:" SDoc -> SDoc -> SDoc
    <+> IfaceLFInfo -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfaceLFInfo
    lf_info

    instance Outputable IfaceJoinInfo where
      ppr :: IfaceJoinInfo -> SDoc
    ppr IfaceJoinInfo
    IfaceNotJoinPoint   = SDoc
    empty
      ppr (IfaceJoinPoint Int
    ar) = SDoc -> SDoc
    angleBrackets (String -> SDoc
    text String
    "join" SDoc -> SDoc -> SDoc
    <+> Int -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Int
    ar)

    instance Outputable IfaceUnfolding where
      ppr :: IfaceUnfolding -> SDoc
    ppr (IfCompulsory IfaceExpr
    e)     = String -> SDoc
    text String
    "<compulsory>" SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    parens (IfaceExpr -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfaceExpr
    e)
      ppr (IfCoreUnfold Bool
    s IfaceExpr
    e)   = (if Bool
    s
                                    then String -> SDoc
    text String
    "<stable>"
                                    else SDoc
    Outputable.empty)
                                  SDoc -> SDoc -> SDoc
    <+> SDoc -> SDoc
    parens (IfaceExpr -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IfaceExpr
    e)
      ppr (IfInlineRule Int
    a Bool
    uok Bool
    bok IfaceExpr
    e) = [SDoc] -> SDoc
    sep [String -> SDoc
    text String
    "InlineRule"
                                                SDoc -> SDoc -> SDoc
    <+> (Int, Bool, Bool) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (Int
    a,Bool
    uok,Bool
    bok),
                                            IfaceExpr -> SDoc
    pprParendIfaceExpr IfaceExpr
    e]
      ppr (IfDFunUnfold [IfaceBndr]
    bs [IfaceExpr]
    es) = SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    text String
    "DFun:" SDoc -> SDoc -> SDoc
    <+> [SDoc] -> SDoc
    sep ((IfaceBndr -> SDoc) -> [IfaceBndr] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map IfaceBndr -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [IfaceBndr]
    bs) SDoc -> SDoc -> SDoc
    <> SDoc
    dot)
                                    Int
    2 ([SDoc] -> SDoc
    sep ((IfaceExpr -> SDoc) -> [IfaceExpr] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map IfaceExpr -> SDoc
    pprParendIfaceExpr [IfaceExpr]
    es))

    {-
    ************************************************************************
    *                                                                      *
                  Finding the Names in Iface syntax
    *                                                                      *
    ************************************************************************

    This is used for dependency analysis in GHC.Iface.Make, so that we
    fingerprint a declaration before the things that depend on it.  It
    is specific to interface-file fingerprinting in the sense that we
    don't collect *all* Names: for example, the DFun of an instance is
    recorded textually rather than by its fingerprint when
    fingerprinting the instance, so DFuns are not dependencies.
    -}

    freeNamesIfDecl :: IfaceDecl -> NameSet
    freeNamesIfDecl :: IfaceDecl -> NameSet
    freeNamesIfDecl (IfaceId { ifType :: IfaceDecl -> IfaceType
    ifType = IfaceType
    t, ifIdDetails :: IfaceDecl -> IfaceIdDetails
    ifIdDetails = IfaceIdDetails
    d, ifIdInfo :: IfaceDecl -> IfaceIdInfo
    ifIdInfo = IfaceIdInfo
    i})
      = IfaceType -> NameSet
    freeNamesIfType IfaceType
    t NameSet -> NameSet -> NameSet
    &&&
        IfaceIdInfo -> NameSet
    freeNamesIfIdInfo IfaceIdInfo
    i NameSet -> NameSet -> NameSet
    &&&
        IfaceIdDetails -> NameSet
    freeNamesIfIdDetails IfaceIdDetails
    d

    freeNamesIfDecl (IfaceData { ifBinders :: IfaceDecl -> [IfaceTyConBinder]
    ifBinders = [IfaceTyConBinder]
    bndrs, ifResKind :: IfaceDecl -> IfaceType
    ifResKind = IfaceType
    res_k
                               , ifParent :: IfaceDecl -> IfaceTyConParent
    ifParent = IfaceTyConParent
    p, ifCtxt :: IfaceDecl -> IfaceContext
    ifCtxt = IfaceContext
    ctxt, ifCons :: IfaceDecl -> IfaceConDecls
    ifCons = IfaceConDecls
    cons })
      = [IfaceTyConBinder] -> NameSet
    forall vis. [VarBndr IfaceBndr vis] -> NameSet
    freeNamesIfVarBndrs [IfaceTyConBinder]
    bndrs NameSet -> NameSet -> NameSet
    &&&
        IfaceType -> NameSet
    freeNamesIfType IfaceType
    res_k NameSet -> NameSet -> NameSet
    &&&
        IfaceTyConParent -> NameSet
    freeNamesIfaceTyConParent IfaceTyConParent
    p NameSet -> NameSet -> NameSet
    &&&
        IfaceContext -> NameSet
    freeNamesIfContext IfaceContext
    ctxt NameSet -> NameSet -> NameSet
    &&&
        IfaceConDecls -> NameSet
    freeNamesIfConDecls IfaceConDecls
    cons

    freeNamesIfDecl (IfaceSynonym { ifBinders :: IfaceDecl -> [IfaceTyConBinder]
    ifBinders = [IfaceTyConBinder]
    bndrs, ifResKind :: IfaceDecl -> IfaceType
    ifResKind = IfaceType
    res_k
                                  , ifSynRhs :: IfaceDecl -> IfaceType
    ifSynRhs = IfaceType
    rhs })
      = [IfaceTyConBinder] -> NameSet
    forall vis. [VarBndr IfaceBndr vis] -> NameSet
    freeNamesIfVarBndrs [IfaceTyConBinder]
    bndrs NameSet -> NameSet -> NameSet
    &&&
        IfaceType -> NameSet
    freeNamesIfKind IfaceType
    res_k NameSet -> NameSet -> NameSet
    &&&
        IfaceType -> NameSet
    freeNamesIfType IfaceType
    rhs

    freeNamesIfDecl (IfaceFamily { ifBinders :: IfaceDecl -> [IfaceTyConBinder]
    ifBinders = [IfaceTyConBinder]
    bndrs, ifResKind :: IfaceDecl -> IfaceType
    ifResKind = IfaceType
    res_k
                                 , ifFamFlav :: IfaceDecl -> IfaceFamTyConFlav
    ifFamFlav = IfaceFamTyConFlav
    flav })
      = [IfaceTyConBinder] -> NameSet
    forall vis. [VarBndr IfaceBndr vis] -> NameSet
    freeNamesIfVarBndrs [IfaceTyConBinder]
    bndrs NameSet -> NameSet -> NameSet
    &&&
        IfaceType -> NameSet
    freeNamesIfKind IfaceType
    res_k NameSet -> NameSet -> NameSet
    &&&
        IfaceFamTyConFlav -> NameSet
    freeNamesIfFamFlav IfaceFamTyConFlav
    flav

    freeNamesIfDecl (IfaceClass{ ifBinders :: IfaceDecl -> [IfaceTyConBinder]
    ifBinders = [IfaceTyConBinder]
    bndrs, ifBody :: IfaceDecl -> IfaceClassBody
    ifBody = IfaceClassBody
    cls_body })
      = [IfaceTyConBinder] -> NameSet
    forall vis. [VarBndr IfaceBndr vis] -> NameSet
    freeNamesIfVarBndrs [IfaceTyConBinder]
    bndrs NameSet -> NameSet -> NameSet
    &&&
        IfaceClassBody -> NameSet
    freeNamesIfClassBody IfaceClassBody
    cls_body

    freeNamesIfDecl (IfaceAxiom { ifTyCon :: IfaceDecl -> IfaceTyCon
    ifTyCon = IfaceTyCon
    tc, ifAxBranches :: IfaceDecl -> [IfaceAxBranch]
    ifAxBranches = [IfaceAxBranch]
    branches })
      = IfaceTyCon -> NameSet
    freeNamesIfTc IfaceTyCon
    tc NameSet -> NameSet -> NameSet
    &&&
        (IfaceAxBranch -> NameSet) -> [IfaceAxBranch] -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList IfaceAxBranch -> NameSet
    freeNamesIfAxBranch [IfaceAxBranch]
    branches

    freeNamesIfDecl (IfacePatSyn { ifPatMatcher :: IfaceDecl -> (IfExtName, Bool)
    ifPatMatcher = (IfExtName
    matcher, Bool
    _)
                                 , ifPatBuilder :: IfaceDecl -> Maybe (IfExtName, Bool)
    ifPatBuilder = Maybe (IfExtName, Bool)
    mb_builder
                                 , ifPatUnivBndrs :: IfaceDecl -> [IfaceForAllSpecBndr]
    ifPatUnivBndrs = [IfaceForAllSpecBndr]
    univ_bndrs
                                 , ifPatExBndrs :: IfaceDecl -> [IfaceForAllSpecBndr]
    ifPatExBndrs = [IfaceForAllSpecBndr]
    ex_bndrs
                                 , ifPatProvCtxt :: IfaceDecl -> IfaceContext
    ifPatProvCtxt = IfaceContext
    prov_ctxt
                                 , ifPatReqCtxt :: IfaceDecl -> IfaceContext
    ifPatReqCtxt = IfaceContext
    req_ctxt
                                 , ifPatArgs :: IfaceDecl -> IfaceContext
    ifPatArgs = IfaceContext
    args
                                 , ifPatTy :: IfaceDecl -> IfaceType
    ifPatTy = IfaceType
    pat_ty
                                 , ifFieldLabels :: IfaceDecl -> [FieldLabel]
    ifFieldLabels = [FieldLabel]
    lbls })
      = IfExtName -> NameSet
    unitNameSet IfExtName
    matcher NameSet -> NameSet -> NameSet
    &&&
        NameSet
    -> ((IfExtName, Bool) -> NameSet)
    -> Maybe (IfExtName, Bool)
    -> NameSet
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe NameSet
    emptyNameSet (IfExtName -> NameSet
    unitNameSet (IfExtName -> NameSet)
    -> ((IfExtName, Bool) -> IfExtName) -> (IfExtName, Bool) -> NameSet
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (IfExtName, Bool) -> IfExtName
    forall a b. (a, b) -> a
    fst) Maybe (IfExtName, Bool)
    mb_builder NameSet -> NameSet -> NameSet
    &&&
        [IfaceForAllSpecBndr] -> NameSet
    forall vis. [VarBndr IfaceBndr vis] -> NameSet
    freeNamesIfVarBndrs [IfaceForAllSpecBndr]
    univ_bndrs NameSet -> NameSet -> NameSet
    &&&
        [IfaceForAllSpecBndr] -> NameSet
    forall vis. [VarBndr IfaceBndr vis] -> NameSet
    freeNamesIfVarBndrs [IfaceForAllSpecBndr]
    ex_bndrs NameSet -> NameSet -> NameSet
    &&&
        IfaceContext -> NameSet
    freeNamesIfContext IfaceContext
    prov_ctxt NameSet -> NameSet -> NameSet
    &&&
        IfaceContext -> NameSet
    freeNamesIfContext IfaceContext
    req_ctxt NameSet -> NameSet -> NameSet
    &&&
        (IfaceType -> NameSet) -> IfaceContext -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList IfaceType -> NameSet
    freeNamesIfType IfaceContext
    args NameSet -> NameSet -> NameSet
    &&&
        IfaceType -> NameSet
    freeNamesIfType IfaceType
    pat_ty NameSet -> NameSet -> NameSet
    &&&
        [IfExtName] -> NameSet
    mkNameSet ((FieldLabel -> IfExtName) -> [FieldLabel] -> [IfExtName]
    forall a b. (a -> b) -> [a] -> [b]
    map FieldLabel -> IfExtName
    flSelector [FieldLabel]
    lbls)

    freeNamesIfClassBody :: IfaceClassBody -> NameSet
    freeNamesIfClassBody :: IfaceClassBody -> NameSet
    freeNamesIfClassBody IfaceClassBody
    IfAbstractClass
      = NameSet
    emptyNameSet
    freeNamesIfClassBody (IfConcreteClass{ ifClassCtxt :: IfaceClassBody -> IfaceContext
    ifClassCtxt = IfaceContext
    ctxt, ifATs :: IfaceClassBody -> [IfaceAT]
    ifATs = [IfaceAT]
    ats, ifSigs :: IfaceClassBody -> [IfaceClassOp]
    ifSigs = [IfaceClassOp]
    sigs })
      = IfaceContext -> NameSet
    freeNamesIfContext IfaceContext
    ctxt  NameSet -> NameSet -> NameSet
    &&&
        (IfaceAT -> NameSet) -> [IfaceAT] -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList IfaceAT -> NameSet
    freeNamesIfAT [IfaceAT]
    ats NameSet -> NameSet -> NameSet
    &&&
        (IfaceClassOp -> NameSet) -> [IfaceClassOp] -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList IfaceClassOp -> NameSet
    freeNamesIfClsSig [IfaceClassOp]
    sigs

    freeNamesIfAxBranch :: IfaceAxBranch -> NameSet
    freeNamesIfAxBranch :: IfaceAxBranch -> NameSet
    freeNamesIfAxBranch (IfaceAxBranch { ifaxbTyVars :: IfaceAxBranch -> [IfaceTvBndr]
    ifaxbTyVars   = [IfaceTvBndr]
    tyvars
                                       , ifaxbCoVars :: IfaceAxBranch -> [IfaceIdBndr]
    ifaxbCoVars   = [IfaceIdBndr]
    covars
                                       , ifaxbLHS :: IfaceAxBranch -> IfaceAppArgs
    ifaxbLHS      = IfaceAppArgs
    lhs
                                       , ifaxbRHS :: IfaceAxBranch -> IfaceType
    ifaxbRHS      = IfaceType
    rhs })
      = (IfaceTvBndr -> NameSet) -> [IfaceTvBndr] -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList IfaceTvBndr -> NameSet
    freeNamesIfTvBndr [IfaceTvBndr]
    tyvars NameSet -> NameSet -> NameSet
    &&&
        (IfaceIdBndr -> NameSet) -> [IfaceIdBndr] -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList IfaceIdBndr -> NameSet
    freeNamesIfIdBndr [IfaceIdBndr]
    covars NameSet -> NameSet -> NameSet
    &&&
        IfaceAppArgs -> NameSet
    freeNamesIfAppArgs IfaceAppArgs
    lhs NameSet -> NameSet -> NameSet
    &&&
        IfaceType -> NameSet
    freeNamesIfType IfaceType
    rhs

    freeNamesIfIdDetails :: IfaceIdDetails -> NameSet
    freeNamesIfIdDetails :: IfaceIdDetails -> NameSet
    freeNamesIfIdDetails (IfRecSelId Either IfaceTyCon IfaceDecl
    tc Bool
    _) =
      (IfaceTyCon -> NameSet)
    -> (IfaceDecl -> NameSet) -> Either IfaceTyCon IfaceDecl -> NameSet
    forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
    either IfaceTyCon -> NameSet
    freeNamesIfTc IfaceDecl -> NameSet
    freeNamesIfDecl Either IfaceTyCon IfaceDecl
    tc
    freeNamesIfIdDetails IfaceIdDetails
    _                 = NameSet
    emptyNameSet

    -- All other changes are handled via the version info on the tycon
    freeNamesIfFamFlav :: IfaceFamTyConFlav -> NameSet
    freeNamesIfFamFlav :: IfaceFamTyConFlav -> NameSet
    freeNamesIfFamFlav IfaceFamTyConFlav
    IfaceOpenSynFamilyTyCon             = NameSet
    emptyNameSet
    freeNamesIfFamFlav IfaceFamTyConFlav
    IfaceDataFamilyTyCon                = NameSet
    emptyNameSet
    freeNamesIfFamFlav (IfaceClosedSynFamilyTyCon (Just (IfExtName
    ax, [IfaceAxBranch]
    br)))
      = IfExtName -> NameSet
    unitNameSet IfExtName
    ax NameSet -> NameSet -> NameSet
    &&& (IfaceAxBranch -> NameSet) -> [IfaceAxBranch] -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList IfaceAxBranch -> NameSet
    freeNamesIfAxBranch [IfaceAxBranch]
    br
    freeNamesIfFamFlav (IfaceClosedSynFamilyTyCon Maybe (IfExtName, [IfaceAxBranch])
    Nothing) = NameSet
    emptyNameSet
    freeNamesIfFamFlav IfaceFamTyConFlav
    IfaceAbstractClosedSynFamilyTyCon   = NameSet
    emptyNameSet
    freeNamesIfFamFlav IfaceFamTyConFlav
    IfaceBuiltInSynFamTyCon             = NameSet
    emptyNameSet

    freeNamesIfContext :: IfaceContext -> NameSet
    freeNamesIfContext :: IfaceContext -> NameSet
    freeNamesIfContext = (IfaceType -> NameSet) -> IfaceContext -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList IfaceType -> NameSet
    freeNamesIfType

    freeNamesIfAT :: IfaceAT -> NameSet
    freeNamesIfAT :: IfaceAT -> NameSet
    freeNamesIfAT (IfaceAT IfaceDecl
    decl Maybe IfaceType
    mb_def)
      = IfaceDecl -> NameSet
    freeNamesIfDecl IfaceDecl
    decl NameSet -> NameSet -> NameSet
    &&&
        case Maybe IfaceType
    mb_def of
          Maybe IfaceType
    Nothing  -> NameSet
    emptyNameSet
          Just IfaceType
    rhs -> IfaceType -> NameSet
    freeNamesIfType IfaceType
    rhs

    freeNamesIfClsSig :: IfaceClassOp -> NameSet
    freeNamesIfClsSig :: IfaceClassOp -> NameSet
    freeNamesIfClsSig (IfaceClassOp IfExtName
    _n IfaceType
    ty Maybe (DefMethSpec IfaceType)
    dm) = IfaceType -> NameSet
    freeNamesIfType IfaceType
    ty NameSet -> NameSet -> NameSet
    &&& Maybe (DefMethSpec IfaceType) -> NameSet
    freeNamesDM Maybe (DefMethSpec IfaceType)
    dm

    freeNamesDM :: Maybe (DefMethSpec IfaceType) -> NameSet
    freeNamesDM :: Maybe (DefMethSpec IfaceType) -> NameSet
    freeNamesDM (Just (GenericDM IfaceType
    ty)) = IfaceType -> NameSet
    freeNamesIfType IfaceType
    ty
    freeNamesDM Maybe (DefMethSpec IfaceType)
    _                     = NameSet
    emptyNameSet

    freeNamesIfConDecls :: IfaceConDecls -> NameSet
    freeNamesIfConDecls :: IfaceConDecls -> NameSet
    freeNamesIfConDecls (IfDataTyCon [IfaceConDecl]
    c) = (IfaceConDecl -> NameSet) -> [IfaceConDecl] -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList IfaceConDecl -> NameSet
    freeNamesIfConDecl [IfaceConDecl]
    c
    freeNamesIfConDecls (IfNewTyCon  IfaceConDecl
    c) = IfaceConDecl -> NameSet
    freeNamesIfConDecl IfaceConDecl
    c
    freeNamesIfConDecls IfaceConDecls
    _                   = NameSet
    emptyNameSet

    freeNamesIfConDecl :: IfaceConDecl -> NameSet
    freeNamesIfConDecl :: IfaceConDecl -> NameSet
    freeNamesIfConDecl (IfCon { ifConExTCvs :: IfaceConDecl -> [IfaceBndr]
    ifConExTCvs  = [IfaceBndr]
    ex_tvs, ifConCtxt :: IfaceConDecl -> IfaceContext
    ifConCtxt = IfaceContext
    ctxt
                              , ifConArgTys :: IfaceConDecl -> [(IfaceType, IfaceType)]
    ifConArgTys  = [(IfaceType, IfaceType)]
    arg_tys
                              , ifConFields :: IfaceConDecl -> [FieldLabel]
    ifConFields  = [FieldLabel]
    flds
                              , ifConEqSpec :: IfaceConDecl -> [IfaceTvBndr]
    ifConEqSpec  = [IfaceTvBndr]
    eq_spec
                              , ifConStricts :: IfaceConDecl -> [IfaceBang]
    ifConStricts = [IfaceBang]
    bangs })
      = (IfaceBndr -> NameSet) -> [IfaceBndr] -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList IfaceBndr -> NameSet
    freeNamesIfBndr [IfaceBndr]
    ex_tvs NameSet -> NameSet -> NameSet
    &&&
        IfaceContext -> NameSet
    freeNamesIfContext IfaceContext
    ctxt NameSet -> NameSet -> NameSet
    &&&
        (IfaceType -> NameSet) -> IfaceContext -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList IfaceType -> NameSet
    freeNamesIfType (((IfaceType, IfaceType) -> IfaceType)
    -> [(IfaceType, IfaceType)] -> IfaceContext
    forall a b. (a -> b) -> [a] -> [b]
    map (IfaceType, IfaceType) -> IfaceType
    forall a b. (a, b) -> a
    fst [(IfaceType, IfaceType)]
    arg_tys) NameSet -> NameSet -> NameSet
    &&& -- these are multiplicities, represented as types
        (IfaceType -> NameSet) -> IfaceContext -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList IfaceType -> NameSet
    freeNamesIfType (((IfaceType, IfaceType) -> IfaceType)
    -> [(IfaceType, IfaceType)] -> IfaceContext
    forall a b. (a -> b) -> [a] -> [b]
    map (IfaceType, IfaceType) -> IfaceType
    forall a b. (a, b) -> b
    snd [(IfaceType, IfaceType)]
    arg_tys) NameSet -> NameSet -> NameSet
    &&&
        [IfExtName] -> NameSet
    mkNameSet ((FieldLabel -> IfExtName) -> [FieldLabel] -> [IfExtName]
    forall a b. (a -> b) -> [a] -> [b]
    map FieldLabel -> IfExtName
    flSelector [FieldLabel]
    flds) NameSet -> NameSet -> NameSet
    &&&
        (IfaceType -> NameSet) -> IfaceContext -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList IfaceType -> NameSet
    freeNamesIfType ((IfaceTvBndr -> IfaceType) -> [IfaceTvBndr] -> IfaceContext
    forall a b. (a -> b) -> [a] -> [b]
    map IfaceTvBndr -> IfaceType
    forall a b. (a, b) -> b
    snd [IfaceTvBndr]
    eq_spec) NameSet -> NameSet -> NameSet
    &&& -- equality constraints
        (IfaceBang -> NameSet) -> [IfaceBang] -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList IfaceBang -> NameSet
    freeNamesIfBang [IfaceBang]
    bangs

    freeNamesIfBang :: IfaceBang -> NameSet
    freeNamesIfBang :: IfaceBang -> NameSet
    freeNamesIfBang (IfUnpackCo IfaceCoercion
    co) = IfaceCoercion -> NameSet
    freeNamesIfCoercion IfaceCoercion
    co
    freeNamesIfBang IfaceBang
    _               = NameSet
    emptyNameSet

    freeNamesIfKind :: IfaceType -> NameSet
    freeNamesIfKind :: IfaceType -> NameSet
    freeNamesIfKind = IfaceType -> NameSet
    freeNamesIfType

    freeNamesIfAppArgs :: IfaceAppArgs -> NameSet
    freeNamesIfAppArgs :: IfaceAppArgs -> NameSet
    freeNamesIfAppArgs (IA_Arg IfaceType
    t ArgFlag
    _ IfaceAppArgs
    ts) = IfaceType -> NameSet
    freeNamesIfType IfaceType
    t NameSet -> NameSet -> NameSet
    &&& IfaceAppArgs -> NameSet
    freeNamesIfAppArgs IfaceAppArgs
    ts
    freeNamesIfAppArgs IfaceAppArgs
    IA_Nil          = NameSet
    emptyNameSet

    freeNamesIfType :: IfaceType -> NameSet
    freeNamesIfType :: IfaceType -> NameSet
    freeNamesIfType (IfaceFreeTyVar TyVar
    _)    = NameSet
    emptyNameSet
    freeNamesIfType (IfaceTyVar IfLclName
    _)        = NameSet
    emptyNameSet
    freeNamesIfType (IfaceAppTy IfaceType
    s IfaceAppArgs
    t)      = IfaceType -> NameSet
    freeNamesIfType IfaceType
    s NameSet -> NameSet -> NameSet
    &&& IfaceAppArgs -> NameSet
    freeNamesIfAppArgs IfaceAppArgs
    t
    freeNamesIfType (IfaceTyConApp IfaceTyCon
    tc IfaceAppArgs
    ts) = IfaceTyCon -> NameSet
    freeNamesIfTc IfaceTyCon
    tc NameSet -> NameSet -> NameSet
    &&& IfaceAppArgs -> NameSet
    freeNamesIfAppArgs IfaceAppArgs
    ts
    freeNamesIfType (IfaceTupleTy TupleSort
    _ PromotionFlag
    _ IfaceAppArgs
    ts) = IfaceAppArgs -> NameSet
    freeNamesIfAppArgs IfaceAppArgs
    ts
    freeNamesIfType (IfaceLitTy IfaceTyLit
    _)        = NameSet
    emptyNameSet
    freeNamesIfType (IfaceForAllTy IfaceForAllBndr
    tv IfaceType
    t)  = IfaceForAllBndr -> NameSet
    forall vis. VarBndr IfaceBndr vis -> NameSet
    freeNamesIfVarBndr IfaceForAllBndr
    tv NameSet -> NameSet -> NameSet
    &&& IfaceType -> NameSet
    freeNamesIfType IfaceType
    t
    freeNamesIfType (IfaceFunTy AnonArgFlag
    _ IfaceType
    w IfaceType
    s IfaceType
    t)  = IfaceType -> NameSet
    freeNamesIfType IfaceType
    s NameSet -> NameSet -> NameSet
    &&& IfaceType -> NameSet
    freeNamesIfType IfaceType
    t NameSet -> NameSet -> NameSet
    &&& IfaceType -> NameSet
    freeNamesIfType IfaceType
    w
    freeNamesIfType (IfaceCastTy IfaceType
    t IfaceCoercion
    c)     = IfaceType -> NameSet
    freeNamesIfType IfaceType
    t NameSet -> NameSet -> NameSet
    &&& IfaceCoercion -> NameSet
    freeNamesIfCoercion IfaceCoercion
    c
    freeNamesIfType (IfaceCoercionTy IfaceCoercion
    c)   = IfaceCoercion -> NameSet
    freeNamesIfCoercion IfaceCoercion
    c

    freeNamesIfMCoercion :: IfaceMCoercion -> NameSet
    freeNamesIfMCoercion :: IfaceMCoercion -> NameSet
    freeNamesIfMCoercion IfaceMCoercion
    IfaceMRefl    = NameSet
    emptyNameSet
    freeNamesIfMCoercion (IfaceMCo IfaceCoercion
    co) = IfaceCoercion -> NameSet
    freeNamesIfCoercion IfaceCoercion
    co

    freeNamesIfCoercion :: IfaceCoercion -> NameSet
    freeNamesIfCoercion :: IfaceCoercion -> NameSet
    freeNamesIfCoercion (IfaceReflCo IfaceType
    t) = IfaceType -> NameSet
    freeNamesIfType IfaceType
    t
    freeNamesIfCoercion (IfaceGReflCo Role
    _ IfaceType
    t IfaceMCoercion
    mco)
      = IfaceType -> NameSet
    freeNamesIfType IfaceType
    t NameSet -> NameSet -> NameSet
    &&& IfaceMCoercion -> NameSet
    freeNamesIfMCoercion IfaceMCoercion
    mco
    freeNamesIfCoercion (IfaceFunCo Role
    _ IfaceCoercion
    c_mult IfaceCoercion
    c1 IfaceCoercion
    c2)
      = IfaceCoercion -> NameSet
    freeNamesIfCoercion IfaceCoercion
    c_mult NameSet -> NameSet -> NameSet
    &&& IfaceCoercion -> NameSet
    freeNamesIfCoercion IfaceCoercion
    c1 NameSet -> NameSet -> NameSet
    &&& IfaceCoercion -> NameSet
    freeNamesIfCoercion IfaceCoercion
    c2
    freeNamesIfCoercion (IfaceTyConAppCo Role
    _ IfaceTyCon
    tc [IfaceCoercion]
    cos)
      = IfaceTyCon -> NameSet
    freeNamesIfTc IfaceTyCon
    tc NameSet -> NameSet -> NameSet
    &&& (IfaceCoercion -> NameSet) -> [IfaceCoercion] -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList IfaceCoercion -> NameSet
    freeNamesIfCoercion [IfaceCoercion]
    cos
    freeNamesIfCoercion (IfaceAppCo IfaceCoercion
    c1 IfaceCoercion
    c2)
      = IfaceCoercion -> NameSet
    freeNamesIfCoercion IfaceCoercion
    c1 NameSet -> NameSet -> NameSet
    &&& IfaceCoercion -> NameSet
    freeNamesIfCoercion IfaceCoercion
    c2
    freeNamesIfCoercion (IfaceForAllCo IfaceBndr
    _ IfaceCoercion
    kind_co IfaceCoercion
    co)
      = IfaceCoercion -> NameSet
    freeNamesIfCoercion IfaceCoercion
    kind_co NameSet -> NameSet -> NameSet
    &&& IfaceCoercion -> NameSet
    freeNamesIfCoercion IfaceCoercion
    co
    freeNamesIfCoercion (IfaceFreeCoVar TyVar
    _) = NameSet
    emptyNameSet
    freeNamesIfCoercion (IfaceCoVarCo IfLclName
    _)   = NameSet
    emptyNameSet
    freeNamesIfCoercion (IfaceHoleCo TyVar
    _)    = NameSet
    emptyNameSet
    freeNamesIfCoercion (IfaceAxiomInstCo IfExtName
    ax Int
    _ [IfaceCoercion]
    cos)
      = IfExtName -> NameSet
    unitNameSet IfExtName
    ax NameSet -> NameSet -> NameSet
    &&& (IfaceCoercion -> NameSet) -> [IfaceCoercion] -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList IfaceCoercion -> NameSet
    freeNamesIfCoercion [IfaceCoercion]
    cos
    freeNamesIfCoercion (IfaceUnivCo IfaceUnivCoProv
    p Role
    _ IfaceType
    t1 IfaceType
    t2)
      = IfaceUnivCoProv -> NameSet
    freeNamesIfProv IfaceUnivCoProv
    p NameSet -> NameSet -> NameSet
    &&& IfaceType -> NameSet
    freeNamesIfType IfaceType
    t1 NameSet -> NameSet -> NameSet
    &&& IfaceType -> NameSet
    freeNamesIfType IfaceType
    t2
    freeNamesIfCoercion (IfaceSymCo IfaceCoercion
    c)
      = IfaceCoercion -> NameSet
    freeNamesIfCoercion IfaceCoercion
    c
    freeNamesIfCoercion (IfaceTransCo IfaceCoercion
    c1 IfaceCoercion
    c2)
      = IfaceCoercion -> NameSet
    freeNamesIfCoercion IfaceCoercion
    c1 NameSet -> NameSet -> NameSet
    &&& IfaceCoercion -> NameSet
    freeNamesIfCoercion IfaceCoercion
    c2
    freeNamesIfCoercion (IfaceNthCo Int
    _ IfaceCoercion
    co)
      = IfaceCoercion -> NameSet
    freeNamesIfCoercion IfaceCoercion
    co
    freeNamesIfCoercion (IfaceLRCo LeftOrRight
    _ IfaceCoercion
    co)
      = IfaceCoercion -> NameSet
    freeNamesIfCoercion IfaceCoercion
    co
    freeNamesIfCoercion (IfaceInstCo IfaceCoercion
    co IfaceCoercion
    co2)
      = IfaceCoercion -> NameSet
    freeNamesIfCoercion IfaceCoercion
    co NameSet -> NameSet -> NameSet
    &&& IfaceCoercion -> NameSet
    freeNamesIfCoercion IfaceCoercion
    co2
    freeNamesIfCoercion (IfaceKindCo IfaceCoercion
    c)
      = IfaceCoercion -> NameSet
    freeNamesIfCoercion IfaceCoercion
    c
    freeNamesIfCoercion (IfaceSubCo IfaceCoercion
    co)
      = IfaceCoercion -> NameSet
    freeNamesIfCoercion IfaceCoercion
    co
    freeNamesIfCoercion (IfaceAxiomRuleCo IfLclName
    _ax [IfaceCoercion]
    cos)
      -- the axiom is just a string, so we don't count it as a name.
      = (IfaceCoercion -> NameSet) -> [IfaceCoercion] -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList IfaceCoercion -> NameSet
    freeNamesIfCoercion [IfaceCoercion]
    cos

    freeNamesIfProv :: IfaceUnivCoProv -> NameSet
    freeNamesIfProv :: IfaceUnivCoProv -> NameSet
    freeNamesIfProv (IfacePhantomProv IfaceCoercion
    co)    = IfaceCoercion -> NameSet
    freeNamesIfCoercion IfaceCoercion
    co
    freeNamesIfProv (IfaceProofIrrelProv IfaceCoercion
    co) = IfaceCoercion -> NameSet
    freeNamesIfCoercion IfaceCoercion
    co
    freeNamesIfProv (IfacePluginProv String
    _)      = NameSet
    emptyNameSet

    freeNamesIfVarBndr :: VarBndr IfaceBndr vis -> NameSet
    freeNamesIfVarBndr :: forall vis. VarBndr IfaceBndr vis -> NameSet
    freeNamesIfVarBndr (Bndr IfaceBndr
    bndr vis
    _) = IfaceBndr -> NameSet
    freeNamesIfBndr IfaceBndr
    bndr

    freeNamesIfVarBndrs :: [VarBndr IfaceBndr vis] -> NameSet
    freeNamesIfVarBndrs :: forall vis. [VarBndr IfaceBndr vis] -> NameSet
    freeNamesIfVarBndrs = (VarBndr IfaceBndr vis -> NameSet)
    -> [VarBndr IfaceBndr vis] -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList VarBndr IfaceBndr vis -> NameSet
    forall vis. VarBndr IfaceBndr vis -> NameSet
    freeNamesIfVarBndr

    freeNamesIfBndr :: IfaceBndr -> NameSet
    freeNamesIfBndr :: IfaceBndr -> NameSet
    freeNamesIfBndr (IfaceIdBndr IfaceIdBndr
    b) = IfaceIdBndr -> NameSet
    freeNamesIfIdBndr IfaceIdBndr
    b
    freeNamesIfBndr (IfaceTvBndr IfaceTvBndr
    b) = IfaceTvBndr -> NameSet
    freeNamesIfTvBndr IfaceTvBndr
    b

    freeNamesIfBndrs :: [IfaceBndr] -> NameSet
    freeNamesIfBndrs :: [IfaceBndr] -> NameSet
    freeNamesIfBndrs = (IfaceBndr -> NameSet) -> [IfaceBndr] -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList IfaceBndr -> NameSet
    freeNamesIfBndr

    freeNamesIfLetBndr :: IfaceLetBndr -> NameSet
    -- Remember IfaceLetBndr is used only for *nested* bindings
    -- The IdInfo can contain an unfolding (in the case of
    -- local INLINE pragmas), so look there too
    freeNamesIfLetBndr :: IfaceLetBndr -> NameSet
    freeNamesIfLetBndr (IfLetBndr IfLclName
    _name IfaceType
    ty IfaceIdInfo
    info IfaceJoinInfo
    _ji) = IfaceType -> NameSet
    freeNamesIfType IfaceType
    ty
                                                     NameSet -> NameSet -> NameSet
    &&& IfaceIdInfo -> NameSet
    freeNamesIfIdInfo IfaceIdInfo
    info

    freeNamesIfTvBndr :: IfaceTvBndr -> NameSet
    freeNamesIfTvBndr :: IfaceTvBndr -> NameSet
    freeNamesIfTvBndr (IfLclName
    _fs,IfaceType
    k) = IfaceType -> NameSet
    freeNamesIfKind IfaceType
    k
        -- kinds can have Names inside, because of promotion

    freeNamesIfIdBndr :: IfaceIdBndr -> NameSet
    freeNamesIfIdBndr :: IfaceIdBndr -> NameSet
    freeNamesIfIdBndr (IfaceType
    _, IfLclName
    _fs,IfaceType
    k) = IfaceType -> NameSet
    freeNamesIfKind IfaceType
    k

    freeNamesIfIdInfo :: IfaceIdInfo -> NameSet
    freeNamesIfIdInfo :: IfaceIdInfo -> NameSet
    freeNamesIfIdInfo = (IfaceInfoItem -> NameSet) -> IfaceIdInfo -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList IfaceInfoItem -> NameSet
    freeNamesItem

    freeNamesItem :: IfaceInfoItem -> NameSet
    freeNamesItem :: IfaceInfoItem -> NameSet
    freeNamesItem (HsUnfold Bool
    _ IfaceUnfolding
    u)         = IfaceUnfolding -> NameSet
    freeNamesIfUnfold IfaceUnfolding
    u
    freeNamesItem (HsLFInfo (IfLFCon IfExtName
    n)) = IfExtName -> NameSet
    unitNameSet IfExtName
    n
    freeNamesItem IfaceInfoItem
    _                      = NameSet
    emptyNameSet

    freeNamesIfUnfold :: IfaceUnfolding -> NameSet
    freeNamesIfUnfold :: IfaceUnfolding -> NameSet
    freeNamesIfUnfold (IfCoreUnfold Bool
    _ IfaceExpr
    e)     = IfaceExpr -> NameSet
    freeNamesIfExpr IfaceExpr
    e
    freeNamesIfUnfold (IfCompulsory IfaceExpr
    e)       = IfaceExpr -> NameSet
    freeNamesIfExpr IfaceExpr
    e
    freeNamesIfUnfold (IfInlineRule Int
    _ Bool
    _ Bool
    _ IfaceExpr
    e) = IfaceExpr -> NameSet
    freeNamesIfExpr IfaceExpr
    e
    freeNamesIfUnfold (IfDFunUnfold [IfaceBndr]
    bs [IfaceExpr]
    es)   = [IfaceBndr] -> NameSet
    freeNamesIfBndrs [IfaceBndr]
    bs NameSet -> NameSet -> NameSet
    &&& (IfaceExpr -> NameSet) -> [IfaceExpr] -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList IfaceExpr -> NameSet
    freeNamesIfExpr [IfaceExpr]
    es

    freeNamesIfExpr :: IfaceExpr -> NameSet
    freeNamesIfExpr :: IfaceExpr -> NameSet
    freeNamesIfExpr (IfaceExt IfExtName
    v)          = IfExtName -> NameSet
    unitNameSet IfExtName
    v
    freeNamesIfExpr (IfaceFCall ForeignCall
    _ IfaceType
    ty)     = IfaceType -> NameSet
    freeNamesIfType IfaceType
    ty
    freeNamesIfExpr (IfaceType IfaceType
    ty)        = IfaceType -> NameSet
    freeNamesIfType IfaceType
    ty
    freeNamesIfExpr (IfaceCo IfaceCoercion
    co)          = IfaceCoercion -> NameSet
    freeNamesIfCoercion IfaceCoercion
    co
    freeNamesIfExpr (IfaceTuple TupleSort
    _ [IfaceExpr]
    as)     = (IfaceExpr -> NameSet) -> [IfaceExpr] -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList IfaceExpr -> NameSet
    freeNamesIfExpr [IfaceExpr]
    as
    freeNamesIfExpr (IfaceLam (IfaceBndr
    b,IfaceOneShot
    _) IfaceExpr
    body) = IfaceBndr -> NameSet
    freeNamesIfBndr IfaceBndr
    b NameSet -> NameSet -> NameSet
    &&& IfaceExpr -> NameSet
    freeNamesIfExpr IfaceExpr
    body
    freeNamesIfExpr (IfaceApp IfaceExpr
    f IfaceExpr
    a)        = IfaceExpr -> NameSet
    freeNamesIfExpr IfaceExpr
    f NameSet -> NameSet -> NameSet
    &&& IfaceExpr -> NameSet
    freeNamesIfExpr IfaceExpr
    a
    freeNamesIfExpr (IfaceCast IfaceExpr
    e IfaceCoercion
    co)      = IfaceExpr -> NameSet
    freeNamesIfExpr IfaceExpr
    e NameSet -> NameSet -> NameSet
    &&& IfaceCoercion -> NameSet
    freeNamesIfCoercion IfaceCoercion
    co
    freeNamesIfExpr (IfaceTick IfaceTickish
    _ IfaceExpr
    e)       = IfaceExpr -> NameSet
    freeNamesIfExpr IfaceExpr
    e
    freeNamesIfExpr (IfaceECase IfaceExpr
    e IfaceType
    ty)     = IfaceExpr -> NameSet
    freeNamesIfExpr IfaceExpr
    e NameSet -> NameSet -> NameSet
    &&& IfaceType -> NameSet
    freeNamesIfType IfaceType
    ty
    freeNamesIfExpr (IfaceCase IfaceExpr
    s IfLclName
    _ [IfaceAlt]
    alts)
      = IfaceExpr -> NameSet
    freeNamesIfExpr IfaceExpr
    s NameSet -> NameSet -> NameSet
    &&& (IfaceAlt -> NameSet) -> [IfaceAlt] -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList IfaceAlt -> NameSet
    fn_alt [IfaceAlt]
    alts NameSet -> NameSet -> NameSet
    &&& [IfaceAlt] -> NameSet
    fn_cons [IfaceAlt]
    alts
      where
        fn_alt :: IfaceAlt -> NameSet
    fn_alt (IfaceAlt IfaceConAlt
    _con [IfLclName]
    _bs IfaceExpr
    r) = IfaceExpr -> NameSet
    freeNamesIfExpr IfaceExpr
    r

        -- Depend on the data constructors.  Just one will do!
        -- Note [Tracking data constructors]
        fn_cons :: [IfaceAlt] -> NameSet
    fn_cons []                                     = NameSet
    emptyNameSet
        fn_cons (IfaceAlt IfaceConAlt
    IfaceDefault [IfLclName]
    _ IfaceExpr
    _       : [IfaceAlt]
    xs) = [IfaceAlt] -> NameSet
    fn_cons [IfaceAlt]
    xs
        fn_cons (IfaceAlt (IfaceDataAlt IfExtName
    con) [IfLclName]
    _ IfaceExpr
    _ : [IfaceAlt]
    _ ) = IfExtName -> NameSet
    unitNameSet IfExtName
    con
        fn_cons (IfaceAlt
    _                               : [IfaceAlt]
    _ ) = NameSet
    emptyNameSet

    freeNamesIfExpr (IfaceLet (IfaceNonRec IfaceLetBndr
    bndr IfaceExpr
    rhs) IfaceExpr
    body)
      = IfaceLetBndr -> NameSet
    freeNamesIfLetBndr IfaceLetBndr
    bndr NameSet -> NameSet -> NameSet
    &&& IfaceExpr -> NameSet
    freeNamesIfExpr IfaceExpr
    rhs NameSet -> NameSet -> NameSet
    &&& IfaceExpr -> NameSet
    freeNamesIfExpr IfaceExpr
    body

    freeNamesIfExpr (IfaceLet (IfaceRec [(IfaceLetBndr, IfaceExpr)]
    as) IfaceExpr
    x)
      = ((IfaceLetBndr, IfaceExpr) -> NameSet)
    -> [(IfaceLetBndr, IfaceExpr)] -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList (IfaceLetBndr, IfaceExpr) -> NameSet
    fn_pair [(IfaceLetBndr, IfaceExpr)]
    as NameSet -> NameSet -> NameSet
    &&& IfaceExpr -> NameSet
    freeNamesIfExpr IfaceExpr
    x
      where
        fn_pair :: (IfaceLetBndr, IfaceExpr) -> NameSet
    fn_pair (IfaceLetBndr
    bndr, IfaceExpr
    rhs) = IfaceLetBndr -> NameSet
    freeNamesIfLetBndr IfaceLetBndr
    bndr NameSet -> NameSet -> NameSet
    &&& IfaceExpr -> NameSet
    freeNamesIfExpr IfaceExpr
    rhs

    freeNamesIfExpr IfaceExpr
    _ = NameSet
    emptyNameSet

    freeNamesIfTc :: IfaceTyCon -> NameSet
    freeNamesIfTc :: IfaceTyCon -> NameSet
    freeNamesIfTc IfaceTyCon
    tc = IfExtName -> NameSet
    unitNameSet (IfaceTyCon -> IfExtName
    ifaceTyConName IfaceTyCon
    tc)
    -- ToDo: shouldn't we include IfaceIntTc & co.?

    freeNamesIfRule :: IfaceRule -> NameSet
    freeNamesIfRule :: IfaceRule -> NameSet
    freeNamesIfRule (IfaceRule { ifRuleBndrs :: IfaceRule -> [IfaceBndr]
    ifRuleBndrs = [IfaceBndr]
    bs, ifRuleHead :: IfaceRule -> IfExtName
    ifRuleHead = IfExtName
    f
                               , ifRuleArgs :: IfaceRule -> [IfaceExpr]
    ifRuleArgs = [IfaceExpr]
    es, ifRuleRhs :: IfaceRule -> IfaceExpr
    ifRuleRhs = IfaceExpr
    rhs })
      = IfExtName -> NameSet
    unitNameSet IfExtName
    f NameSet -> NameSet -> NameSet
    &&&
        (IfaceBndr -> NameSet) -> [IfaceBndr] -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList IfaceBndr -> NameSet
    freeNamesIfBndr [IfaceBndr]
    bs NameSet -> NameSet -> NameSet
    &&&
        (IfaceExpr -> NameSet) -> [IfaceExpr] -> NameSet
    forall a. (a -> NameSet) -> [a] -> NameSet
    fnList IfaceExpr -> NameSet
    freeNamesIfExpr [IfaceExpr]
    es NameSet -> NameSet -> NameSet
    &&&
        IfaceExpr -> NameSet
    freeNamesIfExpr IfaceExpr
    rhs

    freeNamesIfFamInst :: IfaceFamInst -> NameSet
    freeNamesIfFamInst :: IfaceFamInst -> NameSet
    freeNamesIfFamInst (IfaceFamInst { ifFamInstFam :: IfaceFamInst -> IfExtName
    ifFamInstFam = IfExtName
    famName
                                     , ifFamInstAxiom :: IfaceFamInst -> IfExtName
    ifFamInstAxiom = IfExtName
    axName })
      = IfExtName -> NameSet
    unitNameSet IfExtName
    famName NameSet -> NameSet -> NameSet
    &&&
        IfExtName -> NameSet
    unitNameSet IfExtName
    axName

    freeNamesIfaceTyConParent :: IfaceTyConParent -> NameSet
    freeNamesIfaceTyConParent :: IfaceTyConParent -> NameSet
    freeNamesIfaceTyConParent IfaceTyConParent
    IfNoParent = NameSet
    emptyNameSet
    freeNamesIfaceTyConParent (IfDataInstance IfExtName
    ax IfaceTyCon
    tc IfaceAppArgs
    tys)
      = IfExtName -> NameSet
    unitNameSet IfExtName
    ax NameSet -> NameSet -> NameSet
    &&& IfaceTyCon -> NameSet
    freeNamesIfTc IfaceTyCon
    tc NameSet -> NameSet -> NameSet
    &&& IfaceAppArgs -> NameSet
    freeNamesIfAppArgs IfaceAppArgs
    tys

    -- helpers
    (&&&) :: NameSet -> NameSet -> NameSet
    &&& :: NameSet -> NameSet -> NameSet
    (&&&) = NameSet -> NameSet -> NameSet
    unionNameSet

    fnList :: (a -> NameSet) -> [a] -> NameSet
    fnList :: forall a. (a -> NameSet) -> [a] -> NameSet
    fnList a -> NameSet
    f = (NameSet -> NameSet -> NameSet) -> NameSet -> [NameSet] -> NameSet
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr NameSet -> NameSet -> NameSet
    (&&&) NameSet
    emptyNameSet ([NameSet] -> NameSet) -> ([a] -> [NameSet]) -> [a] -> NameSet
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> NameSet) -> [a] -> [NameSet]
    forall a b. (a -> b) -> [a] -> [b]
    map a -> NameSet
    f

    {-
    Note [Tracking data constructors]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    In a case expression
       case e of { C a -> ...; ... }
    You might think that we don't need to include the datacon C
    in the free names, because its type will probably show up in
    the free names of 'e'.  But in rare circumstances this may
    not happen.   Here's the one that bit me:

       module DynFlags where
         import {-# SOURCE #-} Packages( PackageState )
         data DynFlags = DF ... PackageState ...

       module Packages where
         import GHC.Driver.Session
         data PackageState = PS ...
         lookupModule (df :: DynFlags)
            = case df of
                  DF ...p... -> case p of
                                   PS ... -> ...

    Now, lookupModule depends on DynFlags, but the transitive dependency
    on the *locally-defined* type PackageState is not visible. We need
    to take account of the use of the data constructor PS in the pattern match.

    ************************************************************************
    *                                                                      *
                    Binary instances
    *                                                                      *
    ************************************************************************

    Note that there is a bit of subtlety here when we encode names. While
    IfaceTopBndrs is really just a synonym for Name, we need to take care to
    encode them with {get,put}IfaceTopBndr. The difference becomes important when
    we go to fingerprint an IfaceDecl. See Note [Fingerprinting IfaceDecls] for
    details.

    -}

    instance Binary IfaceDecl where
        put_ :: BinHandle -> IfaceDecl -> IO ()
    put_ BinHandle
    bh (IfaceId IfExtName
    name IfaceType
    ty IfaceIdDetails
    details IfaceIdInfo
    idinfo) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    0
            BinHandle -> IfExtName -> IO ()
    putIfaceTopBndr BinHandle
    bh IfExtName
    name
            BinHandle -> (IfaceType, IfaceIdDetails, IfaceIdInfo) -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    lazyPut BinHandle
    bh (IfaceType
    ty, IfaceIdDetails
    details, IfaceIdInfo
    idinfo)
            -- See Note [Lazy deserialization of IfaceId]

        put_ BinHandle
    bh (IfaceData IfExtName
    a1 [IfaceTyConBinder]
    a2 IfaceType
    a3 Maybe CType
    a4 [Role]
    a5 IfaceContext
    a6 IfaceConDecls
    a7 Bool
    a8 IfaceTyConParent
    a9) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    2
            BinHandle -> IfExtName -> IO ()
    putIfaceTopBndr BinHandle
    bh IfExtName
    a1
            BinHandle -> [IfaceTyConBinder] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfaceTyConBinder]
    a2
            BinHandle -> IfaceType -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceType
    a3
            BinHandle -> Maybe CType -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Maybe CType
    a4
            BinHandle -> [Role] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [Role]
    a5
            BinHandle -> IfaceContext -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceContext
    a6
            BinHandle -> IfaceConDecls -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceConDecls
    a7
            BinHandle -> Bool -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Bool
    a8
            BinHandle -> IfaceTyConParent -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceTyConParent
    a9

        put_ BinHandle
    bh (IfaceSynonym IfExtName
    a1 [Role]
    a2 [IfaceTyConBinder]
    a3 IfaceType
    a4 IfaceType
    a5) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    3
            BinHandle -> IfExtName -> IO ()
    putIfaceTopBndr BinHandle
    bh IfExtName
    a1
            BinHandle -> [Role] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [Role]
    a2
            BinHandle -> [IfaceTyConBinder] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfaceTyConBinder]
    a3
            BinHandle -> IfaceType -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceType
    a4
            BinHandle -> IfaceType -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceType
    a5

        put_ BinHandle
    bh (IfaceFamily IfExtName
    a1 Maybe IfLclName
    a2 [IfaceTyConBinder]
    a3 IfaceType
    a4 IfaceFamTyConFlav
    a5 Injectivity
    a6) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    4
            BinHandle -> IfExtName -> IO ()
    putIfaceTopBndr BinHandle
    bh IfExtName
    a1
            BinHandle -> Maybe IfLclName -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Maybe IfLclName
    a2
            BinHandle -> [IfaceTyConBinder] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfaceTyConBinder]
    a3
            BinHandle -> IfaceType -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceType
    a4
            BinHandle -> IfaceFamTyConFlav -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceFamTyConFlav
    a5
            BinHandle -> Injectivity -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Injectivity
    a6

        -- NB: Written in a funny way to avoid an interface change
        put_ BinHandle
    bh (IfaceClass {
                    ifName :: IfaceDecl -> IfExtName
    ifName    = IfExtName
    a2,
                    ifRoles :: IfaceDecl -> [Role]
    ifRoles   = [Role]
    a3,
                    ifBinders :: IfaceDecl -> [IfaceTyConBinder]
    ifBinders = [IfaceTyConBinder]
    a4,
                    ifFDs :: IfaceDecl -> [FunDep IfLclName]
    ifFDs     = [FunDep IfLclName]
    a5,
                    ifBody :: IfaceDecl -> IfaceClassBody
    ifBody = IfConcreteClass {
                        ifClassCtxt :: IfaceClassBody -> IfaceContext
    ifClassCtxt = IfaceContext
    a1,
                        ifATs :: IfaceClassBody -> [IfaceAT]
    ifATs  = [IfaceAT]
    a6,
                        ifSigs :: IfaceClassBody -> [IfaceClassOp]
    ifSigs = [IfaceClassOp]
    a7,
                        ifMinDef :: IfaceClassBody -> BooleanFormula IfLclName
    ifMinDef  = BooleanFormula IfLclName
    a8
                    }}) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    5
            BinHandle -> IfaceContext -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceContext
    a1
            BinHandle -> IfExtName -> IO ()
    putIfaceTopBndr BinHandle
    bh IfExtName
    a2
            BinHandle -> [Role] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [Role]
    a3
            BinHandle -> [IfaceTyConBinder] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfaceTyConBinder]
    a4
            BinHandle -> [FunDep IfLclName] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [FunDep IfLclName]
    a5
            BinHandle -> [IfaceAT] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfaceAT]
    a6
            BinHandle -> [IfaceClassOp] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfaceClassOp]
    a7
            BinHandle -> BooleanFormula IfLclName -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh BooleanFormula IfLclName
    a8

        put_ BinHandle
    bh (IfaceAxiom IfExtName
    a1 IfaceTyCon
    a2 Role
    a3 [IfaceAxBranch]
    a4) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    6
            BinHandle -> IfExtName -> IO ()
    putIfaceTopBndr BinHandle
    bh IfExtName
    a1
            BinHandle -> IfaceTyCon -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceTyCon
    a2
            BinHandle -> Role -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Role
    a3
            BinHandle -> [IfaceAxBranch] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfaceAxBranch]
    a4

        put_ BinHandle
    bh (IfacePatSyn IfExtName
    a1 Bool
    a2 (IfExtName, Bool)
    a3 Maybe (IfExtName, Bool)
    a4 [IfaceForAllSpecBndr]
    a5 [IfaceForAllSpecBndr]
    a6 IfaceContext
    a7 IfaceContext
    a8 IfaceContext
    a9 IfaceType
    a10 [FieldLabel]
    a11) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    7
            BinHandle -> IfExtName -> IO ()
    putIfaceTopBndr BinHandle
    bh IfExtName
    a1
            BinHandle -> Bool -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Bool
    a2
            BinHandle -> (IfExtName, Bool) -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh (IfExtName, Bool)
    a3
            BinHandle -> Maybe (IfExtName, Bool) -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Maybe (IfExtName, Bool)
    a4
            BinHandle -> [IfaceForAllSpecBndr] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfaceForAllSpecBndr]
    a5
            BinHandle -> [IfaceForAllSpecBndr] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfaceForAllSpecBndr]
    a6
            BinHandle -> IfaceContext -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceContext
    a7
            BinHandle -> IfaceContext -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceContext
    a8
            BinHandle -> IfaceContext -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceContext
    a9
            BinHandle -> IfaceType -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceType
    a10
            BinHandle -> [FieldLabel] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [FieldLabel]
    a11

        put_ BinHandle
    bh (IfaceClass {
                    ifName :: IfaceDecl -> IfExtName
    ifName    = IfExtName
    a1,
                    ifRoles :: IfaceDecl -> [Role]
    ifRoles   = [Role]
    a2,
                    ifBinders :: IfaceDecl -> [IfaceTyConBinder]
    ifBinders = [IfaceTyConBinder]
    a3,
                    ifFDs :: IfaceDecl -> [FunDep IfLclName]
    ifFDs     = [FunDep IfLclName]
    a4,
                    ifBody :: IfaceDecl -> IfaceClassBody
    ifBody = IfaceClassBody
    IfAbstractClass }) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    8
            BinHandle -> IfExtName -> IO ()
    putIfaceTopBndr BinHandle
    bh IfExtName
    a1
            BinHandle -> [Role] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [Role]
    a2
            BinHandle -> [IfaceTyConBinder] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfaceTyConBinder]
    a3
            BinHandle -> [FunDep IfLclName] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [FunDep IfLclName]
    a4

        get :: BinHandle -> IO IfaceDecl
    get BinHandle
    bh = do
            Word8
    h <- BinHandle -> IO Word8
    getByte BinHandle
    bh
            case Word8
    h of
                Word8
    0 -> do IfExtName
    name <- BinHandle -> IO IfExtName
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        ~(IfaceType
    ty, IfaceIdDetails
    details, IfaceIdInfo
    idinfo) <- BinHandle -> IO (IfaceType, IfaceIdDetails, IfaceIdInfo)
    forall a. Binary a => BinHandle -> IO a
    lazyGet BinHandle
    bh
                        -- See Note [Lazy deserialization of IfaceId]
                        IfaceDecl -> IO IfaceDecl
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfExtName
    -> IfaceType -> IfaceIdDetails -> IfaceIdInfo -> IfaceDecl
    IfaceId IfExtName
    name IfaceType
    ty IfaceIdDetails
    details IfaceIdInfo
    idinfo)
                Word8
    1 -> String -> IO IfaceDecl
    forall a. HasCallStack => String -> a
    error String
    "Binary.get(TyClDecl): ForeignType"
                Word8
    2 -> do IfExtName
    a1  <- BinHandle -> IO IfExtName
    getIfaceTopBndr BinHandle
    bh
                        [IfaceTyConBinder]
    a2  <- BinHandle -> IO [IfaceTyConBinder]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceType
    a3  <- BinHandle -> IO IfaceType
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        Maybe CType
    a4  <- BinHandle -> IO (Maybe CType)
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        [Role]
    a5  <- BinHandle -> IO [Role]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceContext
    a6  <- BinHandle -> IO IfaceContext
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceConDecls
    a7  <- BinHandle -> IO IfaceConDecls
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        Bool
    a8  <- BinHandle -> IO Bool
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceTyConParent
    a9  <- BinHandle -> IO IfaceTyConParent
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceDecl -> IO IfaceDecl
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfExtName
    -> [IfaceTyConBinder]
    -> IfaceType
    -> Maybe CType
    -> [Role]
    -> IfaceContext
    -> IfaceConDecls
    -> Bool
    -> IfaceTyConParent
    -> IfaceDecl
    IfaceData IfExtName
    a1 [IfaceTyConBinder]
    a2 IfaceType
    a3 Maybe CType
    a4 [Role]
    a5 IfaceContext
    a6 IfaceConDecls
    a7 Bool
    a8 IfaceTyConParent
    a9)
                Word8
    3 -> do IfExtName
    a1 <- BinHandle -> IO IfExtName
    getIfaceTopBndr BinHandle
    bh
                        [Role]
    a2 <- BinHandle -> IO [Role]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        [IfaceTyConBinder]
    a3 <- BinHandle -> IO [IfaceTyConBinder]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceType
    a4 <- BinHandle -> IO IfaceType
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceType
    a5 <- BinHandle -> IO IfaceType
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceDecl -> IO IfaceDecl
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfExtName
    -> [Role]
    -> [IfaceTyConBinder]
    -> IfaceType
    -> IfaceType
    -> IfaceDecl
    IfaceSynonym IfExtName
    a1 [Role]
    a2 [IfaceTyConBinder]
    a3 IfaceType
    a4 IfaceType
    a5)
                Word8
    4 -> do IfExtName
    a1 <- BinHandle -> IO IfExtName
    getIfaceTopBndr BinHandle
    bh
                        Maybe IfLclName
    a2 <- BinHandle -> IO (Maybe IfLclName)
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        [IfaceTyConBinder]
    a3 <- BinHandle -> IO [IfaceTyConBinder]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceType
    a4 <- BinHandle -> IO IfaceType
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceFamTyConFlav
    a5 <- BinHandle -> IO IfaceFamTyConFlav
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        Injectivity
    a6 <- BinHandle -> IO Injectivity
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceDecl -> IO IfaceDecl
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfExtName
    -> Maybe IfLclName
    -> [IfaceTyConBinder]
    -> IfaceType
    -> IfaceFamTyConFlav
    -> Injectivity
    -> IfaceDecl
    IfaceFamily IfExtName
    a1 Maybe IfLclName
    a2 [IfaceTyConBinder]
    a3 IfaceType
    a4 IfaceFamTyConFlav
    a5 Injectivity
    a6)
                Word8
    5 -> do IfaceContext
    a1 <- BinHandle -> IO IfaceContext
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfExtName
    a2 <- BinHandle -> IO IfExtName
    getIfaceTopBndr BinHandle
    bh
                        [Role]
    a3 <- BinHandle -> IO [Role]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        [IfaceTyConBinder]
    a4 <- BinHandle -> IO [IfaceTyConBinder]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        [FunDep IfLclName]
    a5 <- BinHandle -> IO [FunDep IfLclName]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        [IfaceAT]
    a6 <- BinHandle -> IO [IfaceAT]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        [IfaceClassOp]
    a7 <- BinHandle -> IO [IfaceClassOp]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        BooleanFormula IfLclName
    a8 <- BinHandle -> IO (BooleanFormula IfLclName)
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceDecl -> IO IfaceDecl
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfaceClass {
                            ifName :: IfExtName
    ifName    = IfExtName
    a2,
                            ifRoles :: [Role]
    ifRoles   = [Role]
    a3,
                            ifBinders :: [IfaceTyConBinder]
    ifBinders = [IfaceTyConBinder]
    a4,
                            ifFDs :: [FunDep IfLclName]
    ifFDs     = [FunDep IfLclName]
    a5,
                            ifBody :: IfaceClassBody
    ifBody = IfConcreteClass {
                                ifClassCtxt :: IfaceContext
    ifClassCtxt = IfaceContext
    a1,
                                ifATs :: [IfaceAT]
    ifATs  = [IfaceAT]
    a6,
                                ifSigs :: [IfaceClassOp]
    ifSigs = [IfaceClassOp]
    a7,
                                ifMinDef :: BooleanFormula IfLclName
    ifMinDef  = BooleanFormula IfLclName
    a8
                            }})
                Word8
    6 -> do IfExtName
    a1 <- BinHandle -> IO IfExtName
    getIfaceTopBndr BinHandle
    bh
                        IfaceTyCon
    a2 <- BinHandle -> IO IfaceTyCon
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        Role
    a3 <- BinHandle -> IO Role
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        [IfaceAxBranch]
    a4 <- BinHandle -> IO [IfaceAxBranch]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceDecl -> IO IfaceDecl
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfExtName -> IfaceTyCon -> Role -> [IfaceAxBranch] -> IfaceDecl
    IfaceAxiom IfExtName
    a1 IfaceTyCon
    a2 Role
    a3 [IfaceAxBranch]
    a4)
                Word8
    7 -> do IfExtName
    a1 <- BinHandle -> IO IfExtName
    getIfaceTopBndr BinHandle
    bh
                        Bool
    a2 <- BinHandle -> IO Bool
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        (IfExtName, Bool)
    a3 <- BinHandle -> IO (IfExtName, Bool)
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        Maybe (IfExtName, Bool)
    a4 <- BinHandle -> IO (Maybe (IfExtName, Bool))
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        [IfaceForAllSpecBndr]
    a5 <- BinHandle -> IO [IfaceForAllSpecBndr]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        [IfaceForAllSpecBndr]
    a6 <- BinHandle -> IO [IfaceForAllSpecBndr]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceContext
    a7 <- BinHandle -> IO IfaceContext
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceContext
    a8 <- BinHandle -> IO IfaceContext
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceContext
    a9 <- BinHandle -> IO IfaceContext
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceType
    a10 <- BinHandle -> IO IfaceType
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        [FieldLabel]
    a11 <- BinHandle -> IO [FieldLabel]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceDecl -> IO IfaceDecl
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfExtName
    -> Bool
    -> (IfExtName, Bool)
    -> Maybe (IfExtName, Bool)
    -> [IfaceForAllSpecBndr]
    -> [IfaceForAllSpecBndr]
    -> IfaceContext
    -> IfaceContext
    -> IfaceContext
    -> IfaceType
    -> [FieldLabel]
    -> IfaceDecl
    IfacePatSyn IfExtName
    a1 Bool
    a2 (IfExtName, Bool)
    a3 Maybe (IfExtName, Bool)
    a4 [IfaceForAllSpecBndr]
    a5 [IfaceForAllSpecBndr]
    a6 IfaceContext
    a7 IfaceContext
    a8 IfaceContext
    a9 IfaceType
    a10 [FieldLabel]
    a11)
                Word8
    8 -> do IfExtName
    a1 <- BinHandle -> IO IfExtName
    getIfaceTopBndr BinHandle
    bh
                        [Role]
    a2 <- BinHandle -> IO [Role]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        [IfaceTyConBinder]
    a3 <- BinHandle -> IO [IfaceTyConBinder]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        [FunDep IfLclName]
    a4 <- BinHandle -> IO [FunDep IfLclName]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceDecl -> IO IfaceDecl
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfaceClass {
                            ifName :: IfExtName
    ifName    = IfExtName
    a1,
                            ifRoles :: [Role]
    ifRoles   = [Role]
    a2,
                            ifBinders :: [IfaceTyConBinder]
    ifBinders = [IfaceTyConBinder]
    a3,
                            ifFDs :: [FunDep IfLclName]
    ifFDs     = [FunDep IfLclName]
    a4,
                            ifBody :: IfaceClassBody
    ifBody = IfaceClassBody
    IfAbstractClass })
                Word8
    _ -> String -> IO IfaceDecl
    forall a. String -> a
    panic ([String] -> String
    unwords [String
    "Unknown IfaceDecl tag:", Word8 -> String
    forall a. Show a => a -> String
    show Word8
    h])

    {- Note [Lazy deserialization of IfaceId]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    The use of lazyPut and lazyGet in the IfaceId Binary instance is
    purely for performance reasons, to avoid deserializing details about
    identifiers that will never be used. It's not involved in tying the
    knot in the type checker. It saved ~1% of the total build time of GHC.

    When we read an interface file, we extend the PTE, a mapping of Names
    to TyThings, with the declarations we have read. The extension of the
    PTE is strict in the Names, but not in the TyThings themselves.
    GHC.IfaceToCore.tcIfaceDecls calculates the list of (Name, TyThing) bindings
    to add to the PTE.  For an IfaceId, there's just one binding to add; and
    the ty, details, and idinfo fields of an IfaceId are used only in the
    TyThing. So by reading those fields lazily we may be able to save the
    work of ever having to deserialize them (into IfaceType, etc.).

    For IfaceData and IfaceClass, tcIfaceDecls creates extra implicit bindings
    (the constructors and field selectors of the data declaration, or the
    methods of the class), whose Names depend on more than just the Name
    of the type constructor or class itself. So deserializing them lazily
    would be more involved. Similar comments apply to the other
    constructors of IfaceDecl with the additional point that they probably
    represent a small proportion of all declarations.
    -}

    instance Binary IfaceFamTyConFlav where
        put_ :: BinHandle -> IfaceFamTyConFlav -> IO ()
    put_ BinHandle
    bh IfaceFamTyConFlav
    IfaceDataFamilyTyCon              = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    0
        put_ BinHandle
    bh IfaceFamTyConFlav
    IfaceOpenSynFamilyTyCon           = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    1
        put_ BinHandle
    bh (IfaceClosedSynFamilyTyCon Maybe (IfExtName, [IfaceAxBranch])
    mb)    = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    2 IO () -> IO () -> IO ()
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> BinHandle -> Maybe (IfExtName, [IfaceAxBranch]) -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Maybe (IfExtName, [IfaceAxBranch])
    mb
        put_ BinHandle
    bh IfaceFamTyConFlav
    IfaceAbstractClosedSynFamilyTyCon = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    3
        put_ BinHandle
    _ IfaceFamTyConFlav
    IfaceBuiltInSynFamTyCon
            = String -> SDoc -> IO ()
    forall a. HasCallStack => String -> SDoc -> a
    pprPanic String
    "Cannot serialize IfaceBuiltInSynFamTyCon, used for pretty-printing only" SDoc
    Outputable.empty

        get :: BinHandle -> IO IfaceFamTyConFlav
    get BinHandle
    bh = do { Word8
    h <- BinHandle -> IO Word8
    getByte BinHandle
    bh
                    ; case Word8
    h of
                        Word8
    0 -> IfaceFamTyConFlav -> IO IfaceFamTyConFlav
    forall (m :: * -> *) a. Monad m => a -> m a
    return IfaceFamTyConFlav
    IfaceDataFamilyTyCon
                        Word8
    1 -> IfaceFamTyConFlav -> IO IfaceFamTyConFlav
    forall (m :: * -> *) a. Monad m => a -> m a
    return IfaceFamTyConFlav
    IfaceOpenSynFamilyTyCon
                        Word8
    2 -> do { Maybe (IfExtName, [IfaceAxBranch])
    mb <- BinHandle -> IO (Maybe (IfExtName, [IfaceAxBranch]))
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                                ; IfaceFamTyConFlav -> IO IfaceFamTyConFlav
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe (IfExtName, [IfaceAxBranch]) -> IfaceFamTyConFlav
    IfaceClosedSynFamilyTyCon Maybe (IfExtName, [IfaceAxBranch])
    mb) }
                        Word8
    3 -> IfaceFamTyConFlav -> IO IfaceFamTyConFlav
    forall (m :: * -> *) a. Monad m => a -> m a
    return IfaceFamTyConFlav
    IfaceAbstractClosedSynFamilyTyCon
                        Word8
    _ -> String -> SDoc -> IO IfaceFamTyConFlav
    forall a. HasCallStack => String -> SDoc -> a
    pprPanic String
    "Binary.get(IfaceFamTyConFlav): Invalid tag"
                                      (Int -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (Word8 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    h :: Int)) }

    instance Binary IfaceClassOp where
        put_ :: BinHandle -> IfaceClassOp -> IO ()
    put_ BinHandle
    bh (IfaceClassOp IfExtName
    n IfaceType
    ty Maybe (DefMethSpec IfaceType)
    def) = do
            BinHandle -> IfExtName -> IO ()
    putIfaceTopBndr BinHandle
    bh IfExtName
    n
            BinHandle -> IfaceType -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceType
    ty
            BinHandle -> Maybe (DefMethSpec IfaceType) -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Maybe (DefMethSpec IfaceType)
    def
        get :: BinHandle -> IO IfaceClassOp
    get BinHandle
    bh = do
            IfExtName
    n   <- BinHandle -> IO IfExtName
    getIfaceTopBndr BinHandle
    bh
            IfaceType
    ty  <- BinHandle -> IO IfaceType
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            Maybe (DefMethSpec IfaceType)
    def <- BinHandle -> IO (Maybe (DefMethSpec IfaceType))
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            IfaceClassOp -> IO IfaceClassOp
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfExtName
    -> IfaceType -> Maybe (DefMethSpec IfaceType) -> IfaceClassOp
    IfaceClassOp IfExtName
    n IfaceType
    ty Maybe (DefMethSpec IfaceType)
    def)

    instance Binary IfaceAT where
        put_ :: BinHandle -> IfaceAT -> IO ()
    put_ BinHandle
    bh (IfaceAT IfaceDecl
    dec Maybe IfaceType
    defs) = do
            BinHandle -> IfaceDecl -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceDecl
    dec
            BinHandle -> Maybe IfaceType -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Maybe IfaceType
    defs
        get :: BinHandle -> IO IfaceAT
    get BinHandle
    bh = do
            IfaceDecl
    dec  <- BinHandle -> IO IfaceDecl
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            Maybe IfaceType
    defs <- BinHandle -> IO (Maybe IfaceType)
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            IfaceAT -> IO IfaceAT
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfaceDecl -> Maybe IfaceType -> IfaceAT
    IfaceAT IfaceDecl
    dec Maybe IfaceType
    defs)

    instance Binary IfaceAxBranch where
        put_ :: BinHandle -> IfaceAxBranch -> IO ()
    put_ BinHandle
    bh (IfaceAxBranch [IfaceTvBndr]
    a1 [IfaceTvBndr]
    a2 [IfaceIdBndr]
    a3 IfaceAppArgs
    a4 [Role]
    a5 IfaceType
    a6 [Int]
    a7) = do
            BinHandle -> [IfaceTvBndr] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfaceTvBndr]
    a1
            BinHandle -> [IfaceTvBndr] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfaceTvBndr]
    a2
            BinHandle -> [IfaceIdBndr] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfaceIdBndr]
    a3
            BinHandle -> IfaceAppArgs -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceAppArgs
    a4
            BinHandle -> [Role] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [Role]
    a5
            BinHandle -> IfaceType -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceType
    a6
            BinHandle -> [Int] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [Int]
    a7
        get :: BinHandle -> IO IfaceAxBranch
    get BinHandle
    bh = do
            [IfaceTvBndr]
    a1 <- BinHandle -> IO [IfaceTvBndr]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            [IfaceTvBndr]
    a2 <- BinHandle -> IO [IfaceTvBndr]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            [IfaceIdBndr]
    a3 <- BinHandle -> IO [IfaceIdBndr]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            IfaceAppArgs
    a4 <- BinHandle -> IO IfaceAppArgs
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            [Role]
    a5 <- BinHandle -> IO [Role]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            IfaceType
    a6 <- BinHandle -> IO IfaceType
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            [Int]
    a7 <- BinHandle -> IO [Int]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            IfaceAxBranch -> IO IfaceAxBranch
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([IfaceTvBndr]
    -> [IfaceTvBndr]
    -> [IfaceIdBndr]
    -> IfaceAppArgs
    -> [Role]
    -> IfaceType
    -> [Int]
    -> IfaceAxBranch
    IfaceAxBranch [IfaceTvBndr]
    a1 [IfaceTvBndr]
    a2 [IfaceIdBndr]
    a3 IfaceAppArgs
    a4 [Role]
    a5 IfaceType
    a6 [Int]
    a7)

    instance Binary IfaceConDecls where
        put_ :: BinHandle -> IfaceConDecls -> IO ()
    put_ BinHandle
    bh IfaceConDecls
    IfAbstractTyCon  = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    0
        put_ BinHandle
    bh (IfDataTyCon [IfaceConDecl]
    cs) = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    1 IO () -> IO () -> IO ()
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> BinHandle -> [IfaceConDecl] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfaceConDecl]
    cs
        put_ BinHandle
    bh (IfNewTyCon IfaceConDecl
    c)   = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    2 IO () -> IO () -> IO ()
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> BinHandle -> IfaceConDecl -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceConDecl
    c
        get :: BinHandle -> IO IfaceConDecls
    get BinHandle
    bh = do
            Word8
    h <- BinHandle -> IO Word8
    getByte BinHandle
    bh
            case Word8
    h of
                Word8
    0 -> IfaceConDecls -> IO IfaceConDecls
    forall (m :: * -> *) a. Monad m => a -> m a
    return IfaceConDecls
    IfAbstractTyCon
                Word8
    1 -> ([IfaceConDecl] -> IfaceConDecls)
    -> IO [IfaceConDecl] -> IO IfaceConDecls
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM [IfaceConDecl] -> IfaceConDecls
    IfDataTyCon (BinHandle -> IO [IfaceConDecl]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh)
                Word8
    2 -> (IfaceConDecl -> IfaceConDecls)
    -> IO IfaceConDecl -> IO IfaceConDecls
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM IfaceConDecl -> IfaceConDecls
    IfNewTyCon (BinHandle -> IO IfaceConDecl
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh)
                Word8
    _ -> String -> IO IfaceConDecls
    forall a. HasCallStack => String -> a
    error String
    "Binary(IfaceConDecls).get: Invalid IfaceConDecls"

    instance Binary IfaceConDecl where
        put_ :: BinHandle -> IfaceConDecl -> IO ()
    put_ BinHandle
    bh (IfCon IfExtName
    a1 Bool
    a2 Bool
    a3 [IfaceBndr]
    a4 [IfaceForAllSpecBndr]
    a5 [IfaceTvBndr]
    a6 IfaceContext
    a7 [(IfaceType, IfaceType)]
    a8 [FieldLabel]
    a9 [IfaceBang]
    a10 [IfaceSrcBang]
    a11) = do
            BinHandle -> IfExtName -> IO ()
    putIfaceTopBndr BinHandle
    bh IfExtName
    a1
            BinHandle -> Bool -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Bool
    a2
            BinHandle -> Bool -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Bool
    a3
            BinHandle -> [IfaceBndr] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfaceBndr]
    a4
            BinHandle -> [IfaceForAllSpecBndr] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfaceForAllSpecBndr]
    a5
            BinHandle -> [IfaceTvBndr] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfaceTvBndr]
    a6
            BinHandle -> IfaceContext -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceContext
    a7
            BinHandle -> [(IfaceType, IfaceType)] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [(IfaceType, IfaceType)]
    a8
            BinHandle -> Int -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh ([FieldLabel] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length [FieldLabel]
    a9)
            (FieldLabel -> IO ()) -> [FieldLabel] -> IO ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ (BinHandle -> FieldLabel -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh) [FieldLabel]
    a9
            BinHandle -> [IfaceBang] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfaceBang]
    a10
            BinHandle -> [IfaceSrcBang] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfaceSrcBang]
    a11
        get :: BinHandle -> IO IfaceConDecl
    get BinHandle
    bh = do
            IfExtName
    a1 <- BinHandle -> IO IfExtName
    getIfaceTopBndr BinHandle
    bh
            Bool
    a2 <- BinHandle -> IO Bool
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            Bool
    a3 <- BinHandle -> IO Bool
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            [IfaceBndr]
    a4 <- BinHandle -> IO [IfaceBndr]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            [IfaceForAllSpecBndr]
    a5 <- BinHandle -> IO [IfaceForAllSpecBndr]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            [IfaceTvBndr]
    a6 <- BinHandle -> IO [IfaceTvBndr]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            IfaceContext
    a7 <- BinHandle -> IO IfaceContext
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            [(IfaceType, IfaceType)]
    a8 <- BinHandle -> IO [(IfaceType, IfaceType)]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            Int
    n_fields <- BinHandle -> IO Int
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            [FieldLabel]
    a9 <- Int -> IO FieldLabel -> IO [FieldLabel]
    forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
    replicateM Int
    n_fields (BinHandle -> IO FieldLabel
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh)
            [IfaceBang]
    a10 <- BinHandle -> IO [IfaceBang]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            [IfaceSrcBang]
    a11 <- BinHandle -> IO [IfaceSrcBang]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            IfaceConDecl -> IO IfaceConDecl
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfExtName
    -> Bool
    -> Bool
    -> [IfaceBndr]
    -> [IfaceForAllSpecBndr]
    -> [IfaceTvBndr]
    -> IfaceContext
    -> [(IfaceType, IfaceType)]
    -> [FieldLabel]
    -> [IfaceBang]
    -> [IfaceSrcBang]
    -> IfaceConDecl
    IfCon IfExtName
    a1 Bool
    a2 Bool
    a3 [IfaceBndr]
    a4 [IfaceForAllSpecBndr]
    a5 [IfaceTvBndr]
    a6 IfaceContext
    a7 [(IfaceType, IfaceType)]
    a8 [FieldLabel]
    a9 [IfaceBang]
    a10 [IfaceSrcBang]
    a11)

    instance Binary IfaceBang where
        put_ :: BinHandle -> IfaceBang -> IO ()
    put_ BinHandle
    bh IfaceBang
    IfNoBang        = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    0
        put_ BinHandle
    bh IfaceBang
    IfStrict        = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    1
        put_ BinHandle
    bh IfaceBang
    IfUnpack        = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    2
        put_ BinHandle
    bh (IfUnpackCo IfaceCoercion
    co) = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    3 IO () -> IO () -> IO ()
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> BinHandle -> IfaceCoercion -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceCoercion
    co

        get :: BinHandle -> IO IfaceBang
    get BinHandle
    bh = do
                Word8
    h <- BinHandle -> IO Word8
    getByte BinHandle
    bh
                case Word8
    h of
                  Word8
    0 -> IfaceBang -> IO IfaceBang
    forall (m :: * -> *) a. Monad m => a -> m a
    return IfaceBang
    IfNoBang
                  Word8
    1 -> IfaceBang -> IO IfaceBang
    forall (m :: * -> *) a. Monad m => a -> m a
    return IfaceBang
    IfStrict
                  Word8
    2 -> IfaceBang -> IO IfaceBang
    forall (m :: * -> *) a. Monad m => a -> m a
    return IfaceBang
    IfUnpack
                  Word8
    _ -> IfaceCoercion -> IfaceBang
    IfUnpackCo (IfaceCoercion -> IfaceBang) -> IO IfaceCoercion -> IO IfaceBang
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> BinHandle -> IO IfaceCoercion
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh

    instance Binary IfaceSrcBang where
        put_ :: BinHandle -> IfaceSrcBang -> IO ()
    put_ BinHandle
    bh (IfSrcBang SrcUnpackedness
    a1 SrcStrictness
    a2) =
          do BinHandle -> SrcUnpackedness -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh SrcUnpackedness
    a1
             BinHandle -> SrcStrictness -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh SrcStrictness
    a2

        get :: BinHandle -> IO IfaceSrcBang
    get BinHandle
    bh =
          do SrcUnpackedness
    a1 <- BinHandle -> IO SrcUnpackedness
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
             SrcStrictness
    a2 <- BinHandle -> IO SrcStrictness
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
             IfaceSrcBang -> IO IfaceSrcBang
    forall (m :: * -> *) a. Monad m => a -> m a
    return (SrcUnpackedness -> SrcStrictness -> IfaceSrcBang
    IfSrcBang SrcUnpackedness
    a1 SrcStrictness
    a2)

    instance Binary IfaceClsInst where
        put_ :: BinHandle -> IfaceClsInst -> IO ()
    put_ BinHandle
    bh (IfaceClsInst IfExtName
    cls [Maybe IfaceTyCon]
    tys IfExtName
    dfun OverlapFlag
    flag IsOrphan
    orph) = do
            BinHandle -> IfExtName -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfExtName
    cls
            BinHandle -> [Maybe IfaceTyCon] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [Maybe IfaceTyCon]
    tys
            BinHandle -> IfExtName -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfExtName
    dfun
            BinHandle -> OverlapFlag -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh OverlapFlag
    flag
            BinHandle -> IsOrphan -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IsOrphan
    orph
        get :: BinHandle -> IO IfaceClsInst
    get BinHandle
    bh = do
            IfExtName
    cls  <- BinHandle -> IO IfExtName
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            [Maybe IfaceTyCon]
    tys  <- BinHandle -> IO [Maybe IfaceTyCon]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            IfExtName
    dfun <- BinHandle -> IO IfExtName
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            OverlapFlag
    flag <- BinHandle -> IO OverlapFlag
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            IsOrphan
    orph <- BinHandle -> IO IsOrphan
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            IfaceClsInst -> IO IfaceClsInst
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfExtName
    -> [Maybe IfaceTyCon]
    -> IfExtName
    -> OverlapFlag
    -> IsOrphan
    -> IfaceClsInst
    IfaceClsInst IfExtName
    cls [Maybe IfaceTyCon]
    tys IfExtName
    dfun OverlapFlag
    flag IsOrphan
    orph)

    instance Binary IfaceFamInst where
        put_ :: BinHandle -> IfaceFamInst -> IO ()
    put_ BinHandle
    bh (IfaceFamInst IfExtName
    fam [Maybe IfaceTyCon]
    tys IfExtName
    name IsOrphan
    orph) = do
            BinHandle -> IfExtName -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfExtName
    fam
            BinHandle -> [Maybe IfaceTyCon] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [Maybe IfaceTyCon]
    tys
            BinHandle -> IfExtName -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfExtName
    name
            BinHandle -> IsOrphan -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IsOrphan
    orph
        get :: BinHandle -> IO IfaceFamInst
    get BinHandle
    bh = do
            IfExtName
    fam      <- BinHandle -> IO IfExtName
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            [Maybe IfaceTyCon]
    tys      <- BinHandle -> IO [Maybe IfaceTyCon]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            IfExtName
    name     <- BinHandle -> IO IfExtName
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            IsOrphan
    orph     <- BinHandle -> IO IsOrphan
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            IfaceFamInst -> IO IfaceFamInst
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfExtName
    -> [Maybe IfaceTyCon] -> IfExtName -> IsOrphan -> IfaceFamInst
    IfaceFamInst IfExtName
    fam [Maybe IfaceTyCon]
    tys IfExtName
    name IsOrphan
    orph)

    instance Binary IfaceRule where
        put_ :: BinHandle -> IfaceRule -> IO ()
    put_ BinHandle
    bh (IfaceRule IfLclName
    a1 Activation
    a2 [IfaceBndr]
    a3 IfExtName
    a4 [IfaceExpr]
    a5 IfaceExpr
    a6 Bool
    a7 IsOrphan
    a8) = do
            BinHandle -> IfLclName -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfLclName
    a1
            BinHandle -> Activation -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Activation
    a2
            BinHandle -> [IfaceBndr] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfaceBndr]
    a3
            BinHandle -> IfExtName -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfExtName
    a4
            BinHandle -> [IfaceExpr] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfaceExpr]
    a5
            BinHandle -> IfaceExpr -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceExpr
    a6
            BinHandle -> Bool -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Bool
    a7
            BinHandle -> IsOrphan -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IsOrphan
    a8
        get :: BinHandle -> IO IfaceRule
    get BinHandle
    bh = do
            IfLclName
    a1 <- BinHandle -> IO IfLclName
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            Activation
    a2 <- BinHandle -> IO Activation
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            [IfaceBndr]
    a3 <- BinHandle -> IO [IfaceBndr]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            IfExtName
    a4 <- BinHandle -> IO IfExtName
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            [IfaceExpr]
    a5 <- BinHandle -> IO [IfaceExpr]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            IfaceExpr
    a6 <- BinHandle -> IO IfaceExpr
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            Bool
    a7 <- BinHandle -> IO Bool
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            IsOrphan
    a8 <- BinHandle -> IO IsOrphan
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            IfaceRule -> IO IfaceRule
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfLclName
    -> Activation
    -> [IfaceBndr]
    -> IfExtName
    -> [IfaceExpr]
    -> IfaceExpr
    -> Bool
    -> IsOrphan
    -> IfaceRule
    IfaceRule IfLclName
    a1 Activation
    a2 [IfaceBndr]
    a3 IfExtName
    a4 [IfaceExpr]
    a5 IfaceExpr
    a6 Bool
    a7 IsOrphan
    a8)

    instance Binary IfaceAnnotation where
        put_ :: BinHandle -> IfaceAnnotation -> IO ()
    put_ BinHandle
    bh (IfaceAnnotation IfaceAnnTarget
    a1 AnnPayload
    a2) = do
            BinHandle -> IfaceAnnTarget -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceAnnTarget
    a1
            BinHandle -> AnnPayload -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh AnnPayload
    a2
        get :: BinHandle -> IO IfaceAnnotation
    get BinHandle
    bh = do
            IfaceAnnTarget
    a1 <- BinHandle -> IO IfaceAnnTarget
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            AnnPayload
    a2 <- BinHandle -> IO AnnPayload
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            IfaceAnnotation -> IO IfaceAnnotation
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfaceAnnTarget -> AnnPayload -> IfaceAnnotation
    IfaceAnnotation IfaceAnnTarget
    a1 AnnPayload
    a2)

    instance Binary IfaceIdDetails where
        put_ :: BinHandle -> IfaceIdDetails -> IO ()
    put_ BinHandle
    bh IfaceIdDetails
    IfVanillaId      = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    0
        put_ BinHandle
    bh (IfRecSelId Either IfaceTyCon IfaceDecl
    a Bool
    b) = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    1 IO () -> IO () -> IO ()
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> BinHandle -> Either IfaceTyCon IfaceDecl -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Either IfaceTyCon IfaceDecl
    a IO () -> IO () -> IO ()
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> BinHandle -> Bool -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Bool
    b
        put_ BinHandle
    bh IfaceIdDetails
    IfDFunId         = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    2
        get :: BinHandle -> IO IfaceIdDetails
    get BinHandle
    bh = do
            Word8
    h <- BinHandle -> IO Word8
    getByte BinHandle
    bh
            case Word8
    h of
                Word8
    0 -> IfaceIdDetails -> IO IfaceIdDetails
    forall (m :: * -> *) a. Monad m => a -> m a
    return IfaceIdDetails
    IfVanillaId
                Word8
    1 -> do { Either IfaceTyCon IfaceDecl
    a <- BinHandle -> IO (Either IfaceTyCon IfaceDecl)
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh; Bool
    b <- BinHandle -> IO Bool
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh; IfaceIdDetails -> IO IfaceIdDetails
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Either IfaceTyCon IfaceDecl -> Bool -> IfaceIdDetails
    IfRecSelId Either IfaceTyCon IfaceDecl
    a Bool
    b) }
                Word8
    _ -> IfaceIdDetails -> IO IfaceIdDetails
    forall (m :: * -> *) a. Monad m => a -> m a
    return IfaceIdDetails
    IfDFunId

    instance Binary IfaceInfoItem where
        put_ :: BinHandle -> IfaceInfoItem -> IO ()
    put_ BinHandle
    bh (HsArity Int
    aa)          = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    0 IO () -> IO () -> IO ()
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> BinHandle -> Int -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Int
    aa
        put_ BinHandle
    bh (HsStrictness StrictSig
    ab)     = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    1 IO () -> IO () -> IO ()
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> BinHandle -> StrictSig -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh StrictSig
    ab
        put_ BinHandle
    bh (HsUnfold Bool
    lb IfaceUnfolding
    ad)      = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    2 IO () -> IO () -> IO ()
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> BinHandle -> Bool -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Bool
    lb IO () -> IO () -> IO ()
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> BinHandle -> IfaceUnfolding -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceUnfolding
    ad
        put_ BinHandle
    bh (HsInline InlinePragma
    ad)         = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    3 IO () -> IO () -> IO ()
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> BinHandle -> InlinePragma -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh InlinePragma
    ad
        put_ BinHandle
    bh IfaceInfoItem
    HsNoCafRefs           = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    4
        put_ BinHandle
    bh IfaceInfoItem
    HsLevity              = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    5
        put_ BinHandle
    bh (HsCpr CprSig
    cpr)           = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    6 IO () -> IO () -> IO ()
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> BinHandle -> CprSig -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh CprSig
    cpr
        put_ BinHandle
    bh (HsLFInfo IfaceLFInfo
    lf_info)    = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    7 IO () -> IO () -> IO ()
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> BinHandle -> IfaceLFInfo -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceLFInfo
    lf_info

        get :: BinHandle -> IO IfaceInfoItem
    get BinHandle
    bh = do
            Word8
    h <- BinHandle -> IO Word8
    getByte BinHandle
    bh
            case Word8
    h of
                Word8
    0 -> (Int -> IfaceInfoItem) -> IO Int -> IO IfaceInfoItem
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM Int -> IfaceInfoItem
    HsArity (IO Int -> IO IfaceInfoItem) -> IO Int -> IO IfaceInfoItem
    forall a b. (a -> b) -> a -> b
    $ BinHandle -> IO Int
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                Word8
    1 -> (StrictSig -> IfaceInfoItem) -> IO StrictSig -> IO IfaceInfoItem
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM StrictSig -> IfaceInfoItem
    HsStrictness (IO StrictSig -> IO IfaceInfoItem)
    -> IO StrictSig -> IO IfaceInfoItem
    forall a b. (a -> b) -> a -> b
    $ BinHandle -> IO StrictSig
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                Word8
    2 -> do Bool
    lb <- BinHandle -> IO Bool
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceUnfolding
    ad <- BinHandle -> IO IfaceUnfolding
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceInfoItem -> IO IfaceInfoItem
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Bool -> IfaceUnfolding -> IfaceInfoItem
    HsUnfold Bool
    lb IfaceUnfolding
    ad)
                Word8
    3 -> (InlinePragma -> IfaceInfoItem)
    -> IO InlinePragma -> IO IfaceInfoItem
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM InlinePragma -> IfaceInfoItem
    HsInline (IO InlinePragma -> IO IfaceInfoItem)
    -> IO InlinePragma -> IO IfaceInfoItem
    forall a b. (a -> b) -> a -> b
    $ BinHandle -> IO InlinePragma
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                Word8
    4 -> IfaceInfoItem -> IO IfaceInfoItem
    forall (m :: * -> *) a. Monad m => a -> m a
    return IfaceInfoItem
    HsNoCafRefs
                Word8
    5 -> IfaceInfoItem -> IO IfaceInfoItem
    forall (m :: * -> *) a. Monad m => a -> m a
    return IfaceInfoItem
    HsLevity
                Word8
    6 -> CprSig -> IfaceInfoItem
    HsCpr (CprSig -> IfaceInfoItem) -> IO CprSig -> IO IfaceInfoItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> BinHandle -> IO CprSig
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                Word8
    _ -> IfaceLFInfo -> IfaceInfoItem
    HsLFInfo (IfaceLFInfo -> IfaceInfoItem)
    -> IO IfaceLFInfo -> IO IfaceInfoItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> BinHandle -> IO IfaceLFInfo
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh

    instance Binary IfaceUnfolding where
        put_ :: BinHandle -> IfaceUnfolding -> IO ()
    put_ BinHandle
    bh (IfCoreUnfold Bool
    s IfaceExpr
    e) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    0
            BinHandle -> Bool -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Bool
    s
            BinHandle -> IfaceExpr -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceExpr
    e
        put_ BinHandle
    bh (IfInlineRule Int
    a Bool
    b Bool
    c IfaceExpr
    d) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    1
            BinHandle -> Int -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Int
    a
            BinHandle -> Bool -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Bool
    b
            BinHandle -> Bool -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Bool
    c
            BinHandle -> IfaceExpr -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceExpr
    d
        put_ BinHandle
    bh (IfDFunUnfold [IfaceBndr]
    as [IfaceExpr]
    bs) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    2
            BinHandle -> [IfaceBndr] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfaceBndr]
    as
            BinHandle -> [IfaceExpr] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfaceExpr]
    bs
        put_ BinHandle
    bh (IfCompulsory IfaceExpr
    e) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    3
            BinHandle -> IfaceExpr -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceExpr
    e
        get :: BinHandle -> IO IfaceUnfolding
    get BinHandle
    bh = do
            Word8
    h <- BinHandle -> IO Word8
    getByte BinHandle
    bh
            case Word8
    h of
                Word8
    0 -> do Bool
    s <- BinHandle -> IO Bool
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceExpr
    e <- BinHandle -> IO IfaceExpr
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceUnfolding -> IO IfaceUnfolding
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Bool -> IfaceExpr -> IfaceUnfolding
    IfCoreUnfold Bool
    s IfaceExpr
    e)
                Word8
    1 -> do Int
    a <- BinHandle -> IO Int
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        Bool
    b <- BinHandle -> IO Bool
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        Bool
    c <- BinHandle -> IO Bool
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceExpr
    d <- BinHandle -> IO IfaceExpr
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceUnfolding -> IO IfaceUnfolding
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int -> Bool -> Bool -> IfaceExpr -> IfaceUnfolding
    IfInlineRule Int
    a Bool
    b Bool
    c IfaceExpr
    d)
                Word8
    2 -> do [IfaceBndr]
    as <- BinHandle -> IO [IfaceBndr]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        [IfaceExpr]
    bs <- BinHandle -> IO [IfaceExpr]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceUnfolding -> IO IfaceUnfolding
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([IfaceBndr] -> [IfaceExpr] -> IfaceUnfolding
    IfDFunUnfold [IfaceBndr]
    as [IfaceExpr]
    bs)
                Word8
    _ -> do IfaceExpr
    e <- BinHandle -> IO IfaceExpr
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceUnfolding -> IO IfaceUnfolding
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfaceExpr -> IfaceUnfolding
    IfCompulsory IfaceExpr
    e)

    instance Binary IfaceAlt where
        put_ :: BinHandle -> IfaceAlt -> IO ()
    put_ BinHandle
    bh (IfaceAlt IfaceConAlt
    a [IfLclName]
    b IfaceExpr
    c) = do
            BinHandle -> IfaceConAlt -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceConAlt
    a
            BinHandle -> [IfLclName] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfLclName]
    b
            BinHandle -> IfaceExpr -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceExpr
    c
        get :: BinHandle -> IO IfaceAlt
    get BinHandle
    bh = do
            IfaceConAlt
    a <- BinHandle -> IO IfaceConAlt
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            [IfLclName]
    b <- BinHandle -> IO [IfLclName]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            IfaceExpr
    c <- BinHandle -> IO IfaceExpr
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
            IfaceAlt -> IO IfaceAlt
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfaceConAlt -> [IfLclName] -> IfaceExpr -> IfaceAlt
    IfaceAlt IfaceConAlt
    a [IfLclName]
    b IfaceExpr
    c)

    instance Binary IfaceExpr where
        put_ :: BinHandle -> IfaceExpr -> IO ()
    put_ BinHandle
    bh (IfaceLcl IfLclName
    aa) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    0
            BinHandle -> IfLclName -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfLclName
    aa
        put_ BinHandle
    bh (IfaceType IfaceType
    ab) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    1
            BinHandle -> IfaceType -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceType
    ab
        put_ BinHandle
    bh (IfaceCo IfaceCoercion
    ab) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    2
            BinHandle -> IfaceCoercion -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceCoercion
    ab
        put_ BinHandle
    bh (IfaceTuple TupleSort
    ac [IfaceExpr]
    ad) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    3
            BinHandle -> TupleSort -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh TupleSort
    ac
            BinHandle -> [IfaceExpr] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfaceExpr]
    ad
        put_ BinHandle
    bh (IfaceLam (IfaceBndr
    ae, IfaceOneShot
    os) IfaceExpr
    af) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    4
            BinHandle -> IfaceBndr -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceBndr
    ae
            BinHandle -> IfaceOneShot -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceOneShot
    os
            BinHandle -> IfaceExpr -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceExpr
    af
        put_ BinHandle
    bh (IfaceApp IfaceExpr
    ag IfaceExpr
    ah) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    5
            BinHandle -> IfaceExpr -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceExpr
    ag
            BinHandle -> IfaceExpr -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceExpr
    ah
        put_ BinHandle
    bh (IfaceCase IfaceExpr
    ai IfLclName
    aj [IfaceAlt]
    ak) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    6
            BinHandle -> IfaceExpr -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceExpr
    ai
            BinHandle -> IfLclName -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfLclName
    aj
            BinHandle -> [IfaceAlt] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfaceAlt]
    ak
        put_ BinHandle
    bh (IfaceLet IfaceBinding
    al IfaceExpr
    am) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    7
            BinHandle -> IfaceBinding -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceBinding
    al
            BinHandle -> IfaceExpr -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceExpr
    am
        put_ BinHandle
    bh (IfaceTick IfaceTickish
    an IfaceExpr
    ao) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    8
            BinHandle -> IfaceTickish -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceTickish
    an
            BinHandle -> IfaceExpr -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceExpr
    ao
        put_ BinHandle
    bh (IfaceLit Literal
    ap) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    9
            BinHandle -> Literal -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Literal
    ap
        put_ BinHandle
    bh (IfaceFCall ForeignCall
    as IfaceType
    at) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    10
            BinHandle -> ForeignCall -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh ForeignCall
    as
            BinHandle -> IfaceType -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceType
    at
        put_ BinHandle
    bh (IfaceExt IfExtName
    aa) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    11
            BinHandle -> IfExtName -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfExtName
    aa
        put_ BinHandle
    bh (IfaceCast IfaceExpr
    ie IfaceCoercion
    ico) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    12
            BinHandle -> IfaceExpr -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceExpr
    ie
            BinHandle -> IfaceCoercion -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceCoercion
    ico
        put_ BinHandle
    bh (IfaceECase IfaceExpr
    a IfaceType
    b) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    13
            BinHandle -> IfaceExpr -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceExpr
    a
            BinHandle -> IfaceType -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceType
    b
        get :: BinHandle -> IO IfaceExpr
    get BinHandle
    bh = do
            Word8
    h <- BinHandle -> IO Word8
    getByte BinHandle
    bh
            case Word8
    h of
                Word8
    0 -> do IfLclName
    aa <- BinHandle -> IO IfLclName
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceExpr -> IO IfaceExpr
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfLclName -> IfaceExpr
    IfaceLcl IfLclName
    aa)
                Word8
    1 -> do IfaceType
    ab <- BinHandle -> IO IfaceType
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceExpr -> IO IfaceExpr
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfaceType -> IfaceExpr
    IfaceType IfaceType
    ab)
                Word8
    2 -> do IfaceCoercion
    ab <- BinHandle -> IO IfaceCoercion
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceExpr -> IO IfaceExpr
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfaceCoercion -> IfaceExpr
    IfaceCo IfaceCoercion
    ab)
                Word8
    3 -> do TupleSort
    ac <- BinHandle -> IO TupleSort
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        [IfaceExpr]
    ad <- BinHandle -> IO [IfaceExpr]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceExpr -> IO IfaceExpr
    forall (m :: * -> *) a. Monad m => a -> m a
    return (TupleSort -> [IfaceExpr] -> IfaceExpr
    IfaceTuple TupleSort
    ac [IfaceExpr]
    ad)
                Word8
    4 -> do IfaceBndr
    ae <- BinHandle -> IO IfaceBndr
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceOneShot
    os <- BinHandle -> IO IfaceOneShot
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceExpr
    af <- BinHandle -> IO IfaceExpr
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceExpr -> IO IfaceExpr
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfaceLamBndr -> IfaceExpr -> IfaceExpr
    IfaceLam (IfaceBndr
    ae, IfaceOneShot
    os) IfaceExpr
    af)
                Word8
    5 -> do IfaceExpr
    ag <- BinHandle -> IO IfaceExpr
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceExpr
    ah <- BinHandle -> IO IfaceExpr
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceExpr -> IO IfaceExpr
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfaceExpr -> IfaceExpr -> IfaceExpr
    IfaceApp IfaceExpr
    ag IfaceExpr
    ah)
                Word8
    6 -> do IfaceExpr
    ai <- BinHandle -> IO IfaceExpr
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfLclName
    aj <- BinHandle -> IO IfLclName
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        [IfaceAlt]
    ak <- BinHandle -> IO [IfaceAlt]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceExpr -> IO IfaceExpr
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfaceExpr -> IfLclName -> [IfaceAlt] -> IfaceExpr
    IfaceCase IfaceExpr
    ai IfLclName
    aj [IfaceAlt]
    ak)
                Word8
    7 -> do IfaceBinding
    al <- BinHandle -> IO IfaceBinding
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceExpr
    am <- BinHandle -> IO IfaceExpr
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceExpr -> IO IfaceExpr
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfaceBinding -> IfaceExpr -> IfaceExpr
    IfaceLet IfaceBinding
    al IfaceExpr
    am)
                Word8
    8 -> do IfaceTickish
    an <- BinHandle -> IO IfaceTickish
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceExpr
    ao <- BinHandle -> IO IfaceExpr
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceExpr -> IO IfaceExpr
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfaceTickish -> IfaceExpr -> IfaceExpr
    IfaceTick IfaceTickish
    an IfaceExpr
    ao)
                Word8
    9 -> do Literal
    ap <- BinHandle -> IO Literal
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceExpr -> IO IfaceExpr
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Literal -> IfaceExpr
    IfaceLit Literal
    ap)
                Word8
    10 -> do ForeignCall
    as <- BinHandle -> IO ForeignCall
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                         IfaceType
    at <- BinHandle -> IO IfaceType
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                         IfaceExpr -> IO IfaceExpr
    forall (m :: * -> *) a. Monad m => a -> m a
    return (ForeignCall -> IfaceType -> IfaceExpr
    IfaceFCall ForeignCall
    as IfaceType
    at)
                Word8
    11 -> do IfExtName
    aa <- BinHandle -> IO IfExtName
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                         IfaceExpr -> IO IfaceExpr
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfExtName -> IfaceExpr
    IfaceExt IfExtName
    aa)
                Word8
    12 -> do IfaceExpr
    ie <- BinHandle -> IO IfaceExpr
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                         IfaceCoercion
    ico <- BinHandle -> IO IfaceCoercion
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                         IfaceExpr -> IO IfaceExpr
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfaceExpr -> IfaceCoercion -> IfaceExpr
    IfaceCast IfaceExpr
    ie IfaceCoercion
    ico)
                Word8
    13 -> do IfaceExpr
    a <- BinHandle -> IO IfaceExpr
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                         IfaceType
    b <- BinHandle -> IO IfaceType
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                         IfaceExpr -> IO IfaceExpr
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfaceExpr -> IfaceType -> IfaceExpr
    IfaceECase IfaceExpr
    a IfaceType
    b)
                Word8
    _ -> String -> IO IfaceExpr
    forall a. String -> a
    panic (String
    "get IfaceExpr " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ Word8 -> String
    forall a. Show a => a -> String
    show Word8
    h)

    instance Binary IfaceTickish where
        put_ :: BinHandle -> IfaceTickish -> IO ()
    put_ BinHandle
    bh (IfaceHpcTick Module
    m Int
    ix) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    0
            BinHandle -> Module -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Module
    m
            BinHandle -> Int -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Int
    ix
        put_ BinHandle
    bh (IfaceSCC CostCentre
    cc Bool
    tick Bool
    push) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    1
            BinHandle -> CostCentre -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh CostCentre
    cc
            BinHandle -> Bool -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Bool
    tick
            BinHandle -> Bool -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Bool
    push
        put_ BinHandle
    bh (IfaceSource RealSrcSpan
    src String
    name) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    2
            BinHandle -> IfLclName -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh (RealSrcSpan -> IfLclName
    srcSpanFile RealSrcSpan
    src)
            BinHandle -> Int -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh (RealSrcSpan -> Int
    srcSpanStartLine RealSrcSpan
    src)
            BinHandle -> Int -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh (RealSrcSpan -> Int
    srcSpanStartCol RealSrcSpan
    src)
            BinHandle -> Int -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh (RealSrcSpan -> Int
    srcSpanEndLine RealSrcSpan
    src)
            BinHandle -> Int -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh (RealSrcSpan -> Int
    srcSpanEndCol RealSrcSpan
    src)
            BinHandle -> String -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh String
    name

        get :: BinHandle -> IO IfaceTickish
    get BinHandle
    bh = do
            Word8
    h <- BinHandle -> IO Word8
    getByte BinHandle
    bh
            case Word8
    h of
                Word8
    0 -> do Module
    m <- BinHandle -> IO Module
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        Int
    ix <- BinHandle -> IO Int
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceTickish -> IO IfaceTickish
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Module -> Int -> IfaceTickish
    IfaceHpcTick Module
    m Int
    ix)
                Word8
    1 -> do CostCentre
    cc <- BinHandle -> IO CostCentre
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        Bool
    tick <- BinHandle -> IO Bool
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        Bool
    push <- BinHandle -> IO Bool
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceTickish -> IO IfaceTickish
    forall (m :: * -> *) a. Monad m => a -> m a
    return (CostCentre -> Bool -> Bool -> IfaceTickish
    IfaceSCC CostCentre
    cc Bool
    tick Bool
    push)
                Word8
    2 -> do IfLclName
    file <- BinHandle -> IO IfLclName
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        Int
    sl <- BinHandle -> IO Int
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        Int
    sc <- BinHandle -> IO Int
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        Int
    el <- BinHandle -> IO Int
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        Int
    ec <- BinHandle -> IO Int
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        let start :: RealSrcLoc
    start = IfLclName -> Int -> Int -> RealSrcLoc
    mkRealSrcLoc IfLclName
    file Int
    sl Int
    sc
                            end :: RealSrcLoc
    end = IfLclName -> Int -> Int -> RealSrcLoc
    mkRealSrcLoc IfLclName
    file Int
    el Int
    ec
                        String
    name <- BinHandle -> IO String
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                        IfaceTickish -> IO IfaceTickish
    forall (m :: * -> *) a. Monad m => a -> m a
    return (RealSrcSpan -> String -> IfaceTickish
    IfaceSource (RealSrcLoc -> RealSrcLoc -> RealSrcSpan
    mkRealSrcSpan RealSrcLoc
    start RealSrcLoc
    end) String
    name)
                Word8
    _ -> String -> IO IfaceTickish
    forall a. String -> a
    panic (String
    "get IfaceTickish " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ Word8 -> String
    forall a. Show a => a -> String
    show Word8
    h)

    instance Binary IfaceConAlt where
        put_ :: BinHandle -> IfaceConAlt -> IO ()
    put_ BinHandle
    bh IfaceConAlt
    IfaceDefault      = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    0
        put_ BinHandle
    bh (IfaceDataAlt IfExtName
    aa) = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    1 IO () -> IO () -> IO ()
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> BinHandle -> IfExtName -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfExtName
    aa
        put_ BinHandle
    bh (IfaceLitAlt Literal
    ac)  = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    2 IO () -> IO () -> IO ()
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> BinHandle -> Literal -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Literal
    ac
        get :: BinHandle -> IO IfaceConAlt
    get BinHandle
    bh = do
            Word8
    h <- BinHandle -> IO Word8
    getByte BinHandle
    bh
            case Word8
    h of
                Word8
    0 -> IfaceConAlt -> IO IfaceConAlt
    forall (m :: * -> *) a. Monad m => a -> m a
    return IfaceConAlt
    IfaceDefault
                Word8
    1 -> (IfExtName -> IfaceConAlt) -> IO IfExtName -> IO IfaceConAlt
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM IfExtName -> IfaceConAlt
    IfaceDataAlt (IO IfExtName -> IO IfaceConAlt) -> IO IfExtName -> IO IfaceConAlt
    forall a b. (a -> b) -> a -> b
    $ BinHandle -> IO IfExtName
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                Word8
    _ -> (Literal -> IfaceConAlt) -> IO Literal -> IO IfaceConAlt
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM Literal -> IfaceConAlt
    IfaceLitAlt  (IO Literal -> IO IfaceConAlt) -> IO Literal -> IO IfaceConAlt
    forall a b. (a -> b) -> a -> b
    $ BinHandle -> IO Literal
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh

    instance Binary IfaceBinding where
        put_ :: BinHandle -> IfaceBinding -> IO ()
    put_ BinHandle
    bh (IfaceNonRec IfaceLetBndr
    aa IfaceExpr
    ab) = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    0 IO () -> IO () -> IO ()
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> BinHandle -> IfaceLetBndr -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceLetBndr
    aa IO () -> IO () -> IO ()
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> BinHandle -> IfaceExpr -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceExpr
    ab
        put_ BinHandle
    bh (IfaceRec [(IfaceLetBndr, IfaceExpr)]
    ac)       = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    1 IO () -> IO () -> IO ()
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> BinHandle -> [(IfaceLetBndr, IfaceExpr)] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [(IfaceLetBndr, IfaceExpr)]
    ac
        get :: BinHandle -> IO IfaceBinding
    get BinHandle
    bh = do
            Word8
    h <- BinHandle -> IO Word8
    getByte BinHandle
    bh
            case Word8
    h of
                Word8
    0 -> do { IfaceLetBndr
    aa <- BinHandle -> IO IfaceLetBndr
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh; IfaceExpr
    ab <- BinHandle -> IO IfaceExpr
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh; IfaceBinding -> IO IfaceBinding
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfaceLetBndr -> IfaceExpr -> IfaceBinding
    IfaceNonRec IfaceLetBndr
    aa IfaceExpr
    ab) }
                Word8
    _ -> do { [(IfaceLetBndr, IfaceExpr)]
    ac <- BinHandle -> IO [(IfaceLetBndr, IfaceExpr)]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh; IfaceBinding -> IO IfaceBinding
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([(IfaceLetBndr, IfaceExpr)] -> IfaceBinding
    IfaceRec [(IfaceLetBndr, IfaceExpr)]
    ac) }

    instance Binary IfaceLetBndr where
        put_ :: BinHandle -> IfaceLetBndr -> IO ()
    put_ BinHandle
    bh (IfLetBndr IfLclName
    a IfaceType
    b IfaceIdInfo
    c IfaceJoinInfo
    d) = do
                BinHandle -> IfLclName -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfLclName
    a
                BinHandle -> IfaceType -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceType
    b
                BinHandle -> IfaceIdInfo -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceIdInfo
    c
                BinHandle -> IfaceJoinInfo -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceJoinInfo
    d
        get :: BinHandle -> IO IfaceLetBndr
    get BinHandle
    bh = do IfLclName
    a <- BinHandle -> IO IfLclName
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                    IfaceType
    b <- BinHandle -> IO IfaceType
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                    IfaceIdInfo
    c <- BinHandle -> IO IfaceIdInfo
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                    IfaceJoinInfo
    d <- BinHandle -> IO IfaceJoinInfo
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                    IfaceLetBndr -> IO IfaceLetBndr
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfLclName
    -> IfaceType -> IfaceIdInfo -> IfaceJoinInfo -> IfaceLetBndr
    IfLetBndr IfLclName
    a IfaceType
    b IfaceIdInfo
    c IfaceJoinInfo
    d)

    instance Binary IfaceJoinInfo where
        put_ :: BinHandle -> IfaceJoinInfo -> IO ()
    put_ BinHandle
    bh IfaceJoinInfo
    IfaceNotJoinPoint = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    0
        put_ BinHandle
    bh (IfaceJoinPoint Int
    ar) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    1
            BinHandle -> Int -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Int
    ar
        get :: BinHandle -> IO IfaceJoinInfo
    get BinHandle
    bh = do
            Word8
    h <- BinHandle -> IO Word8
    getByte BinHandle
    bh
            case Word8
    h of
                Word8
    0 -> IfaceJoinInfo -> IO IfaceJoinInfo
    forall (m :: * -> *) a. Monad m => a -> m a
    return IfaceJoinInfo
    IfaceNotJoinPoint
                Word8
    _ -> (Int -> IfaceJoinInfo) -> IO Int -> IO IfaceJoinInfo
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM Int -> IfaceJoinInfo
    IfaceJoinPoint (IO Int -> IO IfaceJoinInfo) -> IO Int -> IO IfaceJoinInfo
    forall a b. (a -> b) -> a -> b
    $ BinHandle -> IO Int
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh

    instance Binary IfaceTyConParent where
        put_ :: BinHandle -> IfaceTyConParent -> IO ()
    put_ BinHandle
    bh IfaceTyConParent
    IfNoParent = BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    0
        put_ BinHandle
    bh (IfDataInstance IfExtName
    ax IfaceTyCon
    pr IfaceAppArgs
    ty) = do
            BinHandle -> Word8 -> IO ()
    putByte BinHandle
    bh Word8
    1
            BinHandle -> IfExtName -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfExtName
    ax
            BinHandle -> IfaceTyCon -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceTyCon
    pr
            BinHandle -> IfaceAppArgs -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh IfaceAppArgs
    ty
        get :: BinHandle -> IO IfaceTyConParent
    get BinHandle
    bh = do
            Word8
    h <- BinHandle -> IO Word8
    getByte BinHandle
    bh
            case Word8
    h of
                Word8
    0 -> IfaceTyConParent -> IO IfaceTyConParent
    forall (m :: * -> *) a. Monad m => a -> m a
    return IfaceTyConParent
    IfNoParent
                Word8
    _ -> do
                    IfExtName
    ax <- BinHandle -> IO IfExtName
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                    IfaceTyCon
    pr <- BinHandle -> IO IfaceTyCon
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                    IfaceAppArgs
    ty <- BinHandle -> IO IfaceAppArgs
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh
                    IfaceTyConParent -> IO IfaceTyConParent
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfaceTyConParent -> IO IfaceTyConParent)
    -> IfaceTyConParent -> IO IfaceTyConParent
    forall a b. (a -> b) -> a -> b
    $ IfExtName -> IfaceTyCon -> IfaceAppArgs -> IfaceTyConParent
    IfDataInstance IfExtName
    ax IfaceTyCon
    pr IfaceAppArgs
    ty

    instance Binary IfaceCompleteMatch where
      put_ :: BinHandle -> IfaceCompleteMatch -> IO ()
    put_ BinHandle
    bh (IfaceCompleteMatch [IfExtName]
    cs Maybe IfaceTyCon
    mtc) = BinHandle -> [IfExtName] -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh [IfExtName]
    cs IO () -> IO () -> IO ()
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> BinHandle -> Maybe IfaceTyCon -> IO ()
    forall a. Binary a => BinHandle -> a -> IO ()
    put_ BinHandle
    bh Maybe IfaceTyCon
    mtc
      get :: BinHandle -> IO IfaceCompleteMatch
    get BinHandle
    bh = [IfExtName] -> Maybe IfaceTyCon -> IfaceCompleteMatch
    IfaceCompleteMatch ([IfExtName] -> Maybe IfaceTyCon -> IfaceCompleteMatch)
    -> IO [IfExtName] -> IO (Maybe IfaceTyCon -> IfaceCompleteMatch)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> BinHandle -> IO [IfExtName]
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh IO (Maybe IfaceTyCon -> IfaceCompleteMatch)
    -> IO (Maybe IfaceTyCon) -> IO IfaceCompleteMatch
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> BinHandle -> IO (Maybe IfaceTyCon)
    forall a. Binary a => BinHandle -> IO a
    get BinHandle
    bh

    {-
    ************************************************************************
    *                                                                      *
                    NFData instances
       See Note [Avoiding space leaks in toIface*] in GHC.CoreToIface
    *                                                                      *
    ************************************************************************
    -}

    instance NFData IfaceDecl where
      rnf :: IfaceDecl -> ()
    rnf = \case
        IfaceId IfExtName
    f1 IfaceType
    f2 IfaceIdDetails
    f3 IfaceIdInfo
    f4 ->
          IfExtName -> ()
    forall a. NFData a => a -> ()
    rnf IfExtName
    f1 () -> () -> ()
    `seq` IfaceType -> ()
    forall a. NFData a => a -> ()
    rnf IfaceType
    f2 () -> () -> ()
    `seq` IfaceIdDetails -> ()
    forall a. NFData a => a -> ()
    rnf IfaceIdDetails
    f3 () -> () -> ()
    `seq` IfaceIdInfo -> ()
    forall a. NFData a => a -> ()
    rnf IfaceIdInfo
    f4

        IfaceData IfExtName
    f1 [IfaceTyConBinder]
    f2 IfaceType
    f3 Maybe CType
    f4 [Role]
    f5 IfaceContext
    f6 IfaceConDecls
    f7 Bool
    f8 IfaceTyConParent
    f9 ->
          IfExtName
    f1 IfExtName -> () -> ()
    `seq` [IfaceTyConBinder] -> Any -> Any
    forall a b. [a] -> b -> b
    seqList [IfaceTyConBinder]
    f2 (Any -> Any) -> () -> ()
    `seq` IfaceType
    f3 IfaceType -> () -> ()
    `seq` Maybe CType
    f4 Maybe CType -> () -> ()
    `seq` [Role]
    f5 [Role] -> () -> ()
    `seq`
          IfaceContext -> ()
    forall a. NFData a => a -> ()
    rnf IfaceContext
    f6 () -> () -> ()
    `seq` IfaceConDecls -> ()
    forall a. NFData a => a -> ()
    rnf IfaceConDecls
    f7 () -> () -> ()
    `seq` Bool -> ()
    forall a. NFData a => a -> ()
    rnf Bool
    f8 () -> () -> ()
    `seq` IfaceTyConParent -> ()
    forall a. NFData a => a -> ()
    rnf IfaceTyConParent
    f9

        IfaceSynonym IfExtName
    f1 [Role]
    f2 [IfaceTyConBinder]
    f3 IfaceType
    f4 IfaceType
    f5 ->
          IfExtName -> ()
    forall a. NFData a => a -> ()
    rnf IfExtName
    f1 () -> () -> ()
    `seq` [Role]
    f2 [Role] -> () -> ()
    `seq` [IfaceTyConBinder] -> Any -> Any
    forall a b. [a] -> b -> b
    seqList [IfaceTyConBinder]
    f3 (Any -> Any) -> () -> ()
    `seq` IfaceType -> ()
    forall a. NFData a => a -> ()
    rnf IfaceType
    f4 () -> () -> ()
    `seq` IfaceType -> ()
    forall a. NFData a => a -> ()
    rnf IfaceType
    f5

        IfaceFamily IfExtName
    f1 Maybe IfLclName
    f2 [IfaceTyConBinder]
    f3 IfaceType
    f4 IfaceFamTyConFlav
    f5 Injectivity
    f6 ->
          IfExtName -> ()
    forall a. NFData a => a -> ()
    rnf IfExtName
    f1 () -> () -> ()
    `seq` Maybe IfLclName -> ()
    forall a. NFData a => a -> ()
    rnf Maybe IfLclName
    f2 () -> () -> ()
    `seq` [IfaceTyConBinder] -> Any -> Any
    forall a b. [a] -> b -> b
    seqList [IfaceTyConBinder]
    f3 (Any -> Any) -> () -> ()
    `seq` IfaceType -> ()
    forall a. NFData a => a -> ()
    rnf IfaceType
    f4 () -> () -> ()
    `seq` IfaceFamTyConFlav -> ()
    forall a. NFData a => a -> ()
    rnf IfaceFamTyConFlav
    f5 () -> () -> ()
    `seq` Injectivity
    f6 Injectivity -> () -> ()
    `seq` ()

        IfaceClass IfExtName
    f1 [Role]
    f2 [IfaceTyConBinder]
    f3 [FunDep IfLclName]
    f4 IfaceClassBody
    f5 ->
          IfExtName -> ()
    forall a. NFData a => a -> ()
    rnf IfExtName
    f1 () -> () -> ()
    `seq` [Role]
    f2 [Role] -> () -> ()
    `seq` [IfaceTyConBinder] -> Any -> Any
    forall a b. [a] -> b -> b
    seqList [IfaceTyConBinder]
    f3 (Any -> Any) -> () -> ()
    `seq` [FunDep IfLclName] -> ()
    forall a. NFData a => a -> ()
    rnf [FunDep IfLclName]
    f4 () -> () -> ()
    `seq` IfaceClassBody -> ()
    forall a. NFData a => a -> ()
    rnf IfaceClassBody
    f5

        IfaceAxiom IfExtName
    nm IfaceTyCon
    tycon Role
    role [IfaceAxBranch]
    ax ->
          IfExtName -> ()
    forall a. NFData a => a -> ()
    rnf IfExtName
    nm () -> () -> ()
    `seq`
          IfaceTyCon -> ()
    forall a. NFData a => a -> ()
    rnf IfaceTyCon
    tycon () -> () -> ()
    `seq`
          Role
    role Role -> () -> ()
    `seq`
          [IfaceAxBranch] -> ()
    forall a. NFData a => a -> ()
    rnf [IfaceAxBranch]
    ax

        IfacePatSyn IfExtName
    f1 Bool
    f2 (IfExtName, Bool)
    f3 Maybe (IfExtName, Bool)
    f4 [IfaceForAllSpecBndr]
    f5 [IfaceForAllSpecBndr]
    f6 IfaceContext
    f7 IfaceContext
    f8 IfaceContext
    f9 IfaceType
    f10 [FieldLabel]
    f11 ->
          IfExtName -> ()
    forall a. NFData a => a -> ()
    rnf IfExtName
    f1 () -> () -> ()
    `seq` Bool -> ()
    forall a. NFData a => a -> ()
    rnf Bool
    f2 () -> () -> ()
    `seq` (IfExtName, Bool) -> ()
    forall a. NFData a => a -> ()
    rnf (IfExtName, Bool)
    f3 () -> () -> ()
    `seq` Maybe (IfExtName, Bool) -> ()
    forall a. NFData a => a -> ()
    rnf Maybe (IfExtName, Bool)
    f4 () -> () -> ()
    `seq` [IfaceForAllSpecBndr]
    f5 [IfaceForAllSpecBndr] -> () -> ()
    `seq` [IfaceForAllSpecBndr]
    f6 [IfaceForAllSpecBndr] -> () -> ()
    `seq`
          IfaceContext -> ()
    forall a. NFData a => a -> ()
    rnf IfaceContext
    f7 () -> () -> ()
    `seq` IfaceContext -> ()
    forall a. NFData a => a -> ()
    rnf IfaceContext
    f8 () -> () -> ()
    `seq` IfaceContext -> ()
    forall a. NFData a => a -> ()
    rnf IfaceContext
    f9 () -> () -> ()
    `seq` IfaceType -> ()
    forall a. NFData a => a -> ()
    rnf IfaceType
    f10 () -> () -> ()
    `seq` [FieldLabel]
    f11 [FieldLabel] -> () -> ()
    `seq` ()

    instance NFData IfaceAxBranch where
      rnf :: IfaceAxBranch -> ()
    rnf (IfaceAxBranch [IfaceTvBndr]
    f1 [IfaceTvBndr]
    f2 [IfaceIdBndr]
    f3 IfaceAppArgs
    f4 [Role]
    f5 IfaceType
    f6 [Int]
    f7) =
        [IfaceTvBndr] -> ()
    forall a. NFData a => a -> ()
    rnf [IfaceTvBndr]
    f1 () -> () -> ()
    `seq` [IfaceTvBndr] -> ()
    forall a. NFData a => a -> ()
    rnf [IfaceTvBndr]
    f2 () -> () -> ()
    `seq` [IfaceIdBndr] -> ()
    forall a. NFData a => a -> ()
    rnf [IfaceIdBndr]
    f3 () -> () -> ()
    `seq` IfaceAppArgs -> ()
    forall a. NFData a => a -> ()
    rnf IfaceAppArgs
    f4 () -> () -> ()
    `seq` [Role]
    f5 [Role] -> () -> ()
    `seq` IfaceType -> ()
    forall a. NFData a => a -> ()
    rnf IfaceType
    f6 () -> () -> ()
    `seq` [Int] -> ()
    forall a. NFData a => a -> ()
    rnf [Int]
    f7

    instance NFData IfaceClassBody where
      rnf :: IfaceClassBody -> ()
    rnf = \case
        IfaceClassBody
    IfAbstractClass -> ()
        IfConcreteClass IfaceContext
    f1 [IfaceAT]
    f2 [IfaceClassOp]
    f3 BooleanFormula IfLclName
    f4 -> IfaceContext -> ()
    forall a. NFData a => a -> ()
    rnf IfaceContext
    f1 () -> () -> ()
    `seq` [IfaceAT] -> ()
    forall a. NFData a => a -> ()
    rnf [IfaceAT]
    f2 () -> () -> ()
    `seq` [IfaceClassOp] -> ()
    forall a. NFData a => a -> ()
    rnf [IfaceClassOp]
    f3 () -> () -> ()
    `seq` BooleanFormula IfLclName
    f4 BooleanFormula IfLclName -> () -> ()
    `seq` ()

    instance NFData IfaceAT where
      rnf :: IfaceAT -> ()
    rnf (IfaceAT IfaceDecl
    f1 Maybe IfaceType
    f2) = IfaceDecl -> ()
    forall a. NFData a => a -> ()
    rnf IfaceDecl
    f1 () -> () -> ()
    `seq` Maybe IfaceType -> ()
    forall a. NFData a => a -> ()
    rnf Maybe IfaceType
    f2

    instance NFData IfaceClassOp where
      rnf :: IfaceClassOp -> ()
    rnf (IfaceClassOp IfExtName
    f1 IfaceType
    f2 Maybe (DefMethSpec IfaceType)
    f3) = IfExtName -> ()
    forall a. NFData a => a -> ()
    rnf IfExtName
    f1 () -> () -> ()
    `seq` IfaceType -> ()
    forall a. NFData a => a -> ()
    rnf IfaceType
    f2 () -> () -> ()
    `seq` Maybe (DefMethSpec IfaceType)
    f3 Maybe (DefMethSpec IfaceType) -> () -> ()
    `seq` ()

    instance NFData IfaceTyConParent where
      rnf :: IfaceTyConParent -> ()
    rnf = \case
        IfaceTyConParent
    IfNoParent -> ()
        IfDataInstance IfExtName
    f1 IfaceTyCon
    f2 IfaceAppArgs
    f3 -> IfExtName -> ()
    forall a. NFData a => a -> ()
    rnf IfExtName
    f1 () -> () -> ()
    `seq` IfaceTyCon -> ()
    forall a. NFData a => a -> ()
    rnf IfaceTyCon
    f2 () -> () -> ()
    `seq` IfaceAppArgs -> ()
    forall a. NFData a => a -> ()
    rnf IfaceAppArgs
    f3

    instance NFData IfaceConDecls where
      rnf :: IfaceConDecls -> ()
    rnf = \case
        IfaceConDecls
    IfAbstractTyCon -> ()
        IfDataTyCon [IfaceConDecl]
    f1 -> [IfaceConDecl] -> ()
    forall a. NFData a => a -> ()
    rnf [IfaceConDecl]
    f1
        IfNewTyCon IfaceConDecl
    f1 -> IfaceConDecl -> ()
    forall a. NFData a => a -> ()
    rnf IfaceConDecl
    f1

    instance NFData IfaceConDecl where
      rnf :: IfaceConDecl -> ()
    rnf (IfCon IfExtName
    f1 Bool
    f2 Bool
    f3 [IfaceBndr]
    f4 [IfaceForAllSpecBndr]
    f5 [IfaceTvBndr]
    f6 IfaceContext
    f7 [(IfaceType, IfaceType)]
    f8 [FieldLabel]
    f9 [IfaceBang]
    f10 [IfaceSrcBang]
    f11) =
        IfExtName -> ()
    forall a. NFData a => a -> ()
    rnf IfExtName
    f1 () -> () -> ()
    `seq` Bool -> ()
    forall a. NFData a => a -> ()
    rnf Bool
    f2 () -> () -> ()
    `seq` Bool -> ()
    forall a. NFData a => a -> ()
    rnf Bool
    f3 () -> () -> ()
    `seq` [IfaceBndr] -> ()
    forall a. NFData a => a -> ()
    rnf [IfaceBndr]
    f4 () -> () -> ()
    `seq` [IfaceForAllSpecBndr]
    f5 [IfaceForAllSpecBndr] -> () -> ()
    `seq` [IfaceTvBndr] -> ()
    forall a. NFData a => a -> ()
    rnf [IfaceTvBndr]
    f6 () -> () -> ()
    `seq`
        IfaceContext -> ()
    forall a. NFData a => a -> ()
    rnf IfaceContext
    f7 () -> () -> ()
    `seq` [(IfaceType, IfaceType)] -> ()
    forall a. NFData a => a -> ()
    rnf [(IfaceType, IfaceType)]
    f8 () -> () -> ()
    `seq` [FieldLabel]
    f9 [FieldLabel] -> () -> ()
    `seq` [IfaceBang] -> ()
    forall a. NFData a => a -> ()
    rnf [IfaceBang]
    f10 () -> () -> ()
    `seq` [IfaceSrcBang] -> ()
    forall a. NFData a => a -> ()
    rnf [IfaceSrcBang]
    f11

    instance NFData IfaceSrcBang where
      rnf :: IfaceSrcBang -> ()
    rnf (IfSrcBang SrcUnpackedness
    f1 SrcStrictness
    f2) = SrcUnpackedness
    f1 SrcUnpackedness -> () -> ()
    `seq` SrcStrictness
    f2 SrcStrictness -> () -> ()
    `seq` ()

    instance NFData IfaceBang where
      rnf :: IfaceBang -> ()
    rnf IfaceBang
    x = IfaceBang
    x IfaceBang -> () -> ()
    `seq` ()

    instance NFData IfaceIdDetails where
      rnf :: IfaceIdDetails -> ()
    rnf = \case
        IfaceIdDetails
    IfVanillaId -> ()
        IfRecSelId (Left IfaceTyCon
    tycon) Bool
    b -> IfaceTyCon -> ()
    forall a. NFData a => a -> ()
    rnf IfaceTyCon
    tycon () -> () -> ()
    `seq` Bool -> ()
    forall a. NFData a => a -> ()
    rnf Bool
    b
        IfRecSelId (Right IfaceDecl
    decl) Bool
    b -> IfaceDecl -> ()
    forall a. NFData a => a -> ()
    rnf IfaceDecl
    decl () -> () -> ()
    `seq` Bool -> ()
    forall a. NFData a => a -> ()
    rnf Bool
    b
        IfaceIdDetails
    IfDFunId -> ()

    instance NFData IfaceInfoItem where
      rnf :: IfaceInfoItem -> ()
    rnf = \case
        HsArity Int
    a -> Int -> ()
    forall a. NFData a => a -> ()
    rnf Int
    a
        HsStrictness StrictSig
    str -> StrictSig -> ()
    seqStrictSig StrictSig
    str
        HsInline InlinePragma
    p -> InlinePragma
    p InlinePragma -> () -> ()
    `seq` () -- TODO: seq further?
        HsUnfold Bool
    b IfaceUnfolding
    unf -> Bool -> ()
    forall a. NFData a => a -> ()
    rnf Bool
    b () -> () -> ()
    `seq` IfaceUnfolding -> ()
    forall a. NFData a => a -> ()
    rnf IfaceUnfolding
    unf
        IfaceInfoItem
    HsNoCafRefs -> ()
        IfaceInfoItem
    HsLevity -> ()
        HsCpr CprSig
    cpr -> CprSig
    cpr CprSig -> () -> ()
    `seq` ()
        HsLFInfo IfaceLFInfo
    lf_info -> IfaceLFInfo
    lf_info IfaceLFInfo -> () -> ()
    `seq` () -- TODO: seq further?

    instance NFData IfaceUnfolding where
      rnf :: IfaceUnfolding -> ()
    rnf = \case
        IfCoreUnfold Bool
    inlinable IfaceExpr
    expr ->
          Bool -> ()
    forall a. NFData a => a -> ()
    rnf Bool
    inlinable () -> () -> ()
    `seq` IfaceExpr -> ()
    forall a. NFData a => a -> ()
    rnf IfaceExpr
    expr
        IfCompulsory IfaceExpr
    expr ->
          IfaceExpr -> ()
    forall a. NFData a => a -> ()
    rnf IfaceExpr
    expr
        IfInlineRule Int
    arity Bool
    b1 Bool
    b2 IfaceExpr
    e ->
          Int -> ()
    forall a. NFData a => a -> ()
    rnf Int
    arity () -> () -> ()
    `seq` Bool -> ()
    forall a. NFData a => a -> ()
    rnf Bool
    b1 () -> () -> ()
    `seq` Bool -> ()
    forall a. NFData a => a -> ()
    rnf Bool
    b2 () -> () -> ()
    `seq` IfaceExpr -> ()
    forall a. NFData a => a -> ()
    rnf IfaceExpr
    e
        IfDFunUnfold [IfaceBndr]
    bndrs [IfaceExpr]
    exprs ->
          [IfaceBndr] -> ()
    forall a. NFData a => a -> ()
    rnf [IfaceBndr]
    bndrs () -> () -> ()
    `seq` [IfaceExpr] -> ()
    forall a. NFData a => a -> ()
    rnf [IfaceExpr]
    exprs

    instance NFData IfaceExpr where
      rnf :: IfaceExpr -> ()
    rnf = \case
        IfaceLcl IfLclName
    nm -> IfLclName -> ()
    forall a. NFData a => a -> ()
    rnf IfLclName
    nm
        IfaceExt IfExtName
    nm -> IfExtName -> ()
    forall a. NFData a => a -> ()
    rnf IfExtName
    nm
        IfaceType IfaceType
    ty -> IfaceType -> ()
    forall a. NFData a => a -> ()
    rnf IfaceType
    ty
        IfaceCo IfaceCoercion
    co -> IfaceCoercion -> ()
    forall a. NFData a => a -> ()
    rnf IfaceCoercion
    co
        IfaceTuple TupleSort
    sort [IfaceExpr]
    exprs -> TupleSort
    sort TupleSort -> () -> ()
    `seq` [IfaceExpr] -> ()
    forall a. NFData a => a -> ()
    rnf [IfaceExpr]
    exprs
        IfaceLam IfaceLamBndr
    bndr IfaceExpr
    expr -> IfaceLamBndr -> ()
    forall a. NFData a => a -> ()
    rnf IfaceLamBndr
    bndr () -> () -> ()
    `seq` IfaceExpr -> ()
    forall a. NFData a => a -> ()
    rnf IfaceExpr
    expr
        IfaceApp IfaceExpr
    e1 IfaceExpr
    e2 -> IfaceExpr -> ()
    forall a. NFData a => a -> ()
    rnf IfaceExpr
    e1 () -> () -> ()
    `seq` IfaceExpr -> ()
    forall a. NFData a => a -> ()
    rnf IfaceExpr
    e2
        IfaceCase IfaceExpr
    e IfLclName
    nm [IfaceAlt]
    alts -> IfaceExpr -> ()
    forall a. NFData a => a -> ()
    rnf IfaceExpr
    e () -> () -> ()
    `seq` IfLclName
    nm IfLclName -> () -> ()
    `seq` [IfaceAlt] -> ()
    forall a. NFData a => a -> ()
    rnf [IfaceAlt]
    alts
        IfaceECase IfaceExpr
    e IfaceType
    ty -> IfaceExpr -> ()
    forall a. NFData a => a -> ()
    rnf IfaceExpr
    e () -> () -> ()
    `seq` IfaceType -> ()
    forall a. NFData a => a -> ()
    rnf IfaceType
    ty
        IfaceLet IfaceBinding
    bind IfaceExpr
    e -> IfaceBinding -> ()
    forall a. NFData a => a -> ()
    rnf IfaceBinding
    bind () -> () -> ()
    `seq` IfaceExpr -> ()
    forall a. NFData a => a -> ()
    rnf IfaceExpr
    e
        IfaceCast IfaceExpr
    e IfaceCoercion
    co -> IfaceExpr -> ()
    forall a. NFData a => a -> ()
    rnf IfaceExpr
    e () -> () -> ()
    `seq` IfaceCoercion -> ()
    forall a. NFData a => a -> ()
    rnf IfaceCoercion
    co
        IfaceLit Literal
    l -> Literal
    l Literal -> () -> ()
    `seq` () -- FIXME
        IfaceFCall ForeignCall
    fc IfaceType
    ty -> ForeignCall
    fc ForeignCall -> () -> ()
    `seq` IfaceType -> ()
    forall a. NFData a => a -> ()
    rnf IfaceType
    ty
        IfaceTick IfaceTickish
    tick IfaceExpr
    e -> IfaceTickish -> ()
    forall a. NFData a => a -> ()
    rnf IfaceTickish
    tick () -> () -> ()
    `seq` IfaceExpr -> ()
    forall a. NFData a => a -> ()
    rnf IfaceExpr
    e

    instance NFData IfaceAlt where
      rnf :: IfaceAlt -> ()
    rnf (IfaceAlt IfaceConAlt
    con [IfLclName]
    bndrs IfaceExpr
    rhs) = IfaceConAlt -> ()
    forall a. NFData a => a -> ()
    rnf IfaceConAlt
    con () -> () -> ()
    `seq` [IfLclName] -> ()
    forall a. NFData a => a -> ()
    rnf [IfLclName]
    bndrs () -> () -> ()
    `seq` IfaceExpr -> ()
    forall a. NFData a => a -> ()
    rnf IfaceExpr
    rhs

    instance NFData IfaceBinding where
      rnf :: IfaceBinding -> ()
    rnf = \case
        IfaceNonRec IfaceLetBndr
    bndr IfaceExpr
    e -> IfaceLetBndr -> ()
    forall a. NFData a => a -> ()
    rnf IfaceLetBndr
    bndr () -> () -> ()
    `seq` IfaceExpr -> ()
    forall a. NFData a => a -> ()
    rnf IfaceExpr
    e
        IfaceRec [(IfaceLetBndr, IfaceExpr)]
    binds -> [(IfaceLetBndr, IfaceExpr)] -> ()
    forall a. NFData a => a -> ()
    rnf [(IfaceLetBndr, IfaceExpr)]
    binds

    instance NFData IfaceLetBndr where
      rnf :: IfaceLetBndr -> ()
    rnf (IfLetBndr IfLclName
    nm IfaceType
    ty IfaceIdInfo
    id_info IfaceJoinInfo
    join_info) =
        IfLclName -> ()
    forall a. NFData a => a -> ()
    rnf IfLclName
    nm () -> () -> ()
    `seq` IfaceType -> ()
    forall a. NFData a => a -> ()
    rnf IfaceType
    ty () -> () -> ()
    `seq` IfaceIdInfo -> ()
    forall a. NFData a => a -> ()
    rnf IfaceIdInfo
    id_info () -> () -> ()
    `seq` IfaceJoinInfo -> ()
    forall a. NFData a => a -> ()
    rnf IfaceJoinInfo
    join_info

    instance NFData IfaceFamTyConFlav where
      rnf :: IfaceFamTyConFlav -> ()
    rnf = \case
        IfaceFamTyConFlav
    IfaceDataFamilyTyCon -> ()
        IfaceFamTyConFlav
    IfaceOpenSynFamilyTyCon -> ()
        IfaceClosedSynFamilyTyCon Maybe (IfExtName, [IfaceAxBranch])
    f1 -> Maybe (IfExtName, [IfaceAxBranch]) -> ()
    forall a. NFData a => a -> ()
    rnf Maybe (IfExtName, [IfaceAxBranch])
    f1
        IfaceFamTyConFlav
    IfaceAbstractClosedSynFamilyTyCon -> ()
        IfaceFamTyConFlav
    IfaceBuiltInSynFamTyCon -> ()

    instance NFData IfaceJoinInfo where
      rnf :: IfaceJoinInfo -> ()
    rnf IfaceJoinInfo
    x = IfaceJoinInfo
    x IfaceJoinInfo -> () -> ()
    `seq` ()

    instance NFData IfaceTickish where
      rnf :: IfaceTickish -> ()
    rnf = \case
        IfaceHpcTick Module
    m Int
    i -> Module -> ()
    forall a. NFData a => a -> ()
    rnf Module
    m () -> () -> ()
    `seq` Int -> ()
    forall a. NFData a => a -> ()
    rnf Int
    i
        IfaceSCC CostCentre
    cc Bool
    b1 Bool
    b2 -> CostCentre
    cc CostCentre -> () -> ()
    `seq` Bool -> ()
    forall a. NFData a => a -> ()
    rnf Bool
    b1 () -> () -> ()
    `seq` Bool -> ()
    forall a. NFData a => a -> ()
    rnf Bool
    b2
        IfaceSource RealSrcSpan
    src String
    str -> RealSrcSpan
    src RealSrcSpan -> () -> ()
    `seq` String -> ()
    forall a. NFData a => a -> ()
    rnf String
    str

    instance NFData IfaceConAlt where
      rnf :: IfaceConAlt -> ()
    rnf = \case
        IfaceConAlt
    IfaceDefault -> ()
        IfaceDataAlt IfExtName
    nm -> IfExtName -> ()
    forall a. NFData a => a -> ()
    rnf IfExtName
    nm
        IfaceLitAlt Literal
    lit -> Literal
    lit Literal -> () -> ()
    `seq` ()

    instance NFData IfaceCompleteMatch where
      rnf :: IfaceCompleteMatch -> ()
    rnf (IfaceCompleteMatch [IfExtName]
    f1 Maybe IfaceTyCon
    mtc) = [IfExtName] -> ()
    forall a. NFData a => a -> ()
    rnf [IfExtName]
    f1 () -> () -> ()
    `seq` Maybe IfaceTyCon -> ()
    forall a. NFData a => a -> ()
    rnf Maybe IfaceTyCon
    mtc

    instance NFData IfaceRule where
      rnf :: IfaceRule -> ()
    rnf (IfaceRule IfLclName
    f1 Activation
    f2 [IfaceBndr]
    f3 IfExtName
    f4 [IfaceExpr]
    f5 IfaceExpr
    f6 Bool
    f7 IsOrphan
    f8) =
        IfLclName -> ()
    forall a. NFData a => a -> ()
    rnf IfLclName
    f1 () -> () -> ()
    `seq` Activation
    f2 Activation -> () -> ()
    `seq` [IfaceBndr] -> ()
    forall a. NFData a => a -> ()
    rnf [IfaceBndr]
    f3 () -> () -> ()
    `seq` IfExtName -> ()
    forall a. NFData a => a -> ()
    rnf IfExtName
    f4 () -> () -> ()
    `seq` [IfaceExpr] -> ()
    forall a. NFData a => a -> ()
    rnf [IfaceExpr]
    f5 () -> () -> ()
    `seq` IfaceExpr -> ()
    forall a. NFData a => a -> ()
    rnf IfaceExpr
    f6 () -> () -> ()
    `seq` Bool -> ()
    forall a. NFData a => a -> ()
    rnf Bool
    f7 () -> () -> ()
    `seq` IsOrphan
    f8 IsOrphan -> () -> ()
    `seq` ()

    instance NFData IfaceFamInst where
      rnf :: IfaceFamInst -> ()
    rnf (IfaceFamInst IfExtName
    f1 [Maybe IfaceTyCon]
    f2 IfExtName
    f3 IsOrphan
    f4) =
        IfExtName -> ()
    forall a. NFData a => a -> ()
    rnf IfExtName
    f1 () -> () -> ()
    `seq` [Maybe IfaceTyCon] -> ()
    forall a. NFData a => a -> ()
    rnf [Maybe IfaceTyCon]
    f2 () -> () -> ()
    `seq` IfExtName -> ()
    forall a. NFData a => a -> ()
    rnf IfExtName
    f3 () -> () -> ()
    `seq` IsOrphan
    f4 IsOrphan -> () -> ()
    `seq` ()

    instance NFData IfaceClsInst where
      rnf :: IfaceClsInst -> ()
    rnf (IfaceClsInst IfExtName
    f1 [Maybe IfaceTyCon]
    f2 IfExtName
    f3 OverlapFlag
    f4 IsOrphan
    f5) =
        IfExtName
    f1 IfExtName -> () -> ()
    `seq` [Maybe IfaceTyCon] -> ()
    forall a. NFData a => a -> ()
    rnf [Maybe IfaceTyCon]
    f2 () -> () -> ()
    `seq` IfExtName -> ()
    forall a. NFData a => a -> ()
    rnf IfExtName
    f3 () -> () -> ()
    `seq` OverlapFlag
    f4 OverlapFlag -> () -> ()
    `seq` IsOrphan
    f5 IsOrphan -> () -> ()
    `seq` ()

    instance NFData IfaceAnnotation where
      rnf :: IfaceAnnotation -> ()
    rnf (IfaceAnnotation IfaceAnnTarget
    f1 AnnPayload
    f2) = IfaceAnnTarget
    f1 IfaceAnnTarget -> () -> ()
    `seq` AnnPayload
    f2 AnnPayload -> () -> ()
    `seq` ()